Merge branch 'topic/cvt-dev-prints' into for-next

This merges the bunch of changes over pci and usb sound drivers to
convert to dev_err() and co.

107 files changed, 2520 insertions, 2117 deletions

diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
index bf578ba2677e..14ad54b7928c 100644
--- a/sound/pci/ac97/ac97_codec.c
+++ b/sound/pci/ac97/ac97_codec.c
@@ -214,6 +214,12 @@ static void update_power_regs(struct snd_ac97 *ac97);
 #define ac97_is_power_save_mode(ac97) 0
 #endif
 
+#define ac97_err(ac97, fmt, args...)    \
+        dev_err((ac97)->bus->card->dev, fmt, ##args)
+#define ac97_warn(ac97, fmt, args...)   \
+        dev_warn((ac97)->bus->card->dev, fmt, ##args)
+#define ac97_dbg(ac97, fmt, args...)    \
+        dev_dbg((ac97)->bus->card->dev, fmt, ##args)
 
 /*
  *  I/O routines
@@ -1673,7 +1679,7 @@ static int snd_ac97_modem_build(struct snd_card *card, struct snd_ac97 * ac97)
         int err, idx;
 
         /*
-        printk(KERN_DEBUG "AC97_GPIO_CFG = %x\n",
+        ac97_dbg(ac97, "AC97_GPIO_CFG = %x\n",
                snd_ac97_read(ac97,AC97_GPIO_CFG));
         */
         snd_ac97_write(ac97, AC97_GPIO_CFG, 0xffff & ~(AC97_GPIO_LINE1_OH));
@@ -1963,7 +1969,7 @@ static int snd_ac97_dev_register(struct snd_device *device)
                      ac97->bus->card->number, ac97->num,
                      snd_ac97_get_short_name(ac97));
         if ((err = device_register(&ac97->dev)) < 0) {
-                snd_printk(KERN_ERR "Can't register ac97 bus\n");
+                ac97_err(ac97, "Can't register ac97 bus\n");
                 ac97->dev.bus = NULL;
                 return err;
         }
@@ -2089,7 +2095,8 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
                                                       msecs_to_jiffies(500), 1);
                 }
                 if (err < 0) {
-                        snd_printk(KERN_WARNING "AC'97 %d does not respond - RESET\n", ac97->num);
+                        ac97_warn(ac97, "AC'97 %d does not respond - RESET\n",
+                                 ac97->num);
                         /* proceed anyway - it's often non-critical */
                 }
         }
@@ -2098,7 +2105,9 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
         ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
         if (! (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) &&
             (ac97->id == 0x00000000 || ac97->id == 0xffffffff)) {
-                snd_printk(KERN_ERR "AC'97 %d access is not valid [0x%x], removing mixer.\n", ac97->num, ac97->id);
+                ac97_err(ac97,
+                         "AC'97 %d access is not valid [0x%x], removing mixer.\n",
+                         ac97->num, ac97->id);
                 snd_ac97_free(ac97);
                 return -EIO;
         }
@@ -2131,7 +2140,9 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
 
         if (!ac97_is_audio(ac97) && !ac97_is_modem(ac97)) {
                 if (!(ac97->scaps & (AC97_SCAP_SKIP_AUDIO|AC97_SCAP_SKIP_MODEM)))
-                        snd_printk(KERN_ERR "AC'97 %d access error (not audio or modem codec)\n", ac97->num);
+                        ac97_err(ac97,
+                                 "AC'97 %d access error (not audio or modem codec)\n",
+                                 ac97->num);
                 snd_ac97_free(ac97);
                 return -EACCES;
         }
@@ -2156,7 +2167,8 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
                                 goto __ready_ok;
                         schedule_timeout_uninterruptible(1);
                 } while (time_after_eq(end_time, jiffies));
-                snd_printk(KERN_WARNING "AC'97 %d analog subsections not ready\n", ac97->num);
+                ac97_warn(ac97,
+                          "AC'97 %d analog subsections not ready\n", ac97->num);
         }
 
         /* FIXME: add powerdown control */
@@ -2188,7 +2200,10 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
                                 goto __ready_ok;
                         schedule_timeout_uninterruptible(1);
                 } while (time_after_eq(end_time, jiffies));
-                snd_printk(KERN_WARNING "MC'97 %d converters and GPIO not ready (0x%x)\n", ac97->num, snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS));
+                ac97_warn(ac97,
+                          "MC'97 %d converters and GPIO not ready (0x%x)\n",
+                          ac97->num,
+                          snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS));
         }
         
       __ready_ok:
@@ -2723,7 +2738,7 @@ static int tune_ad_sharing(struct snd_ac97 *ac97)
 {
         unsigned short scfg;
         if ((ac97->id & 0xffffff00) != 0x41445300) {
-                snd_printk(KERN_ERR "ac97_quirk AD_SHARING is only for AD codecs\n");
+                ac97_err(ac97, "ac97_quirk AD_SHARING is only for AD codecs\n");
                 return -EINVAL;
         }
         /* Turn on OMS bit to route microphone to back panel */
@@ -2739,7 +2754,8 @@ AC97_SINGLE("Jack Detect", AC97_ALC650_CLOCK, 5, 1, 0);
 static int tune_alc_jack(struct snd_ac97 *ac97)
 {
         if ((ac97->id & 0xffffff00) != 0x414c4700) {
-                snd_printk(KERN_ERR "ac97_quirk ALC_JACK is only for Realtek codecs\n");
+                ac97_err(ac97,
+                         "ac97_quirk ALC_JACK is only for Realtek codecs\n");
                 return -EINVAL;
         }
         snd_ac97_update_bits(ac97, 0x7a, 0x20, 0x20); /* select jack detect function */
@@ -2899,7 +2915,8 @@ int snd_ac97_tune_hardware(struct snd_ac97 *ac97, struct ac97_quirk *quirk, cons
         if (override && strcmp(override, "-1") && strcmp(override, "default")) {
                 result = apply_quirk_str(ac97, override);
                 if (result < 0)
-                        snd_printk(KERN_ERR "applying quirk type %s failed (%d)\n", override, result);
+                        ac97_err(ac97, "applying quirk type %s failed (%d)\n",
+                                 override, result);
                 return result;
         }
 
@@ -2913,10 +2930,14 @@ int snd_ac97_tune_hardware(struct snd_ac97 *ac97, struct ac97_quirk *quirk, cons
                     quirk->subdevice == (quirk->mask & ac97->subsystem_device)) {
                         if (quirk->codec_id && quirk->codec_id != ac97->id)
                                 continue;
-                        snd_printdd("ac97 quirk for %s (%04x:%04x)\n", quirk->name, ac97->subsystem_vendor, ac97->subsystem_device);
+                        ac97_dbg(ac97, "ac97 quirk for %s (%04x:%04x)\n",
+                                 quirk->name, ac97->subsystem_vendor,
+                                 ac97->subsystem_device);
                         result = apply_quirk(ac97, quirk->type);
                         if (result < 0)
-                                snd_printk(KERN_ERR "applying quirk type %d for %s failed (%d)\n", quirk->type, quirk->name, result);
+                                ac97_err(ac97,
+                                         "applying quirk type %d for %s failed (%d)\n",
+                                         quirk->type, quirk->name, result);
                         return result;
                 }
         }
diff --git a/sound/pci/ac97/ac97_patch.c b/sound/pci/ac97/ac97_patch.c
index 66a3bc95fb84..991762215417 100644
--- a/sound/pci/ac97/ac97_patch.c
+++ b/sound/pci/ac97/ac97_patch.c
@@ -3477,7 +3477,8 @@ static int snd_ac97_add_vmaster(struct snd_ac97 *ac97, char *name,
 
                 sctl = snd_ac97_find_mixer_ctl(ac97, *s);
                 if (!sctl) {
-                        snd_printdd("Cannot find slave %s, skipped\n", *s);
+                        dev_dbg(ac97->bus->card->dev,
+                                "Cannot find slave %s, skipped\n", *s);
                         continue;
                 }
                 err = snd_ctl_add_slave(kctl, sctl);
diff --git a/sound/pci/ac97/ac97_pcm.c b/sound/pci/ac97/ac97_pcm.c
index eab0fc9ff2e0..d15297a68801 100644
--- a/sound/pci/ac97/ac97_pcm.c
+++ b/sound/pci/ac97/ac97_pcm.c
@@ -604,7 +604,9 @@ int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate,
                 }
                 if (!ok_flag) {
                         spin_unlock_irq(&pcm->bus->bus_lock);
-                        snd_printk(KERN_ERR "cannot find configuration for AC97 slot %i\n", i);
+                        dev_err(bus->card->dev,
+                                "cannot find configuration for AC97 slot %i\n",
+                                i);
                         err = -EAGAIN;
                         goto error;
                 }
@@ -618,15 +620,20 @@ int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate,
                         if (pcm->r[r].rslots[cidx] & (1 << i)) {
                                 reg = get_slot_reg(pcm, cidx, i, r);
                                 if (reg == 0xff) {
-                                        snd_printk(KERN_ERR "invalid AC97 slot %i?\n", i);
+                                        dev_err(bus->card->dev,
+                                                "invalid AC97 slot %i?\n", i);
                                         continue;
                                 }
                                 if (reg_ok[cidx] & (1 << (reg - AC97_PCM_FRONT_DAC_RATE)))
                                         continue;
-                                //printk(KERN_DEBUG "setting ac97 reg 0x%x to rate %d\n", reg, rate);
+                                dev_dbg(bus->card->dev,
+                                        "setting ac97 reg 0x%x to rate %d\n",
+                                        reg, rate);
                                 err = snd_ac97_set_rate(pcm->r[r].codec[cidx], reg, rate);
                                 if (err < 0)
-                                        snd_printk(KERN_ERR "error in snd_ac97_set_rate: cidx=%d, reg=0x%x, rate=%d, err=%d\n", cidx, reg, rate, err);
+                                        dev_err(bus->card->dev,
+                                                "error in snd_ac97_set_rate: cidx=%d, reg=0x%x, rate=%d, err=%d\n",
+                                                cidx, reg, rate, err);
                                 else
                                         reg_ok[cidx] |= (1 << (reg - AC97_PCM_FRONT_DAC_RATE));
                         }
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index ba4da1ed0444..488f966adde3 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -77,9 +77,6 @@ MODULE_PARM_DESC(ac97_quirk, "AC'97 workaround for strange hardware.");
 #define DEVNAME "ad1889"
 #define PFX     DEVNAME ": "
 
-/* let's use the global sound debug interfaces */
-#define ad1889_debug(fmt, arg...) snd_printd(KERN_DEBUG fmt, ## arg)
-
 /* keep track of some hw registers */
 struct ad1889_register_state {
         u16 reg;        /* reg setup */
@@ -264,11 +261,11 @@ snd_ad1889_ac97_ready(struct snd_ad1889 *chip)
                         && --retry)
                 mdelay(1);
         if (!retry) {
-                snd_printk(KERN_ERR PFX "[%s] Link is not ready.\n",
-                       __func__);
+                dev_err(chip->card->dev, "[%s] Link is not ready.\n",
+                        __func__);
                 return -EIO;
         }
-        ad1889_debug("[%s] ready after %d ms\n", __func__, 400 - retry);
+        dev_dbg(chip->card->dev, "[%s] ready after %d ms\n", __func__, 400 - retry);
 
         return 0;
 }
@@ -405,9 +402,9 @@ snd_ad1889_playback_prepare(struct snd_pcm_substream *ss)
         
         spin_unlock_irq(&chip->lock);
         
-        ad1889_debug("prepare playback: addr = 0x%x, count = %u, "
-                        "size = %u, reg = 0x%x, rate = %u\n", chip->wave.addr,
-                        count, size, reg, rt->rate);
+        dev_dbg(chip->card->dev,
+                "prepare playback: addr = 0x%x, count = %u, size = %u, reg = 0x%x, rate = %u\n",
+                chip->wave.addr, count, size, reg, rt->rate);
         return 0;
 }
 
@@ -452,9 +449,9 @@ snd_ad1889_capture_prepare(struct snd_pcm_substream *ss)
         
         spin_unlock_irq(&chip->lock);
         
-        ad1889_debug("prepare capture: addr = 0x%x, count = %u, "
-                        "size = %u, reg = 0x%x, rate = %u\n", chip->ramc.addr,
-                        count, size, reg, rt->rate);
+        dev_dbg(chip->card->dev,
+                "prepare capture: addr = 0x%x, count = %u, size = %u, reg = 0x%x, rate = %u\n",
+                chip->ramc.addr, count, size, reg, rt->rate);
         return 0;
 }
 
@@ -614,7 +611,8 @@ snd_ad1889_interrupt(int irq, void *dev_id)
                 return IRQ_NONE;
 
         if (st & (AD_DMA_DISR_PMAI|AD_DMA_DISR_PTAI))
-                ad1889_debug("Unexpected master or target abort interrupt!\n");
+                dev_dbg(chip->card->dev,
+                        "Unexpected master or target abort interrupt!\n");
 
         if ((st & AD_DMA_DISR_WAVI) && chip->psubs)
                 snd_pcm_period_elapsed(chip->psubs);
@@ -656,7 +654,7 @@ snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, struct snd_pcm **rpcm)
                                                 BUFFER_BYTES_MAX);
 
         if (err < 0) {
-                snd_printk(KERN_ERR PFX "buffer allocation error: %d\n", err);
+                dev_err(chip->card->dev, "buffer allocation error: %d\n", err);
                 return err;
         }
         
@@ -912,7 +910,7 @@ snd_ad1889_create(struct snd_card *card,
         /* check PCI availability (32bit DMA) */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
-                printk(KERN_ERR PFX "error setting 32-bit DMA mask.\n");
+                dev_err(card->dev, "error setting 32-bit DMA mask.\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -935,7 +933,7 @@ snd_ad1889_create(struct snd_card *card,
         chip->bar = pci_resource_start(pci, 0);
         chip->iobase = pci_ioremap_bar(pci, 0);
         if (chip->iobase == NULL) {
-                printk(KERN_ERR PFX "unable to reserve region.\n");
+                dev_err(card->dev, "unable to reserve region.\n");
                 err = -EBUSY;
                 goto free_and_ret;
         }
@@ -946,7 +944,7 @@ snd_ad1889_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_ad1889_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
-                printk(KERN_ERR PFX "cannot obtain IRQ %d\n", pci->irq);
+                dev_err(card->dev, "cannot obtain IRQ %d\n", pci->irq);
                 snd_ad1889_free(chip);
                 return -EBUSY;
         }
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index 115b1120319a..feb29c24cab1 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -65,18 +65,6 @@ module_param(enable, bool, 0444);
 
 
 /*
- *  Debug part definitions
- */
-
-/* #define ALI_DEBUG */
-
-#ifdef ALI_DEBUG
-#define snd_ali_printk(format, args...) printk(KERN_DEBUG format, ##args);
-#else
-#define snd_ali_printk(format, args...)
-#endif
-
-/*
  *  Constants definition
  */
 
@@ -321,7 +309,7 @@ static int snd_ali_codec_ready(struct snd_ali *codec,
         }
 
         snd_ali_5451_poke(codec, port, res & ~0x8000);
-        snd_printdd("ali_codec_ready: codec is not ready.\n ");
+        dev_dbg(codec->card->dev, "ali_codec_ready: codec is not ready.\n ");
         return -EIO;
 }
 
@@ -342,7 +330,7 @@ static int snd_ali_stimer_ready(struct snd_ali *codec)
                 schedule_timeout_uninterruptible(1);
         }
 
-        snd_printk(KERN_ERR "ali_stimer_read: stimer is not ready.\n");
+        dev_err(codec->card->dev, "ali_stimer_read: stimer is not ready.\n");
         return -EIO;
 }
 
@@ -354,7 +342,8 @@ static void snd_ali_codec_poke(struct snd_ali *codec,int secondary,
         unsigned int port;
 
         if (reg >= 0x80) {
-                snd_printk(KERN_ERR "ali_codec_poke: reg(%xh) invalid.\n", reg);
+                dev_err(codec->card->dev,
+                        "ali_codec_poke: reg(%xh) invalid.\n", reg);
                 return;
         }
 
@@ -385,7 +374,8 @@ static unsigned short snd_ali_codec_peek(struct snd_ali *codec,
         unsigned int port;
 
         if (reg >= 0x80) {
-                snd_printk(KERN_ERR "ali_codec_peek: reg(%xh) invalid.\n", reg);
+                dev_err(codec->card->dev,
+                        "ali_codec_peek: reg(%xh) invalid.\n", reg);
                 return ~0;
         }
 
@@ -417,7 +407,7 @@ static void snd_ali_codec_write(struct snd_ac97 *ac97,
 {
         struct snd_ali *codec = ac97->private_data;
 
-        snd_ali_printk("codec_write: reg=%xh data=%xh.\n", reg, val);
+        dev_dbg(codec->card->dev, "codec_write: reg=%xh data=%xh.\n", reg, val);
         if (reg == AC97_GPIO_STATUS) {
                 outl((val << ALI_AC97_GPIO_DATA_SHIFT) | ALI_AC97_GPIO_ENABLE,
                      ALI_REG(codec, ALI_AC97_GPIO));
@@ -433,7 +423,7 @@ static unsigned short snd_ali_codec_read(struct snd_ac97 *ac97,
 {
         struct snd_ali *codec = ac97->private_data;
 
-        snd_ali_printk("codec_read reg=%xh.\n", reg);
+        dev_dbg(codec->card->dev, "codec_read reg=%xh.\n", reg);
         return snd_ali_codec_peek(codec, ac97->num, reg);
 }
 
@@ -474,7 +464,7 @@ static int snd_ali_reset_5451(struct snd_ali *codec)
         }
 
         /* non-fatal if you have a non PM capable codec */
-        /* snd_printk(KERN_WARNING "ali5451: reset time out\n"); */
+        /* dev_warn(codec->card->dev, "ali5451: reset time out\n"); */
         return 0;
 }
 
@@ -528,7 +518,7 @@ static void snd_ali_disable_voice_irq(struct snd_ali *codec,
         unsigned int mask;
         struct snd_ali_channel_control *pchregs = &(codec->chregs);
 
-        snd_ali_printk("disable_voice_irq channel=%d\n",channel);
+        dev_dbg(codec->card->dev, "disable_voice_irq channel=%d\n", channel);
 
         mask = 1 << (channel & 0x1f);
         pchregs->data.ainten  = inl(ALI_REG(codec, pchregs->regs.ainten));
@@ -541,7 +531,7 @@ static int snd_ali_alloc_pcm_channel(struct snd_ali *codec, int channel)
         unsigned int idx =  channel & 0x1f;
 
         if (codec->synth.chcnt >= ALI_CHANNELS){
-                snd_printk(KERN_ERR
+                dev_err(codec->card->dev,
                            "ali_alloc_pcm_channel: no free channels.\n");
                 return -1;
         }
@@ -549,7 +539,7 @@ static int snd_ali_alloc_pcm_channel(struct snd_ali *codec, int channel)
         if (!(codec->synth.chmap & (1 << idx))) {
                 codec->synth.chmap |= 1 << idx;
                 codec->synth.chcnt++;
-                snd_ali_printk("alloc_pcm_channel no. %d.\n",idx);
+                dev_dbg(codec->card->dev, "alloc_pcm_channel no. %d.\n", idx);
                 return idx;
         }
         return -1;
@@ -560,7 +550,8 @@ static int snd_ali_find_free_channel(struct snd_ali * codec, int rec)
         int idx;
         int result = -1;
 
-        snd_ali_printk("find_free_channel: for %s\n",rec ? "rec" : "pcm");
+        dev_dbg(codec->card->dev,
+                "find_free_channel: for %s\n", rec ? "rec" : "pcm");
 
         /* recording */
         if (rec) {
@@ -575,8 +566,8 @@ static int snd_ali_find_free_channel(struct snd_ali * codec, int rec)
                 if (result >= 0)
                         return result;
                 else {
-                        snd_printk(KERN_ERR "ali_find_free_channel: "
-                                   "record channel is busy now.\n");
+                        dev_err(codec->card->dev,
+                                "ali_find_free_channel: record channel is busy now.\n");
                         return -1;
                 }
         }
@@ -590,8 +581,8 @@ static int snd_ali_find_free_channel(struct snd_ali * codec, int rec)
                 if (result >= 0)
                         return result;
                 else
-                        snd_printk(KERN_ERR "ali_find_free_channel: "
-                                   "S/PDIF out channel is in busy now.\n");
+                        dev_err(codec->card->dev,
+                                "ali_find_free_channel: S/PDIF out channel is in busy now.\n");
         }
 
         for (idx = 0; idx < ALI_CHANNELS; idx++) {
@@ -599,7 +590,7 @@ static int snd_ali_find_free_channel(struct snd_ali * codec, int rec)
                 if (result >= 0)
                         return result;
         }
-        snd_printk(KERN_ERR "ali_find_free_channel: no free channels.\n");
+        dev_err(codec->card->dev, "ali_find_free_channel: no free channels.\n");
         return -1;
 }
 
@@ -607,14 +598,15 @@ static void snd_ali_free_channel_pcm(struct snd_ali *codec, int channel)
 {
         unsigned int idx = channel & 0x0000001f;
 
-        snd_ali_printk("free_channel_pcm channel=%d\n",channel);
+        dev_dbg(codec->card->dev, "free_channel_pcm channel=%d\n", channel);
 
         if (channel < 0 || channel >= ALI_CHANNELS)
                 return;
 
         if (!(codec->synth.chmap & (1 << idx))) {
-                snd_printk(KERN_ERR "ali_free_channel_pcm: "
-                           "channel %d is not in use.\n", channel);
+                dev_err(codec->card->dev,
+                        "ali_free_channel_pcm: channel %d is not in use.\n",
+                        channel);
                 return;
         } else {
                 codec->synth.chmap &= ~(1 << idx);
@@ -626,7 +618,7 @@ static void snd_ali_stop_voice(struct snd_ali *codec, unsigned int channel)
 {
         unsigned int mask = 1 << (channel & 0x1f);
 
-        snd_ali_printk("stop_voice: channel=%d\n",channel);
+        dev_dbg(codec->card->dev, "stop_voice: channel=%d\n", channel);
         outl(mask, ALI_REG(codec, codec->chregs.regs.stop));
 }
 
@@ -667,7 +659,7 @@ static void snd_ali_detect_spdif_rate(struct snd_ali *codec)
         }
 
         if (count > 50000) {
-                snd_printk(KERN_ERR "ali_detect_spdif_rate: timeout!\n");
+                dev_err(codec->card->dev, "ali_detect_spdif_rate: timeout!\n");
                 return;
         }
 
@@ -682,7 +674,7 @@ static void snd_ali_detect_spdif_rate(struct snd_ali *codec)
         }
 
         if (count > 50000) {
-                snd_printk(KERN_ERR "ali_detect_spdif_rate: timeout!\n");
+                dev_err(codec->card->dev, "ali_detect_spdif_rate: timeout!\n");
                 return;
         }
 
@@ -857,9 +849,6 @@ static void snd_ali_update_ptr(struct snd_ali *codec, int channel)
         struct snd_ali_voice *pvoice;
         struct snd_ali_channel_control *pchregs;
         unsigned int old, mask;
-#ifdef ALI_DEBUG
-        unsigned int temp, cspf;
-#endif
 
         pchregs = &(codec->chregs);
 
@@ -877,14 +866,11 @@ static void snd_ali_update_ptr(struct snd_ali *codec, int channel)
 
         if (pvoice->pcm && pvoice->substream) {
                 /* pcm interrupt */
-#ifdef ALI_DEBUG
-                outb((u8)(pvoice->number), ALI_REG(codec, ALI_GC_CIR));
-                temp = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2));
-                cspf = (inl(ALI_REG(codec, ALI_CSPF)) & mask) == mask;
-#endif
                 if (pvoice->running) {
-                        snd_ali_printk("update_ptr: cso=%4.4x cspf=%d.\n",
-                                       (u16)temp, cspf);
+                        dev_dbg(codec->card->dev,
+                                "update_ptr: cso=%4.4x cspf=%d.\n",
+                                inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2)),
+                                (inl(ALI_REG(codec, ALI_CSPF)) & mask) == mask);
                         spin_unlock(&codec->reg_lock);
                         snd_pcm_period_elapsed(pvoice->substream);
                         spin_lock(&codec->reg_lock);
@@ -940,14 +926,14 @@ static struct snd_ali_voice *snd_ali_alloc_voice(struct snd_ali * codec,
         struct snd_ali_voice *pvoice;
         int idx;
 
-        snd_ali_printk("alloc_voice: type=%d rec=%d\n", type, rec);
+        dev_dbg(codec->card->dev, "alloc_voice: type=%d rec=%d\n", type, rec);
 
         spin_lock_irq(&codec->voice_alloc);
         if (type == SNDRV_ALI_VOICE_TYPE_PCM) {
                 idx = channel > 0 ? snd_ali_alloc_pcm_channel(codec, channel) :
                         snd_ali_find_free_channel(codec,rec);
                 if (idx < 0) {
-                        snd_printk(KERN_ERR "ali_alloc_voice: err.\n");
+                        dev_err(codec->card->dev, "ali_alloc_voice: err.\n");
                         spin_unlock_irq(&codec->voice_alloc);
                         return NULL;
                 }
@@ -970,7 +956,7 @@ static void snd_ali_free_voice(struct snd_ali * codec,
         void (*private_free)(void *);
         void *private_data;
 
-        snd_ali_printk("free_voice: channel=%d\n",pvoice->number);
+        dev_dbg(codec->card->dev, "free_voice: channel=%d\n", pvoice->number);
         if (!pvoice->use)
                 return;
         snd_ali_clear_voices(codec, pvoice->number, pvoice->number);
@@ -1153,7 +1139,7 @@ static int snd_ali_trigger(struct snd_pcm_substream *substream,
         outl(val, ALI_REG(codec, ALI_AINTEN));
         if (do_start)
                 outl(what, ALI_REG(codec, ALI_START));
-        snd_ali_printk("trigger: what=%xh whati=%xh\n", what, whati);
+        dev_dbg(codec->card->dev, "trigger: what=%xh whati=%xh\n", what, whati);
         spin_unlock(&codec->reg_lock);
 
         return 0;
@@ -1239,7 +1225,7 @@ static int snd_ali_playback_prepare(struct snd_pcm_substream *substream)
         unsigned int VOL;
         unsigned int EC;
         
-        snd_ali_printk("playback_prepare ...\n");
+        dev_dbg(codec->card->dev, "playback_prepare ...\n");
 
         spin_lock_irq(&codec->reg_lock);        
         
@@ -1266,7 +1252,7 @@ static int snd_ali_playback_prepare(struct snd_pcm_substream *substream)
         /* set target ESO for channel */
         pvoice->eso = runtime->buffer_size; 
 
-        snd_ali_printk("playback_prepare: eso=%xh count=%xh\n",
+        dev_dbg(codec->card->dev, "playback_prepare: eso=%xh count=%xh\n",
                        pvoice->eso, pvoice->count);
 
         /* set ESO to capture first MIDLP interrupt */
@@ -1278,8 +1264,9 @@ static int snd_ali_playback_prepare(struct snd_pcm_substream *substream)
         PAN = 0;
         VOL = 0;
         EC = 0;
-        snd_ali_printk("playback_prepare:\n");
-        snd_ali_printk("ch=%d, Rate=%d Delta=%xh,GVSEL=%xh,PAN=%xh,CTRL=%xh\n",
+        dev_dbg(codec->card->dev, "playback_prepare:\n");
+        dev_dbg(codec->card->dev,
+                "ch=%d, Rate=%d Delta=%xh,GVSEL=%xh,PAN=%xh,CTRL=%xh\n",
                        pvoice->number,runtime->rate,Delta,GVSEL,PAN,CTRL);
         snd_ali_write_voice_regs(codec,
                                  pvoice->number,
@@ -1332,7 +1319,7 @@ static int snd_ali_prepare(struct snd_pcm_substream *substream)
 
         spin_lock_irq(&codec->reg_lock);
 
-        snd_ali_printk("ali_prepare...\n");
+        dev_dbg(codec->card->dev, "ali_prepare...\n");
 
         snd_ali_enable_special_channel(codec,pvoice->number);
 
@@ -1351,15 +1338,16 @@ static int snd_ali_prepare(struct snd_pcm_substream *substream)
 
                 rate = snd_ali_get_spdif_in_rate(codec);
                 if (rate == 0) {
-                        snd_printk(KERN_WARNING "ali_capture_preapre: "
-                                   "spdif rate detect err!\n");
+                        dev_warn(codec->card->dev,
+                                 "ali_capture_preapre: spdif rate detect err!\n");
                         rate = 48000;
                 }
                 spin_lock_irq(&codec->reg_lock);
                 bValue = inb(ALI_REG(codec,ALI_SPDIF_CTRL));
                 if (bValue & 0x10) {
                         outb(bValue,ALI_REG(codec,ALI_SPDIF_CTRL));
-                        printk(KERN_WARNING "clear SPDIF parity error flag.\n");
+                        dev_warn(codec->card->dev,
+                                 "clear SPDIF parity error flag.\n");
                 }
 
                 if (rate != 48000)
@@ -1418,7 +1406,7 @@ snd_ali_playback_pointer(struct snd_pcm_substream *substream)
         outb(pvoice->number, ALI_REG(codec, ALI_GC_CIR));
         cso = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2));
         spin_unlock(&codec->reg_lock);
-        snd_ali_printk("playback pointer returned cso=%xh.\n", cso);
+        dev_dbg(codec->card->dev, "playback pointer returned cso=%xh.\n", cso);
 
         return cso;
 }
@@ -1685,7 +1673,8 @@ static int snd_ali_pcm(struct snd_ali *codec, int device,
         err = snd_pcm_new(codec->card, desc->name, device,
                           desc->playback_num, desc->capture_num, &pcm);
         if (err < 0) {
-                snd_printk(KERN_ERR "snd_ali_pcm: err called snd_pcm_new.\n");
+                dev_err(codec->card->dev,
+                        "snd_ali_pcm: err called snd_pcm_new.\n");
                 return err;
         }
         pcm->private_data = codec;
@@ -1861,7 +1850,7 @@ static int snd_ali_mixer(struct snd_ali *codec)
                 ac97.num = i;
                 err = snd_ac97_mixer(codec->ac97_bus, &ac97, &codec->ac97[i]);
                 if (err < 0) {
-                        snd_printk(KERN_ERR
+                        dev_err(codec->card->dev,
                                    "ali mixer %d creating error.\n", i);
                         if (i == 0)
                                 return err;
@@ -1947,8 +1936,7 @@ static int ali_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "ali5451: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2013,10 +2001,10 @@ static int snd_ali_chip_init(struct snd_ali *codec)
         unsigned char temp;
         struct pci_dev *pci_dev;
 
-        snd_ali_printk("chip initializing ... \n");
+        dev_dbg(codec->card->dev, "chip initializing ...\n");
 
         if (snd_ali_reset_5451(codec)) {
-                snd_printk(KERN_ERR "ali_chip_init: reset 5451 error.\n");
+                dev_err(codec->card->dev, "ali_chip_init: reset 5451 error.\n");
                 return -1;
         }
 
@@ -2062,7 +2050,7 @@ static int snd_ali_chip_init(struct snd_ali *codec)
                      ALI_REG(codec, ALI_SCTRL));
         }
 
-        snd_ali_printk("chip initialize succeed.\n");
+        dev_dbg(codec->card->dev, "chip initialize succeed.\n");
         return 0;
 
 }
@@ -2088,7 +2076,7 @@ static int snd_ali_resources(struct snd_ali *codec)
 {
         int err;
 
-        snd_ali_printk("resources allocation ...\n");
+        dev_dbg(codec->card->dev, "resources allocation ...\n");
         err = pci_request_regions(codec->pci, "ALI 5451");
         if (err < 0)
                 return err;
@@ -2096,11 +2084,11 @@ static int snd_ali_resources(struct snd_ali *codec)
 
         if (request_irq(codec->pci->irq, snd_ali_card_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, codec)) {
-                snd_printk(KERN_ERR "Unable to request irq.\n");
+                dev_err(codec->card->dev, "Unable to request irq.\n");
                 return -EBUSY;
         }
         codec->irq = codec->pci->irq;
-        snd_ali_printk("resources allocated.\n");
+        dev_dbg(codec->card->dev, "resources allocated.\n");
         return 0;
 }
 static int snd_ali_dev_free(struct snd_device *device)
@@ -2125,7 +2113,7 @@ static int snd_ali_create(struct snd_card *card,
 
         *r_ali = NULL;
 
-        snd_ali_printk("creating ...\n");
+        dev_dbg(card->dev, "creating ...\n");
 
         /* enable PCI device */
         err = pci_enable_device(pci);
@@ -2134,8 +2122,8 @@ static int snd_ali_create(struct snd_card *card,
         /* check, if we can restrict PCI DMA transfers to 31 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(31)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(31)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support "
-                           "31bit PCI busmaster DMA\n");
+                dev_err(card->dev,
+                        "architecture does not support 31bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -2199,19 +2187,19 @@ static int snd_ali_create(struct snd_card *card,
         /* M1533: southbridge */
         codec->pci_m1533 = pci_get_device(0x10b9, 0x1533, NULL);
         if (!codec->pci_m1533) {
-                snd_printk(KERN_ERR "ali5451: cannot find ALi 1533 chip.\n");
+                dev_err(card->dev, "cannot find ALi 1533 chip.\n");
                 snd_ali_free(codec);
                 return -ENODEV;
         }
         /* M7101: power management */
         codec->pci_m7101 = pci_get_device(0x10b9, 0x7101, NULL);
         if (!codec->pci_m7101 && codec->revision == ALI_5451_V02) {
-                snd_printk(KERN_ERR "ali5451: cannot find ALi 7101 chip.\n");
+                dev_err(card->dev, "cannot find ALi 7101 chip.\n");
                 snd_ali_free(codec);
                 return -ENODEV;
         }
 
-        snd_ali_printk("snd_device_new is called.\n");
+        dev_dbg(card->dev, "snd_device_new is called.\n");
         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, codec, &ops);
         if (err < 0) {
                 snd_ali_free(codec);
@@ -2224,21 +2212,21 @@ static int snd_ali_create(struct snd_card *card,
 
         err = snd_ali_chip_init(codec);
         if (err < 0) {
-                snd_printk(KERN_ERR "ali create: chip init error.\n");
+                dev_err(card->dev, "ali create: chip init error.\n");
                 return err;
         }
 
 #ifdef CONFIG_PM_SLEEP
         codec->image = kmalloc(sizeof(*codec->image), GFP_KERNEL);
         if (!codec->image)
-                snd_printk(KERN_WARNING "can't allocate apm buffer\n");
+                dev_warn(card->dev, "can't allocate apm buffer\n");
 #endif
 
         snd_ali_enable_address_interrupt(codec);
         codec->hw_initialized = 1;
 
         *r_ali = codec;
-        snd_ali_printk("created.\n");
+        dev_dbg(card->dev, "created.\n");
         return 0;
 }
 
@@ -2249,7 +2237,7 @@ static int snd_ali_probe(struct pci_dev *pci,
         struct snd_ali *codec;
         int err;
 
-        snd_ali_printk("probe ...\n");
+        dev_dbg(&pci->dev, "probe ...\n");
 
         err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
         if (err < 0)
@@ -2260,12 +2248,12 @@ static int snd_ali_probe(struct pci_dev *pci,
                 goto error;
         card->private_data = codec;
 
-        snd_ali_printk("mixer building ...\n");
+        dev_dbg(&pci->dev, "mixer building ...\n");
         err = snd_ali_mixer(codec);
         if (err < 0)
                 goto error;
         
-        snd_ali_printk("pcm building ...\n");
+        dev_dbg(&pci->dev, "pcm building ...\n");
         err = snd_ali_build_pcms(codec);
         if (err < 0)
                 goto error;
@@ -2278,7 +2266,7 @@ static int snd_ali_probe(struct pci_dev *pci,
         sprintf(card->longname, "%s at 0x%lx, irq %i",
                 card->shortname, codec->port, codec->irq);
 
-        snd_ali_printk("register card.\n");
+        dev_dbg(&pci->dev, "register card.\n");
         err = snd_card_register(card);
         if (err < 0)
                 goto error;
diff --git a/sound/pci/als300.c b/sound/pci/als300.c
index 9acd88ab93a4..cc9a15a1304b 100644
--- a/sound/pci/als300.c
+++ b/sound/pci/als300.c
@@ -87,19 +87,8 @@
 #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
@@ -177,7 +166,6 @@ static inline void snd_als300_gcr_write(unsigned long port,
 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.
@@ -188,19 +176,16 @@ static void snd_als300_set_irq_flag(struct snd_als300 *chip, int cmd)
         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;
 }
 
@@ -280,9 +265,7 @@ static irqreturn_t snd_als300plus_interrupt(int irq, void *dev_id)
 
 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,
@@ -330,14 +313,12 @@ static int snd_als300_ac97(struct snd_als300 *chip)
                 .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);
 }
 
@@ -395,13 +376,11 @@ static int snd_als300_playback_open(struct snd_pcm_substream *substream)
 
         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;
 }
 
@@ -411,11 +390,9 @@ static int snd_als300_playback_close(struct snd_pcm_substream *substream)
         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;
 }
 
@@ -428,13 +405,11 @@ static int snd_als300_capture_open(struct snd_pcm_substream *substream)
 
         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;
 }
 
@@ -444,11 +419,9 @@ static int snd_als300_capture_close(struct snd_pcm_substream *substream)
         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;
 }
 
@@ -472,7 +445,6 @@ static int snd_als300_playback_prepare(struct snd_pcm_substream *substream)
         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;
@@ -491,7 +463,6 @@ static int snd_als300_playback_prepare(struct snd_pcm_substream *substream)
         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;
 }
 
@@ -503,7 +474,6 @@ static int snd_als300_capture_prepare(struct snd_pcm_substream *substream)
         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;
@@ -522,7 +492,6 @@ static int snd_als300_capture_prepare(struct snd_pcm_substream *substream)
         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;
 }
 
@@ -537,7 +506,6 @@ static int snd_als300_trigger(struct snd_pcm_substream *substream, int cmd)
         data = substream->runtime->private_data;
         reg = data->control_register;
 
-        snd_als300_dbgcallenter();
         spin_lock(&chip->reg_lock);
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -568,7 +536,6 @@ static int snd_als300_trigger(struct snd_pcm_substream *substream, int cmd)
                 ret = -EINVAL;
         }
         spin_unlock(&chip->reg_lock);
-        snd_als300_dbgcallleave();
         return ret;
 }
 
@@ -582,7 +549,6 @@ static snd_pcm_uframes_t snd_als300_pointer(struct snd_pcm_substream *substream)
         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;
@@ -595,7 +561,6 @@ static snd_pcm_uframes_t snd_als300_pointer(struct snd_pcm_substream *substream)
         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);
 }
 
@@ -626,7 +591,6 @@ static int snd_als300_new_pcm(struct snd_als300 *chip)
         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;
@@ -643,7 +607,6 @@ static int snd_als300_new_pcm(struct snd_als300 *chip)
         /* 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;
 }
 
@@ -652,7 +615,6 @@ static void snd_als300_init(struct snd_als300 *chip)
         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;
@@ -679,7 +641,6 @@ static void snd_als300_init(struct snd_als300 *chip)
         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,
@@ -695,13 +656,12 @@ static int snd_als300_create(struct snd_card *card,
         };
         *rchip = NULL;
 
-        snd_als300_dbgcallenter();
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
 
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
                 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
-                printk(KERN_ERR "error setting 28bit DMA mask\n");
+                dev_err(card->dev, "error setting 28bit DMA mask\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -733,7 +693,7 @@ static int snd_als300_create(struct snd_card *card,
 
         if (request_irq(pci->irq, irq_handler, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_als300_free(chip);
                 return -EBUSY;
         }
@@ -744,13 +704,13 @@ static int snd_als300_create(struct snd_card *card,
 
         err = snd_als300_ac97(chip);
         if (err < 0) {
-                snd_printk(KERN_WARNING "Could not create ac97\n");
+                dev_err(card->dev, "Could not create ac97\n");
                 snd_als300_free(chip);
                 return err;
         }
 
         if ((err = snd_als300_new_pcm(chip)) < 0) {
-                snd_printk(KERN_WARNING "Could not create PCM\n");
+                dev_err(card->dev, "Could not create PCM\n");
                 snd_als300_free(chip);
                 return err;
         }
@@ -762,7 +722,6 @@ static int snd_als300_create(struct snd_card *card,
         }
 
         *rchip = chip;
-        snd_als300_dbgcallleave();
         return 0;
 }
 
@@ -792,8 +751,7 @@ static int snd_als300_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "als300: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index 2b2bb0fa3bc7..b751c381d25e 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -578,7 +578,7 @@ static irqreturn_t snd_als4000_interrupt(int irq, void *dev_id)
                 snd_als4k_iobase_readb(chip->alt_port,
                                         ALS4K_IOB_16_ACK_FOR_CR1E);
 
-        /* printk(KERN_INFO "als4000: irq 0x%04x 0x%04x\n",
+        /* dev_dbg(chip->card->dev, "als4000: irq 0x%04x 0x%04x\n",
                                          pci_irqstatus, sb_irqstatus); */
 
         /* only ack the things we actually handled above */
@@ -791,13 +791,13 @@ static int snd_als4000_create_gameport(struct snd_card_als4000 *acard, int dev)
         }
 
         if (!r) {
-                printk(KERN_WARNING "als4000: cannot reserve joystick ports\n");
+                dev_warn(&acard->pci->dev, "cannot reserve joystick ports\n");
                 return -EBUSY;
         }
 
         acard->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "als4000: cannot allocate memory for gameport\n");
+                dev_err(&acard->pci->dev, "cannot allocate memory for gameport\n");
                 release_and_free_resource(r);
                 return -ENOMEM;
         }
@@ -873,7 +873,7 @@ static int snd_card_als4000_probe(struct pci_dev *pci,
         /* check, if we can restrict PCI DMA transfers to 24 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
+                dev_err(&pci->dev, "architecture does not support 24bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -933,7 +933,7 @@ static int snd_card_als4000_probe(struct pci_dev *pci,
                                         MPU401_INFO_INTEGRATED |
                                         MPU401_INFO_IRQ_HOOK,
                                         -1, &chip->rmidi)) < 0) {
-                printk(KERN_ERR "als4000: no MPU-401 device at 0x%lx?\n",
+                dev_err(&pci->dev, "no MPU-401 device at 0x%lx?\n",
                                 iobase + ALS4K_IOB_30_MIDI_DATA);
                 goto out_err;
         }
@@ -954,7 +954,7 @@ static int snd_card_als4000_probe(struct pci_dev *pci,
                                 iobase + ALS4K_IOB_10_ADLIB_ADDR0,
                                 iobase + ALS4K_IOB_12_ADLIB_ADDR2,
                             OPL3_HW_AUTO, 1, &opl3) < 0) {
-                printk(KERN_ERR "als4000: no OPL device at 0x%lx-0x%lx?\n",
+                dev_err(&pci->dev, "no OPL device at 0x%lx-0x%lx?\n",
                            iobase + ALS4K_IOB_10_ADLIB_ADDR0,
                            iobase + ALS4K_IOB_12_ADLIB_ADDR2);
         } else {
@@ -1014,8 +1014,7 @@ static int snd_als4000_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "als4000: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index 85f893b5cc99..ae07b4926dc2 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -432,7 +432,7 @@ static int snd_atiixp_acquire_codec(struct atiixp *chip)
 
         while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) {
                 if (! timeout--) {
-                        snd_printk(KERN_WARNING "atiixp: codec acquire timeout\n");
+                        dev_warn(chip->card->dev, "codec acquire timeout\n");
                         return -EBUSY;
                 }
                 udelay(1);
@@ -463,7 +463,7 @@ static unsigned short snd_atiixp_codec_read(struct atiixp *chip, unsigned short
         } while (--timeout);
         /* time out may happen during reset */
         if (reg < 0x7c)
-                snd_printk(KERN_WARNING "atiixp: codec read timeout (reg %x)\n", reg);
+                dev_warn(chip->card->dev, "codec read timeout (reg %x)\n", reg);
         return 0xffff;
 }
 
@@ -523,7 +523,7 @@ static int snd_atiixp_aclink_reset(struct atiixp *chip)
                 mdelay(1);
                 atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET);
                 if (!--timeout) {
-                        snd_printk(KERN_ERR "atiixp: codec reset timeout\n");
+                        dev_err(chip->card->dev, "codec reset timeout\n");
                         break;
                 }
         }
@@ -567,9 +567,8 @@ static int ac97_probing_bugs(struct pci_dev *pci)
 
         q = snd_pci_quirk_lookup(pci, atiixp_quirks);
         if (q) {
-                snd_printdd(KERN_INFO
-                            "Atiixp quirk for %s.  Forcing codec %d\n",
-                            snd_pci_quirk_name(q), q->value);
+                dev_dbg(&pci->dev, "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 */
@@ -600,7 +599,7 @@ static int snd_atiixp_codec_detect(struct atiixp *chip)
         atiixp_write(chip, IER, 0); /* disable irqs */
 
         if ((chip->codec_not_ready_bits & ALL_CODEC_NOT_READY) == ALL_CODEC_NOT_READY) {
-                snd_printk(KERN_ERR "atiixp: no codec detected!\n");
+                dev_err(chip->card->dev, "no codec detected!\n");
                 return -ENXIO;
         }
         return 0;
@@ -676,7 +675,7 @@ static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substr
                         continue;
                 return bytes_to_frames(runtime, curptr);
         }
-        snd_printd("atiixp: invalid DMA pointer read 0x%x (buf=%x)\n",
+        dev_dbg(chip->card->dev, "invalid DMA pointer read 0x%x (buf=%x)\n",
                    readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
         return 0;
 }
@@ -688,7 +687,7 @@ static void snd_atiixp_xrun_dma(struct atiixp *chip, struct atiixp_dma *dma)
 {
         if (! dma->substream || ! dma->running)
                 return;
-        snd_printdd("atiixp: XRUN detected (DMA %d)\n", dma->ops->type);
+        dev_dbg(chip->card->dev, "XRUN detected (DMA %d)\n", dma->ops->type);
         snd_pcm_stream_lock(dma->substream);
         snd_pcm_stop(dma->substream, SNDRV_PCM_STATE_XRUN);
         snd_pcm_stream_unlock(dma->substream);
@@ -1453,14 +1452,15 @@ static int snd_atiixp_mixer_new(struct atiixp *chip, int clock,
                         ac97.scaps |= AC97_SCAP_NO_SPDIF;
                 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) {
                         chip->ac97[i] = NULL; /* to be sure */
-                        snd_printdd("atiixp: codec %d not available for audio\n", i);
+                        dev_dbg(chip->card->dev,
+                                "codec %d not available for audio\n", i);
                         continue;
                 }
                 codec_count++;
         }
 
         if (! codec_count) {
-                snd_printk(KERN_ERR "atiixp: no codec available\n");
+                dev_err(chip->card->dev, "no codec available\n");
                 return -ENODEV;
         }
 
@@ -1511,8 +1511,7 @@ static int snd_atiixp_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "atiixp: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -1637,14 +1636,14 @@ static int snd_atiixp_create(struct snd_card *card,
         chip->addr = pci_resource_start(pci, 0);
         chip->remap_addr = pci_ioremap_bar(pci, 0);
         if (chip->remap_addr == NULL) {
-                snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
+                dev_err(card->dev, "AC'97 space ioremap problem\n");
                 snd_atiixp_free(chip);
                 return -EIO;
         }
 
         if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_atiixp_free(chip);
                 return -EBUSY;
         }
diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c
index 2b3244a85cf8..b9dc96c5d21e 100644
--- a/sound/pci/atiixp_modem.c
+++ b/sound/pci/atiixp_modem.c
@@ -400,7 +400,7 @@ static int snd_atiixp_acquire_codec(struct atiixp_modem *chip)
 
         while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) {
                 if (! timeout--) {
-                        snd_printk(KERN_WARNING "atiixp-modem: codec acquire timeout\n");
+                        dev_warn(chip->card->dev, "codec acquire timeout\n");
                         return -EBUSY;
                 }
                 udelay(1);
@@ -433,7 +433,7 @@ static unsigned short snd_atiixp_codec_read(struct atiixp_modem *chip,
         } while (--timeout);
         /* time out may happen during reset */
         if (reg < 0x7c)
-                snd_printk(KERN_WARNING "atiixp-modem: codec read timeout (reg %x)\n", reg);
+                dev_warn(chip->card->dev, "codec read timeout (reg %x)\n", reg);
         return 0xffff;
 }
 
@@ -499,7 +499,7 @@ static int snd_atiixp_aclink_reset(struct atiixp_modem *chip)
                 msleep(1);
                 atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET);
                 if (!--timeout) {
-                        snd_printk(KERN_ERR "atiixp-modem: codec reset timeout\n");
+                        dev_err(chip->card->dev, "codec reset timeout\n");
                         break;
                 }
         }
@@ -553,7 +553,7 @@ static int snd_atiixp_codec_detect(struct atiixp_modem *chip)
         atiixp_write(chip, IER, 0); /* disable irqs */
 
         if ((chip->codec_not_ready_bits & ALL_CODEC_NOT_READY) == ALL_CODEC_NOT_READY) {
-                snd_printk(KERN_ERR "atiixp-modem: no codec detected!\n");
+                dev_err(chip->card->dev, "no codec detected!\n");
                 return -ENXIO;
         }
         return 0;
@@ -624,7 +624,7 @@ static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substr
                         continue;
                 return bytes_to_frames(runtime, curptr);
         }
-        snd_printd("atiixp-modem: invalid DMA pointer read 0x%x (buf=%x)\n",
+        dev_dbg(chip->card->dev, "invalid DMA pointer read 0x%x (buf=%x)\n",
                    readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
         return 0;
 }
@@ -637,7 +637,7 @@ static void snd_atiixp_xrun_dma(struct atiixp_modem *chip,
 {
         if (! dma->substream || ! dma->running)
                 return;
-        snd_printdd("atiixp-modem: XRUN detected (DMA %d)\n", dma->ops->type);
+        dev_dbg(chip->card->dev, "XRUN detected (DMA %d)\n", dma->ops->type);
         snd_pcm_stream_lock(dma->substream);
         snd_pcm_stop(dma->substream, SNDRV_PCM_STATE_XRUN);
         snd_pcm_stream_unlock(dma->substream);
@@ -1098,14 +1098,15 @@ static int snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock)
                 ac97.scaps = AC97_SCAP_SKIP_AUDIO | AC97_SCAP_POWER_SAVE;
                 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) {
                         chip->ac97[i] = NULL; /* to be sure */
-                        snd_printdd("atiixp-modem: codec %d not available for modem\n", i);
+                        dev_dbg(chip->card->dev,
+                                "codec %d not available for modem\n", i);
                         continue;
                 }
                 codec_count++;
         }
 
         if (! codec_count) {
-                snd_printk(KERN_ERR "atiixp-modem: no codec available\n");
+                dev_err(chip->card->dev, "no codec available\n");
                 return -ENODEV;
         }
 
@@ -1150,8 +1151,7 @@ static int snd_atiixp_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "atiixp-modem: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -1262,14 +1262,14 @@ static int snd_atiixp_create(struct snd_card *card,
         chip->addr = pci_resource_start(pci, 0);
         chip->remap_addr = pci_ioremap_bar(pci, 0);
         if (chip->remap_addr == NULL) {
-                snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
+                dev_err(card->dev, "AC'97 space ioremap problem\n");
                 snd_atiixp_free(chip);
                 return -EIO;
         }
 
         if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_atiixp_free(chip);
                 return -EBUSY;
         }
diff --git a/sound/pci/aw2/aw2-alsa.c b/sound/pci/aw2/aw2-alsa.c
index e9dabee42805..120d0d320a60 100644
--- a/sound/pci/aw2/aw2-alsa.c
+++ b/sound/pci/aw2/aw2-alsa.c
@@ -262,7 +262,7 @@ static int snd_aw2_create(struct snd_card *card,
         /* check PCI availability (32bit DMA) */
         if ((pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) ||
             (pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0)) {
-                printk(KERN_ERR "aw2: Impossible to set 32bit mask DMA\n");
+                dev_err(card->dev, "Impossible to set 32bit mask DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -290,7 +290,7 @@ static int snd_aw2_create(struct snd_card *card,
                                 pci_resource_len(pci, 0));
 
         if (chip->iobase_virt == NULL) {
-                printk(KERN_ERR "aw2: unable to remap memory region");
+                dev_err(card->dev, "unable to remap memory region");
                 pci_release_regions(pci);
                 pci_disable_device(pci);
                 kfree(chip);
@@ -302,7 +302,7 @@ static int snd_aw2_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_aw2_saa7146_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
-                printk(KERN_ERR "aw2: Cannot grab irq %d\n", pci->irq);
+                dev_err(card->dev, "Cannot grab irq %d\n", pci->irq);
 
                 iounmap(chip->iobase_virt);
                 pci_release_regions(chip->pci);
@@ -324,9 +324,8 @@ static int snd_aw2_create(struct snd_card *card,
 
         *rchip = chip;
 
-        printk(KERN_INFO
-               "Audiowerk 2 sound card (saa7146 chipset) detected and "
-               "managed\n");
+        dev_info(card->dev,
+                 "Audiowerk 2 sound card (saa7146 chipset) detected and managed\n");
         return 0;
 }
 
@@ -399,7 +398,7 @@ static int snd_aw2_pcm_playback_open(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
 
-        snd_printdd(KERN_DEBUG "aw2: Playback_open\n");
+        dev_dbg(substream->pcm->card->dev, "Playback_open\n");
         runtime->hw = snd_aw2_playback_hw;
         return 0;
 }
@@ -415,7 +414,7 @@ static int snd_aw2_pcm_capture_open(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
 
-        snd_printdd(KERN_DEBUG "aw2: Capture_open\n");
+        dev_dbg(substream->pcm->card->dev, "Capture_open\n");
         runtime->hw = snd_aw2_capture_hw;
         return 0;
 }
@@ -603,7 +602,7 @@ static int snd_aw2_new_pcm(struct aw2 *chip)
         err = snd_pcm_new(chip->card, "Audiowerk2 analog playback", 0, 1, 0,
                           &pcm_playback_ana);
         if (err < 0) {
-                printk(KERN_ERR "aw2: snd_pcm_new error (0x%X)\n", err);
+                dev_err(chip->card->dev, "snd_pcm_new error (0x%X)\n", err);
                 return err;
         }
 
@@ -633,14 +632,15 @@ static int snd_aw2_new_pcm(struct aw2 *chip)
                                                     (chip->pci),
                                                     64 * 1024, 64 * 1024);
         if (err)
-                printk(KERN_ERR "aw2: snd_pcm_lib_preallocate_pages_for_all "
-                       "error (0x%X)\n", err);
+                dev_err(chip->card->dev,
+                        "snd_pcm_lib_preallocate_pages_for_all error (0x%X)\n",
+                        err);
 
         err = snd_pcm_new(chip->card, "Audiowerk2 digital playback", 1, 1, 0,
                           &pcm_playback_num);
 
         if (err < 0) {
-                printk(KERN_ERR "aw2: snd_pcm_new error (0x%X)\n", err);
+                dev_err(chip->card->dev, "snd_pcm_new error (0x%X)\n", err);
                 return err;
         }
         /* Creation ok */
@@ -669,17 +669,15 @@ static int snd_aw2_new_pcm(struct aw2 *chip)
                                                     (chip->pci),
                                                     64 * 1024, 64 * 1024);
         if (err)
-                printk(KERN_ERR
-                       "aw2: snd_pcm_lib_preallocate_pages_for_all error "
-                       "(0x%X)\n", err);
-
-
+                dev_err(chip->card->dev,
+                        "snd_pcm_lib_preallocate_pages_for_all error (0x%X)\n",
+                        err);
 
         err = snd_pcm_new(chip->card, "Audiowerk2 capture", 2, 0, 1,
                           &pcm_capture);
 
         if (err < 0) {
-                printk(KERN_ERR "aw2: snd_pcm_new error (0x%X)\n", err);
+                dev_err(chip->card->dev, "snd_pcm_new error (0x%X)\n", err);
                 return err;
         }
 
@@ -709,15 +707,15 @@ static int snd_aw2_new_pcm(struct aw2 *chip)
                                                     (chip->pci),
                                                     64 * 1024, 64 * 1024);
         if (err)
-                printk(KERN_ERR
-                       "aw2: snd_pcm_lib_preallocate_pages_for_all error "
-                       "(0x%X)\n", err);
+                dev_err(chip->card->dev,
+                        "snd_pcm_lib_preallocate_pages_for_all error (0x%X)\n",
+                        err);
 
 
         /* Create control */
         err = snd_ctl_add(chip->card, snd_ctl_new1(&aw2_control, chip));
         if (err < 0) {
-                printk(KERN_ERR "aw2: snd_ctl_add error (0x%X)\n", err);
+                dev_err(chip->card->dev, "snd_ctl_add error (0x%X)\n", err);
                 return err;
         }
 
diff --git a/sound/pci/aw2/aw2-saa7146.c b/sound/pci/aw2/aw2-saa7146.c
index 4439636971eb..6d24e9536777 100644
--- a/sound/pci/aw2/aw2-saa7146.c
+++ b/sound/pci/aw2/aw2-saa7146.c
@@ -204,8 +204,7 @@ void snd_aw2_saa7146_pcm_init_playback(struct snd_aw2_saa7146 *chip,
                 /* Define upper limit for DMA access */
                 WRITEREG(dma_addr + buffer_size, ProtA1_out);
         } else {
-                printk(KERN_ERR
-                       "aw2: snd_aw2_saa7146_pcm_init_playback: "
+                pr_err("aw2: snd_aw2_saa7146_pcm_init_playback: "
                        "Substream number is not 0 or 1 -> not managed\n");
         }
 }
@@ -251,8 +250,7 @@ void snd_aw2_saa7146_pcm_init_capture(struct snd_aw2_saa7146 *chip,
                 /* Define upper limit for DMA access  */
                 WRITEREG(dma_addr + buffer_size, ProtA1_in);
         } else {
-                printk(KERN_ERR
-                       "aw2: snd_aw2_saa7146_pcm_init_capture: "
+                pr_err("aw2: snd_aw2_saa7146_pcm_init_capture: "
                        "Substream number is not 0 -> not managed\n");
         }
 }
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index 641c235ab4d8..c9216c0a9c8b 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -238,61 +238,6 @@ MODULE_SUPPORTED_DEVICE("{{Aztech,AZF3328}}");
     2>/dev/null
 */
 
-#define DEBUG_MISC      0
-#define DEBUG_CALLS     0
-#define DEBUG_MIXER     0
-#define DEBUG_CODEC     0
-#define DEBUG_TIMER     0
-#define DEBUG_GAME      0
-#define DEBUG_PM        0
-#define MIXER_TESTING   0
-
-#if DEBUG_MISC
-#define snd_azf3328_dbgmisc(format, args...) printk(KERN_DEBUG format, ##args)
-#else
-#define snd_azf3328_dbgmisc(format, args...)
-#endif
-
-#if DEBUG_CALLS
-#define snd_azf3328_dbgcalls(format, args...) printk(format, ##args)
-#define snd_azf3328_dbgcallenter() printk(KERN_DEBUG "--> %s\n", __func__)
-#define snd_azf3328_dbgcallleave() printk(KERN_DEBUG "<-- %s\n", __func__)
-#else
-#define snd_azf3328_dbgcalls(format, args...)
-#define snd_azf3328_dbgcallenter()
-#define snd_azf3328_dbgcallleave()
-#endif
-
-#if DEBUG_MIXER
-#define snd_azf3328_dbgmixer(format, args...) printk(KERN_DEBUG format, ##args)
-#else
-#define snd_azf3328_dbgmixer(format, args...)
-#endif
-
-#if DEBUG_CODEC
-#define snd_azf3328_dbgcodec(format, args...) printk(KERN_DEBUG format, ##args)
-#else
-#define snd_azf3328_dbgcodec(format, args...)
-#endif
-
-#if DEBUG_MISC
-#define snd_azf3328_dbgtimer(format, args...) printk(KERN_DEBUG format, ##args)
-#else
-#define snd_azf3328_dbgtimer(format, args...)
-#endif
-
-#if DEBUG_GAME
-#define snd_azf3328_dbggame(format, args...) printk(KERN_DEBUG format, ##args)
-#else
-#define snd_azf3328_dbggame(format, args...)
-#endif
-
-#if DEBUG_PM
-#define snd_azf3328_dbgpm(format, args...) printk(KERN_DEBUG format, ##args)
-#else
-#define snd_azf3328_dbgpm(format, args...)
-#endif
-
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for AZF3328 soundcard.");
@@ -475,6 +420,12 @@ snd_azf3328_ctrl_inb(const struct snd_azf3328 *chip, unsigned reg)
         return inb(chip->ctrl_io + reg);
 }
 
+static inline u16
+snd_azf3328_ctrl_inw(const struct snd_azf3328 *chip, unsigned reg)
+{
+        return inw(chip->ctrl_io + reg);
+}
+
 static inline void
 snd_azf3328_ctrl_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
 {
@@ -578,11 +529,12 @@ snd_azf3328_mixer_reset(const struct snd_azf3328 *chip)
 #ifdef AZF_USE_AC97_LAYER
 
 static inline void
-snd_azf3328_mixer_ac97_map_unsupported(unsigned short reg, const char *mode)
+snd_azf3328_mixer_ac97_map_unsupported(const struct snd_azf3328 *chip,
+                                       unsigned short reg, const char *mode)
 {
         /* need to add some more or less clever emulation? */
-        printk(KERN_WARNING
-                "azt3328: missing %s emulation for AC97 register 0x%02x!\n",
+        dev_warn(chip->card->dev,
+                "missing %s emulation for AC97 register 0x%02x!\n",
                 mode, reg);
 }
 
@@ -717,10 +669,8 @@ snd_azf3328_mixer_ac97_read(struct snd_ac97 *ac97, unsigned short reg_ac97)
         unsigned short reg_val = 0;
         bool unsupported = false;
 
-        snd_azf3328_dbgmixer(
-                "snd_azf3328_mixer_ac97_read reg_ac97 %u\n",
-                        reg_ac97
-        );
+        dev_dbg(chip->card->dev, "snd_azf3328_mixer_ac97_read reg_ac97 %u\n",
+                reg_ac97);
         if (reg_azf & AZF_AC97_REG_UNSUPPORTED)
                 unsupported = true;
         else {
@@ -765,7 +715,7 @@ snd_azf3328_mixer_ac97_read(struct snd_ac97 *ac97, unsigned short reg_ac97)
                 }
         }
         if (unsupported)
-                snd_azf3328_mixer_ac97_map_unsupported(reg_ac97, "read");
+                snd_azf3328_mixer_ac97_map_unsupported(chip, reg_ac97, "read");
 
         return reg_val;
 }
@@ -778,10 +728,9 @@ snd_azf3328_mixer_ac97_write(struct snd_ac97 *ac97,
         unsigned short reg_azf = snd_azf3328_mixer_ac97_map_reg_idx(reg_ac97);
         bool unsupported = false;
 
-        snd_azf3328_dbgmixer(
+        dev_dbg(chip->card->dev,
                 "snd_azf3328_mixer_ac97_write reg_ac97 %u val %u\n",
-                        reg_ac97, val
-        );
+                reg_ac97, val);
         if (reg_azf & AZF_AC97_REG_UNSUPPORTED)
                 unsupported = true;
         else {
@@ -814,7 +763,7 @@ snd_azf3328_mixer_ac97_write(struct snd_ac97 *ac97,
                 }
         }
         if (unsupported)
-                snd_azf3328_mixer_ac97_map_unsupported(reg_ac97, "write");
+                snd_azf3328_mixer_ac97_map_unsupported(chip, reg_ac97, "write");
 }
 
 static int
@@ -850,7 +799,7 @@ snd_azf3328_mixer_new(struct snd_azf3328 *chip)
                  * due to this card being a very quirky AC97 "lookalike".
                  */
         if (rc)
-                printk(KERN_ERR "azt3328: AC97 init failed, err %d!\n", rc);
+                dev_err(chip->card->dev, "AC97 init failed, err %d!\n", rc);
 
         /* If we return an error here, then snd_card_free() should
          * free up any ac97 codecs that got created, as well as the bus.
@@ -870,8 +819,6 @@ snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip,
         unsigned char curr_vol_left = 0, curr_vol_right = 0;
         int left_change = 0, right_change = 0;
 
-        snd_azf3328_dbgcallenter();
-
         if (chan_sel & SET_CHAN_LEFT) {
                 curr_vol_left  = inb(portbase + 1);
 
@@ -912,7 +859,6 @@ snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip,
                 if (delay)
                         mdelay(delay);
         } while ((left_change) || (right_change));
-        snd_azf3328_dbgcallleave();
 }
 
 /*
@@ -990,14 +936,12 @@ snd_azf3328_info_mixer(struct snd_kcontrol *kcontrol,
 {
         struct azf3328_mixer_reg reg;
 
-        snd_azf3328_dbgcallenter();
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
         uinfo->type = reg.mask == 1 ?
                 SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
         uinfo->count = reg.stereo + 1;
         uinfo->value.integer.min = 0;
         uinfo->value.integer.max = reg.mask;
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -1009,7 +953,6 @@ snd_azf3328_get_mixer(struct snd_kcontrol *kcontrol,
         struct azf3328_mixer_reg reg;
         u16 oreg, val;
 
-        snd_azf3328_dbgcallenter();
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
 
         oreg = snd_azf3328_mixer_inw(chip, reg.reg);
@@ -1023,12 +966,11 @@ snd_azf3328_get_mixer(struct snd_kcontrol *kcontrol,
                         val = reg.mask - val;
                 ucontrol->value.integer.value[1] = val;
         }
-        snd_azf3328_dbgmixer("get: %02x is %04x -> vol %02lx|%02lx "
-                             "(shift %02d|%02d, mask %02x, inv. %d, stereo %d)\n",
+        dev_dbg(chip->card->dev,
+                "get: %02x is %04x -> vol %02lx|%02lx (shift %02d|%02d, mask %02x, inv. %d, stereo %d)\n",
                 reg.reg, oreg,
                 ucontrol->value.integer.value[0], ucontrol->value.integer.value[1],
                 reg.lchan_shift, reg.rchan_shift, reg.mask, reg.invert, reg.stereo);
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -1040,7 +982,6 @@ snd_azf3328_put_mixer(struct snd_kcontrol *kcontrol,
         struct azf3328_mixer_reg reg;
         u16 oreg, nreg, val;
 
-        snd_azf3328_dbgcallenter();
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
         oreg = snd_azf3328_mixer_inw(chip, reg.reg);
         val = ucontrol->value.integer.value[0] & reg.mask;
@@ -1064,12 +1005,11 @@ snd_azf3328_put_mixer(struct snd_kcontrol *kcontrol,
         else
                 snd_azf3328_mixer_outw(chip, reg.reg, nreg);
 
-        snd_azf3328_dbgmixer("put: %02x to %02lx|%02lx, "
-                             "oreg %04x; shift %02d|%02d -> nreg %04x; after: %04x\n",
+        dev_dbg(chip->card->dev,
+                "put: %02x to %02lx|%02lx, oreg %04x; shift %02d|%02d -> nreg %04x; after: %04x\n",
                 reg.reg, ucontrol->value.integer.value[0], ucontrol->value.integer.value[1],
                 oreg, reg.lchan_shift, reg.rchan_shift,
                 nreg, snd_azf3328_mixer_inw(chip, reg.reg));
-        snd_azf3328_dbgcallleave();
         return (nreg != oreg);
 }
 
@@ -1135,7 +1075,8 @@ snd_azf3328_get_mixer_enum(struct snd_kcontrol *kcontrol,
         } else
                 ucontrol->value.enumerated.item[0] = (val >> reg.lchan_shift) & (reg.enum_c - 1);
 
-        snd_azf3328_dbgmixer("get_enum: %02x is %04x -> %d|%d (shift %02d, enum_c %d)\n",
+        dev_dbg(chip->card->dev,
+                "get_enum: %02x is %04x -> %d|%d (shift %02d, enum_c %d)\n",
                 reg.reg, val, ucontrol->value.enumerated.item[0], ucontrol->value.enumerated.item[1],
                 reg.lchan_shift, reg.enum_c);
         return 0;
@@ -1167,7 +1108,8 @@ snd_azf3328_put_mixer_enum(struct snd_kcontrol *kcontrol,
         snd_azf3328_mixer_outw(chip, reg.reg, val);
         nreg = val;
 
-        snd_azf3328_dbgmixer("put_enum: %02x to %04x, oreg %04x\n", reg.reg, val, oreg);
+        dev_dbg(chip->card->dev,
+                "put_enum: %02x to %04x, oreg %04x\n", reg.reg, val, oreg);
         return (nreg != oreg);
 }
 
@@ -1253,7 +1195,6 @@ snd_azf3328_mixer_new(struct snd_azf3328 *chip)
         unsigned int idx;
         int err;
 
-        snd_azf3328_dbgcallenter();
         if (snd_BUG_ON(!chip || !chip->card))
                 return -EINVAL;
 
@@ -1279,7 +1220,6 @@ snd_azf3328_mixer_new(struct snd_azf3328 *chip)
         snd_component_add(card, "AZF3328 mixer");
         strcpy(card->mixername, "AZF3328 mixer");
 
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 #endif /* AZF_USE_AC97_LAYER */
@@ -1288,19 +1228,13 @@ static int
 snd_azf3328_hw_params(struct snd_pcm_substream *substream,
                                  struct snd_pcm_hw_params *hw_params)
 {
-        int res;
-        snd_azf3328_dbgcallenter();
-        res = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
-        snd_azf3328_dbgcallleave();
-        return res;
+        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 }
 
 static int
 snd_azf3328_hw_free(struct snd_pcm_substream *substream)
 {
-        snd_azf3328_dbgcallenter();
         snd_pcm_lib_free_pages(substream);
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -1315,7 +1249,6 @@ snd_azf3328_codec_setfmt(struct snd_azf3328_codec_data *codec,
         u16 val = 0xff00;
         u8 freq = 0;
 
-        snd_azf3328_dbgcallenter();
         switch (bitrate) {
         case AZF_FREQ_4000:  freq = SOUNDFORMAT_FREQ_SUSPECTED_4000; break;
         case AZF_FREQ_4800:  freq = SOUNDFORMAT_FREQ_SUSPECTED_4800; break;
@@ -1379,7 +1312,6 @@ snd_azf3328_codec_setfmt(struct snd_azf3328_codec_data *codec,
                 );
 
         spin_unlock_irqrestore(codec->lock, flags);
-        snd_azf3328_dbgcallleave();
 }
 
 static inline void
@@ -1404,15 +1336,16 @@ snd_azf3328_ctrl_reg_6AH_update(struct snd_azf3328 *chip,
                 chip->shadow_reg_ctrl_6AH |= bitmask;
         else
                 chip->shadow_reg_ctrl_6AH &= ~bitmask;
-        snd_azf3328_dbgcodec("6AH_update mask 0x%04x do_mask %d: val 0x%04x\n",
-                        bitmask, do_mask, chip->shadow_reg_ctrl_6AH);
+        dev_dbg(chip->card->dev,
+                "6AH_update mask 0x%04x do_mask %d: val 0x%04x\n",
+                bitmask, do_mask, chip->shadow_reg_ctrl_6AH);
         snd_azf3328_ctrl_outw(chip, IDX_IO_6AH, chip->shadow_reg_ctrl_6AH);
 }
 
 static inline void
 snd_azf3328_ctrl_enable_codecs(struct snd_azf3328 *chip, bool enable)
 {
-        snd_azf3328_dbgcodec("codec_enable %d\n", enable);
+        dev_dbg(chip->card->dev, "codec_enable %d\n", enable);
         /* no idea what exactly is being done here, but I strongly assume it's
          * PM related */
         snd_azf3328_ctrl_reg_6AH_update(
@@ -1429,7 +1362,7 @@ snd_azf3328_ctrl_codec_activity(struct snd_azf3328 *chip,
         struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
         bool need_change = (codec->running != enable);
 
-        snd_azf3328_dbgcodec(
+        dev_dbg(chip->card->dev,
                 "codec_activity: %s codec, enable %d, need_change %d\n",
                                 codec->name, enable, need_change
         );
@@ -1470,13 +1403,13 @@ snd_azf3328_ctrl_codec_activity(struct snd_azf3328 *chip,
 }
 
 static void
-snd_azf3328_codec_setdmaa(struct snd_azf3328_codec_data *codec,
-                                unsigned long addr,
-                                unsigned int period_bytes,
-                                unsigned int buffer_bytes
+snd_azf3328_codec_setdmaa(struct snd_azf3328 *chip,
+                          struct snd_azf3328_codec_data *codec,
+                          unsigned long addr,
+                          unsigned int period_bytes,
+                          unsigned int buffer_bytes
 )
 {
-        snd_azf3328_dbgcallenter();
         WARN_ONCE(period_bytes & 1, "odd period length!?\n");
         WARN_ONCE(buffer_bytes != 2 * period_bytes,
                  "missed our input expectations! %u vs. %u\n",
@@ -1499,7 +1432,7 @@ snd_azf3328_codec_setdmaa(struct snd_azf3328_codec_data *codec,
                 setup_io.dma_start_1 = addr;
                 setup_io.dma_start_2 = addr+area_length;
 
-                snd_azf3328_dbgcodec(
+                dev_dbg(chip->card->dev,
                         "setdma: buffers %08x[%u] / %08x[%u], %u, %u\n",
                                 setup_io.dma_start_1, area_length,
                                 setup_io.dma_start_2, area_length,
@@ -1522,7 +1455,6 @@ snd_azf3328_codec_setdmaa(struct snd_azf3328_codec_data *codec,
                 );
                 spin_unlock_irqrestore(codec->lock, flags);
         }
-        snd_azf3328_dbgcallleave();
 }
 
 static int
@@ -1535,8 +1467,6 @@ snd_azf3328_pcm_prepare(struct snd_pcm_substream *substream)
         unsigned int count = snd_pcm_lib_period_bytes(substream);
 #endif
 
-        snd_azf3328_dbgcallenter();
-
         codec->dma_base = runtime->dma_addr;
 
 #if 0
@@ -1544,10 +1474,9 @@ snd_azf3328_pcm_prepare(struct snd_pcm_substream *substream)
                 runtime->rate,
                 snd_pcm_format_width(runtime->format),
                 runtime->channels);
-        snd_azf3328_codec_setdmaa(codec,
+        snd_azf3328_codec_setdmaa(chip, codec,
                                         runtime->dma_addr, count, size);
 #endif
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -1562,11 +1491,9 @@ snd_azf3328_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         bool previously_muted = false;
         bool is_main_mixer_playback_codec = (AZF_CODEC_PLAYBACK == codec->type);
 
-        snd_azf3328_dbgcalls("snd_azf3328_pcm_trigger cmd %d\n", cmd);
-
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
-                snd_azf3328_dbgcodec("START %s\n", codec->name);
+                dev_dbg(chip->card->dev, "START PCM %s\n", codec->name);
 
                 if (is_main_mixer_playback_codec) {
                         /* mute WaveOut (avoid clicking during setup) */
@@ -1593,7 +1520,7 @@ snd_azf3328_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_IRQTYPE, 0xffff);
                 spin_unlock(codec->lock);
 
-                snd_azf3328_codec_setdmaa(codec, runtime->dma_addr,
+                snd_azf3328_codec_setdmaa(chip, codec, runtime->dma_addr,
                         snd_pcm_lib_period_bytes(substream),
                         snd_pcm_lib_buffer_bytes(substream)
                 );
@@ -1633,10 +1560,10 @@ snd_azf3328_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                                 );
                 }
 
-                snd_azf3328_dbgcodec("STARTED %s\n", codec->name);
+                dev_dbg(chip->card->dev, "PCM STARTED %s\n", codec->name);
                 break;
         case SNDRV_PCM_TRIGGER_RESUME:
-                snd_azf3328_dbgcodec("RESUME %s\n", codec->name);
+                dev_dbg(chip->card->dev, "PCM RESUME %s\n", codec->name);
                 /* resume codec if we were active */
                 spin_lock(codec->lock);
                 if (codec->running)
@@ -1648,7 +1575,7 @@ snd_azf3328_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 spin_unlock(codec->lock);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
-                snd_azf3328_dbgcodec("STOP %s\n", codec->name);
+                dev_dbg(chip->card->dev, "PCM STOP %s\n", codec->name);
 
                 if (is_main_mixer_playback_codec) {
                         /* mute WaveOut (avoid clicking during setup) */
@@ -1684,10 +1611,10 @@ snd_azf3328_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                                 );
                 }
 
-                snd_azf3328_dbgcodec("STOPPED %s\n", codec->name);
+                dev_dbg(chip->card->dev, "PCM STOPPED %s\n", codec->name);
                 break;
         case SNDRV_PCM_TRIGGER_SUSPEND:
-                snd_azf3328_dbgcodec("SUSPEND %s\n", codec->name);
+                dev_dbg(chip->card->dev, "PCM SUSPEND %s\n", codec->name);
                 /* make sure codec is stopped */
                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
                         snd_azf3328_codec_inw(
@@ -1696,17 +1623,16 @@ snd_azf3328_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 );
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_PUSH NIY!\n");
+                WARN(1, "FIXME: SNDRV_PCM_TRIGGER_PAUSE_PUSH NIY!\n");
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_RELEASE NIY!\n");
+                WARN(1, "FIXME: SNDRV_PCM_TRIGGER_PAUSE_RELEASE NIY!\n");
                 break;
         default:
-                snd_printk(KERN_ERR "FIXME: unknown trigger mode!\n");
+                WARN(1, "FIXME: unknown trigger mode!\n");
                 return -EINVAL;
         }
 
-        snd_azf3328_dbgcallleave();
         return result;
 }
 
@@ -1728,8 +1654,8 @@ snd_azf3328_pcm_pointer(struct snd_pcm_substream *substream
         result -= codec->dma_base;
 #endif
         frmres = bytes_to_frames( substream->runtime, result);
-        snd_azf3328_dbgcodec("%08li %s @ 0x%8lx, frames %8ld\n",
-                                jiffies, codec->name, result, frmres);
+        dev_dbg(substream->pcm->card->dev, "%08li %s @ 0x%8lx, frames %8ld\n",
+                jiffies, codec->name, result, frmres);
         return frmres;
 }
 
@@ -1792,7 +1718,7 @@ snd_azf3328_gameport_interrupt(struct snd_azf3328 *chip)
          * skeleton handler only
          * (we do not want axis reading in interrupt handler - too much load!)
          */
-        snd_azf3328_dbggame("gameport irq\n");
+        dev_dbg(chip->card->dev, "gameport irq\n");
 
          /* this should ACK the gameport IRQ properly, hopefully. */
         snd_azf3328_game_inw(chip, IDX_GAME_AXIS_VALUE);
@@ -1804,7 +1730,7 @@ snd_azf3328_gameport_open(struct gameport *gameport, int mode)
         struct snd_azf3328 *chip = gameport_get_port_data(gameport);
         int res;
 
-        snd_azf3328_dbggame("gameport_open, mode %d\n", mode);
+        dev_dbg(chip->card->dev, "gameport_open, mode %d\n", mode);
         switch (mode) {
         case GAMEPORT_MODE_COOKED:
         case GAMEPORT_MODE_RAW:
@@ -1827,7 +1753,7 @@ snd_azf3328_gameport_close(struct gameport *gameport)
 {
         struct snd_azf3328 *chip = gameport_get_port_data(gameport);
 
-        snd_azf3328_dbggame("gameport_close\n");
+        dev_dbg(chip->card->dev, "gameport_close\n");
         snd_azf3328_gameport_set_counter_frequency(chip,
                                 GAME_HWCFG_ADC_COUNTER_FREQ_1_200);
         snd_azf3328_gameport_axis_circuit_enable(chip, 0);
@@ -1892,9 +1818,8 @@ snd_azf3328_gameport_cooked_read(struct gameport *gameport,
                         axes[i] = -1;
         }
 
-        snd_azf3328_dbggame("cooked_read: axes %d %d %d %d buttons %d\n",
-                axes[0], axes[1], axes[2], axes[3], *buttons
-        );
+        dev_dbg(chip->card->dev, "cooked_read: axes %d %d %d %d buttons %d\n",
+                axes[0], axes[1], axes[2], axes[3], *buttons);
 
         return 0;
 }
@@ -1906,7 +1831,7 @@ snd_azf3328_gameport(struct snd_azf3328 *chip, int dev)
 
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "azt3328: cannot alloc memory for gameport\n");
+                dev_err(chip->card->dev, "cannot alloc memory for gameport\n");
                 return -ENOMEM;
         }
 
@@ -1950,23 +1875,23 @@ snd_azf3328_gameport_free(struct snd_azf3328 *chip) { }
 static inline void
 snd_azf3328_gameport_interrupt(struct snd_azf3328 *chip)
 {
-        printk(KERN_WARNING "huh, game port IRQ occurred!?\n");
+        dev_warn(chip->card->dev, "huh, game port IRQ occurred!?\n");
 }
 #endif /* SUPPORT_GAMEPORT */
 
 /******************************************************************/
 
 static inline void
-snd_azf3328_irq_log_unknown_type(u8 which)
+snd_azf3328_irq_log_unknown_type(struct snd_azf3328 *chip, u8 which)
 {
-        snd_azf3328_dbgcodec(
-        "azt3328: unknown IRQ type (%x) occurred, please report!\n",
-                which
-        );
+        dev_dbg(chip->card->dev,
+                "unknown IRQ type (%x) occurred, please report!\n",
+                which);
 }
 
 static inline void
-snd_azf3328_pcm_interrupt(const struct snd_azf3328_codec_data *first_codec,
+snd_azf3328_pcm_interrupt(struct snd_azf3328 *chip,
+                          const struct snd_azf3328_codec_data *first_codec,
                           u8 status
 )
 {
@@ -1990,17 +1915,15 @@ snd_azf3328_pcm_interrupt(const struct snd_azf3328_codec_data *first_codec,
 
                 if (codec->substream) {
                         snd_pcm_period_elapsed(codec->substream);
-                        snd_azf3328_dbgcodec("%s period done (#%x), @ %x\n",
+                        dev_dbg(chip->card->dev, "%s period done (#%x), @ %x\n",
                                 codec->name,
                                 which,
                                 snd_azf3328_codec_inl(
-                                        codec, IDX_IO_CODEC_DMA_CURRPOS
-                                )
-                        );
+                                        codec, IDX_IO_CODEC_DMA_CURRPOS));
                 } else
-                        printk(KERN_WARNING "azt3328: irq handler problem!\n");
+                        dev_warn(chip->card->dev, "irq handler problem!\n");
                 if (which & IRQ_SOMETHING)
-                        snd_azf3328_irq_log_unknown_type(which);
+                        snd_azf3328_irq_log_unknown_type(chip, which);
         }
 }
 
@@ -2009,9 +1932,7 @@ snd_azf3328_interrupt(int irq, void *dev_id)
 {
         struct snd_azf3328 *chip = dev_id;
         u8 status;
-#if DEBUG_CODEC
         static unsigned long irq_count;
-#endif
 
         status = snd_azf3328_ctrl_inb(chip, IDX_IO_IRQSTATUS);
 
@@ -2022,14 +1943,13 @@ snd_azf3328_interrupt(int irq, void *dev_id)
         ))
                 return IRQ_NONE; /* must be interrupt for another device */
 
-        snd_azf3328_dbgcodec(
+        dev_dbg(chip->card->dev,
                 "irq_count %ld! IDX_IO_IRQSTATUS %04x\n",
                         irq_count++ /* debug-only */,
-                        status
-        );
+                        status);
 
         if (status & IRQ_TIMER) {
-                /* snd_azf3328_dbgcodec("timer %ld\n",
+                /* dev_dbg(chip->card->dev, "timer %ld\n",
                         snd_azf3328_codec_inl(chip, IDX_IO_TIMER_VALUE)
                                 & TIMER_VALUE_MASK
                 ); */
@@ -2039,11 +1959,11 @@ snd_azf3328_interrupt(int irq, void *dev_id)
                 spin_lock(&chip->reg_lock);
                 snd_azf3328_ctrl_outb(chip, IDX_IO_TIMER_VALUE + 3, 0x07);
                 spin_unlock(&chip->reg_lock);
-                snd_azf3328_dbgcodec("azt3328: timer IRQ\n");
+                dev_dbg(chip->card->dev, "timer IRQ\n");
         }
 
         if (status & (IRQ_PLAYBACK|IRQ_RECORDING|IRQ_I2S_OUT))
-                snd_azf3328_pcm_interrupt(chip->codecs, status);
+                snd_azf3328_pcm_interrupt(chip, chip->codecs, status);
 
         if (status & IRQ_GAMEPORT)
                 snd_azf3328_gameport_interrupt(chip);
@@ -2055,7 +1975,7 @@ snd_azf3328_interrupt(int irq, void *dev_id)
 
                 /* hmm, do we have to ack the IRQ here somehow?
                  * If so, then I don't know how yet... */
-                snd_azf3328_dbgcodec("azt3328: MPU401 IRQ\n");
+                dev_dbg(chip->card->dev, "MPU401 IRQ\n");
         }
         return IRQ_HANDLED;
 }
@@ -2133,7 +2053,6 @@ snd_azf3328_pcm_open(struct snd_pcm_substream *substream,
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
 
-        snd_azf3328_dbgcallenter();
         codec->substream = substream;
 
         /* same parameters for all our codecs - at least we think so... */
@@ -2142,7 +2061,6 @@ snd_azf3328_pcm_open(struct snd_pcm_substream *substream,
         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
                                    &snd_azf3328_hw_constraints_rates);
         runtime->private_data = codec;
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -2171,9 +2089,7 @@ snd_azf3328_pcm_close(struct snd_pcm_substream *substream
         struct snd_azf3328_codec_data *codec =
                 substream->runtime->private_data;
 
-        snd_azf3328_dbgcallenter();
         codec->substream = NULL;
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -2220,8 +2136,6 @@ enum { AZF_PCMDEV_STD, AZF_PCMDEV_I2S_OUT, NUM_AZF_PCMDEVS }; /* pcm devices */
         struct snd_pcm *pcm;
         int err;
 
-        snd_azf3328_dbgcallenter();
-
         err = snd_pcm_new(chip->card, "AZF3328 DSP", AZF_PCMDEV_STD,
                                                                 1, 1, &pcm);
         if (err < 0)
@@ -2258,7 +2172,6 @@ enum { AZF_PCMDEV_STD, AZF_PCMDEV_I2S_OUT, NUM_AZF_PCMDEVS }; /* pcm devices */
                                                 snd_dma_pci_data(chip->pci),
                                                         64*1024, 64*1024);
 
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -2281,7 +2194,6 @@ snd_azf3328_timer_start(struct snd_timer *timer)
         unsigned long flags;
         unsigned int delay;
 
-        snd_azf3328_dbgcallenter();
         chip = snd_timer_chip(timer);
         delay = ((timer->sticks * seqtimer_scaling) - 1) & TIMER_VALUE_MASK;
         if (delay < 49) {
@@ -2289,15 +2201,14 @@ snd_azf3328_timer_start(struct snd_timer *timer)
                  * this timing tweak
                  * (we need to do it to avoid a lockup, though) */
 
-                snd_azf3328_dbgtimer("delay was too low (%d)!\n", delay);
+                dev_dbg(chip->card->dev, "delay was too low (%d)!\n", delay);
                 delay = 49; /* minimum time is 49 ticks */
         }
-        snd_azf3328_dbgtimer("setting timer countdown value %d\n", delay);
+        dev_dbg(chip->card->dev, "setting timer countdown value %d\n", delay);
         delay |= TIMER_COUNTDOWN_ENABLE | TIMER_IRQ_ENABLE;
         spin_lock_irqsave(&chip->reg_lock, flags);
         snd_azf3328_ctrl_outl(chip, IDX_IO_TIMER_VALUE, delay);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -2307,7 +2218,6 @@ snd_azf3328_timer_stop(struct snd_timer *timer)
         struct snd_azf3328 *chip;
         unsigned long flags;
 
-        snd_azf3328_dbgcallenter();
         chip = snd_timer_chip(timer);
         spin_lock_irqsave(&chip->reg_lock, flags);
         /* disable timer countdown and interrupt */
@@ -2319,7 +2229,6 @@ snd_azf3328_timer_stop(struct snd_timer *timer)
            the hardware/ALSA interrupt activity. */
         snd_azf3328_ctrl_outb(chip, IDX_IO_TIMER_VALUE + 3, 0x04);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -2328,10 +2237,8 @@ static int
 snd_azf3328_timer_precise_resolution(struct snd_timer *timer,
                                                unsigned long *num, unsigned long *den)
 {
-        snd_azf3328_dbgcallenter();
         *num = 1;
         *den = 1024000 / seqtimer_scaling;
-        snd_azf3328_dbgcallleave();
         return 0;
 }
 
@@ -2351,7 +2258,6 @@ snd_azf3328_timer(struct snd_azf3328 *chip, int device)
         struct snd_timer_id tid;
         int err;
 
-        snd_azf3328_dbgcallenter();
         tid.dev_class = SNDRV_TIMER_CLASS_CARD;
         tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
         tid.card = chip->card->number;
@@ -2376,7 +2282,6 @@ snd_azf3328_timer(struct snd_azf3328 *chip, int device)
         err = 0;
 
 out:
-        snd_azf3328_dbgcallleave();
         return err;
 }
 
@@ -2438,34 +2343,34 @@ snd_azf3328_test_bit(unsigned unsigned reg, int bit)
 static inline void
 snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip)
 {
-#if DEBUG_MISC
         u16 tmp;
 
-        snd_azf3328_dbgmisc(
+        dev_dbg(chip->card->dev,
                 "ctrl_io 0x%lx, game_io 0x%lx, mpu_io 0x%lx, "
                 "opl3_io 0x%lx, mixer_io 0x%lx, irq %d\n",
                 chip->ctrl_io, chip->game_io, chip->mpu_io,
-                chip->opl3_io, chip->mixer_io, chip->irq
-        );
+                chip->opl3_io, chip->mixer_io, chip->irq);
 
-        snd_azf3328_dbgmisc("game %02x %02x %02x %02x %02x %02x\n",
+        dev_dbg(chip->card->dev,
+                "game %02x %02x %02x %02x %02x %02x\n",
                 snd_azf3328_game_inb(chip, 0),
                 snd_azf3328_game_inb(chip, 1),
                 snd_azf3328_game_inb(chip, 2),
                 snd_azf3328_game_inb(chip, 3),
                 snd_azf3328_game_inb(chip, 4),
-                snd_azf3328_game_inb(chip, 5)
-        );
+                snd_azf3328_game_inb(chip, 5));
 
         for (tmp = 0; tmp < 0x07; tmp += 1)
-                snd_azf3328_dbgmisc("mpu_io 0x%04x\n", inb(chip->mpu_io + tmp));
+                dev_dbg(chip->card->dev,
+                        "mpu_io 0x%04x\n", inb(chip->mpu_io + tmp));
 
         for (tmp = 0; tmp <= 0x07; tmp += 1)
-                snd_azf3328_dbgmisc("0x%02x: game200 0x%04x, game208 0x%04x\n",
+                dev_dbg(chip->card->dev,
+                        "0x%02x: game200 0x%04x, game208 0x%04x\n",
                         tmp, inb(0x200 + tmp), inb(0x208 + tmp));
 
         for (tmp = 0; tmp <= 0x01; tmp += 1)
-                snd_azf3328_dbgmisc(
+                dev_dbg(chip->card->dev,
                         "0x%02x: mpu300 0x%04x, mpu310 0x%04x, mpu320 0x%04x, "
                         "mpu330 0x%04x opl388 0x%04x opl38c 0x%04x\n",
                                 tmp,
@@ -2474,19 +2379,17 @@ snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip)
                                 inb(0x320 + tmp),
                                 inb(0x330 + tmp),
                                 inb(0x388 + tmp),
-                                inb(0x38c + tmp)
-                );
+                                inb(0x38c + tmp));
 
         for (tmp = 0; tmp < AZF_IO_SIZE_CTRL; tmp += 2)
-                snd_azf3328_dbgmisc("ctrl 0x%02x: 0x%04x\n",
-                        tmp, snd_azf3328_ctrl_inw(chip, tmp)
-                );
+                dev_dbg(chip->card->dev,
+                        "ctrl 0x%02x: 0x%04x\n",
+                        tmp, snd_azf3328_ctrl_inw(chip, tmp));
 
         for (tmp = 0; tmp < AZF_IO_SIZE_MIXER; tmp += 2)
-                snd_azf3328_dbgmisc("mixer 0x%02x: 0x%04x\n",
-                        tmp, snd_azf3328_mixer_inw(chip, tmp)
-                );
-#endif /* DEBUG_MISC */
+                dev_dbg(chip->card->dev,
+                        "mixer 0x%02x: 0x%04x\n",
+                        tmp, snd_azf3328_mixer_inw(chip, tmp));
 }
 
 static int
@@ -2523,8 +2426,8 @@ snd_azf3328_create(struct snd_card *card,
         /* check if we can restrict PCI DMA transfers to 24 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support "
-                                        "24bit PCI busmaster DMA\n"
+                dev_err(card->dev,
+                        "architecture does not support 24bit PCI busmaster DMA\n"
                 );
                 err = -ENXIO;
                 goto out_err;
@@ -2560,7 +2463,7 @@ snd_azf3328_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_azf3328_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 err = -EBUSY;
                 goto out_err;
         }
@@ -2622,7 +2525,6 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
         struct snd_opl3 *opl3;
         int err;
 
-        snd_azf3328_dbgcallenter();
         if (dev >= SNDRV_CARDS) {
                 err = -ENODEV;
                 goto out;
@@ -2656,7 +2558,7 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
                 -1, &chip->rmidi
         );
         if (err < 0) {
-                snd_printk(KERN_ERR "azf3328: no MPU-401 device at 0x%lx?\n",
+                dev_err(card->dev, "no MPU-401 device at 0x%lx?\n",
                                 chip->mpu_io
                 );
                 goto out_err;
@@ -2672,7 +2574,7 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
 
         if (snd_opl3_create(card, chip->opl3_io, chip->opl3_io+2,
                             OPL3_HW_AUTO, 1, &opl3) < 0) {
-                snd_printk(KERN_ERR "azf3328: no OPL3 device at 0x%lx-0x%lx?\n",
+                dev_err(card->dev, "no OPL3 device at 0x%lx-0x%lx?\n",
                            chip->opl3_io, chip->opl3_io+2
                 );
         } else {
@@ -2694,12 +2596,15 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
                 goto out_err;
 
 #ifdef MODULE
-        printk(KERN_INFO
-"azt3328: Sound driver for Aztech AZF3328-based soundcards such as PCI168.\n"
-"azt3328: Hardware was completely undocumented, unfortunately.\n"
-"azt3328: Feel free to contact andi AT lisas.de for bug reports etc.!\n"
-"azt3328: User-scalable sequencer timer set to %dHz (1024000Hz / %d).\n",
-        1024000 / seqtimer_scaling, seqtimer_scaling);
+        dev_info(card->dev,
+                 "Sound driver for Aztech AZF3328-based soundcards such as PCI168.\n");
+        dev_info(card->dev,
+                 "Hardware was completely undocumented, unfortunately.\n");
+        dev_info(card->dev,
+                 "Feel free to contact andi AT lisas.de for bug reports etc.!\n");
+        dev_info(card->dev,
+                 "User-scalable sequencer timer set to %dHz (1024000Hz / %d).\n",
+                 1024000 / seqtimer_scaling, seqtimer_scaling);
 #endif
 
         snd_azf3328_gameport(chip, dev);
@@ -2711,31 +2616,29 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
         goto out;
 
 out_err:
-        snd_printk(KERN_ERR "azf3328: something failed, exiting\n");
+        dev_err(card->dev, "something failed, exiting\n");
         snd_card_free(card);
 
 out:
-        snd_azf3328_dbgcallleave();
         return err;
 }
 
 static void
 snd_azf3328_remove(struct pci_dev *pci)
 {
-        snd_azf3328_dbgcallenter();
         snd_card_free(pci_get_drvdata(pci));
-        snd_azf3328_dbgcallleave();
 }
 
 #ifdef CONFIG_PM_SLEEP
 static inline void
-snd_azf3328_suspend_regs(unsigned long io_addr, unsigned count, u32 *saved_regs)
+snd_azf3328_suspend_regs(const struct snd_azf3328 *chip,
+                         unsigned long io_addr, unsigned count, u32 *saved_regs)
 {
         unsigned reg;
 
         for (reg = 0; reg < count; ++reg) {
                 *saved_regs = inl(io_addr);
-                snd_azf3328_dbgpm("suspend: io 0x%04lx: 0x%08x\n",
+                dev_dbg(chip->card->dev, "suspend: io 0x%04lx: 0x%08x\n",
                         io_addr, *saved_regs);
                 ++saved_regs;
                 io_addr += sizeof(*saved_regs);
@@ -2743,7 +2646,8 @@ snd_azf3328_suspend_regs(unsigned long io_addr, unsigned count, u32 *saved_regs)
 }
 
 static inline void
-snd_azf3328_resume_regs(const u32 *saved_regs,
+snd_azf3328_resume_regs(const struct snd_azf3328 *chip,
+                        const u32 *saved_regs,
                         unsigned long io_addr,
                         unsigned count
 )
@@ -2752,7 +2656,8 @@ snd_azf3328_resume_regs(const u32 *saved_regs,
 
         for (reg = 0; reg < count; ++reg) {
                 outl(*saved_regs, io_addr);
-                snd_azf3328_dbgpm("resume: io 0x%04lx: 0x%08x --> 0x%08x\n",
+                dev_dbg(chip->card->dev,
+                        "resume: io 0x%04lx: 0x%08x --> 0x%08x\n",
                         io_addr, *saved_regs, inl(io_addr));
                 ++saved_regs;
                 io_addr += sizeof(*saved_regs);
@@ -2765,7 +2670,7 @@ snd_azf3328_suspend_ac97(struct snd_azf3328 *chip)
 #ifdef AZF_USE_AC97_LAYER
         snd_ac97_suspend(chip->ac97);
 #else
-        snd_azf3328_suspend_regs(chip->mixer_io,
+        snd_azf3328_suspend_regs(chip, chip->mixer_io,
                 ARRAY_SIZE(chip->saved_regs_mixer), chip->saved_regs_mixer);
 
         /* make sure to disable master volume etc. to prevent looping sound */
@@ -2780,7 +2685,7 @@ snd_azf3328_resume_ac97(const struct snd_azf3328 *chip)
 #ifdef AZF_USE_AC97_LAYER
         snd_ac97_resume(chip->ac97);
 #else
-        snd_azf3328_resume_regs(chip->saved_regs_mixer, chip->mixer_io,
+        snd_azf3328_resume_regs(chip, chip->saved_regs_mixer, chip->mixer_io,
                                         ARRAY_SIZE(chip->saved_regs_mixer));
 
         /* unfortunately with 32bit transfers, IDX_MIXER_PLAY_MASTER (0x02)
@@ -2807,18 +2712,18 @@ snd_azf3328_suspend(struct device *dev)
 
         snd_azf3328_suspend_ac97(chip);
 
-        snd_azf3328_suspend_regs(chip->ctrl_io,
+        snd_azf3328_suspend_regs(chip, chip->ctrl_io,
                 ARRAY_SIZE(chip->saved_regs_ctrl), chip->saved_regs_ctrl);
 
         /* manually store the one currently relevant write-only reg, too */
         saved_regs_ctrl_u16 = (u16 *)chip->saved_regs_ctrl;
         saved_regs_ctrl_u16[IDX_IO_6AH / 2] = chip->shadow_reg_ctrl_6AH;
 
-        snd_azf3328_suspend_regs(chip->game_io,
+        snd_azf3328_suspend_regs(chip, chip->game_io,
                 ARRAY_SIZE(chip->saved_regs_game), chip->saved_regs_game);
-        snd_azf3328_suspend_regs(chip->mpu_io,
+        snd_azf3328_suspend_regs(chip, chip->mpu_io,
                 ARRAY_SIZE(chip->saved_regs_mpu), chip->saved_regs_mpu);
-        snd_azf3328_suspend_regs(chip->opl3_io,
+        snd_azf3328_suspend_regs(chip, chip->opl3_io,
                 ARRAY_SIZE(chip->saved_regs_opl3), chip->saved_regs_opl3);
 
         pci_disable_device(pci);
@@ -2837,23 +2742,22 @@ snd_azf3328_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "azt3328: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
         pci_set_master(pci);
 
-        snd_azf3328_resume_regs(chip->saved_regs_game, chip->game_io,
+        snd_azf3328_resume_regs(chip, chip->saved_regs_game, chip->game_io,
                                         ARRAY_SIZE(chip->saved_regs_game));
-        snd_azf3328_resume_regs(chip->saved_regs_mpu, chip->mpu_io,
+        snd_azf3328_resume_regs(chip, chip->saved_regs_mpu, chip->mpu_io,
                                         ARRAY_SIZE(chip->saved_regs_mpu));
-        snd_azf3328_resume_regs(chip->saved_regs_opl3, chip->opl3_io,
+        snd_azf3328_resume_regs(chip, chip->saved_regs_opl3, chip->opl3_io,
                                         ARRAY_SIZE(chip->saved_regs_opl3));
 
         snd_azf3328_resume_ac97(chip);
 
-        snd_azf3328_resume_regs(chip->saved_regs_ctrl, chip->ctrl_io,
+        snd_azf3328_resume_regs(chip, chip->saved_regs_ctrl, chip->ctrl_io,
                                         ARRAY_SIZE(chip->saved_regs_ctrl));
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index 06dc7d97cc0c..8546711d12f9 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -293,17 +293,23 @@ static void snd_bt87x_pci_error(struct snd_bt87x *chip, unsigned int status)
                 PCI_STATUS_SIG_SYSTEM_ERROR | PCI_STATUS_DETECTED_PARITY;
         pci_write_config_word(chip->pci, PCI_STATUS, pci_status);
         if (pci_status != PCI_STATUS_DETECTED_PARITY)
-                snd_printk(KERN_ERR "Aieee - PCI error! status %#08x, PCI status %#04x\n",
+                dev_err(chip->card->dev,
+                        "Aieee - PCI error! status %#08x, PCI status %#04x\n",
                            status & ERROR_INTERRUPTS, pci_status);
         else {
-                snd_printk(KERN_ERR "Aieee - PCI parity error detected!\n");
+                dev_err(chip->card->dev,
+                        "Aieee - PCI parity error detected!\n");
                 /* error 'handling' similar to aic7xxx_pci.c: */
                 chip->pci_parity_errors++;
                 if (chip->pci_parity_errors > 20) {
-                        snd_printk(KERN_ERR "Too many PCI parity errors observed.\n");
-                        snd_printk(KERN_ERR "Some device on this bus is generating bad parity.\n");
-                        snd_printk(KERN_ERR "This is an error *observed by*, not *generated by*, this card.\n");
-                        snd_printk(KERN_ERR "PCI parity error checking has been disabled.\n");
+                        dev_err(chip->card->dev,
+                                "Too many PCI parity errors observed.\n");
+                        dev_err(chip->card->dev,
+                                "Some device on this bus is generating bad parity.\n");
+                        dev_err(chip->card->dev,
+                                "This is an error *observed by*, not *generated by*, this card.\n");
+                        dev_err(chip->card->dev,
+                                "PCI parity error checking has been disabled.\n");
                         chip->interrupt_mask &= ~(INT_PPERR | INT_RIPERR);
                         snd_bt87x_writel(chip, REG_INT_MASK, chip->interrupt_mask);
                 }
@@ -323,9 +329,11 @@ static irqreturn_t snd_bt87x_interrupt(int irq, void *dev_id)
 
         if (irq_status & ERROR_INTERRUPTS) {
                 if (irq_status & (INT_FBUS | INT_FTRGT))
-                        snd_printk(KERN_WARNING "FIFO overrun, status %#08x\n", status);
+                        dev_warn(chip->card->dev,
+                                 "FIFO overrun, status %#08x\n", status);
                 if (irq_status & INT_OCERR)
-                        snd_printk(KERN_ERR "internal RISC error, status %#08x\n", status);
+                        dev_err(chip->card->dev,
+                                "internal RISC error, status %#08x\n", status);
                 if (irq_status & (INT_PPERR | INT_RIPERR | INT_PABORT))
                         snd_bt87x_pci_error(chip, irq_status);
         }
@@ -747,7 +755,7 @@ static int snd_bt87x_create(struct snd_card *card,
         }
         chip->mmio = pci_ioremap_bar(pci, 0);
         if (!chip->mmio) {
-                snd_printk(KERN_ERR "cannot remap io memory\n");
+                dev_err(card->dev, "cannot remap io memory\n");
                 err = -ENOMEM;
                 goto fail;
         }
@@ -762,7 +770,7 @@ static int snd_bt87x_create(struct snd_card *card,
         err = request_irq(pci->irq, snd_bt87x_interrupt, IRQF_SHARED,
                           KBUILD_MODNAME, chip);
         if (err < 0) {
-                snd_printk(KERN_ERR "cannot grab irq %d\n", pci->irq);
+                dev_err(card->dev, "cannot grab irq %d\n", pci->irq);
                 goto fail;
         }
         chip->irq = pci->irq;
@@ -850,14 +858,15 @@ static int snd_bt87x_detect_card(struct pci_dev *pci)
         for (i = 0; i < ARRAY_SIZE(blacklist); ++i)
                 if (blacklist[i].subvendor == pci->subsystem_vendor &&
                     blacklist[i].subdevice == pci->subsystem_device) {
-                        snd_printdd(KERN_INFO "card %#04x-%#04x:%#04x has no audio\n",
+                        dev_dbg(&pci->dev,
+                                "card %#04x-%#04x:%#04x has no audio\n",
                                     pci->device, pci->subsystem_vendor, pci->subsystem_device);
                         return -EBUSY;
                 }
 
-        snd_printk(KERN_INFO "unknown card %#04x-%#04x:%#04x\n",
+        dev_info(&pci->dev, "unknown card %#04x-%#04x:%#04x\n",
                    pci->device, pci->subsystem_vendor, pci->subsystem_device);
-        snd_printk(KERN_DEBUG "please mail id, board name, and, "
+        dev_info(&pci->dev, "please mail id, board name, and, "
                    "if it works, the correct digital_rate option to "
                    "<alsa-devel@alsa-project.org>\n");
         return SND_BT87X_BOARD_UNKNOWN;
@@ -925,7 +934,7 @@ static int snd_bt87x_probe(struct pci_dev *pci,
                 if (err < 0)
                         goto _error;
         }
-        snd_printk(KERN_INFO "bt87x%d: Using board %d, %sanalog, %sdigital "
+        dev_info(card->dev, "bt87x%d: Using board %d, %sanalog, %sdigital "
                    "(rate %d Hz)\n", dev, boardid,
                    chip->board.no_analog ? "no " : "",
                    chip->board.no_digital ? "no " : "", chip->board.dig_rate);
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index f659c7a89c0c..f94cc6e97d4a 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -417,13 +417,13 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
         int status;
         int retry;
         if ((reg > 0x7f) || (value > 0x1ff)) {
-                snd_printk(KERN_ERR "i2c_write: invalid values.\n");
+                dev_err(emu->card->dev, "i2c_write: invalid values.\n");
                 return -EINVAL;
         }
 
         tmp = reg << 25 | value << 16;
         /*
-        snd_printk(KERN_DEBUG "I2C-write:reg=0x%x, value=0x%x\n", reg, value);
+        dev_dbg(emu->card->dev, "I2C-write:reg=0x%x, value=0x%x\n", reg, value);
         */
         /* Not sure what this I2C channel controls. */
         /* snd_ca0106_ptr_write(emu, I2C_D0, 0, tmp); */
@@ -442,7 +442,7 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
                 /* Wait till the transaction ends */
                 while (1) {
                         status = snd_ca0106_ptr_read(emu, I2C_A, 0);
-                        /*snd_printk(KERN_DEBUG "I2C:status=0x%x\n", status);*/
+                        /*dev_dbg(emu->card->dev, "I2C:status=0x%x\n", status);*/
                         timeout++;
                         if ((status & I2C_A_ADC_START) == 0)
                                 break;
@@ -456,7 +456,7 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
         }
 
         if (retry == 10) {
-                snd_printk(KERN_ERR "Writing to ADC failed!\n");
+                dev_err(emu->card->dev, "Writing to ADC failed!\n");
                 return -EINVAL;
         }
     
@@ -516,7 +516,8 @@ static void restore_spdif_bits(struct snd_ca0106 *chip, int idx)
         }
 }
 
-static int snd_ca0106_channel_dac(struct snd_ca0106_details *details,
+static int snd_ca0106_channel_dac(struct snd_ca0106 *chip,
+                                  struct snd_ca0106_details *details,
                                   int channel_id)
 {
         switch (channel_id) {
@@ -529,7 +530,7 @@ static int snd_ca0106_channel_dac(struct snd_ca0106_details *details,
         case PCM_UNKNOWN_CHANNEL:
                 return (details->spi_dac & 0x000f) >> (4 * 0);
         default:
-                snd_printk(KERN_DEBUG "ca0106: unknown channel_id %d\n",
+                dev_dbg(chip->card->dev, "ca0106: unknown channel_id %d\n",
                            channel_id);
         }
         return 0;
@@ -539,7 +540,7 @@ static int snd_ca0106_pcm_power_dac(struct snd_ca0106 *chip, int channel_id,
                                     int power)
 {
         if (chip->details->spi_dac) {
-                const int dac = snd_ca0106_channel_dac(chip->details,
+                const int dac = snd_ca0106_channel_dac(chip, chip->details,
                                                        channel_id);
                 const int reg = spi_dacd_reg[dac];
                 const int bit = spi_dacd_bit[dac];
@@ -583,7 +584,7 @@ static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substr
 
         channel->use = 1;
         /*
-        printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
+        dev_dbg(chip->card->dev, "open:channel_id=%d, chip=%p, channel=%p\n",
                channel_id, chip, channel);
         */
         //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
@@ -660,7 +661,8 @@ static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substre
 
         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
         if (epcm == NULL) {
-                snd_printk(KERN_ERR "open_capture_channel: failed epcm alloc\n");
+                dev_err(chip->card->dev,
+                        "open_capture_channel: failed epcm alloc\n");
                 return -ENOMEM;
         }
         epcm->emu = chip;
@@ -677,7 +679,7 @@ static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substre
 
         channel->use = 1;
         /*
-        printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
+        dev_dbg(chip->card->dev, "open:channel_id=%d, chip=%p, channel=%p\n",
                channel_id, chip, channel);
         */
         //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
@@ -771,7 +773,7 @@ static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream)
         int i;
         
 #if 0 /* debug */
-        snd_printk(KERN_DEBUG
+        dev_dbg(emu->card->dev,
                    "prepare:channel_number=%d, rate=%d, format=0x%x, "
                    "channels=%d, buffer_size=%ld, period_size=%ld, "
                    "periods=%u, frames_to_bytes=%d\n",
@@ -779,9 +781,11 @@ static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream)
                    runtime->channels, runtime->buffer_size,
                    runtime->period_size, runtime->periods,
                    frames_to_bytes(runtime, 1));
-        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
+        dev_dbg(emu->card->dev,
+                "dma_addr=%x, dma_area=%p, table_base=%p\n",
                    runtime->dma_addr, runtime->dma_area, table_base);
-        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
+        dev_dbg(emu->card->dev,
+                "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
                    emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
 #endif /* debug */
         /* Rate can be set per channel. */
@@ -876,7 +880,7 @@ static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
         u32 reg71;
         
 #if 0 /* debug */
-        snd_printk(KERN_DEBUG
+        dev_dbg(emu->card->dev,
                    "prepare:channel_number=%d, rate=%d, format=0x%x, "
                    "channels=%d, buffer_size=%ld, period_size=%ld, "
                    "periods=%u, frames_to_bytes=%d\n",
@@ -884,9 +888,11 @@ static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
                    runtime->channels, runtime->buffer_size,
                    runtime->period_size, runtime->periods,
                    frames_to_bytes(runtime, 1));
-        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
+        dev_dbg(emu->card->dev,
+                "dma_addr=%x, dma_area=%p, table_base=%p\n",
                    runtime->dma_addr, runtime->dma_area, table_base);
-        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
+        dev_dbg(emu->card->dev,
+                "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
                    emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
 #endif /* debug */
         /* reg71 controls ADC rate. */
@@ -934,7 +940,7 @@ static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
 
 
         /*
-        printk(KERN_DEBUG
+        dev_dbg(emu->card->dev,
                "prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, "
                "buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",
                channel, runtime->rate, runtime->format, runtime->channels,
@@ -982,13 +988,13 @@ static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream,
                 runtime = s->runtime;
                 epcm = runtime->private_data;
                 channel = epcm->channel_id;
-                /* snd_printk(KERN_DEBUG "channel=%d\n", channel); */
+                /* dev_dbg(emu->card->dev, "channel=%d\n", channel); */
                 epcm->running = running;
                 basic |= (0x1 << channel);
                 extended |= (0x10 << channel);
                 snd_pcm_trigger_done(s, substream);
         }
-        /* snd_printk(KERN_DEBUG "basic=0x%x, extended=0x%x\n",basic, extended); */
+        /* dev_dbg(emu->card->dev, "basic=0x%x, extended=0x%x\n",basic, extended); */
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -1070,7 +1076,7 @@ snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
                         return ptr;
                 prev_ptr = ptr;
         } while (--timeout);
-        snd_printk(KERN_WARNING "ca0106: unstable DMA pointer!\n");
+        dev_warn(emu->card->dev, "ca0106: unstable DMA pointer!\n");
         return 0;
 }
 
@@ -1093,7 +1099,7 @@ snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream)
         if (ptr >= runtime->buffer_size)
                 ptr -= runtime->buffer_size;
         /*
-        printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
+        dev_dbg(emu->card->dev, "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
                "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
                ptr1, ptr2, ptr, (int)runtime->buffer_size,
                (int)runtime->period_size, (int)runtime->frame_bits,
@@ -1284,9 +1290,9 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
 
         stat76 = snd_ca0106_ptr_read(chip, EXTENDED_INT, 0);
         /*
-        snd_printk(KERN_DEBUG "interrupt status = 0x%08x, stat76=0x%08x\n",
+        dev_dbg(emu->card->dev, "interrupt status = 0x%08x, stat76=0x%08x\n",
                    status, stat76);
-        snd_printk(KERN_DEBUG "ptr=0x%08x\n",
+        dev_dbg(emu->card->dev, "ptr=0x%08x\n",
                    snd_ca0106_ptr_read(chip, PLAYBACK_POINTER, 0));
         */
         mask = 0x11; /* 0x1 for one half, 0x10 for the other half period. */
@@ -1296,11 +1302,13 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
 /* FIXME: Select the correct substream for period elapsed */
                         if(pchannel->use) {
                                 snd_pcm_period_elapsed(pchannel->epcm->substream);
-                                //printk(KERN_INFO "interrupt [%d] used\n", i);
+                                /* dev_dbg(emu->card->dev, "interrupt [%d] used\n", i); */
                         }
                 }
-                //printk(KERN_INFO "channel=%p\n",pchannel);
-                //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
+                /*
+                dev_dbg(emu->card->dev, "channel=%p\n", pchannel);
+                dev_dbg(emu->card->dev, "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
+                */
                 mask <<= 1;
         }
         mask = 0x110000; /* 0x1 for one half, 0x10 for the other half period. */
@@ -1310,11 +1318,13 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
 /* FIXME: Select the correct substream for period elapsed */
                         if(pchannel->use) {
                                 snd_pcm_period_elapsed(pchannel->epcm->substream);
-                                //printk(KERN_INFO "interrupt [%d] used\n", i);
+                                /* dev_dbg(emu->card->dev, "interrupt [%d] used\n", i); */
                         }
                 }
-                //printk(KERN_INFO "channel=%p\n",pchannel);
-                //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
+                /*
+                dev_dbg(emu->card->dev, "channel=%p\n", pchannel);
+                dev_dbg(emu->card->dev, "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
+                */
                 mask <<= 1;
         }
 
@@ -1603,7 +1613,7 @@ static void ca0106_init_chip(struct snd_ca0106 *chip, int resume)
                 int size, n;
 
                 size = ARRAY_SIZE(i2c_adc_init);
-                /* snd_printk(KERN_DEBUG "I2C:array size=0x%x\n", size); */
+                /* dev_dbg(emu->card->dev, "I2C:array size=0x%x\n", size); */
                 for (n = 0; n < size; n++)
                         snd_ca0106_i2c_write(chip, i2c_adc_init[n][0],
                                              i2c_adc_init[n][1]);
@@ -1668,7 +1678,7 @@ static int snd_ca0106_create(int dev, struct snd_card *card,
                 return err;
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
-                printk(KERN_ERR "error to set 32bit mask DMA\n");
+                dev_err(card->dev, "error to set 32bit mask DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -1689,14 +1699,14 @@ static int snd_ca0106_create(int dev, struct snd_card *card,
         chip->res_port = request_region(chip->port, 0x20, "snd_ca0106");
         if (!chip->res_port) {
                 snd_ca0106_free(chip);
-                printk(KERN_ERR "cannot allocate the port\n");
+                dev_err(card->dev, "cannot allocate the port\n");
                 return -EBUSY;
         }
 
         if (request_irq(pci->irq, snd_ca0106_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
                 snd_ca0106_free(chip);
-                printk(KERN_ERR "cannot grab irq\n");
+                dev_err(card->dev, "cannot grab irq\n");
                 return -EBUSY;
         }
         chip->irq = pci->irq;
@@ -1712,7 +1722,7 @@ static int snd_ca0106_create(int dev, struct snd_card *card,
         /* read serial */
         pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
         pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
-        printk(KERN_INFO "snd-ca0106: Model %04x Rev %08x Serial %08x\n",
+        dev_info(card->dev, "Model %04x Rev %08x Serial %08x\n",
                chip->model, pci->revision, chip->serial);
         strcpy(card->driver, "CA0106");
         strcpy(card->shortname, "CA0106");
@@ -1726,7 +1736,7 @@ static int snd_ca0106_create(int dev, struct snd_card *card,
         }
         chip->details = c;
         if (subsystem[dev]) {
-                printk(KERN_INFO "snd-ca0106: Sound card name=%s, "
+                dev_info(card->dev, "Sound card name=%s, "
                        "subsystem=0x%x. Forced to subsystem=0x%x\n",
                        c->name, chip->serial, subsystem[dev]);
         }
@@ -1869,11 +1879,11 @@ static int snd_ca0106_probe(struct pci_dev *pci,
         if (err < 0)
                 goto error;
 
-        snd_printdd("ca0106: probe for MIDI channel A ...");
+        dev_dbg(card->dev, "probe for MIDI channel A ...");
         err = snd_ca0106_midi(chip, CA0106_MIDI_CHAN_A);
         if (err < 0)
                 goto error;
-        snd_printdd(" done.\n");
+        dev_dbg(card->dev, " done.\n");
 
 #ifdef CONFIG_PROC_FS
         snd_ca0106_proc_init(chip);
diff --git a/sound/pci/ca0106/ca_midi.c b/sound/pci/ca0106/ca_midi.c
index 8bbdf265d11d..b91c7f6d19f9 100644
--- a/sound/pci/ca0106/ca_midi.c
+++ b/sound/pci/ca0106/ca_midi.c
@@ -46,7 +46,7 @@ static void ca_midi_clear_rx(struct snd_ca_midi *midi)
                 ca_midi_read_data(midi);
 #ifdef CONFIG_SND_DEBUG
         if (timeout <= 0)
-                snd_printk(KERN_ERR "ca_midi_clear_rx: timeout (status = 0x%x)\n",
+                pr_err("ca_midi_clear_rx: timeout (status = 0x%x)\n",
                            ca_midi_read_stat(midi));
 #endif
 }
@@ -113,7 +113,7 @@ static void ca_midi_cmd(struct snd_ca_midi *midi, unsigned char cmd, int ack)
         }
         spin_unlock_irqrestore(&midi->input_lock, flags);
         if (!ok)
-                snd_printk(KERN_ERR "ca_midi_cmd: 0x%x failed at 0x%x (status = 0x%x, data = 0x%x)!!!\n",
+                pr_err("ca_midi_cmd: 0x%x failed at 0x%x (status = 0x%x, data = 0x%x)!!!\n",
                            cmd,
                            midi->get_dev_id_port(midi->dev_id),
                            ca_midi_read_stat(midi),
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index 66c0558ce449..12c318e175f4 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -796,7 +796,7 @@ static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec,
         if (runtime->channels > 1)
                 rec->fmt |= 0x01;
         if (rec->is_dac && set_dac_channels(cm, rec, runtime->channels) < 0) {
-                snd_printd("cannot set dac channels\n");
+                dev_dbg(cm->card->dev, "cannot set dac channels\n");
                 return -EINVAL;
         }
 
@@ -827,7 +827,7 @@ static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec,
         else
                 cm->ctrl |= val;
         snd_cmipci_write(cm, CM_REG_FUNCTRL0, cm->ctrl);
-        //snd_printd("cmipci: functrl0 = %08x\n", cm->ctrl);
+        /* dev_dbg(cm->card->dev, "functrl0 = %08x\n", cm->ctrl); */
 
         /* set sample rate */
         freq = 0;
@@ -850,7 +850,7 @@ static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec,
                 val |= (freq << CM_ASFC_SHIFT) & CM_ASFC_MASK;
         }
         snd_cmipci_write(cm, CM_REG_FUNCTRL1, val);
-        //snd_printd("cmipci: functrl1 = %08x\n", val);
+        dev_dbg(cm->card->dev, "functrl1 = %08x\n", val);
 
         /* set format */
         val = snd_cmipci_read(cm, CM_REG_CHFORMAT);
@@ -866,7 +866,7 @@ static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec,
                 val |= freq_ext << (rec->ch * 2);
         }
         snd_cmipci_write(cm, CM_REG_CHFORMAT, val);
-        //snd_printd("cmipci: chformat = %08x\n", val);
+        dev_dbg(cm->card->dev, "chformat = %08x\n", val);
 
         if (!rec->is_dac && cm->chip_version) {
                 if (runtime->rate > 44100)
@@ -904,7 +904,7 @@ static int snd_cmipci_pcm_trigger(struct cmipci *cm, struct cmipci_pcm *rec,
                 cm->ctrl |= chen;
                 /* enable channel */
                 snd_cmipci_write(cm, CM_REG_FUNCTRL0, cm->ctrl);
-                //snd_printd("cmipci: functrl0 = %08x\n", cm->ctrl);
+                dev_dbg(cm->card->dev, "functrl0 = %08x\n", cm->ctrl);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
                 rec->running = 0;
@@ -952,7 +952,7 @@ static snd_pcm_uframes_t snd_cmipci_pcm_pointer(struct cmipci *cm, struct cmipci
                 if (rem < rec->dma_size)
                         goto ok;
         } 
-        printk(KERN_ERR "cmipci: invalid PCM pointer: %#x\n", rem);
+        dev_err(cm->card->dev, "invalid PCM pointer: %#x\n", rem);
         return SNDRV_PCM_POS_XRUN;
 ok:
         ptr = (rec->dma_size - (rem + 1)) >> rec->shift;
@@ -2889,13 +2889,13 @@ static int snd_cmipci_create_gameport(struct cmipci *cm, int dev)
         }
 
         if (!r) {
-                printk(KERN_WARNING "cmipci: cannot reserve joystick ports\n");
+                dev_warn(cm->card->dev, "cannot reserve joystick ports\n");
                 return -EBUSY;
         }
 
         cm->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "cmipci: cannot allocate memory for gameport\n");
+                dev_err(cm->card->dev, "cannot allocate memory for gameport\n");
                 release_and_free_resource(r);
                 return -ENOMEM;
         }
@@ -2995,13 +2995,14 @@ static int snd_cmipci_create_fm(struct cmipci *cm, long fm_port)
 
                 if (snd_opl3_create(cm->card, iosynth, iosynth + 2,
                                     OPL3_HW_OPL3, 0, &opl3) < 0) {
-                        printk(KERN_ERR "cmipci: no OPL device at %#lx, "
-                               "skipping...\n", iosynth);
+                        dev_err(cm->card->dev,
+                                "no OPL device at %#lx, skipping...\n",
+                                iosynth);
                         goto disable_fm;
                 }
         }
         if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
-                printk(KERN_ERR "cmipci: cannot create OPL3 hwdep\n");
+                dev_err(cm->card->dev, "cannot create OPL3 hwdep\n");
                 return err;
         }
         return 0;
@@ -3060,7 +3061,7 @@ static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci,
 
         if (request_irq(pci->irq, snd_cmipci_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, cm)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_cmipci_free(cm);
                 return -EBUSY;
         }
@@ -3192,8 +3193,9 @@ static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci,
                         /* enable UART */
                         snd_cmipci_set_bit(cm, CM_REG_FUNCTRL1, CM_UART_EN);
                         if (inb(iomidi + 1) == 0xff) {
-                                snd_printk(KERN_ERR "cannot enable MPU-401 port"
-                                           " at %#lx\n", iomidi);
+                                dev_err(cm->card->dev,
+                                        "cannot enable MPU-401 port at %#lx\n",
+                                        iomidi);
                                 snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1,
                                                      CM_UART_EN);
                                 iomidi = 0;
@@ -3237,7 +3239,8 @@ static int snd_cmipci_create(struct snd_card *card, struct pci_dev *pci,
                                                 MPU401_INFO_INTEGRATED : 0) |
                                                MPU401_INFO_IRQ_HOOK,
                                                -1, &cm->rmidi)) < 0) {
-                        printk(KERN_ERR "cmipci: no UART401 device at 0x%lx\n", iomidi);
+                        dev_err(cm->card->dev,
+                                "no UART401 device at 0x%lx\n", iomidi);
                 }
         }
 
@@ -3380,8 +3383,7 @@ static int snd_cmipci_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "cmipci: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index 2bd55177b1ae..43d1f912c641 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -564,7 +564,8 @@ static void snd_cs4281_ac97_write(struct snd_ac97 *ac97,
                         return;
                 }
         }
-        snd_printk(KERN_ERR "AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val);
+        dev_err(chip->card->dev,
+                "AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val);
 }
 
 static unsigned short snd_cs4281_ac97_read(struct snd_ac97 *ac97,
@@ -624,7 +625,8 @@ static unsigned short snd_cs4281_ac97_read(struct snd_ac97 *ac97,
                         goto __ok1;
         }
 
-        snd_printk(KERN_ERR "AC'97 read problem (ACCTL_DCV), reg = 0x%x\n", reg);
+        dev_err(chip->card->dev,
+                "AC'97 read problem (ACCTL_DCV), reg = 0x%x\n", reg);
         result = 0xffff;
         goto __end;
         
@@ -643,7 +645,8 @@ static unsigned short snd_cs4281_ac97_read(struct snd_ac97 *ac97,
                 udelay(10);
         }
         
-        snd_printk(KERN_ERR "AC'97 read problem (ACSTS_VSTS), reg = 0x%x\n", reg);
+        dev_err(chip->card->dev,
+                "AC'97 read problem (ACSTS_VSTS), reg = 0x%x\n", reg);
         result = 0xffff;
         goto __end;
 
@@ -835,8 +838,9 @@ static snd_pcm_uframes_t snd_cs4281_pointer(struct snd_pcm_substream *substream)
         struct cs4281 *chip = snd_pcm_substream_chip(substream);
 
         /*
-        printk(KERN_DEBUG "DCC = 0x%x, buffer_size = 0x%x, jiffies = %li\n",
-               snd_cs4281_peekBA0(chip, dma->regDCC), runtime->buffer_size,
+        dev_dbg(chip->card->dev,
+                "DCC = 0x%x, buffer_size = 0x%x, jiffies = %li\n",
+                snd_cs4281_peekBA0(chip, dma->regDCC), runtime->buffer_size,
                jiffies);
         */
         return runtime->buffer_size -
@@ -1265,7 +1269,8 @@ static int snd_cs4281_create_gameport(struct cs4281 *chip)
 
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "cs4281: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
 
@@ -1361,7 +1366,7 @@ static int snd_cs4281_create(struct snd_card *card,
         chip->irq = -1;
         pci_set_master(pci);
         if (dual_codec < 0 || dual_codec > 3) {
-                snd_printk(KERN_ERR "invalid dual_codec option %d\n", dual_codec);
+                dev_err(card->dev, "invalid dual_codec option %d\n", dual_codec);
                 dual_codec = 0;
         }
         chip->dual_codec = dual_codec;
@@ -1383,7 +1388,7 @@ static int snd_cs4281_create(struct snd_card *card,
         
         if (request_irq(pci->irq, snd_cs4281_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_cs4281_free(chip);
                 return -ENOMEM;
         }
@@ -1423,7 +1428,8 @@ static int snd_cs4281_chip_init(struct cs4281 *chip)
                 snd_cs4281_pokeBA0(chip, BA0_CFLR, BA0_CFLR_DEFAULT);
                 tmp = snd_cs4281_peekBA0(chip, BA0_CFLR);
                 if (tmp != BA0_CFLR_DEFAULT) {
-                        snd_printk(KERN_ERR "CFLR setup failed (0x%x)\n", tmp);
+                        dev_err(chip->card->dev,
+                                "CFLR setup failed (0x%x)\n", tmp);
                         return -EIO;
                 }
         }
@@ -1434,11 +1440,13 @@ static int snd_cs4281_chip_init(struct cs4281 *chip)
         snd_cs4281_pokeBA0(chip, BA0_CWPR, 0x4281);
         
         if ((tmp = snd_cs4281_peekBA0(chip, BA0_SERC1)) != (BA0_SERC1_SO1EN | BA0_SERC1_AC97)) {
-                snd_printk(KERN_ERR "SERC1 AC'97 check failed (0x%x)\n", tmp);
+                dev_err(chip->card->dev,
+                        "SERC1 AC'97 check failed (0x%x)\n", tmp);
                 return -EIO;
         }
         if ((tmp = snd_cs4281_peekBA0(chip, BA0_SERC2)) != (BA0_SERC2_SI1EN | BA0_SERC2_AC97)) {
-                snd_printk(KERN_ERR "SERC2 AC'97 check failed (0x%x)\n", tmp);
+                dev_err(chip->card->dev,
+                        "SERC2 AC'97 check failed (0x%x)\n", tmp);
                 return -EIO;
         }
 
@@ -1500,7 +1508,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip)
                 schedule_timeout_uninterruptible(1);
         } while (time_after_eq(end_time, jiffies));
 
-        snd_printk(KERN_ERR "DLLRDY not seen\n");
+        dev_err(chip->card->dev, "DLLRDY not seen\n");
         return -EIO;
 
       __ok0:
@@ -1526,7 +1534,9 @@ static int snd_cs4281_chip_init(struct cs4281 *chip)
                 schedule_timeout_uninterruptible(1);
         } while (time_after_eq(end_time, jiffies));
 
-        snd_printk(KERN_ERR "never read codec ready from AC'97 (0x%x)\n", snd_cs4281_peekBA0(chip, BA0_ACSTS));
+        dev_err(chip->card->dev,
+                "never read codec ready from AC'97 (0x%x)\n",
+                snd_cs4281_peekBA0(chip, BA0_ACSTS));
         return -EIO;
 
       __ok1:
@@ -1537,7 +1547,8 @@ static int snd_cs4281_chip_init(struct cs4281 *chip)
                                 goto __codec2_ok;
                         schedule_timeout_uninterruptible(1);
                 } while (time_after_eq(end_time, jiffies));
-                snd_printk(KERN_INFO "secondary codec doesn't respond. disable it...\n");
+                dev_info(chip->card->dev,
+                         "secondary codec doesn't respond. disable it...\n");
                 chip->dual_codec = 0;
         __codec2_ok: ;
         }
@@ -1567,7 +1578,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip)
 
         if (--retry_count > 0)
                 goto __retry;
-        snd_printk(KERN_ERR "never read ISV3 and ISV4 from AC'97\n");
+        dev_err(chip->card->dev, "never read ISV3 and ISV4 from AC'97\n");
         return -EIO;
 
       __ok2:
@@ -2054,8 +2065,7 @@ static int cs4281_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "cs4281: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/cs46xx/cs46xx_lib.c b/sound/pci/cs46xx/cs46xx_lib.c
index 28766478f81c..32b44f25b5c8 100644
--- a/sound/pci/cs46xx/cs46xx_lib.c
+++ b/sound/pci/cs46xx/cs46xx_lib.c
@@ -116,7 +116,7 @@ static unsigned short snd_cs46xx_codec_read(struct snd_cs46xx *chip,
 
         tmp = snd_cs46xx_peekBA0(chip, BA0_ACCTL);
         if ((tmp & ACCTL_VFRM) == 0) {
-                snd_printk(KERN_WARNING  "cs46xx: ACCTL_VFRM not set 0x%x\n",tmp);
+                dev_warn(chip->card->dev, "ACCTL_VFRM not set 0x%x\n", tmp);
                 snd_cs46xx_pokeBA0(chip, BA0_ACCTL, (tmp & (~ACCTL_ESYN)) | ACCTL_VFRM );
                 msleep(50);
                 tmp = snd_cs46xx_peekBA0(chip, BA0_ACCTL + offset);
@@ -168,7 +168,8 @@ static unsigned short snd_cs46xx_codec_read(struct snd_cs46xx *chip,
                         goto ok1;
         }
 
-        snd_printk(KERN_ERR "AC'97 read problem (ACCTL_DCV), reg = 0x%x\n", reg);
+        dev_err(chip->card->dev,
+                "AC'97 read problem (ACCTL_DCV), reg = 0x%x\n", reg);
         result = 0xffff;
         goto end;
         
@@ -187,7 +188,9 @@ static unsigned short snd_cs46xx_codec_read(struct snd_cs46xx *chip,
                 udelay(10);
         }
         
-        snd_printk(KERN_ERR "AC'97 read problem (ACSTS_VSTS), codec_index %d, reg = 0x%x\n", codec_index, reg);
+        dev_err(chip->card->dev,
+                "AC'97 read problem (ACSTS_VSTS), codec_index %d, reg = 0x%x\n",
+                codec_index, reg);
         result = 0xffff;
         goto end;
 
@@ -197,7 +200,8 @@ static unsigned short snd_cs46xx_codec_read(struct snd_cs46xx *chip,
          *  ACSDA = Status Data Register = 474h
          */
 #if 0
-        printk(KERN_DEBUG "e) reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n", reg,
+        dev_dbg(chip->card->dev,
+                "e) reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n", reg,
                         snd_cs46xx_peekBA0(chip, BA0_ACSDA),
                         snd_cs46xx_peekBA0(chip, BA0_ACCAD));
 #endif
@@ -286,7 +290,9 @@ static void snd_cs46xx_codec_write(struct snd_cs46xx *chip,
                         goto end;
                 }
         }
-        snd_printk(KERN_ERR "AC'97 write problem, codec_index = %d, reg = 0x%x, val = 0x%x\n", codec_index, reg, val);
+        dev_err(chip->card->dev,
+                "AC'97 write problem, codec_index = %d, reg = 0x%x, val = 0x%x\n",
+                codec_index, reg, val);
  end:
         chip->active_ctrl(chip, -1);
 }
@@ -608,8 +614,8 @@ static int cs46xx_wait_for_fifo(struct snd_cs46xx * chip,int retry_timeout)
         }
   
         if(status & SERBST_WBSY) {
-                snd_printk(KERN_ERR "cs46xx: failure waiting for "
-                           "FIFO command to complete\n");
+                dev_err(chip->card->dev,
+                        "failure waiting for FIFO command to complete\n");
                 return -EINVAL;
         }
 
@@ -646,7 +652,9 @@ static void snd_cs46xx_clear_serial_FIFOs(struct snd_cs46xx *chip)
                  *  Make sure the previous FIFO write operation has completed.
                  */
                 if (cs46xx_wait_for_fifo(chip,1)) {
-                        snd_printdd ("failed waiting for FIFO at addr (%02X)\n",idx);
+                        dev_dbg(chip->card->dev,
+                                "failed waiting for FIFO at addr (%02X)\n",
+                                idx);
 
                         if (powerdown)
                                 snd_cs46xx_pokeBA0(chip, BA0_CLKCR1, tmp);
@@ -694,7 +702,7 @@ static void snd_cs46xx_proc_start(struct snd_cs46xx *chip)
         }
 
         if (snd_cs46xx_peek(chip, BA1_SPCR) & SPCR_RUNFR)
-                snd_printk(KERN_ERR "SPCR_RUNFR never reset\n");
+                dev_err(chip->card->dev, "SPCR_RUNFR never reset\n");
 }
 
 static void snd_cs46xx_proc_stop(struct snd_cs46xx *chip)
@@ -1054,7 +1062,8 @@ static int _cs46xx_adjust_sample_rate (struct snd_cs46xx *chip, struct snd_cs46x
                 cpcm->pcm_channel = cs46xx_dsp_create_pcm_channel (chip, sample_rate, 
                                                                    cpcm, cpcm->hw_buf.addr,cpcm->pcm_channel_id);
                 if (cpcm->pcm_channel == NULL) {
-                        snd_printk(KERN_ERR "cs46xx: failed to create virtual PCM channel\n");
+                        dev_err(chip->card->dev,
+                                "failed to create virtual PCM channel\n");
                         return -ENOMEM;
                 }
                 cpcm->pcm_channel->sample_rate = sample_rate;
@@ -1067,7 +1076,8 @@ static int _cs46xx_adjust_sample_rate (struct snd_cs46xx *chip, struct snd_cs46x
                 if ( (cpcm->pcm_channel = cs46xx_dsp_create_pcm_channel (chip, sample_rate, cpcm, 
                                                                          cpcm->hw_buf.addr,
                                                                          cpcm->pcm_channel_id)) == NULL) {
-                        snd_printk(KERN_ERR "cs46xx: failed to re-create virtual PCM channel\n");
+                        dev_err(chip->card->dev,
+                                "failed to re-create virtual PCM channel\n");
                         return -ENOMEM;
                 }
 
@@ -1116,7 +1126,8 @@ static int snd_cs46xx_playback_hw_params(struct snd_pcm_substream *substream,
                  return -EINVAL;
          }
 
-        snd_printdd ("period_size (%d), periods (%d) buffer_size(%d)\n",
+        dev_dbg(chip->card->dev,
+                "period_size (%d), periods (%d) buffer_size(%d)\n",
                      period_size, params_periods(hw_params),
                      params_buffer_bytes(hw_params));
 #endif
@@ -1531,22 +1542,20 @@ static int _cs46xx_playback_open_channel (struct snd_pcm_substream *substream,in
 
 static int snd_cs46xx_playback_open(struct snd_pcm_substream *substream)
 {
-        snd_printdd("open front channel\n");
+        dev_dbg(substream->pcm->card->dev, "open front channel\n");
         return _cs46xx_playback_open_channel(substream,DSP_PCM_MAIN_CHANNEL);
 }
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
 static int snd_cs46xx_playback_open_rear(struct snd_pcm_substream *substream)
 {
-        snd_printdd("open rear channel\n");
-
+        dev_dbg(substream->pcm->card->dev, "open rear channel\n");
         return _cs46xx_playback_open_channel(substream,DSP_PCM_REAR_CHANNEL);
 }
 
 static int snd_cs46xx_playback_open_clfe(struct snd_pcm_substream *substream)
 {
-        snd_printdd("open center - LFE channel\n");
-
+        dev_dbg(substream->pcm->card->dev, "open center - LFE channel\n");
         return _cs46xx_playback_open_channel(substream,DSP_PCM_CENTER_LFE_CHANNEL);
 }
 
@@ -1554,7 +1563,7 @@ static int snd_cs46xx_playback_open_iec958(struct snd_pcm_substream *substream)
 {
         struct snd_cs46xx *chip = snd_pcm_substream_chip(substream);
 
-        snd_printdd("open raw iec958 channel\n");
+        dev_dbg(chip->card->dev, "open raw iec958 channel\n");
 
         mutex_lock(&chip->spos_mutex);
         cs46xx_iec958_pre_open (chip);
@@ -1570,7 +1579,7 @@ static int snd_cs46xx_playback_close_iec958(struct snd_pcm_substream *substream)
         int err;
         struct snd_cs46xx *chip = snd_pcm_substream_chip(substream);
   
-        snd_printdd("close raw iec958 channel\n");
+        dev_dbg(chip->card->dev, "close raw iec958 channel\n");
 
         err = snd_cs46xx_playback_close(substream);
 
@@ -2421,10 +2430,10 @@ static void snd_cs46xx_codec_reset (struct snd_ac97 * ac97)
 
         /* set the desired CODEC mode */
         if (ac97->num == CS46XX_PRIMARY_CODEC_INDEX) {
-                snd_printdd("cs46xx: CODEC1 mode %04x\n", 0x0);
+                dev_dbg(ac97->bus->card->dev, "CODEC1 mode %04x\n", 0x0);
                 snd_cs46xx_ac97_write(ac97, AC97_CSR_ACMODE, 0x0);
         } else if (ac97->num == CS46XX_SECONDARY_CODEC_INDEX) {
-                snd_printdd("cs46xx: CODEC2 mode %04x\n", 0x3);
+                dev_dbg(ac97->bus->card->dev, "CODEC2 mode %04x\n", 0x3);
                 snd_cs46xx_ac97_write(ac97, AC97_CSR_ACMODE, 0x3);
         } else {
                 snd_BUG(); /* should never happen ... */
@@ -2456,7 +2465,8 @@ static void snd_cs46xx_codec_reset (struct snd_ac97 * ac97)
                 msleep(10);
         } while (time_after_eq(end_time, jiffies));
 
-        snd_printk(KERN_ERR "CS46xx secondary codec doesn't respond!\n");  
+        dev_err(ac97->bus->card->dev,
+                "CS46xx secondary codec doesn't respond!\n");
 }
 #endif
 
@@ -2476,7 +2486,8 @@ static int cs46xx_detect_codec(struct snd_cs46xx *chip, int codec)
                 snd_cs46xx_codec_write(chip, AC97_RESET, 0, codec);
                 udelay(10);
                 if (snd_cs46xx_codec_read(chip, AC97_RESET, codec) & 0x8000) {
-                        snd_printdd("snd_cs46xx: seconadry codec not present\n");
+                        dev_dbg(chip->card->dev,
+                                "seconadry codec not present\n");
                         return -ENXIO;
                 }
         }
@@ -2489,7 +2500,7 @@ static int cs46xx_detect_codec(struct snd_cs46xx *chip, int codec)
                 }
                 msleep(10);
         }
-        snd_printdd("snd_cs46xx: codec %d detection timeout\n", codec);
+        dev_dbg(chip->card->dev, "codec %d detection timeout\n", codec);
         return -ENXIO;
 }
 
@@ -2509,7 +2520,7 @@ int snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device)
 
         /* detect primary codec */
         chip->nr_ac97_codecs = 0;
-        snd_printdd("snd_cs46xx: detecting primary codec\n");
+        dev_dbg(chip->card->dev, "detecting primary codec\n");
         if ((err = snd_ac97_bus(card, 0, &ops, chip, &chip->ac97_bus)) < 0)
                 return err;
         chip->ac97_bus->private_free = snd_cs46xx_mixer_free_ac97_bus;
@@ -2519,7 +2530,7 @@ int snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device)
         chip->nr_ac97_codecs = 1;
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-        snd_printdd("snd_cs46xx: detecting seconadry codec\n");
+        dev_dbg(chip->card->dev, "detecting seconadry codec\n");
         /* try detect a secondary codec */
         if (! cs46xx_detect_codec(chip, CS46XX_SECONDARY_CODEC_INDEX))
                 chip->nr_ac97_codecs = 2;
@@ -2554,7 +2565,7 @@ int snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device)
         }
         /* do soundcard specific mixer setup */
         if (chip->mixer_init) {
-                snd_printdd ("calling chip->mixer_init(chip);\n");
+                dev_dbg(chip->card->dev, "calling chip->mixer_init(chip);\n");
                 chip->mixer_init(chip);
         }
 #endif
@@ -2801,7 +2812,8 @@ int snd_cs46xx_gameport(struct snd_cs46xx *chip)
 
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "cs46xx: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
 
@@ -3138,8 +3150,10 @@ static int snd_cs46xx_chip_init(struct snd_cs46xx *chip)
         }
 
 
-        snd_printk(KERN_ERR "create - never read codec ready from AC'97\n");
-        snd_printk(KERN_ERR "it is not probably bug, try to use CS4236 driver\n");
+        dev_err(chip->card->dev,
+                "create - never read codec ready from AC'97\n");
+        dev_err(chip->card->dev,
+                "it is not probably bug, try to use CS4236 driver\n");
         return -EIO;
  ok1:
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
@@ -3157,7 +3171,8 @@ static int snd_cs46xx_chip_init(struct snd_cs46xx *chip)
                  *  Make sure CODEC is READY.
                  */
                 if (!(snd_cs46xx_peekBA0(chip, BA0_ACSTS2) & ACSTS_CRDY))
-                        snd_printdd("cs46xx: never read card ready from secondary AC'97\n");
+                        dev_dbg(chip->card->dev,
+                                "never read card ready from secondary AC'97\n");
         }
 #endif
 
@@ -3187,17 +3202,21 @@ static int snd_cs46xx_chip_init(struct snd_cs46xx *chip)
         }
 
 #ifndef CONFIG_SND_CS46XX_NEW_DSP
-        snd_printk(KERN_ERR "create - never read ISV3 & ISV4 from AC'97\n");
+        dev_err(chip->card->dev,
+                "create - never read ISV3 & ISV4 from AC'97\n");
         return -EIO;
 #else
         /* This may happen on a cold boot with a Terratec SiXPack 5.1.
            Reloading the driver may help, if there's other soundcards 
            with the same problem I would like to know. (Benny) */
 
-        snd_printk(KERN_ERR "ERROR: snd-cs46xx: never read ISV3 & ISV4 from AC'97\n");
-        snd_printk(KERN_ERR "       Try reloading the ALSA driver, if you find something\n");
-        snd_printk(KERN_ERR "       broken or not working on your soundcard upon\n");
-        snd_printk(KERN_ERR "       this message please report to alsa-devel@alsa-project.org\n");
+        dev_err(chip->card->dev, "never read ISV3 & ISV4 from AC'97\n");
+        dev_err(chip->card->dev,
+                "Try reloading the ALSA driver, if you find something\n");
+        dev_err(chip->card->dev,
+                "broken or not working on your soundcard upon\n");
+        dev_err(chip->card->dev,
+                "this message please report to alsa-devel@alsa-project.org\n");
 
         return -EIO;
 #endif
@@ -3266,13 +3285,13 @@ int snd_cs46xx_start_dsp(struct snd_cs46xx *chip)
         for (i = 0; i < CS46XX_DSP_MODULES; i++) {
                 err = load_firmware(chip, &chip->modules[i], module_names[i]);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "firmware load error [%s]\n",
+                        dev_err(chip->card->dev, "firmware load error [%s]\n",
                                    module_names[i]);
                         return err;
                 }
                 err = cs46xx_dsp_load_module(chip, chip->modules[i]);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "image download error [%s]\n",
+                        dev_err(chip->card->dev, "image download error [%s]\n",
                                    module_names[i]);
                         return err;
                 }
@@ -3288,7 +3307,7 @@ int snd_cs46xx_start_dsp(struct snd_cs46xx *chip)
         /* old image */
         err = snd_cs46xx_download_image(chip);
         if (err < 0) {
-                snd_printk(KERN_ERR "image download error\n");
+                dev_err(chip->card->dev, "image download error\n");
                 return err;
         }
 
@@ -3341,7 +3360,7 @@ static int voyetra_setup_eapd_slot(struct snd_cs46xx *chip)
         u32 idx, valid_slots,tmp,powerdown = 0;
         u16 modem_power,pin_config,logic_type;
 
-        snd_printdd ("cs46xx: cs46xx_setup_eapd_slot()+\n");
+        dev_dbg(chip->card->dev, "cs46xx_setup_eapd_slot()+\n");
 
         /*
          *  See if the devices are powered down.  If so, we must power them up first
@@ -3359,7 +3378,8 @@ static int voyetra_setup_eapd_slot(struct snd_cs46xx *chip)
          * stuff.
          */
         if(chip->nr_ac97_codecs != 2) {
-                snd_printk (KERN_ERR "cs46xx: cs46xx_setup_eapd_slot() - no secondary codec configured\n");
+                dev_err(chip->card->dev,
+                        "cs46xx_setup_eapd_slot() - no secondary codec configured\n");
                 return -EINVAL;
         }
 
@@ -3400,7 +3420,7 @@ static int voyetra_setup_eapd_slot(struct snd_cs46xx *chip)
         snd_cs46xx_pokeBA0(chip, BA0_ACOSV, valid_slots);
 
         if ( cs46xx_wait_for_fifo(chip,1) ) {
-          snd_printdd("FIFO is busy\n");
+                dev_dbg(chip->card->dev, "FIFO is busy\n");
           
           return -EINVAL;
         }
@@ -3421,7 +3441,9 @@ static int voyetra_setup_eapd_slot(struct snd_cs46xx *chip)
                  * Wait for command to complete
                  */
                 if ( cs46xx_wait_for_fifo(chip,200) ) {
-                        snd_printdd("failed waiting for FIFO at addr (%02X)\n",idx);
+                        dev_dbg(chip->card->dev,
+                                "failed waiting for FIFO at addr (%02X)\n",
+                                idx);
 
                         return -EINVAL;
                 }
@@ -3510,14 +3532,14 @@ static void amp_hercules(struct snd_cs46xx *chip, int change)
 
         chip->amplifier += change;
         if (chip->amplifier && !old) {
-                snd_printdd ("Hercules amplifier ON\n");
+                dev_dbg(chip->card->dev, "Hercules amplifier ON\n");
 
                 snd_cs46xx_pokeBA0(chip, BA0_EGPIODR, 
                                    EGPIODR_GPOE2 | val1);     /* enable EGPIO2 output */
                 snd_cs46xx_pokeBA0(chip, BA0_EGPIOPTR, 
                                    EGPIOPTR_GPPT2 | val2);   /* open-drain on output */
         } else if (old && !chip->amplifier) {
-                snd_printdd ("Hercules amplifier OFF\n");
+                dev_dbg(chip->card->dev, "Hercules amplifier OFF\n");
                 snd_cs46xx_pokeBA0(chip, BA0_EGPIODR,  val1 & ~EGPIODR_GPOE2); /* disable */
                 snd_cs46xx_pokeBA0(chip, BA0_EGPIOPTR, val2 & ~EGPIOPTR_GPPT2); /* disable */
         }
@@ -3525,7 +3547,7 @@ static void amp_hercules(struct snd_cs46xx *chip, int change)
 
 static void voyetra_mixer_init (struct snd_cs46xx *chip)
 {
-        snd_printdd ("initializing Voyetra mixer\n");
+        dev_dbg(chip->card->dev, "initializing Voyetra mixer\n");
 
         /* Enable SPDIF out */
         snd_cs46xx_pokeBA0(chip, BA0_EGPIODR, EGPIODR_GPOE0);
@@ -3543,7 +3565,7 @@ static void hercules_mixer_init (struct snd_cs46xx *chip)
         /* set EGPIO to default */
         hercules_init(chip);
 
-        snd_printdd ("initializing Hercules mixer\n");
+        dev_dbg(chip->card->dev, "initializing Hercules mixer\n");
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
         if (chip->in_suspend)
@@ -3554,7 +3576,9 @@ static void hercules_mixer_init (struct snd_cs46xx *chip)
 
                 kctl = snd_ctl_new1(&snd_hercules_controls[idx], chip);
                 if ((err = snd_ctl_add(card, kctl)) < 0) {
-                        printk (KERN_ERR "cs46xx: failed to initialize Hercules mixer (%d)\n",err);
+                        dev_err(card->dev,
+                                "failed to initialize Hercules mixer (%d)\n",
+                                err);
                         break;
                 }
         }
@@ -3826,8 +3850,7 @@ static int snd_cs46xx_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "cs46xx: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -3932,7 +3955,8 @@ int snd_cs46xx_create(struct snd_card *card,
         chip->ba1_addr = pci_resource_start(pci, 1);
         if (chip->ba0_addr == 0 || chip->ba0_addr == (unsigned long)~0 ||
             chip->ba1_addr == 0 || chip->ba1_addr == (unsigned long)~0) {
-                snd_printk(KERN_ERR "wrong address(es) - ba0 = 0x%lx, ba1 = 0x%lx\n",
+                dev_err(chip->card->dev,
+                        "wrong address(es) - ba0 = 0x%lx, ba1 = 0x%lx\n",
                            chip->ba0_addr, chip->ba1_addr);
                 snd_cs46xx_free(chip);
                 return -ENOMEM;
@@ -3969,7 +3993,8 @@ int snd_cs46xx_create(struct snd_card *card,
 
         for (cp = &cards[0]; cp->name; cp++) {
                 if (cp->vendor == ss_vendor && cp->id == ss_card) {
-                        snd_printdd ("hack for %s enabled\n", cp->name);
+                        dev_dbg(chip->card->dev, "hack for %s enabled\n",
+                                cp->name);
 
                         chip->amplifier_ctrl = cp->amp;
                         chip->active_ctrl = cp->active;
@@ -3982,12 +4007,14 @@ int snd_cs46xx_create(struct snd_card *card,
         }
 
         if (external_amp) {
-                snd_printk(KERN_INFO "Crystal EAPD support forced on.\n");
+                dev_info(chip->card->dev,
+                         "Crystal EAPD support forced on.\n");
                 chip->amplifier_ctrl = amp_voyetra;
         }
 
         if (thinkpad) {
-                snd_printk(KERN_INFO "Activating CLKRUN hack for Thinkpad.\n");
+                dev_info(chip->card->dev,
+                         "Activating CLKRUN hack for Thinkpad.\n");
                 chip->active_ctrl = clkrun_hack;
                 clkrun_init(chip);
         }
@@ -4005,14 +4032,16 @@ int snd_cs46xx_create(struct snd_card *card,
                 region = &chip->region.idx[idx];
                 if ((region->resource = request_mem_region(region->base, region->size,
                                                            region->name)) == NULL) {
-                        snd_printk(KERN_ERR "unable to request memory region 0x%lx-0x%lx\n",
+                        dev_err(chip->card->dev,
+                                "unable to request memory region 0x%lx-0x%lx\n",
                                    region->base, region->base + region->size - 1);
                         snd_cs46xx_free(chip);
                         return -EBUSY;
                 }
                 region->remap_addr = ioremap_nocache(region->base, region->size);
                 if (region->remap_addr == NULL) {
-                        snd_printk(KERN_ERR "%s ioremap problem\n", region->name);
+                        dev_err(chip->card->dev,
+                                "%s ioremap problem\n", region->name);
                         snd_cs46xx_free(chip);
                         return -ENOMEM;
                 }
@@ -4020,7 +4049,7 @@ int snd_cs46xx_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_cs46xx_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_cs46xx_free(chip);
                 return -EBUSY;
         }
diff --git a/sound/pci/cs46xx/dsp_spos.c b/sound/pci/cs46xx/dsp_spos.c
index 1686b4f4c44f..1c4a0fb3ffef 100644
--- a/sound/pci/cs46xx/dsp_spos.c
+++ b/sound/pci/cs46xx/dsp_spos.c
@@ -85,12 +85,15 @@ static int shadow_and_reallocate_code (struct snd_cs46xx * chip, u32 * data, u32
                                                 address  = (hival & 0x00FFF) << 5;
                                                 address |=  loval >> 15;
             
-                                                snd_printdd("handle_wideop[1]: %05x:%05x addr %04x\n",hival,loval,address);
+                                                dev_dbg(chip->card->dev,
+                                                        "handle_wideop[1]: %05x:%05x addr %04x\n",
+                                                        hival, loval, address);
             
                                                 if ( !(address & 0x8000) ) {
                                                         address += (ins->code.offset / 2) - overlay_begin_address;
                                                 } else {
-                                                        snd_printdd("handle_wideop[1]: ROM symbol not reallocated\n");
+                                                        dev_dbg(chip->card->dev,
+                                                                "handle_wideop[1]: ROM symbol not reallocated\n");
                                                 }
             
                                                 hival &= 0xFF000;
@@ -102,8 +105,9 @@ static int shadow_and_reallocate_code (struct snd_cs46xx * chip, u32 * data, u32
                                                 address  = (hival & 0x00FFF) << 5;
                                                 address |=  loval >> 15;
             
-                                                snd_printdd("handle_wideop:[2] %05x:%05x addr %04x\n",hival,loval,address);            
-                                                nreallocated ++;
+                                                dev_dbg(chip->card->dev,
+                                                        "handle_wideop:[2] %05x:%05x addr %04x\n",
+                                                        hival, loval, address);                                         nreallocated++;
                                         } /* wide_opcodes[j] == wide_op */
                                 } /* for */
                         } /* mod_type == 0 ... */
@@ -113,7 +117,8 @@ static int shadow_and_reallocate_code (struct snd_cs46xx * chip, u32 * data, u32
                 ins->code.data[ins->code.size++] = hival;
         }
 
-        snd_printdd("dsp_spos: %d instructions reallocated\n",nreallocated);
+        dev_dbg(chip->card->dev,
+                "dsp_spos: %d instructions reallocated\n", nreallocated);
         return nreallocated;
 }
 
@@ -157,7 +162,8 @@ static int add_symbols (struct snd_cs46xx * chip, struct dsp_module_desc * modul
 
         for (i = 0;i < module->symbol_table.nsymbols; ++i) {
                 if (ins->symbol_table.nsymbols == (DSP_MAX_SYMBOLS - 1)) {
-                        snd_printk(KERN_ERR "dsp_spos: symbol table is full\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: symbol table is full\n");
                         return -ENOMEM;
                 }
 
@@ -176,8 +182,11 @@ static int add_symbols (struct snd_cs46xx * chip, struct dsp_module_desc * modul
 
                         ins->symbol_table.nsymbols++;
                 } else {
-          /* if (0) printk ("dsp_spos: symbol <%s> duplicated, probably nothing wrong with that (Cirrus?)\n",
-                             module->symbol_table.symbols[i].symbol_name); */
+#if 0
+                        dev_dbg(chip->card->dev,
+                                "dsp_spos: symbol <%s> duplicated, probably nothing wrong with that (Cirrus?)\n",
+                                module->symbol_table.symbols[i].symbol_name); */
+#endif
                 }
         }
 
@@ -192,14 +201,15 @@ add_symbol (struct snd_cs46xx * chip, char * symbol_name, u32 address, int type)
         int index;
 
         if (ins->symbol_table.nsymbols == (DSP_MAX_SYMBOLS - 1)) {
-                snd_printk(KERN_ERR "dsp_spos: symbol table is full\n");
+                dev_err(chip->card->dev, "dsp_spos: symbol table is full\n");
                 return NULL;
         }
   
         if (cs46xx_dsp_lookup_symbol(chip,
                                      symbol_name,
                                      type) != NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol <%s> duplicated\n", symbol_name);
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol <%s> duplicated\n", symbol_name);
                 return NULL;
         }
 
@@ -305,19 +315,20 @@ static int dsp_load_parameter(struct snd_cs46xx *chip,
         u32 doffset, dsize;
 
         if (!parameter) {
-                snd_printdd("dsp_spos: module got no parameter segment\n");
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: module got no parameter segment\n");
                 return 0;
         }
 
         doffset = (parameter->offset * 4 + DSP_PARAMETER_BYTE_OFFSET);
         dsize   = parameter->size * 4;
 
-        snd_printdd("dsp_spos: "
-                    "downloading parameter data to chip (%08x-%08x)\n",
+        dev_dbg(chip->card->dev,
+                "dsp_spos: downloading parameter data to chip (%08x-%08x)\n",
                     doffset,doffset + dsize);
         if (snd_cs46xx_download (chip, parameter->data, doffset, dsize)) {
-                snd_printk(KERN_ERR "dsp_spos: "
-                           "failed to download parameter data to DSP\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: failed to download parameter data to DSP\n");
                 return -EINVAL;
         }
         return 0;
@@ -329,18 +340,21 @@ static int dsp_load_sample(struct snd_cs46xx *chip,
         u32 doffset, dsize;
 
         if (!sample) {
-                snd_printdd("dsp_spos: module got no sample segment\n");
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: module got no sample segment\n");
                 return 0;
         }
 
         doffset = (sample->offset * 4  + DSP_SAMPLE_BYTE_OFFSET);
         dsize   =  sample->size * 4;
 
-        snd_printdd("dsp_spos: downloading sample data to chip (%08x-%08x)\n",
+        dev_dbg(chip->card->dev,
+                "dsp_spos: downloading sample data to chip (%08x-%08x)\n",
                     doffset,doffset + dsize);
 
         if (snd_cs46xx_download (chip,sample->data,doffset,dsize)) {
-                snd_printk(KERN_ERR "dsp_spos: failed to sample data to DSP\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: failed to sample data to DSP\n");
                 return -EINVAL;
         }
         return 0;
@@ -354,14 +368,16 @@ int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * m
         int err;
 
         if (ins->nmodules == DSP_MAX_MODULES - 1) {
-                snd_printk(KERN_ERR "dsp_spos: to many modules loaded into DSP\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: to many modules loaded into DSP\n");
                 return -ENOMEM;
         }
 
-        snd_printdd("dsp_spos: loading module %s into DSP\n", module->module_name);
+        dev_dbg(chip->card->dev,
+                "dsp_spos: loading module %s into DSP\n", module->module_name);
   
         if (ins->nmodules == 0) {
-                snd_printdd("dsp_spos: clearing parameter area\n");
+                dev_dbg(chip->card->dev, "dsp_spos: clearing parameter area\n");
                 snd_cs46xx_clear_BA1(chip, DSP_PARAMETER_BYTE_OFFSET, DSP_PARAMETER_BYTE_SIZE);
         }
   
@@ -371,7 +387,7 @@ int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * m
                 return err;
 
         if (ins->nmodules == 0) {
-                snd_printdd("dsp_spos: clearing sample area\n");
+                dev_dbg(chip->card->dev, "dsp_spos: clearing sample area\n");
                 snd_cs46xx_clear_BA1(chip, DSP_SAMPLE_BYTE_OFFSET, DSP_SAMPLE_BYTE_SIZE);
         }
 
@@ -381,15 +397,17 @@ int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * m
                 return err;
 
         if (ins->nmodules == 0) {
-                snd_printdd("dsp_spos: clearing code area\n");
+                dev_dbg(chip->card->dev, "dsp_spos: clearing code area\n");
                 snd_cs46xx_clear_BA1(chip, DSP_CODE_BYTE_OFFSET, DSP_CODE_BYTE_SIZE);
         }
 
         if (code == NULL) {
-                snd_printdd("dsp_spos: module got no code segment\n");
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: module got no code segment\n");
         } else {
                 if (ins->code.offset + code->size > DSP_CODE_BYTE_SIZE) {
-                        snd_printk(KERN_ERR "dsp_spos: no space available in DSP\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: no space available in DSP\n");
                         return -ENOMEM;
                 }
 
@@ -401,19 +419,22 @@ int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * m
                 if (snd_BUG_ON(!module->symbol_table.symbols))
                         return -ENOMEM;
                 if (add_symbols(chip,module)) {
-                        snd_printk(KERN_ERR "dsp_spos: failed to load symbol table\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: failed to load symbol table\n");
                         return -ENOMEM;
                 }
     
                 doffset = (code->offset * 4 + ins->code.offset * 4 + DSP_CODE_BYTE_OFFSET);
                 dsize   = code->size * 4;
-                snd_printdd("dsp_spos: downloading code to chip (%08x-%08x)\n",
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: downloading code to chip (%08x-%08x)\n",
                             doffset,doffset + dsize);   
 
                 module->nfixups = shadow_and_reallocate_code(chip,code->data,code->size,module->overlay_begin_address);
 
                 if (snd_cs46xx_download (chip,(ins->code.data + ins->code.offset),doffset,dsize)) {
-                        snd_printk(KERN_ERR "dsp_spos: failed to download code to DSP\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: failed to download code to DSP\n");
                         return -EINVAL;
                 }
 
@@ -447,7 +468,7 @@ cs46xx_dsp_lookup_symbol (struct snd_cs46xx * chip, char * symbol_name, int symb
         }
 
 #if 0
-        printk ("dsp_spos: symbol <%s> type %02x not found\n",
+        dev_err(chip->card->dev, "dsp_spos: symbol <%s> type %02x not found\n",
                 symbol_name,symbol_type);
 #endif
 
@@ -910,7 +931,6 @@ int cs46xx_dsp_proc_done (struct snd_cs46xx *chip)
 }
 #endif /* CONFIG_PROC_FS */
 
-static int debug_tree;
 static void _dsp_create_task_tree (struct snd_cs46xx *chip, u32 * task_data,
                                    u32  dest, int size)
 {
@@ -919,13 +939,13 @@ static void _dsp_create_task_tree (struct snd_cs46xx *chip, u32 * task_data,
         int i;
 
         for (i = 0; i < size; ++i) {
-                if (debug_tree) printk ("addr %p, val %08x\n",spdst,task_data[i]);
+                dev_dbg(chip->card->dev, "addr %p, val %08x\n",
+                        spdst, task_data[i]);
                 writel(task_data[i],spdst);
                 spdst += sizeof(u32);
         }
 }
 
-static int debug_scb;
 static void _dsp_create_scb (struct snd_cs46xx *chip, u32 * scb_data, u32 dest)
 {
         void __iomem *spdst = chip->region.idx[1].remap_addr + 
@@ -933,7 +953,8 @@ static void _dsp_create_scb (struct snd_cs46xx *chip, u32 * scb_data, u32 dest)
         int i;
 
         for (i = 0; i < 0x10; ++i) {
-                if (debug_scb) printk ("addr %p, val %08x\n",spdst,scb_data[i]);
+                dev_dbg(chip->card->dev, "addr %p, val %08x\n",
+                        spdst, scb_data[i]);
                 writel(scb_data[i],spdst);
                 spdst += sizeof(u32);
         }
@@ -960,7 +981,8 @@ static struct dsp_scb_descriptor * _map_scb (struct snd_cs46xx *chip, char * nam
         int index;
 
         if (ins->nscb == DSP_MAX_SCB_DESC - 1) {
-                snd_printk(KERN_ERR "dsp_spos: got no place for other SCB\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: got no place for other SCB\n");
                 return NULL;
         }
 
@@ -991,7 +1013,8 @@ _map_task_tree (struct snd_cs46xx *chip, char * name, u32 dest, u32 size)
         struct dsp_task_descriptor * desc = NULL;
 
         if (ins->ntask == DSP_MAX_TASK_DESC - 1) {
-                snd_printk(KERN_ERR "dsp_spos: got no place for other TASK\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: got no place for other TASK\n");
                 return NULL;
         }
 
@@ -1031,7 +1054,7 @@ cs46xx_dsp_create_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, u32
                 desc->data = scb_data;
                 _dsp_create_scb(chip,scb_data,dest);
         } else {
-                snd_printk(KERN_ERR "dsp_spos: failed to map SCB\n");
+                dev_err(chip->card->dev, "dsp_spos: failed to map SCB\n");
 #ifdef CONFIG_PM_SLEEP
                 kfree(scb_data);
 #endif
@@ -1052,7 +1075,7 @@ cs46xx_dsp_create_task_tree (struct snd_cs46xx *chip, char * name, u32 * task_da
                 desc->data = task_data;
                 _dsp_create_task_tree(chip,task_data,dest,size);
         } else {
-                snd_printk(KERN_ERR "dsp_spos: failed to map TASK\n");
+                dev_err(chip->card->dev, "dsp_spos: failed to map TASK\n");
         }
 
         return desc;
@@ -1105,31 +1128,36 @@ int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip)
 
         null_algorithm  = cs46xx_dsp_lookup_symbol(chip, "NULLALGORITHM", SYMBOL_CODE);
         if (null_algorithm == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol NULLALGORITHM not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol NULLALGORITHM not found\n");
                 return -EIO;
         }
 
         fg_task_tree_header_code = cs46xx_dsp_lookup_symbol(chip, "FGTASKTREEHEADERCODE", SYMBOL_CODE);  
         if (fg_task_tree_header_code == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol FGTASKTREEHEADERCODE not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol FGTASKTREEHEADERCODE not found\n");
                 return -EIO;
         }
 
         task_tree_header_code = cs46xx_dsp_lookup_symbol(chip, "TASKTREEHEADERCODE", SYMBOL_CODE);  
         if (task_tree_header_code == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol TASKTREEHEADERCODE not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol TASKTREEHEADERCODE not found\n");
                 return -EIO;
         }
   
         task_tree_thread = cs46xx_dsp_lookup_symbol(chip, "TASKTREETHREAD", SYMBOL_CODE);
         if (task_tree_thread == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol TASKTREETHREAD not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol TASKTREETHREAD not found\n");
                 return -EIO;
         }
 
         magic_snoop_task = cs46xx_dsp_lookup_symbol(chip, "MAGICSNOOPTASK", SYMBOL_CODE);
         if (magic_snoop_task == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol MAGICSNOOPTASK not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol MAGICSNOOPTASK not found\n");
                 return -EIO;
         }
   
@@ -1476,7 +1504,7 @@ int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip)
         return 0;
 
  _fail_end:
-        snd_printk(KERN_ERR "dsp_spos: failed to setup SCB's in DSP\n");
+        dev_err(chip->card->dev, "dsp_spos: failed to setup SCB's in DSP\n");
         return -EINVAL;
 }
 
@@ -1491,18 +1519,21 @@ static int cs46xx_dsp_async_init (struct snd_cs46xx *chip,
 
         s16_async_codec_input_task = cs46xx_dsp_lookup_symbol(chip, "S16_ASYNCCODECINPUTTASK", SYMBOL_CODE);
         if (s16_async_codec_input_task == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol S16_ASYNCCODECINPUTTASK not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol S16_ASYNCCODECINPUTTASK not found\n");
                 return -EIO;
         }
         spdifo_task = cs46xx_dsp_lookup_symbol(chip, "SPDIFOTASK", SYMBOL_CODE);
         if (spdifo_task == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol SPDIFOTASK not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol SPDIFOTASK not found\n");
                 return -EIO;
         }
 
         spdifi_task = cs46xx_dsp_lookup_symbol(chip, "SPDIFITASK", SYMBOL_CODE);
         if (spdifi_task == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol SPDIFITASK not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol SPDIFITASK not found\n");
                 return -EIO;
         }
 
@@ -1883,7 +1914,8 @@ int cs46xx_poke_via_dsp (struct snd_cs46xx *chip, u32 address, u32 data)
         }
 
         if (i == 25) {
-                snd_printk(KERN_ERR "dsp_spos: SPIOWriteTask not responding\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: SPIOWriteTask not responding\n");
                 return -EBUSY;
         }
 
diff --git a/sound/pci/cs46xx/dsp_spos_scb_lib.c b/sound/pci/cs46xx/dsp_spos_scb_lib.c
index 409e8764fbeb..8284bc9b5858 100644
--- a/sound/pci/cs46xx/dsp_spos_scb_lib.c
+++ b/sound/pci/cs46xx/dsp_spos_scb_lib.c
@@ -233,8 +233,11 @@ void cs46xx_dsp_proc_free_scb_desc (struct dsp_scb_descriptor * scb)
 {
         if (scb->proc_info) {
                 struct proc_scb_info * scb_info = scb->proc_info->private_data;
+                struct snd_cs46xx *chip = scb_info->chip;
 
-                snd_printdd("cs46xx_dsp_proc_free_scb_desc: freeing %s\n",scb->scb_name);
+                dev_dbg(chip->card->dev,
+                        "cs46xx_dsp_proc_free_scb_desc: freeing %s\n",
+                        scb->scb_name);
 
                 snd_info_free_entry(scb->proc_info);
                 scb->proc_info = NULL;
@@ -305,7 +308,7 @@ _dsp_create_generic_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, u
         scb_data[SCBfuncEntryPtr] &= 0xFFFF0000;
         scb_data[SCBfuncEntryPtr] |= task_entry->address;
 
-        snd_printdd("dsp_spos: creating SCB <%s>\n",name);
+        dev_dbg(chip->card->dev, "dsp_spos: creating SCB <%s>\n", name);
 
         scb = cs46xx_dsp_create_scb(chip,name,scb_data,dest);
 
@@ -320,9 +323,15 @@ _dsp_create_generic_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, u
         /* update parent SCB */
         if (scb->parent_scb_ptr) {
 #if 0
-                printk ("scb->parent_scb_ptr = %s\n",scb->parent_scb_ptr->scb_name);
-                printk ("scb->parent_scb_ptr->next_scb_ptr = %s\n",scb->parent_scb_ptr->next_scb_ptr->scb_name);
-                printk ("scb->parent_scb_ptr->sub_list_ptr = %s\n",scb->parent_scb_ptr->sub_list_ptr->scb_name);
+                dev_dbg(chip->card->dev,
+                        "scb->parent_scb_ptr = %s\n",
+                        scb->parent_scb_ptr->scb_name);
+                dev_dbg(chip->card->dev,
+                        "scb->parent_scb_ptr->next_scb_ptr = %s\n",
+                        scb->parent_scb_ptr->next_scb_ptr->scb_name);
+                dev_dbg(chip->card->dev,
+                        "scb->parent_scb_ptr->sub_list_ptr = %s\n",
+                        scb->parent_scb_ptr->sub_list_ptr->scb_name);
 #endif
                 /* link to  parent SCB */
                 if (scb_child_type == SCB_ON_PARENT_NEXT_SCB) {
@@ -368,7 +377,8 @@ cs46xx_dsp_create_generic_scb (struct snd_cs46xx *chip, char * name, u32 * scb_d
                                                SYMBOL_CODE);
   
         if (task_entry == NULL) {
-                snd_printk (KERN_ERR "dsp_spos: symbol %s not found\n",task_entry_name);
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol %s not found\n", task_entry_name);
                 return NULL;
         }
   
@@ -582,7 +592,8 @@ cs46xx_dsp_create_pcm_reader_scb(struct snd_cs46xx * chip, char * scb_name,
                                                                  SYMBOL_CODE);
     
                 if (ins->null_algorithm == NULL) {
-                        snd_printk (KERN_ERR "dsp_spos: symbol NULLALGORITHM not found\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: symbol NULLALGORITHM not found\n");
                         return NULL;
                 }    
         }
@@ -612,7 +623,8 @@ cs46xx_dsp_create_src_task_scb(struct snd_cs46xx * chip, char * scb_name,
         unsigned int phiIncr;
         unsigned int correctionPerGOF, correctionPerSec;
 
-        snd_printdd( "dsp_spos: setting %s rate to %u\n",scb_name,rate);
+        dev_dbg(chip->card->dev, "dsp_spos: setting %s rate to %u\n",
+                scb_name, rate);
 
         /*
          *  Compute the values used to drive the actual sample rate conversion.
@@ -670,7 +682,8 @@ cs46xx_dsp_create_src_task_scb(struct snd_cs46xx * chip, char * scb_name,
                                                                  SYMBOL_CODE);
                         
                         if (ins->s16_up == NULL) {
-                                snd_printk (KERN_ERR "dsp_spos: symbol S16_UPSRC not found\n");
+                                dev_err(chip->card->dev,
+                                        "dsp_spos: symbol S16_UPSRC not found\n");
                                 return NULL;
                         }    
                 }
@@ -1265,7 +1278,7 @@ cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip,
                    the Sample Rate Converted (which could
                    alter the raw data stream ...) */
                 if (sample_rate == 48000) {
-                        snd_printdd ("IEC958 pass through\n");
+                        dev_dbg(chip->card->dev, "IEC958 pass through\n");
                         /* Hack to bypass creating a new SRC */
                         pass_through = 1;
                 }
@@ -1299,13 +1312,14 @@ cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip,
         }
 
         if (pcm_index == -1) {
-                snd_printk (KERN_ERR "dsp_spos: no free PCM channel\n");
+                dev_err(chip->card->dev, "dsp_spos: no free PCM channel\n");
                 return NULL;
         }
 
         if (src_scb == NULL) {
                 if (ins->nsrc_scb >= DSP_MAX_SRC_NR) {
-                        snd_printk(KERN_ERR "dsp_spos: to many SRC instances\n!");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: to many SRC instances\n!");
                         return NULL;
                 }
 
@@ -1331,7 +1345,8 @@ cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip,
 
                 snprintf (scb_name,DSP_MAX_SCB_NAME,"SrcTask_SCB%d",src_index);
                 
-                snd_printdd( "dsp_spos: creating SRC \"%s\"\n",scb_name);
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: creating SRC \"%s\"\n", scb_name);
                 src_scb = cs46xx_dsp_create_src_task_scb(chip,scb_name,
                                                          sample_rate,
                                                          src_output_buffer_addr[src_index],
@@ -1343,7 +1358,8 @@ cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip,
                                                          pass_through);
 
                 if (!src_scb) {
-                        snd_printk (KERN_ERR "dsp_spos: failed to create SRCtaskSCB\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: failed to create SRCtaskSCB\n");
                         return NULL;
                 }
 
@@ -1355,8 +1371,8 @@ cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip,
   
         snprintf (scb_name,DSP_MAX_SCB_NAME,"PCMReader_SCB%d",pcm_index);
 
-        snd_printdd( "dsp_spos: creating PCM \"%s\" (%d)\n",scb_name,
-                 pcm_channel_id);
+        dev_dbg(chip->card->dev, "dsp_spos: creating PCM \"%s\" (%d)\n",
+                scb_name, pcm_channel_id);
 
         pcm_scb = cs46xx_dsp_create_pcm_reader_scb(chip,scb_name,
                                                    pcm_reader_buffer_addr[pcm_index],
@@ -1369,7 +1385,8 @@ cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip,
                            );
 
         if (!pcm_scb) {
-                snd_printk (KERN_ERR "dsp_spos: failed to create PCMreaderSCB\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: failed to create PCMreaderSCB\n");
                 return NULL;
         }
         
@@ -1419,7 +1436,8 @@ int cs46xx_dsp_pcm_channel_set_period (struct snd_cs46xx * chip,
                 temp |= DMA_RQ_C1_SOURCE_MOD16;
                 break; 
         default:
-                snd_printdd ("period size (%d) not supported by HW\n", period_size);
+                dev_dbg(chip->card->dev,
+                        "period size (%d) not supported by HW\n", period_size);
                 return -EINVAL;
         }
 
@@ -1457,7 +1475,8 @@ int cs46xx_dsp_pcm_ostream_set_period (struct snd_cs46xx * chip,
                 temp |= DMA_RQ_C1_DEST_MOD16;
                 break; 
         default:
-                snd_printdd ("period size (%d) not supported by HW\n", period_size);
+                dev_dbg(chip->card->dev,
+                        "period size (%d) not supported by HW\n", period_size);
                 return -EINVAL;
         }
 
diff --git a/sound/pci/cs5530.c b/sound/pci/cs5530.c
index 8037e8600a72..b4e0ff6a99a3 100644
--- a/sound/pci/cs5530.c
+++ b/sound/pci/cs5530.c
@@ -160,17 +160,17 @@ static int snd_cs5530_create(struct snd_card *card,
         sb_base = 0x220 + 0x20 * (map & 3);
 
         if (map & (1<<2))
-                printk(KERN_INFO "CS5530: XpressAudio at 0x%lx\n", sb_base);
+                dev_info(card->dev, "XpressAudio at 0x%lx\n", sb_base);
         else {
-                printk(KERN_ERR "Could not find XpressAudio!\n");
+                dev_err(card->dev, "Could not find XpressAudio!\n");
                 snd_cs5530_free(chip);
                 return -ENODEV;
         }
 
         if (map & (1<<5))
-                printk(KERN_INFO "CS5530: MPU at 0x300\n");
+                dev_info(card->dev, "MPU at 0x300\n");
         else if (map & (1<<6))
-                printk(KERN_INFO "CS5530: MPU at 0x330\n");
+                dev_info(card->dev, "MPU at 0x330\n");
 
         irq = snd_cs5530_mixer_read(sb_base, 0x80) & 0x0F;
         dma8 = snd_cs5530_mixer_read(sb_base, 0x81);
@@ -182,7 +182,7 @@ static int snd_cs5530_create(struct snd_card *card,
         else if (dma8 & 0x80)
                 dma16 = 7;
         else {
-                printk(KERN_ERR "CS5530: No 16bit DMA enabled\n");
+                dev_err(card->dev, "No 16bit DMA enabled\n");
                 snd_cs5530_free(chip);
                 return -ENODEV;
         }
@@ -194,7 +194,7 @@ static int snd_cs5530_create(struct snd_card *card,
         else if (dma8 & 0x08)
                 dma8 = 3;
         else {
-                printk(KERN_ERR "CS5530: No 8bit DMA enabled\n");
+                dev_err(card->dev, "No 8bit DMA enabled\n");
                 snd_cs5530_free(chip);
                 return -ENODEV;
         }
@@ -208,32 +208,31 @@ static int snd_cs5530_create(struct snd_card *card,
         else if (irq & 8)
                 irq = 10;
         else {
-                printk(KERN_ERR "CS5530: SoundBlaster IRQ not set\n");
+                dev_err(card->dev, "SoundBlaster IRQ not set\n");
                 snd_cs5530_free(chip);
                 return -ENODEV;
         }
 
-        printk(KERN_INFO "CS5530: IRQ: %d DMA8: %d DMA16: %d\n", irq, dma8, 
-                                                                        dma16);
+        dev_info(card->dev, "IRQ: %d DMA8: %d DMA16: %d\n", irq, dma8, dma16);
 
         err = snd_sbdsp_create(card, sb_base, irq, snd_sb16dsp_interrupt, dma8,
                                                 dma16, SB_HW_CS5530, &chip->sb);
         if (err < 0) {
-                printk(KERN_ERR "CS5530: Could not create SoundBlaster\n");
+                dev_err(card->dev, "Could not create SoundBlaster\n");
                 snd_cs5530_free(chip);
                 return err;
         }
 
         err = snd_sb16dsp_pcm(chip->sb, 0, &chip->sb->pcm);
         if (err < 0) {
-                printk(KERN_ERR "CS5530: Could not create PCM\n");
+                dev_err(card->dev, "Could not create PCM\n");
                 snd_cs5530_free(chip);
                 return err;
         }
 
         err = snd_sbmixer_new(chip->sb);
         if (err < 0) {
-                printk(KERN_ERR "CS5530: Could not create Mixer\n");
+                dev_err(card->dev, "Could not create Mixer\n");
                 snd_cs5530_free(chip);
                 return err;
         }
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index 051b3e28e341..edcbbda5c488 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -84,7 +84,8 @@ static void wait_till_cmd_acked(struct cs5535audio *cs5535au, unsigned long time
                 udelay(1);
         } while (--timeout);
         if (!timeout)
-                snd_printk(KERN_ERR "Failure writing to cs5535 codec\n");
+                dev_err(cs5535au->card->dev,
+                        "Failure writing to cs5535 codec\n");
 }
 
 static unsigned short snd_cs5535audio_codec_read(struct cs5535audio *cs5535au,
@@ -109,8 +110,9 @@ static unsigned short snd_cs5535audio_codec_read(struct cs5535audio *cs5535au,
                 udelay(1);
         } while (--timeout);
         if (!timeout)
-                snd_printk(KERN_ERR "Failure reading codec reg 0x%x,"
-                                        "Last value=0x%x\n", reg, val);
+                dev_err(cs5535au->card->dev,
+                        "Failure reading codec reg 0x%x, Last value=0x%x\n",
+                        reg, val);
 
         return (unsigned short) val;
 }
@@ -168,7 +170,7 @@ static int snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
         olpc_prequirks(card, &ac97);
 
         if ((err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97)) < 0) {
-                snd_printk(KERN_ERR "mixer failed\n");
+                dev_err(card->dev, "mixer failed\n");
                 return err;
         }
 
@@ -176,7 +178,7 @@ static int snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
 
         err = olpc_quirks(card, cs5535au->ac97);
         if (err < 0) {
-                snd_printk(KERN_ERR "olpc quirks failed\n");
+                dev_err(card->dev, "olpc quirks failed\n");
                 return err;
         }
 
@@ -194,8 +196,9 @@ static void process_bm0_irq(struct cs5535audio *cs5535au)
                 dma = cs5535au->playback_substream->runtime->private_data;
                 snd_pcm_period_elapsed(cs5535au->playback_substream);
         } else {
-                snd_printk(KERN_ERR "unexpected bm0 irq src, bm_stat=%x\n",
-                                        bm_stat);
+                dev_err(cs5535au->card->dev,
+                        "unexpected bm0 irq src, bm_stat=%x\n",
+                        bm_stat);
         }
 }
 
@@ -241,8 +244,9 @@ static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id)
                                 process_bm1_irq(cs5535au);
                                 break;
                         default:
-                                snd_printk(KERN_ERR "Unexpected irq src: "
-                                                "0x%x\n", acc_irq_stat);
+                                dev_err(cs5535au->card->dev,
+                                        "Unexpected irq src: 0x%x\n",
+                                        acc_irq_stat);
                                 break;
                         }
                 }
@@ -287,7 +291,7 @@ static int snd_cs5535audio_create(struct snd_card *card,
 
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
-                printk(KERN_WARNING "unable to get 32bit dma\n");
+                dev_warn(card->dev, "unable to get 32bit dma\n");
                 err = -ENXIO;
                 goto pcifail;
         }
@@ -312,7 +316,7 @@ static int snd_cs5535audio_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_cs5535audio_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 err = -EBUSY;
                 goto sndfail;
         }
diff --git a/sound/pci/cs5535audio/cs5535audio_olpc.c b/sound/pci/cs5535audio/cs5535audio_olpc.c
index e6a44507d557..3b0fdaca8dc7 100644
--- a/sound/pci/cs5535audio/cs5535audio_olpc.c
+++ b/sound/pci/cs5535audio/cs5535audio_olpc.c
@@ -36,7 +36,8 @@ void olpc_analog_input(struct snd_ac97 *ac97, int on)
         err = snd_ac97_update_bits(ac97, AC97_AD_TEST2,
                         1 << AC97_AD_HPFD_SHIFT, on << AC97_AD_HPFD_SHIFT);
         if (err < 0) {
-                snd_printk(KERN_ERR "setting High Pass Filter - %d\n", err);
+                dev_err(ac97->bus->card->dev,
+                        "setting High Pass Filter - %d\n", err);
                 return;
         }
 
@@ -58,7 +59,7 @@ void olpc_mic_bias(struct snd_ac97 *ac97, int on)
         err = snd_ac97_update_bits(ac97, AC97_AD_MISC,
                         1 << AC97_AD_VREFD_SHIFT, on << AC97_AD_VREFD_SHIFT);
         if (err < 0)
-                snd_printk(KERN_ERR "setting MIC Bias - %d\n", err);
+                dev_err(ac97->bus->card->dev, "setting MIC Bias - %d\n", err);
 }
 
 static int olpc_dc_info(struct snd_kcontrol *kctl,
@@ -153,7 +154,7 @@ int olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)
                 return 0;
 
         if (gpio_request(OLPC_GPIO_MIC_AC, DRV_NAME)) {
-                printk(KERN_ERR DRV_NAME ": unable to allocate MIC GPIO\n");
+                dev_err(card->dev, "unable to allocate MIC GPIO\n");
                 return -EIO;
         }
         gpio_direction_output(OLPC_GPIO_MIC_AC, 0);
diff --git a/sound/pci/cs5535audio/cs5535audio_pcm.c b/sound/pci/cs5535audio/cs5535audio_pcm.c
index 9ab01a7047cf..9c2dc911d8d7 100644
--- a/sound/pci/cs5535audio/cs5535audio_pcm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pcm.c
@@ -317,7 +317,7 @@ static int snd_cs5535audio_trigger(struct snd_pcm_substream *substream, int cmd)
                 dma->ops->disable_dma(cs5535au);
                 break;
         default:
-                snd_printk(KERN_ERR "unhandled trigger\n");
+                dev_err(cs5535au->card->dev, "unhandled trigger\n");
                 err = -EINVAL;
                 break;
         }
@@ -335,13 +335,13 @@ static snd_pcm_uframes_t snd_cs5535audio_pcm_pointer(struct snd_pcm_substream
         dma = substream->runtime->private_data;
         curdma = dma->ops->read_dma_pntr(cs5535au);
         if (curdma < dma->buf_addr) {
-                snd_printk(KERN_ERR "curdma=%x < %x bufaddr.\n",
+                dev_err(cs5535au->card->dev, "curdma=%x < %x bufaddr.\n",
                                         curdma, dma->buf_addr);
                 return 0;
         }
         curdma -= dma->buf_addr;
         if (curdma >= dma->buf_bytes) {
-                snd_printk(KERN_ERR "diff=%x >= %x buf_bytes.\n",
+                dev_err(cs5535au->card->dev, "diff=%x >= %x buf_bytes.\n",
                                         curdma, dma->buf_bytes);
                 return 0;
         }
diff --git a/sound/pci/cs5535audio/cs5535audio_pm.c b/sound/pci/cs5535audio/cs5535audio_pm.c
index 6c34def5986d..34cc60057d0c 100644
--- a/sound/pci/cs5535audio/cs5535audio_pm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pm.c
@@ -74,7 +74,7 @@ static int snd_cs5535audio_suspend(struct device *dev)
         snd_cs5535audio_stop_hardware(cs5535au);
 
         if (pci_save_state(pci)) {
-                printk(KERN_ERR "cs5535audio: pci_save_state failed!\n");
+                dev_err(dev, "pci_save_state failed!\n");
                 return -EIO;
         }
         pci_disable_device(pci);
@@ -94,8 +94,7 @@ static int snd_cs5535audio_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "cs5535audio: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -113,7 +112,7 @@ static int snd_cs5535audio_resume(struct device *dev)
         } while (--timeout);
 
         if (!timeout)
-                snd_printk(KERN_ERR "Failure getting AC Link ready\n");
+                dev_err(cs5535au->card->dev, "Failure getting AC Link ready\n");
 
         /* set up rate regs, dma. actual initiation is done in trig */
         for (i = 0; i < NUM_CS5535AUDIO_DMAS; i++) {
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 1ef77c0d39ec..166ec0c120d4 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -58,7 +58,8 @@ static int get_firmware(const struct firmware **fw_entry,
         snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data);
         err = request_firmware(fw_entry, name, pci_device(chip));
         if (err < 0)
-                snd_printk(KERN_ERR "get_firmware(): Firmware not available (%d)\n", err);
+                dev_err(chip->card->dev,
+                        "get_firmware(): Firmware not available (%d)\n", err);
 #ifdef CONFIG_PM_SLEEP
         else
                 chip->fw_cache[fw_index] = *fw_entry;
@@ -563,7 +564,7 @@ static int init_engine(struct snd_pcm_substream *substream,
         err = snd_pcm_lib_malloc_pages(substream,
                                        params_buffer_bytes(hw_params));
         if (err < 0) {
-                snd_printk(KERN_ERR "malloc_pages err=%d\n", err);
+                dev_err(chip->card->dev, "malloc_pages err=%d\n", err);
                 spin_lock_irq(&chip->lock);
                 free_pipes(chip, pipe);
                 spin_unlock_irq(&chip->lock);
@@ -1990,7 +1991,7 @@ static int snd_echo_create(struct snd_card *card,
         if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
                                               ECHOCARD_NAME)) == NULL) {
                 snd_echo_free(chip);
-                snd_printk(KERN_ERR "cannot get memory region\n");
+                dev_err(chip->card->dev, "cannot get memory region\n");
                 return -EBUSY;
         }
         chip->dsp_registers = (volatile u32 __iomem *)
@@ -1999,7 +2000,7 @@ static int snd_echo_create(struct snd_card *card,
         if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
                 snd_echo_free(chip);
-                snd_printk(KERN_ERR "cannot grab irq\n");
+                dev_err(chip->card->dev, "cannot grab irq\n");
                 return -EBUSY;
         }
         chip->irq = pci->irq;
@@ -2012,7 +2013,7 @@ static int snd_echo_create(struct snd_card *card,
                                 sizeof(struct comm_page),
                                 &chip->commpage_dma_buf) < 0) {
                 snd_echo_free(chip);
-                snd_printk(KERN_ERR "cannot allocate the comm page\n");
+                dev_err(chip->card->dev, "cannot allocate the comm page\n");
                 return -ENOMEM;
         }
         chip->comm_page_phys = chip->commpage_dma_buf.addr;
@@ -2081,7 +2082,7 @@ static int snd_echo_probe(struct pci_dev *pci,
                 chip->dsp_registers_phys, chip->irq);
 
         if ((err = snd_echo_new_pcm(chip)) < 0) {
-                snd_printk(KERN_ERR "new pcm error %d\n", err);
+                dev_err(chip->card->dev, "new pcm error %d\n", err);
                 snd_card_free(card);
                 return err;
         }
@@ -2089,7 +2090,7 @@ static int snd_echo_probe(struct pci_dev *pci,
 #ifdef ECHOCARD_HAS_MIDI
         if (chip->has_midi) {   /* Some Mia's do not have midi */
                 if ((err = snd_echo_midi_create(card, chip)) < 0) {
-                        snd_printk(KERN_ERR "new midi error %d\n", err);
+                        dev_err(chip->card->dev, "new midi error %d\n", err);
                         snd_card_free(card);
                         return err;
                 }
@@ -2188,14 +2189,14 @@ static int snd_echo_probe(struct pci_dev *pci,
         err = snd_card_register(card);
         if (err < 0)
                 goto ctl_error;
-        snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
+        dev_info(card->dev, "Card registered: %s\n", card->longname);
 
         pci_set_drvdata(pci, chip);
         dev++;
         return 0;
 
 ctl_error:
-        snd_printk(KERN_ERR "new control error %d\n", err);
+        dev_err(card->dev, "new control error %d\n", err);
         snd_card_free(card);
         return err;
 }
@@ -2291,7 +2292,7 @@ static int snd_echo_resume(struct device *dev)
         if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
                 snd_echo_free(chip);
-                snd_printk(KERN_ERR "cannot grab irq\n");
+                dev_err(chip->card->dev, "cannot grab irq\n");
                 return -EBUSY;
         }
         chip->irq = pci->irq;
diff --git a/sound/pci/echoaudio/echoaudio_dsp.c b/sound/pci/echoaudio/echoaudio_dsp.c
index d8c670c9d62c..5a6a217b82e0 100644
--- a/sound/pci/echoaudio/echoaudio_dsp.c
+++ b/sound/pci/echoaudio/echoaudio_dsp.c
@@ -53,7 +53,7 @@ static int wait_handshake(struct echoaudio *chip)
                 udelay(1);
         }
 
-        snd_printk(KERN_ERR "wait_handshake(): Timeout waiting for DSP\n");
+        dev_err(chip->card->dev, "wait_handshake(): Timeout waiting for DSP\n");
         return -EBUSY;
 }
 
@@ -149,7 +149,8 @@ static int read_sn(struct echoaudio *chip)
 
         for (i = 0; i < 5; i++) {
                 if (read_dsp(chip, &sn[i])) {
-                        snd_printk(KERN_ERR "Failed to read serial number\n");
+                        dev_err(chip->card->dev,
+                                "Failed to read serial number\n");
                         return -EIO;
                 }
         }
@@ -184,7 +185,7 @@ static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic)
 
         err = get_firmware(&fw, chip, asic);
         if (err < 0) {
-                snd_printk(KERN_WARNING "Firmware not found !\n");
+                dev_warn(chip->card->dev, "Firmware not found !\n");
                 return err;
         }
 
@@ -247,7 +248,7 @@ static int install_resident_loader(struct echoaudio *chip)
 
         i = get_firmware(&fw, chip, FW_361_LOADER);
         if (i < 0) {
-                snd_printk(KERN_WARNING "Firmware not found !\n");
+                dev_warn(chip->card->dev, "Firmware not found !\n");
                 return i;
         }
 
diff --git a/sound/pci/echoaudio/midi.c b/sound/pci/echoaudio/midi.c
index abfd51c2530e..7f4dfae0323a 100644
--- a/sound/pci/echoaudio/midi.c
+++ b/sound/pci/echoaudio/midi.c
@@ -221,7 +221,8 @@ static void snd_echo_midi_output_write(unsigned long data)
                 DE_MID(("Try to send %d bytes...\n", bytes));
                 sent = write_midi(chip, buf, bytes);
                 if (sent < 0) {
-                        snd_printk(KERN_ERR "write_midi() error %d\n", sent);
+                        dev_err(chip->card->dev,
+                                "write_midi() error %d\n", sent);
                         /* retry later */
                         sent = 9000;
                         chip->midi_full = 1;
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index 5c0413b40dc3..ad9d9f8b48ed 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -170,7 +170,8 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci,
         if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH,
                                sizeof(struct snd_emu10k1_synth_arg), &wave) < 0 ||
             wave == NULL) {
-                snd_printk(KERN_WARNING "can't initialize Emu10k1 wavetable synth\n");
+                dev_warn(emu->card->dev,
+                         "can't initialize Emu10k1 wavetable synth\n");
         } else {
                 struct snd_emu10k1_synth_arg *arg;
                 arg = SNDRV_SEQ_DEVICE_ARGPTR(wave);
@@ -247,8 +248,7 @@ static int snd_emu10k1_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "emu10k1: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/emu10k1/emu10k1_callback.c b/sound/pci/emu10k1/emu10k1_callback.c
index cae36597aa71..3f3ef38d9b6e 100644
--- a/sound/pci/emu10k1/emu10k1_callback.c
+++ b/sound/pci/emu10k1/emu10k1_callback.c
@@ -105,7 +105,7 @@ snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw)
                         vp = &emu->voices[best[i].voice];
                         if ((ch = vp->ch) < 0) {
                                 /*
-                                printk(KERN_WARNING
+                                dev_warn(emu->card->dev,
                                        "synth_get_voice: ch < 0 (%d) ??", i);
                                 */
                                 continue;
@@ -339,7 +339,7 @@ start_voice(struct snd_emux_voice *vp)
                 return -EINVAL;
         emem->map_locked++;
         if (snd_emu10k1_memblk_map(hw, emem) < 0) {
-                /* printk(KERN_ERR "emu: cannot map!\n"); */
+                /* dev_err(hw->card->devK, "emu: cannot map!\n"); */
                 return -ENOMEM;
         }
         mapped_offset = snd_emu10k1_memblk_offset(emem) >> 1;
diff --git a/sound/pci/emu10k1/emu10k1_main.c b/sound/pci/emu10k1/emu10k1_main.c
index 75504da63613..229269788023 100644
--- a/sound/pci/emu10k1/emu10k1_main.c
+++ b/sound/pci/emu10k1/emu10k1_main.c
@@ -217,7 +217,7 @@ static int snd_emu10k1_init(struct snd_emu10k1 *emu, int enable_ir, int resume)
         }
         if (emu->card_capabilities->ca0108_chip) { /* audigy2 Value */
                 /* Hacks for Alice3 to work independent of haP16V driver */
-                snd_printk(KERN_INFO "Audigy2 value: Special config.\n");
+                dev_info(emu->card->dev, "Audigy2 value: Special config.\n");
                 /* Setup SRCMulti_I2S SamplingRate */
                 tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0);
                 tmp &= 0xfffff1ff;
@@ -723,7 +723,8 @@ static int emu1010_firmware_thread(void *data)
                 if (reg & EMU_HANA_OPTION_DOCK_OFFLINE) {
                         /* Audio Dock attached */
                         /* Return to Audio Dock programming mode */
-                        snd_printk(KERN_INFO "emu1010: Loading Audio Dock Firmware\n");
+                        dev_info(emu->card->dev,
+                                 "emu1010: Loading Audio Dock Firmware\n");
                         snd_emu1010_fpga_write(emu, EMU_HANA_FPGA_CONFIG, EMU_HANA_FPGA_CONFIG_AUDIODOCK);
 
                         if (!emu->dock_fw) {
@@ -756,19 +757,25 @@ static int emu1010_firmware_thread(void *data)
 
                         snd_emu1010_fpga_write(emu, EMU_HANA_FPGA_CONFIG, 0);
                         snd_emu1010_fpga_read(emu, EMU_HANA_IRQ_STATUS, &reg);
-                        snd_printk(KERN_INFO "emu1010: EMU_HANA+DOCK_IRQ_STATUS = 0x%x\n", reg);
+                        dev_info(emu->card->dev,
+                                 "emu1010: EMU_HANA+DOCK_IRQ_STATUS = 0x%x\n",
+                                 reg);
                         /* ID, should read & 0x7f = 0x55 when FPGA programmed. */
                         snd_emu1010_fpga_read(emu, EMU_HANA_ID, &reg);
-                        snd_printk(KERN_INFO "emu1010: EMU_HANA+DOCK_ID = 0x%x\n", reg);
+                        dev_info(emu->card->dev,
+                                 "emu1010: EMU_HANA+DOCK_ID = 0x%x\n", reg);
                         if ((reg & 0x1f) != 0x15) {
                                 /* FPGA failed to be programmed */
-                                snd_printk(KERN_INFO "emu1010: Loading Audio Dock Firmware file failed, reg = 0x%x\n", reg);
+                                dev_info(emu->card->dev,
+                                         "emu1010: Loading Audio Dock Firmware file failed, reg = 0x%x\n",
+                                         reg);
                                 continue;
                         }
-                        snd_printk(KERN_INFO "emu1010: Audio Dock Firmware loaded\n");
+                        dev_info(emu->card->dev,
+                                 "emu1010: Audio Dock Firmware loaded\n");
                         snd_emu1010_fpga_read(emu, EMU_DOCK_MAJOR_REV, &tmp);
                         snd_emu1010_fpga_read(emu, EMU_DOCK_MINOR_REV, &tmp2);
-                        snd_printk(KERN_INFO "Audio Dock ver: %u.%u\n",
+                        dev_info(emu->card->dev, "Audio Dock ver: %u.%u\n",
                                    tmp, tmp2);
                         /* Sync clocking between 1010 and Dock */
                         /* Allow DLL to settle */
@@ -777,7 +784,7 @@ static int emu1010_firmware_thread(void *data)
                         snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE);
                 }
         }
-        snd_printk(KERN_INFO "emu1010: firmware thread stopping\n");
+        dev_info(emu->card->dev, "emu1010: firmware thread stopping\n");
         return 0;
 }
 
@@ -818,7 +825,7 @@ static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
         u32 tmp, tmp2, reg;
         int err;
 
-        snd_printk(KERN_INFO "emu1010: Special config.\n");
+        dev_info(emu->card->dev, "emu1010: Special config.\n");
         /* AC97 2.1, Any 16Meg of 4Gig address, Auto-Mute, EMU32 Slave,
          * Lock Sound Memory Cache, Lock Tank Memory Cache,
          * Mute all codecs.
@@ -843,7 +850,7 @@ static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
 
         /* ID, should read & 0x7f = 0x55. (Bit 7 is the IRQ bit) */
         snd_emu1010_fpga_read(emu, EMU_HANA_ID, &reg);
-        snd_printdd("reg1 = 0x%x\n", reg);
+        dev_dbg(emu->card->dev, "reg1 = 0x%x\n", reg);
         if ((reg & 0x3f) == 0x15) {
                 /* FPGA netlist already present so clear it */
                 /* Return to programming mode */
@@ -851,13 +858,14 @@ static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
                 snd_emu1010_fpga_write(emu, EMU_HANA_FPGA_CONFIG, 0x02);
         }
         snd_emu1010_fpga_read(emu, EMU_HANA_ID, &reg);
-        snd_printdd("reg2 = 0x%x\n", reg);
+        dev_dbg(emu->card->dev, "reg2 = 0x%x\n", reg);
         if ((reg & 0x3f) == 0x15) {
                 /* FPGA failed to return to programming mode */
-                snd_printk(KERN_INFO "emu1010: FPGA failed to return to programming mode\n");
+                dev_info(emu->card->dev,
+                         "emu1010: FPGA failed to return to programming mode\n");
                 return -ENODEV;
         }
-        snd_printk(KERN_INFO "emu1010: EMU_HANA_ID = 0x%x\n", reg);
+        dev_info(emu->card->dev, "emu1010: EMU_HANA_ID = 0x%x\n", reg);
 
         if (!emu->firmware) {
                 const char *filename;
@@ -880,16 +888,19 @@ static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
 
                 err = request_firmware(&emu->firmware, filename, &emu->pci->dev);
                 if (err != 0) {
-                        snd_printk(KERN_ERR "emu1010: firmware: %s not found. Err = %d\n", filename, err);
+                        dev_info(emu->card->dev,
+                                 "emu1010: firmware: %s not found. Err = %d\n",
+                                 filename, err);
                         return err;
                 }
-                snd_printk(KERN_INFO "emu1010: firmware file = %s, size = 0x%zx\n",
+                dev_info(emu->card->dev,
+                         "emu1010: firmware file = %s, size = 0x%zx\n",
                            filename, emu->firmware->size);
         }
 
         err = snd_emu1010_load_firmware(emu, emu->firmware);
         if (err != 0) {
-                snd_printk(KERN_INFO "emu1010: Loading Firmware failed\n");
+                dev_info(emu->card->dev, "emu1010: Loading Firmware failed\n");
                 return err;
         }
 
@@ -897,21 +908,23 @@ static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
         snd_emu1010_fpga_read(emu, EMU_HANA_ID, &reg);
         if ((reg & 0x3f) != 0x15) {
                 /* FPGA failed to be programmed */
-                snd_printk(KERN_INFO "emu1010: Loading Hana Firmware file failed, reg = 0x%x\n", reg);
+                dev_info(emu->card->dev,
+                         "emu1010: Loading Hana Firmware file failed, reg = 0x%x\n",
+                         reg);
                 return -ENODEV;
         }
 
-        snd_printk(KERN_INFO "emu1010: Hana Firmware loaded\n");
+        dev_info(emu->card->dev, "emu1010: Hana Firmware loaded\n");
         snd_emu1010_fpga_read(emu, EMU_HANA_MAJOR_REV, &tmp);
         snd_emu1010_fpga_read(emu, EMU_HANA_MINOR_REV, &tmp2);
-        snd_printk(KERN_INFO "emu1010: Hana version: %u.%u\n", tmp, tmp2);
+        dev_info(emu->card->dev, "emu1010: Hana version: %u.%u\n", tmp, tmp2);
         /* Enable 48Volt power to Audio Dock */
         snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_PWR, EMU_HANA_DOCK_PWR_ON);
 
         snd_emu1010_fpga_read(emu, EMU_HANA_OPTION_CARDS, &reg);
-        snd_printk(KERN_INFO "emu1010: Card options = 0x%x\n", reg);
+        dev_info(emu->card->dev, "emu1010: Card options = 0x%x\n", reg);
         snd_emu1010_fpga_read(emu, EMU_HANA_OPTION_CARDS, &reg);
-        snd_printk(KERN_INFO "emu1010: Card options = 0x%x\n", reg);
+        dev_info(emu->card->dev, "emu1010: Card options = 0x%x\n", reg);
         snd_emu1010_fpga_read(emu, EMU_HANA_OPTICAL_TYPE, &tmp);
         /* Optical -> ADAT I/O  */
         /* 0 : SPDIF
@@ -950,7 +963,7 @@ static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
         snd_emu1010_fpga_write(emu, EMU_HANA_IRQ_ENABLE, 0x00);
 
         snd_emu1010_fpga_read(emu, EMU_HANA_OPTION_CARDS, &reg);
-        snd_printk(KERN_INFO "emu1010: Card options3 = 0x%x\n", reg);
+        dev_info(emu->card->dev, "emu1010: Card options3 = 0x%x\n", reg);
         /* Default WCLK set to 48kHz. */
         snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, 0x00);
         /* Word Clock source, Internal 48kHz x1 */
@@ -1808,7 +1821,9 @@ int snd_emu10k1_create(struct snd_card *card,
         emu->revision = pci->revision;
         pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &emu->serial);
         pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &emu->model);
-        snd_printdd("vendor = 0x%x, device = 0x%x, subsystem_vendor_id = 0x%x, subsystem_id = 0x%x\n", pci->vendor, pci->device, emu->serial, emu->model);
+        dev_dbg(card->dev,
+                "vendor = 0x%x, device = 0x%x, subsystem_vendor_id = 0x%x, subsystem_id = 0x%x\n",
+                pci->vendor, pci->device, emu->serial, emu->model);
 
         for (c = emu_chip_details; c->vendor; c++) {
                 if (c->vendor == pci->vendor && c->device == pci->device) {
@@ -1827,21 +1842,21 @@ int snd_emu10k1_create(struct snd_card *card,
                 }
         }
         if (c->vendor == 0) {
-                snd_printk(KERN_ERR "emu10k1: Card not recognised\n");
+                dev_err(card->dev, "emu10k1: Card not recognised\n");
                 kfree(emu);
                 pci_disable_device(pci);
                 return -ENOENT;
         }
         emu->card_capabilities = c;
         if (c->subsystem && !subsystem)
-                snd_printdd("Sound card name = %s\n", c->name);
+                dev_dbg(card->dev, "Sound card name = %s\n", c->name);
         else if (subsystem)
-                snd_printdd("Sound card name = %s, "
+                dev_dbg(card->dev, "Sound card name = %s, "
                         "vendor = 0x%x, device = 0x%x, subsystem = 0x%x. "
                         "Forced to subsystem = 0x%x\n", c->name,
                         pci->vendor, pci->device, emu->serial, c->subsystem);
         else
-                snd_printdd("Sound card name = %s, "
+                dev_dbg(card->dev, "Sound card name = %s, "
                         "vendor = 0x%x, device = 0x%x, subsystem = 0x%x.\n",
                         c->name, pci->vendor, pci->device,
                         emu->serial);
@@ -1869,7 +1884,9 @@ int snd_emu10k1_create(struct snd_card *card,
         emu->dma_mask = is_audigy ? AUDIGY_DMA_MASK : EMU10K1_DMA_MASK;
         if (pci_set_dma_mask(pci, emu->dma_mask) < 0 ||
             pci_set_consistent_dma_mask(pci, emu->dma_mask) < 0) {
-                snd_printk(KERN_ERR "architecture does not support PCI busmaster DMA with mask 0x%lx\n", emu->dma_mask);
+                dev_err(card->dev,
+                        "architecture does not support PCI busmaster DMA with mask 0x%lx\n",
+                        emu->dma_mask);
                 kfree(emu);
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/emu10k1/emu10k1_patch.c b/sound/pci/emu10k1/emu10k1_patch.c
index 662a45876a8b..0e069aeab86d 100644
--- a/sound/pci/emu10k1/emu10k1_patch.c
+++ b/sound/pci/emu10k1/emu10k1_patch.c
@@ -50,7 +50,8 @@ snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
                 return -EINVAL;
 
         if (sp->v.size == 0) {
-                snd_printd("emu: rom font for sample %d\n", sp->v.sample);
+                dev_dbg(emu->card->dev,
+                        "emu: rom font for sample %d\n", sp->v.sample);
                 return 0;
         }
 
@@ -92,7 +93,8 @@ snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
                 blocksize *= 2;
         sp->block = snd_emu10k1_synth_alloc(emu, blocksize);
         if (sp->block == NULL) {
-                snd_printd("emu10k1: synth malloc failed (size=%d)\n", blocksize);
+                dev_dbg(emu->card->dev,
+                        "synth malloc failed (size=%d)\n", blocksize);
                 /* not ENOMEM (for compatibility with OSS) */
                 return -ENOSPC;
         }
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index 3988eaa778cf..efe017526977 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -369,7 +369,8 @@ static void snd_emu10k1x_pcm_interrupt(struct emu10k1x *emu, struct emu10k1x_voi
         if (epcm->substream == NULL)
                 return;
 #if 0
-        snd_printk(KERN_INFO "IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
+        dev_info(emu->card->dev,
+                 "IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
                    epcm->substream->ops->pointer(epcm->substream),
                    snd_pcm_lib_period_bytes(epcm->substream),
                    snd_pcm_lib_buffer_bytes(epcm->substream));
@@ -487,7 +488,11 @@ static int snd_emu10k1x_pcm_trigger(struct snd_pcm_substream *substream,
         int channel = epcm->voice->number;
         int result = 0;
 
-//      snd_printk(KERN_INFO "trigger - emu10k1x = 0x%x, cmd = %i, pointer = %d\n", (int)emu, cmd, (int)substream->ops->pointer(substream));
+        /*
+        dev_dbg(emu->card->dev,
+                "trigger - emu10k1x = 0x%x, cmd = %i, pointer = %d\n",
+                (int)emu, cmd, (int)substream->ops->pointer(substream));
+        */
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -826,7 +831,7 @@ static irqreturn_t snd_emu10k1x_interrupt(int irq, void *dev_id)
         // acknowledge the interrupt if necessary
         outl(status, chip->port + IPR);
 
-        // snd_printk(KERN_INFO "interrupt %08x\n", status);
+        /* dev_dbg(chip->card->dev, "interrupt %08x\n", status); */
         return IRQ_HANDLED;
 }
 
@@ -919,7 +924,7 @@ static int snd_emu10k1x_create(struct snd_card *card,
                 return err;
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
-                snd_printk(KERN_ERR "error to set 28bit mask DMA\n");
+                dev_err(card->dev, "error to set 28bit mask DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -940,14 +945,15 @@ static int snd_emu10k1x_create(struct snd_card *card,
         chip->port = pci_resource_start(pci, 0);
         if ((chip->res_port = request_region(chip->port, 8,
                                              "EMU10K1X")) == NULL) { 
-                snd_printk(KERN_ERR "emu10k1x: cannot allocate the port 0x%lx\n", chip->port);
+                dev_err(card->dev, "cannot allocate the port 0x%lx\n",
+                        chip->port);
                 snd_emu10k1x_free(chip);
                 return -EBUSY;
         }
 
         if (request_irq(pci->irq, snd_emu10k1x_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "emu10k1x: cannot grab irq %d\n", pci->irq);
+                dev_err(card->dev, "cannot grab irq %d\n", pci->irq);
                 snd_emu10k1x_free(chip);
                 return -EBUSY;
         }
@@ -964,7 +970,7 @@ static int snd_emu10k1x_create(struct snd_card *card,
         chip->revision = pci->revision;
         pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
         pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
-        snd_printk(KERN_INFO "Model %04x Rev %08x Serial %08x\n", chip->model,
+        dev_info(card->dev, "Model %04x Rev %08x Serial %08x\n", chip->model,
                    chip->revision, chip->serial);
 
         outl(0, chip->port + INTE);     
@@ -1248,7 +1254,9 @@ static void mpu401_clear_rx(struct emu10k1x *emu, struct emu10k1x_midi *mpu)
                 mpu401_read_data(emu, mpu);
 #ifdef CONFIG_SND_DEBUG
         if (timeout <= 0)
-                snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n", mpu401_read_stat(emu, mpu));
+                dev_err(emu->card->dev,
+                        "cmd: clear rx timeout (status = 0x%x)\n",
+                        mpu401_read_stat(emu, mpu));
 #endif
 }
 
@@ -1322,7 +1330,8 @@ static int snd_emu10k1x_midi_cmd(struct emu10k1x * emu,
         }
         spin_unlock_irqrestore(&midi->input_lock, flags);
         if (!ok) {
-                snd_printk(KERN_ERR "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
+                dev_err(emu->card->dev,
+                        "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
                            cmd, emu->port,
                            mpu401_read_stat(emu, midi),
                            mpu401_read_data(emu, midi));
diff --git a/sound/pci/emu10k1/emufx.c b/sound/pci/emu10k1/emufx.c
index 1f9c7c4bbcd8..745f0627c634 100644
--- a/sound/pci/emu10k1/emufx.c
+++ b/sound/pci/emu10k1/emufx.c
@@ -1547,7 +1547,7 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
         /* A_PUT_STEREO_OUTPUT(A_EXTOUT_FRONT_L, A_EXTOUT_FRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); */
         if (emu->card_capabilities->emu_model) {
                 /* EMU1010 Outputs from PCM Front, Rear, Center, LFE, Side */
-                snd_printk(KERN_INFO "EMU outputs on\n");
+                dev_info(emu->card->dev, "EMU outputs on\n");
                 for (z = 0; z < 8; z++) {
                         if (emu->card_capabilities->ca0108_chip) {
                                 A_OP(icode, &ptr, iACC3, A3_EMU32OUT(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000);
@@ -1571,7 +1571,9 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
                 A_SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1);
                 if ((z==1) && (emu->card_capabilities->spdif_bug)) {
                         /* Due to a SPDIF output bug on some Audigy cards, this code delays the Right channel by 1 sample */
-                        snd_printk(KERN_INFO "Installing spdif_bug patch: %s\n", emu->card_capabilities->name);
+                        dev_info(emu->card->dev,
+                                 "Installing spdif_bug patch: %s\n",
+                                 emu->card_capabilities->name);
                         A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(gpr - 3), A_C_00000000, A_C_00000000);
                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 3), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000);
                 } else {
@@ -1595,7 +1597,7 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
 
         if (emu->card_capabilities->emu_model) {
                 if (emu->card_capabilities->ca0108_chip) {
-                        snd_printk(KERN_INFO "EMU2 inputs on\n");
+                        dev_info(emu->card->dev, "EMU2 inputs on\n");
                         for (z = 0; z < 0x10; z++) {
                                 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, 
                                                                         bit_shifter16,
@@ -1603,11 +1605,11 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
                                                                         A_FXBUS2(z*2) );
                         }
                 } else {
-                        snd_printk(KERN_INFO "EMU inputs on\n");
+                        dev_info(emu->card->dev, "EMU inputs on\n");
                         /* Capture 16 (originally 8) channels of S32_LE sound */
 
                         /*
-                        printk(KERN_DEBUG "emufx.c: gpr=0x%x, tmp=0x%x\n",
+                        dev_dbg(emu->card->dev, "emufx.c: gpr=0x%x, tmp=0x%x\n",
                                gpr, tmp);
                         */
                         /* For the EMU1010: How to get 32bit values from the DSP. High 16bits into L, low 16bits into R. */
diff --git a/sound/pci/emu10k1/emumixer.c b/sound/pci/emu10k1/emumixer.c
index f6c3da0d377d..c5ae2a24d8a5 100644
--- a/sound/pci/emu10k1/emumixer.c
+++ b/sound/pci/emu10k1/emumixer.c
@@ -1853,8 +1853,10 @@ int snd_emu10k1_mixer(struct snd_emu10k1 *emu,
                 if ((err = snd_ac97_mixer(pbus, &ac97, &emu->ac97)) < 0) {
                         if (emu->card_capabilities->ac97_chip == 1)
                                 return err;
-                        snd_printd(KERN_INFO "emu10k1: AC97 is optional on this board\n");
-                        snd_printd(KERN_INFO"          Proceeding without ac97 mixers...\n");
+                        dev_info(emu->card->dev,
+                                 "AC97 is optional on this board\n");
+                        dev_info(emu->card->dev,
+                                 "Proceeding without ac97 mixers...\n");
                         snd_device_free(emu->card, pbus);
                         goto no_ac97; /* FIXME: get rid of ugly gotos.. */
                 }
diff --git a/sound/pci/emu10k1/emumpu401.c b/sound/pci/emu10k1/emumpu401.c
index 1ec91246dfee..fdf2b0ada489 100644
--- a/sound/pci/emu10k1/emumpu401.c
+++ b/sound/pci/emu10k1/emumpu401.c
@@ -64,7 +64,9 @@ static void mpu401_clear_rx(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mp
                 mpu401_read_data(emu, mpu);
 #ifdef CONFIG_SND_DEBUG
         if (timeout <= 0)
-                snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n", mpu401_read_stat(emu, mpu));
+                dev_err(emu->card->dev,
+                        "cmd: clear rx timeout (status = 0x%x)\n",
+                        mpu401_read_stat(emu, mpu));
 #endif
 }
 
@@ -141,7 +143,8 @@ static int snd_emu10k1_midi_cmd(struct snd_emu10k1 * emu, struct snd_emu10k1_mid
         }
         spin_unlock_irqrestore(&midi->input_lock, flags);
         if (!ok) {
-                snd_printk(KERN_ERR "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
+                dev_err(emu->card->dev,
+                        "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
                            cmd, emu->port,
                            mpu401_read_stat(emu, midi),
                            mpu401_read_data(emu, midi));
diff --git a/sound/pci/emu10k1/emupcm.c b/sound/pci/emu10k1/emupcm.c
index 5ae1d045bdcb..f82481bd2542 100644
--- a/sound/pci/emu10k1/emupcm.c
+++ b/sound/pci/emu10k1/emupcm.c
@@ -44,7 +44,8 @@ static void snd_emu10k1_pcm_interrupt(struct snd_emu10k1 *emu,
         if (epcm->substream == NULL)
                 return;
 #if 0
-        printk(KERN_DEBUG "IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
+        dev_dbg(emu->card->dev,
+                "IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
                         epcm->substream->runtime->hw->pointer(emu, epcm->substream),
                         snd_pcm_lib_period_bytes(epcm->substream),
                         snd_pcm_lib_buffer_bytes(epcm->substream));
@@ -147,7 +148,7 @@ static int snd_emu10k1_pcm_channel_alloc(struct snd_emu10k1_pcm * epcm, int voic
                                               &epcm->extra);
                 if (err < 0) {
                         /*
-                        printk(KERN_DEBUG "pcm_channel_alloc: "
+                        dev_dbg(emu->card->dev, "pcm_channel_alloc: "
                                "failed extra: voices=%d, frame=%d\n",
                                voices, frame);
                         */
@@ -761,7 +762,8 @@ static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream,
         int result = 0;
 
         /*
-        printk(KERN_DEBUG "trigger - emu10k1 = 0x%x, cmd = %i, pointer = %i\n",
+        dev_dbg(emu->card->dev,
+                "trigger - emu10k1 = 0x%x, cmd = %i, pointer = %i\n",
                (int)emu, cmd, substream->ops->pointer(substream))
         */
         spin_lock(&emu->reg_lock);
@@ -815,7 +817,7 @@ static int snd_emu10k1_capture_trigger(struct snd_pcm_substream *substream,
                 outl(epcm->capture_ipr, emu->port + IPR);
                 snd_emu10k1_intr_enable(emu, epcm->capture_inte);
                 /*
-                printk(KERN_DEBUG "adccr = 0x%x, adcbs = 0x%x\n",
+                dev_dbg(emu->card->dev, "adccr = 0x%x, adcbs = 0x%x\n",
                        epcm->adccr, epcm->adcbs);
                 */
                 switch (epcm->type) {
@@ -826,7 +828,10 @@ static int snd_emu10k1_capture_trigger(struct snd_pcm_substream *substream,
                         if (emu->audigy) {
                                 snd_emu10k1_ptr_write(emu, A_FXWC1, 0, epcm->capture_cr_val);
                                 snd_emu10k1_ptr_write(emu, A_FXWC2, 0, epcm->capture_cr_val2);
-                                snd_printdd("cr_val=0x%x, cr_val2=0x%x\n", epcm->capture_cr_val, epcm->capture_cr_val2);
+                                dev_dbg(emu->card->dev,
+                                        "cr_val=0x%x, cr_val2=0x%x\n",
+                                        epcm->capture_cr_val,
+                                        epcm->capture_cr_val2);
                         } else
                                 snd_emu10k1_ptr_write(emu, FXWC, 0, epcm->capture_cr_val);
                         break;
@@ -889,7 +894,7 @@ static snd_pcm_uframes_t snd_emu10k1_playback_pointer(struct snd_pcm_substream *
         }
 #endif
         /*
-        printk(KERN_DEBUG
+        dev_dbg(emu->card->dev,
                "ptr = 0x%lx, buffer_size = 0x%lx, period_size = 0x%lx\n",
                (long)ptr, (long)runtime->buffer_size,
                (long)runtime->period_size);
@@ -1594,7 +1599,8 @@ static void snd_emu10k1_fx8010_playback_tram_poke1(unsigned short *dst_left,
                                                    unsigned int tram_shift)
 {
         /*
-        printk(KERN_DEBUG "tram_poke1: dst_left = 0x%p, dst_right = 0x%p, "
+        dev_dbg(emu->card->dev,
+                "tram_poke1: dst_left = 0x%p, dst_right = 0x%p, "
                "src = 0x%p, count = 0x%x\n",
                dst_left, dst_right, src, count);
         */
@@ -1675,7 +1681,7 @@ static int snd_emu10k1_fx8010_playback_prepare(struct snd_pcm_substream *substre
         unsigned int i;
         
         /*
-        printk(KERN_DEBUG "prepare: etram_pages = 0x%p, dma_area = 0x%x, "
+        dev_dbg(emu->card->dev, "prepare: etram_pages = 0x%p, dma_area = 0x%x, "
                "buffer_size = 0x%x (0x%x)\n",
                emu->fx8010.etram_pages, runtime->dma_area,
                runtime->buffer_size, runtime->buffer_size << 2);
diff --git a/sound/pci/emu10k1/io.c b/sound/pci/emu10k1/io.c
index e4fba49fee4a..81c75b4528d9 100644
--- a/sound/pci/emu10k1/io.c
+++ b/sound/pci/emu10k1/io.c
@@ -72,7 +72,7 @@ void snd_emu10k1_ptr_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned i
         unsigned int mask;
 
         if (!emu) {
-                snd_printk(KERN_ERR "ptr_write: emu is null!\n");
+                dev_err(emu->card->dev, "ptr_write: emu is null!\n");
                 dump_stack();
                 return;
         }
@@ -199,7 +199,7 @@ int snd_emu10k1_i2c_write(struct snd_emu10k1 *emu,
         int err = 0;
 
         if ((reg > 0x7f) || (value > 0x1ff)) {
-                snd_printk(KERN_ERR "i2c_write: invalid values.\n");
+                dev_err(emu->card->dev, "i2c_write: invalid values.\n");
                 return -EINVAL;
         }
 
@@ -227,7 +227,7 @@ int snd_emu10k1_i2c_write(struct snd_emu10k1 *emu,
                                 break;
 
                         if (timeout > 1000) {
-                                snd_printk(KERN_WARNING
+                                dev_warn(emu->card->dev,
                                            "emu10k1:I2C:timeout status=0x%x\n",
                                            status);
                                 break;
@@ -239,8 +239,8 @@ int snd_emu10k1_i2c_write(struct snd_emu10k1 *emu,
         }
 
         if (retry == 10) {
-                snd_printk(KERN_ERR "Writing to ADC failed!\n");
-                snd_printk(KERN_ERR "status=0x%x, reg=%d, value=%d\n",
+                dev_err(emu->card->dev, "Writing to ADC failed!\n");
+                dev_err(emu->card->dev, "status=0x%x, reg=%d, value=%d\n",
                         status, reg, value);
                 /* dump_stack(); */
                 err = -EINVAL;
diff --git a/sound/pci/emu10k1/irq.c b/sound/pci/emu10k1/irq.c
index 30bfed6f8339..3c5c5e3dc2d9 100644
--- a/sound/pci/emu10k1/irq.c
+++ b/sound/pci/emu10k1/irq.c
@@ -41,11 +41,12 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id)
                 orig_status = status;
                 handled = 1;
                 if ((status & 0xffffffff) == 0xffffffff) {
-                        snd_printk(KERN_INFO "snd-emu10k1: Suspected sound card removal\n");
+                        dev_info(emu->card->dev,
+                                 "Suspected sound card removal\n");
                         break;
                 }
                 if (status & IPR_PCIERROR) {
-                        snd_printk(KERN_ERR "interrupt: PCI error\n");
+                        dev_err(emu->card->dev, "interrupt: PCI error\n");
                         snd_emu10k1_intr_disable(emu, INTE_PCIERRORENABLE);
                         status &= ~IPR_PCIERROR;
                 }
@@ -157,19 +158,22 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id)
                                 struct snd_emu10k1_voice *pvoice = &(emu->p16v_voices[0]);
                                 struct snd_emu10k1_voice *cvoice = &(emu->p16v_capture_voice);
 
-                                //printk(KERN_INFO "status2=0x%x\n", status2);
+                                /* dev_dbg(emu->card->dev, "status2=0x%x\n", status2); */
                                 orig_status2 = status2;
                                 if(status2 & mask) {
                                         if(pvoice->use) {
                                                 snd_pcm_period_elapsed(pvoice->epcm->substream);
                                         } else { 
-                                                snd_printk(KERN_ERR "p16v: status: 0x%08x, mask=0x%08x, pvoice=%p, use=%d\n", status2, mask, pvoice, pvoice->use);
+                                                dev_err(emu->card->dev,
+                                                        "p16v: status: 0x%08x, mask=0x%08x, pvoice=%p, use=%d\n",
+                                                        status2, mask, pvoice,
+                                                        pvoice->use);
                                         }
                                 }
                                 if(status2 & 0x110000) {
-                                        //printk(KERN_INFO "capture int found\n");
+                                        /* dev_info(emu->card->dev, "capture int found\n"); */
                                         if(cvoice->use) {
-                                                //printk(KERN_INFO "capture period_elapsed\n");
+                                                /* dev_info(emu->card->dev, "capture period_elapsed\n"); */
                                                 snd_pcm_period_elapsed(cvoice->epcm->substream);
                                         }
                                 }
@@ -180,7 +184,8 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id)
 
                 if (status) {
                         unsigned int bits;
-                        snd_printk(KERN_ERR "emu10k1: unhandled interrupt: 0x%08x\n", status);
+                        dev_err(emu->card->dev,
+                                "unhandled interrupt: 0x%08x\n", status);
                         //make sure any interrupts we don't handle are disabled:
                         bits = INTE_FXDSPENABLE |
                                 INTE_PCIERRORENABLE |
@@ -202,7 +207,7 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id)
                 outl(orig_status, emu->port + IPR); /* ack all */
         }
         if (timeout == 1000)
-                snd_printk(KERN_INFO "emu10k1 irq routine failure\n");
+                dev_info(emu->card->dev, "emu10k1 irq routine failure\n");
 
         return IRQ_RETVAL(handled);
 }
diff --git a/sound/pci/emu10k1/memory.c b/sound/pci/emu10k1/memory.c
index ae709c1ab3a8..c68e6dd2fa67 100644
--- a/sound/pci/emu10k1/memory.c
+++ b/sound/pci/emu10k1/memory.c
@@ -236,11 +236,13 @@ __found_pages:
 static int is_valid_page(struct snd_emu10k1 *emu, dma_addr_t addr)
 {
         if (addr & ~emu->dma_mask) {
-                snd_printk(KERN_ERR "max memory size is 0x%lx (addr = 0x%lx)!!\n", emu->dma_mask, (unsigned long)addr);
+                dev_err(emu->card->dev,
+                        "max memory size is 0x%lx (addr = 0x%lx)!!\n",
+                        emu->dma_mask, (unsigned long)addr);
                 return 0;
         }
         if (addr & (EMUPAGESIZE-1)) {
-                snd_printk(KERN_ERR "page is not aligned\n");
+                dev_err(emu->card->dev, "page is not aligned\n");
                 return 0;
         }
         return 1;
@@ -331,7 +333,8 @@ snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *subst
                 else
                         addr = snd_pcm_sgbuf_get_addr(substream, ofs);
                 if (! is_valid_page(emu, addr)) {
-                        printk(KERN_ERR "emu: failure page = %d\n", idx);
+                        dev_err(emu->card->dev,
+                                "emu: failure page = %d\n", idx);
                         mutex_unlock(&hdr->block_mutex);
                         return NULL;
                 }
@@ -507,7 +510,8 @@ static inline void *offset_ptr(struct snd_emu10k1 *emu, int page, int offset)
                 return NULL;
         ptr = emu->page_ptr_table[page];
         if (! ptr) {
-                printk(KERN_ERR "emu10k1: access to NULL ptr: page = %d\n", page);
+                dev_err(emu->card->dev,
+                        "access to NULL ptr: page = %d\n", page);
                 return NULL;
         }
         ptr += offset & (PAGE_SIZE - 1);
diff --git a/sound/pci/emu10k1/p16v.c b/sound/pci/emu10k1/p16v.c
index 7e2025cd6d9c..a4fe7f0c9458 100644
--- a/sound/pci/emu10k1/p16v.c
+++ b/sound/pci/emu10k1/p16v.c
@@ -168,7 +168,7 @@ static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime *runtime)
         struct snd_emu10k1_pcm *epcm = runtime->private_data;
   
         if (epcm) {
-                /* snd_printk(KERN_DEBUG "epcm free: %p\n", epcm); */
+                /* dev_dbg(emu->card->dev, "epcm free: %p\n", epcm); */
                 kfree(epcm);
         }
 }
@@ -183,14 +183,14 @@ static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream *substrea
         int err;
 
         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
-        /* snd_printk(KERN_DEBUG "epcm kcalloc: %p\n", epcm); */
+        /* dev_dbg(emu->card->dev, "epcm kcalloc: %p\n", epcm); */
 
         if (epcm == NULL)
                 return -ENOMEM;
         epcm->emu = emu;
         epcm->substream = substream;
         /*
-        snd_printk(KERN_DEBUG "epcm device=%d, channel_id=%d\n",
+        dev_dbg(emu->card->dev, "epcm device=%d, channel_id=%d\n",
                    substream->pcm->device, channel_id);
         */
         runtime->private_data = epcm;
@@ -203,10 +203,10 @@ static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream *substrea
 
         channel->use=1;
 #if 0 /* debug */
-        snd_printk(KERN_DEBUG
+        dev_dbg(emu->card->dev,
                    "p16v: open channel_id=%d, channel=%p, use=0x%x\n",
                    channel_id, channel, channel->use);
-        printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
+        dev_dbg(emu->card->dev, "open:channel_id=%d, chip=%p, channel=%p\n",
                channel_id, chip, channel);
 #endif /* debug */
         /* channel->interrupt = snd_p16v_pcm_channel_interrupt; */
@@ -231,14 +231,14 @@ static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream *substream
         int err;
 
         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
-        /* snd_printk(KERN_DEBUG "epcm kcalloc: %p\n", epcm); */
+        /* dev_dbg(emu->card->dev, "epcm kcalloc: %p\n", epcm); */
 
         if (epcm == NULL)
                 return -ENOMEM;
         epcm->emu = emu;
         epcm->substream = substream;
         /*
-        snd_printk(KERN_DEBUG "epcm device=%d, channel_id=%d\n",
+        dev_dbg(emu->card->dev, "epcm device=%d, channel_id=%d\n",
                    substream->pcm->device, channel_id);
         */
         runtime->private_data = epcm;
@@ -251,10 +251,10 @@ static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream *substream
 
         channel->use=1;
 #if 0 /* debug */
-        snd_printk(KERN_DEBUG
+        dev_dbg(emu->card->dev,
                    "p16v: open channel_id=%d, channel=%p, use=0x%x\n",
                    channel_id, channel, channel->use);
-        printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
+        dev_dbg(emu->card->dev, "open:channel_id=%d, chip=%p, channel=%p\n",
                channel_id, chip, channel);
 #endif /* debug */
         /* channel->interrupt = snd_p16v_pcm_channel_interrupt; */
@@ -349,15 +349,18 @@ static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream)
         u32 tmp;
         
 #if 0 /* debug */
-        snd_printk(KERN_DEBUG "prepare:channel_number=%d, rate=%d, "
+        dev_dbg(emu->card->dev,
+                "prepare:channel_number=%d, rate=%d, "
                    "format=0x%x, channels=%d, buffer_size=%ld, "
                    "period_size=%ld, periods=%u, frames_to_bytes=%d\n",
                    channel, runtime->rate, runtime->format, runtime->channels,
                    runtime->buffer_size, runtime->period_size,
                    runtime->periods, frames_to_bytes(runtime, 1));
-        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
+        dev_dbg(emu->card->dev,
+                "dma_addr=%x, dma_area=%p, table_base=%p\n",
                    runtime->dma_addr, runtime->dma_area, table_base);
-        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
+        dev_dbg(emu->card->dev,
+                "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
                    emu->p16v_buffer.addr, emu->p16v_buffer.area,
                    emu->p16v_buffer.bytes);
 #endif /* debug */
@@ -405,7 +408,7 @@ static int snd_p16v_pcm_prepare_capture(struct snd_pcm_substream *substream)
         u32 tmp;
 
         /*
-        printk(KERN_DEBUG "prepare capture:channel_number=%d, rate=%d, "
+        dev_dbg(emu->card->dev, "prepare capture:channel_number=%d, rate=%d, "
                "format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, "
                "frames_to_bytes=%d\n",
                channel, runtime->rate, runtime->format, runtime->channels,
@@ -491,13 +494,13 @@ static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream *substream,
                 runtime = s->runtime;
                 epcm = runtime->private_data;
                 channel = substream->pcm->device-emu->p16v_device_offset;
-                /* snd_printk(KERN_DEBUG "p16v channel=%d\n", channel); */
+                /* dev_dbg(emu->card->dev, "p16v channel=%d\n", channel); */
                 epcm->running = running;
                 basic |= (0x1<<channel);
                 inte |= (INTE2_PLAYBACK_CH_0_LOOP<<channel);
                 snd_pcm_trigger_done(s, substream);
         }
-        /* snd_printk(KERN_DEBUG "basic=0x%x, inte=0x%x\n", basic, inte); */
+        /* dev_dbg(emu->card->dev, "basic=0x%x, inte=0x%x\n", basic, inte); */
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -588,10 +591,10 @@ snd_p16v_pcm_pointer_capture(struct snd_pcm_substream *substream)
         ptr=ptr2;
         if (ptr >= runtime->buffer_size) {
                 ptr -= runtime->buffer_size;
-                printk(KERN_WARNING "buffer capture limited!\n");
+                dev_warn(emu->card->dev, "buffer capture limited!\n");
         }
         /*
-        printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
+        dev_dbg(emu->card->dev, "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
                "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
                ptr1, ptr2, ptr, (int)runtime->buffer_size,
                (int)runtime->period_size, (int)runtime->frame_bits,
@@ -630,7 +633,7 @@ int snd_p16v_free(struct snd_emu10k1 *chip)
         if (chip->p16v_buffer.area) {
                 snd_dma_free_pages(&chip->p16v_buffer);
                 /*
-                snd_printk(KERN_DEBUG "period lables free: %p\n",
+                dev_dbg(chip->card->dev, "period lables free: %p\n",
                            &chip->p16v_buffer);
                 */
         }
@@ -644,7 +647,7 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
         int err;
         int capture=1;
   
-        /* snd_printk(KERN_DEBUG "snd_p16v_pcm called. device=%d\n", device); */
+        /* dev_dbg(emu->card->dev, "snd_p16v_pcm called. device=%d\n", device); */
         emu->p16v_device_offset = device;
         if (rpcm)
                 *rpcm = NULL;
@@ -672,7 +675,7 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
                                                          ((65536 - 64) * 8), ((65536 - 64) * 8))) < 0) 
                         return err;
                 /*
-                snd_printk(KERN_DEBUG
+                dev_dbg(emu->card->dev,
                            "preallocate playback substream: err=%d\n", err);
                 */
         }
@@ -686,7 +689,7 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
                                                    65536 - 64, 65536 - 64)) < 0)
                         return err;
                 /*
-                snd_printk(KERN_DEBUG
+                dev_dbg(emu->card->dev,
                            "preallocate capture substream: err=%d\n", err);
                 */
         }
diff --git a/sound/pci/emu10k1/voice.c b/sound/pci/emu10k1/voice.c
index 101e7cb79cb2..f16fd5cfb7cd 100644
--- a/sound/pci/emu10k1/voice.c
+++ b/sound/pci/emu10k1/voice.c
@@ -55,7 +55,7 @@ static int voice_alloc(struct snd_emu10k1 *emu, int type, int number,
         first_voice = last_voice = 0;
         for (i = emu->next_free_voice, j = 0; j < NUM_G ; i += number, j += number) {
                 /*
-                printk(KERN_DEBUG "i %d j %d next free %d!\n",
+                dev_dbg(emu->card->dev, "i %d j %d next free %d!\n",
                        i, j, emu->next_free_voice);
                 */
                 i %= NUM_G;
@@ -75,7 +75,7 @@ static int voice_alloc(struct snd_emu10k1 *emu, int type, int number,
                         }
                 }
                 if (!skip) {
-                        /* printk(KERN_DEBUG "allocated voice %d\n", i); */
+                        /* dev_dbg(emu->card->dev, "allocated voice %d\n", i); */
                         first_voice = i;
                         last_voice = (i + number) % NUM_G;
                         emu->next_free_voice = last_voice;
@@ -89,7 +89,7 @@ static int voice_alloc(struct snd_emu10k1 *emu, int type, int number,
         for (i = 0; i < number; i++) {
                 voice = &emu->voices[(first_voice + i) % NUM_G];
                 /*
-                printk(kERN_DEBUG "voice alloc - %i, %i of %i\n",
+                dev_dbg(emu->card->dev, "voice alloc - %i, %i of %i\n",
                        voice->number, idx-first_voice+1, number);
                 */
                 voice->use = 1;
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index 0f89d2a2090e..29cd339ffc37 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -525,7 +525,7 @@ static unsigned int snd_es1371_wait_src_ready(struct ensoniq * ensoniq)
                         return r;
                 cond_resched();
         }
-        snd_printk(KERN_ERR "wait src ready timeout 0x%lx [0x%x]\n",
+        dev_err(ensoniq->card->dev, "wait src ready timeout 0x%lx [0x%x]\n",
                    ES_REG(ensoniq, 1371_SMPRATE), r);
         return 0;
 }
@@ -587,7 +587,7 @@ static void snd_es1370_codec_write(struct snd_ak4531 *ak4531,
         unsigned long end_time = jiffies + HZ / 10;
 
 #if 0
-        printk(KERN_DEBUG
+        dev_dbg(ensoniq->card->dev,
                "CODEC WRITE: reg = 0x%x, val = 0x%x (0x%x), creg = 0x%x\n",
                reg, val, ES_1370_CODEC_WRITE(reg, val), ES_REG(ensoniq, 1370_CODEC));
 #endif
@@ -598,7 +598,7 @@ static void snd_es1370_codec_write(struct snd_ak4531 *ak4531,
                 }
                 schedule_timeout_uninterruptible(1);
         } while (time_after(end_time, jiffies));
-        snd_printk(KERN_ERR "codec write timeout, status = 0x%x\n",
+        dev_err(ensoniq->card->dev, "codec write timeout, status = 0x%x\n",
                    inl(ES_REG(ensoniq, STATUS)));
 }
 
@@ -649,7 +649,7 @@ static void snd_es1371_codec_write(struct snd_ac97 *ac97,
                 }
         }
         mutex_unlock(&ensoniq->src_mutex);
-        snd_printk(KERN_ERR "codec write timeout at 0x%lx [0x%x]\n",
+        dev_err(ensoniq->card->dev, "codec write timeout at 0x%lx [0x%x]\n",
                    ES_REG(ensoniq, 1371_CODEC), inl(ES_REG(ensoniq, 1371_CODEC)));
 }
 
@@ -706,8 +706,8 @@ static unsigned short snd_es1371_codec_read(struct snd_ac97 *ac97,
                         }
                         mutex_unlock(&ensoniq->src_mutex);
                         if (++fail > 10) {
-                                snd_printk(KERN_ERR "codec read timeout (final) "
-                                           "at 0x%lx, reg = 0x%x [0x%x]\n",
+                                dev_err(ensoniq->card->dev,
+                                        "codec read timeout (final) at 0x%lx, reg = 0x%x [0x%x]\n",
                                            ES_REG(ensoniq, 1371_CODEC), reg,
                                            inl(ES_REG(ensoniq, 1371_CODEC)));
                                 return 0;
@@ -716,7 +716,7 @@ static unsigned short snd_es1371_codec_read(struct snd_ac97 *ac97,
                 }
         }
         mutex_unlock(&ensoniq->src_mutex);
-        snd_printk(KERN_ERR "es1371: codec read timeout at 0x%lx [0x%x]\n",
+        dev_err(ensoniq->card->dev, "codec read timeout at 0x%lx [0x%x]\n",
                    ES_REG(ensoniq, 1371_CODEC), inl(ES_REG(ensoniq, 1371_CODEC)));
         return 0;
 }
@@ -1796,7 +1796,7 @@ static int snd_ensoniq_1370_mixer(struct ensoniq *ensoniq)
 #ifdef SUPPORT_JOYSTICK
 
 #ifdef CHIP1371
-static int snd_ensoniq_get_joystick_port(int dev)
+static int snd_ensoniq_get_joystick_port(struct ensoniq *ensoniq, int dev)
 {
         switch (joystick_port[dev]) {
         case 0: /* disabled */
@@ -1808,12 +1808,13 @@ static int snd_ensoniq_get_joystick_port(int dev)
                 return joystick_port[dev];
 
         default:
-                printk(KERN_ERR "ens1371: invalid joystick port %#x", joystick_port[dev]);
+                dev_err(ensoniq->card->dev,
+                        "invalid joystick port %#x", joystick_port[dev]);
                 return 0;
         }
 }
 #else
-static inline int snd_ensoniq_get_joystick_port(int dev)
+static int snd_ensoniq_get_joystick_port(struct ensoniq *ensoniq, int dev)
 {
         return joystick[dev] ? 0x200 : 0;
 }
@@ -1824,7 +1825,7 @@ static int snd_ensoniq_create_gameport(struct ensoniq *ensoniq, int dev)
         struct gameport *gp;
         int io_port;
 
-        io_port = snd_ensoniq_get_joystick_port(dev);
+        io_port = snd_ensoniq_get_joystick_port(ensoniq, dev);
 
         switch (io_port) {
         case 0:
@@ -1835,14 +1836,16 @@ static int snd_ensoniq_create_gameport(struct ensoniq *ensoniq, int dev)
                         if (request_region(io_port, 8, "ens137x: gameport"))
                                 break;
                 if (io_port > 0x218) {
-                        printk(KERN_WARNING "ens137x: no gameport ports available\n");
+                        dev_warn(ensoniq->card->dev,
+                                 "no gameport ports available\n");
                         return -EBUSY;
                 }
                 break;
 
         default:
                 if (!request_region(io_port, 8, "ens137x: gameport")) {
-                        printk(KERN_WARNING "ens137x: gameport io port %#x in use\n",
+                        dev_warn(ensoniq->card->dev,
+                                 "gameport io port %#x in use\n",
                                io_port);
                         return -EBUSY;
                 }
@@ -1851,7 +1854,8 @@ static int snd_ensoniq_create_gameport(struct ensoniq *ensoniq, int dev)
 
         ensoniq->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "ens137x: cannot allocate memory for gameport\n");
+                dev_err(ensoniq->card->dev,
+                        "cannot allocate memory for gameport\n");
                 release_region(io_port, 8);
                 return -ENOMEM;
         }
@@ -2082,8 +2086,7 @@ static int snd_ensoniq_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR DRIVER_NAME ": pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2137,7 +2140,7 @@ static int snd_ensoniq_create(struct snd_card *card,
         ensoniq->port = pci_resource_start(pci, 0);
         if (request_irq(pci->irq, snd_audiopci_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, ensoniq)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_ensoniq_free(ensoniq);
                 return -EBUSY;
         }
@@ -2145,7 +2148,7 @@ static int snd_ensoniq_create(struct snd_card *card,
 #ifdef CHIP1370
         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
                                 16, &ensoniq->dma_bug) < 0) {
-                snd_printk(KERN_ERR "unable to allocate space for phantom area - dma_bug\n");
+                dev_err(card->dev, "unable to allocate space for phantom area - dma_bug\n");
                 snd_ensoniq_free(ensoniq);
                 return -EBUSY;
         }
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index 33489bcc0aff..34d95bf916b5 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -254,7 +254,6 @@ MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
 #define WRITE_LOOP_TIMEOUT      0x10000
 #define GET_LOOP_TIMEOUT        0x01000
 
-#undef REG_DEBUG
 /* -----------------------------------------------------------------
  * Write to a mixer register
  * -----------------------------------------------------------------*/
@@ -265,9 +264,7 @@ static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsig
         outb(reg, SLSB_REG(chip, MIXERADDR));
         outb(val, SLSB_REG(chip, MIXERDATA));
         spin_unlock_irqrestore(&chip->mixer_lock, flags);
-#ifdef REG_DEBUG
-        snd_printk(KERN_DEBUG "Mixer reg %02x set to %02x\n", reg, val);
-#endif
+        dev_dbg(chip->card->dev, "Mixer reg %02x set to %02x\n", reg, val);
 }
 
 /* -----------------------------------------------------------------
@@ -281,9 +278,7 @@ static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg)
         outb(reg, SLSB_REG(chip, MIXERADDR));
         data = inb(SLSB_REG(chip, MIXERDATA));
         spin_unlock_irqrestore(&chip->mixer_lock, flags);
-#ifdef REG_DEBUG
-        snd_printk(KERN_DEBUG "Mixer reg %02x now is %02x\n", reg, data);
-#endif
+        dev_dbg(chip->card->dev, "Mixer reg %02x now is %02x\n", reg, data);
         return data;
 }
 
@@ -302,10 +297,9 @@ static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg,
         if (val != oval) {
                 new = (old & ~mask) | (val & mask);
                 outb(new, SLSB_REG(chip, MIXERDATA));
-#ifdef REG_DEBUG
-                snd_printk(KERN_DEBUG "Mixer reg %02x was %02x, set to %02x\n",
+                dev_dbg(chip->card->dev,
+                        "Mixer reg %02x was %02x, set to %02x\n",
                            reg, old, new);
-#endif
         }
         spin_unlock_irqrestore(&chip->mixer_lock, flags);
         return oval;
@@ -324,7 +318,8 @@ static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd)
                         return;
                 }
         }
-        printk(KERN_ERR "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
+        dev_err(chip->card->dev,
+                "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
 }
 
 /* -----------------------------------------------------------------
@@ -337,7 +332,7 @@ static int snd_es1938_get_byte(struct es1938 *chip)
         for (i = GET_LOOP_TIMEOUT; i; i--)
                 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
                         return inb(SLSB_REG(chip, READDATA));
-        snd_printk(KERN_ERR "get_byte timeout: status 0x02%x\n", v);
+        dev_err(chip->card->dev, "get_byte timeout: status 0x02%x\n", v);
         return -ENODEV;
 }
 
@@ -351,9 +346,7 @@ static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned ch
         snd_es1938_write_cmd(chip, reg);
         snd_es1938_write_cmd(chip, val);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-#ifdef REG_DEBUG
-        snd_printk(KERN_DEBUG "Reg %02x set to %02x\n", reg, val);
-#endif
+        dev_dbg(chip->card->dev, "Reg %02x set to %02x\n", reg, val);
 }
 
 /* -----------------------------------------------------------------
@@ -368,9 +361,7 @@ static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg)
         snd_es1938_write_cmd(chip, reg);
         val = snd_es1938_get_byte(chip);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-#ifdef REG_DEBUG
-        snd_printk(KERN_DEBUG "Reg %02x now is %02x\n", reg, val);
-#endif
+        dev_dbg(chip->card->dev, "Reg %02x now is %02x\n", reg, val);
         return val;
 }
 
@@ -391,10 +382,8 @@ static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char
                 snd_es1938_write_cmd(chip, reg);
                 new = (old & ~mask) | (val & mask);
                 snd_es1938_write_cmd(chip, new);
-#ifdef REG_DEBUG
-                snd_printk(KERN_DEBUG "Reg %02x was %02x, set to %02x\n",
+                dev_dbg(chip->card->dev, "Reg %02x was %02x, set to %02x\n",
                            reg, old, new);
-#endif
         }
         spin_unlock_irqrestore(&chip->reg_lock, flags);
         return oval;
@@ -416,7 +405,7 @@ static void snd_es1938_reset(struct es1938 *chip)
                                 goto __next;
                 }
         }
-        snd_printk(KERN_ERR "ESS Solo-1 reset failed\n");
+        dev_err(chip->card->dev, "ESS Solo-1 reset failed\n");
 
      __next:
         snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
@@ -1504,16 +1493,15 @@ static int es1938_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "es1938: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
 
         if (request_irq(pci->irq, snd_es1938_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
-                printk(KERN_ERR "es1938: unable to grab IRQ %d, "
-                       "disabling device\n", pci->irq);
+                dev_err(dev, "unable to grab IRQ %d, disabling device\n",
+                        pci->irq);
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -1545,7 +1533,8 @@ static int snd_es1938_create_gameport(struct es1938 *chip)
 
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "es1938: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
 
@@ -1612,7 +1601,8 @@ static int snd_es1938_create(struct snd_card *card,
         /* check, if we can restrict PCI DMA transfers to 24 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
+                dev_err(card->dev,
+                        "architecture does not support 24bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -1639,15 +1629,14 @@ static int snd_es1938_create(struct snd_card *card,
         chip->game_port = pci_resource_start(pci, 4);
         if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_es1938_free(chip);
                 return -EBUSY;
         }
         chip->irq = pci->irq;
-#ifdef ES1938_DDEBUG
-        snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
+        dev_dbg(card->dev,
+                "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
-#endif
 
         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
 
@@ -1673,21 +1662,22 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id)
 
         status = inb(SLIO_REG(chip, IRQCONTROL));
 #if 0
-        printk(KERN_DEBUG "Es1938debug - interrupt status: =0x%x\n", status);
+        dev_dbg(chip->card->dev,
+                "Es1938debug - interrupt status: =0x%x\n", status);
 #endif
         
         /* AUDIO 1 */
         if (status & 0x10) {
 #if 0
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 1 interrupt\n");
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
                        inw(SLDM_REG(chip, DMACOUNT)));
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
                        inl(SLDM_REG(chip, DMAADDR)));
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
                        inl(SLDM_REG(chip, DMASTATUS)));
 #endif
@@ -1703,12 +1693,12 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id)
         /* AUDIO 2 */
         if (status & 0x20) {
 #if 0
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 2 interrupt\n");
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
                        inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
                        inl(SLIO_REG(chip, AUDIO2DMAADDR)));
 
@@ -1842,7 +1832,7 @@ static int snd_es1938_probe(struct pci_dev *pci,
                             SLSB_REG(chip, FMLOWADDR),
                             SLSB_REG(chip, FMHIGHADDR),
                             OPL3_HW_OPL3, 1, &opl3) < 0) {
-                printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
+                dev_err(card->dev, "OPL3 not detected at 0x%lx\n",
                            SLSB_REG(chip, FMLOWADDR));
         } else {
                 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
@@ -1858,7 +1848,7 @@ static int snd_es1938_probe(struct pci_dev *pci,
                                 chip->mpu_port,
                                 MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK,
                                 -1, &chip->rmidi) < 0) {
-                printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
+                dev_err(card->dev, "unable to initialize MPU-401\n");
         } else {
                 // this line is vital for MIDI interrupt handling on ess-solo1
                 // andreas@flying-snail.de
diff --git a/sound/pci/es1968.c b/sound/pci/es1968.c
index 87e9cd5d3ceb..5bb1cf603301 100644
--- a/sound/pci/es1968.c
+++ b/sound/pci/es1968.c
@@ -632,7 +632,7 @@ static int snd_es1968_ac97_wait(struct es1968 *chip)
                         return 0;
                 cond_resched();
         }
-        snd_printd("es1968: ac97 timeout\n");
+        dev_dbg(chip->card->dev, "ac97 timeout\n");
         return 1; /* timeout */
 }
 
@@ -644,7 +644,7 @@ static int snd_es1968_ac97_wait_poll(struct es1968 *chip)
                 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
                         return 0;
         }
-        snd_printd("es1968: ac97 timeout\n");
+        dev_dbg(chip->card->dev, "ac97 timeout\n");
         return 1; /* timeout */
 }
 
@@ -687,7 +687,7 @@ static void apu_index_set(struct es1968 *chip, u16 index)
         for (i = 0; i < 1000; i++)
                 if (__maestro_read(chip, IDR1_CRAM_POINTER) == index)
                         return;
-        snd_printd("es1968: APU register select failed. (Timeout)\n");
+        dev_dbg(chip->card->dev, "APU register select failed. (Timeout)\n");
 }
 
 /* no spinlock */
@@ -699,7 +699,7 @@ static void apu_data_set(struct es1968 *chip, u16 data)
                         return;
                 __maestro_write(chip, IDR0_DATA_PORT, data);
         }
-        snd_printd("es1968: APU register set probably failed (Timeout)!\n");
+        dev_dbg(chip->card->dev, "APU register set probably failed (Timeout)!\n");
 }
 
 /* no spinlock */
@@ -1442,13 +1442,14 @@ snd_es1968_init_dmabuf(struct es1968 *chip)
                                            snd_dma_pci_data(chip->pci),
                                            chip->total_bufsize, &chip->dma);
         if (err < 0 || ! chip->dma.area) {
-                snd_printk(KERN_ERR "es1968: can't allocate dma pages for size %d\n",
+                dev_err(chip->card->dev,
+                        "can't allocate dma pages for size %d\n",
                            chip->total_bufsize);
                 return -ENOMEM;
         }
         if ((chip->dma.addr + chip->dma.bytes - 1) & ~((1 << 28) - 1)) {
                 snd_dma_free_pages(&chip->dma);
-                snd_printk(KERN_ERR "es1968: DMA buffer beyond 256MB.\n");
+                dev_err(chip->card->dev, "DMA buffer beyond 256MB.\n");
                 return -ENOMEM;
         }
 
@@ -1489,7 +1490,8 @@ static int snd_es1968_hw_params(struct snd_pcm_substream *substream,
         }
         chan->memory = snd_es1968_new_memory(chip, size);
         if (chan->memory == NULL) {
-                // snd_printd("cannot allocate dma buffer: size = %d\n", size);
+                dev_dbg(chip->card->dev,
+                        "cannot allocate dma buffer: size = %d\n", size);
                 return -ENOMEM;
         }
         snd_pcm_set_runtime_buffer(substream, &chan->memory->buf);
@@ -1715,11 +1717,13 @@ static void es1968_measure_clock(struct es1968 *chip)
 
         /* search 2 APUs (although one apu is enough) */
         if ((apu = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY)) < 0) {
-                snd_printk(KERN_ERR "Hmm, cannot find empty APU pair!?\n");
+                dev_err(chip->card->dev, "Hmm, cannot find empty APU pair!?\n");
                 return;
         }
         if ((memory = snd_es1968_new_memory(chip, CLOCK_MEASURE_BUFSIZE)) == NULL) {
-                snd_printk(KERN_ERR "cannot allocate dma buffer - using default clock %d\n", chip->clock);
+                dev_warn(chip->card->dev,
+                         "cannot allocate dma buffer - using default clock %d\n",
+                         chip->clock);
                 snd_es1968_free_apu_pair(chip, apu);
                 return;
         }
@@ -1780,7 +1784,7 @@ static void es1968_measure_clock(struct es1968 *chip)
         else
                 t += stop_time.tv_usec - start_time.tv_usec;
         if (t == 0) {
-                snd_printk(KERN_ERR "?? calculation error..\n");
+                dev_err(chip->card->dev, "?? calculation error..\n");
         } else {
                 offset *= 1000;
                 offset = (offset / t) * 1000 + ((offset % t) * 1000) / t;
@@ -1788,7 +1792,7 @@ static void es1968_measure_clock(struct es1968 *chip)
                         if (offset >= 40000 && offset <= 50000)
                                 chip->clock = (chip->clock * offset) / 48000;
                 }
-                printk(KERN_INFO "es1968: clocking to %d\n", chip->clock);
+                dev_info(chip->card->dev, "clocking to %d\n", chip->clock);
         }
         snd_es1968_free_memory(chip, memory);
         snd_es1968_free_apu_pair(chip, apu);
@@ -2108,7 +2112,7 @@ static void snd_es1968_ac97_reset(struct es1968 *chip)
         outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
 
 #if 0                           /* the loop here needs to be much better if we want it.. */
-        snd_printk(KERN_INFO "trying software reset\n");
+        dev_info(chip->card->dev, "trying software reset\n");
         /* try and do a software reset */
         outb(0x80 | 0x7c, ioaddr + 0x30);
         for (w = 0;; w++) {
@@ -2416,8 +2420,7 @@ static int es1968_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "es1968: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2479,7 +2482,8 @@ static int snd_es1968_create_gameport(struct es1968 *chip, int dev)
 
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "es1968: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 release_and_free_resource(r);
                 return -ENOMEM;
         }
@@ -2706,7 +2710,8 @@ static int snd_es1968_create(struct snd_card *card,
         /* check, if we can restrict PCI DMA transfers to 28 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
+                dev_err(card->dev,
+                        "architecture does not support 28bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -2740,7 +2745,7 @@ static int snd_es1968_create(struct snd_card *card,
         chip->io_port = pci_resource_start(pci, 0);
         if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_es1968_free(chip);
                 return -EBUSY;
         }
@@ -2770,7 +2775,7 @@ static int snd_es1968_create(struct snd_card *card,
                 }
                 if (do_pm > 1) {
                         /* not matched; disabling pm */
-                        printk(KERN_INFO "es1968: not attempting power management.\n");
+                        dev_info(card->dev, "not attempting power management.\n");
                         do_pm = 0;
                 }
         }
@@ -2800,7 +2805,7 @@ static int snd_es1968_create(struct snd_card *card,
         for (i = 0; i < ARRAY_SIZE(snd_es1968_tea575x_gpios); i++) {
                 chip->tea575x_tuner = i;
                 if (!snd_tea575x_init(&chip->tea, THIS_MODULE)) {
-                        snd_printk(KERN_INFO "es1968: detected TEA575x radio type %s\n",
+                        dev_info(card->dev, "detected TEA575x radio type %s\n",
                                    get_tea575x_gpio(chip)->name);
                         strlcpy(chip->tea.card, get_tea575x_gpio(chip)->name,
                                 sizeof(chip->tea.card));
@@ -2899,7 +2904,7 @@ static int snd_es1968_probe(struct pci_dev *pci,
                                                MPU401_INFO_INTEGRATED |
                                                MPU401_INFO_IRQ_HOOK,
                                                -1, &chip->rmidi)) < 0) {
-                        printk(KERN_WARNING "es1968: skipping MPU-401 MIDI support..\n");
+                        dev_warn(card->dev, "skipping MPU-401 MIDI support..\n");
                 }
         }
 
@@ -2908,8 +2913,8 @@ static int snd_es1968_probe(struct pci_dev *pci,
 #ifdef CONFIG_SND_ES1968_INPUT
         err = snd_es1968_input_register(chip);
         if (err)
-                snd_printk(KERN_WARNING "Input device registration "
-                        "failed with error %i", err);
+                dev_warn(card->dev,
+                         "Input device registration failed with error %i", err);
 #endif
 
         snd_es1968_start_irq(chip);
diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c
index 8b6af212cbfe..db18ccabadd6 100644
--- a/sound/pci/fm801.c
+++ b/sound/pci/fm801.c
@@ -254,7 +254,7 @@ static void snd_fm801_codec_write(struct snd_ac97 *ac97,
                         goto ok1;
                 udelay(10);
         }
-        snd_printk(KERN_ERR "AC'97 interface is busy (1)\n");
+        dev_err(chip->card->dev, "AC'97 interface is busy (1)\n");
         return;
 
  ok1:
@@ -269,7 +269,7 @@ static void snd_fm801_codec_write(struct snd_ac97 *ac97,
                         return;
                 udelay(10);
         }
-        snd_printk(KERN_ERR "AC'97 interface #%d is busy (2)\n", ac97->num);
+        dev_err(chip->card->dev, "AC'97 interface #%d is busy (2)\n", ac97->num);
 }
 
 static unsigned short snd_fm801_codec_read(struct snd_ac97 *ac97, unsigned short reg)
@@ -285,7 +285,7 @@ static unsigned short snd_fm801_codec_read(struct snd_ac97 *ac97, unsigned short
                         goto ok1;
                 udelay(10);
         }
-        snd_printk(KERN_ERR "AC'97 interface is busy (1)\n");
+        dev_err(chip->card->dev, "AC'97 interface is busy (1)\n");
         return 0;
 
  ok1:
@@ -297,7 +297,7 @@ static unsigned short snd_fm801_codec_read(struct snd_ac97 *ac97, unsigned short
                         goto ok2;
                 udelay(10);
         }
-        snd_printk(KERN_ERR "AC'97 interface #%d is busy (2)\n", ac97->num);
+        dev_err(chip->card->dev, "AC'97 interface #%d is busy (2)\n", ac97->num);
         return 0;
 
  ok2:
@@ -306,7 +306,7 @@ static unsigned short snd_fm801_codec_read(struct snd_ac97 *ac97, unsigned short
                         goto ok3;
                 udelay(10);
         }
-        snd_printk(KERN_ERR "AC'97 interface #%d is not valid (2)\n", ac97->num);
+        dev_err(chip->card->dev, "AC'97 interface #%d is not valid (2)\n", ac97->num);
         return 0;
 
  ok3:
@@ -1100,8 +1100,8 @@ static int snd_fm801_chip_init(struct fm801 *chip, int resume)
 
         if (wait_for_codec(chip, 0, AC97_RESET, msecs_to_jiffies(750)) < 0)
                 if (!resume) {
-                        snd_printk(KERN_INFO "Primary AC'97 codec not found, "
-                                            "assume SF64-PCR (tuner-only)\n");
+                        dev_info(chip->card->dev,
+                                 "Primary AC'97 codec not found, assume SF64-PCR (tuner-only)\n");
                         chip->tea575x_tuner = 3 | TUNER_ONLY;
                         goto __ac97_ok;
                 }
@@ -1225,7 +1225,7 @@ static int snd_fm801_create(struct snd_card *card,
         if ((tea575x_tuner & TUNER_ONLY) == 0) {
                 if (request_irq(pci->irq, snd_fm801_interrupt, IRQF_SHARED,
                                 KBUILD_MODNAME, chip)) {
-                        snd_printk(KERN_ERR "unable to grab IRQ %d\n", chip->irq);
+                        dev_err(card->dev, "unable to grab IRQ %d\n", chip->irq);
                         snd_fm801_free(chip);
                         return -EBUSY;
                 }
@@ -1265,7 +1265,7 @@ static int snd_fm801_create(struct snd_card *card,
         if ((tea575x_tuner & TUNER_TYPE_MASK) > 0 &&
             (tea575x_tuner & TUNER_TYPE_MASK) < 4) {
                 if (snd_tea575x_init(&chip->tea, THIS_MODULE)) {
-                        snd_printk(KERN_ERR "TEA575x radio not found\n");
+                        dev_err(card->dev, "TEA575x radio not found\n");
                         snd_fm801_free(chip);
                         return -ENODEV;
                 }
@@ -1274,13 +1274,14 @@ static int snd_fm801_create(struct snd_card *card,
                 for (tea575x_tuner = 1; tea575x_tuner <= 3; tea575x_tuner++) {
                         chip->tea575x_tuner = tea575x_tuner;
                         if (!snd_tea575x_init(&chip->tea, THIS_MODULE)) {
-                                snd_printk(KERN_INFO "detected TEA575x radio type %s\n",
+                                dev_info(card->dev,
+                                         "detected TEA575x radio type %s\n",
                                            get_tea575x_gpio(chip)->name);
                                 break;
                         }
                 }
                 if (tea575x_tuner == 4) {
-                        snd_printk(KERN_ERR "TEA575x radio not found\n");
+                        dev_err(card->dev, "TEA575x radio not found\n");
                         chip->tea575x_tuner = TUNER_DISABLED;
                 }
         }
@@ -1410,8 +1411,7 @@ static int snd_fm801_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "fm801: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/ice1712/aureon.c b/sound/pci/ice1712/aureon.c
index 55902ec40344..3b3cf4ac9060 100644
--- a/sound/pci/ice1712/aureon.c
+++ b/sound/pci/ice1712/aureon.c
@@ -1937,9 +1937,12 @@ static int aureon_add_controls(struct snd_ice1712 *ice)
                 snd_ice1712_save_gpio_status(ice);
                 id = aureon_cs8415_get(ice, CS8415_ID);
                 if (id != 0x41)
-                        snd_printk(KERN_INFO "No CS8415 chip. Skipping CS8415 controls.\n");
+                        dev_info(ice->card->dev,
+                                 "No CS8415 chip. Skipping CS8415 controls.\n");
                 else if ((id & 0x0F) != 0x01)
-                        snd_printk(KERN_INFO "Detected unsupported CS8415 rev. (%c)\n", (char)((id & 0x0F) + 'A' - 1));
+                        dev_info(ice->card->dev,
+                                 "Detected unsupported CS8415 rev. (%c)\n",
+                                 (char)((id & 0x0F) + 'A' - 1));
                 else {
                         for (i = 0; i < ARRAY_SIZE(cs8415_controls); i++) {
                                 struct snd_kcontrol *kctl;
diff --git a/sound/pci/ice1712/delta.c b/sound/pci/ice1712/delta.c
index 9e28cc12969b..98e5e955261e 100644
--- a/sound/pci/ice1712/delta.c
+++ b/sound/pci/ice1712/delta.c
@@ -425,7 +425,8 @@ static int snd_ice1712_delta1010lt_wordclock_status_get(struct snd_kcontrol *kco
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
 
         if (snd_i2c_sendbytes(ice->cs8427, &reg, 1) != 1)
-                snd_printk(KERN_ERR "unable to send register 0x%x byte to CS8427\n", reg);
+                dev_err(ice->card->dev,
+                        "unable to send register 0x%x byte to CS8427\n", reg);
         snd_i2c_readbytes(ice->cs8427, &reg, 1);
         ucontrol->value.integer.value[0] = (reg & CS8427_UNLOCK) ? 1 : 0;
         return 0;
@@ -637,7 +638,7 @@ static int snd_ice1712_delta_init(struct snd_ice1712 *ice)
         case ICE1712_SUBDEVICE_VX442:
         case ICE1712_SUBDEVICE_DELTA66E:
                 if ((err = snd_i2c_bus_create(ice->card, "ICE1712 GPIO 1", NULL, &ice->i2c)) < 0) {
-                        snd_printk(KERN_ERR "unable to create I2C bus\n");
+                        dev_err(ice->card->dev, "unable to create I2C bus\n");
                         return err;
                 }
                 ice->i2c->private_data = ice;
diff --git a/sound/pci/ice1712/ews.c b/sound/pci/ice1712/ews.c
index bc2e7011c55d..817a1bc50a60 100644
--- a/sound/pci/ice1712/ews.c
+++ b/sound/pci/ice1712/ews.c
@@ -163,7 +163,8 @@ static int snd_ice1712_ews88mt_chip_select(struct snd_ice1712 *ice, int chip_mas
 
      __error:
         snd_i2c_unlock(ice->i2c);
-        snd_printk(KERN_ERR "AK4524 chip select failed, check cable to the front module\n");
+        dev_err(ice->card->dev,
+                "AK4524 chip select failed, check cable to the front module\n");
         return -EIO;
 }
 
@@ -174,7 +175,7 @@ static void ews88mt_ak4524_lock(struct snd_akm4xxx *ak, int chip)
         unsigned char tmp;
         /* assert AK4524 CS */
         if (snd_ice1712_ews88mt_chip_select(ice, ~(1 << chip) & 0x0f) < 0)
-                snd_printk(KERN_ERR "fatal error (ews88mt chip select)\n");
+                dev_err(ice->card->dev, "fatal error (ews88mt chip select)\n");
         snd_ice1712_save_gpio_status(ice);
         tmp = ICE1712_EWS88_SERIAL_DATA |
                 ICE1712_EWS88_SERIAL_CLOCK |
@@ -456,7 +457,7 @@ static int snd_ice1712_ews_init(struct snd_ice1712 *ice)
 
         /* create i2c */
         if ((err = snd_i2c_bus_create(ice->card, "ICE1712 GPIO 1", NULL, &ice->i2c)) < 0) {
-                snd_printk(KERN_ERR "unable to create I2C bus\n");
+                dev_err(ice->card->dev, "unable to create I2C bus\n");
                 return err;
         }
         ice->i2c->private_data = ice;
@@ -469,7 +470,8 @@ static int snd_ice1712_ews_init(struct snd_ice1712 *ice)
                                             ICE1712_6FIRE_PCF9554_ADDR,
                                             &spec->i2cdevs[EWS_I2C_6FIRE]);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "PCF9554 initialization failed\n");
+                        dev_err(ice->card->dev,
+                                "PCF9554 initialization failed\n");
                         return err;
                 }
                 snd_ice1712_6fire_write_pca(ice, PCF9554_REG_CONFIG, 0x80);
@@ -834,7 +836,7 @@ static int snd_ice1712_6fire_read_pca(struct snd_ice1712 *ice, unsigned char reg
         byte = 0;
         if (snd_i2c_readbytes(spec->i2cdevs[EWS_I2C_6FIRE], &byte, 1) != 1) {
                 snd_i2c_unlock(ice->i2c);
-                printk(KERN_ERR "cannot read pca\n");
+                dev_err(ice->card->dev, "cannot read pca\n");
                 return -EIO;
         }
         snd_i2c_unlock(ice->i2c);
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index 99c022a0d612..0710ec7e69d3 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -394,7 +394,7 @@ int snd_ice1712_init_cs8427(struct snd_ice1712 *ice, int addr)
         err = snd_cs8427_create(ice->i2c, addr,
                 (ice->cs8427_timeout * HZ) / 1000, &ice->cs8427);
         if (err < 0) {
-                snd_printk(KERN_ERR "CS8427 initialization failed\n");
+                dev_err(ice->card->dev, "CS8427 initialization failed\n");
                 return err;
         }
         ice->spdif.ops.open = open_cs8427;
@@ -467,7 +467,7 @@ static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id)
                         u16 pbkstatus;
                         struct snd_pcm_substream *substream;
                         pbkstatus = inw(ICEDS(ice, INTSTAT));
-                        /* printk(KERN_DEBUG "pbkstatus = 0x%x\n", pbkstatus); */
+                        /* dev_dbg(ice->card->dev, "pbkstatus = 0x%x\n", pbkstatus); */
                         for (idx = 0; idx < 6; idx++) {
                                 if ((pbkstatus & (3 << (idx * 2))) == 0)
                                         continue;
@@ -903,7 +903,8 @@ static int snd_ice1712_pcm(struct snd_ice1712 *ice, int device, struct snd_pcm *
         if (rpcm)
                 *rpcm = pcm;
 
-        printk(KERN_WARNING "Consumer PCM code does not work well at the moment --jk\n");
+        dev_warn(ice->card->dev,
+                 "Consumer PCM code does not work well at the moment --jk\n");
 
         return 0;
 }
@@ -1534,7 +1535,8 @@ static int snd_ice1712_ac97_mixer(struct snd_ice1712 *ice)
                 ac97.private_free = snd_ice1712_mixer_free_ac97;
                 err = snd_ac97_mixer(pbus, &ac97, &ice->ac97);
                 if (err < 0)
-                        printk(KERN_WARNING "ice1712: cannot initialize ac97 for consumer, skipped\n");
+                        dev_warn(ice->card->dev,
+                                 "cannot initialize ac97 for consumer, skipped\n");
                 else {
                         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_digmix_route_ac97, ice));
                         if (err < 0)
@@ -1552,7 +1554,8 @@ static int snd_ice1712_ac97_mixer(struct snd_ice1712 *ice)
                 ac97.private_free = snd_ice1712_mixer_free_ac97;
                 err = snd_ac97_mixer(pbus, &ac97, &ice->ac97);
                 if (err < 0)
-                        printk(KERN_WARNING "ice1712: cannot initialize pro ac97, skipped\n");
+                        dev_warn(ice->card->dev,
+                                 "cannot initialize pro ac97, skipped\n");
                 else
                         return 0;
         }
@@ -2332,7 +2335,8 @@ static int snd_ice1712_read_eeprom(struct snd_ice1712 *ice,
                         pci_read_config_word(ice->pci, PCI_SUBSYSTEM_ID, &device);
                         ice->eeprom.subvendor = ((unsigned int)swab16(vendor) << 16) | swab16(device);
                         if (ice->eeprom.subvendor == 0 || ice->eeprom.subvendor == (unsigned int)-1) {
-                                printk(KERN_ERR "ice1712: No valid ID is found\n");
+                                dev_err(ice->card->dev,
+                                        "No valid ID is found\n");
                                 return -ENXIO;
                         }
                 }
@@ -2340,21 +2344,22 @@ static int snd_ice1712_read_eeprom(struct snd_ice1712 *ice,
         for (tbl = card_tables; *tbl; tbl++) {
                 for (c = *tbl; c->subvendor; c++) {
                         if (modelname && c->model && !strcmp(modelname, c->model)) {
-                                printk(KERN_INFO "ice1712: Using board model %s\n", c->name);
+                                dev_info(ice->card->dev,
+                                         "Using board model %s\n", c->name);
                                 ice->eeprom.subvendor = c->subvendor;
                         } else if (c->subvendor != ice->eeprom.subvendor)
                                 continue;
                         if (!c->eeprom_size || !c->eeprom_data)
                                 goto found;
                         /* if the EEPROM is given by the driver, use it */
-                        snd_printdd("using the defined eeprom..\n");
+                        dev_dbg(ice->card->dev, "using the defined eeprom..\n");
                         ice->eeprom.version = 1;
                         ice->eeprom.size = c->eeprom_size + 6;
                         memcpy(ice->eeprom.data, c->eeprom_data, c->eeprom_size);
                         goto read_skipped;
                 }
         }
-        printk(KERN_WARNING "ice1712: No matching model found for ID 0x%x\n",
+        dev_warn(ice->card->dev, "No matching model found for ID 0x%x\n",
                ice->eeprom.subvendor);
 
  found:
@@ -2362,12 +2367,13 @@ static int snd_ice1712_read_eeprom(struct snd_ice1712 *ice,
         if (ice->eeprom.size < 6)
                 ice->eeprom.size = 32; /* FIXME: any cards without the correct size? */
         else if (ice->eeprom.size > 32) {
-                snd_printk(KERN_ERR "invalid EEPROM (size = %i)\n", ice->eeprom.size);
+                dev_err(ice->card->dev,
+                        "invalid EEPROM (size = %i)\n", ice->eeprom.size);
                 return -EIO;
         }
         ice->eeprom.version = snd_ice1712_read_i2c(ice, dev, 0x05);
         if (ice->eeprom.version != 1) {
-                snd_printk(KERN_ERR "invalid EEPROM version %i\n",
+                dev_err(ice->card->dev, "invalid EEPROM version %i\n",
                            ice->eeprom.version);
                 /* return -EIO; */
         }
@@ -2553,7 +2559,8 @@ static int snd_ice1712_create(struct snd_card *card,
         /* check, if we can restrict PCI DMA transfers to 28 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
+                dev_err(card->dev,
+                        "architecture does not support 28bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -2609,7 +2616,7 @@ static int snd_ice1712_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_ice1712_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, ice)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_ice1712_free(ice);
                 return -EIO;
         }
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index cf1ba116a772..5e7948f3efe9 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -146,7 +146,7 @@ static unsigned char snd_vt1724_ac97_ready(struct snd_ice1712 *ice)
                         continue;
                 return old_cmd;
         }
-        snd_printd(KERN_ERR "snd_vt1724_ac97_ready: timeout\n");
+        dev_dbg(ice->card->dev, "snd_vt1724_ac97_ready: timeout\n");
         return old_cmd;
 }
 
@@ -156,7 +156,7 @@ static int snd_vt1724_ac97_wait_bit(struct snd_ice1712 *ice, unsigned char bit)
         for (tm = 0; tm < 0x10000; tm++)
                 if ((inb(ICEMT1724(ice, AC97_CMD)) & bit) == 0)
                         return 0;
-        snd_printd(KERN_ERR "snd_vt1724_ac97_wait_bit: timeout\n");
+        dev_dbg(ice->card->dev, "snd_vt1724_ac97_wait_bit: timeout\n");
         return -EIO;
 }
 
@@ -430,10 +430,10 @@ static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id)
                 spin_lock(&ice->reg_lock);
                 if (++timeout > 10) {
                         status = inb(ICEREG1724(ice, IRQSTAT));
-                        printk(KERN_ERR "ice1724: Too long irq loop, "
-                               "status = 0x%x\n", status);
+                        dev_err(ice->card->dev,
+                                "Too long irq loop, status = 0x%x\n", status);
                         if (status & VT1724_IRQ_MPU_TX) {
-                                printk(KERN_ERR "ice1724: Disabling MPU_TX\n");
+                                dev_err(ice->card->dev, "Disabling MPU_TX\n");
                                 enable_midi_irq(ice, VT1724_IRQ_MPU_TX, 0);
                         }
                         spin_unlock(&ice->reg_lock);
@@ -801,7 +801,7 @@ static int snd_vt1724_playback_pro_prepare(struct snd_pcm_substream *substream)
         spin_unlock_irq(&ice->reg_lock);
 
         /*
-        printk(KERN_DEBUG "pro prepare: ch = %d, addr = 0x%x, "
+        dev_dbg(ice->card->dev, "pro prepare: ch = %d, addr = 0x%x, "
                "buffer = 0x%x, period = 0x%x\n",
                substream->runtime->channels,
                (unsigned int)substream->runtime->dma_addr,
@@ -821,13 +821,13 @@ static snd_pcm_uframes_t snd_vt1724_playback_pro_pointer(struct snd_pcm_substrea
 #if 0 /* read PLAYBACK_ADDR */
         ptr = inl(ICEMT1724(ice, PLAYBACK_ADDR));
         if (ptr < substream->runtime->dma_addr) {
-                snd_printd("ice1724: invalid negative ptr\n");
+                dev_dbg(ice->card->dev, "invalid negative ptr\n");
                 return 0;
         }
         ptr -= substream->runtime->dma_addr;
         ptr = bytes_to_frames(substream->runtime, ptr);
         if (ptr >= substream->runtime->buffer_size) {
-                snd_printd("ice1724: invalid ptr %d (size=%d)\n",
+                dev_dbg(ice->card->dev, "invalid ptr %d (size=%d)\n",
                            (int)ptr, (int)substream->runtime->period_size);
                 return 0;
         }
@@ -840,7 +840,7 @@ static snd_pcm_uframes_t snd_vt1724_playback_pro_pointer(struct snd_pcm_substrea
         else if (ptr <= substream->runtime->buffer_size)
                 ptr = substream->runtime->buffer_size - ptr;
         else {
-                snd_printd("ice1724: invalid ptr %d (size=%d)\n",
+                dev_dbg(ice->card->dev, "invalid ptr %d (size=%d)\n",
                            (int)ptr, (int)substream->runtime->buffer_size);
                 ptr = 0;
         }
@@ -884,7 +884,7 @@ static snd_pcm_uframes_t snd_vt1724_pcm_pointer(struct snd_pcm_substream *substr
         else if (ptr <= substream->runtime->buffer_size)
                 ptr = substream->runtime->buffer_size - ptr;
         else {
-                snd_printd("ice1724: invalid ptr %d (size=%d)\n",
+                dev_dbg(ice->card->dev, "invalid ptr %d (size=%d)\n",
                            (int)ptr, (int)substream->runtime->buffer_size);
                 ptr = 0;
         }
@@ -1508,7 +1508,8 @@ static int snd_vt1724_ac97_mixer(struct snd_ice1712 *ice)
                 ac97.private_data = ice;
                 err = snd_ac97_mixer(pbus, &ac97, &ice->ac97);
                 if (err < 0)
-                        printk(KERN_WARNING "ice1712: cannot initialize pro ac97, skipped\n");
+                        dev_warn(ice->card->dev,
+                                 "cannot initialize pro ac97, skipped\n");
                 else
                         return 0;
         }
@@ -2271,7 +2272,7 @@ static void wait_i2c_busy(struct snd_ice1712 *ice)
         while ((inb(ICEREG1724(ice, I2C_CTRL)) & VT1724_I2C_BUSY) && t--)
                 ;
         if (t == -1)
-                printk(KERN_ERR "ice1724: i2c busy timeout\n");
+                dev_err(ice->card->dev, "i2c busy timeout\n");
 }
 
 unsigned char snd_vt1724_read_i2c(struct snd_ice1712 *ice,
@@ -2287,7 +2288,7 @@ unsigned char snd_vt1724_read_i2c(struct snd_ice1712 *ice,
         val = inb(ICEREG1724(ice, I2C_DATA));
         mutex_unlock(&ice->i2c_mutex);
         /*
-        printk(KERN_DEBUG "i2c_read: [0x%x,0x%x] = 0x%x\n", dev, addr, val);
+        dev_dbg(ice->card->dev, "i2c_read: [0x%x,0x%x] = 0x%x\n", dev, addr, val);
         */
         return val;
 }
@@ -2298,7 +2299,7 @@ void snd_vt1724_write_i2c(struct snd_ice1712 *ice,
         mutex_lock(&ice->i2c_mutex);
         wait_i2c_busy(ice);
         /*
-        printk(KERN_DEBUG "i2c_write: [0x%x,0x%x] = 0x%x\n", dev, addr, data);
+        dev_dbg(ice->card->dev, "i2c_write: [0x%x,0x%x] = 0x%x\n", dev, addr, data);
         */
         outb(addr, ICEREG1724(ice, I2C_BYTE_ADDR));
         outb(data, ICEREG1724(ice, I2C_DATA));
@@ -2335,7 +2336,8 @@ static int snd_vt1724_read_eeprom(struct snd_ice1712 *ice,
                                 ((unsigned int)swab16(vendor) << 16) | swab16(device);
                         if (ice->eeprom.subvendor == 0 ||
                             ice->eeprom.subvendor == (unsigned int)-1) {
-                                printk(KERN_ERR "ice1724: No valid ID is found\n");
+                                dev_err(ice->card->dev,
+                                        "No valid ID is found\n");
                                 return -ENXIO;
                         }
                 }
@@ -2344,7 +2346,8 @@ static int snd_vt1724_read_eeprom(struct snd_ice1712 *ice,
                 for (c = *tbl; c->name; c++) {
                         if (modelname && c->model &&
                             !strcmp(modelname, c->model)) {
-                                printk(KERN_INFO "ice1724: Using board model %s\n",
+                                dev_info(ice->card->dev,
+                                         "Using board model %s\n",
                                        c->name);
                                 ice->eeprom.subvendor = c->subvendor;
                         } else if (c->subvendor != ice->eeprom.subvendor)
@@ -2353,14 +2356,14 @@ static int snd_vt1724_read_eeprom(struct snd_ice1712 *ice,
                         if (!c->eeprom_size || !c->eeprom_data)
                                 goto found;
                         /* if the EEPROM is given by the driver, use it */
-                        snd_printdd("using the defined eeprom..\n");
+                        dev_dbg(ice->card->dev, "using the defined eeprom..\n");
                         ice->eeprom.version = 2;
                         ice->eeprom.size = c->eeprom_size + 6;
                         memcpy(ice->eeprom.data, c->eeprom_data, c->eeprom_size);
                         goto read_skipped;
                 }
         }
-        printk(KERN_WARNING "ice1724: No matching model found for ID 0x%x\n",
+        dev_warn(ice->card->dev, "No matching model found for ID 0x%x\n",
                ice->eeprom.subvendor);
 #ifdef CONFIG_PM_SLEEP
         /* assume AC97-only card which can suspend without additional code */
@@ -2372,13 +2375,13 @@ static int snd_vt1724_read_eeprom(struct snd_ice1712 *ice,
         if (ice->eeprom.size < 6)
                 ice->eeprom.size = 32;
         else if (ice->eeprom.size > 32) {
-                printk(KERN_ERR "ice1724: Invalid EEPROM (size = %i)\n",
+                dev_err(ice->card->dev, "Invalid EEPROM (size = %i)\n",
                        ice->eeprom.size);
                 return -EIO;
         }
         ice->eeprom.version = snd_vt1724_read_i2c(ice, dev, 0x05);
         if (ice->eeprom.version != 1 && ice->eeprom.version != 2)
-                printk(KERN_WARNING "ice1724: Invalid EEPROM version %i\n",
+                dev_warn(ice->card->dev, "Invalid EEPROM version %i\n",
                        ice->eeprom.version);
         size = ice->eeprom.size - 6;
         for (i = 0; i < size; i++)
@@ -2586,7 +2589,7 @@ static int snd_vt1724_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_vt1724_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, ice)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_vt1724_free(ice);
                 return -EIO;
         }
diff --git a/sound/pci/ice1712/juli.c b/sound/pci/ice1712/juli.c
index 8855933e710d..7a6c0786c55c 100644
--- a/sound/pci/ice1712/juli.c
+++ b/sound/pci/ice1712/juli.c
@@ -244,7 +244,7 @@ static void juli_akm_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate)
         /* AK5385 first, since it requires cold reset affecting both codecs */
         old_gpio = ice->gpio.get_data(ice);
         new_gpio =  (old_gpio & ~GPIO_AK5385A_MASK) | ak5385_pins;
-        /* printk(KERN_DEBUG "JULI - ak5385 set_rate_val: new gpio 0x%x\n",
+        /* dev_dbg(ice->card->dev, "JULI - ak5385 set_rate_val: new gpio 0x%x\n",
                 new_gpio); */
         ice->gpio.set_data(ice, new_gpio);
 
@@ -344,7 +344,7 @@ static int juli_mute_put(struct snd_kcontrol *kcontrol,
                         new_gpio =  old_gpio &
                                 ~((unsigned int) kcontrol->private_value);
         }
-        /* printk(KERN_DEBUG
+        /* dev_dbg(ice->card->dev,
                 "JULI - mute/unmute: control_value: 0x%x, old_gpio: 0x%x, "
                 "new_gpio 0x%x\n",
                 (unsigned int)ucontrol->value.integer.value[0], old_gpio,
@@ -439,9 +439,9 @@ static void add_slaves(struct snd_card *card,
 {
         for (; *list; list++) {
                 struct snd_kcontrol *slave = ctl_find(card, *list);
-                /* printk(KERN_DEBUG "add_slaves - %s\n", *list); */
+                /* dev_dbg(card->dev, "add_slaves - %s\n", *list); */
                 if (slave) {
-                        /* printk(KERN_DEBUG "slave %s found\n", *list); */
+                        /* dev_dbg(card->dev, "slave %s found\n", *list); */
                         snd_ctl_add_slave(master, slave);
                 }
         }
@@ -536,7 +536,7 @@ static void juli_set_rate(struct snd_ice1712 *ice, unsigned int rate)
 
         old = ice->gpio.get_data(ice);
         new =  (old & ~GPIO_RATE_MASK) | get_gpio_val(rate);
-        /* printk(KERN_DEBUG "JULI - set_rate: old %x, new %x\n",
+        /* dev_dbg(ice->card->dev, "JULI - set_rate: old %x, new %x\n",
                         old & GPIO_RATE_MASK,
                         new & GPIO_RATE_MASK); */
 
@@ -573,7 +573,7 @@ static void juli_ak4114_change(struct ak4114 *ak4114, unsigned char c0,
         if (ice->is_spdif_master(ice) && c1) {
                 /* only for SPDIF master mode, rate was changed */
                 rate = snd_ak4114_external_rate(ak4114);
-                /* printk(KERN_DEBUG "ak4114 - input rate changed to %d\n",
+                /* dev_dbg(ice->card->dev, "ak4114 - input rate changed to %d\n",
                                 rate); */
                 juli_akm_set_rate_val(ice->akm, rate);
         }
@@ -628,7 +628,7 @@ static int juli_init(struct snd_ice1712 *ice)
 #endif
 
         if (spec->analog) {
-                printk(KERN_INFO "juli@: analog I/O detected\n");
+                dev_info(ice->card->dev, "juli@: analog I/O detected\n");
                 ice->num_total_dacs = 2;
                 ice->num_total_adcs = 2;
 
diff --git a/sound/pci/ice1712/prodigy192.c b/sound/pci/ice1712/prodigy192.c
index e610339f7601..f3b491aa3e22 100644
--- a/sound/pci/ice1712/prodigy192.c
+++ b/sound/pci/ice1712/prodigy192.c
@@ -98,7 +98,7 @@ static int stac9460_dac_mute(struct snd_ice1712 *ice, int idx,
         new = (~mute << 7 & 0x80) | (old & ~0x80);
         change = (new != old);
         if (change)
-                /*printk ("Volume register 0x%02x: 0x%02x\n", idx, new);*/
+                /* dev_dbg(ice->card->dev, "Volume register 0x%02x: 0x%02x\n", idx, new);*/
                 stac9460_put(ice, idx, new);
         return change;
 }
@@ -133,7 +133,7 @@ static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         /* due to possible conflicts with stac9460_set_rate_val, mutexing */
         mutex_lock(&spec->mute_mutex);
         /*
-        printk(KERN_DEBUG "Mute put: reg 0x%02x, ctrl value: 0x%02x\n", idx,
+        dev_dbg(ice->card->dev, "Mute put: reg 0x%02x, ctrl value: 0x%02x\n", idx,
                ucontrol->value.integer.value[0]);
         */
         change = stac9460_dac_mute(ice, idx, ucontrol->value.integer.value[0]);
@@ -187,7 +187,7 @@ static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el
         if (change) {
                 ovol =  (0x7f - nvol) | (tmp & 0x80);
                 /*
-                printk(KERN_DEBUG "DAC Volume: reg 0x%02x: 0x%02x\n",
+                dev_dbg(ice->card->dev, "DAC Volume: reg 0x%02x: 0x%02x\n",
                        idx, ovol);
                 */
                 stac9460_put(ice, idx, (0x7f - nvol) | (tmp & 0x80));
@@ -348,7 +348,7 @@ static void stac9460_set_rate_val(struct snd_ice1712 *ice, unsigned int rate)
         for (idx = 0; idx < 7 ; ++idx)
                 changed[idx] = stac9460_dac_mute(ice,
                                 STAC946X_MASTER_VOLUME + idx, 0);
-        /*printk(KERN_DEBUG "Rate change: %d, new MC: 0x%02x\n", rate, new);*/
+        /*dev_dbg(ice->card->dev, "Rate change: %d, new MC: 0x%02x\n", rate, new);*/
         stac9460_put(ice, STAC946X_MASTER_CLOCKING, new);
         udelay(10);
         /* unmuting - only originally unmuted dacs -
@@ -768,9 +768,10 @@ static int prodigy192_init(struct snd_ice1712 *ice)
                 /* from this moment if err = 0 then
                  * spec->ak4114 should not be null
                  */
-                snd_printdd("AK4114 initialized with status %d\n", err);
+                dev_dbg(ice->card->dev,
+                        "AK4114 initialized with status %d\n", err);
         } else
-                snd_printdd("AK4114 not found\n");
+                dev_dbg(ice->card->dev, "AK4114 not found\n");
         if (err < 0)
                 return err;
 
diff --git a/sound/pci/ice1712/quartet.c b/sound/pci/ice1712/quartet.c
index 71c6003ef338..2c2df4b74e01 100644
--- a/sound/pci/ice1712/quartet.c
+++ b/sound/pci/ice1712/quartet.c
@@ -280,7 +280,7 @@ static void qtet_akm_write(struct snd_akm4xxx *ak, int chip,
 
         if (snd_BUG_ON(chip < 0 || chip >= 4))
                 return;
-        /*printk(KERN_DEBUG "Writing to AK4620: chip=%d, addr=0x%x,
+        /*dev_dbg(ice->card->dev, "Writing to AK4620: chip=%d, addr=0x%x,
           data=0x%x\n", chip, addr, data);*/
         orig_dir = ice->gpio.get_dir(ice);
         ice->gpio.set_dir(ice, orig_dir | GPIO_SPI_ALL);
@@ -898,7 +898,7 @@ static void qtet_set_rate(struct snd_ice1712 *ice, unsigned int rate)
         new =  (get_cpld(ice) & ~CPLD_CKS_MASK) | get_cks_val(rate);
         /* switch to internal clock, drop CPLD_SYNC_SEL */
         new &= ~CPLD_SYNC_SEL;
-        /* printk(KERN_DEBUG "QT - set_rate: old %x, new %x\n",
+        /* dev_dbg(ice->card->dev, "QT - set_rate: old %x, new %x\n",
            get_cpld(ice), new); */
         set_cpld(ice, new);
 }
@@ -978,7 +978,7 @@ static void qtet_ak4113_change(struct ak4113 *ak4113, unsigned char c0,
                         c1) {
                 /* only for SPDIF master mode, rate was changed */
                 rate = snd_ak4113_external_rate(ak4113);
-                /* printk(KERN_DEBUG "ak4113 - input rate changed to %d\n",
+                /* dev_dbg(ice->card->dev, "ak4113 - input rate changed to %d\n",
                    rate); */
                 qtet_akm_set_rate_val(ice->akm, rate);
         }
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index ff24acf06bdd..68340d7df76d 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -547,7 +547,8 @@ static int snd_intel8x0_codec_semaphore(struct intel8x0 *chip, unsigned int code
         /* access to some forbidden (non existent) ac97 registers will not
          * reset the semaphore. So even if you don't get the semaphore, still
          * continue the access. We don't need the semaphore anyway. */
-        snd_printk(KERN_ERR "codec_semaphore: semaphore is not ready [0x%x][0x%x]\n",
+        dev_err(chip->card->dev,
+                "codec_semaphore: semaphore is not ready [0x%x][0x%x]\n",
                         igetbyte(chip, ICHREG(ACC_SEMA)), igetdword(chip, ICHREG(GLOB_STA)));
         iagetword(chip, 0);     /* clear semaphore flag */
         /* I don't care about the semaphore */
@@ -562,7 +563,9 @@ static void snd_intel8x0_codec_write(struct snd_ac97 *ac97,
         
         if (snd_intel8x0_codec_semaphore(chip, ac97->num) < 0) {
                 if (! chip->in_ac97_init)
-                        snd_printk(KERN_ERR "codec_write %d: semaphore is not ready for register 0x%x\n", ac97->num, reg);
+                        dev_err(chip->card->dev,
+                                "codec_write %d: semaphore is not ready for register 0x%x\n",
+                                ac97->num, reg);
         }
         iaputword(chip, reg + ac97->num * 0x80, val);
 }
@@ -576,7 +579,9 @@ static unsigned short snd_intel8x0_codec_read(struct snd_ac97 *ac97,
 
         if (snd_intel8x0_codec_semaphore(chip, ac97->num) < 0) {
                 if (! chip->in_ac97_init)
-                        snd_printk(KERN_ERR "codec_read %d: semaphore is not ready for register 0x%x\n", ac97->num, reg);
+                        dev_err(chip->card->dev,
+                                "codec_read %d: semaphore is not ready for register 0x%x\n",
+                                ac97->num, reg);
                 res = 0xffff;
         } else {
                 res = iagetword(chip, reg + ac97->num * 0x80);
@@ -585,7 +590,9 @@ static unsigned short snd_intel8x0_codec_read(struct snd_ac97 *ac97,
                         iputdword(chip, ICHREG(GLOB_STA), tmp &
                                   ~(chip->codec_ready_bits | ICH_GSCI));
                         if (! chip->in_ac97_init)
-                                snd_printk(KERN_ERR "codec_read %d: read timeout for register 0x%x\n", ac97->num, reg);
+                                dev_err(chip->card->dev,
+                                        "codec_read %d: read timeout for register 0x%x\n",
+                                        ac97->num, reg);
                         res = 0xffff;
                 }
         }
@@ -619,7 +626,7 @@ static int snd_intel8x0_ali_codec_ready(struct intel8x0 *chip, int mask)
                         return 0;
         }
         if (! chip->in_ac97_init)
-                snd_printd(KERN_WARNING "intel8x0: AC97 codec ready timeout.\n");
+                dev_warn(chip->card->dev, "AC97 codec ready timeout.\n");
         return -EBUSY;
 }
 
@@ -631,7 +638,7 @@ static int snd_intel8x0_ali_codec_semaphore(struct intel8x0 *chip)
         while (--time && (igetdword(chip, ICHREG(ALI_CAS)) & ALI_CAS_SEM_BUSY))
                 udelay(1);
         if (! time && ! chip->in_ac97_init)
-                snd_printk(KERN_WARNING "ali_codec_semaphore timeout\n");
+                dev_warn(chip->card->dev, "ali_codec_semaphore timeout\n");
         return snd_intel8x0_ali_codec_ready(chip, ALI_CSPSR_CODEC_READY);
 }
 
@@ -700,7 +707,7 @@ static void snd_intel8x0_setup_periods(struct intel8x0 *chip, struct ichdev *ich
                         bdbar[idx + 1] = cpu_to_le32(0x80000000 | /* interrupt on completion */
                                                      ichdev->fragsize >> ichdev->pos_shift);
 #if 0
-                        printk(KERN_DEBUG "bdbar[%i] = 0x%x [0x%x]\n",
+                        dev_dbg(chip->card->dev, "bdbar[%i] = 0x%x [0x%x]\n",
                                idx + 0, bdbar[idx + 0], bdbar[idx + 1]);
 #endif
                 }
@@ -712,8 +719,8 @@ static void snd_intel8x0_setup_periods(struct intel8x0 *chip, struct ichdev *ich
         ichdev->lvi_frag = ICH_REG_LVI_MASK % ichdev->frags;
         ichdev->position = 0;
 #if 0
-        printk(KERN_DEBUG "lvi_frag = %i, frags = %i, period_size = 0x%x, "
-               "period_size1 = 0x%x\n",
+        dev_dbg(chip->card->dev,
+                "lvi_frag = %i, frags = %i, period_size = 0x%x, period_size1 = 0x%x\n",
                ichdev->lvi_frag, ichdev->frags, ichdev->fragsize,
                ichdev->fragsize1);
 #endif
@@ -781,8 +788,8 @@ static inline void snd_intel8x0_update(struct intel8x0 *chip, struct ichdev *ich
                 ichdev->lvi_frag %= ichdev->frags;
                 ichdev->bdbar[ichdev->lvi * 2] = cpu_to_le32(ichdev->physbuf + ichdev->lvi_frag * ichdev->fragsize1);
 #if 0
-        printk(KERN_DEBUG "new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, "
-               "all = 0x%x, 0x%x\n",
+        dev_dbg(chip->card->dev,
+                "new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, all = 0x%x, 0x%x\n",
                ichdev->lvi * 2, ichdev->bdbar[ichdev->lvi * 2],
                ichdev->bdbar[ichdev->lvi * 2 + 1], inb(ICH_REG_OFF_PIV + port),
                inl(port + 4), inb(port + ICH_REG_OFF_CR));
@@ -2289,7 +2296,8 @@ static int snd_intel8x0_mixer(struct intel8x0 *chip, int ac97_clock,
                 ac97.num = i;
                 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) {
                         if (err != -EACCES)
-                                snd_printk(KERN_ERR "Unable to initialize codec #%d\n", i);
+                                dev_err(chip->card->dev,
+                                        "Unable to initialize codec #%d\n", i);
                         if (i == 0)
                                 goto __err;
                 }
@@ -2441,7 +2449,7 @@ static int snd_intel8x0_ich_chip_reset(struct intel8x0 *chip)
                         return 0;
                 schedule_timeout_uninterruptible(1);
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR "AC'97 warm reset still in progress? [0x%x]\n",
+        dev_err(chip->card->dev, "AC'97 warm reset still in progress? [0x%x]\n",
                    igetdword(chip, ICHREG(GLOB_CNT)));
         return -EIO;
 }
@@ -2483,7 +2491,8 @@ static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing)
                 } while (time_after_eq(end_time, jiffies));
                 if (! status) {
                         /* no codec is found */
-                        snd_printk(KERN_ERR "codec_ready: codec is not ready [0x%x]\n",
+                        dev_err(chip->card->dev,
+                                "codec_ready: codec is not ready [0x%x]\n",
                                    igetdword(chip, ICHREG(GLOB_STA)));
                         return -EIO;
                 }
@@ -2547,7 +2556,7 @@ static int snd_intel8x0_ali_chip_init(struct intel8x0 *chip, int probing)
                         goto __ok;
                 schedule_timeout_uninterruptible(1);
         }
-        snd_printk(KERN_ERR "AC'97 reset failed.\n");
+        dev_err(chip->card->dev, "AC'97 reset failed.\n");
         if (probing)
                 return -EIO;
 
@@ -2591,7 +2600,7 @@ static int snd_intel8x0_chip_init(struct intel8x0 *chip, int probing)
                                 break;
                 }
                 if (timeout == 0)
-                        printk(KERN_ERR "intel8x0: reset of registers failed?\n");
+                        dev_err(chip->card->dev, "reset of registers failed?\n");
         }
         /* initialize Buffer Descriptor Lists */
         for (i = 0; i < chip->bdbars_count; i++)
@@ -2692,8 +2701,7 @@ static int intel8x0_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "intel8x0: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2701,8 +2709,8 @@ static int intel8x0_resume(struct device *dev)
         snd_intel8x0_chip_init(chip, 0);
         if (request_irq(pci->irq, snd_intel8x0_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
-                printk(KERN_ERR "intel8x0: unable to grab IRQ %d, "
-                       "disabling device\n", pci->irq);
+                dev_err(dev, "unable to grab IRQ %d, disabling device\n",
+                        pci->irq);
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2779,7 +2787,8 @@ static void intel8x0_measure_ac97_clock(struct intel8x0 *chip)
       __again:
         subs = chip->pcm[0]->streams[0].substream;
         if (! subs || subs->dma_buffer.bytes < INTEL8X0_TESTBUF_SIZE) {
-                snd_printk(KERN_WARNING "no playback buffer allocated - aborting measure ac97 clock\n");
+                dev_warn(chip->card->dev,
+                         "no playback buffer allocated - aborting measure ac97 clock\n");
                 return;
         }
         ichdev = &chip->ichd[ICHD_PCMOUT];
@@ -2789,7 +2798,8 @@ static void intel8x0_measure_ac97_clock(struct intel8x0 *chip)
 
         /* set rate */
         if (snd_ac97_set_rate(chip->ac97[0], AC97_PCM_FRONT_DAC_RATE, 48000) < 0) {
-                snd_printk(KERN_ERR "cannot set ac97 rate: clock = %d\n", chip->ac97_bus->clock);
+                dev_err(chip->card->dev, "cannot set ac97 rate: clock = %d\n",
+                        chip->ac97_bus->clock);
                 return;
         }
         snd_intel8x0_setup_periods(chip, ichdev);
@@ -2843,7 +2853,8 @@ static void intel8x0_measure_ac97_clock(struct intel8x0 *chip)
         spin_unlock_irq(&chip->reg_lock);
 
         if (pos == 0) {
-                snd_printk(KERN_ERR "intel8x0: measure - unreliable DMA position..\n");
+                dev_err(chip->card->dev,
+                        "measure - unreliable DMA position..\n");
               __retry:
                 if (attempt < 3) {
                         msleep(300);
@@ -2857,16 +2868,17 @@ static void intel8x0_measure_ac97_clock(struct intel8x0 *chip)
         t = stop_time.tv_sec - start_time.tv_sec;
         t *= 1000000;
         t += (stop_time.tv_nsec - start_time.tv_nsec) / 1000;
-        printk(KERN_INFO "%s: measured %lu usecs (%lu samples)\n", __func__, t, pos);
+        dev_info(chip->card->dev,
+                 "%s: measured %lu usecs (%lu samples)\n", __func__, t, pos);
         if (t == 0) {
-                snd_printk(KERN_ERR "intel8x0: ?? calculation error..\n");
+                dev_err(chip->card->dev, "?? calculation error..\n");
                 goto __retry;
         }
         pos *= 1000;
         pos = (pos / t) * 1000 + ((pos % t) * 1000) / t;
         if (pos < 40000 || pos >= 60000) {
                 /* abnormal value. hw problem? */
-                printk(KERN_INFO "intel8x0: measured clock %ld rejected\n", pos);
+                dev_info(chip->card->dev, "measured clock %ld rejected\n", pos);
                 goto __retry;
         } else if (pos > 40500 && pos < 41500)
                 /* first exception - 41000Hz reference clock */
@@ -2878,7 +2890,7 @@ static void intel8x0_measure_ac97_clock(struct intel8x0 *chip)
                 /* not 48000Hz, tuning the clock.. */
                 chip->ac97_bus->clock = (chip->ac97_bus->clock * 48000) / pos;
       __end:
-        printk(KERN_INFO "intel8x0: clocking to %d\n", chip->ac97_bus->clock);
+        dev_info(chip->card->dev, "clocking to %d\n", chip->ac97_bus->clock);
         snd_ac97_update_power(chip->ac97[0], AC97_PCM_FRONT_DAC_RATE, 0);
 }
 
@@ -2899,7 +2911,7 @@ static int intel8x0_in_clock_list(struct intel8x0 *chip)
         wl = snd_pci_quirk_lookup(pci, intel8x0_clock_list);
         if (!wl)
                 return 0;
-        printk(KERN_INFO "intel8x0: white list rate for %04x:%04x is %i\n",
+        dev_info(chip->card->dev, "white list rate for %04x:%04x is %i\n",
                pci->subsystem_vendor, pci->subsystem_device, wl->value);
         chip->ac97_bus->clock = wl->value;
         return 1;
@@ -3003,7 +3015,7 @@ static int snd_intel8x0_inside_vm(struct pci_dev *pci)
 
 fini:
         if (msg != NULL)
-                printk(KERN_INFO "intel8x0: %s optimization\n", msg);
+                dev_info(&pci->dev, "%s optimization\n", msg);
 
         return result;
 }
@@ -3098,7 +3110,7 @@ static int snd_intel8x0_create(struct snd_card *card,
         else
                 chip->addr = pci_iomap(pci, 0, 0);
         if (!chip->addr) {
-                snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
+                dev_err(card->dev, "AC'97 space ioremap problem\n");
                 snd_intel8x0_free(chip);
                 return -EIO;
         }
@@ -3107,7 +3119,7 @@ static int snd_intel8x0_create(struct snd_card *card,
         else
                 chip->bmaddr = pci_iomap(pci, 1, 0);
         if (!chip->bmaddr) {
-                snd_printk(KERN_ERR "Controller space ioremap problem\n");
+                dev_err(card->dev, "Controller space ioremap problem\n");
                 snd_intel8x0_free(chip);
                 return -EIO;
         }
@@ -3152,7 +3164,7 @@ static int snd_intel8x0_create(struct snd_card *card,
                                 chip->bdbars_count * sizeof(u32) * ICH_MAX_FRAGS * 2,
                                 &chip->bdbars) < 0) {
                 snd_intel8x0_free(chip);
-                snd_printk(KERN_ERR "intel8x0: cannot allocate buffer descriptors\n");
+                dev_err(card->dev, "cannot allocate buffer descriptors\n");
                 return -ENOMEM;
         }
         /* tables must be aligned to 8 bytes here, but the kernel pages
@@ -3206,7 +3218,7 @@ static int snd_intel8x0_create(struct snd_card *card,
         /* request irq after initializaing int_sta_mask, etc */
         if (request_irq(pci->irq, snd_intel8x0_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_intel8x0_free(chip);
                 return -EBUSY;
         }
@@ -3263,12 +3275,12 @@ static int check_default_spdif_aclink(struct pci_dev *pci)
         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",
+                        dev_dbg(&pci->dev,
+                                "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",
+                        dev_dbg(&pci->dev,
+                                "Using integrated SPDIF DMA for %s\n",
                                     snd_pci_quirk_name(w));
                 return w->value;
         }
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index f8c72bd8a3cd..b54d3e93cab1 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -334,7 +334,8 @@ static int snd_intel8x0m_codec_semaphore(struct intel8x0m *chip, unsigned int co
         /* access to some forbidden (non existent) ac97 registers will not
          * reset the semaphore. So even if you don't get the semaphore, still
          * continue the access. We don't need the semaphore anyway. */
-        snd_printk(KERN_ERR "codec_semaphore: semaphore is not ready [0x%x][0x%x]\n",
+        dev_err(chip->card->dev,
+                "codec_semaphore: semaphore is not ready [0x%x][0x%x]\n",
                         igetbyte(chip, ICHREG(ACC_SEMA)), igetdword(chip, ICHREG(GLOB_STA)));
         iagetword(chip, 0);     /* clear semaphore flag */
         /* I don't care about the semaphore */
@@ -349,7 +350,9 @@ static void snd_intel8x0m_codec_write(struct snd_ac97 *ac97,
         
         if (snd_intel8x0m_codec_semaphore(chip, ac97->num) < 0) {
                 if (! chip->in_ac97_init)
-                        snd_printk(KERN_ERR "codec_write %d: semaphore is not ready for register 0x%x\n", ac97->num, reg);
+                        dev_err(chip->card->dev,
+                                "codec_write %d: semaphore is not ready for register 0x%x\n",
+                                ac97->num, reg);
         }
         iaputword(chip, reg + ac97->num * 0x80, val);
 }
@@ -363,7 +366,9 @@ static unsigned short snd_intel8x0m_codec_read(struct snd_ac97 *ac97,
 
         if (snd_intel8x0m_codec_semaphore(chip, ac97->num) < 0) {
                 if (! chip->in_ac97_init)
-                        snd_printk(KERN_ERR "codec_read %d: semaphore is not ready for register 0x%x\n", ac97->num, reg);
+                        dev_err(chip->card->dev,
+                                "codec_read %d: semaphore is not ready for register 0x%x\n",
+                                ac97->num, reg);
                 res = 0xffff;
         } else {
                 res = iagetword(chip, reg + ac97->num * 0x80);
@@ -372,7 +377,9 @@ static unsigned short snd_intel8x0m_codec_read(struct snd_ac97 *ac97,
                         iputdword(chip, ICHREG(GLOB_STA),
                                   tmp & ~(ICH_SRI|ICH_PRI|ICH_TRI|ICH_GSCI));
                         if (! chip->in_ac97_init)
-                                snd_printk(KERN_ERR "codec_read %d: read timeout for register 0x%x\n", ac97->num, reg);
+                                dev_err(chip->card->dev,
+                                        "codec_read %d: read timeout for register 0x%x\n",
+                                        ac97->num, reg);
                         res = 0xffff;
                 }
         }
@@ -412,7 +419,7 @@ static void snd_intel8x0m_setup_periods(struct intel8x0m *chip, struct ichdev *i
                         bdbar[idx + 1] = cpu_to_le32(0x80000000 | /* interrupt on completion */
                                                      ichdev->fragsize >> chip->pcm_pos_shift);
                         /*
-                        printk(KERN_DEBUG "bdbar[%i] = 0x%x [0x%x]\n",
+                        dev_dbg(chip->card->dev, "bdbar[%i] = 0x%x [0x%x]\n",
                                idx + 0, bdbar[idx + 0], bdbar[idx + 1]);
                         */
                 }
@@ -424,8 +431,8 @@ static void snd_intel8x0m_setup_periods(struct intel8x0m *chip, struct ichdev *i
         ichdev->lvi_frag = ICH_REG_LVI_MASK % ichdev->frags;
         ichdev->position = 0;
 #if 0
-        printk(KERN_DEBUG "lvi_frag = %i, frags = %i, period_size = 0x%x, "
-               "period_size1 = 0x%x\n",
+        dev_dbg(chip->card->dev,
+                "lvi_frag = %i, frags = %i, period_size = 0x%x, period_size1 = 0x%x\n",
                ichdev->lvi_frag, ichdev->frags, ichdev->fragsize,
                ichdev->fragsize1);
 #endif
@@ -470,8 +477,8 @@ static inline void snd_intel8x0m_update(struct intel8x0m *chip, struct ichdev *i
                                                              ichdev->lvi_frag *
                                                              ichdev->fragsize1);
 #if 0
-                printk(KERN_DEBUG "new: bdbar[%i] = 0x%x [0x%x], "
-                       "prefetch = %i, all = 0x%x, 0x%x\n",
+                dev_dbg(chip->card->dev,
+                        "new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, all = 0x%x, 0x%x\n",
                        ichdev->lvi * 2, ichdev->bdbar[ichdev->lvi * 2],
                        ichdev->bdbar[ichdev->lvi * 2 + 1], inb(ICH_REG_OFF_PIV + port),
                        inl(port + 4), inb(port + ICH_REG_OFF_CR));
@@ -850,7 +857,8 @@ static int snd_intel8x0m_mixer(struct intel8x0m *chip, int ac97_clock)
         ac97.pci = chip->pci;
         ac97.num = glob_sta & ICH_SCR ? 1 : 0;
         if ((err = snd_ac97_mixer(pbus, &ac97, &x97)) < 0) {
-                snd_printk(KERN_ERR "Unable to initialize codec #%d\n", ac97.num);
+                dev_err(chip->card->dev,
+                        "Unable to initialize codec #%d\n", ac97.num);
                 if (ac97.num == 0)
                         goto __err;
                 return err;
@@ -901,7 +909,7 @@ static int snd_intel8x0m_ich_chip_init(struct intel8x0m *chip, int probing)
                         goto __ok;
                 schedule_timeout_uninterruptible(1);
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR "AC'97 warm reset still in progress? [0x%x]\n",
+        dev_err(chip->card->dev, "AC'97 warm reset still in progress? [0x%x]\n",
                    igetdword(chip, ICHREG(GLOB_CNT)));
         return -EIO;
 
@@ -921,7 +929,8 @@ static int snd_intel8x0m_ich_chip_init(struct intel8x0m *chip, int probing)
                 } while (time_after_eq(end_time, jiffies));
                 if (! status) {
                         /* no codec is found */
-                        snd_printk(KERN_ERR "codec_ready: codec is not ready [0x%x]\n",
+                        dev_err(chip->card->dev,
+                                "codec_ready: codec is not ready [0x%x]\n",
                                    igetdword(chip, ICHREG(GLOB_STA)));
                         return -EIO;
                 }
@@ -1042,16 +1051,15 @@ static int intel8x0m_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "intel8x0m: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
         pci_set_master(pci);
         if (request_irq(pci->irq, snd_intel8x0m_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
-                printk(KERN_ERR "intel8x0m: unable to grab IRQ %d, "
-                       "disabling device\n", pci->irq);
+                dev_err(dev, "unable to grab IRQ %d, disabling device\n",
+                        pci->irq);
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -1165,7 +1173,7 @@ static int snd_intel8x0m_create(struct snd_card *card,
         else
                 chip->addr = pci_iomap(pci, 0, 0);
         if (!chip->addr) {
-                snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
+                dev_err(card->dev, "AC'97 space ioremap problem\n");
                 snd_intel8x0m_free(chip);
                 return -EIO;
         }
@@ -1174,7 +1182,7 @@ static int snd_intel8x0m_create(struct snd_card *card,
         else
                 chip->bmaddr = pci_iomap(pci, 1, 0);
         if (!chip->bmaddr) {
-                snd_printk(KERN_ERR "Controller space ioremap problem\n");
+                dev_err(card->dev, "Controller space ioremap problem\n");
                 snd_intel8x0m_free(chip);
                 return -EIO;
         }
@@ -1182,7 +1190,7 @@ static int snd_intel8x0m_create(struct snd_card *card,
  port_inited:
         if (request_irq(pci->irq, snd_intel8x0m_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_intel8x0m_free(chip);
                 return -EBUSY;
         }
diff --git a/sound/pci/lola/lola.c b/sound/pci/lola/lola.c
index 56d4f94daea2..d63434d8c3fb 100644
--- a/sound/pci/lola/lola.c
+++ b/sound/pci/lola/lola.c
@@ -75,7 +75,7 @@ MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
 static int debug;
 module_param(debug, int, 0644);
 #define verbose_debug(fmt, args...)                     \
-        do { if (debug > 1) printk(KERN_DEBUG SFX fmt, ##args); } while (0)
+        do { if (debug > 1) pr_debug(SFX fmt, ##args); } while (0)
 #else
 #define verbose_debug(fmt, args...)
 #endif
@@ -168,7 +168,7 @@ static int rirb_get_response(struct lola *chip, unsigned int *val,
                         verbose_debug("get_response: %x, %x\n",
                                       chip->res, chip->res_ex);
                         if (chip->res_ex & LOLA_RIRB_EX_ERROR) {
-                                printk(KERN_WARNING SFX "RIRB ERROR: "
+                                dev_warn(chip->card->dev, "RIRB ERROR: "
                                        "NID=%x, verb=%x, data=%x, ext=%x\n",
                                        chip->last_cmd_nid,
                                        chip->last_verb, chip->last_data,
@@ -182,9 +182,9 @@ static int rirb_get_response(struct lola *chip, unsigned int *val,
                 udelay(20);
                 cond_resched();
         }
-        printk(KERN_WARNING SFX "RIRB response error\n");
+        dev_warn(chip->card->dev, "RIRB response error\n");
         if (!chip->polling_mode) {
-                printk(KERN_WARNING SFX "switching to polling mode\n");
+                dev_warn(chip->card->dev, "switching to polling mode\n");
                 chip->polling_mode = 1;
                 goto again;
         }
@@ -327,7 +327,7 @@ static int reset_controller(struct lola *chip)
                         break;
         } while (time_before(jiffies, end_time));
         if (!gctl) {
-                printk(KERN_ERR SFX "cannot reset controller\n");
+                dev_err(chip->card->dev, "cannot reset controller\n");
                 return -EIO;
         }
         return 0;
@@ -452,40 +452,40 @@ static int lola_parse_tree(struct lola *chip)
 
         err = lola_read_param(chip, 0, LOLA_PAR_VENDOR_ID, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read VENDOR_ID\n");
+                dev_err(chip->card->dev, "Can't read VENDOR_ID\n");
                 return err;
         }
         val >>= 16;
         if (val != 0x1369) {
-                printk(KERN_ERR SFX "Unknown codec vendor 0x%x\n", val);
+                dev_err(chip->card->dev, "Unknown codec vendor 0x%x\n", val);
                 return -EINVAL;
         }
 
         err = lola_read_param(chip, 1, LOLA_PAR_FUNCTION_TYPE, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read FUNCTION_TYPE\n");
+                dev_err(chip->card->dev, "Can't read FUNCTION_TYPE\n");
                 return err;
         }
         if (val != 1) {
-                printk(KERN_ERR SFX "Unknown function type %d\n", val);
+                dev_err(chip->card->dev, "Unknown function type %d\n", val);
                 return -EINVAL;
         }
 
         err = lola_read_param(chip, 1, LOLA_PAR_SPECIFIC_CAPS, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read SPECCAPS\n");
+                dev_err(chip->card->dev, "Can't read SPECCAPS\n");
                 return err;
         }
         chip->lola_caps = val;
         chip->pin[CAPT].num_pins = LOLA_AFG_INPUT_PIN_COUNT(chip->lola_caps);
         chip->pin[PLAY].num_pins = LOLA_AFG_OUTPUT_PIN_COUNT(chip->lola_caps);
-        snd_printdd(SFX "speccaps=0x%x, pins in=%d, out=%d\n",
+        dev_dbg(chip->card->dev, "speccaps=0x%x, pins in=%d, out=%d\n",
                     chip->lola_caps,
                     chip->pin[CAPT].num_pins, chip->pin[PLAY].num_pins);
 
         if (chip->pin[CAPT].num_pins > MAX_AUDIO_INOUT_COUNT ||
             chip->pin[PLAY].num_pins > MAX_AUDIO_INOUT_COUNT) {
-                printk(KERN_ERR SFX "Invalid Lola-spec caps 0x%x\n", val);
+                dev_err(chip->card->dev, "Invalid Lola-spec caps 0x%x\n", val);
                 return -EINVAL;
         }
 
@@ -586,7 +586,7 @@ static int lola_create(struct snd_card *card, struct pci_dev *pci,
 
         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (!chip) {
-                snd_printk(KERN_ERR SFX "cannot allocate chip\n");
+                dev_err(chip->card->dev, "cannot allocate chip\n");
                 pci_disable_device(pci);
                 return -ENOMEM;
         }
@@ -609,7 +609,7 @@ static int lola_create(struct snd_card *card, struct pci_dev *pci,
                 chip->sample_rate_max = 192000;
                 break;
         default:
-                snd_printk(KERN_WARNING SFX
+                dev_warn(chip->card->dev,
                            "Invalid granularity %d, reset to %d\n",
                            chip->granularity, LOLA_GRANULARITY_MAX);
                 chip->granularity = LOLA_GRANULARITY_MAX;
@@ -618,7 +618,7 @@ static int lola_create(struct snd_card *card, struct pci_dev *pci,
         }
         chip->sample_rate_min = sample_rate_min[dev];
         if (chip->sample_rate_min > chip->sample_rate_max) {
-                snd_printk(KERN_WARNING SFX
+                dev_warn(chip->card->dev,
                            "Invalid sample_rate_min %d, reset to 16000\n",
                            chip->sample_rate_min);
                 chip->sample_rate_min = 16000;
@@ -636,7 +636,7 @@ static int lola_create(struct snd_card *card, struct pci_dev *pci,
         chip->bar[1].addr = pci_resource_start(pci, 2);
         chip->bar[1].remap_addr = pci_ioremap_bar(pci, 2);
         if (!chip->bar[0].remap_addr || !chip->bar[1].remap_addr) {
-                snd_printk(KERN_ERR SFX "ioremap error\n");
+                dev_err(chip->card->dev, "ioremap error\n");
                 err = -ENXIO;
                 goto errout;
         }
@@ -649,7 +649,7 @@ static int lola_create(struct snd_card *card, struct pci_dev *pci,
 
         if (request_irq(pci->irq, lola_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                printk(KERN_ERR SFX "unable to grab IRQ %d\n", pci->irq);
+                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
                 err = -EBUSY;
                 goto errout;
         }
@@ -660,7 +660,7 @@ static int lola_create(struct snd_card *card, struct pci_dev *pci,
         chip->pcm[CAPT].num_streams = (dever >> 0) & 0x3ff;
         chip->pcm[PLAY].num_streams = (dever >> 10) & 0x3ff;
         chip->version = (dever >> 24) & 0xff;
-        snd_printdd(SFX "streams in=%d, out=%d, version=0x%x\n",
+        dev_dbg(chip->card->dev, "streams in=%d, out=%d, version=0x%x\n",
                     chip->pcm[CAPT].num_streams, chip->pcm[PLAY].num_streams,
                     chip->version);
 
@@ -669,7 +669,7 @@ static int lola_create(struct snd_card *card, struct pci_dev *pci,
             chip->pcm[PLAY].num_streams > MAX_STREAM_OUT_COUNT ||
             (!chip->pcm[CAPT].num_streams &&
              !chip->pcm[PLAY].num_streams)) {
-                printk(KERN_ERR SFX "invalid DEVER = %x\n", dever);
+                dev_err(chip->card->dev, "invalid DEVER = %x\n", dever);
                 err = -EINVAL;
                 goto errout;
         }
@@ -680,7 +680,7 @@ static int lola_create(struct snd_card *card, struct pci_dev *pci,
 
         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
         if (err < 0) {
-                snd_printk(KERN_ERR SFX "Error creating device [card]!\n");
+                dev_err(chip->card->dev, "Error creating device [card]!\n");
                 goto errout;
         }
 
@@ -720,7 +720,7 @@ static int lola_probe(struct pci_dev *pci,
         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
                            0, &card);
         if (err < 0) {
-                snd_printk(KERN_ERR SFX "Error creating card!\n");
+                dev_err(card->dev, "Error creating card!\n");
                 return err;
         }
 
diff --git a/sound/pci/lola/lola_clock.c b/sound/pci/lola/lola_clock.c
index eb1d6b97df16..2bef6b412aee 100644
--- a/sound/pci/lola/lola_clock.c
+++ b/sound/pci/lola/lola_clock.c
@@ -128,21 +128,21 @@ int lola_init_clock_widget(struct lola *chip, int nid)
 
         err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read wcaps for 0x%x\n", nid);
+                dev_err(chip->card->dev, "Can't read wcaps for 0x%x\n", nid);
                 return err;
         }
 
         if ((val & 0xfff00000) != 0x01f00000) { /* test SubType and Type */
-                snd_printdd("No valid clock widget\n");
+                dev_dbg(chip->card->dev, "No valid clock widget\n");
                 return 0;
         }
 
         chip->clock.nid = nid;
         chip->clock.items = val & 0xff;
-        snd_printdd("clock_list nid=%x, entries=%d\n", nid,
+        dev_dbg(chip->card->dev, "clock_list nid=%x, entries=%d\n", nid,
                     chip->clock.items);
         if (chip->clock.items > MAX_SAMPLE_CLOCK_COUNT) {
-                printk(KERN_ERR SFX "CLOCK_LIST too big: %d\n",
+                dev_err(chip->card->dev, "CLOCK_LIST too big: %d\n",
                        chip->clock.items);
                 return -EINVAL;
         }
@@ -158,7 +158,7 @@ int lola_init_clock_widget(struct lola *chip, int nid)
                 err = lola_codec_read(chip, nid, LOLA_VERB_GET_CLOCK_LIST,
                                       idx, 0, &val, &res_ex);
                 if (err < 0) {
-                        printk(KERN_ERR SFX "Can't read CLOCK_LIST\n");
+                        dev_err(chip->card->dev, "Can't read CLOCK_LIST\n");
                         return -EINVAL;
                 }
 
@@ -223,7 +223,7 @@ int lola_enable_clock_events(struct lola *chip)
         if (err < 0)
                 return err;
         if (res) {
-                printk(KERN_WARNING SFX "error in enable_clock_events %d\n",
+                dev_warn(chip->card->dev, "error in enable_clock_events %d\n",
                        res);
                 return -EINVAL;
         }
@@ -242,7 +242,7 @@ int lola_set_clock_index(struct lola *chip, unsigned int idx)
         if (err < 0)
                 return err;
         if (res) {
-                printk(KERN_WARNING SFX "error in set_clock %d\n", res);
+                dev_warn(chip->card->dev, "error in set_clock %d\n", res);
                 return -EINVAL;
         }
         return 0;
diff --git a/sound/pci/lola/lola_mixer.c b/sound/pci/lola/lola_mixer.c
index 52c8d6b0f39b..782f4d8299ae 100644
--- a/sound/pci/lola/lola_mixer.c
+++ b/sound/pci/lola/lola_mixer.c
@@ -37,7 +37,7 @@ static int lola_init_pin(struct lola *chip, struct lola_pin *pin,
         pin->nid = nid;
         err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read wcaps for 0x%x\n", nid);
+                dev_err(chip->card->dev, "Can't read wcaps for 0x%x\n", nid);
                 return err;
         }
         val &= 0x00f00fff; /* test TYPE and bits 0..11 */
@@ -48,7 +48,7 @@ static int lola_init_pin(struct lola *chip, struct lola_pin *pin,
         else if (val == 0x0040000c && dir == PLAY) /* Dig=0, OutAmp/ovrd */
                 pin->is_analog = true;
         else {
-                printk(KERN_ERR SFX "Invalid wcaps 0x%x for 0x%x\n", val, nid);
+                dev_err(chip->card->dev, "Invalid wcaps 0x%x for 0x%x\n", val, nid);
                 return -EINVAL;
         }
 
@@ -62,7 +62,7 @@ static int lola_init_pin(struct lola *chip, struct lola_pin *pin,
         else
                 err = lola_read_param(chip, nid, LOLA_PAR_AMP_IN_CAP, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read AMP-caps for 0x%x\n", nid);
+                dev_err(chip->card->dev, "Can't read AMP-caps for 0x%x\n", nid);
                 return err;
         }
 
@@ -79,7 +79,7 @@ static int lola_init_pin(struct lola *chip, struct lola_pin *pin,
         err = lola_codec_read(chip, nid, LOLA_VERB_GET_MAX_LEVEL, 0, 0, &val,
                               NULL);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't get MAX_LEVEL 0x%x\n", nid);
+                dev_err(chip->card->dev, "Can't get MAX_LEVEL 0x%x\n", nid);
                 return err;
         }
         pin->max_level = val & 0x3ff;   /* 10 bits */
@@ -119,12 +119,12 @@ int lola_init_mixer_widget(struct lola *chip, int nid)
 
         err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read wcaps for 0x%x\n", nid);
+                dev_err(chip->card->dev, "Can't read wcaps for 0x%x\n", nid);
                 return err;
         }
 
         if ((val & 0xfff00000) != 0x02f00000) { /* test SubType and Type */
-                snd_printdd("No valid mixer widget\n");
+                dev_dbg(chip->card->dev, "No valid mixer widget\n");
                 return 0;
         }
 
@@ -202,7 +202,7 @@ int lola_init_mixer_widget(struct lola *chip, int nid)
          */
         if (chip->mixer.src_stream_out_ofs > MAX_AUDIO_INOUT_COUNT ||
             chip->mixer.dest_phys_out_ofs > MAX_STREAM_IN_COUNT) {
-                printk(KERN_ERR SFX "Invalid mixer widget size\n");
+                dev_err(chip->card->dev, "Invalid mixer widget size\n");
                 return -EINVAL;
         }
 
@@ -213,7 +213,7 @@ int lola_init_mixer_widget(struct lola *chip, int nid)
                 (((1U << chip->mixer.dest_phys_outs) - 1)
                  << chip->mixer.dest_phys_out_ofs);
 
-        snd_printdd("Mixer src_mask=%x, dest_mask=%x\n",
+        dev_dbg(chip->card->dev, "Mixer src_mask=%x, dest_mask=%x\n",
                     chip->mixer.src_mask, chip->mixer.dest_mask);
 
         return 0;
@@ -236,7 +236,8 @@ static int lola_mixer_set_src_gain(struct lola *chip, unsigned int id,
             (gain == readw(&chip->mixer.array->src_gain[id])))
                 return 0;
 
-        snd_printdd("lola_mixer_set_src_gain (id=%d, gain=%d) enable=%x\n",
+        dev_dbg(chip->card->dev,
+                "lola_mixer_set_src_gain (id=%d, gain=%d) enable=%x\n",
                         id, gain, val);
         writew(gain, &chip->mixer.array->src_gain[id]);
         writel(val, &chip->mixer.array->src_gain_enable);
@@ -409,7 +410,8 @@ static int set_analog_volume(struct lola *chip, int dir,
                 return 0;
         if (external_call)
                 lola_codec_flush(chip);
-        snd_printdd("set_analog_volume (dir=%d idx=%d, volume=%d)\n",
+        dev_dbg(chip->card->dev,
+                "set_analog_volume (dir=%d idx=%d, volume=%d)\n",
                         dir, idx, val);
         err = lola_codec_write(chip, pin->nid,
                                LOLA_VERB_SET_AMP_GAIN_MUTE, val, 0);
diff --git a/sound/pci/lola/lola_pcm.c b/sound/pci/lola/lola_pcm.c
index 5ea85e8b83ab..3bd6985430e8 100644
--- a/sound/pci/lola/lola_pcm.c
+++ b/sound/pci/lola/lola_pcm.c
@@ -103,7 +103,7 @@ static void wait_for_srst_clear(struct lola *chip, struct lola_stream *str)
                         return;
                 msleep(1);
         }
-        printk(KERN_WARNING SFX "SRST not clear (stream %d)\n", str->dsd);
+        dev_warn(chip->card->dev, "SRST not clear (stream %d)\n", str->dsd);
 }
 
 static int lola_stream_wait_for_fifo(struct lola *chip,
@@ -118,7 +118,7 @@ static int lola_stream_wait_for_fifo(struct lola *chip,
                         return 0;
                 msleep(1);
         }
-        printk(KERN_WARNING SFX "FIFO not ready (stream %d)\n", str->dsd);
+        dev_warn(chip->card->dev, "FIFO not ready (stream %d)\n", str->dsd);
         return -EIO;
 }
 
@@ -156,7 +156,7 @@ static int lola_sync_wait_for_fifo(struct lola *chip,
                         return 0;
                 msleep(1);
         }
-        printk(KERN_WARNING SFX "FIFO not ready (pending %d)\n", pending - 1);
+        dev_warn(chip->card->dev, "FIFO not ready (pending %d)\n", pending - 1);
         return -EIO;
 }
 
@@ -373,7 +373,7 @@ static int lola_setup_periods(struct lola *chip, struct lola_pcm *pcm,
         return 0;
 
  error:
-        snd_printk(KERN_ERR SFX "Too many BDL entries: buffer=%d, period=%d\n",
+        dev_err(chip->card->dev, "Too many BDL entries: buffer=%d, period=%d\n",
                    str->bufsize, period_bytes);
         return -EINVAL;
 }
@@ -415,7 +415,7 @@ static int lola_set_stream_config(struct lola *chip,
         err = lola_codec_read(chip, str->nid, LOLA_VERB_SET_STREAM_FORMAT,
                               str->format_verb, 0, &val, NULL);
         if (err < 0) {
-                printk(KERN_ERR SFX "Cannot set stream format 0x%x\n",
+                dev_err(chip->card->dev, "Cannot set stream format 0x%x\n",
                        str->format_verb);
                 return err;
         }
@@ -427,7 +427,8 @@ static int lola_set_stream_config(struct lola *chip,
                                       LOLA_VERB_SET_CHANNEL_STREAMID, 0, verb,
                                       &val, NULL);
                 if (err < 0) {
-                        printk(KERN_ERR SFX "Cannot set stream channel %d\n", i);
+                        dev_err(chip->card->dev,
+                                "Cannot set stream channel %d\n", i);
                         return err;
                 }
         }
@@ -651,13 +652,14 @@ static int lola_init_stream(struct lola *chip, struct lola_stream *str,
                 str->dsd += MAX_STREAM_IN_COUNT;
         err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read wcaps for 0x%x\n", nid);
+                dev_err(chip->card->dev, "Can't read wcaps for 0x%x\n", nid);
                 return err;
         }
         if (dir == PLAY) {
                 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1) */
                 if ((val & 0x00f00dff) != 0x00000010) {
-                        printk(KERN_ERR SFX "Invalid wcaps 0x%x for 0x%x\n",
+                        dev_err(chip->card->dev,
+                                "Invalid wcaps 0x%x for 0x%x\n",
                                val, nid);
                         return -EINVAL;
                 }
@@ -666,7 +668,8 @@ static int lola_init_stream(struct lola *chip, struct lola_stream *str,
                  * (bug : ignore bit8: Conn list = 0/1)
                  */
                 if ((val & 0x00f00cff) != 0x00100010) {
-                        printk(KERN_ERR SFX "Invalid wcaps 0x%x for 0x%x\n",
+                        dev_err(chip->card->dev,
+                                "Invalid wcaps 0x%x for 0x%x\n",
                                val, nid);
                         return -EINVAL;
                 }
@@ -677,14 +680,15 @@ static int lola_init_stream(struct lola *chip, struct lola_stream *str,
 
         err = lola_read_param(chip, nid, LOLA_PAR_STREAM_FORMATS, &val);
         if (err < 0) {
-                printk(KERN_ERR SFX "Can't read FORMATS 0x%x\n", nid);
+                dev_err(chip->card->dev, "Can't read FORMATS 0x%x\n", nid);
                 return err;
         }
         val &= 3;
         if (val == 3)
                 str->can_float = true;
         if (!(val & 1)) {
-                printk(KERN_ERR SFX "Invalid formats 0x%x for 0x%x", val, nid);
+                dev_err(chip->card->dev,
+                        "Invalid formats 0x%x for 0x%x", val, nid);
                 return -EINVAL;
         }
         return 0;
diff --git a/sound/pci/lx6464es/lx6464es.c b/sound/pci/lx6464es/lx6464es.c
index b9743d4fa1cc..27f60ce8a55c 100644
--- a/sound/pci/lx6464es/lx6464es.c
+++ b/sound/pci/lx6464es/lx6464es.c
@@ -112,16 +112,16 @@ static int lx_hardware_open(struct lx6464es *chip,
 
         snd_pcm_uframes_t period_size = runtime->period_size;
 
-        snd_printd(LXP "allocating pipe for %d channels\n", channels);
+        dev_dbg(chip->card->dev, "allocating pipe for %d channels\n", channels);
         err = lx_pipe_allocate(chip, 0, is_capture, channels);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "allocating pipe failed\n");
+                dev_err(chip->card->dev, LXP "allocating pipe failed\n");
                 return err;
         }
 
         err = lx_set_granularity(chip, period_size);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "setting granularity to %ld failed\n",
+                dev_err(chip->card->dev, "setting granularity to %ld failed\n",
                            period_size);
                 return err;
         }
@@ -136,24 +136,24 @@ static int lx_hardware_start(struct lx6464es *chip,
         struct snd_pcm_runtime *runtime = substream->runtime;
         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 
-        snd_printd(LXP "setting stream format\n");
+        dev_dbg(chip->card->dev, "setting stream format\n");
         err = lx_stream_set_format(chip, runtime, 0, is_capture);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "setting stream format failed\n");
+                dev_err(chip->card->dev, "setting stream format failed\n");
                 return err;
         }
 
-        snd_printd(LXP "starting pipe\n");
+        dev_dbg(chip->card->dev, "starting pipe\n");
         err = lx_pipe_start(chip, 0, is_capture);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "starting pipe failed\n");
+                dev_err(chip->card->dev, "starting pipe failed\n");
                 return err;
         }
 
-        snd_printd(LXP "waiting for pipe to start\n");
+        dev_dbg(chip->card->dev, "waiting for pipe to start\n");
         err = lx_pipe_wait_for_start(chip, 0, is_capture);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "waiting for pipe failed\n");
+                dev_err(chip->card->dev, "waiting for pipe failed\n");
                 return err;
         }
 
@@ -167,24 +167,24 @@ static int lx_hardware_stop(struct lx6464es *chip,
         int err = 0;
         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 
-        snd_printd(LXP "pausing pipe\n");
+        dev_dbg(chip->card->dev, "pausing pipe\n");
         err = lx_pipe_pause(chip, 0, is_capture);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "pausing pipe failed\n");
+                dev_err(chip->card->dev, "pausing pipe failed\n");
                 return err;
         }
 
-        snd_printd(LXP "waiting for pipe to become idle\n");
+        dev_dbg(chip->card->dev, "waiting for pipe to become idle\n");
         err = lx_pipe_wait_for_idle(chip, 0, is_capture);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "waiting for pipe failed\n");
+                dev_err(chip->card->dev, "waiting for pipe failed\n");
                 return err;
         }
 
-        snd_printd(LXP "stopping pipe\n");
+        dev_dbg(chip->card->dev, "stopping pipe\n");
         err = lx_pipe_stop(chip, 0, is_capture);
         if (err < 0) {
-                snd_printk(LXP "stopping pipe failed\n");
+                dev_err(chip->card->dev, "stopping pipe failed\n");
                 return err;
         }
 
@@ -198,10 +198,10 @@ static int lx_hardware_close(struct lx6464es *chip,
         int err = 0;
         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 
-        snd_printd(LXP "releasing pipe\n");
+        dev_dbg(chip->card->dev, "releasing pipe\n");
         err = lx_pipe_release(chip, 0, is_capture);
         if (err < 0) {
-                snd_printk(LXP "releasing pipe failed\n");
+                dev_err(chip->card->dev, "releasing pipe failed\n");
                 return err;
         }
 
@@ -216,7 +216,7 @@ static int lx_pcm_open(struct snd_pcm_substream *substream)
         int err = 0;
         int board_rate;
 
-        snd_printdd("->lx_pcm_open\n");
+        dev_dbg(chip->card->dev, "->lx_pcm_open\n");
         mutex_lock(&chip->setup_mutex);
 
         /* copy the struct snd_pcm_hardware struct */
@@ -227,7 +227,7 @@ static int lx_pcm_open(struct snd_pcm_substream *substream)
         err = snd_pcm_hw_constraint_integer(runtime,
                                             SNDRV_PCM_HW_PARAM_PERIODS);
         if (err < 0) {
-                snd_printk(KERN_WARNING LXP "could not constrain periods\n");
+                dev_warn(chip->card->dev, "could not constrain periods\n");
                 goto exit;
         }
 #endif
@@ -238,7 +238,7 @@ static int lx_pcm_open(struct snd_pcm_substream *substream)
                                            board_rate, board_rate);
 
         if (err < 0) {
-                snd_printk(KERN_WARNING LXP "could not constrain periods\n");
+                dev_warn(chip->card->dev, "could not constrain periods\n");
                 goto exit;
         }
 
@@ -248,7 +248,7 @@ static int lx_pcm_open(struct snd_pcm_substream *substream)
                                            MICROBLAZE_IBL_MIN,
                                            MICROBLAZE_IBL_MAX);
         if (err < 0) {
-                snd_printk(KERN_WARNING LXP
+                dev_warn(chip->card->dev,
                            "could not constrain period size\n");
                 goto exit;
         }
@@ -263,14 +263,14 @@ exit:
         runtime->private_data = chip;
 
         mutex_unlock(&chip->setup_mutex);
-        snd_printdd("<-lx_pcm_open, %d\n", err);
+        dev_dbg(chip->card->dev, "<-lx_pcm_open, %d\n", err);
         return err;
 }
 
 static int lx_pcm_close(struct snd_pcm_substream *substream)
 {
         int err = 0;
-        snd_printdd("->lx_pcm_close\n");
+        dev_dbg(substream->pcm->card->dev, "->lx_pcm_close\n");
         return err;
 }
 
@@ -285,13 +285,13 @@ static snd_pcm_uframes_t lx_pcm_stream_pointer(struct snd_pcm_substream
         struct lx_stream *lx_stream = is_capture ? &chip->capture_stream :
                 &chip->playback_stream;
 
-        snd_printdd("->lx_pcm_stream_pointer\n");
+        dev_dbg(chip->card->dev, "->lx_pcm_stream_pointer\n");
 
         spin_lock_irqsave(&chip->lock, flags);
         pos = lx_stream->frame_pos * substream->runtime->period_size;
         spin_unlock_irqrestore(&chip->lock, flags);
 
-        snd_printdd(LXP "stream_pointer at %ld\n", pos);
+        dev_dbg(chip->card->dev, "stream_pointer at %ld\n", pos);
         return pos;
 }
 
@@ -301,37 +301,37 @@ static int lx_pcm_prepare(struct snd_pcm_substream *substream)
         int err = 0;
         const int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 
-        snd_printdd("->lx_pcm_prepare\n");
+        dev_dbg(chip->card->dev, "->lx_pcm_prepare\n");
 
         mutex_lock(&chip->setup_mutex);
 
         if (chip->hardware_running[is_capture]) {
                 err = lx_hardware_stop(chip, substream);
                 if (err < 0) {
-                        snd_printk(KERN_ERR LXP "failed to stop hardware. "
+                        dev_err(chip->card->dev, "failed to stop hardware. "
                                    "Error code %d\n", err);
                         goto exit;
                 }
 
                 err = lx_hardware_close(chip, substream);
                 if (err < 0) {
-                        snd_printk(KERN_ERR LXP "failed to close hardware. "
+                        dev_err(chip->card->dev, "failed to close hardware. "
                                    "Error code %d\n", err);
                         goto exit;
                 }
         }
 
-        snd_printd(LXP "opening hardware\n");
+        dev_dbg(chip->card->dev, "opening hardware\n");
         err = lx_hardware_open(chip, substream);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "failed to open hardware. "
+                dev_err(chip->card->dev, "failed to open hardware. "
                            "Error code %d\n", err);
                 goto exit;
         }
 
         err = lx_hardware_start(chip, substream);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "failed to start hardware. "
+                dev_err(chip->card->dev, "failed to start hardware. "
                            "Error code %d\n", err);
                 goto exit;
         }
@@ -354,7 +354,7 @@ static int lx_pcm_hw_params(struct snd_pcm_substream *substream,
         struct lx6464es *chip = snd_pcm_substream_chip(substream);
         int err = 0;
 
-        snd_printdd("->lx_pcm_hw_params\n");
+        dev_dbg(chip->card->dev, "->lx_pcm_hw_params\n");
 
         mutex_lock(&chip->setup_mutex);
 
@@ -389,20 +389,20 @@ static int lx_pcm_hw_free(struct snd_pcm_substream *substream)
         int err = 0;
         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 
-        snd_printdd("->lx_pcm_hw_free\n");
+        dev_dbg(chip->card->dev, "->lx_pcm_hw_free\n");
         mutex_lock(&chip->setup_mutex);
 
         if (chip->hardware_running[is_capture]) {
                 err = lx_hardware_stop(chip, substream);
                 if (err < 0) {
-                        snd_printk(KERN_ERR LXP "failed to stop hardware. "
+                        dev_err(chip->card->dev, "failed to stop hardware. "
                                    "Error code %d\n", err);
                         goto exit;
                 }
 
                 err = lx_hardware_close(chip, substream);
                 if (err < 0) {
-                        snd_printk(KERN_ERR LXP "failed to close hardware. "
+                        dev_err(chip->card->dev, "failed to close hardware. "
                                    "Error code %d\n", err);
                         goto exit;
                 }
@@ -446,25 +446,25 @@ static void lx_trigger_start(struct lx6464es *chip, struct lx_stream *lx_stream)
 
                 err = lx_buffer_ask(chip, 0, is_capture, &needed, &freed,
                                     size_array);
-                snd_printdd(LXP "starting: needed %d, freed %d\n",
+                dev_dbg(chip->card->dev, "starting: needed %d, freed %d\n",
                             needed, freed);
 
                 err = lx_buffer_give(chip, 0, is_capture, period_bytes,
                                      lower_32_bits(buf), upper_32_bits(buf),
                                      &buffer_index);
 
-                snd_printdd(LXP "starting: buffer index %x on 0x%lx (%d bytes)\n",
+                dev_dbg(chip->card->dev, "starting: buffer index %x on 0x%lx (%d bytes)\n",
                             buffer_index, (unsigned long)buf, period_bytes);
                 buf += period_bytes;
         }
 
         err = lx_buffer_ask(chip, 0, is_capture, &needed, &freed, size_array);
-        snd_printdd(LXP "starting: needed %d, freed %d\n", needed, freed);
+        dev_dbg(chip->card->dev, "starting: needed %d, freed %d\n", needed, freed);
 
-        snd_printd(LXP "starting: starting stream\n");
+        dev_dbg(chip->card->dev, "starting: starting stream\n");
         err = lx_stream_start(chip, 0, is_capture);
         if (err < 0)
-                snd_printk(KERN_ERR LXP "couldn't start stream\n");
+                dev_err(chip->card->dev, "couldn't start stream\n");
         else
                 lx_stream->status = LX_STREAM_STATUS_RUNNING;
 
@@ -476,10 +476,10 @@ static void lx_trigger_stop(struct lx6464es *chip, struct lx_stream *lx_stream)
         const unsigned int is_capture = lx_stream->is_capture;
         int err;
 
-        snd_printd(LXP "stopping: stopping stream\n");
+        dev_dbg(chip->card->dev, "stopping: stopping stream\n");
         err = lx_stream_stop(chip, 0, is_capture);
         if (err < 0)
-                snd_printk(KERN_ERR LXP "couldn't stop stream\n");
+                dev_err(chip->card->dev, "couldn't stop stream\n");
         else
                 lx_stream->status = LX_STREAM_STATUS_FREE;
 
@@ -507,7 +507,7 @@ static void lx_trigger_tasklet(unsigned long data)
         struct lx6464es *chip = (struct lx6464es *)data;
         unsigned long flags;
 
-        snd_printdd("->lx_trigger_tasklet\n");
+        dev_dbg(chip->card->dev, "->lx_trigger_tasklet\n");
 
         spin_lock_irqsave(&chip->lock, flags);
         lx_trigger_tasklet_dispatch_stream(chip, &chip->capture_stream);
@@ -547,14 +547,14 @@ static int lx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         struct lx_stream *stream = is_capture ? &chip->capture_stream :
                 &chip->playback_stream;
 
-        snd_printdd("->lx_pcm_trigger\n");
+        dev_dbg(chip->card->dev, "->lx_pcm_trigger\n");
 
         return lx_pcm_trigger_dispatch(chip, stream, cmd);
 }
 
 static int snd_lx6464es_free(struct lx6464es *chip)
 {
-        snd_printdd("->snd_lx6464es_free\n");
+        dev_dbg(chip->card->dev, "->snd_lx6464es_free\n");
 
         lx_irq_disable(chip);
 
@@ -583,7 +583,7 @@ static int lx_init_xilinx_reset(struct lx6464es *chip)
         int i;
         u32 plx_reg = lx_plx_reg_read(chip, ePLX_CHIPSC);
 
-        snd_printdd("->lx_init_xilinx_reset\n");
+        dev_dbg(chip->card->dev, "->lx_init_xilinx_reset\n");
 
         /* activate reset of xilinx */
         plx_reg &= ~CHIPSC_RESET_XILINX;
@@ -603,8 +603,8 @@ static int lx_init_xilinx_reset(struct lx6464es *chip)
                 msleep(10);
                 reg_mbox3 = lx_plx_reg_read(chip, ePLX_MBOX3);
                 if (reg_mbox3) {
-                        snd_printd(LXP "xilinx reset done\n");
-                        snd_printdd(LXP "xilinx took %d loops\n", i);
+                        dev_dbg(chip->card->dev, "xilinx reset done\n");
+                        dev_dbg(chip->card->dev, "xilinx took %d loops\n", i);
                         break;
                 }
         }
@@ -624,7 +624,7 @@ static int lx_init_xilinx_test(struct lx6464es *chip)
 {
         u32 reg;
 
-        snd_printdd("->lx_init_xilinx_test\n");
+        dev_dbg(chip->card->dev, "->lx_init_xilinx_test\n");
 
         /* TEST if we have access to Xilinx/MicroBlaze */
         lx_dsp_reg_write(chip, eReg_CSM, 0);
@@ -632,19 +632,19 @@ static int lx_init_xilinx_test(struct lx6464es *chip)
         reg = lx_dsp_reg_read(chip, eReg_CSM);
 
         if (reg) {
-                snd_printk(KERN_ERR LXP "Problem: Reg_CSM %x.\n", reg);
+                dev_err(chip->card->dev, "Problem: Reg_CSM %x.\n", reg);
 
                 /* PCI9056_SPACE0_REMAP */
                 lx_plx_reg_write(chip, ePLX_PCICR, 1);
 
                 reg = lx_dsp_reg_read(chip, eReg_CSM);
                 if (reg) {
-                        snd_printk(KERN_ERR LXP "Error: Reg_CSM %x.\n", reg);
+                        dev_err(chip->card->dev, "Error: Reg_CSM %x.\n", reg);
                         return -EAGAIN; /* seems to be appropriate */
                 }
         }
 
-        snd_printd(LXP "Xilinx/MicroBlaze access test successful\n");
+        dev_dbg(chip->card->dev, "Xilinx/MicroBlaze access test successful\n");
 
         return 0;
 }
@@ -661,7 +661,7 @@ static int lx_init_ethersound_config(struct lx6464es *chip)
                 (64 << IOCR_OUTPUTS_OFFSET) |
                 (FREQ_RATIO_SINGLE_MODE << FREQ_RATIO_OFFSET);
 
-        snd_printdd("->lx_init_ethersound\n");
+        dev_dbg(chip->card->dev, "->lx_init_ethersound\n");
 
         chip->freq_ratio = FREQ_RATIO_SINGLE_MODE;
 
@@ -675,18 +675,18 @@ static int lx_init_ethersound_config(struct lx6464es *chip)
 
         for (i = 0; i != 1000; ++i) {
                 if (lx_dsp_reg_read(chip, eReg_CSES) & 4) {
-                        snd_printd(LXP "ethersound initialized after %dms\n",
+                        dev_dbg(chip->card->dev, "ethersound initialized after %dms\n",
                                    i);
                         goto ethersound_initialized;
                 }
                 msleep(1);
         }
-        snd_printk(KERN_WARNING LXP
+        dev_warn(chip->card->dev,
                    "ethersound could not be initialized after %dms\n", i);
         return -ETIMEDOUT;
 
  ethersound_initialized:
-        snd_printd(LXP "ethersound initialized\n");
+        dev_dbg(chip->card->dev, "ethersound initialized\n");
         return 0;
 }
 
@@ -696,14 +696,14 @@ static int lx_init_get_version_features(struct lx6464es *chip)
 
         int err;
 
-        snd_printdd("->lx_init_get_version_features\n");
+        dev_dbg(chip->card->dev, "->lx_init_get_version_features\n");
 
         err = lx_dsp_get_version(chip, &dsp_version);
 
         if (err == 0) {
                 u32 freq;
 
-                snd_printk(LXP "DSP version: V%02d.%02d #%d\n",
+                dev_info(chip->card->dev, "DSP version: V%02d.%02d #%d\n",
                            (dsp_version>>16) & 0xff, (dsp_version>>8) & 0xff,
                            dsp_version & 0xff);
 
@@ -718,9 +718,9 @@ static int lx_init_get_version_features(struct lx6464es *chip)
                 err = lx_dsp_get_clock_frequency(chip, &freq);
                 if (err == 0)
                         chip->board_sample_rate = freq;
-                snd_printd(LXP "actual clock frequency %d\n", freq);
+                dev_dbg(chip->card->dev, "actual clock frequency %d\n", freq);
         } else {
-                snd_printk(KERN_ERR LXP "DSP corrupted \n");
+                dev_err(chip->card->dev, "DSP corrupted \n");
                 err = -EAGAIN;
         }
 
@@ -732,7 +732,7 @@ static int lx_set_granularity(struct lx6464es *chip, u32 gran)
         int err = 0;
         u32 snapped_gran = MICROBLAZE_IBL_MIN;
 
-        snd_printdd("->lx_set_granularity\n");
+        dev_dbg(chip->card->dev, "->lx_set_granularity\n");
 
         /* blocksize is a power of 2 */
         while ((snapped_gran < gran) &&
@@ -745,14 +745,14 @@ static int lx_set_granularity(struct lx6464es *chip, u32 gran)
 
         err = lx_dsp_set_granularity(chip, snapped_gran);
         if (err < 0) {
-                snd_printk(KERN_WARNING LXP "could not set granularity\n");
+                dev_warn(chip->card->dev, "could not set granularity\n");
                 err = -EAGAIN;
         }
 
         if (snapped_gran != gran)
-                snd_printk(LXP "snapped blocksize to %d\n", snapped_gran);
+                dev_err(chip->card->dev, "snapped blocksize to %d\n", snapped_gran);
 
-        snd_printd(LXP "set blocksize on board %d\n", snapped_gran);
+        dev_dbg(chip->card->dev, "set blocksize on board %d\n", snapped_gran);
         chip->pcm_granularity = snapped_gran;
 
         return err;
@@ -764,19 +764,19 @@ static int lx_init_dsp(struct lx6464es *chip)
         int err;
         int i;
 
-        snd_printdd("->lx_init_dsp\n");
+        dev_dbg(chip->card->dev, "->lx_init_dsp\n");
 
-        snd_printd(LXP "initialize board\n");
+        dev_dbg(chip->card->dev, "initialize board\n");
         err = lx_init_xilinx_reset(chip);
         if (err)
                 return err;
 
-        snd_printd(LXP "testing board\n");
+        dev_dbg(chip->card->dev, "testing board\n");
         err = lx_init_xilinx_test(chip);
         if (err)
                 return err;
 
-        snd_printd(LXP "initialize ethersound configuration\n");
+        dev_dbg(chip->card->dev, "initialize ethersound configuration\n");
         err = lx_init_ethersound_config(chip);
         if (err)
                 return err;
@@ -797,8 +797,9 @@ static int lx_init_dsp(struct lx6464es *chip)
         return -ETIMEDOUT;
 
 mac_ready:
-        snd_printd(LXP "mac address ready read after: %dms\n", i);
-        snd_printk(LXP "mac address: %02X.%02X.%02X.%02X.%02X.%02X\n",
+        dev_dbg(chip->card->dev, "mac address ready read after: %dms\n", i);
+        dev_info(chip->card->dev,
+                 "mac address: %02X.%02X.%02X.%02X.%02X.%02X\n",
                    chip->mac_address[0], chip->mac_address[1], chip->mac_address[2],
                    chip->mac_address[3], chip->mac_address[4], chip->mac_address[5]);
 
@@ -977,7 +978,7 @@ static int snd_lx6464es_create(struct snd_card *card,
                 .dev_free = snd_lx6464es_dev_free,
         };
 
-        snd_printdd("->snd_lx6464es_create\n");
+        dev_dbg(card->dev, "->snd_lx6464es_create\n");
 
         *rchip = NULL;
 
@@ -991,8 +992,8 @@ static int snd_lx6464es_create(struct snd_card *card,
         /* check if we can restrict PCI DMA transfers to 32 bits */
         err = pci_set_dma_mask(pci, DMA_BIT_MASK(32));
         if (err < 0) {
-                snd_printk(KERN_ERR "architecture does not support "
-                           "32bit PCI busmaster DMA\n");
+                dev_err(card->dev,
+                        "architecture does not support 32bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -1034,7 +1035,7 @@ static int snd_lx6464es_create(struct snd_card *card,
         err = request_irq(pci->irq, lx_interrupt, IRQF_SHARED,
                           KBUILD_MODNAME, chip);
         if (err) {
-                snd_printk(KERN_ERR LXP "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 goto request_irq_failed;
         }
         chip->irq = pci->irq;
@@ -1045,7 +1046,7 @@ static int snd_lx6464es_create(struct snd_card *card,
 
         err = lx_init_dsp(chip);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "error during DSP initialization\n");
+                dev_err(card->dev, "error during DSP initialization\n");
                 return err;
         }
 
@@ -1088,7 +1089,7 @@ static int snd_lx6464es_probe(struct pci_dev *pci,
         struct lx6464es *chip;
         int err;
 
-        snd_printdd("->snd_lx6464es_probe\n");
+        dev_dbg(&pci->dev, "->snd_lx6464es_probe\n");
 
         if (dev >= SNDRV_CARDS)
                 return -ENODEV;
@@ -1104,7 +1105,7 @@ static int snd_lx6464es_probe(struct pci_dev *pci,
 
         err = snd_lx6464es_create(card, pci, &chip);
         if (err < 0) {
-                snd_printk(KERN_ERR LXP "error during snd_lx6464es_create\n");
+                dev_err(card->dev, "error during snd_lx6464es_create\n");
                 goto out_free;
         }
 
@@ -1124,7 +1125,7 @@ static int snd_lx6464es_probe(struct pci_dev *pci,
         if (err < 0)
                 goto out_free;
 
-        snd_printdd(LXP "initialization successful\n");
+        dev_dbg(chip->card->dev, "initialization successful\n");
         pci_set_drvdata(pci, card);
         dev++;
         return 0;
diff --git a/sound/pci/lx6464es/lx_core.c b/sound/pci/lx6464es/lx_core.c
index df4044d4f43d..2d8e95e9fbe5 100644
--- a/sound/pci/lx6464es/lx_core.c
+++ b/sound/pci/lx6464es/lx_core.c
@@ -273,7 +273,7 @@ static int lx_message_send_atomic(struct lx6464es *chip, struct lx_rmh *rmh)
         int dwloop;
 
         if (lx_dsp_reg_read(chip, eReg_CSM) & (Reg_CSM_MC | Reg_CSM_MR)) {
-                snd_printk(KERN_ERR LXP "PIOSendMessage eReg_CSM %x\n", reg);
+                dev_err(chip->card->dev, "PIOSendMessage eReg_CSM %x\n", reg);
                 return -EBUSY;
         }
 
@@ -294,7 +294,7 @@ static int lx_message_send_atomic(struct lx6464es *chip, struct lx_rmh *rmh)
                 } else
                         udelay(1);
         }
-        snd_printk(KERN_WARNING LXP "TIMEOUT lx_message_send_atomic! "
+        dev_warn(chip->card->dev, "TIMEOUT lx_message_send_atomic! "
                    "polling failed\n");
 
 polling_successful:
@@ -306,18 +306,18 @@ polling_successful:
                                            rmh->stat_len);
                 }
         } else
-                snd_printk(LXP "rmh error: %08x\n", reg);
+                dev_err(chip->card->dev, "rmh error: %08x\n", reg);
 
         /* clear Reg_CSM_MR */
         lx_dsp_reg_write(chip, eReg_CSM, 0);
 
         switch (reg) {
         case ED_DSP_TIMED_OUT:
-                snd_printk(KERN_WARNING LXP "lx_message_send: dsp timeout\n");
+                dev_warn(chip->card->dev, "lx_message_send: dsp timeout\n");
                 return -ETIMEDOUT;
 
         case ED_DSP_CRASHED:
-                snd_printk(KERN_WARNING LXP "lx_message_send: dsp crashed\n");
+                dev_warn(chip->card->dev, "lx_message_send: dsp crashed\n");
                 return -EAGAIN;
         }
 
@@ -458,7 +458,7 @@ int lx_pipe_allocate(struct lx6464es *chip, u32 pipe, int is_capture,
         spin_unlock_irqrestore(&chip->msg_lock, flags);
 
         if (err != 0)
-                snd_printk(KERN_ERR "lx6464es: could not allocate pipe\n");
+                dev_err(chip->card->dev, "could not allocate pipe\n");
 
         return err;
 }
@@ -520,11 +520,13 @@ int lx_buffer_ask(struct lx6464es *chip, u32 pipe, int is_capture,
                 }
 
 #if 0
-                snd_printdd(LXP "CMD_08_ASK_BUFFERS: needed %d, freed %d\n",
+                dev_dbg(chip->card->dev,
+                        "CMD_08_ASK_BUFFERS: needed %d, freed %d\n",
                             *r_needed, *r_freed);
                 for (i = 0; i < MAX_STREAM_BUFFER; ++i) {
                         for (i = 0; i != chip->rmh.stat_len; ++i)
-                                snd_printdd("  stat[%d]: %x, %x\n", i,
+                                dev_dbg(chip->card->dev,
+                                        "  stat[%d]: %x, %x\n", i,
                                             chip->rmh.stat[i],
                                             chip->rmh.stat[i] & MASK_DATA_SIZE);
                 }
@@ -617,8 +619,8 @@ int lx_pipe_sample_count(struct lx6464es *chip, u32 pipe, int is_capture,
         err = lx_message_send_atomic(chip, &chip->rmh); /* don't sleep! */
 
         if (err != 0)
-                snd_printk(KERN_ERR
-                           "lx6464es: could not query pipe's sample count\n");
+                dev_err(chip->card->dev,
+                        "could not query pipe's sample count\n");
         else {
                 *rsample_count = ((u64)(chip->rmh.stat[0] & MASK_SPL_COUNT_HI)
                                   << 24)     /* hi part */
@@ -644,7 +646,7 @@ int lx_pipe_state(struct lx6464es *chip, u32 pipe, int is_capture, u16 *rstate)
         err = lx_message_send_atomic(chip, &chip->rmh);
 
         if (err != 0)
-                snd_printk(KERN_ERR "lx6464es: could not query pipe's state\n");
+                dev_err(chip->card->dev, "could not query pipe's state\n");
         else
                 *rstate = (chip->rmh.stat[0] >> PSTATE_OFFSET) & 0x0F;
 
@@ -717,7 +719,7 @@ int lx_stream_set_format(struct lx6464es *chip, struct snd_pcm_runtime *runtime,
         u32 channels = runtime->channels;
 
         if (runtime->channels != channels)
-                snd_printk(KERN_ERR LXP "channel count mismatch: %d vs %d",
+                dev_err(chip->card->dev, "channel count mismatch: %d vs %d",
                            runtime->channels, channels);
 
         spin_lock_irqsave(&chip->msg_lock, flags);
@@ -820,13 +822,16 @@ int lx_buffer_give(struct lx6464es *chip, u32 pipe, int is_capture,
         }
 
         if (err == EB_RBUFFERS_TABLE_OVERFLOW)
-                snd_printk(LXP "lx_buffer_give EB_RBUFFERS_TABLE_OVERFLOW\n");
+                dev_err(chip->card->dev,
+                        "lx_buffer_give EB_RBUFFERS_TABLE_OVERFLOW\n");
 
         if (err == EB_INVALID_STREAM)
-                snd_printk(LXP "lx_buffer_give EB_INVALID_STREAM\n");
+                dev_err(chip->card->dev,
+                        "lx_buffer_give EB_INVALID_STREAM\n");
 
         if (err == EB_CMD_REFUSED)
-                snd_printk(LXP "lx_buffer_give EB_CMD_REFUSED\n");
+                dev_err(chip->card->dev,
+                        "lx_buffer_give EB_CMD_REFUSED\n");
 
  done:
         spin_unlock_irqrestore(&chip->msg_lock, flags);
@@ -899,7 +904,8 @@ int lx_level_unmute(struct lx6464es *chip, int is_capture, int unmute)
         chip->rmh.cmd[1] = (u32)(mute_mask >> (u64)32);        /* hi part */
         chip->rmh.cmd[2] = (u32)(mute_mask & (u64)0xFFFFFFFF); /* lo part */
 
-        snd_printk("mute %x %x %x\n", chip->rmh.cmd[0], chip->rmh.cmd[1],
+        dev_dbg(chip->card->dev,
+                "mute %x %x %x\n", chip->rmh.cmd[0], chip->rmh.cmd[1],
                    chip->rmh.cmd[2]);
 
         err = lx_message_send_atomic(chip, &chip->rmh);
@@ -1009,7 +1015,7 @@ static int lx_interrupt_ack(struct lx6464es *chip, u32 *r_irqsrc,
         }
 
         if (irq_async) {
-                /* snd_printd("interrupt: async event pending\n"); */
+                /* dev_dbg(chip->card->dev, "interrupt: async event pending\n"); */
                 *r_async_pending = 1;
         }
 
@@ -1055,13 +1061,13 @@ static int lx_interrupt_handle_async_events(struct lx6464es *chip, u32 irqsrc,
         if (eb_pending_in) {
                 *r_notified_in_pipe_mask = ((u64)stat[3] << 32)
                         + stat[4];
-                snd_printdd(LXP "interrupt: EOBI pending %llx\n",
+                dev_dbg(chip->card->dev, "interrupt: EOBI pending %llx\n",
                             *r_notified_in_pipe_mask);
         }
         if (eb_pending_out) {
                 *r_notified_out_pipe_mask = ((u64)stat[1] << 32)
                         + stat[2];
-                snd_printdd(LXP "interrupt: EOBO pending %llx\n",
+                dev_dbg(chip->card->dev, "interrupt: EOBO pending %llx\n",
                             *r_notified_out_pipe_mask);
         }
 
@@ -1097,17 +1103,19 @@ static int lx_interrupt_request_new_buffer(struct lx6464es *chip,
         u32 needed, freed;
         u32 size_array[MAX_STREAM_BUFFER];
 
-        snd_printdd("->lx_interrupt_request_new_buffer\n");
+        dev_dbg(chip->card->dev, "->lx_interrupt_request_new_buffer\n");
 
         spin_lock_irqsave(&chip->lock, flags);
 
         err = lx_buffer_ask(chip, 0, is_capture, &needed, &freed, size_array);
-        snd_printdd(LXP "interrupt: needed %d, freed %d\n", needed, freed);
+        dev_dbg(chip->card->dev,
+                "interrupt: needed %d, freed %d\n", needed, freed);
 
         unpack_pointer(buf, &buf_lo, &buf_hi);
         err = lx_buffer_give(chip, 0, is_capture, period_bytes, buf_lo, buf_hi,
                              &buffer_index);
-        snd_printdd(LXP "interrupt: gave buffer index %x on 0x%lx (%d bytes)\n",
+        dev_dbg(chip->card->dev,
+                "interrupt: gave buffer index %x on 0x%lx (%d bytes)\n",
                     buffer_index, (unsigned long)buf, period_bytes);
 
         lx_stream->frame_pos = next_pos;
@@ -1122,11 +1130,11 @@ void lx_tasklet_playback(unsigned long data)
         struct lx_stream *lx_stream = &chip->playback_stream;
         int err;
 
-        snd_printdd("->lx_tasklet_playback\n");
+        dev_dbg(chip->card->dev, "->lx_tasklet_playback\n");
 
         err = lx_interrupt_request_new_buffer(chip, lx_stream);
         if (err < 0)
-                snd_printk(KERN_ERR LXP
+                dev_err(chip->card->dev,
                            "cannot request new buffer for playback\n");
 
         snd_pcm_period_elapsed(lx_stream->stream);
@@ -1138,10 +1146,10 @@ void lx_tasklet_capture(unsigned long data)
         struct lx_stream *lx_stream = &chip->capture_stream;
         int err;
 
-        snd_printdd("->lx_tasklet_capture\n");
+        dev_dbg(chip->card->dev, "->lx_tasklet_capture\n");
         err = lx_interrupt_request_new_buffer(chip, lx_stream);
         if (err < 0)
-                snd_printk(KERN_ERR LXP
+                dev_err(chip->card->dev,
                            "cannot request new buffer for capture\n");
 
         snd_pcm_period_elapsed(lx_stream->stream);
@@ -1156,12 +1164,14 @@ static int lx_interrupt_handle_audio_transfer(struct lx6464es *chip,
         int err = 0;
 
         if (notified_in_pipe_mask) {
-                snd_printdd(LXP "requesting audio transfer for capture\n");
+                dev_dbg(chip->card->dev,
+                        "requesting audio transfer for capture\n");
                 tasklet_hi_schedule(&chip->tasklet_capture);
         }
 
         if (notified_out_pipe_mask) {
-                snd_printdd(LXP "requesting audio transfer for playback\n");
+                dev_dbg(chip->card->dev,
+                        "requesting audio transfer for playback\n");
                 tasklet_hi_schedule(&chip->tasklet_playback);
         }
 
@@ -1177,11 +1187,12 @@ irqreturn_t lx_interrupt(int irq, void *dev_id)
 
         spin_lock(&chip->lock);
 
-        snd_printdd("**************************************************\n");
+        dev_dbg(chip->card->dev,
+                "**************************************************\n");
 
         if (!lx_interrupt_ack(chip, &irqsrc, &async_pending, &async_escmd)) {
                 spin_unlock(&chip->lock);
-                snd_printdd("IRQ_NONE\n");
+                dev_dbg(chip->card->dev, "IRQ_NONE\n");
                 return IRQ_NONE; /* this device did not cause the interrupt */
         }
 
@@ -1190,16 +1201,16 @@ irqreturn_t lx_interrupt(int irq, void *dev_id)
 
 #if 0
         if (irqsrc & MASK_SYS_STATUS_EOBI)
-                snd_printdd(LXP "interrupt: EOBI\n");
+                dev_dgg(chip->card->dev, "interrupt: EOBI\n");
 
         if (irqsrc & MASK_SYS_STATUS_EOBO)
-                snd_printdd(LXP "interrupt: EOBO\n");
+                dev_dbg(chip->card->dev, "interrupt: EOBO\n");
 
         if (irqsrc & MASK_SYS_STATUS_URUN)
-                snd_printdd(LXP "interrupt: URUN\n");
+                dev_dbg(chip->card->dev, "interrupt: URUN\n");
 
         if (irqsrc & MASK_SYS_STATUS_ORUN)
-                snd_printdd(LXP "interrupt: ORUN\n");
+                dev_dbg(chip->card->dev, "interrupt: ORUN\n");
 #endif
 
         if (async_pending) {
@@ -1214,7 +1225,7 @@ irqreturn_t lx_interrupt(int irq, void *dev_id)
                                                        &notified_in_pipe_mask,
                                                        &notified_out_pipe_mask);
                 if (err)
-                        snd_printk(KERN_ERR LXP
+                        dev_err(chip->card->dev,
                                    "error handling async events\n");
 
                 err = lx_interrupt_handle_audio_transfer(chip,
@@ -1222,7 +1233,7 @@ irqreturn_t lx_interrupt(int irq, void *dev_id)
                                                          notified_out_pipe_mask
                         );
                 if (err)
-                        snd_printk(KERN_ERR LXP
+                        dev_err(chip->card->dev,
                                    "error during audio transfer\n");
         }
 
@@ -1234,7 +1245,7 @@ irqreturn_t lx_interrupt(int irq, void *dev_id)
                  *
                  * */
 
-                snd_printdd("lx6464es: interrupt requests escmd handling\n");
+                dev_dbg(chip->card->dev, "interrupt requests escmd handling\n");
 #endif
         }
 
@@ -1262,12 +1273,12 @@ static void lx_irq_set(struct lx6464es *chip, int enable)
 
 void lx_irq_enable(struct lx6464es *chip)
 {
-        snd_printdd("->lx_irq_enable\n");
+        dev_dbg(chip->card->dev, "->lx_irq_enable\n");
         lx_irq_set(chip, 1);
 }
 
 void lx_irq_disable(struct lx6464es *chip)
 {
-        snd_printdd("->lx_irq_disable\n");
+        dev_dbg(chip->card->dev, "->lx_irq_disable\n");
         lx_irq_set(chip, 0);
 }
diff --git a/sound/pci/maestro3.c b/sound/pci/maestro3.c
index 076c3ec000c0..0d3ea3e79952 100644
--- a/sound/pci/maestro3.c
+++ b/sound/pci/maestro3.c
@@ -1403,7 +1403,7 @@ static int snd_m3_pcm_hw_params(struct snd_pcm_substream *substream,
         /* set buffer address */
         s->buffer_addr = substream->runtime->dma_addr;
         if (s->buffer_addr & 0x3) {
-                snd_printk(KERN_ERR "oh my, not aligned\n");
+                dev_err(substream->pcm->card->dev, "oh my, not aligned\n");
                 s->buffer_addr = s->buffer_addr & ~0x3;
         }
         return 0;
@@ -1900,7 +1900,7 @@ static int snd_m3_ac97_wait(struct snd_m3 *chip)
                 cpu_relax();
         } while (i-- > 0);
 
-        snd_printk(KERN_ERR "ac97 serial bus busy\n");
+        dev_err(chip->card->dev, "ac97 serial bus busy\n");
         return 1;
 }
 
@@ -2015,7 +2015,8 @@ static void snd_m3_ac97_reset(struct snd_m3 *chip)
                 delay1 += 10;
                 delay2 += 100;
 
-                snd_printd("maestro3: retrying codec reset with delays of %d and %d ms\n",
+                dev_dbg(chip->card->dev,
+                        "retrying codec reset with delays of %d and %d ms\n",
                            delay1, delay2);
         }
 
@@ -2194,7 +2195,8 @@ static int snd_m3_assp_client_init(struct snd_m3 *chip, struct m3_dma *s, int in
         address = 0x1100 + ((data_bytes/2) * index);
 
         if ((address + (data_bytes/2)) >= 0x1c00) {
-                snd_printk(KERN_ERR "no memory for %d bytes at ind %d (addr 0x%x)\n",
+                dev_err(chip->card->dev,
+                        "no memory for %d bytes at ind %d (addr 0x%x)\n",
                            data_bytes, index, address);
                 return -ENOMEM;
         }
@@ -2439,8 +2441,7 @@ static int m3_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "maestor3: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2553,7 +2554,8 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci,
         /* check, if we can restrict PCI DMA transfers to 28 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
+                dev_err(card->dev,
+                        "architecture does not support 28bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -2586,9 +2588,8 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci,
         else {
                 quirk = snd_pci_quirk_lookup(pci, m3_amp_quirk_list);
                 if (quirk) {
-                        snd_printdd(KERN_INFO
-                                    "maestro3: set amp-gpio for '%s'\n",
-                                    snd_pci_quirk_name(quirk));
+                        dev_info(card->dev, "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;
@@ -2598,9 +2599,8 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci,
 
         quirk = snd_pci_quirk_lookup(pci, m3_irda_quirk_list);
         if (quirk) {
-                snd_printdd(KERN_INFO
-                            "maestro3: enabled irda workaround for '%s'\n",
-                            snd_pci_quirk_name(quirk));
+                dev_info(card->dev, "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);
@@ -2652,7 +2652,7 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci,
 
         if (request_irq(pci->irq, snd_m3_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_m3_free(chip);
                 return -ENOMEM;
         }
@@ -2661,7 +2661,7 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci,
 #ifdef CONFIG_PM_SLEEP
         chip->suspend_mem = vmalloc(sizeof(u16) * (REV_B_CODE_MEMORY_LENGTH + REV_B_DATA_MEMORY_LENGTH));
         if (chip->suspend_mem == NULL)
-                snd_printk(KERN_WARNING "can't allocate apm buffer\n");
+                dev_warn(card->dev, "can't allocate apm buffer\n");
 #endif
 
         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
@@ -2685,8 +2685,9 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci,
         if (chip->hv_config & HV_CTRL_ENABLE) {
                 err = snd_m3_input_register(chip);
                 if (err)
-                        snd_printk(KERN_WARNING "Input device registration "
-                                "failed with error %i", err);
+                        dev_warn(card->dev,
+                                 "Input device registration failed with error %i",
+                                 err);
         }
 #endif
 
@@ -2763,7 +2764,7 @@ snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
                                   MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK,
                                   -1, &chip->rmidi);
         if (err < 0)
-                printk(KERN_WARNING "maestro3: no MIDI support.\n");
+                dev_warn(card->dev, "no MIDI support.\n");
 #endif
 
         pci_set_drvdata(pci, card);
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index 9ab057bb9859..a93e7af51eed 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -87,7 +87,8 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr,
                 if(!start) return 0; /* already stopped */
                 break;
         default:
-                snd_printk(KERN_ERR "error mixart_set_pipe_state called with wrong pipe->status!\n");
+                dev_err(&mgr->pci->dev,
+                        "error mixart_set_pipe_state called with wrong pipe->status!\n");
                 return -EINVAL;      /* function called with wrong pipe status */
         }
 
@@ -102,7 +103,8 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr,
 
         err = snd_mixart_send_msg_wait_notif(mgr, &request, system_msg_uid);
         if(err) {
-                snd_printk(KERN_ERR "error : MSG_SYSTEM_WAIT_SYNCHRO_CMD was not notified !\n");
+                dev_err(&mgr->pci->dev,
+                        "error : MSG_SYSTEM_WAIT_SYNCHRO_CMD was not notified !\n");
                 return err;
         }
 
@@ -123,7 +125,9 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr,
 
         err = snd_mixart_send_msg(mgr, &request, sizeof(group_state_resp), &group_state_resp);
         if (err < 0 || group_state_resp.txx_status != 0) {
-                snd_printk(KERN_ERR "error MSG_STREAM_ST***_STREAM_GRP_PACKET err=%x stat=%x !\n", err, group_state_resp.txx_status);
+                dev_err(&mgr->pci->dev,
+                        "error MSG_STREAM_ST***_STREAM_GRP_PACKET err=%x stat=%x !\n",
+                        err, group_state_resp.txx_status);
                 return -EINVAL;
         }
 
@@ -134,7 +138,9 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr,
 
                 err = snd_mixart_send_msg(mgr, &request, sizeof(group_state_resp), &group_state_resp);
                 if (err < 0 || group_state_resp.txx_status != 0) {
-                        snd_printk(KERN_ERR "error MSG_STREAM_START_STREAM_GRP_PACKET err=%x stat=%x !\n", err, group_state_resp.txx_status);
+                        dev_err(&mgr->pci->dev,
+                                "error MSG_STREAM_START_STREAM_GRP_PACKET err=%x stat=%x !\n",
+                                err, group_state_resp.txx_status);
                         return -EINVAL;
                 }
 
@@ -147,7 +153,9 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr,
 
                 err = snd_mixart_send_msg(mgr, &request, sizeof(stat), &stat);
                 if (err < 0 || stat != 0) {
-                        snd_printk(KERN_ERR "error MSG_SYSTEM_SEND_SYNCHRO_CMD err=%x stat=%x !\n", err, stat);
+                        dev_err(&mgr->pci->dev,
+                                "error MSG_SYSTEM_SEND_SYNCHRO_CMD err=%x stat=%x !\n",
+                                err, stat);
                         return -EINVAL;
                 }
 
@@ -178,7 +186,9 @@ static int mixart_set_clock(struct mixart_mgr *mgr,
                 if(rate == 0)
                         return 0; /* nothing to do */
                 else {
-                        snd_printk(KERN_ERR "error mixart_set_clock(%d) called with wrong pipe->status !\n", rate);
+                        dev_err(&mgr->pci->dev,
+                                "error mixart_set_clock(%d) called with wrong pipe->status !\n",
+                                rate);
                         return -EINVAL;
                 }
         }
@@ -190,7 +200,7 @@ static int mixart_set_clock(struct mixart_mgr *mgr,
         clock_properties.nb_callers = 1; /* only one entry in uid_caller ! */
         clock_properties.uid_caller[0] = pipe->group_uid;
 
-        snd_printdd("mixart_set_clock to %d kHz\n", rate);
+        dev_dbg(&mgr->pci->dev, "mixart_set_clock to %d kHz\n", rate);
 
         request.message_id = MSG_CLOCK_SET_PROPERTIES;
         request.uid = mgr->uid_console_manager;
@@ -199,7 +209,9 @@ static int mixart_set_clock(struct mixart_mgr *mgr,
 
         err = snd_mixart_send_msg(mgr, &request, sizeof(clock_prop_resp), &clock_prop_resp);
         if (err < 0 || clock_prop_resp.status != 0 || clock_prop_resp.clock_mode != CM_STANDALONE) {
-                snd_printk(KERN_ERR "error MSG_CLOCK_SET_PROPERTIES err=%x stat=%x mod=%x !\n", err, clock_prop_resp.status, clock_prop_resp.clock_mode);
+                dev_err(&mgr->pci->dev,
+                        "error MSG_CLOCK_SET_PROPERTIES err=%x stat=%x mod=%x !\n",
+                        err, clock_prop_resp.status, clock_prop_resp.clock_mode);
                 return -EINVAL;
         }
 
@@ -252,7 +264,9 @@ snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture,
                         struct mixart_streaming_group sgroup_resp;
                 } *buf;
 
-                snd_printdd("add_ref_pipe audio chip(%d) pcm(%d)\n", chip->chip_idx, pcm_number);
+                dev_dbg(chip->card->dev,
+                        "add_ref_pipe audio chip(%d) pcm(%d)\n",
+                        chip->chip_idx, pcm_number);
 
                 buf = kmalloc(sizeof(*buf), GFP_KERNEL);
                 if (!buf)
@@ -302,7 +316,9 @@ snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture,
 
                 err = snd_mixart_send_msg(chip->mgr, &request, sizeof(buf->sgroup_resp), &buf->sgroup_resp);
                 if((err < 0) || (buf->sgroup_resp.status != 0)) {
-                        snd_printk(KERN_ERR "error MSG_STREAM_ADD_**PUT_GROUP err=%x stat=%x !\n", err, buf->sgroup_resp.status);
+                        dev_err(chip->card->dev,
+                                "error MSG_STREAM_ADD_**PUT_GROUP err=%x stat=%x !\n",
+                                err, buf->sgroup_resp.status);
                         kfree(buf);
                         return NULL;
                 }
@@ -343,13 +359,14 @@ int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr,
                 /* release the clock */
                 err = mixart_set_clock( mgr, pipe, 0);
                 if( err < 0 ) {
-                        snd_printk(KERN_ERR "mixart_set_clock(0) return error!\n");
+                        dev_err(&mgr->pci->dev,
+                                "mixart_set_clock(0) return error!\n");
                 }
 
                 /* stop the pipe */
                 err = mixart_set_pipe_state(mgr, pipe, 0);
                 if( err < 0 ) {
-                        snd_printk(KERN_ERR "error stopping pipe!\n");
+                        dev_err(&mgr->pci->dev, "error stopping pipe!\n");
                 }
 
                 request.message_id = MSG_STREAM_DELETE_GROUP;
@@ -360,7 +377,9 @@ int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr,
                 /* delete the pipe */
                 err = snd_mixart_send_msg(mgr, &request, sizeof(delete_resp), &delete_resp);
                 if ((err < 0) || (delete_resp.status != 0)) {
-                        snd_printk(KERN_ERR "error MSG_STREAM_DELETE_GROUP err(%x), status(%x)\n", err, delete_resp.status);
+                        dev_err(&mgr->pci->dev,
+                                "error MSG_STREAM_DELETE_GROUP err(%x), status(%x)\n",
+                                err, delete_resp.status);
                 }
 
                 pipe->group_uid = (struct mixart_uid){0,0};
@@ -414,7 +433,7 @@ static int snd_mixart_trigger(struct snd_pcm_substream *subs, int cmd)
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
 
-                snd_printdd("SNDRV_PCM_TRIGGER_START\n");
+                dev_dbg(subs->pcm->card->dev, "SNDRV_PCM_TRIGGER_START\n");
 
                 /* START_STREAM */
                 if( mixart_set_stream_state(stream, 1) )
@@ -431,19 +450,19 @@ static int snd_mixart_trigger(struct snd_pcm_substream *subs, int cmd)
 
                 stream->status = MIXART_STREAM_STATUS_OPEN;
 
-                snd_printdd("SNDRV_PCM_TRIGGER_STOP\n");
+                dev_dbg(subs->pcm->card->dev, "SNDRV_PCM_TRIGGER_STOP\n");
 
                 break;
 
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 /* TODO */
                 stream->status = MIXART_STREAM_STATUS_PAUSE;
-                snd_printdd("SNDRV_PCM_PAUSE_PUSH\n");
+                dev_dbg(subs->pcm->card->dev, "SNDRV_PCM_PAUSE_PUSH\n");
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 /* TODO */
                 stream->status = MIXART_STREAM_STATUS_RUNNING;
-                snd_printdd("SNDRV_PCM_PAUSE_RELEASE\n");
+                dev_dbg(subs->pcm->card->dev, "SNDRV_PCM_PAUSE_RELEASE\n");
                 break;
         default:
                 return -EINVAL;
@@ -456,7 +475,8 @@ static int mixart_sync_nonblock_events(struct mixart_mgr *mgr)
         unsigned long timeout = jiffies + HZ;
         while (atomic_read(&mgr->msg_processed) > 0) {
                 if (time_after(jiffies, timeout)) {
-                        snd_printk(KERN_ERR "mixart: cannot process nonblock events!\n");
+                        dev_err(&mgr->pci->dev,
+                                "mixart: cannot process nonblock events!\n");
                         return -EBUSY;
                 }
                 schedule_timeout_uninterruptible(1);
@@ -474,7 +494,7 @@ static int snd_mixart_prepare(struct snd_pcm_substream *subs)
 
         /* TODO de façon non bloquante, réappliquer les hw_params (rate, bits, codec) */
 
-        snd_printdd("snd_mixart_prepare\n");
+        dev_dbg(chip->card->dev, "snd_mixart_prepare\n");
 
         mixart_sync_nonblock_events(chip->mgr);
 
@@ -542,11 +562,13 @@ static int mixart_set_format(struct mixart_stream *stream, snd_pcm_format_t form
                 stream_param.sample_size = 32;
                 break;
         default:
-                snd_printk(KERN_ERR "error mixart_set_format() : unknown format\n");
+                dev_err(chip->card->dev,
+                        "error mixart_set_format() : unknown format\n");
                 return -EINVAL;
         }
 
-        snd_printdd("set SNDRV_PCM_FORMAT sample_type(%d) sample_size(%d) freq(%d) channels(%d)\n",
+        dev_dbg(chip->card->dev,
+                "set SNDRV_PCM_FORMAT sample_type(%d) sample_size(%d) freq(%d) channels(%d)\n",
                    stream_param.sample_type, stream_param.sample_size, stream_param.sampling_freq, stream->channels);
 
         /* TODO: what else to configure ? */
@@ -566,7 +588,9 @@ static int mixart_set_format(struct mixart_stream *stream, snd_pcm_format_t form
 
         err = snd_mixart_send_msg(chip->mgr, &request, sizeof(resp), &resp);
         if((err < 0) || resp.error_code) {
-                snd_printk(KERN_ERR "MSG_STREAM_SET_INPUT_STAGE_PARAM err=%x; resp=%x\n", err, resp.error_code);
+                dev_err(chip->card->dev,
+                        "MSG_STREAM_SET_INPUT_STAGE_PARAM err=%x; resp=%x\n",
+                        err, resp.error_code);
                 return -EINVAL;
         }
         return 0;
@@ -627,8 +651,9 @@ static int snd_mixart_hw_params(struct snd_pcm_substream *subs,
                 bufferinfo[i].available_length = subs->runtime->dma_bytes;
                 /* bufferinfo[i].buffer_id  is already defined */
 
-                snd_printdd("snd_mixart_hw_params(pcm %d) : dma_addr(%x) dma_bytes(%x) subs-number(%d)\n", i,
-                                bufferinfo[i].buffer_address,
+                dev_dbg(chip->card->dev,
+                        "snd_mixart_hw_params(pcm %d) : dma_addr(%x) dma_bytes(%x) subs-number(%d)\n",
+                        i, bufferinfo[i].buffer_address,
                                 bufferinfo[i].available_length,
                                 subs->number);
         }
@@ -714,14 +739,18 @@ static int snd_mixart_playback_open(struct snd_pcm_substream *subs)
                 pcm_number = MIXART_PCM_DIGITAL;
                 runtime->hw = snd_mixart_digital_caps;
         }
-        snd_printdd("snd_mixart_playback_open C%d/P%d/Sub%d\n", chip->chip_idx, pcm_number, subs->number);
+        dev_dbg(chip->card->dev,
+                "snd_mixart_playback_open C%d/P%d/Sub%d\n",
+                chip->chip_idx, pcm_number, subs->number);
 
         /* get stream info */
         stream = &(chip->playback_stream[pcm_number][subs->number]);
 
         if (stream->status != MIXART_STREAM_STATUS_FREE){
                 /* streams in use */
-                snd_printk(KERN_ERR "snd_mixart_playback_open C%d/P%d/Sub%d in use\n", chip->chip_idx, pcm_number, subs->number);
+                dev_err(chip->card->dev,
+                        "snd_mixart_playback_open C%d/P%d/Sub%d in use\n",
+                        chip->chip_idx, pcm_number, subs->number);
                 err = -EBUSY;
                 goto _exit_open;
         }
@@ -737,7 +766,7 @@ static int snd_mixart_playback_open(struct snd_pcm_substream *subs)
         /* start the pipe if necessary */
         err = mixart_set_pipe_state(chip->mgr, pipe, 1);
         if( err < 0 ) {
-                snd_printk(KERN_ERR "error starting pipe!\n");
+                dev_err(chip->card->dev, "error starting pipe!\n");
                 snd_mixart_kill_ref_pipe(chip->mgr, pipe, 0);
                 err = -EINVAL;
                 goto _exit_open;
@@ -792,14 +821,17 @@ static int snd_mixart_capture_open(struct snd_pcm_substream *subs)
 
         runtime->hw.channels_min = 2; /* for instance, no mono */
 
-        snd_printdd("snd_mixart_capture_open C%d/P%d/Sub%d\n", chip->chip_idx, pcm_number, subs->number);
+        dev_dbg(chip->card->dev, "snd_mixart_capture_open C%d/P%d/Sub%d\n",
+                chip->chip_idx, pcm_number, subs->number);
 
         /* get stream info */
         stream = &(chip->capture_stream[pcm_number]);
 
         if (stream->status != MIXART_STREAM_STATUS_FREE){
                 /* streams in use */
-                snd_printk(KERN_ERR "snd_mixart_capture_open C%d/P%d/Sub%d in use\n", chip->chip_idx, pcm_number, subs->number);
+                dev_err(chip->card->dev,
+                        "snd_mixart_capture_open C%d/P%d/Sub%d in use\n",
+                        chip->chip_idx, pcm_number, subs->number);
                 err = -EBUSY;
                 goto _exit_open;
         }
@@ -815,7 +847,7 @@ static int snd_mixart_capture_open(struct snd_pcm_substream *subs)
         /* start the pipe if necessary */
         err = mixart_set_pipe_state(chip->mgr, pipe, 1);
         if( err < 0 ) {
-                snd_printk(KERN_ERR "error starting pipe!\n");
+                dev_err(chip->card->dev, "error starting pipe!\n");
                 snd_mixart_kill_ref_pipe(chip->mgr, pipe, 0);
                 err = -EINVAL;
                 goto _exit_open;
@@ -855,7 +887,8 @@ static int snd_mixart_close(struct snd_pcm_substream *subs)
 
         mutex_lock(&mgr->setup_mutex);
 
-        snd_printdd("snd_mixart_close C%d/P%d/Sub%d\n", chip->chip_idx, stream->pcm_number, subs->number);
+        dev_dbg(chip->card->dev, "snd_mixart_close C%d/P%d/Sub%d\n",
+                chip->chip_idx, stream->pcm_number, subs->number);
 
         /* sample rate released */
         if(--mgr->ref_count_rate == 0) {
@@ -865,7 +898,9 @@ static int snd_mixart_close(struct snd_pcm_substream *subs)
         /* delete pipe */
         if (snd_mixart_kill_ref_pipe(mgr, stream->pipe, 0 ) < 0) {
 
-                snd_printk(KERN_ERR "error snd_mixart_kill_ref_pipe C%dP%d\n", chip->chip_idx, stream->pcm_number);
+                dev_err(chip->card->dev,
+                        "error snd_mixart_kill_ref_pipe C%dP%d\n",
+                        chip->chip_idx, stream->pcm_number);
         }
 
         stream->pipe      = NULL;
@@ -940,7 +975,8 @@ static int snd_mixart_pcm_analog(struct snd_mixart *chip)
         if ((err = snd_pcm_new(chip->card, name, MIXART_PCM_ANALOG,
                                MIXART_PLAYBACK_STREAMS,
                                MIXART_CAPTURE_STREAMS, &pcm)) < 0) {
-                snd_printk(KERN_ERR "cannot create the analog pcm %d\n", chip->chip_idx);
+                dev_err(chip->card->dev,
+                        "cannot create the analog pcm %d\n", chip->chip_idx);
                 return err;
         }
 
@@ -971,7 +1007,8 @@ static int snd_mixart_pcm_digital(struct snd_mixart *chip)
         if ((err = snd_pcm_new(chip->card, name, MIXART_PCM_DIGITAL,
                                MIXART_PLAYBACK_STREAMS,
                                MIXART_CAPTURE_STREAMS, &pcm)) < 0) {
-                snd_printk(KERN_ERR "cannot create the digital pcm %d\n", chip->chip_idx);
+                dev_err(chip->card->dev,
+                        "cannot create the digital pcm %d\n", chip->chip_idx);
                 return err;
         }
 
@@ -1014,7 +1051,7 @@ static int snd_mixart_create(struct mixart_mgr *mgr, struct snd_card *card, int
 
         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (! chip) {
-                snd_printk(KERN_ERR "cannot allocate chip\n");
+                dev_err(card->dev, "cannot allocate chip\n");
                 return -ENOMEM;
         }
 
@@ -1071,7 +1108,7 @@ static int snd_mixart_free(struct mixart_mgr *mgr)
         /* reset board if some firmware was loaded */
         if(mgr->dsp_loaded) {
                 snd_mixart_reset_board(mgr);
-                snd_printdd("reset miXart !\n");
+                dev_dbg(&mgr->pci->dev, "reset miXart !\n");
         }
 
         /* release the i/o ports */
@@ -1232,7 +1269,8 @@ static int snd_mixart_probe(struct pci_dev *pci,
 
         /* check if we can restrict PCI DMA transfers to 32 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 32bit PCI busmaster DMA\n");
+                dev_err(&pci->dev,
+                        "architecture does not support 32bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -1258,7 +1296,7 @@ static int snd_mixart_probe(struct pci_dev *pci,
                 mgr->mem[i].phys = pci_resource_start(pci, i);
                 mgr->mem[i].virt = pci_ioremap_bar(pci, i);
                 if (!mgr->mem[i].virt) {
-                        printk(KERN_ERR "unable to remap resource 0x%lx\n",
+                        dev_err(&pci->dev, "unable to remap resource 0x%lx\n",
                                mgr->mem[i].phys);
                         snd_mixart_free(mgr);
                         return -EBUSY;
@@ -1267,7 +1305,7 @@ static int snd_mixart_probe(struct pci_dev *pci,
 
         if (request_irq(pci->irq, snd_mixart_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, mgr)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(&pci->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_mixart_free(mgr);
                 return -EBUSY;
         }
@@ -1310,7 +1348,7 @@ static int snd_mixart_probe(struct pci_dev *pci,
                                    0, &card);
 
                 if (err < 0) {
-                        snd_printk(KERN_ERR "cannot allocate the card %d\n", i);
+                        dev_err(&pci->dev, "cannot allocate the card %d\n", i);
                         snd_mixart_free(mgr);
                         return err;
                 }
diff --git a/sound/pci/mixart/mixart_core.c b/sound/pci/mixart/mixart_core.c
index 3df0f530f67c..71f4bdcc4055 100644
--- a/sound/pci/mixart/mixart_core.c
+++ b/sound/pci/mixart/mixart_core.c
@@ -22,6 +22,7 @@
 
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
+#include <linux/pci.h>
 
 #include <asm/io.h>
 #include <sound/core.h>
@@ -94,7 +95,8 @@ static int get_msg(struct mixart_mgr *mgr, struct mixart_msg *resp,
 
         if( (size < MSG_DESCRIPTOR_SIZE) || (resp->size < (size - MSG_DESCRIPTOR_SIZE))) {
                 err = -EINVAL;
-                snd_printk(KERN_ERR "problem with response size = %d\n", size);
+                dev_err(&mgr->pci->dev,
+                        "problem with response size = %d\n", size);
                 goto _clean_exit;
         }
         size -= MSG_DESCRIPTOR_SIZE;
@@ -161,7 +163,7 @@ static int send_msg( struct mixart_mgr *mgr,
         headptr = readl_be(MIXART_MEM(mgr, MSG_INBOUND_FREE_HEAD));
 
         if (tailptr == headptr) {
-                snd_printk(KERN_ERR "error: no message frame available\n");
+                dev_err(&mgr->pci->dev, "error: no message frame available\n");
                 return -EBUSY;
         }
 
@@ -265,7 +267,8 @@ int snd_mixart_send_msg(struct mixart_mgr *mgr, struct mixart_msg *request, int
         if (! timeout) {
                 /* error - no ack */
                 mutex_unlock(&mgr->msg_mutex);
-                snd_printk(KERN_ERR "error: no response on msg %x\n", msg_frame);
+                dev_err(&mgr->pci->dev,
+                        "error: no response on msg %x\n", msg_frame);
                 return -EIO;
         }
 
@@ -278,7 +281,7 @@ int snd_mixart_send_msg(struct mixart_mgr *mgr, struct mixart_msg *request, int
         err = get_msg(mgr, &resp, msg_frame);
 
         if( request->message_id != resp.message_id )
-                snd_printk(KERN_ERR "RESPONSE ERROR!\n");
+                dev_err(&mgr->pci->dev, "RESPONSE ERROR!\n");
 
         mutex_unlock(&mgr->msg_mutex);
         return err;
@@ -321,7 +324,8 @@ int snd_mixart_send_msg_wait_notif(struct mixart_mgr *mgr,
         if (! timeout) {
                 /* error - no ack */
                 mutex_unlock(&mgr->msg_mutex);
-                snd_printk(KERN_ERR "error: notification %x not received\n", notif_event);
+                dev_err(&mgr->pci->dev,
+                        "error: notification %x not received\n", notif_event);
                 return -EIO;
         }
 
@@ -378,7 +382,9 @@ void snd_mixart_msg_tasklet(unsigned long arg)
                         resp.size = sizeof(mixart_msg_data);
                         err = get_msg(mgr, &resp, addr);
                         if( err < 0 ) {
-                                snd_printk(KERN_ERR "tasklet: error(%d) reading mf %x\n", err, msg);
+                                dev_err(&mgr->pci->dev,
+                                        "tasklet: error(%d) reading mf %x\n",
+                                        err, msg);
                                 break;
                         }
 
@@ -388,10 +394,13 @@ void snd_mixart_msg_tasklet(unsigned long arg)
                         case MSG_STREAM_STOP_INPUT_STAGE_PACKET:
                         case MSG_STREAM_STOP_OUTPUT_STAGE_PACKET:
                                 if(mixart_msg_data[0])
-                                        snd_printk(KERN_ERR "tasklet : error MSG_STREAM_ST***_***PUT_STAGE_PACKET status=%x\n", mixart_msg_data[0]);
+                                        dev_err(&mgr->pci->dev,
+                                                "tasklet : error MSG_STREAM_ST***_***PUT_STAGE_PACKET status=%x\n",
+                                                mixart_msg_data[0]);
                                 break;
                         default:
-                                snd_printdd("tasklet received mf(%x) : msg_id(%x) uid(%x, %x) size(%zd)\n",
+                                dev_dbg(&mgr->pci->dev,
+                                        "tasklet received mf(%x) : msg_id(%x) uid(%x, %x) size(%zd)\n",
                                            msg, resp.message_id, resp.uid.object_id, resp.uid.desc, resp.size);
                                 break;
                         }
@@ -401,7 +410,9 @@ void snd_mixart_msg_tasklet(unsigned long arg)
                 case MSG_TYPE_COMMAND:
                         /* get_msg() necessary */
                 default:
-                        snd_printk(KERN_ERR "tasklet doesn't know what to do with message %x\n", msg);
+                        dev_err(&mgr->pci->dev,
+                                "tasklet doesn't know what to do with message %x\n",
+                                msg);
                 } /* switch type */
 
                 /* decrement counter */
@@ -451,7 +462,9 @@ irqreturn_t snd_mixart_interrupt(int irq, void *dev_id)
                         resp.size = sizeof(mixart_msg_data);
                         err = get_msg(mgr, &resp, msg & ~MSG_TYPE_MASK);
                         if( err < 0 ) {
-                                snd_printk(KERN_ERR "interrupt: error(%d) reading mf %x\n", err, msg);
+                                dev_err(&mgr->pci->dev,
+                                        "interrupt: error(%d) reading mf %x\n",
+                                        err, msg);
                                 break;
                         }
 
@@ -472,7 +485,8 @@ irqreturn_t snd_mixart_interrupt(int irq, void *dev_id)
                                         struct mixart_stream *stream;
 
                                         if ((chip_number >= mgr->num_cards) || (pcm_number >= MIXART_PCM_TOTAL) || (sub_number >= MIXART_PLAYBACK_STREAMS)) {
-                                                snd_printk(KERN_ERR "error MSG_SERVICES_TIMER_NOTIFY buffer_id (%x) pos(%d)\n",
+                                                dev_err(&mgr->pci->dev,
+                                                        "error MSG_SERVICES_TIMER_NOTIFY buffer_id (%x) pos(%d)\n",
                                                            buffer_id, notify->streams[i].sample_pos_low_part);
                                                 break;
                                         }
@@ -524,18 +538,22 @@ irqreturn_t snd_mixart_interrupt(int irq, void *dev_id)
                                         }
 #endif
                                         ((char*)mixart_msg_data)[resp.size - 1] = 0;
-                                        snd_printdd("MIXART TRACE : %s\n", (char*)mixart_msg_data);
+                                        dev_dbg(&mgr->pci->dev,
+                                                "MIXART TRACE : %s\n",
+                                                (char *)mixart_msg_data);
                                 }
                                 break;
                         }
 
-                        snd_printdd("command %x not handled\n", resp.message_id);
+                        dev_dbg(&mgr->pci->dev, "command %x not handled\n",
+                                resp.message_id);
                         break;
 
                 case MSG_TYPE_NOTIFY:
                         if(msg & MSG_CANCEL_NOTIFY_MASK) {
                                 msg &= ~MSG_CANCEL_NOTIFY_MASK;
-                                snd_printk(KERN_ERR "canceled notification %x !\n", msg);
+                                dev_err(&mgr->pci->dev,
+                                        "canceled notification %x !\n", msg);
                         }
                         /* no break, continue ! */
                 case MSG_TYPE_ANSWER:
@@ -556,7 +574,8 @@ irqreturn_t snd_mixart_interrupt(int irq, void *dev_id)
                         break;
                 case MSG_TYPE_REQUEST:
                 default:
-                        snd_printdd("interrupt received request %x\n", msg);
+                        dev_dbg(&mgr->pci->dev,
+                                "interrupt received request %x\n", msg);
                         /* TODO : are there things to do here ? */
                         break;
                 } /* switch on msg type */
diff --git a/sound/pci/mixart/mixart_hwdep.c b/sound/pci/mixart/mixart_hwdep.c
index ece1f831c16a..581e1e74863c 100644
--- a/sound/pci/mixart/mixart_hwdep.c
+++ b/sound/pci/mixart/mixart_hwdep.c
@@ -165,7 +165,8 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr)
 
         err = snd_mixart_send_msg(mgr, &request, sizeof(*connector), connector);
         if((err < 0) || (connector->error_code) || (connector->uid_count > MIXART_MAX_PHYS_CONNECTORS)) {
-                snd_printk(KERN_ERR "error MSG_SYSTEM_ENUM_PLAY_CONNECTOR\n");
+                dev_err(&mgr->pci->dev,
+                        "error MSG_SYSTEM_ENUM_PLAY_CONNECTOR\n");
                 err = -EINVAL;
                 goto __error;
         }
@@ -184,7 +185,7 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr)
                         pipe->uid_left_connector = connector->uid[k];    /* even */
                 }
 
-                /* snd_printk(KERN_DEBUG "playback connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
+                /* dev_dbg(&mgr->pci->dev, "playback connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
 
                 /* TODO: really need send_msg MSG_CONNECTOR_GET_AUDIO_INFO for each connector ? perhaps for analog level caps ? */
                 request.message_id = MSG_CONNECTOR_GET_AUDIO_INFO;
@@ -194,10 +195,11 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr)
 
                 err = snd_mixart_send_msg(mgr, &request, sizeof(*audio_info), audio_info);
                 if( err < 0 ) {
-                        snd_printk(KERN_ERR "error MSG_CONNECTOR_GET_AUDIO_INFO\n");
+                        dev_err(&mgr->pci->dev,
+                                "error MSG_CONNECTOR_GET_AUDIO_INFO\n");
                         goto __error;
                 }
-                /*snd_printk(KERN_DEBUG "play  analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
+                /*dev_dbg(&mgr->pci->dev, "play  analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
         }
 
         request.message_id = MSG_SYSTEM_ENUM_RECORD_CONNECTOR;
@@ -207,7 +209,8 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr)
 
         err = snd_mixart_send_msg(mgr, &request, sizeof(*connector), connector);
         if((err < 0) || (connector->error_code) || (connector->uid_count > MIXART_MAX_PHYS_CONNECTORS)) {
-                snd_printk(KERN_ERR "error MSG_SYSTEM_ENUM_RECORD_CONNECTOR\n");
+                dev_err(&mgr->pci->dev,
+                        "error MSG_SYSTEM_ENUM_RECORD_CONNECTOR\n");
                 err = -EINVAL;
                 goto __error;
         }
@@ -226,7 +229,7 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr)
                         pipe->uid_left_connector = connector->uid[k];    /* even */
                 }
 
-                /* snd_printk(KERN_DEBUG "capture connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
+                /* dev_dbg(&mgr->pci->dev, "capture connector[%d].object_id = %x\n", k, connector->uid[k].object_id); */
 
                 /* TODO: really need send_msg MSG_CONNECTOR_GET_AUDIO_INFO for each connector ? perhaps for analog level caps ? */
                 request.message_id = MSG_CONNECTOR_GET_AUDIO_INFO;
@@ -236,10 +239,11 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr)
 
                 err = snd_mixart_send_msg(mgr, &request, sizeof(*audio_info), audio_info);
                 if( err < 0 ) {
-                        snd_printk(KERN_ERR "error MSG_CONNECTOR_GET_AUDIO_INFO\n");
+                        dev_err(&mgr->pci->dev,
+                                "error MSG_CONNECTOR_GET_AUDIO_INFO\n");
                         goto __error;
                 }
-                /*snd_printk(KERN_DEBUG "rec  analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
+                /*dev_dbg(&mgr->pci->dev, "rec  analog_info.analog_level_present = %x\n", audio_info->info.analog_info.analog_level_present);*/
         }
         err = 0;
 
@@ -272,7 +276,9 @@ static int mixart_enum_physio(struct mixart_mgr *mgr)
         err = snd_mixart_send_msg(mgr, &request, sizeof(console_mgr), &console_mgr);
 
         if( (err < 0) || (console_mgr.error_code != 0) ) {
-                snd_printk(KERN_DEBUG "error MSG_CONSOLE_GET_CLOCK_UID : err=%x\n", console_mgr.error_code);
+                dev_dbg(&mgr->pci->dev,
+                        "error MSG_CONSOLE_GET_CLOCK_UID : err=%x\n",
+                        console_mgr.error_code);
                 return -EINVAL;
         }
 
@@ -286,7 +292,9 @@ static int mixart_enum_physio(struct mixart_mgr *mgr)
 
         err = snd_mixart_send_msg(mgr, &request, sizeof(phys_io), &phys_io);
         if( (err < 0) || ( phys_io.error_code != 0 ) ) {
-                snd_printk(KERN_ERR "error MSG_SYSTEM_ENUM_PHYSICAL_IO err(%x) error_code(%x)\n", err, phys_io.error_code );
+                dev_err(&mgr->pci->dev,
+                        "error MSG_SYSTEM_ENUM_PHYSICAL_IO err(%x) error_code(%x)\n",
+                        err, phys_io.error_code);
                 return -EINVAL;
         }
 
@@ -322,7 +330,7 @@ static int mixart_first_init(struct mixart_mgr *mgr)
         /* this command has no data. response is a 32 bit status */
         err = snd_mixart_send_msg(mgr, &request, sizeof(k), &k);
         if( (err < 0) || (k != 0) ) {
-                snd_printk(KERN_ERR "error MSG_SYSTEM_SEND_SYNCHRO_CMD\n");
+                dev_err(&mgr->pci->dev, "error MSG_SYSTEM_SEND_SYNCHRO_CMD\n");
                 return err == 0 ? -EINVAL : err;
         }
 
@@ -348,7 +356,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
 
         /* motherboard xilinx status 5 will say that the board is performing a reset */
         if (status_xilinx == 5) {
-                snd_printk(KERN_ERR "miXart is resetting !\n");
+                dev_err(&mgr->pci->dev, "miXart is resetting !\n");
                 return -EAGAIN; /* try again later */
         }
 
@@ -357,12 +365,13 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
 
                 /* xilinx already loaded ? */ 
                 if (status_xilinx == 4) {
-                        snd_printk(KERN_DEBUG "xilinx is already loaded !\n");
+                        dev_dbg(&mgr->pci->dev, "xilinx is already loaded !\n");
                         return 0;
                 }
                 /* the status should be 0 == "idle" */
                 if (status_xilinx != 0) {
-                        snd_printk(KERN_ERR "xilinx load error ! status = %d\n",
+                        dev_err(&mgr->pci->dev,
+                                "xilinx load error ! status = %d\n",
                                    status_xilinx);
                         return -EIO; /* modprob -r may help ? */
                 }
@@ -393,13 +402,14 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
         case MIXART_MOTHERBOARD_ELF_INDEX:
 
                 if (status_elf == 4) {
-                        snd_printk(KERN_DEBUG "elf file already loaded !\n");
+                        dev_dbg(&mgr->pci->dev, "elf file already loaded !\n");
                         return 0;
                 }
 
                 /* the status should be 0 == "idle" */
                 if (status_elf != 0) {
-                        snd_printk(KERN_ERR "elf load error ! status = %d\n",
+                        dev_err(&mgr->pci->dev,
+                                "elf load error ! status = %d\n",
                                    status_elf);
                         return -EIO; /* modprob -r may help ? */
                 }
@@ -407,7 +417,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
                 /* wait for xilinx status == 4 */
                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET, 1, 4, 500); /* 5sec */
                 if (err < 0) {
-                        snd_printk(KERN_ERR "xilinx was not loaded or "
+                        dev_err(&mgr->pci->dev, "xilinx was not loaded or "
                                    "could not be started\n");
                         return err;
                 }
@@ -429,7 +439,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
                 /* wait for elf status == 4 */
                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_ELF_STATUS_OFFSET, 1, 4, 300); /* 3sec */
                 if (err < 0) {
-                        snd_printk(KERN_ERR "elf could not be started\n");
+                        dev_err(&mgr->pci->dev, "elf could not be started\n");
                         return err;
                 }
 
@@ -443,7 +453,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
 
                 /* elf and xilinx should be loaded */
                 if (status_elf != 4 || status_xilinx != 4) {
-                        printk(KERN_ERR "xilinx or elf not "
+                        dev_err(&mgr->pci->dev, "xilinx or elf not "
                                "successfully loaded\n");
                         return -EIO; /* modprob -r may help ? */
                 }
@@ -451,7 +461,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
                 /* wait for daughter detection != 0 */
                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DBRD_PRESENCE_OFFSET, 0, 0, 30); /* 300msec */
                 if (err < 0) {
-                        snd_printk(KERN_ERR "error starting elf file\n");
+                        dev_err(&mgr->pci->dev, "error starting elf file\n");
                         return err;
                 }
 
@@ -467,7 +477,8 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
 
                 /* daughter should be idle */
                 if (status_daught != 0) {
-                        printk(KERN_ERR "daughter load error ! status = %d\n",
+                        dev_err(&mgr->pci->dev,
+                                "daughter load error ! status = %d\n",
                                status_daught);
                         return -EIO; /* modprob -r may help ? */
                 }
@@ -487,7 +498,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
                 /* wait for status == 2 */
                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET, 1, 2, 30); /* 300msec */
                 if (err < 0) {
-                        snd_printk(KERN_ERR "daughter board load error\n");
+                        dev_err(&mgr->pci->dev, "daughter board load error\n");
                         return err;
                 }
 
@@ -509,7 +520,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
         /* wait for daughter status == 3 */
         err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET, 1, 3, 300); /* 3sec */
         if (err < 0) {
-                snd_printk(KERN_ERR
+                dev_err(&mgr->pci->dev,
                            "daughter board could not be initialised\n");
                 return err;
         }
@@ -520,7 +531,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
         /* first communication with embedded */
         err = mixart_first_init(mgr);
         if (err < 0) {
-                snd_printk(KERN_ERR "miXart could not be set up\n");
+                dev_err(&mgr->pci->dev, "miXart could not be set up\n");
                 return err;
         }
 
@@ -540,7 +551,8 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
                         return err;
         }
 
-        snd_printdd("miXart firmware downloaded and successfully set up\n");
+        dev_dbg(&mgr->pci->dev,
+                "miXart firmware downloaded and successfully set up\n");
 
         return 0;
 }
@@ -559,7 +571,8 @@ int snd_mixart_setup_firmware(struct mixart_mgr *mgr)
         for (i = 0; i < 3; i++) {
                 sprintf(path, "mixart/%s", fw_files[i]);
                 if (request_firmware(&fw_entry, path, &mgr->pci->dev)) {
-                        snd_printk(KERN_ERR "miXart: can't load firmware %s\n", path);
+                        dev_err(&mgr->pci->dev,
+                                "miXart: can't load firmware %s\n", path);
                         return -ENOENT;
                 }
                 /* fake hwdep dsp record */
diff --git a/sound/pci/mixart/mixart_mixer.c b/sound/pci/mixart/mixart_mixer.c
index 3ba6174c3df1..24a1955b8c29 100644
--- a/sound/pci/mixart/mixart_mixer.c
+++ b/sound/pci/mixart/mixart_mixer.c
@@ -329,7 +329,9 @@ static int mixart_update_analog_audio_level(struct snd_mixart* chip, int is_capt
 
         err = snd_mixart_send_msg(chip->mgr, &request, sizeof(resp), &resp);
         if((err<0) || (resp.error_code)) {
-                snd_printk(KERN_DEBUG "error MSG_PHYSICALIO_SET_LEVEL card(%d) is_capture(%d) error_code(%x)\n", chip->chip_idx, is_capture, resp.error_code);
+                dev_dbg(chip->card->dev,
+                        "error MSG_PHYSICALIO_SET_LEVEL card(%d) is_capture(%d) error_code(%x)\n",
+                        chip->chip_idx, is_capture, resp.error_code);
                 return -EINVAL;
         }
         return 0;
@@ -762,7 +764,9 @@ int mixart_update_playback_stream_level(struct snd_mixart* chip, int is_aes, int
 
         err = snd_mixart_send_msg(chip->mgr, &request, sizeof(status), &status);
         if((err<0) || status) {
-                snd_printk(KERN_DEBUG "error MSG_STREAM_SET_OUT_STREAM_LEVEL card(%d) status(%x)\n", chip->chip_idx, status);
+                dev_dbg(chip->card->dev,
+                        "error MSG_STREAM_SET_OUT_STREAM_LEVEL card(%d) status(%x)\n",
+                        chip->chip_idx, status);
                 return -EINVAL;
         }
         return 0;
@@ -805,7 +809,9 @@ int mixart_update_capture_stream_level(struct snd_mixart* chip, int is_aes)
 
         err = snd_mixart_send_msg(chip->mgr, &request, sizeof(status), &status);
         if((err<0) || status) {
-                snd_printk(KERN_DEBUG "error MSG_STREAM_SET_IN_AUDIO_LEVEL card(%d) status(%x)\n", chip->chip_idx, status);
+                dev_dbg(chip->card->dev,
+                        "error MSG_STREAM_SET_IN_AUDIO_LEVEL card(%d) status(%x)\n",
+                        chip->chip_idx, status);
                 return -EINVAL;
         }
         return 0;
@@ -977,7 +983,9 @@ static int mixart_update_monitoring(struct snd_mixart* chip, int channel)
 
         err = snd_mixart_send_msg(chip->mgr, &request, sizeof(resp), &resp);
         if((err<0) || resp) {
-                snd_printk(KERN_DEBUG "error MSG_CONNECTOR_SET_OUT_AUDIO_LEVEL card(%d) resp(%x)\n", chip->chip_idx, resp);
+                dev_dbg(chip->card->dev,
+                        "error MSG_CONNECTOR_SET_OUT_AUDIO_LEVEL card(%d) resp(%x)\n",
+                        chip->chip_idx, resp);
                 return -EINVAL;
         }
         return 0;
diff --git a/sound/pci/nm256/nm256.c b/sound/pci/nm256/nm256.c
index b7afd9c8dcd7..ddc60215cc10 100644
--- a/sound/pci/nm256/nm256.c
+++ b/sound/pci/nm256/nm256.c
@@ -318,7 +318,8 @@ snd_nm256_write_buffer(struct nm256 *chip, void *src, int offset, int size)
         offset -= chip->buffer_start;
 #ifdef CONFIG_SND_DEBUG
         if (offset < 0 || offset >= chip->buffer_size) {
-                snd_printk(KERN_ERR "write_buffer invalid offset = %d size = %d\n",
+                dev_err(chip->card->dev,
+                        "write_buffer invalid offset = %d size = %d\n",
                            offset, size);
                 return;
         }
@@ -366,7 +367,8 @@ snd_nm256_load_coefficient(struct nm256 *chip, int stream, int number)
                  NM_RECORD_REG_OFFSET : NM_PLAYBACK_REG_OFFSET);
 
         if (snd_nm256_readb(chip, poffset) & 1) {
-                snd_printd("NM256: Engine was enabled while loading coefficients!\n");
+                dev_dbg(chip->card->dev,
+                        "NM256: Engine was enabled while loading coefficients!\n");
                 return;
         }
 
@@ -466,7 +468,8 @@ static int snd_nm256_acquire_irq(struct nm256 *chip)
         if (chip->irq < 0) {
                 if (request_irq(chip->pci->irq, chip->interrupt, IRQF_SHARED,
                                 KBUILD_MODNAME, chip)) {
-                        snd_printk(KERN_ERR "unable to grab IRQ %d\n", chip->pci->irq);
+                        dev_err(chip->card->dev,
+                                "unable to grab IRQ %d\n", chip->pci->irq);
                         mutex_unlock(&chip->irq_mutex);
                         return -EBUSY;
                 }
@@ -1039,7 +1042,7 @@ snd_nm256_interrupt(int irq, void *dev_id)
         if (status & NM_MISC_INT_1) {
                 status &= ~NM_MISC_INT_1;
                 NM_ACK_INT(chip, NM_MISC_INT_1);
-                snd_printd("NM256: Got misc interrupt #1\n");
+                dev_dbg(chip->card->dev, "NM256: Got misc interrupt #1\n");
                 snd_nm256_writew(chip, NM_INT_REG, 0x8000);
                 cbyte = snd_nm256_readb(chip, 0x400);
                 snd_nm256_writeb(chip, 0x400, cbyte | 2);
@@ -1048,14 +1051,15 @@ snd_nm256_interrupt(int irq, void *dev_id)
         if (status & NM_MISC_INT_2) {
                 status &= ~NM_MISC_INT_2;
                 NM_ACK_INT(chip, NM_MISC_INT_2);
-                snd_printd("NM256: Got misc interrupt #2\n");
+                dev_dbg(chip->card->dev, "NM256: Got misc interrupt #2\n");
                 cbyte = snd_nm256_readb(chip, 0x400);
                 snd_nm256_writeb(chip, 0x400, cbyte & ~2);
         }
 
         /* Unknown interrupt. */
         if (status) {
-                snd_printd("NM256: Fire in the hole! Unknown status 0x%x\n",
+                dev_dbg(chip->card->dev,
+                        "NM256: Fire in the hole! Unknown status 0x%x\n",
                            status);
                 /* Pray. */
                 NM_ACK_INT(chip, status);
@@ -1104,7 +1108,7 @@ snd_nm256_interrupt_zx(int irq, void *dev_id)
         if (status & NM2_MISC_INT_1) {
                 status &= ~NM2_MISC_INT_1;
                 NM2_ACK_INT(chip, NM2_MISC_INT_1);
-                snd_printd("NM256: Got misc interrupt #1\n");
+                dev_dbg(chip->card->dev, "NM256: Got misc interrupt #1\n");
                 cbyte = snd_nm256_readb(chip, 0x400);
                 snd_nm256_writeb(chip, 0x400, cbyte | 2);
         }
@@ -1112,14 +1116,15 @@ snd_nm256_interrupt_zx(int irq, void *dev_id)
         if (status & NM2_MISC_INT_2) {
                 status &= ~NM2_MISC_INT_2;
                 NM2_ACK_INT(chip, NM2_MISC_INT_2);
-                snd_printd("NM256: Got misc interrupt #2\n");
+                dev_dbg(chip->card->dev, "NM256: Got misc interrupt #2\n");
                 cbyte = snd_nm256_readb(chip, 0x400);
                 snd_nm256_writeb(chip, 0x400, cbyte & ~2);
         }
 
         /* Unknown interrupt. */
         if (status) {
-                snd_printd("NM256: Fire in the hole! Unknown status 0x%x\n",
+                dev_dbg(chip->card->dev,
+                        "NM256: Fire in the hole! Unknown status 0x%x\n",
                            status);
                 /* Pray. */
                 NM2_ACK_INT(chip, status);
@@ -1245,7 +1250,7 @@ snd_nm256_ac97_write(struct snd_ac97 *ac97,
                         return;
                 }
         }
-        snd_printd("nm256: ac97 codec not ready..\n");
+        dev_dbg(chip->card->dev, "nm256: ac97 codec not ready..\n");
 }
 
 /* static resolution table */
@@ -1347,7 +1352,8 @@ snd_nm256_peek_for_sig(struct nm256 *chip)
 
         temp = ioremap_nocache(chip->buffer_addr + chip->buffer_end - 0x400, 16);
         if (temp == NULL) {
-                snd_printk(KERN_ERR "Unable to scan for card signature in video RAM\n");
+                dev_err(chip->card->dev,
+                        "Unable to scan for card signature in video RAM\n");
                 return -EBUSY;
         }
 
@@ -1361,12 +1367,14 @@ snd_nm256_peek_for_sig(struct nm256 *chip)
                 if (pointer == 0xffffffff ||
                     pointer < chip->buffer_size ||
                     pointer > chip->buffer_end) {
-                        snd_printk(KERN_ERR "invalid signature found: 0x%x\n", pointer);
+                        dev_err(chip->card->dev,
+                                "invalid signature found: 0x%x\n", pointer);
                         iounmap(temp);
                         return -ENODEV;
                 } else {
                         pointer_found = pointer;
-                        printk(KERN_INFO "nm256: found card signature in video RAM: 0x%x\n",
+                        dev_info(chip->card->dev,
+                                 "found card signature in video RAM: 0x%x\n",
                                pointer);
                 }
         }
@@ -1411,8 +1419,7 @@ static int nm256_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "nm256: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -1520,14 +1527,15 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
         chip->res_cport = request_mem_region(chip->cport_addr, NM_PORT2_SIZE,
                                              card->driver);
         if (chip->res_cport == NULL) {
-                snd_printk(KERN_ERR "memory region 0x%lx (size 0x%x) busy\n",
+                dev_err(card->dev, "memory region 0x%lx (size 0x%x) busy\n",
                            chip->cport_addr, NM_PORT2_SIZE);
                 err = -EBUSY;
                 goto __error;
         }
         chip->cport = ioremap_nocache(chip->cport_addr, NM_PORT2_SIZE);
         if (chip->cport == NULL) {
-                snd_printk(KERN_ERR "unable to map control port %lx\n", chip->cport_addr);
+                dev_err(card->dev, "unable to map control port %lx\n",
+                        chip->cport_addr);
                 err = -ENOMEM;
                 goto __error;
         }
@@ -1537,12 +1545,14 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
                 pval = snd_nm256_readw(chip, NM_MIXER_PRESENCE);
                 if ((pval & NM_PRESENCE_MASK) != NM_PRESENCE_VALUE) {
                         if (! force_ac97) {
-                                printk(KERN_ERR "nm256: no ac97 is found!\n");
-                                printk(KERN_ERR "  force the driver to load by "
-                                       "passing in the module parameter\n");
-                                printk(KERN_ERR "    force_ac97=1\n");
-                                printk(KERN_ERR "  or try sb16, opl3sa2, or "
-                                       "cs423x drivers instead.\n");
+                                dev_err(card->dev,
+                                        "no ac97 is found!\n");
+                                dev_err(card->dev,
+                                        "force the driver to load by passing in the module parameter\n");
+                                dev_err(card->dev,
+                                        " force_ac97=1\n");
+                                dev_err(card->dev,
+                                        "or try sb16, opl3sa2, or cs423x drivers instead.\n");
                                 err = -ENXIO;
                                 goto __error;
                         }
@@ -1581,14 +1591,14 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
         chip->buffer_start = chip->buffer_end - chip->buffer_size;
         chip->buffer_addr += chip->buffer_start;
 
-        printk(KERN_INFO "nm256: Mapping port 1 from 0x%x - 0x%x\n",
+        dev_info(card->dev, "Mapping port 1 from 0x%x - 0x%x\n",
                chip->buffer_start, chip->buffer_end);
 
         chip->res_buffer = request_mem_region(chip->buffer_addr,
                                               chip->buffer_size,
                                               card->driver);
         if (chip->res_buffer == NULL) {
-                snd_printk(KERN_ERR "nm256: buffer 0x%lx (size 0x%x) busy\n",
+                dev_err(card->dev, "buffer 0x%lx (size 0x%x) busy\n",
                            chip->buffer_addr, chip->buffer_size);
                 err = -EBUSY;
                 goto __error;
@@ -1596,7 +1606,8 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci,
         chip->buffer = ioremap_nocache(chip->buffer_addr, chip->buffer_size);
         if (chip->buffer == NULL) {
                 err = -ENOMEM;
-                snd_printk(KERN_ERR "unable to map ring buffer at %lx\n", chip->buffer_addr);
+                dev_err(card->dev, "unable to map ring buffer at %lx\n",
+                        chip->buffer_addr);
                 goto __error;
         }
 
@@ -1658,12 +1669,12 @@ static int snd_nm256_probe(struct pci_dev *pci,
 
         q = snd_pci_quirk_lookup(pci, nm256_quirks);
         if (q) {
-                snd_printdd(KERN_INFO "nm256: Enabled quirk for %s.\n",
+                dev_dbg(&pci->dev, "Enabled quirk for %s.\n",
                             snd_pci_quirk_name(q));
                 switch (q->value) {
                 case NM_BLACKLISTED:
-                        printk(KERN_INFO "nm256: The device is blacklisted. "
-                               "Loading stopped\n");
+                        dev_info(&pci->dev,
+                                 "The device is blacklisted. Loading stopped\n");
                         return -ENODEV;
                 case NM_RESET_WORKAROUND_2:
                         reset_workaround_2 = 1;
@@ -1689,7 +1700,7 @@ static int snd_nm256_probe(struct pci_dev *pci,
                 strcpy(card->driver, "NM256XL+");
                 break;
         default:
-                snd_printk(KERN_ERR "invalid device id 0x%x\n", pci->device);
+                dev_err(&pci->dev, "invalid device id 0x%x\n", pci->device);
                 snd_card_free(card);
                 return -EINVAL;
         }
@@ -1712,12 +1723,12 @@ static int snd_nm256_probe(struct pci_dev *pci,
         card->private_data = chip;
 
         if (reset_workaround) {
-                snd_printdd(KERN_INFO "nm256: reset_workaround activated\n");
+                dev_dbg(&pci->dev, "reset_workaround activated\n");
                 chip->reset_workaround = 1;
         }
 
         if (reset_workaround_2) {
-                snd_printdd(KERN_INFO "nm256: reset_workaround_2 activated\n");
+                dev_dbg(&pci->dev, "reset_workaround_2 activated\n");
                 chip->reset_workaround_2 = 1;
         }
 
diff --git a/sound/pci/oxygen/oxygen_io.c b/sound/pci/oxygen/oxygen_io.c
index 3274907189fe..4b8a32c37e31 100644
--- a/sound/pci/oxygen/oxygen_io.c
+++ b/sound/pci/oxygen/oxygen_io.c
@@ -147,7 +147,7 @@ void oxygen_write_ac97(struct oxygen *chip, unsigned int codec,
                         return;
                 }
         }
-        snd_printk(KERN_ERR "AC'97 write timeout\n");
+        dev_err(chip->card->dev, "AC'97 write timeout\n");
 }
 EXPORT_SYMBOL(oxygen_write_ac97);
 
@@ -179,7 +179,7 @@ u16 oxygen_read_ac97(struct oxygen *chip, unsigned int codec,
                         reg ^= 0xffff;
                 }
         }
-        snd_printk(KERN_ERR "AC'97 read timeout on codec %u\n", codec);
+        dev_err(chip->card->dev, "AC'97 read timeout on codec %u\n", codec);
         return 0;
 }
 EXPORT_SYMBOL(oxygen_read_ac97);
@@ -208,7 +208,7 @@ static int oxygen_wait_spi(struct oxygen *chip)
                                                 OXYGEN_SPI_BUSY) == 0)
                         return 0;
         }
-        snd_printk(KERN_ERR "oxygen: SPI wait timeout\n");
+        dev_err(chip->card->dev, "oxygen: SPI wait timeout\n");
         return -EIO;
 }
 
@@ -288,5 +288,5 @@ void oxygen_write_eeprom(struct oxygen *chip, unsigned int index, u16 value)
                       & OXYGEN_EEPROM_BUSY))
                         return;
         }
-        snd_printk(KERN_ERR "EEPROM write timeout\n");
+        dev_err(chip->card->dev, "EEPROM write timeout\n");
 }
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c
index efa610cd735c..b67e30602473 100644
--- a/sound/pci/oxygen/oxygen_lib.c
+++ b/sound/pci/oxygen/oxygen_lib.c
@@ -313,7 +313,7 @@ static void oxygen_restore_eeprom(struct oxygen *chip,
                 oxygen_clear_bits8(chip, OXYGEN_MISC,
                                    OXYGEN_MISC_WRITE_PCI_SUBID);
 
-                snd_printk(KERN_INFO "EEPROM ID restored\n");
+                dev_info(chip->card->dev, "EEPROM ID restored\n");
         }
 }
 
@@ -617,13 +617,13 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
 
         err = pci_request_regions(pci, DRIVER);
         if (err < 0) {
-                snd_printk(KERN_ERR "cannot reserve PCI resources\n");
+                dev_err(card->dev, "cannot reserve PCI resources\n");
                 goto err_pci_enable;
         }
 
         if (!(pci_resource_flags(pci, 0) & IORESOURCE_IO) ||
             pci_resource_len(pci, 0) < OXYGEN_IO_SIZE) {
-                snd_printk(KERN_ERR "invalid PCI I/O range\n");
+                dev_err(card->dev, "invalid PCI I/O range\n");
                 err = -ENXIO;
                 goto err_pci_regions;
         }
@@ -658,7 +658,7 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
         err = request_irq(pci->irq, oxygen_interrupt, IRQF_SHARED,
                           KBUILD_MODNAME, chip);
         if (err < 0) {
-                snd_printk(KERN_ERR "cannot grab interrupt %d\n", pci->irq);
+                dev_err(card->dev, "cannot grab interrupt %d\n", pci->irq);
                 goto err_card;
         }
         chip->irq = pci->irq;
@@ -796,7 +796,7 @@ static int oxygen_pci_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                snd_printk(KERN_ERR "cannot reenable device");
+                dev_err(dev, "cannot reenable device");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/oxygen/xonar_hdmi.c b/sound/pci/oxygen/xonar_hdmi.c
index 136dac6a3964..91d92bc32b75 100644
--- a/sound/pci/oxygen/xonar_hdmi.c
+++ b/sound/pci/oxygen/xonar_hdmi.c
@@ -120,7 +120,7 @@ void xonar_hdmi_uart_input(struct oxygen *chip)
         if (chip->uart_input_count >= 2 &&
             chip->uart_input[chip->uart_input_count - 2] == 'O' &&
             chip->uart_input[chip->uart_input_count - 1] == 'K') {
-                printk(KERN_DEBUG "message from HDMI chip received:\n");
+                dev_dbg(chip->card->dev, "message from HDMI chip received:\n");
                 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET,
                                      chip->uart_input, chip->uart_input_count);
                 chip->uart_input_count = 0;
diff --git a/sound/pci/oxygen/xonar_lib.c b/sound/pci/oxygen/xonar_lib.c
index 0ebe7f5916f9..706b1a42163f 100644
--- a/sound/pci/oxygen/xonar_lib.c
+++ b/sound/pci/oxygen/xonar_lib.c
@@ -56,9 +56,9 @@ static void xonar_ext_power_gpio_changed(struct oxygen *chip)
         if (has_power != data->has_power) {
                 data->has_power = has_power;
                 if (has_power) {
-                        snd_printk(KERN_NOTICE "power restored\n");
+                        dev_notice(chip->card->dev, "power restored\n");
                 } else {
-                        snd_printk(KERN_CRIT
+                        dev_crit(chip->card->dev,
                                    "Hey! Don't unplug the power cable!\n");
                         /* TODO: stop PCMs */
                 }
diff --git a/sound/pci/pcxhr/pcxhr.c b/sound/pci/pcxhr/pcxhr.c
index 3880f6da9a87..8d09444ff88b 100644
--- a/sound/pci/pcxhr/pcxhr.c
+++ b/sound/pci/pcxhr/pcxhr.c
@@ -284,7 +284,7 @@ static int pcxhr_get_clock_reg(struct pcxhr_mgr *mgr, unsigned int rate,
                         rmh.cmd_len = 3;
                         err = pcxhr_send_msg(mgr, &rmh);
                         if (err < 0) {
-                                snd_printk(KERN_ERR
+                                dev_err(&mgr->pci->dev,
                                            "error CMD_ACCESS_IO_WRITE "
                                            "for PLL register : %x!\n", err);
                                 return err;
@@ -357,7 +357,7 @@ static int pcxhr_sub_set_clock(struct pcxhr_mgr *mgr,
                         return err;
         }
         /* set the new frequency */
-        snd_printdd("clock register : set %x\n", val);
+        dev_dbg(&mgr->pci->dev, "clock register : set %x\n", val);
         err = pcxhr_write_io_num_reg_cont(mgr, PCXHR_FREQ_REG_MASK,
                                           val, changed);
         if (err)
@@ -380,7 +380,7 @@ static int pcxhr_sub_set_clock(struct pcxhr_mgr *mgr,
                 mgr->codec_speed = speed;       /* save new codec speed */
         }
 
-        snd_printdd("pcxhr_sub_set_clock to %dHz (realfreq=%d)\n",
+        dev_dbg(&mgr->pci->dev, "pcxhr_sub_set_clock to %dHz (realfreq=%d)\n",
                     rate, realfreq);
         return 0;
 }
@@ -480,7 +480,7 @@ static int pcxhr_sub_get_external_clock(struct pcxhr_mgr *mgr,
         case REG_STATUS_SYNC_192000 :   rate = 192000; break;
         default: rate = 0;
         }
-        snd_printdd("External clock is at %d Hz\n", rate);
+        dev_dbg(&mgr->pci->dev, "External clock is at %d Hz\n", rate);
         *sample_rate = rate;
         return 0;
 }
@@ -537,8 +537,8 @@ static int pcxhr_set_stream_state(struct pcxhr_stream *stream)
 
         err = pcxhr_send_msg(chip->mgr, &rmh);
         if (err)
-                snd_printk(KERN_ERR "ERROR pcxhr_set_stream_state err=%x;\n",
-                           err);
+                dev_err(chip->card->dev,
+                        "ERROR pcxhr_set_stream_state err=%x;\n", err);
         stream->status =
           start ? PCXHR_STREAM_STATUS_STARTED : PCXHR_STREAM_STATUS_STOPPED;
         return err;
@@ -628,7 +628,8 @@ static int pcxhr_set_format(struct pcxhr_stream *stream)
         rmh.cmd[rmh.cmd_len++] = (header & 0xff) << 16;
         err = pcxhr_send_msg(chip->mgr, &rmh);
         if (err)
-                snd_printk(KERN_ERR "ERROR pcxhr_set_format err=%x;\n", err);
+                dev_err(chip->card->dev,
+                        "ERROR pcxhr_set_format err=%x;\n", err);
         return err;
 }
 
@@ -665,7 +666,7 @@ static int pcxhr_update_r_buffer(struct pcxhr_stream *stream)
         rmh.cmd_len = 4;
         err = pcxhr_send_msg(chip->mgr, &rmh);
         if (err)
-                snd_printk(KERN_ERR
+                dev_err(chip->card->dev,
                            "ERROR CMD_UPDATE_R_BUFFERS err=%x;\n", err);
         return err;
 }
@@ -735,11 +736,11 @@ static void pcxhr_trigger_tasklet(unsigned long arg)
         }
         if (capture_mask == 0 && playback_mask == 0) {
                 mutex_unlock(&mgr->setup_mutex);
-                snd_printk(KERN_ERR "pcxhr_trigger_tasklet : no pipes\n");
+                dev_err(&mgr->pci->dev, "pcxhr_trigger_tasklet : no pipes\n");
                 return;
         }
 
-        snd_printdd("pcxhr_trigger_tasklet : "
+        dev_dbg(&mgr->pci->dev, "pcxhr_trigger_tasklet : "
                     "playback_mask=%x capture_mask=%x\n",
                     playback_mask, capture_mask);
 
@@ -747,7 +748,7 @@ static void pcxhr_trigger_tasklet(unsigned long arg)
         err = pcxhr_set_pipe_state(mgr,  playback_mask, capture_mask, 0);
         if (err) {
                 mutex_unlock(&mgr->setup_mutex);
-                snd_printk(KERN_ERR "pcxhr_trigger_tasklet : "
+                dev_err(&mgr->pci->dev, "pcxhr_trigger_tasklet : "
                            "error stop pipes (P%x C%x)\n",
                            playback_mask, capture_mask);
                 return;
@@ -792,7 +793,7 @@ static void pcxhr_trigger_tasklet(unsigned long arg)
         err = pcxhr_set_pipe_state(mgr, playback_mask, capture_mask, 1);
         if (err) {
                 mutex_unlock(&mgr->setup_mutex);
-                snd_printk(KERN_ERR "pcxhr_trigger_tasklet : "
+                dev_err(&mgr->pci->dev, "pcxhr_trigger_tasklet : "
                            "error start pipes (P%x C%x)\n",
                            playback_mask, capture_mask);
                 return;
@@ -825,7 +826,7 @@ static void pcxhr_trigger_tasklet(unsigned long arg)
 
 #ifdef CONFIG_SND_DEBUG_VERBOSE
         do_gettimeofday(&my_tv2);
-        snd_printdd("***TRIGGER TASKLET*** TIME = %ld (err = %x)\n",
+        dev_dbg(&mgr->pci->dev, "***TRIGGER TASKLET*** TIME = %ld (err = %x)\n",
                     (long)(my_tv2.tv_usec - my_tv1.tv_usec), err);
 #endif
 }
@@ -902,7 +903,7 @@ static int pcxhr_hardware_timer(struct pcxhr_mgr *mgr, int start)
         }
         err = pcxhr_send_msg(mgr, &rmh);
         if (err < 0)
-                snd_printk(KERN_ERR "error pcxhr_hardware_timer err(%x)\n",
+                dev_err(&mgr->pci->dev, "error pcxhr_hardware_timer err(%x)\n",
                            err);
         return err;
 }
@@ -916,7 +917,8 @@ static int pcxhr_prepare(struct snd_pcm_substream *subs)
         struct pcxhr_mgr *mgr = chip->mgr;
         int err = 0;
 
-        snd_printdd("pcxhr_prepare : period_size(%lx) periods(%x) buffer_size(%lx)\n",
+        dev_dbg(chip->card->dev,
+                "pcxhr_prepare : period_size(%lx) periods(%x) buffer_size(%lx)\n",
                     subs->runtime->period_size, subs->runtime->periods,
                     subs->runtime->buffer_size);
 
@@ -1025,11 +1027,11 @@ static int pcxhr_open(struct snd_pcm_substream *subs)
         runtime->hw = pcxhr_caps;
 
         if( subs->stream == SNDRV_PCM_STREAM_PLAYBACK ) {
-                snd_printdd("pcxhr_open playback chip%d subs%d\n",
+                dev_dbg(chip->card->dev, "pcxhr_open playback chip%d subs%d\n",
                             chip->chip_idx, subs->number);
                 stream = &chip->playback_stream[subs->number];
         } else {
-                snd_printdd("pcxhr_open capture chip%d subs%d\n",
+                dev_dbg(chip->card->dev, "pcxhr_open capture chip%d subs%d\n",
                             chip->chip_idx, subs->number);
                 if (mgr->mono_capture)
                         runtime->hw.channels_max = 1;
@@ -1039,7 +1041,7 @@ static int pcxhr_open(struct snd_pcm_substream *subs)
         }
         if (stream->status != PCXHR_STREAM_STATUS_FREE){
                 /* streams in use */
-                snd_printk(KERN_ERR "pcxhr_open chip%d subs%d in use\n",
+                dev_err(chip->card->dev, "pcxhr_open chip%d subs%d in use\n",
                            chip->chip_idx, subs->number);
                 mutex_unlock(&mgr->setup_mutex);
                 return -EBUSY;
@@ -1105,7 +1107,7 @@ static int pcxhr_close(struct snd_pcm_substream *subs)
 
         mutex_lock(&mgr->setup_mutex);
 
-        snd_printdd("pcxhr_close chip%d subs%d\n",
+        dev_dbg(chip->card->dev, "pcxhr_close chip%d subs%d\n",
                     chip->chip_idx, subs->number);
 
         /* sample rate released */
@@ -1168,7 +1170,7 @@ int pcxhr_create_pcm(struct snd_pcxhr *chip)
         if ((err = snd_pcm_new(chip->card, name, 0,
                                chip->nb_streams_play,
                                chip->nb_streams_capt, &pcm)) < 0) {
-                snd_printk(KERN_ERR "cannot create pcm %s\n", name);
+                dev_err(chip->card->dev, "cannot create pcm %s\n", name);
                 return err;
         }
         pcm->private_data = chip;
@@ -1214,7 +1216,7 @@ static int pcxhr_create(struct pcxhr_mgr *mgr,
 
         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (! chip) {
-                snd_printk(KERN_ERR "cannot allocate chip\n");
+                dev_err(card->dev, "cannot allocate chip\n");
                 return -ENOMEM;
         }
 
@@ -1487,7 +1489,7 @@ static int pcxhr_free(struct pcxhr_mgr *mgr)
         /* reset board if some firmware was loaded */
         if(mgr->dsp_loaded) {
                 pcxhr_reset_board(mgr);
-                snd_printdd("reset pcxhr !\n");
+                dev_dbg(&mgr->pci->dev, "reset pcxhr !\n");
         }
 
         /* release irq  */
@@ -1536,8 +1538,8 @@ static int pcxhr_probe(struct pci_dev *pci,
 
         /* check if we can restrict PCI DMA transfers to 32 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support "
-                           "32bit PCI busmaster DMA\n");
+                dev_err(&pci->dev,
+                        "architecture does not support 32bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -1588,7 +1590,7 @@ static int pcxhr_probe(struct pci_dev *pci,
 
         if (request_irq(pci->irq, pcxhr_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, mgr)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(&pci->dev, "unable to grab IRQ %d\n", pci->irq);
                 pcxhr_free(mgr);
                 return -EBUSY;
         }
@@ -1641,7 +1643,7 @@ static int pcxhr_probe(struct pci_dev *pci,
                                    0, &card);
 
                 if (err < 0) {
-                        snd_printk(KERN_ERR "cannot allocate the card %d\n", i);
+                        dev_err(card->dev, "cannot allocate the card %d\n", i);
                         pcxhr_free(mgr);
                         return err;
                 }
diff --git a/sound/pci/pcxhr/pcxhr_core.c b/sound/pci/pcxhr/pcxhr_core.c
index 37b431b9b69d..df9371918601 100644
--- a/sound/pci/pcxhr/pcxhr_core.c
+++ b/sound/pci/pcxhr/pcxhr_core.c
@@ -23,6 +23,7 @@
 #include <linux/delay.h>
 #include <linux/firmware.h>
 #include <linux/interrupt.h>
+#include <linux/pci.h>
 #include <asm/io.h>
 #include <sound/core.h>
 #include "pcxhr.h"
@@ -132,14 +133,14 @@ static int pcxhr_check_reg_bit(struct pcxhr_mgr *mgr, unsigned int reg,
                 *read = PCXHR_INPB(mgr, reg);
                 if ((*read & mask) == bit) {
                         if (i > 100)
-                                snd_printdd("ATTENTION! check_reg(%x) "
-                                            "loopcount=%d\n",
+                                dev_dbg(&mgr->pci->dev,
+                                        "ATTENTION! check_reg(%x) loopcount=%d\n",
                                             reg, i);
                         return 0;
                 }
                 i++;
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR
+        dev_err(&mgr->pci->dev,
                    "pcxhr_check_reg_bit: timeout, reg=%x, mask=0x%x, val=%x\n",
                    reg, mask, *read);
         return -EIO;
@@ -216,7 +217,7 @@ static int pcxhr_send_it_dsp(struct pcxhr_mgr *mgr,
         err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_CVR,  PCXHR_CVR_HI08_HC, 0,
                                   PCXHR_TIMEOUT_DSP, &reg);
         if (err) {
-                snd_printk(KERN_ERR "pcxhr_send_it_dsp : TIMEOUT CVR\n");
+                dev_err(&mgr->pci->dev, "pcxhr_send_it_dsp : TIMEOUT CVR\n");
                 return err;
         }
         if (itdsp & PCXHR_MASK_IT_MANAGE_HF5) {
@@ -227,7 +228,7 @@ static int pcxhr_send_it_dsp(struct pcxhr_mgr *mgr,
                                           PCXHR_TIMEOUT_DSP,
                                           &reg);
                 if (err) {
-                        snd_printk(KERN_ERR
+                        dev_err(&mgr->pci->dev,
                                    "pcxhr_send_it_dsp : TIMEOUT HF5\n");
                         return err;
                 }
@@ -294,7 +295,7 @@ int pcxhr_load_xilinx_binary(struct pcxhr_mgr *mgr,
          */
         if(second) {
                 if ((chipsc & PCXHR_CHIPSC_GPI_USERI) == 0) {
-                        snd_printk(KERN_ERR "error loading first xilinx\n");
+                        dev_err(&mgr->pci->dev, "error loading first xilinx\n");
                         return -EINVAL;
                 }
                 /* activate second xilinx */
@@ -360,7 +361,7 @@ static int pcxhr_download_dsp(struct pcxhr_mgr *mgr, const struct firmware *dsp)
                                           PCXHR_ISR_HI08_TRDY,
                                           PCXHR_TIMEOUT_DSP, &dummy);
                 if (err) {
-                        snd_printk(KERN_ERR
+                        dev_err(&mgr->pci->dev,
                                    "dsp loading error at position %d\n", i);
                         return err;
                 }
@@ -396,7 +397,7 @@ int pcxhr_load_eeprom_binary(struct pcxhr_mgr *mgr,
                 msleep(PCXHR_WAIT_DEFAULT);
                 PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg);
                 msleep(PCXHR_WAIT_DEFAULT);
-                snd_printdd("no need to load eeprom boot\n");
+                dev_dbg(&mgr->pci->dev, "no need to load eeprom boot\n");
                 return 0;
         }
         PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg);
@@ -561,9 +562,9 @@ static int pcxhr_read_rmh_status(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh)
                                           PCXHR_ISR_HI08_RXDF,
                                           PCXHR_TIMEOUT_DSP, &reg);
                 if (err) {
-                        snd_printk(KERN_ERR "ERROR RMH stat: "
-                                   "ISR:RXDF=1 (ISR = %x; i=%d )\n",
-                                   reg, i);
+                        dev_err(&mgr->pci->dev,
+                                "ERROR RMH stat: ISR:RXDF=1 (ISR = %x; i=%d )\n",
+                                reg, i);
                         return err;
                 }
                 /* read data */
@@ -591,13 +592,13 @@ static int pcxhr_read_rmh_status(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh)
                 }
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                 if (rmh->cmd_idx < CMD_LAST_INDEX)
-                        snd_printdd("    stat[%d]=%x\n", i, data);
+                        dev_dbg(&mgr->pci->dev, "    stat[%d]=%x\n", i, data);
 #endif
                 if (i < max_stat_len)
                         rmh->stat[i] = data;
         }
         if (rmh->stat_len > max_stat_len) {
-                snd_printdd("PCXHR : rmh->stat_len=%x too big\n",
+                dev_dbg(&mgr->pci->dev, "PCXHR : rmh->stat_len=%x too big\n",
                             rmh->stat_len);
                 rmh->stat_len = max_stat_len;
         }
@@ -615,7 +616,8 @@ static int pcxhr_send_msg_nolock(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh)
                 return -EINVAL;
         err = pcxhr_send_it_dsp(mgr, PCXHR_IT_MESSAGE, 1);
         if (err) {
-                snd_printk(KERN_ERR "pcxhr_send_message : ED_DSP_CRASHED\n");
+                dev_err(&mgr->pci->dev,
+                        "pcxhr_send_message : ED_DSP_CRASHED\n");
                 return err;
         }
         /* wait for chk bit */
@@ -641,7 +643,7 @@ static int pcxhr_send_msg_nolock(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh)
                 data &= 0xff7fff;       /* MASK_1_WORD_COMMAND */
 #ifdef CONFIG_SND_DEBUG_VERBOSE
         if (rmh->cmd_idx < CMD_LAST_INDEX)
-                snd_printdd("MSG cmd[0]=%x (%s)\n",
+                dev_dbg(&mgr->pci->dev, "MSG cmd[0]=%x (%s)\n",
                             data, cmd_names[rmh->cmd_idx]);
 #endif
 
@@ -671,7 +673,8 @@ static int pcxhr_send_msg_nolock(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh)
                         data = rmh->cmd[i];
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                         if (rmh->cmd_idx < CMD_LAST_INDEX)
-                                snd_printdd("    cmd[%d]=%x\n", i, data);
+                                dev_dbg(&mgr->pci->dev,
+                                        "    cmd[%d]=%x\n", i, data);
 #endif
                         err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR,
                                                   PCXHR_ISR_HI08_TRDY,
@@ -697,14 +700,15 @@ static int pcxhr_send_msg_nolock(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh)
                                           PCXHR_ISR_HI08_RXDF,
                                           PCXHR_TIMEOUT_DSP, &reg);
                 if (err) {
-                        snd_printk(KERN_ERR "ERROR RMH: ISR:RXDF=1 (ISR = %x)\n", reg);
+                        dev_err(&mgr->pci->dev,
+                                "ERROR RMH: ISR:RXDF=1 (ISR = %x)\n", reg);
                         return err;
                 }
                 /* read error code */
                 data  = PCXHR_INPB(mgr, PCXHR_DSP_TXH) << 16;
                 data |= PCXHR_INPB(mgr, PCXHR_DSP_TXM) << 8;
                 data |= PCXHR_INPB(mgr, PCXHR_DSP_TXL);
-                snd_printk(KERN_ERR "ERROR RMH(%d): 0x%x\n",
+                dev_err(&mgr->pci->dev, "ERROR RMH(%d): 0x%x\n",
                            rmh->cmd_idx, data);
                 err = -EINVAL;
         } else {
@@ -780,7 +784,7 @@ static inline int pcxhr_pipes_running(struct pcxhr_mgr *mgr)
          * (PCXHR_PIPE_STATE_CAPTURE_OFFSET)
          */
         start_mask &= 0xffffff;
-        snd_printdd("CMD_PIPE_STATE MBOX2=0x%06x\n", start_mask);
+        dev_dbg(&mgr->pci->dev, "CMD_PIPE_STATE MBOX2=0x%06x\n", start_mask);
         return start_mask;
 }
 
@@ -809,7 +813,7 @@ static int pcxhr_prepair_pipe_start(struct pcxhr_mgr *mgr,
                         }
                         err = pcxhr_send_msg(mgr, &rmh);
                         if (err) {
-                                snd_printk(KERN_ERR
+                                dev_err(&mgr->pci->dev,
                                            "error pipe start "
                                            "(CMD_CAN_START_PIPE) err=%x!\n",
                                            err);
@@ -847,7 +851,7 @@ static int pcxhr_stop_pipes(struct pcxhr_mgr *mgr, int audio_mask)
                         }
                         err = pcxhr_send_msg(mgr, &rmh);
                         if (err) {
-                                snd_printk(KERN_ERR
+                                dev_err(&mgr->pci->dev,
                                            "error pipe stop "
                                            "(CMD_STOP_PIPE) err=%x!\n", err);
                                 return err;
@@ -876,7 +880,7 @@ static int pcxhr_toggle_pipes(struct pcxhr_mgr *mgr, int audio_mask)
                                                           1 << (audio - PCXHR_PIPE_STATE_CAPTURE_OFFSET));
                         err = pcxhr_send_msg(mgr, &rmh);
                         if (err) {
-                                snd_printk(KERN_ERR
+                                dev_err(&mgr->pci->dev,
                                            "error pipe start "
                                            "(CMD_CONF_PIPE) err=%x!\n", err);
                                 return err;
@@ -889,7 +893,7 @@ static int pcxhr_toggle_pipes(struct pcxhr_mgr *mgr, int audio_mask)
         pcxhr_init_rmh(&rmh, CMD_SEND_IRQA);
         err = pcxhr_send_msg(mgr, &rmh);
         if (err) {
-                snd_printk(KERN_ERR
+                dev_err(&mgr->pci->dev,
                            "error pipe start (CMD_SEND_IRQA) err=%x!\n",
                            err);
                 return err;
@@ -913,7 +917,8 @@ int pcxhr_set_pipe_state(struct pcxhr_mgr *mgr, int playback_mask,
                       (capture_mask << PCXHR_PIPE_STATE_CAPTURE_OFFSET));
         /* current pipe state (playback + record) */
         state = pcxhr_pipes_running(mgr);
-        snd_printdd("pcxhr_set_pipe_state %s (mask %x current %x)\n",
+        dev_dbg(&mgr->pci->dev,
+                "pcxhr_set_pipe_state %s (mask %x current %x)\n",
                     start ? "START" : "STOP", audio_mask, state);
         if (start) {
                 /* start only pipes that are not yet started */
@@ -944,7 +949,7 @@ int pcxhr_set_pipe_state(struct pcxhr_mgr *mgr, int playback_mask,
                 if ((state & audio_mask) == (start ? audio_mask : 0))
                         break;
                 if (++i >= MAX_WAIT_FOR_DSP * 100) {
-                        snd_printk(KERN_ERR "error pipe start/stop\n");
+                        dev_err(&mgr->pci->dev, "error pipe start/stop\n");
                         return -EBUSY;
                 }
                 udelay(10);                     /* wait 10 microseconds */
@@ -956,7 +961,7 @@ int pcxhr_set_pipe_state(struct pcxhr_mgr *mgr, int playback_mask,
         }
 #ifdef CONFIG_SND_DEBUG_VERBOSE
         do_gettimeofday(&my_tv2);
-        snd_printdd("***SET PIPE STATE*** TIME = %ld (err = %x)\n",
+        dev_dbg(&mgr->pci->dev, "***SET PIPE STATE*** TIME = %ld (err = %x)\n",
                     (long)(my_tv2.tv_usec - my_tv1.tv_usec), err);
 #endif
         return 0;
@@ -971,7 +976,8 @@ int pcxhr_write_io_num_reg_cont(struct pcxhr_mgr *mgr, unsigned int mask,
 
         spin_lock_irqsave(&mgr->msg_lock, flags);
         if ((mgr->io_num_reg_cont & mask) == value) {
-                snd_printdd("IO_NUM_REG_CONT mask %x already is set to %x\n",
+                dev_dbg(&mgr->pci->dev,
+                        "IO_NUM_REG_CONT mask %x already is set to %x\n",
                             mask, value);
                 if (changed)
                         *changed = 0;
@@ -1024,7 +1030,7 @@ static int pcxhr_handle_async_err(struct pcxhr_mgr *mgr, u32 err,
                 err = ((err >> 12) & 0xfff);
         if (!err)
                 return 0;
-        snd_printdd("CMD_ASYNC : Error %s %s Pipe %d err=%x\n",
+        dev_dbg(&mgr->pci->dev, "CMD_ASYNC : Error %s %s Pipe %d err=%x\n",
                     err_src_name[err_src],
                     is_capture ? "Record" : "Play", pipe, err);
         if (err == 0xe01)
@@ -1045,20 +1051,24 @@ void pcxhr_msg_tasklet(unsigned long arg)
         int i, j;
 
         if (mgr->src_it_dsp & PCXHR_IRQ_FREQ_CHANGE)
-                snd_printdd("TASKLET : PCXHR_IRQ_FREQ_CHANGE event occurred\n");
+                dev_dbg(&mgr->pci->dev,
+                        "TASKLET : PCXHR_IRQ_FREQ_CHANGE event occurred\n");
         if (mgr->src_it_dsp & PCXHR_IRQ_TIME_CODE)
-                snd_printdd("TASKLET : PCXHR_IRQ_TIME_CODE event occurred\n");
+                dev_dbg(&mgr->pci->dev,
+                        "TASKLET : PCXHR_IRQ_TIME_CODE event occurred\n");
         if (mgr->src_it_dsp & PCXHR_IRQ_NOTIFY)
-                snd_printdd("TASKLET : PCXHR_IRQ_NOTIFY event occurred\n");
+                dev_dbg(&mgr->pci->dev,
+                        "TASKLET : PCXHR_IRQ_NOTIFY event occurred\n");
         if (mgr->src_it_dsp & (PCXHR_IRQ_FREQ_CHANGE | PCXHR_IRQ_TIME_CODE)) {
                 /* clear events FREQ_CHANGE and TIME_CODE */
                 pcxhr_init_rmh(prmh, CMD_TEST_IT);
                 err = pcxhr_send_msg(mgr, prmh);
-                snd_printdd("CMD_TEST_IT : err=%x, stat=%x\n",
+                dev_dbg(&mgr->pci->dev, "CMD_TEST_IT : err=%x, stat=%x\n",
                             err, prmh->stat[0]);
         }
         if (mgr->src_it_dsp & PCXHR_IRQ_ASYNC) {
-                snd_printdd("TASKLET : PCXHR_IRQ_ASYNC event occurred\n");
+                dev_dbg(&mgr->pci->dev,
+                        "TASKLET : PCXHR_IRQ_ASYNC event occurred\n");
 
                 pcxhr_init_rmh(prmh, CMD_ASYNC);
                 prmh->cmd[0] |= 1;      /* add SEL_ASYNC_EVENTS */
@@ -1066,7 +1076,7 @@ void pcxhr_msg_tasklet(unsigned long arg)
                 prmh->stat_len = PCXHR_SIZE_MAX_LONG_STATUS;
                 err = pcxhr_send_msg(mgr, prmh);
                 if (err)
-                        snd_printk(KERN_ERR "ERROR pcxhr_msg_tasklet=%x;\n",
+                        dev_err(&mgr->pci->dev, "ERROR pcxhr_msg_tasklet=%x;\n",
                                    err);
                 i = 1;
                 while (i < prmh->stat_len) {
@@ -1079,7 +1089,8 @@ void pcxhr_msg_tasklet(unsigned long arg)
                         u32 err2;
 
                         if (prmh->stat[i] & 0x800000) { /* if BIT_END */
-                                snd_printdd("TASKLET : End%sPipe %d\n",
+                                dev_dbg(&mgr->pci->dev,
+                                        "TASKLET : End%sPipe %d\n",
                                             is_capture ? "Record" : "Play",
                                             pipe);
                         }
@@ -1136,7 +1147,8 @@ static u_int64_t pcxhr_stream_read_position(struct pcxhr_mgr *mgr,
         hw_sample_count = ((u_int64_t)rmh.stat[0]) << 24;
         hw_sample_count += (u_int64_t)rmh.stat[1];
 
-        snd_printdd("stream %c%d : abs samples real(%llu) timer(%llu)\n",
+        dev_dbg(&mgr->pci->dev,
+                "stream %c%d : abs samples real(%llu) timer(%llu)\n",
                     stream->pipe->is_capture ? 'C' : 'P',
                     stream->substream->number,
                     hw_sample_count,
@@ -1202,7 +1214,7 @@ static void pcxhr_update_timer_pos(struct pcxhr_mgr *mgr,
                                 (u_int32_t)(new_sample_count -
                                             stream->timer_abs_periods);
                 } else {
-                        snd_printk(KERN_ERR
+                        dev_err(&mgr->pci->dev,
                                    "ERROR new_sample_count too small ??? %ld\n",
                                    (long unsigned int)new_sample_count);
                 }
@@ -1247,33 +1259,39 @@ irqreturn_t pcxhr_interrupt(int irq, void *dev_id)
                     (mgr->dsp_time_last != PCXHR_DSP_TIME_INVALID)) {
                         /* handle dsp counter wraparound without resync */
                         int tmp_diff = dsp_time_diff + PCXHR_DSP_TIME_MASK + 1;
-                        snd_printdd("WARNING DSP timestamp old(%d) new(%d)",
+                        dev_dbg(&mgr->pci->dev,
+                                "WARNING DSP timestamp old(%d) new(%d)",
                                     mgr->dsp_time_last, dsp_time_new);
                         if (tmp_diff > 0 && tmp_diff <= (2*mgr->granularity)) {
-                                snd_printdd("-> timestamp wraparound OK: "
+                                dev_dbg(&mgr->pci->dev,
+                                        "-> timestamp wraparound OK: "
                                             "diff=%d\n", tmp_diff);
                                 dsp_time_diff = tmp_diff;
                         } else {
-                                snd_printdd("-> resynchronize all streams\n");
+                                dev_dbg(&mgr->pci->dev,
+                                        "-> resynchronize all streams\n");
                                 mgr->dsp_time_err++;
                         }
                 }
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                 if (dsp_time_diff == 0)
-                        snd_printdd("ERROR DSP TIME NO DIFF time(%d)\n",
+                        dev_dbg(&mgr->pci->dev,
+                                "ERROR DSP TIME NO DIFF time(%d)\n",
                                     dsp_time_new);
                 else if (dsp_time_diff >= (2*mgr->granularity))
-                        snd_printdd("ERROR DSP TIME TOO BIG old(%d) add(%d)\n",
+                        dev_dbg(&mgr->pci->dev,
+                                "ERROR DSP TIME TOO BIG old(%d) add(%d)\n",
                                     mgr->dsp_time_last,
                                     dsp_time_new - mgr->dsp_time_last);
                 else if (dsp_time_diff % mgr->granularity)
-                        snd_printdd("ERROR DSP TIME increased by %d\n",
+                        dev_dbg(&mgr->pci->dev,
+                                "ERROR DSP TIME increased by %d\n",
                                     dsp_time_diff);
 #endif
                 mgr->dsp_time_last = dsp_time_new;
 
                 if (timer_toggle == mgr->timer_toggle) {
-                        snd_printdd("ERROR TIMER TOGGLE\n");
+                        dev_dbg(&mgr->pci->dev, "ERROR TIMER TOGGLE\n");
                         mgr->dsp_time_err++;
                 }
                 mgr->timer_toggle = timer_toggle;
@@ -1308,7 +1326,7 @@ irqreturn_t pcxhr_interrupt(int irq, void *dev_id)
         }
 #ifdef CONFIG_SND_DEBUG_VERBOSE
         if (reg & PCXHR_FATAL_DSP_ERR)
-                snd_printdd("FATAL DSP ERROR : %x\n", reg);
+                dev_dbg(&mgr->pci->dev, "FATAL DSP ERROR : %x\n", reg);
 #endif
         spin_unlock(&mgr->lock);
         return IRQ_HANDLED;     /* this device caused the interrupt */
diff --git a/sound/pci/pcxhr/pcxhr_hwdep.c b/sound/pci/pcxhr/pcxhr_hwdep.c
index d995175c1c48..15a8ce5f1f48 100644
--- a/sound/pci/pcxhr/pcxhr_hwdep.c
+++ b/sound/pci/pcxhr/pcxhr_hwdep.c
@@ -72,7 +72,8 @@ static int pcxhr_init_board(struct pcxhr_mgr *mgr)
         /* test max nb substream per pipe */
         if (((rmh.stat[1] >> 7) & 0x5F) < PCXHR_PLAYBACK_STREAMS)
                 return -EINVAL;
-        snd_printdd("supported formats : playback=%x capture=%x\n",
+        dev_dbg(&mgr->pci->dev,
+                "supported formats : playback=%x capture=%x\n",
                     rmh.stat[2], rmh.stat[3]);
 
         pcxhr_init_rmh(&rmh, CMD_VERSION);
@@ -84,7 +85,8 @@ static int pcxhr_init_board(struct pcxhr_mgr *mgr)
         err = pcxhr_send_msg(mgr, &rmh);
         if (err)
                 return err;
-        snd_printdd("PCXHR DSP version is %d.%d.%d\n", (rmh.stat[0]>>16)&0xff,
+        dev_dbg(&mgr->pci->dev,
+                "PCXHR DSP version is %d.%d.%d\n", (rmh.stat[0]>>16)&0xff,
                     (rmh.stat[0]>>8)&0xff, rmh.stat[0]&0xff);
         mgr->dsp_version = rmh.stat[0];
 
@@ -179,7 +181,7 @@ static int pcxhr_dsp_allocate_pipe(struct pcxhr_mgr *mgr,
                 stream_count = PCXHR_PLAYBACK_STREAMS;
                 audio_count = 2;        /* always stereo */
         }
-        snd_printdd("snd_add_ref_pipe pin(%d) pcm%c0\n",
+        dev_dbg(&mgr->pci->dev, "snd_add_ref_pipe pin(%d) pcm%c0\n",
                     pin, is_capture ? 'c' : 'p');
         pipe->is_capture = is_capture;
         pipe->first_audio = pin;
@@ -194,7 +196,7 @@ static int pcxhr_dsp_allocate_pipe(struct pcxhr_mgr *mgr,
         }
         err = pcxhr_send_msg(mgr, &rmh);
         if (err < 0) {
-                snd_printk(KERN_ERR "error pipe allocation "
+                dev_err(&mgr->pci->dev, "error pipe allocation "
                            "(CMD_RES_PIPE) err=%x!\n", err);
                 return err;
         }
@@ -222,14 +224,14 @@ static int pcxhr_dsp_free_pipe( struct pcxhr_mgr *mgr, struct pcxhr_pipe *pipe)
         /* stop one pipe */
         err = pcxhr_set_pipe_state(mgr, playback_mask, capture_mask, 0);
         if (err < 0)
-                snd_printk(KERN_ERR "error stopping pipe!\n");
+                dev_err(&mgr->pci->dev, "error stopping pipe!\n");
         /* release the pipe */
         pcxhr_init_rmh(&rmh, CMD_FREE_PIPE);
         pcxhr_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->first_audio,
                                   0, 0);
         err = pcxhr_send_msg(mgr, &rmh);
         if (err < 0)
-                snd_printk(KERN_ERR "error pipe release "
+                dev_err(&mgr->pci->dev, "error pipe release "
                            "(CMD_FREE_PIPE) err(%x)\n", err);
         pipe->status = PCXHR_PIPE_UNDEFINED;
         return err;
@@ -289,7 +291,8 @@ static int pcxhr_dsp_load(struct pcxhr_mgr *mgr, int index,
 {
         int err, card_index;
 
-        snd_printdd("loading dsp [%d] size = %Zd\n", index, dsp->size);
+        dev_dbg(&mgr->pci->dev,
+                "loading dsp [%d] size = %Zd\n", index, dsp->size);
 
         switch (index) {
         case PCXHR_FIRMWARE_XLX_INT_INDEX:
@@ -313,19 +316,19 @@ static int pcxhr_dsp_load(struct pcxhr_mgr *mgr, int index,
                         return err;
                 break;  /* continue with first init */
         default:
-                snd_printk(KERN_ERR "wrong file index\n");
+                dev_err(&mgr->pci->dev, "wrong file index\n");
                 return -EFAULT;
         } /* end of switch file index*/
 
         /* first communication with embedded */
         err = pcxhr_init_board(mgr);
         if (err < 0) {
-                snd_printk(KERN_ERR "pcxhr could not be set up\n");
+                dev_err(&mgr->pci->dev, "pcxhr could not be set up\n");
                 return err;
         }
         err = pcxhr_config_pipes(mgr);
         if (err < 0) {
-                snd_printk(KERN_ERR "pcxhr pipes could not be set up\n");
+                dev_err(&mgr->pci->dev, "pcxhr pipes could not be set up\n");
                 return err;
         }
         /* create devices and mixer in accordance with HW options*/
@@ -344,10 +347,11 @@ static int pcxhr_dsp_load(struct pcxhr_mgr *mgr, int index,
         }
         err = pcxhr_start_pipes(mgr);
         if (err < 0) {
-                snd_printk(KERN_ERR "pcxhr pipes could not be started\n");
+                dev_err(&mgr->pci->dev, "pcxhr pipes could not be started\n");
                 return err;
         }
-        snd_printdd("pcxhr firmware downloaded and successfully set up\n");
+        dev_dbg(&mgr->pci->dev,
+                "pcxhr firmware downloaded and successfully set up\n");
 
         return 0;
 }
@@ -382,7 +386,8 @@ int pcxhr_setup_firmware(struct pcxhr_mgr *mgr)
                         continue;
                 sprintf(path, "pcxhr/%s", fw_files[fw_set][i]);
                 if (request_firmware(&fw_entry, path, &mgr->pci->dev)) {
-                        snd_printk(KERN_ERR "pcxhr: can't load firmware %s\n",
+                        dev_err(&mgr->pci->dev,
+                                "pcxhr: can't load firmware %s\n",
                                    path);
                         return -ENOENT;
                 }
diff --git a/sound/pci/pcxhr/pcxhr_mix22.c b/sound/pci/pcxhr/pcxhr_mix22.c
index 84fe57626eba..6a56e5306a65 100644
--- a/sound/pci/pcxhr/pcxhr_mix22.c
+++ b/sound/pci/pcxhr/pcxhr_mix22.c
@@ -22,6 +22,7 @@
 
 #include <linux/delay.h>
 #include <linux/io.h>
+#include <linux/pci.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/tlv.h>
@@ -290,7 +291,8 @@ int hr222_sub_init(struct pcxhr_mgr *mgr)
         reg = PCXHR_INPB(mgr, PCXHR_XLX_STATUS);
         if (reg & PCXHR_STAT_MIC_CAPS)
                 mgr->board_has_mic = 1; /* microphone available */
-        snd_printdd("MIC input available = %d\n", mgr->board_has_mic);
+        dev_dbg(&mgr->pci->dev,
+                "MIC input available = %d\n", mgr->board_has_mic);
 
         /* reset codec */
         PCXHR_OUTPB(mgr, PCXHR_DSP_RESET,
@@ -405,7 +407,7 @@ int hr222_sub_set_clock(struct pcxhr_mgr *mgr,
 
         hr222_config_akm(mgr, AKM_UNMUTE_CMD);
 
-        snd_printdd("set_clock to %dHz (realfreq=%d pllreg=%x)\n",
+        dev_dbg(&mgr->pci->dev, "set_clock to %dHz (realfreq=%d pllreg=%x)\n",
                     rate, realfreq, pllreg);
         return 0;
 }
@@ -431,13 +433,15 @@ int hr222_get_external_clock(struct pcxhr_mgr *mgr,
                 reg = PCXHR_STAT_FREQ_UER1_MASK;
 
         } else {
-                snd_printdd("get_external_clock : type %d not supported\n",
+                dev_dbg(&mgr->pci->dev,
+                        "get_external_clock : type %d not supported\n",
                             clock_type);
                 return -EINVAL; /* other clocks not supported */
         }
 
         if ((PCXHR_INPB(mgr, PCXHR_XLX_CSUER) & mask) != mask) {
-                snd_printdd("get_external_clock(%d) = 0 Hz\n", clock_type);
+                dev_dbg(&mgr->pci->dev,
+                        "get_external_clock(%d) = 0 Hz\n", clock_type);
                 *sample_rate = 0;
                 return 0; /* no external clock locked */
         }
@@ -495,7 +499,7 @@ int hr222_get_external_clock(struct pcxhr_mgr *mgr,
         else
                 rate = 0;
 
-        snd_printdd("External clock is at %d Hz (measured %d Hz)\n",
+        dev_dbg(&mgr->pci->dev, "External clock is at %d Hz (measured %d Hz)\n",
                     rate, calc_rate);
         *sample_rate = rate;
         return 0;
@@ -542,7 +546,8 @@ int hr222_manage_timecode(struct pcxhr_mgr *mgr, int enable)
 int hr222_update_analog_audio_level(struct snd_pcxhr *chip,
                                     int is_capture, int channel)
 {
-        snd_printdd("hr222_update_analog_audio_level(%s chan=%d)\n",
+        dev_dbg(chip->card->dev,
+                "hr222_update_analog_audio_level(%s chan=%d)\n",
                     is_capture ? "capture" : "playback", channel);
         if (is_capture) {
                 int level_l, level_r, level_mic;
@@ -642,7 +647,7 @@ int hr222_iec958_capture_byte(struct snd_pcxhr *chip,
                 if (PCXHR_INPB(chip->mgr, PCXHR_XLX_CSUER) & mask)
                         temp |= 1;
         }
-        snd_printdd("read iec958 AES %d byte %d = 0x%x\n",
+        dev_dbg(chip->card->dev, "read iec958 AES %d byte %d = 0x%x\n",
                     chip->chip_idx, aes_idx, temp);
         *aes_bits = temp;
         return 0;
@@ -684,7 +689,7 @@ static void hr222_micro_boost(struct pcxhr_mgr *mgr, int level)
 
         PCXHR_OUTPB(mgr, PCXHR_XLX_SELMIC, mgr->xlx_selmic);
 
-        snd_printdd("hr222_micro_boost : set %x\n", boost_mask);
+        dev_dbg(&mgr->pci->dev, "hr222_micro_boost : set %x\n", boost_mask);
 }
 
 static void hr222_phantom_power(struct pcxhr_mgr *mgr, int power)
@@ -696,7 +701,7 @@ static void hr222_phantom_power(struct pcxhr_mgr *mgr, int power)
 
         PCXHR_OUTPB(mgr, PCXHR_XLX_SELMIC, mgr->xlx_selmic);
 
-        snd_printdd("hr222_phantom_power : set %d\n", power);
+        dev_dbg(&mgr->pci->dev, "hr222_phantom_power : set %d\n", power);
 }
 
 
diff --git a/sound/pci/pcxhr/pcxhr_mixer.c b/sound/pci/pcxhr/pcxhr_mixer.c
index fec049344621..95c9571780d8 100644
--- a/sound/pci/pcxhr/pcxhr_mixer.c
+++ b/sound/pci/pcxhr/pcxhr_mixer.c
@@ -72,7 +72,8 @@ static int pcxhr_update_analog_audio_level(struct snd_pcxhr *chip,
         rmh.cmd_len = 3;
         err = pcxhr_send_msg(chip->mgr, &rmh);
         if (err < 0) {
-                snd_printk(KERN_DEBUG "error update_analog_audio_level card(%d)"
+                dev_dbg(chip->card->dev,
+                        "error update_analog_audio_level card(%d)"
                            " is_capture(%d) err(%x)\n",
                            chip->chip_idx, is_capture, err);
                 return -EINVAL;
@@ -284,7 +285,7 @@ static int pcxhr_update_playback_stream_level(struct snd_pcxhr* chip, int idx)
 
         err = pcxhr_send_msg(chip->mgr, &rmh);
         if (err < 0) {
-                snd_printk(KERN_DEBUG "error update_playback_stream_level "
+                dev_dbg(chip->card->dev, "error update_playback_stream_level "
                            "card(%d) err(%x)\n", chip->chip_idx, err);
                 return -EINVAL;
         }
@@ -335,7 +336,8 @@ static int pcxhr_update_audio_pipe_level(struct snd_pcxhr *chip,
 
         err = pcxhr_send_msg(chip->mgr, &rmh);
         if (err < 0) {
-                snd_printk(KERN_DEBUG "error update_audio_level(%d) err=%x\n",
+                dev_dbg(chip->card->dev,
+                        "error update_audio_level(%d) err=%x\n",
                            chip->chip_idx, err);
                 return -EINVAL;
         }
@@ -930,7 +932,7 @@ static int pcxhr_iec958_capture_byte(struct snd_pcxhr *chip,
                                 temp |= 1;
                 }
         }
-        snd_printdd("read iec958 AES %d byte %d = 0x%x\n",
+        dev_dbg(chip->card->dev, "read iec958 AES %d byte %d = 0x%x\n",
                     chip->chip_idx, aes_idx, temp);
         *aes_bits = temp;
         return 0;
@@ -992,7 +994,8 @@ static int pcxhr_iec958_update_byte(struct snd_pcxhr *chip,
                         rmh.cmd[0] |= IO_NUM_REG_CUER;
                         rmh.cmd[1] = cmd;
                         rmh.cmd_len = 2;
-                        snd_printdd("write iec958 AES %d byte %d bit %d (cmd %x)\n",
+                        dev_dbg(chip->card->dev,
+                                "write iec958 AES %d byte %d bit %d (cmd %x)\n",
                                     chip->chip_idx, aes_idx, i, cmd);
                         err = pcxhr_send_msg(chip->mgr, &rmh);
                         if (err)
diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c
index 77465cc03e95..cc2f0c1b6484 100644
--- a/sound/pci/rme32.c
+++ b/sound/pci/rme32.c
@@ -1349,14 +1349,15 @@ static int snd_rme32_create(struct rme32 *rme32)
 
         rme32->iobase = ioremap_nocache(rme32->port, RME32_IO_SIZE);
         if (!rme32->iobase) {
-                snd_printk(KERN_ERR "unable to remap memory region 0x%lx-0x%lx\n",
+                dev_err(rme32->card->dev,
+                        "unable to remap memory region 0x%lx-0x%lx\n",
                            rme32->port, rme32->port + RME32_IO_SIZE - 1);
                 return -ENOMEM;
         }
 
         if (request_irq(pci->irq, snd_rme32_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, rme32)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(rme32->card->dev, "unable to grab IRQ %d\n", pci->irq);
                 return -EBUSY;
         }
         rme32->irq = pci->irq;
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index 00d46116e04a..76169929770d 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -240,7 +240,7 @@ struct rme96 {
 
         u8 rev; /* card revision number */
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         u32 playback_pointer;
         u32 capture_pointer;
         void *playback_suspend_buffer;
@@ -1570,7 +1570,7 @@ snd_rme96_free(void *private_data)
                 pci_release_regions(rme96->pci);
                 rme96->port = 0;
         }
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         vfree(rme96->playback_suspend_buffer);
         vfree(rme96->capture_suspend_buffer);
 #endif
@@ -1609,13 +1609,15 @@ snd_rme96_create(struct rme96 *rme96)
 
         rme96->iobase = ioremap_nocache(rme96->port, RME96_IO_SIZE);
         if (!rme96->iobase) {
-                snd_printk(KERN_ERR "unable to remap memory region 0x%lx-0x%lx\n", rme96->port, rme96->port + RME96_IO_SIZE - 1);
+                dev_err(rme96->card->dev,
+                        "unable to remap memory region 0x%lx-0x%lx\n",
+                        rme96->port, rme96->port + RME96_IO_SIZE - 1);
                 return -ENOMEM;
         }
 
         if (request_irq(pci->irq, snd_rme96_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, rme96)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(rme96->card->dev, "unable to grab IRQ %d\n", pci->irq);
                 return -EBUSY;
         }
         rme96->irq = pci->irq;
@@ -2372,13 +2374,12 @@ snd_rme96_create_switches(struct snd_card *card,
  * Card initialisation
  */
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 
-static int
-snd_rme96_suspend(struct pci_dev *pci,
-                  pm_message_t state)
+static int rme96_suspend(struct device *dev)
 {
-        struct snd_card *card = pci_get_drvdata(pci);
+        struct pci_dev *pci = to_pci_dev(dev);
+        struct snd_card *card = dev_get_drvdata(dev);
         struct rme96 *rme96 = card->private_data;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
@@ -2407,15 +2408,15 @@ snd_rme96_suspend(struct pci_dev *pci,
         return 0;
 }
 
-static int
-snd_rme96_resume(struct pci_dev *pci)
+static int rme96_resume(struct device *dev)
 {
-        struct snd_card *card = pci_get_drvdata(pci);
+        struct pci_dev *pci = to_pci_dev(dev);
+        struct snd_card *card = dev_get_drvdata(dev);
         struct rme96 *rme96 = card->private_data;
 
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "rme96: pci_enable_device failed, disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2451,7 +2452,11 @@ snd_rme96_resume(struct pci_dev *pci)
         return 0;
 }
 
-#endif
+static SIMPLE_DEV_PM_OPS(rme96_pm, rme96_suspend, rme96_resume);
+#define RME96_PM_OPS    &rme96_pm
+#else
+#define RME96_PM_OPS    NULL
+#endif /* CONFIG_PM_SLEEP */
 
 static void snd_rme96_card_free(struct snd_card *card)
 {
@@ -2488,17 +2493,17 @@ snd_rme96_probe(struct pci_dev *pci,
                 return err;
         }
         
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         rme96->playback_suspend_buffer = vmalloc(RME96_BUFFER_SIZE);
         if (!rme96->playback_suspend_buffer) {
-                snd_printk(KERN_ERR
+                dev_err(card->dev,
                            "Failed to allocate playback suspend buffer!\n");
                 snd_card_free(card);
                 return -ENOMEM;
         }
         rme96->capture_suspend_buffer = vmalloc(RME96_BUFFER_SIZE);
         if (!rme96->capture_suspend_buffer) {
-                snd_printk(KERN_ERR
+                dev_err(card->dev,
                            "Failed to allocate capture suspend buffer!\n");
                 snd_card_free(card);
                 return -ENOMEM;
@@ -2547,10 +2552,9 @@ static struct pci_driver rme96_driver = {
         .id_table = snd_rme96_ids,
         .probe = snd_rme96_probe,
         .remove = snd_rme96_remove,
-#ifdef CONFIG_PM
-        .suspend = snd_rme96_suspend,
-        .resume = snd_rme96_resume,
-#endif
+        .driver = {
+                .pm = RME96_PM_OPS,
+        },
 };
 
 module_pci_driver(rme96_driver);
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index 825fbbea7f6f..4c6f5d1c9882 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -675,14 +675,15 @@ static int hdsp_check_for_iobox (struct hdsp *hdsp)
                 if (0 == (hdsp_read(hdsp, HDSP_statusRegister) &
                                         HDSP_ConfigError)) {
                         if (i) {
-                                snd_printd("Hammerfall-DSP: IO box found after %d ms\n",
+                                dev_dbg(hdsp->card->dev,
+                                        "IO box found after %d ms\n",
                                                 (20 * i));
                         }
                         return 0;
                 }
                 msleep(20);
         }
-        snd_printk(KERN_ERR "Hammerfall-DSP: no IO box connected!\n");
+        dev_err(hdsp->card->dev, "no IO box connected!\n");
         hdsp->state &= ~HDSP_FirmwareLoaded;
         return -EIO;
 }
@@ -699,13 +700,13 @@ static int hdsp_wait_for_iobox(struct hdsp *hdsp, unsigned int loops,
                 if (hdsp_read(hdsp, HDSP_statusRegister) & HDSP_ConfigError)
                         msleep(delay);
                 else {
-                        snd_printd("Hammerfall-DSP: iobox found after %ums!\n",
+                        dev_dbg(hdsp->card->dev, "iobox found after %ums!\n",
                                    i * delay);
                         return 0;
                 }
         }
 
-        snd_printk("Hammerfall-DSP: no IO box connected!\n");
+        dev_info(hdsp->card->dev, "no IO box connected!\n");
         hdsp->state &= ~HDSP_FirmwareLoaded;
         return -EIO;
 }
@@ -728,13 +729,14 @@ static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
 
         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
 
-                snd_printk ("Hammerfall-DSP: loading firmware\n");
+                dev_info(hdsp->card->dev, "loading firmware\n");
 
                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_PROGRAM);
                 hdsp_write (hdsp, HDSP_fifoData, 0);
 
                 if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
-                        snd_printk ("Hammerfall-DSP: timeout waiting for download preparation\n");
+                        dev_info(hdsp->card->dev,
+                                 "timeout waiting for download preparation\n");
                         hdsp_write(hdsp, HDSP_control2Reg, HDSP_S200);
                         return -EIO;
                 }
@@ -744,7 +746,8 @@ static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
                 for (i = 0; i < HDSP_FIRMWARE_SIZE / 4; ++i) {
                         hdsp_write(hdsp, HDSP_fifoData, cache[i]);
                         if (hdsp_fifo_wait (hdsp, 127, HDSP_LONG_WAIT)) {
-                                snd_printk ("Hammerfall-DSP: timeout during firmware loading\n");
+                                dev_info(hdsp->card->dev,
+                                         "timeout during firmware loading\n");
                                 hdsp_write(hdsp, HDSP_control2Reg, HDSP_S200);
                                 return -EIO;
                         }
@@ -760,11 +763,12 @@ static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
                 hdsp->control2_register = 0;
 #endif
                 hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
-                snd_printk ("Hammerfall-DSP: finished firmware loading\n");
+                dev_info(hdsp->card->dev, "finished firmware loading\n");
 
         }
         if (hdsp->state & HDSP_InitializationComplete) {
-                snd_printk(KERN_INFO "Hammerfall-DSP: firmware loaded from cache, restoring defaults\n");
+                dev_info(hdsp->card->dev,
+                         "firmware loaded from cache, restoring defaults\n");
                 spin_lock_irqsave(&hdsp->lock, flags);
                 snd_hdsp_set_defaults(hdsp);
                 spin_unlock_irqrestore(&hdsp->lock, flags);
@@ -791,7 +795,7 @@ static int hdsp_get_iobox_version (struct hdsp *hdsp)
                 hdsp_write (hdsp, HDSP_fifoData, 0);
                 if (hdsp_fifo_wait(hdsp, 0, HDSP_SHORT_WAIT) < 0) {
                         hdsp->io_type = Multiface;
-                        snd_printk("Hammerfall-DSP: Multiface found\n");
+                        dev_info(hdsp->card->dev, "Multiface found\n");
                         return 0;
                 }
 
@@ -799,7 +803,7 @@ static int hdsp_get_iobox_version (struct hdsp *hdsp)
                 hdsp_write(hdsp, HDSP_fifoData, 0);
                 if (hdsp_fifo_wait(hdsp, 0, HDSP_SHORT_WAIT) == 0) {
                         hdsp->io_type = Digiface;
-                        snd_printk("Hammerfall-DSP: Digiface found\n");
+                        dev_info(hdsp->card->dev, "Digiface found\n");
                         return 0;
                 }
 
@@ -808,7 +812,7 @@ static int hdsp_get_iobox_version (struct hdsp *hdsp)
                 hdsp_write(hdsp, HDSP_fifoData, 0);
                 if (hdsp_fifo_wait(hdsp, 0, HDSP_SHORT_WAIT) == 0) {
                         hdsp->io_type = Multiface;
-                        snd_printk("Hammerfall-DSP: Multiface found\n");
+                        dev_info(hdsp->card->dev, "Multiface found\n");
                         return 0;
                 }
 
@@ -817,12 +821,12 @@ static int hdsp_get_iobox_version (struct hdsp *hdsp)
                 hdsp_write(hdsp, HDSP_fifoData, 0);
                 if (hdsp_fifo_wait(hdsp, 0, HDSP_SHORT_WAIT) < 0) {
                         hdsp->io_type = Multiface;
-                        snd_printk("Hammerfall-DSP: Multiface found\n");
+                        dev_info(hdsp->card->dev, "Multiface found\n");
                         return 0;
                 }
 
                 hdsp->io_type = RPM;
-                snd_printk("Hammerfall-DSP: RPM found\n");
+                dev_info(hdsp->card->dev, "RPM found\n");
                 return 0;
         } else {
                 /* firmware was already loaded, get iobox type */
@@ -847,20 +851,18 @@ static int hdsp_check_for_firmware (struct hdsp *hdsp, int load_on_demand)
                 hdsp->state &= ~HDSP_FirmwareLoaded;
                 if (! load_on_demand)
                         return -EIO;
-                snd_printk(KERN_ERR "Hammerfall-DSP: firmware not present.\n");
+                dev_err(hdsp->card->dev, "firmware not present.\n");
                 /* try to load firmware */
                 if (! (hdsp->state & HDSP_FirmwareCached)) {
                         if (! hdsp_request_fw_loader(hdsp))
                                 return 0;
-                        snd_printk(KERN_ERR
-                                   "Hammerfall-DSP: No firmware loaded nor "
-                                   "cached, please upload firmware.\n");
+                        dev_err(hdsp->card->dev,
+                                   "No firmware loaded nor cached, please upload firmware.\n");
                         return -EIO;
                 }
                 if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
-                        snd_printk(KERN_ERR
-                                   "Hammerfall-DSP: Firmware loading from "
-                                   "cache failed, please upload manually.\n");
+                        dev_err(hdsp->card->dev,
+                                   "Firmware loading from cache failed, please upload manually.\n");
                         return -EIO;
                 }
         }
@@ -888,7 +890,8 @@ static int hdsp_fifo_wait(struct hdsp *hdsp, int count, int timeout)
                 udelay (100);
         }
 
-        snd_printk ("Hammerfall-DSP: wait for FIFO status <= %d failed after %d iterations\n",
+        dev_warn(hdsp->card->dev,
+                 "wait for FIFO status <= %d failed after %d iterations\n",
                     count, timeout);
         return -1;
 }
@@ -1005,7 +1008,9 @@ static int hdsp_spdif_sample_rate(struct hdsp *hdsp)
         default:
                 break;
         }
-        snd_printk ("Hammerfall-DSP: unknown spdif frequency status; bits = 0x%x, status = 0x%x\n", rate_bits, status);
+        dev_warn(hdsp->card->dev,
+                 "unknown spdif frequency status; bits = 0x%x, status = 0x%x\n",
+                 rate_bits, status);
         return 0;
 }
 
@@ -1139,7 +1144,8 @@ static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally)
         if (!(hdsp->control_register & HDSP_ClockModeMaster)) {
                 if (called_internally) {
                         /* request from ctl or card initialization */
-                        snd_printk(KERN_ERR "Hammerfall-DSP: device is not running as a clock master: cannot set sample rate.\n");
+                        dev_err(hdsp->card->dev,
+                                "device is not running as a clock master: cannot set sample rate.\n");
                         return -1;
                 } else {
                         /* hw_param request while in AutoSync mode */
@@ -1147,11 +1153,14 @@ static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally)
                         int spdif_freq = hdsp_spdif_sample_rate(hdsp);
 
                         if ((spdif_freq == external_freq*2) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1))
-                                snd_printk(KERN_INFO "Hammerfall-DSP: Detected ADAT in double speed mode\n");
+                                dev_info(hdsp->card->dev,
+                                         "Detected ADAT in double speed mode\n");
                         else if (hdsp->io_type == H9632 && (spdif_freq == external_freq*4) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1))
-                                snd_printk(KERN_INFO "Hammerfall-DSP: Detected ADAT in quad speed mode\n");
+                                dev_info(hdsp->card->dev,
+                                         "Detected ADAT in quad speed mode\n");
                         else if (rate != external_freq) {
-                                snd_printk(KERN_INFO "Hammerfall-DSP: No AutoSync source for requested rate\n");
+                                dev_info(hdsp->card->dev,
+                                         "No AutoSync source for requested rate\n");
                                 return -1;
                         }
                 }
@@ -1223,7 +1232,8 @@ static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally)
         }
 
         if (reject_if_open && (hdsp->capture_pid >= 0 || hdsp->playback_pid >= 0)) {
-                snd_printk ("Hammerfall-DSP: cannot change speed mode (capture PID = %d, playback PID = %d)\n",
+                dev_warn(hdsp->card->dev,
+                         "cannot change speed mode (capture PID = %d, playback PID = %d)\n",
                             hdsp->capture_pid,
                             hdsp->playback_pid);
                 return -EBUSY;
@@ -3785,7 +3795,8 @@ static int snd_hdsp_initialize_memory(struct hdsp *hdsp)
             snd_hammerfall_get_buffer(hdsp->pci, &hdsp->playback_dma_buf, HDSP_DMA_AREA_BYTES) < 0) {
                 if (hdsp->capture_dma_buf.area)
                         snd_dma_free_pages(&hdsp->capture_dma_buf);
-                printk(KERN_ERR "%s: no buffers available\n", hdsp->card_name);
+                dev_err(hdsp->card->dev,
+                        "%s: no buffers available\n", hdsp->card_name);
                 return -ENOMEM;
         }
 
@@ -4747,7 +4758,8 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
                         return err;
 
                 if (!(hdsp->state & HDSP_FirmwareLoaded)) {
-                        snd_printk(KERN_ERR "Hammerfall-DSP: firmware needs to be uploaded to the card.\n");
+                        dev_err(hdsp->card->dev,
+                                "firmware needs to be uploaded to the card.\n");
                         return -EINVAL;
                 }
 
@@ -4858,7 +4870,8 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
                 if (hdsp->state & (HDSP_FirmwareCached | HDSP_FirmwareLoaded))
                         return -EBUSY;
 
-                snd_printk(KERN_INFO "Hammerfall-DSP: initializing firmware upload\n");
+                dev_info(hdsp->card->dev,
+                         "initializing firmware upload\n");
                 firmware = (struct hdsp_firmware __user *)argp;
 
                 if (get_user(firmware_data, &firmware->firmware_data))
@@ -4893,7 +4906,8 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
                         snd_hdsp_initialize_midi_flush(hdsp);
 
                         if ((err = snd_hdsp_create_alsa_devices(hdsp->card, hdsp)) < 0) {
-                                snd_printk(KERN_ERR "Hammerfall-DSP: error creating alsa devices\n");
+                                dev_err(hdsp->card->dev,
+                                        "error creating alsa devices\n");
                                 return err;
                         }
                 }
@@ -4983,7 +4997,8 @@ static int snd_hdsp_enable_io (struct hdsp *hdsp)
         int i;
 
         if (hdsp_fifo_wait (hdsp, 0, 100)) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: enable_io fifo_wait failed\n");
+                dev_err(hdsp->card->dev,
+                        "enable_io fifo_wait failed\n");
                 return -EIO;
         }
 
@@ -5057,25 +5072,29 @@ static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp
         int err;
 
         if ((err = snd_hdsp_create_pcm(card, hdsp)) < 0) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: Error creating pcm interface\n");
+                dev_err(card->dev,
+                        "Error creating pcm interface\n");
                 return err;
         }
 
 
         if ((err = snd_hdsp_create_midi(card, hdsp, 0)) < 0) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: Error creating first midi interface\n");
+                dev_err(card->dev,
+                        "Error creating first midi interface\n");
                 return err;
         }
 
         if (hdsp->io_type == Digiface || hdsp->io_type == H9652) {
                 if ((err = snd_hdsp_create_midi(card, hdsp, 1)) < 0) {
-                        snd_printk(KERN_ERR "Hammerfall-DSP: Error creating second midi interface\n");
+                        dev_err(card->dev,
+                                "Error creating second midi interface\n");
                         return err;
                 }
         }
 
         if ((err = snd_hdsp_create_controls(card, hdsp)) < 0) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: Error creating ctl interface\n");
+                dev_err(card->dev,
+                        "Error creating ctl interface\n");
                 return err;
         }
 
@@ -5088,7 +5107,8 @@ static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp
         hdsp->playback_substream = NULL;
 
         if ((err = snd_hdsp_set_defaults(hdsp)) < 0) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: Error setting default values\n");
+                dev_err(card->dev,
+                        "Error setting default values\n");
                 return err;
         }
 
@@ -5098,7 +5118,8 @@ static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp
                         hdsp->port, hdsp->irq);
 
                 if ((err = snd_card_register(card)) < 0) {
-                        snd_printk(KERN_ERR "Hammerfall-DSP: error registering card\n");
+                        dev_err(card->dev,
+                                "error registering card\n");
                         return err;
                 }
                 hdsp->state |= HDSP_InitializationComplete;
@@ -5141,16 +5162,19 @@ static int hdsp_request_fw_loader(struct hdsp *hdsp)
                         fwfile = "digiface_firmware_rev11.bin";
                 break;
         default:
-                snd_printk(KERN_ERR "Hammerfall-DSP: invalid io_type %d\n", hdsp->io_type);
+                dev_err(hdsp->card->dev,
+                        "invalid io_type %d\n", hdsp->io_type);
                 return -EINVAL;
         }
 
         if (request_firmware(&fw, fwfile, &hdsp->pci->dev)) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: cannot load firmware %s\n", fwfile);
+                dev_err(hdsp->card->dev,
+                        "cannot load firmware %s\n", fwfile);
                 return -ENOENT;
         }
         if (fw->size < HDSP_FIRMWARE_SIZE) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: too short firmware size %d (expected %d)\n",
+                dev_err(hdsp->card->dev,
+                        "too short firmware size %d (expected %d)\n",
                            (int)fw->size, HDSP_FIRMWARE_SIZE);
                 return -EINVAL;
         }
@@ -5167,13 +5191,15 @@ static int hdsp_request_fw_loader(struct hdsp *hdsp)
                         return err;
 
                 if ((err = snd_hdsp_create_hwdep(hdsp->card, hdsp)) < 0) {
-                        snd_printk(KERN_ERR "Hammerfall-DSP: error creating hwdep device\n");
+                        dev_err(hdsp->card->dev,
+                                "error creating hwdep device\n");
                         return err;
                 }
                 snd_hdsp_initialize_channels(hdsp);
                 snd_hdsp_initialize_midi_flush(hdsp);
                 if ((err = snd_hdsp_create_alsa_devices(hdsp->card, hdsp)) < 0) {
-                        snd_printk(KERN_ERR "Hammerfall-DSP: error creating alsa devices\n");
+                        dev_err(hdsp->card->dev,
+                                "error creating alsa devices\n");
                         return err;
                 }
         }
@@ -5249,13 +5275,14 @@ static int snd_hdsp_create(struct snd_card *card,
                 return err;
         hdsp->port = pci_resource_start(pci, 0);
         if ((hdsp->iobase = ioremap_nocache(hdsp->port, HDSP_IO_EXTENT)) == NULL) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: unable to remap region 0x%lx-0x%lx\n", hdsp->port, hdsp->port + HDSP_IO_EXTENT - 1);
+                dev_err(hdsp->card->dev, "unable to remap region 0x%lx-0x%lx\n",
+                        hdsp->port, hdsp->port + HDSP_IO_EXTENT - 1);
                 return -EBUSY;
         }
 
         if (request_irq(pci->irq, snd_hdsp_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, hdsp)) {
-                snd_printk(KERN_ERR "Hammerfall-DSP: unable to use IRQ %d\n", pci->irq);
+                dev_err(hdsp->card->dev, "unable to use IRQ %d\n", pci->irq);
                 return -EBUSY;
         }
 
@@ -5281,17 +5308,20 @@ static int snd_hdsp_create(struct snd_card *card,
                                    if userspace is not ready for
                                    firmware upload
                                 */
-                                snd_printk(KERN_ERR "Hammerfall-DSP: couldn't get firmware from userspace. try using hdsploader\n");
+                                dev_err(hdsp->card->dev,
+                                        "couldn't get firmware from userspace. try using hdsploader\n");
                         else
                                 /* init is complete, we return */
                                 return 0;
                         /* we defer initialization */
-                        snd_printk(KERN_INFO "Hammerfall-DSP: card initialization pending : waiting for firmware\n");
+                        dev_info(hdsp->card->dev,
+                                 "card initialization pending : waiting for firmware\n");
                         if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0)
                                 return err;
                         return 0;
                 } else {
-                        snd_printk(KERN_INFO "Hammerfall-DSP: Firmware already present, initializing card.\n");
+                        dev_info(hdsp->card->dev,
+                                 "Firmware already present, initializing card.\n");
                         if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version2)
                                 hdsp->io_type = RPM;
                         else if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1)
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index 76016287e46f..cb82b593473a 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -1651,9 +1651,8 @@ static int hdspm_set_rate(struct hdspm * hdspm, int rate, int called_internally)
                            just make a warning an remember setting
                            for future master mode switching */
 
-                        snd_printk(KERN_WARNING "HDSPM: "
-                                   "Warning: device is not running "
-                                   "as a clock master.\n");
+                        dev_warn(hdspm->card->dev,
+                                 "Warning: device is not running as a clock master.\n");
                         not_set = 1;
                 } else {
 
@@ -1664,15 +1663,14 @@ static int hdspm_set_rate(struct hdspm * hdspm, int rate, int called_internally)
                         if (hdspm_autosync_ref(hdspm) ==
                             HDSPM_AUTOSYNC_FROM_NONE) {
 
-                                snd_printk(KERN_WARNING "HDSPM: "
-                                           "Detected no Externel Sync \n");
+                                dev_warn(hdspm->card->dev,
+                                         "Detected no Externel Sync\n");
                                 not_set = 1;
 
                         } else if (rate != external_freq) {
 
-                                snd_printk(KERN_WARNING "HDSPM: "
-                                           "Warning: No AutoSync source for "
-                                           "requested rate\n");
+                                dev_warn(hdspm->card->dev,
+                                         "Warning: No AutoSync source for requested rate\n");
                                 not_set = 1;
                         }
                 }
@@ -1738,13 +1736,11 @@ static int hdspm_set_rate(struct hdspm * hdspm, int rate, int called_internally)
 
         if (current_speed != target_speed
             && (hdspm->capture_pid >= 0 || hdspm->playback_pid >= 0)) {
-                snd_printk
-                    (KERN_ERR "HDSPM: "
-                     "cannot change from %s speed to %s speed mode "
-                     "(capture PID = %d, playback PID = %d)\n",
-                     hdspm_speed_names[current_speed],
-                     hdspm_speed_names[target_speed],
-                     hdspm->capture_pid, hdspm->playback_pid);
+                dev_err(hdspm->card->dev,
+                        "cannot change from %s speed to %s speed mode (capture PID = %d, playback PID = %d)\n",
+                        hdspm_speed_names[current_speed],
+                        hdspm_speed_names[target_speed],
+                        hdspm->capture_pid, hdspm->playback_pid);
                 return -EBUSY;
         }
 
@@ -5446,7 +5442,7 @@ static irqreturn_t snd_hdspm_interrupt(int irq, void *dev_id)
          *          0         64     ~3998231       ~8191558
          **/
         /*
-           snd_printk(KERN_INFO "snd_hdspm_interrupt %llu @ %llx\n",
+          dev_info(hdspm->card->dev, "snd_hdspm_interrupt %llu @ %llx\n",
            now-hdspm->last_interrupt, status & 0xFFC0);
            hdspm->last_interrupt = now;
         */
@@ -5583,7 +5579,7 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
         spin_lock_irq(&hdspm->lock);
         err = hdspm_set_rate(hdspm, params_rate(params), 0);
         if (err < 0) {
-                snd_printk(KERN_INFO "err on hdspm_set_rate: %d\n", err);
+                dev_info(hdspm->card->dev, "err on hdspm_set_rate: %d\n", err);
                 spin_unlock_irq(&hdspm->lock);
                 _snd_pcm_hw_param_setempty(params,
                                 SNDRV_PCM_HW_PARAM_RATE);
@@ -5594,7 +5590,8 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
         err = hdspm_set_interrupt_interval(hdspm,
                         params_period_size(params));
         if (err < 0) {
-                snd_printk(KERN_INFO "err on hdspm_set_interrupt_interval: %d\n", err);
+                dev_info(hdspm->card->dev,
+                         "err on hdspm_set_interrupt_interval: %d\n", err);
                 _snd_pcm_hw_param_setempty(params,
                                 SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
                 return err;
@@ -5610,7 +5607,8 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
         err =
                 snd_pcm_lib_malloc_pages(substream, HDSPM_DMA_AREA_BYTES);
         if (err < 0) {
-                snd_printk(KERN_INFO "err on snd_pcm_lib_malloc_pages: %d\n", err);
+                dev_info(hdspm->card->dev,
+                         "err on snd_pcm_lib_malloc_pages: %d\n", err);
                 return err;
         }
 
@@ -5624,7 +5622,8 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
 
                 hdspm->playback_buffer =
                         (unsigned char *) substream->runtime->dma_area;
-                snd_printdd("Allocated sample buffer for playback at %p\n",
+                dev_dbg(hdspm->card->dev,
+                        "Allocated sample buffer for playback at %p\n",
                                 hdspm->playback_buffer);
         } else {
                 hdspm_set_sgbuf(hdspm, substream, HDSPM_pageAddressBufferIn,
@@ -5635,18 +5634,21 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
 
                 hdspm->capture_buffer =
                         (unsigned char *) substream->runtime->dma_area;
-                snd_printdd("Allocated sample buffer for capture at %p\n",
+                dev_dbg(hdspm->card->dev,
+                        "Allocated sample buffer for capture at %p\n",
                                 hdspm->capture_buffer);
         }
 
         /*
-           snd_printdd("Allocated sample buffer for %s at 0x%08X\n",
+           dev_dbg(hdspm->card->dev,
+           "Allocated sample buffer for %s at 0x%08X\n",
            substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
            "playback" : "capture",
            snd_pcm_sgbuf_get_addr(substream, 0));
            */
         /*
-           snd_printdd("set_hwparams: %s %d Hz, %d channels, bs = %d\n",
+           dev_dbg(hdspm->card->dev,
+           "set_hwparams: %s %d Hz, %d channels, bs = %d\n",
            substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
            "playback" : "capture",
            params_rate(params), params_channels(params),
@@ -5667,12 +5669,14 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
         /* Switch to native float format if requested */
         if (SNDRV_PCM_FORMAT_FLOAT_LE == params_format(params)) {
                 if (!(hdspm->control_register & HDSPe_FLOAT_FORMAT))
-                        snd_printk(KERN_INFO "hdspm: Switching to native 32bit LE float format.\n");
+                        dev_info(hdspm->card->dev,
+                                 "Switching to native 32bit LE float format.\n");
 
                 hdspm->control_register |= HDSPe_FLOAT_FORMAT;
         } else if (SNDRV_PCM_FORMAT_S32_LE == params_format(params)) {
                 if (hdspm->control_register & HDSPe_FLOAT_FORMAT)
-                        snd_printk(KERN_INFO "hdspm: Switching to native 32bit LE integer format.\n");
+                        dev_info(hdspm->card->dev,
+                                 "Switching to native 32bit LE integer format.\n");
 
                 hdspm->control_register &= ~HDSPe_FLOAT_FORMAT;
         }
@@ -5715,12 +5719,16 @@ static int snd_hdspm_channel_info(struct snd_pcm_substream *substream,
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 if (snd_BUG_ON(info->channel >= hdspm->max_channels_out)) {
-                        snd_printk(KERN_INFO "snd_hdspm_channel_info: output channel out of range (%d)\n", info->channel);
+                        dev_info(hdspm->card->dev,
+                                 "snd_hdspm_channel_info: output channel out of range (%d)\n",
+                                 info->channel);
                         return -EINVAL;
                 }
 
                 if (hdspm->channel_map_out[info->channel] < 0) {
-                        snd_printk(KERN_INFO "snd_hdspm_channel_info: output channel %d mapped out\n", info->channel);
+                        dev_info(hdspm->card->dev,
+                                 "snd_hdspm_channel_info: output channel %d mapped out\n",
+                                 info->channel);
                         return -EINVAL;
                 }
 
@@ -5728,12 +5736,16 @@ static int snd_hdspm_channel_info(struct snd_pcm_substream *substream,
                         HDSPM_CHANNEL_BUFFER_BYTES;
         } else {
                 if (snd_BUG_ON(info->channel >= hdspm->max_channels_in)) {
-                        snd_printk(KERN_INFO "snd_hdspm_channel_info: input channel out of range (%d)\n", info->channel);
+                        dev_info(hdspm->card->dev,
+                                 "snd_hdspm_channel_info: input channel out of range (%d)\n",
+                                 info->channel);
                         return -EINVAL;
                 }
 
                 if (hdspm->channel_map_in[info->channel] < 0) {
-                        snd_printk(KERN_INFO "snd_hdspm_channel_info: input channel %d mapped out\n", info->channel);
+                        dev_info(hdspm->card->dev,
+                                 "snd_hdspm_channel_info: input channel %d mapped out\n",
+                                 info->channel);
                         return -EINVAL;
                 }
 
@@ -6283,7 +6295,7 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
 
                 s = copy_to_user(argp, levels, sizeof(struct hdspm_peak_rms));
                 if (0 != s) {
-                        /* snd_printk(KERN_ERR "copy_to_user(.., .., %lu): %lu
+                        /* dev_err(hdspm->card->dev, "copy_to_user(.., .., %lu): %lu
                          [Levels]\n", sizeof(struct hdspm_peak_rms), s);
                          */
                         return -EFAULT;
@@ -6329,7 +6341,7 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
                 s = copy_to_user(argp, &ltc, sizeof(struct hdspm_ltc));
                 if (0 != s) {
                         /*
-                         snd_printk(KERN_ERR "copy_to_user(.., .., %lu): %lu [LTC]\n", sizeof(struct hdspm_ltc), s); */
+                          dev_err(hdspm->card->dev, "copy_to_user(.., .., %lu): %lu [LTC]\n", sizeof(struct hdspm_ltc), s); */
                         return -EFAULT;
                 }
 
@@ -6494,11 +6506,13 @@ static int snd_hdspm_preallocate_memory(struct hdspm *hdspm)
                                                    wanted,
                                                    wanted);
         if (err < 0) {
-                snd_printdd("Could not preallocate %zd Bytes\n", wanted);
+                dev_dbg(hdspm->card->dev,
+                        "Could not preallocate %zd Bytes\n", wanted);
 
                 return err;
         } else
-                snd_printdd(" Preallocated %zd Bytes\n", wanted);
+                dev_dbg(hdspm->card->dev,
+                        " Preallocated %zd Bytes\n", wanted);
 
         return 0;
 }
@@ -6559,7 +6573,7 @@ static int snd_hdspm_create_alsa_devices(struct snd_card *card,
 {
         int err, i;
 
-        snd_printdd("Create card...\n");
+        dev_dbg(card->dev, "Create card...\n");
         err = snd_hdspm_create_pcm(card, hdspm);
         if (err < 0)
                 return err;
@@ -6581,7 +6595,7 @@ static int snd_hdspm_create_alsa_devices(struct snd_card *card,
         if (err < 0)
                 return err;
 
-        snd_printdd("proc init...\n");
+        dev_dbg(card->dev, "proc init...\n");
         snd_hdspm_proc_init(hdspm);
 
         hdspm->system_sample_rate = -1;
@@ -6592,23 +6606,23 @@ static int snd_hdspm_create_alsa_devices(struct snd_card *card,
         hdspm->capture_substream = NULL;
         hdspm->playback_substream = NULL;
 
-        snd_printdd("Set defaults...\n");
+        dev_dbg(card->dev, "Set defaults...\n");
         err = snd_hdspm_set_defaults(hdspm);
         if (err < 0)
                 return err;
 
-        snd_printdd("Update mixer controls...\n");
+        dev_dbg(card->dev, "Update mixer controls...\n");
         hdspm_update_simple_mixer_controls(hdspm);
 
-        snd_printdd("Initializeing complete ???\n");
+        dev_dbg(card->dev, "Initializeing complete ???\n");
 
         err = snd_card_register(card);
         if (err < 0) {
-                snd_printk(KERN_ERR "HDSPM: error registering card\n");
+                dev_err(card->dev, "error registering card\n");
                 return err;
         }
 
-        snd_printdd("... yes now\n");
+        dev_dbg(card->dev, "... yes now\n");
 
         return 0;
 }
@@ -6662,8 +6676,8 @@ static int snd_hdspm_create(struct snd_card *card,
                         hdspm->card_name = "RME MADI";
                         hdspm->midiPorts = 3;
                 } else {
-                        snd_printk(KERN_ERR
-                                "HDSPM: unknown firmware revision %x\n",
+                        dev_err(card->dev,
+                                "unknown firmware revision %x\n",
                                 hdspm->firmware_rev);
                         return -ENODEV;
                 }
@@ -6682,36 +6696,35 @@ static int snd_hdspm_create(struct snd_card *card,
         hdspm->port = pci_resource_start(pci, 0);
         io_extent = pci_resource_len(pci, 0);
 
-        snd_printdd("grabbed memory region 0x%lx-0x%lx\n",
+        dev_dbg(card->dev, "grabbed memory region 0x%lx-0x%lx\n",
                         hdspm->port, hdspm->port + io_extent - 1);
 
         hdspm->iobase = ioremap_nocache(hdspm->port, io_extent);
         if (!hdspm->iobase) {
-                snd_printk(KERN_ERR "HDSPM: "
-                                "unable to remap region 0x%lx-0x%lx\n",
+                dev_err(card->dev, "unable to remap region 0x%lx-0x%lx\n",
                                 hdspm->port, hdspm->port + io_extent - 1);
                 return -EBUSY;
         }
-        snd_printdd("remapped region (0x%lx) 0x%lx-0x%lx\n",
+        dev_dbg(card->dev, "remapped region (0x%lx) 0x%lx-0x%lx\n",
                         (unsigned long)hdspm->iobase, hdspm->port,
                         hdspm->port + io_extent - 1);
 
         if (request_irq(pci->irq, snd_hdspm_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, hdspm)) {
-                snd_printk(KERN_ERR "HDSPM: unable to use IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to use IRQ %d\n", pci->irq);
                 return -EBUSY;
         }
 
-        snd_printdd("use IRQ %d\n", pci->irq);
+        dev_dbg(card->dev, "use IRQ %d\n", pci->irq);
 
         hdspm->irq = pci->irq;
 
-        snd_printdd("kmalloc Mixer memory of %zd Bytes\n",
+        dev_dbg(card->dev, "kmalloc Mixer memory of %zd Bytes\n",
                         sizeof(struct hdspm_mixer));
         hdspm->mixer = kzalloc(sizeof(struct hdspm_mixer), GFP_KERNEL);
         if (!hdspm->mixer) {
-                snd_printk(KERN_ERR "HDSPM: "
-                                "unable to kmalloc Mixer memory of %d Bytes\n",
+                dev_err(card->dev,
+                        "unable to kmalloc Mixer memory of %d Bytes\n",
                                 (int)sizeof(struct hdspm_mixer));
                 return -ENOMEM;
         }
@@ -6780,14 +6793,14 @@ static int snd_hdspm_create(struct snd_card *card,
                 hdspm->qs_out_channels = AIO_OUT_QS_CHANNELS;
 
                 if (0 == (hdspm_read(hdspm, HDSPM_statusRegister2) & HDSPM_s2_AEBI_D)) {
-                        snd_printk(KERN_INFO "HDSPM: AEB input board found\n");
+                        dev_info(card->dev, "AEB input board found\n");
                         hdspm->ss_in_channels += 4;
                         hdspm->ds_in_channels += 4;
                         hdspm->qs_in_channels += 4;
                 }
 
                 if (0 == (hdspm_read(hdspm, HDSPM_statusRegister2) & HDSPM_s2_AEBO_D)) {
-                        snd_printk(KERN_INFO "HDSPM: AEB output board found\n");
+                        dev_info(card->dev, "AEB output board found\n");
                         hdspm->ss_out_channels += 4;
                         hdspm->ds_out_channels += 4;
                         hdspm->qs_out_channels += 4;
@@ -6854,7 +6867,7 @@ static int snd_hdspm_create(struct snd_card *card,
                         if (NULL != hdspm->tco) {
                                 hdspm_tco_write(hdspm);
                         }
-                        snd_printk(KERN_INFO "HDSPM: AIO/RayDAT TCO module found\n");
+                        dev_info(card->dev, "AIO/RayDAT TCO module found\n");
                 } else {
                         hdspm->tco = NULL;
                 }
@@ -6869,7 +6882,7 @@ static int snd_hdspm_create(struct snd_card *card,
                         if (NULL != hdspm->tco) {
                                 hdspm_tco_write(hdspm);
                         }
-                        snd_printk(KERN_INFO "HDSPM: MADI/AES TCO module found\n");
+                        dev_info(card->dev, "MADI/AES TCO module found\n");
                 } else {
                         hdspm->tco = NULL;
                 }
@@ -6951,7 +6964,7 @@ static int snd_hdspm_create(struct snd_card *card,
                 }
         }
 
-        snd_printdd("create alsa devices.\n");
+        dev_dbg(card->dev, "create alsa devices.\n");
         err = snd_hdspm_create_alsa_devices(card, hdspm);
         if (err < 0)
                 return err;
diff --git a/sound/pci/rme9652/rme9652.c b/sound/pci/rme9652/rme9652.c
index a62d6e13d8ce..1d9be90f7748 100644
--- a/sound/pci/rme9652/rme9652.c
+++ b/sound/pci/rme9652/rme9652.c
@@ -394,7 +394,9 @@ static snd_pcm_uframes_t rme9652_hw_pointer(struct snd_rme9652 *rme9652)
         if (offset < period_size) {
                 if (offset > rme9652->max_jitter) {
                         if (frag)
-                                printk(KERN_ERR "Unexpected hw_pointer position (bufid == 0): status: %x offset: %d\n", status, offset);
+                                dev_err(rme9652->card->dev,
+                                        "Unexpected hw_pointer position (bufid == 0): status: %x offset: %d\n",
+                                        status, offset);
                 } else if (!frag)
                         return 0;
                 offset -= rme9652->max_jitter;
@@ -403,7 +405,9 @@ static snd_pcm_uframes_t rme9652_hw_pointer(struct snd_rme9652 *rme9652)
         } else {
                 if (offset > period_size + rme9652->max_jitter) {
                         if (!frag)
-                                printk(KERN_ERR "Unexpected hw_pointer position (bufid == 1): status: %x offset: %d\n", status, offset);
+                                dev_err(rme9652->card->dev,
+                                        "Unexpected hw_pointer position (bufid == 1): status: %x offset: %d\n",
+                                        status, offset);
                 } else if (frag)
                         return period_size;
                 offset -= rme9652->max_jitter;
@@ -769,7 +773,8 @@ static inline int rme9652_spdif_sample_rate(struct snd_rme9652 *s)
                 break;
 
         default:
-                snd_printk(KERN_ERR "%s: unknown S/PDIF input rate (bits = 0x%x)\n",
+                dev_err(s->card->dev,
+                        "%s: unknown S/PDIF input rate (bits = 0x%x)\n",
                            s->card_name, rate_bits);
                 return 0;
                 break;
@@ -1790,7 +1795,8 @@ static int snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652)
             snd_hammerfall_get_buffer(rme9652->pci, &rme9652->playback_dma_buf, RME9652_DMA_AREA_BYTES) < 0) {
                 if (rme9652->capture_dma_buf.area)
                         snd_dma_free_pages(&rme9652->capture_dma_buf);
-                printk(KERN_ERR "%s: no buffers available\n", rme9652->card_name);
+                dev_err(rme9652->card->dev,
+                        "%s: no buffers available\n", rme9652->card_name);
                 return -ENOMEM;
         }
 
@@ -2468,13 +2474,14 @@ static int snd_rme9652_create(struct snd_card *card,
         rme9652->port = pci_resource_start(pci, 0);
         rme9652->iobase = ioremap_nocache(rme9652->port, RME9652_IO_EXTENT);
         if (rme9652->iobase == NULL) {
-                snd_printk(KERN_ERR "unable to remap region 0x%lx-0x%lx\n", rme9652->port, rme9652->port + RME9652_IO_EXTENT - 1);
+                dev_err(card->dev, "unable to remap region 0x%lx-0x%lx\n",
+                        rme9652->port, rme9652->port + RME9652_IO_EXTENT - 1);
                 return -EBUSY;
         }
         
         if (request_irq(pci->irq, snd_rme9652_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, rme9652)) {
-                snd_printk(KERN_ERR "unable to request IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to request IRQ %d\n", pci->irq);
                 return -EBUSY;
         }
         rme9652->irq = pci->irq;
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index 9ff408fff7b0..2044dc742071 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -273,7 +273,7 @@ static inline void snd_sonicvibes_setdmaa(struct sonicvibes * sonic,
         outl(count, sonic->dmaa_port + SV_DMA_COUNT0);
         outb(0x18, sonic->dmaa_port + SV_DMA_MODE);
 #if 0
-        printk(KERN_DEBUG "program dmaa: addr = 0x%x, paddr = 0x%x\n",
+        dev_dbg(sonic->card->dev, "program dmaa: addr = 0x%x, paddr = 0x%x\n",
                addr, inl(sonic->dmaa_port + SV_DMA_ADDR0));
 #endif
 }
@@ -289,7 +289,7 @@ static inline void snd_sonicvibes_setdmac(struct sonicvibes * sonic,
         outl(count, sonic->dmac_port + SV_DMA_COUNT0);
         outb(0x14, sonic->dmac_port + SV_DMA_MODE);
 #if 0
-        printk(KERN_DEBUG "program dmac: addr = 0x%x, paddr = 0x%x\n",
+        dev_dbg(sonic->card->dev, "program dmac: addr = 0x%x, paddr = 0x%x\n",
                addr, inl(sonic->dmac_port + SV_DMA_ADDR0));
 #endif
 }
@@ -357,105 +357,105 @@ static unsigned char snd_sonicvibes_in(struct sonicvibes * sonic, unsigned char
 #if 0
 static void snd_sonicvibes_debug(struct sonicvibes * sonic)
 {
-        printk(KERN_DEBUG
-               "SV REGS:          INDEX = 0x%02x  ", inb(SV_REG(sonic, INDEX)));
-        printk("                 STATUS = 0x%02x\n", inb(SV_REG(sonic, STATUS)));
-        printk(KERN_DEBUG
-               "  0x00: left input      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x00));
-        printk("  0x20: synth rate low  = 0x%02x\n", snd_sonicvibes_in(sonic, 0x20));
-        printk(KERN_DEBUG
-               "  0x01: right input     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x01));
-        printk("  0x21: synth rate high = 0x%02x\n", snd_sonicvibes_in(sonic, 0x21));
-        printk(KERN_DEBUG
-               "  0x02: left AUX1       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x02));
-        printk("  0x22: ADC clock       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x22));
-        printk(KERN_DEBUG
-               "  0x03: right AUX1      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x03));
-        printk("  0x23: ADC alt rate    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x23));
-        printk(KERN_DEBUG
-               "  0x04: left CD         = 0x%02x  ", snd_sonicvibes_in(sonic, 0x04));
-        printk("  0x24: ADC pll M       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x24));
-        printk(KERN_DEBUG
-               "  0x05: right CD        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x05));
-        printk("  0x25: ADC pll N       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x25));
-        printk(KERN_DEBUG
-               "  0x06: left line       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x06));
-        printk("  0x26: Synth pll M     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x26));
-        printk(KERN_DEBUG
-               "  0x07: right line      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x07));
-        printk("  0x27: Synth pll N     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x27));
-        printk(KERN_DEBUG
-               "  0x08: MIC             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x08));
-        printk("  0x28: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x28));
-        printk(KERN_DEBUG
-               "  0x09: Game port       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x09));
-        printk("  0x29: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x29));
-        printk(KERN_DEBUG
-               "  0x0a: left synth      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0a));
-        printk("  0x2a: MPU401          = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2a));
-        printk(KERN_DEBUG
-               "  0x0b: right synth     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0b));
-        printk("  0x2b: drive ctrl      = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2b));
-        printk(KERN_DEBUG
-               "  0x0c: left AUX2       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0c));
-        printk("  0x2c: SRS space       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2c));
-        printk(KERN_DEBUG
-               "  0x0d: right AUX2      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0d));
-        printk("  0x2d: SRS center      = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2d));
-        printk(KERN_DEBUG
-               "  0x0e: left analog     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0e));
-        printk("  0x2e: wave source     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2e));
-        printk(KERN_DEBUG
-               "  0x0f: right analog    = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0f));
-        printk("  0x2f: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2f));
-        printk(KERN_DEBUG
-               "  0x10: left PCM        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x10));
-        printk("  0x30: analog power    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x30));
-        printk(KERN_DEBUG
-               "  0x11: right PCM       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x11));
-        printk("  0x31: analog power    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x31));
-        printk(KERN_DEBUG
-               "  0x12: DMA data format = 0x%02x  ", snd_sonicvibes_in(sonic, 0x12));
-        printk("  0x32: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x32));
-        printk(KERN_DEBUG
-               "  0x13: P/C enable      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x13));
-        printk("  0x33: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x33));
-        printk(KERN_DEBUG
-               "  0x14: U/D button      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x14));
-        printk("  0x34: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x34));
-        printk(KERN_DEBUG
-               "  0x15: revision        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x15));
-        printk("  0x35: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x35));
-        printk(KERN_DEBUG
-               "  0x16: ADC output ctrl = 0x%02x  ", snd_sonicvibes_in(sonic, 0x16));
-        printk("  0x36: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x36));
-        printk(KERN_DEBUG
-               "  0x17: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x17));
-        printk("  0x37: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x37));
-        printk(KERN_DEBUG
-               "  0x18: DMA A upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x18));
-        printk("  0x38: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x38));
-        printk(KERN_DEBUG
-               "  0x19: DMA A lower cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x19));
-        printk("  0x39: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x39));
-        printk(KERN_DEBUG
-               "  0x1a: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1a));
-        printk("  0x3a: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3a));
-        printk(KERN_DEBUG
-               "  0x1b: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1b));
-        printk("  0x3b: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3b));
-        printk(KERN_DEBUG
-               "  0x1c: DMA C upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1c));
-        printk("  0x3c: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3c));
-        printk(KERN_DEBUG
-               "  0x1d: DMA C upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1d));
-        printk("  0x3d: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3d));
-        printk(KERN_DEBUG
-               "  0x1e: PCM rate low    = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1e));
-        printk("  0x3e: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3e));
-        printk(KERN_DEBUG
-               "  0x1f: PCM rate high   = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1f));
-        printk("  0x3f: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3f));
+        dev_dbg(sonic->card->dev,
+                "SV REGS:          INDEX = 0x%02x                   STATUS = 0x%02x\n",
+                inb(SV_REG(sonic, INDEX)), inb(SV_REG(sonic, STATUS)));
+        dev_dbg(sonic->card->dev,
+                "  0x00: left input      = 0x%02x    0x20: synth rate low  = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x00), snd_sonicvibes_in(sonic, 0x20));
+        dev_dbg(sonic->card->dev,
+                "  0x01: right input     = 0x%02x    0x21: synth rate high = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x01), snd_sonicvibes_in(sonic, 0x21));
+        dev_dbg(sonic->card->dev,
+                "  0x02: left AUX1       = 0x%02x    0x22: ADC clock       = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x02), snd_sonicvibes_in(sonic, 0x22));
+        dev_dbg(sonic->card->dev,
+                "  0x03: right AUX1      = 0x%02x    0x23: ADC alt rate    = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x03), snd_sonicvibes_in(sonic, 0x23));
+        dev_dbg(sonic->card->dev,
+                "  0x04: left CD         = 0x%02x    0x24: ADC pll M       = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x04), snd_sonicvibes_in(sonic, 0x24));
+        dev_dbg(sonic->card->dev,
+                "  0x05: right CD        = 0x%02x    0x25: ADC pll N       = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x05), snd_sonicvibes_in(sonic, 0x25));
+        dev_dbg(sonic->card->dev,
+                "  0x06: left line       = 0x%02x    0x26: Synth pll M     = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x06), snd_sonicvibes_in(sonic, 0x26));
+        dev_dbg(sonic->card->dev,
+                "  0x07: right line      = 0x%02x    0x27: Synth pll N     = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x07), snd_sonicvibes_in(sonic, 0x27));
+        dev_dbg(sonic->card->dev,
+                "  0x08: MIC             = 0x%02x    0x28: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x08), snd_sonicvibes_in(sonic, 0x28));
+        dev_dbg(sonic->card->dev,
+                "  0x09: Game port       = 0x%02x    0x29: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x09), snd_sonicvibes_in(sonic, 0x29));
+        dev_dbg(sonic->card->dev,
+                "  0x0a: left synth      = 0x%02x    0x2a: MPU401          = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x0a), snd_sonicvibes_in(sonic, 0x2a));
+        dev_dbg(sonic->card->dev,
+                "  0x0b: right synth     = 0x%02x    0x2b: drive ctrl      = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x0b), snd_sonicvibes_in(sonic, 0x2b));
+        dev_dbg(sonic->card->dev,
+                "  0x0c: left AUX2       = 0x%02x    0x2c: SRS space       = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x0c), snd_sonicvibes_in(sonic, 0x2c));
+        dev_dbg(sonic->card->dev,
+                "  0x0d: right AUX2      = 0x%02x    0x2d: SRS center      = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x0d), snd_sonicvibes_in(sonic, 0x2d));
+        dev_dbg(sonic->card->dev,
+                "  0x0e: left analog     = 0x%02x    0x2e: wave source     = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x0e), snd_sonicvibes_in(sonic, 0x2e));
+        dev_dbg(sonic->card->dev,
+                "  0x0f: right analog    = 0x%02x    0x2f: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x0f), snd_sonicvibes_in(sonic, 0x2f));
+        dev_dbg(sonic->card->dev,
+                "  0x10: left PCM        = 0x%02x    0x30: analog power    = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x10), snd_sonicvibes_in(sonic, 0x30));
+        dev_dbg(sonic->card->dev,
+                "  0x11: right PCM       = 0x%02x    0x31: analog power    = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x11), snd_sonicvibes_in(sonic, 0x31));
+        dev_dbg(sonic->card->dev,
+                "  0x12: DMA data format = 0x%02x    0x32: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x12), snd_sonicvibes_in(sonic, 0x32));
+        dev_dbg(sonic->card->dev,
+                "  0x13: P/C enable      = 0x%02x    0x33: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x13), snd_sonicvibes_in(sonic, 0x33));
+        dev_dbg(sonic->card->dev,
+                "  0x14: U/D button      = 0x%02x    0x34: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x14), snd_sonicvibes_in(sonic, 0x34));
+        dev_dbg(sonic->card->dev,
+                "  0x15: revision        = 0x%02x    0x35: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x15), snd_sonicvibes_in(sonic, 0x35));
+        dev_dbg(sonic->card->dev,
+                "  0x16: ADC output ctrl = 0x%02x    0x36: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x16), snd_sonicvibes_in(sonic, 0x36));
+        dev_dbg(sonic->card->dev,
+                "  0x17: ---             = 0x%02x    0x37: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x17), snd_sonicvibes_in(sonic, 0x37));
+        dev_dbg(sonic->card->dev,
+                "  0x18: DMA A upper cnt = 0x%02x    0x38: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x18), snd_sonicvibes_in(sonic, 0x38));
+        dev_dbg(sonic->card->dev,
+                "  0x19: DMA A lower cnt = 0x%02x    0x39: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x19), snd_sonicvibes_in(sonic, 0x39));
+        dev_dbg(sonic->card->dev,
+                "  0x1a: ---             = 0x%02x    0x3a: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x1a), snd_sonicvibes_in(sonic, 0x3a));
+        dev_dbg(sonic->card->dev,
+                "  0x1b: ---             = 0x%02x    0x3b: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x1b), snd_sonicvibes_in(sonic, 0x3b));
+        dev_dbg(sonic->card->dev,
+                "  0x1c: DMA C upper cnt = 0x%02x    0x3c: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x1c), snd_sonicvibes_in(sonic, 0x3c));
+        dev_dbg(sonic->card->dev,
+                "  0x1d: DMA C upper cnt = 0x%02x    0x3d: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x1d), snd_sonicvibes_in(sonic, 0x3d));
+        dev_dbg(sonic->card->dev,
+                "  0x1e: PCM rate low    = 0x%02x    0x3e: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x1e), snd_sonicvibes_in(sonic, 0x3e));
+        dev_dbg(sonic->card->dev,
+                "  0x1f: PCM rate high   = 0x%02x    0x3f: ---             = 0x%02x\n",
+                snd_sonicvibes_in(sonic, 0x1f), snd_sonicvibes_in(sonic, 0x3f));
 }
 
 #endif
@@ -511,8 +511,10 @@ static void snd_sonicvibes_pll(unsigned int rate,
         *res_m = m;
         *res_n = n;
 #if 0
-        printk(KERN_DEBUG "metric = %i, xm = %i, xn = %i\n", metric, xm, xn);
-        printk(KERN_DEBUG "pll: m = 0x%x, r = 0x%x, n = 0x%x\n", reg, m, r, n);
+        dev_dbg(sonic->card->dev,
+                "metric = %i, xm = %i, xn = %i\n", metric, xm, xn);
+        dev_dbg(sonic->card->dev,
+                "pll: m = 0x%x, r = 0x%x, n = 0x%x\n", reg, m, r, n);
 #endif
 }
 
@@ -624,7 +626,8 @@ static irqreturn_t snd_sonicvibes_interrupt(int irq, void *dev_id)
                 return IRQ_NONE;
         if (status == 0xff) {   /* failure */
                 outb(sonic->irqmask = ~0, SV_REG(sonic, IRQMASK));
-                snd_printk(KERN_ERR "IRQ failure - interrupts disabled!!\n");
+                dev_err(sonic->card->dev,
+                        "IRQ failure - interrupts disabled!!\n");
                 return IRQ_HANDLED;
         }
         if (sonic->pcm) {
@@ -1198,7 +1201,8 @@ static int snd_sonicvibes_create_gameport(struct sonicvibes *sonic)
 
         sonic->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "sonicvibes: cannot allocate memory for gameport\n");
+                dev_err(sonic->card->dev,
+                        "sonicvibes: cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
 
@@ -1267,7 +1271,8 @@ static int snd_sonicvibes_create(struct snd_card *card,
         /* check, if we can restrict PCI DMA transfers to 24 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
+                dev_err(card->dev,
+                        "architecture does not support 24bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -1296,7 +1301,7 @@ static int snd_sonicvibes_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_sonicvibes_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, sonic)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_sonicvibes_free(sonic);
                 return -EBUSY;
         }
@@ -1310,24 +1315,32 @@ static int snd_sonicvibes_create(struct snd_card *card,
         if (!dmaa) {
                 dmaa = dmaio;
                 dmaio += 0x10;
-                snd_printk(KERN_INFO "BIOS did not allocate DDMA channel A i/o, allocated at 0x%x\n", dmaa);
+                dev_info(card->dev,
+                         "BIOS did not allocate DDMA channel A i/o, allocated at 0x%x\n",
+                         dmaa);
         }
         if (!dmac) {
                 dmac = dmaio;
                 dmaio += 0x10;
-                snd_printk(KERN_INFO "BIOS did not allocate DDMA channel C i/o, allocated at 0x%x\n", dmac);
+                dev_info(card->dev,
+                         "BIOS did not allocate DDMA channel C i/o, allocated at 0x%x\n",
+                         dmac);
         }
         pci_write_config_dword(pci, 0x40, dmaa);
         pci_write_config_dword(pci, 0x48, dmac);
 
         if ((sonic->res_dmaa = request_region(dmaa, 0x10, "S3 SonicVibes DDMA-A")) == NULL) {
                 snd_sonicvibes_free(sonic);
-                snd_printk(KERN_ERR "unable to grab DDMA-A port at 0x%x-0x%x\n", dmaa, dmaa + 0x10 - 1);
+                dev_err(card->dev,
+                        "unable to grab DDMA-A port at 0x%x-0x%x\n",
+                        dmaa, dmaa + 0x10 - 1);
                 return -EBUSY;
         }
         if ((sonic->res_dmac = request_region(dmac, 0x10, "S3 SonicVibes DDMA-C")) == NULL) {
                 snd_sonicvibes_free(sonic);
-                snd_printk(KERN_ERR "unable to grab DDMA-C port at 0x%x-0x%x\n", dmac, dmac + 0x10 - 1);
+                dev_err(card->dev,
+                        "unable to grab DDMA-C port at 0x%x-0x%x\n",
+                        dmac, dmac + 0x10 - 1);
                 return -EBUSY;
         }
 
diff --git a/sound/pci/trident/trident_main.c b/sound/pci/trident/trident_main.c
index 4f3c4be30a48..1272c18a2544 100644
--- a/sound/pci/trident/trident_main.c
+++ b/sound/pci/trident/trident_main.c
@@ -69,40 +69,40 @@ static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)
 {
         unsigned int val, tmp;
 
-        printk(KERN_DEBUG "Trident voice %i:\n", voice);
+        dev_dbg(trident->card->dev, "Trident voice %i:\n", voice);
         outb(voice, TRID_REG(trident, T4D_LFO_GC_CIR));
         val = inl(TRID_REG(trident, CH_LBA));
-        printk(KERN_DEBUG "LBA: 0x%x\n", val);
+        dev_dbg(trident->card->dev, "LBA: 0x%x\n", val);
         val = inl(TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
-        printk(KERN_DEBUG "GVSel: %i\n", val >> 31);
-        printk(KERN_DEBUG "Pan: 0x%x\n", (val >> 24) & 0x7f);
-        printk(KERN_DEBUG "Vol: 0x%x\n", (val >> 16) & 0xff);
-        printk(KERN_DEBUG "CTRL: 0x%x\n", (val >> 12) & 0x0f);
-        printk(KERN_DEBUG "EC: 0x%x\n", val & 0x0fff);
+        dev_dbg(trident->card->dev, "GVSel: %i\n", val >> 31);
+        dev_dbg(trident->card->dev, "Pan: 0x%x\n", (val >> 24) & 0x7f);
+        dev_dbg(trident->card->dev, "Vol: 0x%x\n", (val >> 16) & 0xff);
+        dev_dbg(trident->card->dev, "CTRL: 0x%x\n", (val >> 12) & 0x0f);
+        dev_dbg(trident->card->dev, "EC: 0x%x\n", val & 0x0fff);
         if (trident->device != TRIDENT_DEVICE_ID_NX) {
                 val = inl(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS));
-                printk(KERN_DEBUG "CSO: 0x%x\n", val >> 16);
-                printk("Alpha: 0x%x\n", (val >> 4) & 0x0fff);
-                printk(KERN_DEBUG "FMS: 0x%x\n", val & 0x0f);
+                dev_dbg(trident->card->dev, "CSO: 0x%x\n", val >> 16);
+                dev_dbg(trident->card->dev, "Alpha: 0x%x\n", (val >> 4) & 0x0fff);
+                dev_dbg(trident->card->dev, "FMS: 0x%x\n", val & 0x0f);
                 val = inl(TRID_REG(trident, CH_DX_ESO_DELTA));
-                printk(KERN_DEBUG "ESO: 0x%x\n", val >> 16);
-                printk(KERN_DEBUG "Delta: 0x%x\n", val & 0xffff);
+                dev_dbg(trident->card->dev, "ESO: 0x%x\n", val >> 16);
+                dev_dbg(trident->card->dev, "Delta: 0x%x\n", val & 0xffff);
                 val = inl(TRID_REG(trident, CH_DX_FMC_RVOL_CVOL));
         } else {                // TRIDENT_DEVICE_ID_NX
                 val = inl(TRID_REG(trident, CH_NX_DELTA_CSO));
                 tmp = (val >> 24) & 0xff;
-                printk(KERN_DEBUG "CSO: 0x%x\n", val & 0x00ffffff);
+                dev_dbg(trident->card->dev, "CSO: 0x%x\n", val & 0x00ffffff);
                 val = inl(TRID_REG(trident, CH_NX_DELTA_ESO));
                 tmp |= (val >> 16) & 0xff00;
-                printk(KERN_DEBUG "Delta: 0x%x\n", tmp);
-                printk(KERN_DEBUG "ESO: 0x%x\n", val & 0x00ffffff);
+                dev_dbg(trident->card->dev, "Delta: 0x%x\n", tmp);
+                dev_dbg(trident->card->dev, "ESO: 0x%x\n", val & 0x00ffffff);
                 val = inl(TRID_REG(trident, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL));
-                printk(KERN_DEBUG "Alpha: 0x%x\n", val >> 20);
-                printk(KERN_DEBUG "FMS: 0x%x\n", (val >> 16) & 0x0f);
+                dev_dbg(trident->card->dev, "Alpha: 0x%x\n", val >> 20);
+                dev_dbg(trident->card->dev, "FMS: 0x%x\n", (val >> 16) & 0x0f);
         }
-        printk(KERN_DEBUG "FMC: 0x%x\n", (val >> 14) & 3);
-        printk(KERN_DEBUG "RVol: 0x%x\n", (val >> 7) & 0x7f);
-        printk(KERN_DEBUG "CVol: 0x%x\n", val & 0x7f);
+        dev_dbg(trident->card->dev, "FMC: 0x%x\n", (val >> 14) & 3);
+        dev_dbg(trident->card->dev, "RVol: 0x%x\n", (val >> 7) & 0x7f);
+        dev_dbg(trident->card->dev, "CVol: 0x%x\n", val & 0x7f);
 }
 #endif
 
@@ -156,7 +156,8 @@ static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned sho
         }
 
         if (count == 0 && !trident->ac97_detect) {
-                snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
+                dev_err(trident->card->dev,
+                        "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
                            reg, data);
                 data = 0;
         }
@@ -497,16 +498,16 @@ void snd_trident_write_voice_regs(struct snd_trident * trident,
         outl(regs[4], TRID_REG(trident, CH_START + 16));
 
 #if 0
-        printk(KERN_DEBUG "written %i channel:\n", voice->number);
-        printk(KERN_DEBUG "  regs[0] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "written %i channel:\n", voice->number);
+        dev_dbg(trident->card->dev, "  regs[0] = 0x%x/0x%x\n",
                regs[0], inl(TRID_REG(trident, CH_START + 0)));
-        printk(KERN_DEBUG "  regs[1] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "  regs[1] = 0x%x/0x%x\n",
                regs[1], inl(TRID_REG(trident, CH_START + 4)));
-        printk(KERN_DEBUG "  regs[2] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "  regs[2] = 0x%x/0x%x\n",
                regs[2], inl(TRID_REG(trident, CH_START + 8)));
-        printk(KERN_DEBUG "  regs[3] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "  regs[3] = 0x%x/0x%x\n",
                regs[3], inl(TRID_REG(trident, CH_START + 12)));
-        printk(KERN_DEBUG "  regs[4] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "  regs[4] = 0x%x/0x%x\n",
                regs[4], inl(TRID_REG(trident, CH_START + 16)));
 #endif
 }
@@ -589,7 +590,7 @@ static void snd_trident_write_vol_reg(struct snd_trident * trident,
                 outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
                 break;
         case TRIDENT_DEVICE_ID_SI7018:
-                /* printk(KERN_DEBUG "voice->Vol = 0x%x\n", voice->Vol); */
+                /* dev_dbg(trident->card->dev, "voice->Vol = 0x%x\n", voice->Vol); */
                 outw((voice->CTRL << 12) | voice->Vol,
                      TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
                 break;
@@ -3013,13 +3014,15 @@ static int snd_trident_mixer(struct snd_trident *trident, int pcm_spdif_device)
                 _ac97.num = 1;
                 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
                 if (err < 0)
-                        snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n");
+                        dev_err(trident->card->dev,
+                                "SI7018: the secondary codec - invalid access\n");
 #if 0   // only for my testing purpose --jk
                 {
                         struct snd_ac97 *mc97;
                         err = snd_ac97_modem(trident->card, &_ac97, &mc97);
                         if (err < 0)
-                                snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err);
+                                dev_err(trident->card->dev,
+                                        "snd_ac97_modem returned error %i\n", err);
                 }
 #endif
         }
@@ -3197,7 +3200,8 @@ int snd_trident_create_gameport(struct snd_trident *chip)
 
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "trident: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
 
@@ -3270,7 +3274,8 @@ static int snd_trident_sis_reset(struct snd_trident *trident)
                         goto __si7018_ok;
                 do_delay(trident);
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
+        dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
+                inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
         if (r-- > 0) {
                 end_time = jiffies + HZ;
                 do {
@@ -3367,7 +3372,7 @@ static int snd_trident_tlb_alloc(struct snd_trident *trident)
 
         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
                                 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
-                snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n");
+                dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
                 return -ENOMEM;
         }
         trident->tlb.entries = (unsigned int*)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
@@ -3375,13 +3380,14 @@ static int snd_trident_tlb_alloc(struct snd_trident *trident)
         /* allocate shadow TLB page table (virtual addresses) */
         trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long));
         if (trident->tlb.shadow_entries == NULL) {
-                snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n");
+                dev_err(trident->card->dev,
+                        "unable to allocate shadow TLB entries\n");
                 return -ENOMEM;
         }
         /* allocate and setup silent page and initialise TLB entries */
         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
                                 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
-                snd_printk(KERN_ERR "trident: unable to allocate silent page\n");
+                dev_err(trident->card->dev, "unable to allocate silent page\n");
                 return -ENOMEM;
         }
         memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE);
@@ -3439,7 +3445,7 @@ static int snd_trident_4d_dx_init(struct snd_trident *trident)
                         goto __dx_ok;
                 do_delay(trident);
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR "AC'97 codec ready error\n");
+        dev_err(trident->card->dev, "AC'97 codec ready error\n");
         return -EIO;
 
  __dx_ok:
@@ -3477,7 +3483,8 @@ static int snd_trident_4d_nx_init(struct snd_trident *trident)
                         goto __nx_ok;
                 do_delay(trident);
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
+        dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
+                inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
         return -EIO;
 
  __nx_ok:
@@ -3562,7 +3569,8 @@ int snd_trident_create(struct snd_card *card,
         /* check, if we can restrict PCI DMA transfers to 30 bits */
         if (pci_set_dma_mask(pci, DMA_BIT_MASK(30)) < 0 ||
             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(30)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n");
+                dev_err(card->dev,
+                        "architecture does not support 30bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
         }
@@ -3600,7 +3608,7 @@ int snd_trident_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, trident)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_trident_free(trident);
                 return -EBUSY;
         }
@@ -3949,8 +3957,7 @@ static int snd_trident_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "trident: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index 20d2eeeecf47..95b98f537b67 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -459,7 +459,7 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
                         unsigned int addr;
 
                         if (idx >= VIA_TABLE_SIZE) {
-                                snd_printk(KERN_ERR "via82xx: too much table size!\n");
+                                dev_err(&pci->dev, "too much table size!\n");
                                 return -EINVAL;
                         }
                         addr = snd_pcm_sgbuf_get_addr(substream, ofs);
@@ -474,8 +474,9 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
                         } else
                                 flag = 0; /* period continues to the next */
                         /*
-                        printk(KERN_DEBUG "via: tbl %d: at %d  size %d "
-                               "(rest %d)\n", idx, ofs, r, rest);
+                        dev_dbg(&pci->dev,
+                                "tbl %d: at %d  size %d (rest %d)\n",
+                                idx, ofs, r, rest);
                         */
                         ((u32 *)dev->table.area)[(idx<<1) + 1] = cpu_to_le32(r | flag);
                         dev->idx_table[idx].offset = ofs;
@@ -528,7 +529,7 @@ static int snd_via82xx_codec_ready(struct via82xx *chip, int secondary)
                 if (!((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY))
                         return val & 0xffff;
         }
-        snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n",
+        dev_err(chip->card->dev, "codec_ready: codec %i is not ready [0x%x]\n",
                    secondary, snd_via82xx_codec_xread(chip));
         return -EIO;
 }
@@ -587,7 +588,8 @@ static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned sho
         xval |= (reg & 0x7f) << VIA_REG_AC97_CMD_SHIFT;
         while (1) {
                 if (again++ > 3) {
-                        snd_printk(KERN_ERR "codec_read: codec %i is not valid [0x%x]\n",
+                        dev_err(chip->card->dev,
+                                "codec_read: codec %i is not valid [0x%x]\n",
                                    ac97->num, snd_via82xx_codec_xread(chip));
                         return 0xffff;
                 }
@@ -777,7 +779,9 @@ static int snd_via82xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         ((pos) < viadev->lastpos && ((pos) >= viadev->bufsize2 ||\
                                      viadev->lastpos < viadev->bufsize2))
 
-static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int idx,
+static inline unsigned int calc_linear_pos(struct via82xx *chip,
+                                           struct viadev *viadev,
+                                           unsigned int idx,
                                            unsigned int count)
 {
         unsigned int size, base, res;
@@ -790,7 +794,8 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i
 
         /* check the validity of the calculated position */
         if (size < count) {
-                snd_printd(KERN_ERR "invalid via82xx_cur_ptr (size = %d, count = %d)\n",
+                dev_dbg(chip->card->dev,
+                        "invalid via82xx_cur_ptr (size = %d, count = %d)\n",
                            (int)size, (int)count);
                 res = viadev->lastpos;
         } else {
@@ -807,9 +812,9 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i
                 }
                 if (check_invalid_pos(viadev, res)) {
 #ifdef POINTER_DEBUG
-                        printk(KERN_DEBUG "fail: idx = %i/%i, lastpos = 0x%x, "
-                               "bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, "
-                               "count = 0x%x\n", idx, viadev->tbl_entries,
+                        dev_dbg(chip->card->dev,
+                                "fail: idx = %i/%i, lastpos = 0x%x, bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, count = 0x%x\n",
+                                idx, viadev->tbl_entries,
                                viadev->lastpos, viadev->bufsize2,
                                viadev->idx_table[idx].offset,
                                viadev->idx_table[idx].size, count);
@@ -817,8 +822,8 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i
                         /* count register returns full size when end of buffer is reached */
                         res = base + size;
                         if (check_invalid_pos(viadev, res)) {
-                                snd_printd(KERN_ERR "invalid via82xx_cur_ptr (2), "
-                                           "using last valid pointer\n");
+                                dev_dbg(chip->card->dev,
+                                        "invalid via82xx_cur_ptr (2), using last valid pointer\n");
                                 res = viadev->lastpos;
                         }
                 }
@@ -850,7 +855,7 @@ static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substr
                 idx = 0;
         else /* CURR_PTR holds the address + 8 */
                 idx = ((ptr - (unsigned int)viadev->table.addr) / 8 - 1) % viadev->tbl_entries;
-        res = calc_linear_pos(viadev, idx, count);
+        res = calc_linear_pos(chip, viadev, idx, count);
         viadev->lastpos = res; /* remember the last position */
         spin_unlock(&chip->reg_lock);
 
@@ -889,13 +894,14 @@ static snd_pcm_uframes_t snd_via8233_pcm_pointer(struct snd_pcm_substream *subst
                 idx = count >> 24;
                 if (idx >= viadev->tbl_entries) {
 #ifdef POINTER_DEBUG
-                        printk(KERN_DEBUG "fail: invalid idx = %i/%i\n", idx,
+                        dev_dbg(chip->card->dev,
+                                "fail: invalid idx = %i/%i\n", idx,
                                viadev->tbl_entries);
 #endif
                         res = viadev->lastpos;
                 } else {
                         count &= 0xffffff;
-                        res = calc_linear_pos(viadev, idx, count);
+                        res = calc_linear_pos(chip, viadev, idx, count);
                 }
         } else {
                 res = viadev->hwptr_done;
@@ -1940,14 +1946,15 @@ static int snd_via686_create_gameport(struct via82xx *chip, unsigned char *legac
 
         r = request_region(JOYSTICK_ADDR, 8, "VIA686 gameport");
         if (!r) {
-                printk(KERN_WARNING "via82xx: cannot reserve joystick port %#x\n",
+                dev_warn(chip->card->dev, "cannot reserve joystick port %#x\n",
                        JOYSTICK_ADDR);
                 return -EBUSY;
         }
 
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "via82xx: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 release_and_free_resource(r);
                 return -ENOMEM;
         }
@@ -2016,7 +2023,8 @@ static int snd_via8233_init_misc(struct via82xx *chip)
                 strcpy(sid.name, "PCM Playback Volume");
                 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
                 if (! snd_ctl_find_id(chip->card, &sid)) {
-                        snd_printd(KERN_INFO "Using DXS as PCM Playback\n");
+                        dev_info(chip->card->dev,
+                                 "Using DXS as PCM Playback\n");
                         err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_via8233_pcmdxs_volume_control, chip));
                         if (err < 0)
                                 return err;
@@ -2102,8 +2110,9 @@ static int snd_via686_init_misc(struct via82xx *chip)
                                         mpu_port, MPU401_INFO_INTEGRATED |
                                         MPU401_INFO_IRQ_HOOK, -1,
                                         &chip->rmidi) < 0) {
-                        printk(KERN_WARNING "unable to initialize MPU-401"
-                               " at 0x%lx, skipping\n", mpu_port);
+                        dev_warn(chip->card->dev,
+                                 "unable to initialize MPU-401 at 0x%lx, skipping\n",
+                                 mpu_port);
                         legacy &= ~VIA_FUNC_ENABLE_MIDI;
                 } else {
                         legacy &= ~VIA_FUNC_MIDI_IRQMASK;       /* enable MIDI interrupt */
@@ -2203,7 +2212,8 @@ static int snd_via82xx_chip_init(struct via82xx *chip)
         } while (time_before(jiffies, end_time));
 
         if ((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY)
-                snd_printk(KERN_ERR "AC'97 codec is not ready [0x%x]\n", val);
+                dev_err(chip->card->dev,
+                        "AC'97 codec is not ready [0x%x]\n", val);
 
 #if 0 /* FIXME: we don't support the second codec yet so skip the detection now.. */
         snd_via82xx_codec_xwrite(chip, VIA_REG_AC97_READ |
@@ -2303,8 +2313,7 @@ static int snd_via82xx_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "via82xx: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2417,7 +2426,7 @@ static int snd_via82xx_create(struct snd_card *card,
                         snd_via8233_interrupt : snd_via686_interrupt,
                         IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_via82xx_free(chip);
                 return -EBUSY;
         }
@@ -2514,7 +2523,7 @@ static int check_dxs_list(struct pci_dev *pci, int revision)
 
         w = snd_pci_quirk_lookup(pci, dxs_whitelist);
         if (w) {
-                snd_printdd(KERN_INFO "via82xx: DXS white list for %s found\n",
+                dev_dbg(&pci->dev, "DXS white list for %s found\n",
                             snd_pci_quirk_name(w));
                 return w->value;
         }
@@ -2526,10 +2535,10 @@ static int check_dxs_list(struct pci_dev *pci, int revision)
         /*
          * not detected, try 48k rate only to be sure.
          */
-        printk(KERN_INFO "via82xx: Assuming DXS channels with 48k fixed sample rate.\n");
-        printk(KERN_INFO "         Please try dxs_support=5 option\n");
-        printk(KERN_INFO "         and report if it works on your machine.\n");
-        printk(KERN_INFO "         For more details, read ALSA-Configuration.txt.\n");
+        dev_info(&pci->dev, "Assuming DXS channels with 48k fixed sample rate.\n");
+        dev_info(&pci->dev, "         Please try dxs_support=5 option\n");
+        dev_info(&pci->dev, "         and report if it works on your machine.\n");
+        dev_info(&pci->dev, "         For more details, read ALSA-Configuration.txt.\n");
         return VIA_DXS_48K;
 };
 
@@ -2582,7 +2591,7 @@ static int snd_via82xx_probe(struct pci_dev *pci,
                         strcpy(card->driver, "VIA8233");
                 break;
         default:
-                snd_printk(KERN_ERR "invalid card type %d\n", card_type);
+                dev_err(card->dev, "invalid card type %d\n", card_type);
                 err = -EINVAL;
                 goto __error;
         }
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index 519740154824..46a0526b1d79 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -312,7 +312,7 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
                         unsigned int addr;
 
                         if (idx >= VIA_TABLE_SIZE) {
-                                snd_printk(KERN_ERR "via82xx: too much table size!\n");
+                                dev_err(&pci->dev, "too much table size!\n");
                                 return -EINVAL;
                         }
                         addr = snd_pcm_sgbuf_get_addr(substream, ofs);
@@ -329,8 +329,9 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
                         } else
                                 flag = 0; /* period continues to the next */
                         /*
-                        printk(KERN_DEBUG "via: tbl %d: at %d  size %d "
-                               "(rest %d)\n", idx, ofs, r, rest);
+                        dev_dbg(&pci->dev,
+                                "tbl %d: at %d  size %d (rest %d)\n",
+                                idx, ofs, r, rest);
                         */
                         ((u32 *)dev->table.area)[(idx<<1) + 1] = cpu_to_le32(r | flag);
                         dev->idx_table[idx].offset = ofs;
@@ -382,7 +383,7 @@ static int snd_via82xx_codec_ready(struct via82xx_modem *chip, int secondary)
                 if (!((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY))
                         return val & 0xffff;
         }
-        snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n",
+        dev_err(chip->card->dev, "codec_ready: codec %i is not ready [0x%x]\n",
                    secondary, snd_via82xx_codec_xread(chip));
         return -EIO;
 }
@@ -443,7 +444,8 @@ static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned sho
         xval |= (reg & 0x7f) << VIA_REG_AC97_CMD_SHIFT;
         while (1) {
                 if (again++ > 3) {
-                        snd_printk(KERN_ERR "codec_read: codec %i is not valid [0x%x]\n",
+                        dev_err(chip->card->dev,
+                                "codec_read: codec %i is not valid [0x%x]\n",
                                    ac97->num, snd_via82xx_codec_xread(chip));
                         return 0xffff;
                 }
@@ -560,7 +562,9 @@ static int snd_via82xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         ((pos) < viadev->lastpos && ((pos) >= viadev->bufsize2 ||\
                                      viadev->lastpos < viadev->bufsize2))
 
-static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int idx,
+static inline unsigned int calc_linear_pos(struct via82xx_modem *chip,
+                                           struct viadev *viadev,
+                                           unsigned int idx,
                                            unsigned int count)
 {
         unsigned int size, res;
@@ -570,20 +574,21 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i
 
         /* check the validity of the calculated position */
         if (size < count) {
-                snd_printd(KERN_ERR "invalid via82xx_cur_ptr (size = %d, count = %d)\n",
+                dev_err(chip->card->dev,
+                        "invalid via82xx_cur_ptr (size = %d, count = %d)\n",
                            (int)size, (int)count);
                 res = viadev->lastpos;
         } else if (check_invalid_pos(viadev, res)) {
 #ifdef POINTER_DEBUG
-                printk(KERN_DEBUG "fail: idx = %i/%i, lastpos = 0x%x, "
-                       "bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, "
-                       "count = 0x%x\n", idx, viadev->tbl_entries, viadev->lastpos,
+                dev_dbg(chip->card->dev,
+                        "fail: idx = %i/%i, lastpos = 0x%x, bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, count = 0x%x\n",
+                        idx, viadev->tbl_entries, viadev->lastpos,
                        viadev->bufsize2, viadev->idx_table[idx].offset,
                        viadev->idx_table[idx].size, count);
 #endif
                 if (count && size < count) {
-                        snd_printd(KERN_ERR "invalid via82xx_cur_ptr, "
-                                   "using last valid pointer\n");
+                        dev_dbg(chip->card->dev,
+                                "invalid via82xx_cur_ptr, using last valid pointer\n");
                         res = viadev->lastpos;
                 } else {
                         if (! count)
@@ -595,8 +600,8 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i
                                  */
                                 res = viadev->idx_table[idx].offset + size;
                         if (check_invalid_pos(viadev, res)) {
-                                snd_printd(KERN_ERR "invalid via82xx_cur_ptr (2), "
-                                           "using last valid pointer\n");
+                                dev_dbg(chip->card->dev,
+                                        "invalid via82xx_cur_ptr (2), using last valid pointer\n");
                                 res = viadev->lastpos;
                         }
                 }
@@ -632,7 +637,7 @@ static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substr
         else /* CURR_PTR holds the address + 8 */
                 idx = ((ptr - (unsigned int)viadev->table.addr) / 8 - 1) %
                         viadev->tbl_entries;
-        res = calc_linear_pos(viadev, idx, count);
+        res = calc_linear_pos(chip, viadev, idx, count);
         spin_unlock(&chip->reg_lock);
 
         return bytes_to_frames(substream->runtime, res);
@@ -991,7 +996,8 @@ static int snd_via82xx_chip_init(struct via82xx_modem *chip)
         } while (time_before(jiffies, end_time));
 
         if ((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY)
-                snd_printk(KERN_ERR "AC'97 codec is not ready [0x%x]\n", val);
+                dev_err(chip->card->dev,
+                        "AC'97 codec is not ready [0x%x]\n", val);
 
         snd_via82xx_codec_xwrite(chip, VIA_REG_AC97_READ |
                                  VIA_REG_AC97_SECONDARY_VALID |
@@ -1054,8 +1060,7 @@ static int snd_via82xx_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "via82xx-modem: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -1137,7 +1142,7 @@ static int snd_via82xx_create(struct snd_card *card,
         chip->port = pci_resource_start(pci, 0);
         if (request_irq(pci->irq, snd_via82xx_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_via82xx_free(chip);
                 return -EBUSY;
         }
@@ -1186,7 +1191,7 @@ static int snd_via82xx_probe(struct pci_dev *pci,
                 sprintf(card->shortname, "VIA 82XX modem");
                 break;
         default:
-                snd_printk(KERN_ERR "invalid card type %d\n", card_type);
+                dev_err(card->dev, "invalid card type %d\n", card_type);
                 err = -EINVAL;
                 goto __error;
         }
diff --git a/sound/pci/vx222/vx222.c b/sound/pci/vx222/vx222.c
index 4323556c13f8..ff9074d22607 100644
--- a/sound/pci/vx222/vx222.c
+++ b/sound/pci/vx222/vx222.c
@@ -170,7 +170,7 @@ static int snd_vx222_create(struct snd_card *card, struct pci_dev *pci,
 
         if (request_irq(pci->irq, snd_vx_irq_handler, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_vx222_free(chip);
                 return -EBUSY;
         }
@@ -228,7 +228,7 @@ static int snd_vx222_probe(struct pci_dev *pci,
 
         sprintf(card->longname, "%s at 0x%lx & 0x%lx, irq %i",
                 card->shortname, vx->port[0], vx->port[1], vx->core.irq);
-        snd_printdd("%s at 0x%lx & 0x%lx, irq %i\n",
+        dev_dbg(card->dev, "%s at 0x%lx & 0x%lx, irq %i\n",
                     card->shortname, vx->port[0], vx->port[1], vx->core.irq);
 
 #ifdef SND_VX_FW_LOADER
@@ -279,8 +279,7 @@ static int snd_vx222_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "vx222: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
diff --git a/sound/pci/vx222/vx222_ops.c b/sound/pci/vx222/vx222_ops.c
index a69e774d0b13..2d1570273e99 100644
--- a/sound/pci/vx222/vx222_ops.c
+++ b/sound/pci/vx222/vx222_ops.c
@@ -108,7 +108,7 @@ static void vx2_outb(struct vx_core *chip, int offset, unsigned char val)
 {
         outb(val, vx2_reg_addr(chip, offset));
         /*
-        printk(KERN_DEBUG "outb: %x -> %x\n", val, vx2_reg_addr(chip, offset));
+        dev_dbg(chip->card->dev, "outb: %x -> %x\n", val, vx2_reg_addr(chip, offset));
         */
 }
 
@@ -129,7 +129,7 @@ static unsigned int vx2_inl(struct vx_core *chip, int offset)
 static void vx2_outl(struct vx_core *chip, int offset, unsigned int val)
 {
         /*
-        printk(KERN_DEBUG "outl: %x -> %x\n", val, vx2_reg_addr(chip, offset));
+        dev_dbg(chip->card->dev, "outl: %x -> %x\n", val, vx2_reg_addr(chip, offset));
         */
         outl(val, vx2_reg_addr(chip, offset));
 }
@@ -173,7 +173,7 @@ static int vx2_test_xilinx(struct vx_core *_chip)
         struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
         unsigned int data;
 
-        snd_printdd("testing xilinx...\n");
+        dev_dbg(_chip->card->dev, "testing xilinx...\n");
         /* This test uses several write/read sequences on TEST0 and TEST1 bits
          * to figure out whever or not the xilinx was correctly loaded
          */
@@ -183,7 +183,7 @@ static int vx2_test_xilinx(struct vx_core *_chip)
         vx_inl(chip, ISR);
         data = vx_inl(chip, STATUS);
         if ((data & VX_STATUS_VAL_TEST0_MASK) == VX_STATUS_VAL_TEST0_MASK) {
-                snd_printdd("bad!\n");
+                dev_dbg(_chip->card->dev, "bad!\n");
                 return -ENODEV;
         }
 
@@ -192,7 +192,7 @@ static int vx2_test_xilinx(struct vx_core *_chip)
         vx_inl(chip, ISR);
         data = vx_inl(chip, STATUS);
         if (! (data & VX_STATUS_VAL_TEST0_MASK)) {
-                snd_printdd("bad! #2\n");
+                dev_dbg(_chip->card->dev, "bad! #2\n");
                 return -ENODEV;
         }
 
@@ -203,7 +203,7 @@ static int vx2_test_xilinx(struct vx_core *_chip)
                 vx_inl(chip, ISR);
                 data = vx_inl(chip, STATUS);
                 if ((data & VX_STATUS_VAL_TEST1_MASK) == VX_STATUS_VAL_TEST1_MASK) {
-                        snd_printdd("bad! #3\n");
+                        dev_dbg(_chip->card->dev, "bad! #3\n");
                         return -ENODEV;
                 }
 
@@ -212,11 +212,11 @@ static int vx2_test_xilinx(struct vx_core *_chip)
                 vx_inl(chip, ISR);
                 data = vx_inl(chip, STATUS);
                 if (! (data & VX_STATUS_VAL_TEST1_MASK)) {
-                        snd_printdd("bad! #4\n");
+                        dev_dbg(_chip->card->dev, "bad! #4\n");
                         return -ENODEV;
                 }
         }
-        snd_printdd("ok, xilinx fine.\n");
+        dev_dbg(_chip->card->dev, "ok, xilinx fine.\n");
         return 0;
 }
 
@@ -397,7 +397,8 @@ static int vx2_load_xilinx_binary(struct vx_core *chip, const struct firmware *x
                 i = vx_inl(chip, GPIOC);
                 if (i & 0x0100)
                         return 0;
-                snd_printk(KERN_ERR "vx222: xilinx test failed after load, GPIOC=0x%x\n", i);
+                dev_err(chip->card->dev,
+                        "xilinx test failed after load, GPIOC=0x%x\n", i);
                 return -EINVAL;
         }
 
diff --git a/sound/pci/ymfpci/ymfpci.c b/sound/pci/ymfpci/ymfpci.c
index 6ff4ea389b02..82eed164b275 100644
--- a/sound/pci/ymfpci/ymfpci.c
+++ b/sound/pci/ymfpci/ymfpci.c
@@ -106,7 +106,8 @@ static int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev,
                                         break;
                         }
                         if (!r) {
-                                printk(KERN_ERR "ymfpci: no gameport ports available\n");
+                                dev_err(chip->card->dev,
+                                        "no gameport ports available\n");
                                 return -EBUSY;
                         }
                 }
@@ -116,19 +117,22 @@ static int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev,
                 case 0x204: legacy_ctrl2 |= 2 << 6; break;
                 case 0x205: legacy_ctrl2 |= 3 << 6; break;
                 default:
-                        printk(KERN_ERR "ymfpci: invalid joystick port %#x", io_port);
+                        dev_err(chip->card->dev,
+                                "invalid joystick port %#x", io_port);
                         return -EINVAL;
                 }
         }
 
         if (!r && !(r = request_region(io_port, 1, "YMFPCI gameport"))) {
-                printk(KERN_ERR "ymfpci: joystick port %#x is in use.\n", io_port);
+                dev_err(chip->card->dev,
+                        "joystick port %#x is in use.\n", io_port);
                 return -EBUSY;
         }
 
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "ymfpci: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 release_and_free_resource(r);
                 return -ENOMEM;
         }
@@ -314,7 +318,9 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci,
                                                MPU401_INFO_INTEGRATED |
                                                MPU401_INFO_IRQ_HOOK,
                                                -1, &chip->rawmidi)) < 0) {
-                        printk(KERN_WARNING "ymfpci: cannot initialize MPU401 at 0x%lx, skipping...\n", mpu_port[dev]);
+                        dev_warn(card->dev,
+                                 "cannot initialize MPU401 at 0x%lx, skipping...\n",
+                                 mpu_port[dev]);
                         legacy_ctrl &= ~YMFPCI_LEGACY_MIEN; /* disable MPU401 irq */
                         pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl);
                 }
@@ -324,12 +330,14 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci,
                                            fm_port[dev],
                                            fm_port[dev] + 2,
                                            OPL3_HW_OPL3, 1, &opl3)) < 0) {
-                        printk(KERN_WARNING "ymfpci: cannot initialize FM OPL3 at 0x%lx, skipping...\n", fm_port[dev]);
+                        dev_warn(card->dev,
+                                 "cannot initialize FM OPL3 at 0x%lx, skipping...\n",
+                                 fm_port[dev]);
                         legacy_ctrl &= ~YMFPCI_LEGACY_FMEN;
                         pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl);
                 } else if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
                         snd_card_free(card);
-                        snd_printk(KERN_ERR "cannot create opl3 hwdep\n");
+                        dev_err(card->dev, "cannot create opl3 hwdep\n");
                         return err;
                 }
         }
diff --git a/sound/pci/ymfpci/ymfpci_main.c b/sound/pci/ymfpci/ymfpci_main.c
index c7e98ff4f80f..81c916a5eb96 100644
--- a/sound/pci/ymfpci/ymfpci_main.c
+++ b/sound/pci/ymfpci/ymfpci_main.c
@@ -86,7 +86,9 @@ static int snd_ymfpci_codec_ready(struct snd_ymfpci *chip, int secondary)
                         return 0;
                 schedule_timeout_uninterruptible(1);
         } while (time_before(jiffies, end_time));
-        snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n", secondary, snd_ymfpci_readw(chip, reg));
+        dev_err(chip->card->dev,
+                "codec_ready: codec %i is not ready [0x%x]\n",
+                secondary, snd_ymfpci_readw(chip, reg));
         return -EBUSY;
 }
 
@@ -319,7 +321,7 @@ static void snd_ymfpci_pcm_interrupt(struct snd_ymfpci *chip, struct snd_ymfpci_
                 ypcm->last_pos = pos;
                 if (ypcm->period_pos >= ypcm->period_size) {
                         /*
-                        printk(KERN_DEBUG
+                        dev_dbg(chip->card->dev,
                                "done - active_bank = 0x%x, start = 0x%x\n",
                                chip->active_bank,
                                voice->bank[chip->active_bank].start);
@@ -372,7 +374,7 @@ static void snd_ymfpci_pcm_capture_interrupt(struct snd_pcm_substream *substream
                 if (ypcm->period_pos >= ypcm->period_size) {
                         ypcm->period_pos %= ypcm->period_size;
                         /*
-                        printk(KERN_DEBUG
+                        dev_dbg(chip->card->dev,
                                "done - active_bank = 0x%x, start = 0x%x\n",
                                chip->active_bank,
                                voice->bank[chip->active_bank].start);
@@ -2067,7 +2069,8 @@ static int snd_ymfpci_request_firmware(struct snd_ymfpci *chip)
                                &chip->pci->dev);
         if (err >= 0) {
                 if (chip->dsp_microcode->size != YDSXG_DSPLENGTH) {
-                        snd_printk(KERN_ERR "DSP microcode has wrong size\n");
+                        dev_err(chip->card->dev,
+                                "DSP microcode has wrong size\n");
                         err = -EINVAL;
                 }
         }
@@ -2082,8 +2085,8 @@ static int snd_ymfpci_request_firmware(struct snd_ymfpci *chip)
                                &chip->pci->dev);
         if (err >= 0) {
                 if (chip->controller_microcode->size != YDSXG_CTRLLENGTH) {
-                        snd_printk(KERN_ERR "controller microcode"
-                                   " has wrong size\n");
+                        dev_err(chip->card->dev,
+                                "controller microcode has wrong size\n");
                         err = -EINVAL;
                 }
         }
@@ -2360,8 +2363,7 @@ static int snd_ymfpci_resume(struct device *dev)
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "ymfpci: pci_enable_device failed, "
-                       "disabling device\n");
+                dev_err(dev, "pci_enable_device failed, disabling device\n");
                 snd_card_disconnect(card);
                 return -EIO;
         }
@@ -2433,13 +2435,15 @@ int snd_ymfpci_create(struct snd_card *card,
         chip->src441_used = -1;
 
         if ((chip->res_reg_area = request_mem_region(chip->reg_area_phys, 0x8000, "YMFPCI")) == NULL) {
-                snd_printk(KERN_ERR "unable to grab memory region 0x%lx-0x%lx\n", chip->reg_area_phys, chip->reg_area_phys + 0x8000 - 1);
+                dev_err(chip->card->dev,
+                        "unable to grab memory region 0x%lx-0x%lx\n",
+                        chip->reg_area_phys, chip->reg_area_phys + 0x8000 - 1);
                 snd_ymfpci_free(chip);
                 return -EBUSY;
         }
         if (request_irq(pci->irq, snd_ymfpci_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_ymfpci_free(chip);
                 return -EBUSY;
         }
@@ -2453,7 +2457,7 @@ int snd_ymfpci_create(struct snd_card *card,
 
         err = snd_ymfpci_request_firmware(chip);
         if (err < 0) {
-                snd_printk(KERN_ERR "firmware request failed: %d\n", err);
+                dev_err(chip->card->dev, "firmware request failed: %d\n", err);
                 snd_ymfpci_free(chip);
                 return err;
         }
diff --git a/sound/usb/6fire/chip.c b/sound/usb/6fire/chip.c
index e0fe0d92db8c..dcddfc354ba6 100644
--- a/sound/usb/6fire/chip.c
+++ b/sound/usb/6fire/chip.c
@@ -106,7 +106,7 @@ static int usb6fire_chip_probe(struct usb_interface *intf,
         }
         if (regidx < 0) {
                 mutex_unlock(&register_mutex);
-                snd_printk(KERN_ERR PREFIX "too many cards registered.\n");
+                dev_err(&intf->dev, "too many cards registered.\n");
                 return -ENODEV;
         }
         devices[regidx] = device;
@@ -121,13 +121,13 @@ static int usb6fire_chip_probe(struct usb_interface *intf,
 
         /* if we are here, card can be registered in alsa. */
         if (usb_set_interface(device, 0, 0) != 0) {
-                snd_printk(KERN_ERR PREFIX "can't set first interface.\n");
+                dev_err(&intf->dev, "can't set first interface.\n");
                 return -EIO;
         }
         ret = snd_card_new(&intf->dev, index[regidx], id[regidx],
                            THIS_MODULE, sizeof(struct sfire_chip), &card);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "cannot create alsa card.\n");
+                dev_err(&intf->dev, "cannot create alsa card.\n");
                 return ret;
         }
         strcpy(card->driver, "6FireUSB");
@@ -168,7 +168,7 @@ static int usb6fire_chip_probe(struct usb_interface *intf,
 
         ret = snd_card_register(card);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "cannot register card.");
+                dev_err(&intf->dev, "cannot register card.");
                 usb6fire_chip_destroy(chip);
                 return ret;
         }
diff --git a/sound/usb/6fire/comm.c b/sound/usb/6fire/comm.c
index 23452ee617e1..161215d78d95 100644
--- a/sound/usb/6fire/comm.c
+++ b/sound/usb/6fire/comm.c
@@ -51,7 +51,7 @@ static void usb6fire_comm_receiver_handler(struct urb *urb)
                 urb->status = 0;
                 urb->actual_length = 0;
                 if (usb_submit_urb(urb, GFP_ATOMIC) < 0)
-                        snd_printk(KERN_WARNING PREFIX
+                        dev_warn(&urb->dev->dev,
                                         "comm data receiver aborted.\n");
         }
 }
@@ -179,7 +179,7 @@ int usb6fire_comm_init(struct sfire_chip *chip)
         if (ret < 0) {
                 kfree(rt->receiver_buffer);
                 kfree(rt);
-                snd_printk(KERN_ERR PREFIX "cannot create comm data receiver.");
+                dev_err(&chip->dev->dev, "cannot create comm data receiver.");
                 return ret;
         }
         chip->comm = rt;
diff --git a/sound/usb/6fire/control.c b/sound/usb/6fire/control.c
index f6434c245720..184e3987ac24 100644
--- a/sound/usb/6fire/control.c
+++ b/sound/usb/6fire/control.c
@@ -194,7 +194,8 @@ static int usb6fire_control_output_vol_put(struct snd_kcontrol *kcontrol,
         int changed = 0;
 
         if (ch > 4) {
-                snd_printk(KERN_ERR PREFIX "Invalid channel in volume control.");
+                dev_err(&rt->chip->dev->dev,
+                        "Invalid channel in volume control.");
                 return -EINVAL;
         }
 
@@ -222,7 +223,8 @@ static int usb6fire_control_output_vol_get(struct snd_kcontrol *kcontrol,
         unsigned int ch = kcontrol->private_value;
 
         if (ch > 4) {
-                snd_printk(KERN_ERR PREFIX "Invalid channel in volume control.");
+                dev_err(&rt->chip->dev->dev,
+                        "Invalid channel in volume control.");
                 return -EINVAL;
         }
 
@@ -240,7 +242,8 @@ static int usb6fire_control_output_mute_put(struct snd_kcontrol *kcontrol,
         u8 value = 0;
 
         if (ch > 4) {
-                snd_printk(KERN_ERR PREFIX "Invalid channel in volume control.");
+                dev_err(&rt->chip->dev->dev,
+                        "Invalid channel in volume control.");
                 return -EINVAL;
         }
 
@@ -265,7 +268,8 @@ static int usb6fire_control_output_mute_get(struct snd_kcontrol *kcontrol,
         u8 value = rt->output_mute >> ch;
 
         if (ch > 4) {
-                snd_printk(KERN_ERR PREFIX "Invalid channel in volume control.");
+                dev_err(&rt->chip->dev->dev,
+                        "Invalid channel in volume control.");
                 return -EINVAL;
         }
 
@@ -594,14 +598,14 @@ int usb6fire_control_init(struct sfire_chip *chip)
         ret = usb6fire_control_add_virtual(rt, chip->card,
                 "Master Playback Volume", vol_elements);
         if (ret) {
-                snd_printk(KERN_ERR PREFIX "cannot add control.\n");
+                dev_err(&chip->dev->dev, "cannot add control.\n");
                 kfree(rt);
                 return ret;
         }
         ret = usb6fire_control_add_virtual(rt, chip->card,
                 "Master Playback Switch", mute_elements);
         if (ret) {
-                snd_printk(KERN_ERR PREFIX "cannot add control.\n");
+                dev_err(&chip->dev->dev, "cannot add control.\n");
                 kfree(rt);
                 return ret;
         }
@@ -611,7 +615,7 @@ int usb6fire_control_init(struct sfire_chip *chip)
                 ret = snd_ctl_add(chip->card, snd_ctl_new1(&elements[i], rt));
                 if (ret < 0) {
                         kfree(rt);
-                        snd_printk(KERN_ERR PREFIX "cannot add control.\n");
+                        dev_err(&chip->dev->dev, "cannot add control.\n");
                         return ret;
                 }
                 i++;
diff --git a/sound/usb/6fire/firmware.c b/sound/usb/6fire/firmware.c
index 780bf3f62d28..3b02e54b8f6d 100644
--- a/sound/usb/6fire/firmware.c
+++ b/sound/usb/6fire/firmware.c
@@ -219,16 +219,16 @@ static int usb6fire_fw_ezusb_upload(
         ret = request_firmware(&fw, fwname, &device->dev);
         if (ret < 0) {
                 kfree(rec);
-                snd_printk(KERN_ERR PREFIX "error requesting ezusb "
-                                "firmware %s.\n", fwname);
+                dev_err(&intf->dev,
+                        "error requesting ezusb firmware %s.\n", fwname);
                 return ret;
         }
         ret = usb6fire_fw_ihex_init(fw, rec);
         if (ret < 0) {
                 kfree(rec);
                 release_firmware(fw);
-                snd_printk(KERN_ERR PREFIX "error validating ezusb "
-                                "firmware %s.\n", fwname);
+                dev_err(&intf->dev,
+                        "error validating ezusb firmware %s.\n", fwname);
                 return ret;
         }
         /* upload firmware image */
@@ -237,8 +237,9 @@ static int usb6fire_fw_ezusb_upload(
         if (ret < 0) {
                 kfree(rec);
                 release_firmware(fw);
-                snd_printk(KERN_ERR PREFIX "unable to upload ezusb "
-                                "firmware %s: begin message.\n", fwname);
+                dev_err(&intf->dev,
+                        "unable to upload ezusb firmware %s: begin message.\n",
+                        fwname);
                 return ret;
         }
 
@@ -248,8 +249,9 @@ static int usb6fire_fw_ezusb_upload(
                 if (ret < 0) {
                         kfree(rec);
                         release_firmware(fw);
-                        snd_printk(KERN_ERR PREFIX "unable to upload ezusb "
-                                        "firmware %s: data urb.\n", fwname);
+                        dev_err(&intf->dev,
+                                "unable to upload ezusb firmware %s: data urb.\n",
+                                fwname);
                         return ret;
                 }
         }
@@ -260,8 +262,9 @@ static int usb6fire_fw_ezusb_upload(
                 ret = usb6fire_fw_ezusb_write(device, 0xa0, postaddr,
                                 postdata, postlen);
                 if (ret < 0) {
-                        snd_printk(KERN_ERR PREFIX "unable to upload ezusb "
-                                        "firmware %s: post urb.\n", fwname);
+                        dev_err(&intf->dev,
+                                "unable to upload ezusb firmware %s: post urb.\n",
+                                fwname);
                         return ret;
                 }
         }
@@ -269,8 +272,9 @@ static int usb6fire_fw_ezusb_upload(
         data = 0x00; /* resume ezusb cpu */
         ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "unable to upload ezusb "
-                                "firmware %s: end message.\n", fwname);
+                dev_err(&intf->dev,
+                        "unable to upload ezusb firmware %s: end message.\n",
+                        fwname);
                 return ret;
         }
         return 0;
@@ -292,7 +296,7 @@ static int usb6fire_fw_fpga_upload(
 
         ret = request_firmware(&fw, fwname, &device->dev);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "unable to get fpga firmware %s.\n",
+                dev_err(&intf->dev, "unable to get fpga firmware %s.\n",
                                 fwname);
                 kfree(buffer);
                 return -EIO;
@@ -305,8 +309,8 @@ static int usb6fire_fw_fpga_upload(
         if (ret < 0) {
                 kfree(buffer);
                 release_firmware(fw);
-                snd_printk(KERN_ERR PREFIX "unable to upload fpga firmware: "
-                                "begin urb.\n");
+                dev_err(&intf->dev,
+                        "unable to upload fpga firmware: begin urb.\n");
                 return ret;
         }
 
@@ -318,8 +322,8 @@ static int usb6fire_fw_fpga_upload(
                 if (ret < 0) {
                         release_firmware(fw);
                         kfree(buffer);
-                        snd_printk(KERN_ERR PREFIX "unable to upload fpga "
-                                        "firmware: fw urb.\n");
+                        dev_err(&intf->dev,
+                                "unable to upload fpga firmware: fw urb.\n");
                         return ret;
                 }
         }
@@ -328,8 +332,8 @@ static int usb6fire_fw_fpga_upload(
 
         ret = usb6fire_fw_ezusb_write(device, 9, 0, NULL, 0);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "unable to upload fpga firmware: "
-                                "end urb.\n");
+                dev_err(&intf->dev,
+                        "unable to upload fpga firmware: end urb.\n");
                 return ret;
         }
         return 0;
@@ -338,7 +342,7 @@ static int usb6fire_fw_fpga_upload(
 /* check, if the firmware version the devices has currently loaded
  * is known by this driver. 'version' needs to have 4 bytes version
  * info data. */
-static int usb6fire_fw_check(u8 *version)
+static int usb6fire_fw_check(struct usb_interface *intf, const u8 *version)
 {
         int i;
 
@@ -346,7 +350,7 @@ static int usb6fire_fw_check(u8 *version)
                 if (!memcmp(version, known_fw_versions + i, 2))
                         return 0;
 
-        snd_printk(KERN_ERR PREFIX "invalid fimware version in device: %4ph. "
+        dev_err(&intf->dev, "invalid fimware version in device: %4ph. "
                         "please reconnect to power. if this failure "
                         "still happens, check your firmware installation.",
                         version);
@@ -364,16 +368,16 @@ int usb6fire_fw_init(struct usb_interface *intf)
 
         ret = usb6fire_fw_ezusb_read(device, 1, 0, buffer, 8);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "unable to receive device "
-                                "firmware state.\n");
+                dev_err(&intf->dev,
+                        "unable to receive device firmware state.\n");
                 return ret;
         }
         if (buffer[0] != 0xeb || buffer[1] != 0xaa || buffer[2] != 0x55) {
-                snd_printk(KERN_ERR PREFIX "unknown device firmware state "
-                                "received from device: ");
+                dev_err(&intf->dev,
+                        "unknown device firmware state received from device:");
                 for (i = 0; i < 8; i++)
-                        snd_printk("%02x ", buffer[i]);
-                snd_printk("\n");
+                        printk(KERN_CONT "%02x ", buffer[i]);
+                printk(KERN_CONT "\n");
                 return -EIO;
         }
         /* do we need fpga loader ezusb firmware? */
@@ -386,7 +390,7 @@ int usb6fire_fw_init(struct usb_interface *intf)
         }
         /* do we need fpga firmware and application ezusb firmware? */
         else if (buffer[3] == 0x02) {
-                ret = usb6fire_fw_check(buffer + 4);
+                ret = usb6fire_fw_check(intf, buffer + 4);
                 if (ret < 0)
                         return ret;
                 ret = usb6fire_fw_fpga_upload(intf, "6fire/dmx6firecf.bin");
@@ -402,14 +406,14 @@ int usb6fire_fw_init(struct usb_interface *intf)
         }
         /* all fw loaded? */
         else if (buffer[3] == 0x03)
-                return usb6fire_fw_check(buffer + 4);
+                return usb6fire_fw_check(intf, buffer + 4);
         /* unknown data? */
         else {
-                snd_printk(KERN_ERR PREFIX "unknown device firmware state "
-                                "received from device: ");
+                dev_err(&intf->dev,
+                        "unknown device firmware state received from device: ");
                 for (i = 0; i < 8; i++)
-                        snd_printk("%02x ", buffer[i]);
-                snd_printk("\n");
+                        printk(KERN_CONT "%02x ", buffer[i]);
+                printk(KERN_CONT "\n");
                 return -EIO;
         }
         return 0;
diff --git a/sound/usb/6fire/midi.c b/sound/usb/6fire/midi.c
index f3dd7266c391..3d410969553e 100644
--- a/sound/usb/6fire/midi.c
+++ b/sound/usb/6fire/midi.c
@@ -41,8 +41,9 @@ static void usb6fire_midi_out_handler(struct urb *urb)
 
                         ret = usb_submit_urb(urb, GFP_ATOMIC);
                         if (ret < 0)
-                                snd_printk(KERN_ERR PREFIX "midi out urb "
-                                                "submit failed: %d\n", ret);
+                                dev_err(&urb->dev->dev,
+                                        "midi out urb submit failed: %d\n",
+                                        ret);
                 } else /* no more data to transmit */
                         rt->out = NULL;
         }
@@ -94,8 +95,9 @@ static void usb6fire_midi_out_trigger(
 
                         ret = usb_submit_urb(urb, GFP_ATOMIC);
                         if (ret < 0)
-                                snd_printk(KERN_ERR PREFIX "midi out urb "
-                                                "submit failed: %d\n", ret);
+                                dev_err(&urb->dev->dev,
+                                        "midi out urb submit failed: %d\n",
+                                        ret);
                         else
                                 rt->out = alsa_sub;
                 }
@@ -181,7 +183,7 @@ int usb6fire_midi_init(struct sfire_chip *chip)
         if (ret < 0) {
                 kfree(rt->out_buffer);
                 kfree(rt);
-                snd_printk(KERN_ERR PREFIX "unable to create midi.\n");
+                dev_err(&chip->dev->dev, "unable to create midi.\n");
                 return ret;
         }
         rt->instance->private_data = rt;
diff --git a/sound/usb/6fire/pcm.c b/sound/usb/6fire/pcm.c
index b5eb97fdc842..ba40489b2de4 100644
--- a/sound/usb/6fire/pcm.c
+++ b/sound/usb/6fire/pcm.c
@@ -79,32 +79,35 @@ static int usb6fire_pcm_set_rate(struct pcm_runtime *rt)
         ctrl_rt->usb_streaming = false;
         ret = ctrl_rt->update_streaming(ctrl_rt);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "error stopping streaming while "
-                                "setting samplerate %d.\n", rates[rt->rate]);
+                dev_err(&rt->chip->dev->dev,
+                        "error stopping streaming while setting samplerate %d.\n",
+                        rates[rt->rate]);
                 return ret;
         }
 
         ret = ctrl_rt->set_rate(ctrl_rt, rt->rate);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "error setting samplerate %d.\n",
-                                rates[rt->rate]);
+                dev_err(&rt->chip->dev->dev,
+                        "error setting samplerate %d.\n",
+                        rates[rt->rate]);
                 return ret;
         }
 
         ret = ctrl_rt->set_channels(ctrl_rt, OUT_N_CHANNELS, IN_N_CHANNELS,
                         false, false);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "error initializing channels "
-                                "while setting samplerate %d.\n",
-                                rates[rt->rate]);
+                dev_err(&rt->chip->dev->dev,
+                        "error initializing channels while setting samplerate %d.\n",
+                        rates[rt->rate]);
                 return ret;
         }
 
         ctrl_rt->usb_streaming = true;
         ret = ctrl_rt->update_streaming(ctrl_rt);
         if (ret < 0) {
-                snd_printk(KERN_ERR PREFIX "error starting streaming while "
-                                "setting samplerate %d.\n", rates[rt->rate]);
+                dev_err(&rt->chip->dev->dev,
+                        "error starting streaming while setting samplerate %d.\n",
+                        rates[rt->rate]);
                 return ret;
         }
 
@@ -124,7 +127,7 @@ static struct pcm_substream *usb6fire_pcm_get_substream(
                 return &rt->playback;
         else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE)
                 return &rt->capture;
-        snd_printk(KERN_ERR PREFIX "error getting pcm substream slot.\n");
+        dev_err(&rt->chip->dev->dev, "error getting pcm substream slot.\n");
         return NULL;
 }
 
@@ -257,7 +260,7 @@ static void usb6fire_pcm_playback(struct pcm_substream *sub,
         else if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
                 dest = (u32 *) (urb->buffer);
         else {
-                snd_printk(KERN_ERR PREFIX "Unknown sample format.");
+                dev_err(&rt->chip->dev->dev, "Unknown sample format.");
                 return;
         }
 
@@ -307,8 +310,8 @@ static void usb6fire_pcm_in_urb_handler(struct urb *usb_urb)
                 }
 
         if (rt->stream_state == STREAM_DISABLED) {
-                snd_printk(KERN_ERR PREFIX "internal error: "
-                                "stream disabled in in-urb handler.\n");
+                dev_err(&rt->chip->dev->dev,
+                        "internal error: stream disabled in in-urb handler.\n");
                 return;
         }
 
@@ -410,7 +413,7 @@ static int usb6fire_pcm_open(struct snd_pcm_substream *alsa_sub)
 
         if (!sub) {
                 mutex_unlock(&rt->stream_mutex);
-                snd_printk(KERN_ERR PREFIX "invalid stream type.\n");
+                dev_err(&rt->chip->dev->dev, "invalid stream type.\n");
                 return -EINVAL;
         }
 
@@ -481,8 +484,9 @@ static int usb6fire_pcm_prepare(struct snd_pcm_substream *alsa_sub)
                                 break;
                 if (rt->rate == ARRAY_SIZE(rates)) {
                         mutex_unlock(&rt->stream_mutex);
-                        snd_printk("invalid rate %d in prepare.\n",
-                                        alsa_rt->rate);
+                        dev_err(&rt->chip->dev->dev,
+                                "invalid rate %d in prepare.\n",
+                                alsa_rt->rate);
                         return -EINVAL;
                 }
 
@@ -494,8 +498,8 @@ static int usb6fire_pcm_prepare(struct snd_pcm_substream *alsa_sub)
                 ret = usb6fire_pcm_stream_start(rt);
                 if (ret) {
                         mutex_unlock(&rt->stream_mutex);
-                        snd_printk(KERN_ERR PREFIX
-                                        "could not start pcm stream.\n");
+                        dev_err(&rt->chip->dev->dev,
+                                "could not start pcm stream.\n");
                         return ret;
                 }
         }
@@ -650,7 +654,7 @@ int usb6fire_pcm_init(struct sfire_chip *chip)
         if (ret < 0) {
                 usb6fire_pcm_buffers_destroy(rt);
                 kfree(rt);
-                snd_printk(KERN_ERR PREFIX "cannot create pcm instance.\n");
+                dev_err(&chip->dev->dev, "cannot create pcm instance.\n");
                 return ret;
         }
 
@@ -662,8 +666,8 @@ int usb6fire_pcm_init(struct sfire_chip *chip)
         if (ret) {
                 usb6fire_pcm_buffers_destroy(rt);
                 kfree(rt);
-                snd_printk(KERN_ERR PREFIX
-                                "error preallocating pcm buffers.\n");
+                dev_err(&chip->dev->dev,
+                        "error preallocating pcm buffers.\n");
                 return ret;
         }
         rt->instance = pcm;
diff --git a/sound/usb/card.c b/sound/usb/card.c
index 0cfdc2d3b631..893d5a1afc3c 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -139,8 +139,8 @@ static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int int
         struct usb_interface *iface = usb_ifnum_to_if(dev, interface);
 
         if (!iface) {
-                snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
-                           dev->devnum, ctrlif, interface);
+                dev_err(&dev->dev, "%u:%d : does not exist\n",
+                        ctrlif, interface);
                 return -EINVAL;
         }
 
@@ -165,8 +165,8 @@ static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int int
         }
 
         if (usb_interface_claimed(iface)) {
-                snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n",
-                                                dev->devnum, ctrlif, interface);
+                dev_dbg(&dev->dev, "%d:%d: skipping, already claimed\n",
+                        ctrlif, interface);
                 return -EINVAL;
         }
 
@@ -176,8 +176,9 @@ static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int int
                 int err = snd_usbmidi_create(chip->card, iface,
                                              &chip->midi_list, NULL);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n",
-                                                dev->devnum, ctrlif, interface);
+                        dev_err(&dev->dev,
+                                "%u:%d: cannot create sequencer device\n",
+                                ctrlif, interface);
                         return -EINVAL;
                 }
                 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
@@ -188,14 +189,15 @@ static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int int
         if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
              altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
             altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) {
-                snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n",
-                                        dev->devnum, ctrlif, interface, altsd->bInterfaceClass);
+                dev_dbg(&dev->dev,
+                        "%u:%d: skipping non-supported interface %d\n",
+                        ctrlif, interface, altsd->bInterfaceClass);
                 /* skip non-supported classes */
                 return -EINVAL;
         }
 
         if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
-                snd_printk(KERN_ERR "low speed audio streaming not supported\n");
+                dev_err(&dev->dev, "low speed audio streaming not supported\n");
                 return -EINVAL;
         }
 
@@ -228,26 +230,27 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
         protocol = altsd->bInterfaceProtocol;
 
         if (!control_header) {
-                snd_printk(KERN_ERR "cannot find UAC_HEADER\n");
+                dev_err(&dev->dev, "cannot find UAC_HEADER\n");
                 return -EINVAL;
         }
 
         switch (protocol) {
         default:
-                snd_printdd(KERN_WARNING "unknown interface protocol %#02x, assuming v1\n",
-                            protocol);
+                dev_warn(&dev->dev,
+                         "unknown interface protocol %#02x, assuming v1\n",
+                         protocol);
                 /* fall through */
 
         case UAC_VERSION_1: {
                 struct uac1_ac_header_descriptor *h1 = control_header;
 
                 if (!h1->bInCollection) {
-                        snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
+                        dev_info(&dev->dev, "skipping empty audio interface (v1)\n");
                         return -EINVAL;
                 }
 
                 if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
-                        snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n");
+                        dev_err(&dev->dev, "invalid UAC_HEADER (v1)\n");
                         return -EINVAL;
                 }
 
@@ -277,7 +280,7 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
                 }
 
                 if (!assoc) {
-                        snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n");
+                        dev_err(&dev->dev, "Audio class v2 interfaces need an interface association\n");
                         return -EINVAL;
                 }
 
@@ -351,14 +354,14 @@ static int snd_usb_audio_create(struct usb_interface *intf,
         case USB_SPEED_SUPER:
                 break;
         default:
-                snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
+                dev_err(&dev->dev, "unknown device speed %d\n", snd_usb_get_speed(dev));
                 return -ENXIO;
         }
 
         err = snd_card_new(&intf->dev, index[idx], id[idx], THIS_MODULE,
                            0, &card);
         if (err < 0) {
-                snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
+                dev_err(&dev->dev, "cannot create card instance %d\n", idx);
                 return err;
         }
 
@@ -499,7 +502,7 @@ snd_usb_audio_probe(struct usb_device *dev,
         for (i = 0; i < SNDRV_CARDS; i++) {
                 if (usb_chip[i] && usb_chip[i]->dev == dev) {
                         if (usb_chip[i]->shutdown) {
-                                snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
+                                dev_err(&dev->dev, "USB device is in the shutdown state, cannot create a card instance\n");
                                 goto __error;
                         }
                         chip = usb_chip[i];
@@ -523,7 +526,7 @@ snd_usb_audio_probe(struct usb_device *dev,
                                 break;
                         }
                 if (!chip) {
-                        printk(KERN_ERR "no available usb audio device\n");
+                        dev_err(&dev->dev, "no available usb audio device\n");
                         goto __error;
                 }
         }
diff --git a/sound/usb/clock.c b/sound/usb/clock.c
index 86f80c60b21f..03fed6611d9e 100644
--- a/sound/usb/clock.c
+++ b/sound/usb/clock.c
@@ -115,9 +115,9 @@ static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_i
                 return ret;
 
         if (ret != sizeof(pin)) {
-                snd_printk(KERN_ERR
-                        "usb-audio:%d: setting selector (id %d) unexpected length %d\n",
-                        chip->dev->devnum, selector_id, ret);
+                usb_audio_err(chip,
+                        "setting selector (id %d) unexpected length %d\n",
+                        selector_id, ret);
                 return -EINVAL;
         }
 
@@ -126,9 +126,9 @@ static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_i
                 return ret;
 
         if (ret != pin) {
-                snd_printk(KERN_ERR
-                        "usb-audio:%d: setting selector (id %d) to %x failed (current: %d)\n",
-                        chip->dev->devnum, selector_id, pin, ret);
+                usb_audio_err(chip,
+                        "setting selector (id %d) to %x failed (current: %d)\n",
+                        selector_id, pin, ret);
                 return -EINVAL;
         }
 
@@ -158,7 +158,8 @@ static bool uac_clock_source_is_valid(struct snd_usb_audio *chip, int source_id)
                               &data, sizeof(data));
 
         if (err < 0) {
-                snd_printk(KERN_WARNING "%s(): cannot get clock validity for id %d\n",
+                dev_warn(&dev->dev,
+                         "%s(): cannot get clock validity for id %d\n",
                            __func__, source_id);
                 return 0;
         }
@@ -177,9 +178,9 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip,
         entity_id &= 0xff;
 
         if (test_and_set_bit(entity_id, visited)) {
-                snd_printk(KERN_WARNING
-                        "%s(): recursive clock topology detected, id %d.\n",
-                        __func__, entity_id);
+                usb_audio_warn(chip,
+                         "%s(): recursive clock topology detected, id %d.\n",
+                         __func__, entity_id);
                 return -EINVAL;
         }
 
@@ -188,8 +189,9 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip,
         if (source) {
                 entity_id = source->bClockID;
                 if (validate && !uac_clock_source_is_valid(chip, entity_id)) {
-                        snd_printk(KERN_ERR "usb-audio:%d: clock source %d is not valid, cannot use\n",
-                                   chip->dev->devnum, entity_id);
+                        usb_audio_err(chip,
+                                "clock source %d is not valid, cannot use\n",
+                                entity_id);
                         return -ENXIO;
                 }
                 return entity_id;
@@ -208,7 +210,7 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip,
                 /* Selector values are one-based */
 
                 if (ret > selector->bNrInPins || ret < 1) {
-                        snd_printk(KERN_ERR
+                        usb_audio_err(chip,
                                 "%s(): selector reported illegal value, id %d, ret %d\n",
                                 __func__, selector->bClockID, ret);
 
@@ -237,9 +239,9 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip,
                         if (err < 0)
                                 continue;
 
-                        snd_printk(KERN_INFO
-                                "usb-audio:%d: found and selected valid clock source %d\n",
-                                chip->dev->devnum, ret);
+                        usb_audio_info(chip,
+                                 "found and selected valid clock source %d\n",
+                                 ret);
                         return ret;
                 }
 
@@ -296,8 +298,8 @@ static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
                                    USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                                    UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
                                    data, sizeof(data))) < 0) {
-                snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",
-                           dev->devnum, iface, fmt->altsetting, rate, ep);
+                dev_err(&dev->dev, "%d:%d: cannot set freq %d to ep %#x\n",
+                        iface, fmt->altsetting, rate, ep);
                 return err;
         }
 
@@ -305,14 +307,14 @@ static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
                                    USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
                                    UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
                                    data, sizeof(data))) < 0) {
-                snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",
-                           dev->devnum, iface, fmt->altsetting, ep);
+                dev_err(&dev->dev, "%d:%d: cannot get freq at ep %#x\n",
+                        iface, fmt->altsetting, ep);
                 return 0; /* some devices don't support reading */
         }
 
         crate = data[0] | (data[1] << 8) | (data[2] << 16);
         if (crate != rate) {
-                snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
+                dev_warn(&dev->dev, "current rate %d is different from the runtime rate %d\n", crate, rate);
                 // runtime->rate = crate;
         }
 
@@ -332,8 +334,8 @@ static int get_sample_rate_v2(struct snd_usb_audio *chip, int iface,
                               snd_usb_ctrl_intf(chip) | (clock << 8),
                               &data, sizeof(data));
         if (err < 0) {
-                snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq (v2): err %d\n",
-                           dev->devnum, iface, altsetting, err);
+                dev_warn(&dev->dev, "%d:%d: cannot get freq (v2): err %d\n",
+                         iface, altsetting, err);
                 return 0;
         }
 
@@ -369,8 +371,9 @@ static int set_sample_rate_v2(struct snd_usb_audio *chip, int iface,
                                       snd_usb_ctrl_intf(chip) | (clock << 8),
                                       &data, sizeof(data));
                 if (err < 0) {
-                        snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d (v2): err %d\n",
-                                   dev->devnum, iface, fmt->altsetting, rate, err);
+                        usb_audio_err(chip,
+                                "%d:%d: cannot set freq %d (v2): err %d\n",
+                                iface, fmt->altsetting, rate, err);
                         return err;
                 }
 
@@ -381,14 +384,14 @@ static int set_sample_rate_v2(struct snd_usb_audio *chip, int iface,
 
         if (cur_rate != rate) {
                 if (!writeable) {
-                        snd_printk(KERN_WARNING
-                                   "%d:%d:%d: freq mismatch (RO clock): req %d, clock runs @%d\n",
-                                   dev->devnum, iface, fmt->altsetting, rate, cur_rate);
+                        usb_audio_warn(chip,
+                                 "%d:%d: freq mismatch (RO clock): req %d, clock runs @%d\n",
+                                 iface, fmt->altsetting, rate, cur_rate);
                         return -ENXIO;
                 }
-                snd_printd(KERN_WARNING
-                           "current rate %d is different from the runtime rate %d\n",
-                           cur_rate, rate);
+                usb_audio_dbg(chip,
+                        "current rate %d is different from the runtime rate %d\n",
+                        cur_rate, rate);
         }
 
         /* Some devices doesn't respond to sample rate changes while the
diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
index 83aabea259d7..e70a87e0d9fe 100644
--- a/sound/usb/endpoint.c
+++ b/sound/usb/endpoint.c
@@ -333,8 +333,9 @@ static void queue_pending_output_urbs(struct snd_usb_endpoint *ep)
 
                 err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
                 if (err < 0)
-                        snd_printk(KERN_ERR "Unable to submit urb #%d: %d (urb %p)\n",
-                                   ctx->index, err, ctx->urb);
+                        usb_audio_err(ep->chip,
+                                "Unable to submit urb #%d: %d (urb %p)\n",
+                                ctx->index, err, ctx->urb);
                 else
                         set_bit(ctx->index, &ep->active_mask);
         }
@@ -387,7 +388,7 @@ static void snd_complete_urb(struct urb *urb)
         if (err == 0)
                 return;
 
-        snd_printk(KERN_ERR "cannot submit urb (err = %d)\n", err);
+        usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);
         //snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 
 exit_clear:
@@ -426,13 +427,14 @@ struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip,
                 if (ep->ep_num == ep_num &&
                     ep->iface == alts->desc.bInterfaceNumber &&
                     ep->altsetting == alts->desc.bAlternateSetting) {
-                        snd_printdd(KERN_DEBUG "Re-using EP %x in iface %d,%d @%p\n",
+                        usb_audio_dbg(ep->chip,
+                                      "Re-using EP %x in iface %d,%d @%p\n",
                                         ep_num, ep->iface, ep->altsetting, ep);
                         goto __exit_unlock;
                 }
         }
 
-        snd_printdd(KERN_DEBUG "Creating new %s %s endpoint #%x\n",
+        usb_audio_dbg(chip, "Creating new %s %s endpoint #%x\n",
                     is_playback ? "playback" : "capture",
                     type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync",
                     ep_num);
@@ -496,8 +498,9 @@ static int wait_clear_urbs(struct snd_usb_endpoint *ep)
         } while (time_before(jiffies, end_time));
 
         if (alive)
-                snd_printk(KERN_ERR "timeout: still %d active urbs on EP #%x\n",
-                                        alive, ep->ep_num);
+                usb_audio_err(ep->chip,
+                        "timeout: still %d active urbs on EP #%x\n",
+                        alive, ep->ep_num);
         clear_bit(EP_FLAG_STOPPING, &ep->flags);
 
         return 0;
@@ -794,8 +797,9 @@ int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
         int err;
 
         if (ep->use_count != 0) {
-                snd_printk(KERN_WARNING "Unable to change format on ep #%x: already in use\n",
-                           ep->ep_num);
+                usb_audio_warn(ep->chip,
+                         "Unable to change format on ep #%x: already in use\n",
+                         ep->ep_num);
                 return -EBUSY;
         }
 
@@ -830,8 +834,9 @@ int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
                 err = -EINVAL;
         }
 
-        snd_printdd(KERN_DEBUG "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
-                   ep->ep_num, ep->type, ep->nurbs, err);
+        usb_audio_dbg(ep->chip,
+                "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
+                ep->ep_num, ep->type, ep->nurbs, err);
 
         return err;
 }
@@ -906,8 +911,9 @@ int snd_usb_endpoint_start(struct snd_usb_endpoint *ep, bool can_sleep)
 
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "cannot submit urb %d, error %d: %s\n",
-                                   i, err, usb_error_string(err));
+                        usb_audio_err(ep->chip,
+                                "cannot submit urb %d, error %d: %s\n",
+                                i, err, usb_error_string(err));
                         goto __error;
                 }
                 set_bit(i, &ep->active_mask);
diff --git a/sound/usb/format.c b/sound/usb/format.c
index d244fd3703d8..8bcc87cf5667 100644
--- a/sound/usb/format.c
+++ b/sound/usb/format.c
@@ -74,8 +74,8 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
         if ((pcm_formats == 0) &&
             (format == 0 || format == (1 << UAC_FORMAT_TYPE_I_UNDEFINED))) {
                 /* some devices don't define this correctly... */
-                snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
-                            chip->dev->devnum, fp->iface, fp->altsetting);
+                usb_audio_info(chip, "%u:%d : format type 0 is detected, processed as PCM\n",
+                        fp->iface, fp->altsetting);
                 format = 1 << UAC_FORMAT_TYPE_I_PCM;
         }
         if (format & (1 << UAC_FORMAT_TYPE_I_PCM)) {
@@ -83,9 +83,9 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
                     sample_width == 24 && sample_bytes == 2)
                         sample_bytes = 3;
                 else if (sample_width > sample_bytes * 8) {
-                        snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
-                                   chip->dev->devnum, fp->iface, fp->altsetting,
-                                   sample_width, sample_bytes);
+                        usb_audio_info(chip, "%u:%d : sample bitwidth %d in over sample bytes %d\n",
+                                 fp->iface, fp->altsetting,
+                                 sample_width, sample_bytes);
                 }
                 /* check the format byte size */
                 switch (sample_bytes) {
@@ -108,9 +108,10 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
                         pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE;
                         break;
                 default:
-                        snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
-                                   chip->dev->devnum, fp->iface, fp->altsetting,
-                                   sample_width, sample_bytes);
+                        usb_audio_info(chip,
+                                 "%u:%d : unsupported sample bitwidth %d in %d bytes\n",
+                                 fp->iface, fp->altsetting,
+                                 sample_width, sample_bytes);
                         break;
                 }
         }
@@ -132,8 +133,9 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
                 pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW;
         }
         if (format & ~0x3f) {
-                snd_printk(KERN_INFO "%d:%u:%d : unsupported format bits %#x\n",
-                           chip->dev->devnum, fp->iface, fp->altsetting, format);
+                usb_audio_info(chip,
+                         "%u:%d : unsupported format bits %#x\n",
+                         fp->iface, fp->altsetting, format);
         }
 
         pcm_formats |= snd_usb_interface_dsd_format_quirks(chip, fp, sample_bytes);
@@ -158,8 +160,9 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof
         int nr_rates = fmt[offset];
 
         if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
-                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
-                                   chip->dev->devnum, fp->iface, fp->altsetting);
+                usb_audio_err(chip,
+                        "%u:%d : invalid UAC_FORMAT_TYPE desc\n",
+                        fp->iface, fp->altsetting);
                 return -EINVAL;
         }
 
@@ -171,7 +174,7 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof
 
                 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
                 if (fp->rate_table == NULL) {
-                        snd_printk(KERN_ERR "cannot malloc\n");
+                        usb_audio_err(chip, "cannot malloc\n");
                         return -ENOMEM;
                 }
 
@@ -222,7 +225,8 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof
  * get to know how many sample rates we have to expect.
  * Then fp->rate_table can be allocated and filled.
  */
-static int parse_uac2_sample_rate_range(struct audioformat *fp, int nr_triplets,
+static int parse_uac2_sample_rate_range(struct snd_usb_audio *chip,
+                                        struct audioformat *fp, int nr_triplets,
                                         const unsigned char *data)
 {
         int i, nr_rates = 0;
@@ -261,7 +265,7 @@ static int parse_uac2_sample_rate_range(struct audioformat *fp, int nr_triplets,
 
                         nr_rates++;
                         if (nr_rates >= MAX_NR_RATES) {
-                                snd_printk(KERN_ERR "invalid uac2 rates\n");
+                                usb_audio_err(chip, "invalid uac2 rates\n");
                                 break;
                         }
 
@@ -287,7 +291,8 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
         int clock = snd_usb_clock_find_source(chip, fp->clock, false);
 
         if (clock < 0) {
-                snd_printk(KERN_ERR "%s(): unable to find clock source (clock %d)\n",
+                dev_err(&dev->dev,
+                        "%s(): unable to find clock source (clock %d)\n",
                                 __func__, clock);
                 goto err;
         }
@@ -300,7 +305,8 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
                               tmp, sizeof(tmp));
 
         if (ret < 0) {
-                snd_printk(KERN_ERR "%s(): unable to retrieve number of sample rates (clock %d)\n",
+                dev_err(&dev->dev,
+                        "%s(): unable to retrieve number of sample rates (clock %d)\n",
                                 __func__, clock);
                 goto err;
         }
@@ -321,7 +327,8 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
                               data, data_size);
 
         if (ret < 0) {
-                snd_printk(KERN_ERR "%s(): unable to retrieve sample rate range (clock %d)\n",
+                dev_err(&dev->dev,
+                        "%s(): unable to retrieve sample rate range (clock %d)\n",
                                 __func__, clock);
                 ret = -EINVAL;
                 goto err_free;
@@ -332,7 +339,7 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
          * will have to deal with. */
         kfree(fp->rate_table);
         fp->rate_table = NULL;
-        fp->nr_rates = parse_uac2_sample_rate_range(fp, nr_triplets, data);
+        fp->nr_rates = parse_uac2_sample_rate_range(chip, fp, nr_triplets, data);
 
         if (fp->nr_rates == 0) {
                 /* SNDRV_PCM_RATE_CONTINUOUS */
@@ -348,7 +355,7 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
 
         /* Call the triplet parser again, but this time, fp->rate_table is
          * allocated, so the rates will be stored */
-        parse_uac2_sample_rate_range(fp, nr_triplets, data);
+        parse_uac2_sample_rate_range(chip, fp, nr_triplets, data);
 
 err_free:
         kfree(data);
@@ -408,8 +415,9 @@ static int parse_audio_format_i(struct snd_usb_audio *chip,
         }
 
         if (fp->channels < 1) {
-                snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
-                           chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
+                usb_audio_err(chip,
+                        "%u:%d : invalid channels %d\n",
+                        fp->iface, fp->altsetting, fp->channels);
                 return -EINVAL;
         }
 
@@ -435,8 +443,9 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip,
                 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
                 break;
         default:
-                snd_printd(KERN_INFO "%d:%u:%d : unknown format tag %#x is detected.  processed as MPEG.\n",
-                           chip->dev->devnum, fp->iface, fp->altsetting, format);
+                usb_audio_info(chip,
+                         "%u:%d : unknown format tag %#x is detected.  processed as MPEG.\n",
+                         fp->iface, fp->altsetting, format);
                 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
                 break;
         }
@@ -449,7 +458,7 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip,
                 struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
                 brate = le16_to_cpu(fmt->wMaxBitRate);
                 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
-                snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
+                usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
                 fp->frame_size = framesize;
                 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */
                 break;
@@ -458,7 +467,7 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip,
                 struct uac_format_type_ii_ext_descriptor *fmt = _fmt;
                 brate = le16_to_cpu(fmt->wMaxBitRate);
                 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
-                snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
+                usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
                 fp->frame_size = framesize;
                 ret = parse_audio_format_rates_v2(chip, fp);
                 break;
@@ -484,9 +493,10 @@ int snd_usb_parse_audio_format(struct snd_usb_audio *chip,
                 err = parse_audio_format_ii(chip, fp, format, fmt);
                 break;
         default:
-                snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
-                           chip->dev->devnum, fp->iface, fp->altsetting,
-                           fmt->bFormatType);
+                usb_audio_info(chip,
+                         "%u:%d : format type %d is not supported yet\n",
+                         fp->iface, fp->altsetting,
+                         fmt->bFormatType);
                 return -ENOTSUPP;
         }
         fp->fmt_type = fmt->bFormatType;
diff --git a/sound/usb/midi.c b/sound/usb/midi.c
index b901f468b67a..9da74d2e8eee 100644
--- a/sound/usb/midi.c
+++ b/sound/usb/midi.c
@@ -191,16 +191,16 @@ static int snd_usbmidi_submit_urb(struct urb* urb, gfp_t flags)
 {
         int err = usb_submit_urb(urb, flags);
         if (err < 0 && err != -ENODEV)
-                snd_printk(KERN_ERR "usb_submit_urb: %d\n", err);
+                dev_err(&urb->dev->dev, "usb_submit_urb: %d\n", err);
         return err;
 }
 
 /*
  * Error handling for URB completion functions.
  */
-static int snd_usbmidi_urb_error(int status)
+static int snd_usbmidi_urb_error(const struct urb *urb)
 {
-        switch (status) {
+        switch (urb->status) {
         /* manually unlinked, or device gone */
         case -ENOENT:
         case -ECONNRESET:
@@ -213,7 +213,7 @@ static int snd_usbmidi_urb_error(int status)
         case -EILSEQ:
                 return -EIO;
         default:
-                snd_printk(KERN_ERR "urb status %d\n", status);
+                dev_err(&urb->dev->dev, "urb status %d\n", urb->status);
                 return 0; /* continue */
         }
 }
@@ -227,7 +227,7 @@ static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint* ep, int port
         struct usbmidi_in_port* port = &ep->ports[portidx];
 
         if (!port->substream) {
-                snd_printd("unexpected port %d!\n", portidx);
+                dev_dbg(&ep->umidi->dev->dev, "unexpected port %d!\n", portidx);
                 return;
         }
         if (!test_bit(port->substream->number, &ep->umidi->input_triggered))
@@ -259,7 +259,7 @@ static void snd_usbmidi_in_urb_complete(struct urb* urb)
                 ep->umidi->usb_protocol_ops->input(ep, urb->transfer_buffer,
                                                    urb->actual_length);
         } else {
-                int err = snd_usbmidi_urb_error(urb->status);
+                int err = snd_usbmidi_urb_error(urb);
                 if (err < 0) {
                         if (err != -ENODEV) {
                                 ep->error_resubmit = 1;
@@ -289,7 +289,7 @@ static void snd_usbmidi_out_urb_complete(struct urb* urb)
         }
         spin_unlock(&ep->buffer_lock);
         if (urb->status < 0) {
-                int err = snd_usbmidi_urb_error(urb->status);
+                int err = snd_usbmidi_urb_error(urb);
                 if (err < 0) {
                         if (err != -ENODEV)
                                 mod_timer(&ep->umidi->error_timer,
@@ -1668,7 +1668,7 @@ static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi,
 
         struct snd_rawmidi_substream *substream = snd_usbmidi_find_substream(umidi, stream, number);
         if (!substream) {
-                snd_printd(KERN_ERR "substream %d:%d not found\n", stream, number);
+                dev_err(&umidi->dev->dev, "substream %d:%d not found\n", stream, number);
                 return;
         }
 
@@ -1717,7 +1717,7 @@ static int snd_usbmidi_create_endpoints(struct snd_usb_midi* umidi,
                         }
                 }
         }
-        snd_printdd(KERN_INFO "created %d output and %d input ports\n",
+        dev_dbg(&umidi->dev->dev, "created %d output and %d input ports\n",
                     out_ports, in_ports);
         return 0;
 }
@@ -1747,10 +1747,11 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
             ms_header->bLength >= 7 &&
             ms_header->bDescriptorType == USB_DT_CS_INTERFACE &&
             ms_header->bDescriptorSubtype == UAC_HEADER)
-                snd_printdd(KERN_INFO "MIDIStreaming version %02x.%02x\n",
+                dev_dbg(&umidi->dev->dev, "MIDIStreaming version %02x.%02x\n",
                             ms_header->bcdMSC[1], ms_header->bcdMSC[0]);
         else
-                snd_printk(KERN_WARNING "MIDIStreaming interface descriptor not found\n");
+                dev_warn(&umidi->dev->dev,
+                         "MIDIStreaming interface descriptor not found\n");
 
         epidx = 0;
         for (i = 0; i < intfd->bNumEndpoints; ++i) {
@@ -1767,7 +1768,8 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                 if (usb_endpoint_dir_out(ep)) {
                         if (endpoints[epidx].out_ep) {
                                 if (++epidx >= MIDI_MAX_ENDPOINTS) {
-                                        snd_printk(KERN_WARNING "too many endpoints\n");
+                                        dev_warn(&umidi->dev->dev,
+                                                 "too many endpoints\n");
                                         break;
                                 }
                         }
@@ -1782,12 +1784,13 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                                  */
                                 endpoints[epidx].out_interval = 1;
                         endpoints[epidx].out_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
-                        snd_printdd(KERN_INFO "EP %02X: %d jack(s)\n",
+                        dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n",
                                     ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack);
                 } else {
                         if (endpoints[epidx].in_ep) {
                                 if (++epidx >= MIDI_MAX_ENDPOINTS) {
-                                        snd_printk(KERN_WARNING "too many endpoints\n");
+                                        dev_warn(&umidi->dev->dev,
+                                                 "too many endpoints\n");
                                         break;
                                 }
                         }
@@ -1797,7 +1800,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                         else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW)
                                 endpoints[epidx].in_interval = 1;
                         endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
-                        snd_printdd(KERN_INFO "EP %02X: %d jack(s)\n",
+                        dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n",
                                     ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack);
                 }
         }
@@ -1865,7 +1868,7 @@ static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi* umidi)
             (get_endpoint(hostif, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT)
                 return;
 
-        snd_printdd(KERN_INFO "switching to altsetting %d with int ep\n",
+        dev_dbg(&umidi->dev->dev, "switching to altsetting %d with int ep\n",
                     intfd->bAlternateSetting);
         usb_set_interface(umidi->dev, intfd->bInterfaceNumber,
                           intfd->bAlternateSetting);
@@ -2047,25 +2050,25 @@ static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi,
          * input bulk endpoints (at indices 1 and 3) which aren't used.
          */
         if (intfd->bNumEndpoints < (endpoint->out_cables > 0x0001 ? 5 : 3)) {
-                snd_printdd(KERN_ERR "not enough endpoints\n");
+                dev_dbg(&umidi->dev->dev, "not enough endpoints\n");
                 return -ENOENT;
         }
 
         epd = get_endpoint(hostif, 0);
         if (!usb_endpoint_dir_in(epd) || !usb_endpoint_xfer_int(epd)) {
-                snd_printdd(KERN_ERR "endpoint[0] isn't interrupt\n");
+                dev_dbg(&umidi->dev->dev, "endpoint[0] isn't interrupt\n");
                 return -ENXIO;
         }
         epd = get_endpoint(hostif, 2);
         if (!usb_endpoint_dir_out(epd) || !usb_endpoint_xfer_bulk(epd)) {
-                snd_printdd(KERN_ERR "endpoint[2] isn't bulk output\n");
+                dev_dbg(&umidi->dev->dev, "endpoint[2] isn't bulk output\n");
                 return -ENXIO;
         }
         if (endpoint->out_cables > 0x0001) {
                 epd = get_endpoint(hostif, 4);
                 if (!usb_endpoint_dir_out(epd) ||
                     !usb_endpoint_xfer_bulk(epd)) {
-                        snd_printdd(KERN_ERR "endpoint[4] isn't bulk output\n");
+                        dev_dbg(&umidi->dev->dev, "endpoint[4] isn't bulk output\n");
                         return -ENXIO;
                 }
         }
@@ -2289,7 +2292,7 @@ int snd_usbmidi_create(struct snd_card *card,
                 err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
                 break;
         default:
-                snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
+                dev_err(&umidi->dev->dev, "invalid quirk type %d\n", quirk->type);
                 err = -ENXIO;
                 break;
         }
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index 8c152b02da5a..fcd3ab9331d3 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -305,8 +305,9 @@ static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request, int v
                         goto out;
                 }
         }
-        snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
-                    request, validx, idx, cval->val_type);
+        usb_audio_dbg(chip,
+                "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
+                request, validx, idx, cval->val_type);
         err = -EINVAL;
 
  out:
@@ -351,8 +352,9 @@ static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request, int v
 
         if (ret < 0) {
 error:
-                snd_printk(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
-                           request, validx, idx, cval->val_type);
+                usb_audio_err(chip,
+                        "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
+                        request, validx, idx, cval->val_type);
                 return ret;
         }
 
@@ -413,7 +415,8 @@ static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
         err = get_cur_mix_raw(cval, channel, value);
         if (err < 0) {
                 if (!cval->mixer->ignore_ctl_error)
-                        snd_printd(KERN_ERR "cannot get current value for control %d ch %d: err = %d\n",
+                        usb_audio_dbg(cval->mixer->chip,
+                                "cannot get current value for control %d ch %d: err = %d\n",
                                    cval->control, channel, err);
                 return err;
         }
@@ -444,7 +447,7 @@ int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
 
                 /* FIXME */
                 if (request != UAC_SET_CUR) {
-                        snd_printdd(KERN_WARNING "RANGE setting not yet supported\n");
+                        usb_audio_dbg(chip, "RANGE setting not yet supported\n");
                         return -EINVAL;
                 }
 
@@ -470,7 +473,7 @@ int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
                         goto out;
                 }
         }
-        snd_printdd(KERN_ERR "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
+        usb_audio_dbg(chip, "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
                     request, validx, idx, cval->val_type, buf[0], buf[1]);
         err = -EINVAL;
 
@@ -494,7 +497,8 @@ static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
                 cval->ch_readonly & (1 << (channel - 1));
 
         if (read_only) {
-                snd_printdd(KERN_INFO "%s(): channel %d of control %d is read_only\n",
+                usb_audio_dbg(cval->mixer->chip,
+                              "%s(): channel %d of control %d is read_only\n",
                             __func__, channel, cval->control);
                 return 0;
         }
@@ -560,7 +564,7 @@ int snd_usb_mixer_add_control(struct usb_mixer_interface *mixer,
         while (snd_ctl_find_id(mixer->chip->card, &kctl->id))
                 kctl->id.index++;
         if ((err = snd_ctl_add(mixer->chip->card, kctl)) < 0) {
-                snd_printd(KERN_ERR "cannot add control (err = %d)\n", err);
+                usb_audio_dbg(mixer->chip, "cannot add control (err = %d)\n", err);
                 return err;
         }
         cval->elem_id = &kctl->id;
@@ -807,7 +811,8 @@ static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
 static void volume_control_quirks(struct usb_mixer_elem_info *cval,
                                   struct snd_kcontrol *kctl)
 {
-        switch (cval->mixer->chip->usb_id) {
+        struct snd_usb_audio *chip = cval->mixer->chip;
+        switch (chip->usb_id) {
         case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
         case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C600 */
                 if (strcmp(kctl->id.name, "Effect Duration") == 0) {
@@ -839,8 +844,8 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval,
         case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
         case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
                 if (strcmp(kctl->id.name, "Effect Duration") == 0) {
-                        snd_printk(KERN_INFO
-                                "usb-audio: set quirk for FTU Effect Duration\n");
+                        usb_audio_info(chip,
+                                       "set quirk for FTU Effect Duration\n");
                         cval->min = 0x0000;
                         cval->max = 0x7f00;
                         cval->res = 0x0100;
@@ -848,8 +853,8 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval,
                 }
                 if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
                     strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
-                        snd_printk(KERN_INFO
-                                "usb-audio: set quirks for FTU Effect Feedback/Volume\n");
+                        usb_audio_info(chip,
+                                       "set quirks for FTU Effect Feedback/Volume\n");
                         cval->min = 0x00;
                         cval->max = 0x7f;
                         break;
@@ -867,7 +872,7 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval,
          */
                 if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
                     cval->min == -15616) {
-                        snd_printk(KERN_INFO
+                        usb_audio_info(chip,
                                  "set volume quirk for UDA1321/N101 chip\n");
                         cval->max = -256;
                 }
@@ -875,7 +880,7 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval,
 
         case USB_ID(0x046d, 0x09a4):
                 if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
-                        snd_printk(KERN_INFO
+                        usb_audio_info(chip,
                                 "set volume quirk for QuickCam E3500\n");
                         cval->min = 6080;
                         cval->max = 8768;
@@ -895,7 +900,7 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval,
          * Proboly there is some logitech magic behind this number --fishor
          */
                 if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
-                        snd_printk(KERN_INFO
+                        usb_audio_info(chip,
                                 "set resolution quirk: cval->res = 384\n");
                         cval->res = 384;
                 }
@@ -931,7 +936,8 @@ static int get_min_max_with_quirks(struct usb_mixer_elem_info *cval,
                 }
                 if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
                     get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
-                        snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
+                        usb_audio_err(cval->mixer->chip,
+                                      "%d:%d: cannot get min/max values for control %d (id %d)\n",
                                    cval->id, snd_usb_ctrl_intf(cval->mixer->chip), cval->control, cval->id);
                         return -EINVAL;
                 }
@@ -1195,7 +1201,7 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
 
         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
         if (! cval) {
-                snd_printk(KERN_ERR "cannot malloc kcontrol\n");
+                usb_audio_err(state->chip, "cannot malloc kcontrol\n");
                 return;
         }
         cval->mixer = state->mixer;
@@ -1224,7 +1230,7 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
                 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
 
         if (! kctl) {
-                snd_printk(KERN_ERR "cannot malloc kcontrol\n");
+                usb_audio_err(state->chip, "cannot malloc kcontrol\n");
                 kfree(cval);
                 return;
         }
@@ -1298,16 +1304,16 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
          * devices. It will definitively catch all buggy Logitech devices.
          */
         if (range > 384) {
-                snd_printk(KERN_WARNING "usb_audio: Warning! Unlikely big "
+                usb_audio_warn(state->chip, "Warning! Unlikely big "
                            "volume range (=%u), cval->res is probably wrong.",
                            range);
-                snd_printk(KERN_WARNING "usb_audio: [%d] FU [%s] ch = %d, "
+                usb_audio_warn(state->chip, "[%d] FU [%s] ch = %d, "
                            "val = %d/%d/%d", cval->id,
                            kctl->id.name, cval->channels,
                            cval->min, cval->max, cval->res);
         }
 
-        snd_printdd(KERN_INFO "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
+        usb_audio_dbg(state->chip, "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
                     cval->id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res);
         snd_usb_mixer_add_control(state->mixer, kctl);
 }
@@ -1331,16 +1337,17 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void
         if (state->mixer->protocol == UAC_VERSION_1) {
                 csize = hdr->bControlSize;
                 if (!csize) {
-                        snd_printdd(KERN_ERR "usbaudio: unit %u: "
-                                    "invalid bControlSize == 0\n", unitid);
+                        usb_audio_dbg(state->chip,
+                                      "unit %u: invalid bControlSize == 0\n",
+                                      unitid);
                         return -EINVAL;
                 }
                 channels = (hdr->bLength - 7) / csize - 1;
                 bmaControls = hdr->bmaControls;
                 if (hdr->bLength < 7 + csize) {
-                        snd_printk(KERN_ERR "usbaudio: unit %u: "
-                                   "invalid UAC_FEATURE_UNIT descriptor\n",
-                                   unitid);
+                        usb_audio_err(state->chip,
+                                      "unit %u: invalid UAC_FEATURE_UNIT descriptor\n",
+                                      unitid);
                         return -EINVAL;
                 }
         } else {
@@ -1349,9 +1356,9 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void
                 channels = (hdr->bLength - 6) / 4 - 1;
                 bmaControls = ftr->bmaControls;
                 if (hdr->bLength < 6 + csize) {
-                        snd_printk(KERN_ERR "usbaudio: unit %u: "
-                                   "invalid UAC_FEATURE_UNIT descriptor\n",
-                                   unitid);
+                        usb_audio_err(state->chip,
+                                      "unit %u: invalid UAC_FEATURE_UNIT descriptor\n",
+                                      unitid);
                         return -EINVAL;
                 }
         }
@@ -1369,14 +1376,14 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void
         /* master configuration quirks */
         switch (state->chip->usb_id) {
         case USB_ID(0x08bb, 0x2702):
-                snd_printk(KERN_INFO
-                           "usbmixer: master volume quirk for PCM2702 chip\n");
+                usb_audio_info(state->chip,
+                               "usbmixer: master volume quirk for PCM2702 chip\n");
                 /* disable non-functional volume control */
                 master_bits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME);
                 break;
         case USB_ID(0x1130, 0xf211):
-                snd_printk(KERN_INFO
-                           "usbmixer: volume control quirk for Tenx TP6911 Audio Headset\n");
+                usb_audio_info(state->chip,
+                               "usbmixer: volume control quirk for Tenx TP6911 Audio Headset\n");
                 /* disable non-functional volume control */
                 channels = 0;
                 break;
@@ -1478,7 +1485,7 @@ static void build_mixer_unit_ctl(struct mixer_build *state,
 
         kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
         if (! kctl) {
-                snd_printk(KERN_ERR "cannot malloc kcontrol\n");
+                usb_audio_err(state->chip, "cannot malloc kcontrol\n");
                 kfree(cval);
                 return;
         }
@@ -1491,7 +1498,7 @@ static void build_mixer_unit_ctl(struct mixer_build *state,
                 len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1);
         append_ctl_name(kctl, " Volume");
 
-        snd_printdd(KERN_INFO "[%d] MU [%s] ch = %d, val = %d/%d\n",
+        usb_audio_dbg(state->chip, "[%d] MU [%s] ch = %d, val = %d/%d\n",
                     cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
         snd_usb_mixer_add_control(state->mixer, kctl);
 }
@@ -1508,12 +1515,12 @@ static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, void *r
         int pin, ich, err;
 
         if (desc->bLength < 11 || ! (input_pins = desc->bNrInPins) || ! (num_outs = uac_mixer_unit_bNrChannels(desc))) {
-                snd_printk(KERN_ERR "invalid MIXER UNIT descriptor %d\n", unitid);
+                usb_audio_err(state->chip, "invalid MIXER UNIT descriptor %d\n", unitid);
                 return -EINVAL;
         }
         /* no bmControls field (e.g. Maya44) -> ignore */
         if (desc->bLength <= 10 + input_pins) {
-                snd_printdd(KERN_INFO "MU %d has no bmControls field\n", unitid);
+                usb_audio_dbg(state->chip, "MU %d has no bmControls field\n", unitid);
                 return 0;
         }
 
@@ -1712,7 +1719,7 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, void *raw
 
         if (desc->bLength < 13 || desc->bLength < 13 + num_ins ||
             desc->bLength < num_ins + uac_processing_unit_bControlSize(desc, state->mixer->protocol)) {
-                snd_printk(KERN_ERR "invalid %s descriptor (id %d)\n", name, unitid);
+                usb_audio_err(state->chip, "invalid %s descriptor (id %d)\n", name, unitid);
                 return -EINVAL;
         }
 
@@ -1738,7 +1745,7 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, void *raw
                         continue;
                 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
                 if (! cval) {
-                        snd_printk(KERN_ERR "cannot malloc kcontrol\n");
+                        usb_audio_err(state->chip, "cannot malloc kcontrol\n");
                         return -ENOMEM;
                 }
                 cval->mixer = state->mixer;
@@ -1770,7 +1777,7 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, void *raw
 
                 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
                 if (! kctl) {
-                        snd_printk(KERN_ERR "cannot malloc kcontrol\n");
+                        usb_audio_err(state->chip, "cannot malloc kcontrol\n");
                         kfree(cval);
                         return -ENOMEM;
                 }
@@ -1792,7 +1799,8 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, void *raw
                 append_ctl_name(kctl, " ");
                 append_ctl_name(kctl, valinfo->suffix);
 
-                snd_printdd(KERN_INFO "[%d] PU [%s] ch = %d, val = %d/%d\n",
+                usb_audio_dbg(state->chip,
+                        "[%d] PU [%s] ch = %d, val = %d/%d\n",
                             cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
                 if ((err = snd_usb_mixer_add_control(state->mixer, kctl)) < 0)
                         return err;
@@ -1917,7 +1925,8 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void
         char **namelist;
 
         if (!desc->bNrInPins || desc->bLength < 5 + desc->bNrInPins) {
-                snd_printk(KERN_ERR "invalid SELECTOR UNIT descriptor %d\n", unitid);
+                usb_audio_err(state->chip,
+                        "invalid SELECTOR UNIT descriptor %d\n", unitid);
                 return -EINVAL;
         }
 
@@ -1935,7 +1944,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void
 
         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
         if (! cval) {
-                snd_printk(KERN_ERR "cannot malloc kcontrol\n");
+                usb_audio_err(state->chip, "cannot malloc kcontrol\n");
                 return -ENOMEM;
         }
         cval->mixer = state->mixer;
@@ -1954,7 +1963,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void
 
         namelist = kmalloc(sizeof(char *) * desc->bNrInPins, GFP_KERNEL);
         if (! namelist) {
-                snd_printk(KERN_ERR "cannot malloc\n");
+                usb_audio_err(state->chip, "cannot malloc\n");
                 kfree(cval);
                 return -ENOMEM;
         }
@@ -1964,7 +1973,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void
                 len = 0;
                 namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
                 if (! namelist[i]) {
-                        snd_printk(KERN_ERR "cannot malloc\n");
+                        usb_audio_err(state->chip, "cannot malloc\n");
                         while (i--)
                                 kfree(namelist[i]);
                         kfree(namelist);
@@ -1981,7 +1990,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void
 
         kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
         if (! kctl) {
-                snd_printk(KERN_ERR "cannot malloc kcontrol\n");
+                usb_audio_err(state->chip, "cannot malloc kcontrol\n");
                 kfree(namelist);
                 kfree(cval);
                 return -ENOMEM;
@@ -2009,7 +2018,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void
                         append_ctl_name(kctl, " Playback Source");
         }
 
-        snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n",
+        usb_audio_dbg(state->chip, "[%d] SU [%s] items = %d\n",
                     cval->id, kctl->id.name, desc->bNrInPins);
         if ((err = snd_usb_mixer_add_control(state->mixer, kctl)) < 0)
                 return err;
@@ -2031,7 +2040,7 @@ static int parse_audio_unit(struct mixer_build *state, int unitid)
 
         p1 = find_audio_control_unit(state, unitid);
         if (!p1) {
-                snd_printk(KERN_ERR "usbaudio: unit %d not found!\n", unitid);
+                usb_audio_err(state->chip, "unit %d not found!\n", unitid);
                 return -EINVAL;
         }
 
@@ -2061,7 +2070,8 @@ static int parse_audio_unit(struct mixer_build *state, int unitid)
         case UAC2_EXTENSION_UNIT_V2:
                 return parse_audio_extension_unit(state, unitid, p1);
         default:
-                snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
+                usb_audio_err(state->chip,
+                        "unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
                 return -EINVAL;
         }
 }
@@ -2209,8 +2219,9 @@ static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
         __u8 channel = value & 0xff;
 
         if (channel >= MAX_CHANNELS) {
-                snd_printk(KERN_DEBUG "%s(): bogus channel number %d\n",
-                                __func__, channel);
+                usb_audio_dbg(mixer->chip,
+                        "%s(): bogus channel number %d\n",
+                        __func__, channel);
                 return;
         }
 
@@ -2239,8 +2250,9 @@ static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
                         break;
 
                 default:
-                        snd_printk(KERN_DEBUG "unknown attribute %d in interrupt\n",
-                                                attribute);
+                        usb_audio_dbg(mixer->chip,
+                                "unknown attribute %d in interrupt\n",
+                                attribute);
                         break;
                 } /* switch */
         }
@@ -2261,7 +2273,7 @@ static void snd_usb_mixer_interrupt(struct urb *urb)
                 for (status = urb->transfer_buffer;
                      len >= sizeof(*status);
                      len -= sizeof(*status), status++) {
-                        snd_printd(KERN_DEBUG "status interrupt: %02x %02x\n",
+                        dev_dbg(&urb->dev->dev, "status interrupt: %02x %02x\n",
                                                 status->bStatusType,
                                                 status->bOriginator);
 
diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c
index f4b12c216f1c..f119a41ed9a9 100644
--- a/sound/usb/mixer_quirks.c
+++ b/sound/usb/mixer_quirks.c
@@ -600,8 +600,8 @@ static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
         up_read(&mixer->chip->shutdown_rwsem);
 
         if (ret < 0) {
-                snd_printk(KERN_ERR
-                           "unable to issue vendor read request (ret = %d)", ret);
+                dev_err(&dev->dev,
+                        "unable to issue vendor read request (ret = %d)", ret);
                 return ret;
         }
 
@@ -631,8 +631,8 @@ static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
         up_read(&mixer->chip->shutdown_rwsem);
 
         if (ret < 0) {
-                snd_printk(KERN_ERR
-                           "unable to issue vendor write request (ret = %d)", ret);
+                dev_err(&dev->dev,
+                        "unable to issue vendor write request (ret = %d)", ret);
                 return ret;
         }
 
@@ -1699,7 +1699,7 @@ void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
                         snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
                 break;
         default:
-                snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
+                usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
                 break;
         }
 }
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index ca3256d6fde3..49de5c1284f6 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -166,8 +166,8 @@ static int init_pitch_v1(struct snd_usb_audio *chip, int iface,
                                    USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
                                    UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep,
                                    data, sizeof(data))) < 0) {
-                snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
-                           dev->devnum, iface, ep);
+                usb_audio_err(chip, "%d:%d: cannot set enable PITCH\n",
+                              iface, ep);
                 return err;
         }
 
@@ -187,8 +187,8 @@ static int init_pitch_v2(struct snd_usb_audio *chip, int iface,
                                    USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                                    UAC2_EP_CS_PITCH << 8, 0,
                                    data, sizeof(data))) < 0) {
-                snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH (v2)\n",
-                           dev->devnum, iface, fmt->altsetting);
+                usb_audio_err(chip, "%d:%d: cannot set enable PITCH (v2)\n",
+                              iface, fmt->altsetting);
                 return err;
         }
 
@@ -226,7 +226,7 @@ static int start_endpoints(struct snd_usb_substream *subs, bool can_sleep)
         if (!test_and_set_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) {
                 struct snd_usb_endpoint *ep = subs->data_endpoint;
 
-                snd_printdd(KERN_DEBUG "Starting data EP @%p\n", ep);
+                dev_dbg(&subs->dev->dev, "Starting data EP @%p\n", ep);
 
                 ep->data_subs = subs;
                 err = snd_usb_endpoint_start(ep, can_sleep);
@@ -247,16 +247,15 @@ static int start_endpoints(struct snd_usb_substream *subs, bool can_sleep)
                                                 subs->sync_endpoint->altsetting);
                         if (err < 0) {
                                 clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags);
-                                snd_printk(KERN_ERR
-                                           "%d:%d:%d: cannot set interface (%d)\n",
-                                           subs->dev->devnum,
+                                dev_err(&subs->dev->dev,
+                                           "%d:%d: cannot set interface (%d)\n",
                                            subs->sync_endpoint->iface,
                                            subs->sync_endpoint->altsetting, err);
                                 return -EIO;
                         }
                 }
 
-                snd_printdd(KERN_DEBUG "Starting sync EP @%p\n", ep);
+                dev_dbg(&subs->dev->dev, "Starting sync EP @%p\n", ep);
 
                 ep->sync_slave = subs->data_endpoint;
                 err = snd_usb_endpoint_start(ep, can_sleep);
@@ -410,8 +409,9 @@ static int set_sync_endpoint(struct snd_usb_substream *subs,
         if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_ISOC ||
             (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
              get_endpoint(alts, 1)->bSynchAddress != 0)) {
-                snd_printk(KERN_ERR "%d:%d:%d : invalid sync pipe. bmAttributes %02x, bLength %d, bSynchAddress %02x\n",
-                           dev->devnum, fmt->iface, fmt->altsetting,
+                dev_err(&dev->dev,
+                        "%d:%d : invalid sync pipe. bmAttributes %02x, bLength %d, bSynchAddress %02x\n",
+                           fmt->iface, fmt->altsetting,
                            get_endpoint(alts, 1)->bmAttributes,
                            get_endpoint(alts, 1)->bLength,
                            get_endpoint(alts, 1)->bSynchAddress);
@@ -421,8 +421,9 @@ static int set_sync_endpoint(struct snd_usb_substream *subs,
         if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
             ((is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
              (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
-                snd_printk(KERN_ERR "%d:%d:%d : invalid sync pipe. is_playback %d, ep %02x, bSynchAddress %02x\n",
-                           dev->devnum, fmt->iface, fmt->altsetting,
+                dev_err(&dev->dev,
+                        "%d:%d : invalid sync pipe. is_playback %d, ep %02x, bSynchAddress %02x\n",
+                           fmt->iface, fmt->altsetting,
                            is_playback, ep, get_endpoint(alts, 0)->bSynchAddress);
                 return -EINVAL;
         }
@@ -469,8 +470,9 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
         if (subs->interface >= 0 && subs->interface != fmt->iface) {
                 err = usb_set_interface(subs->dev, subs->interface, 0);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed (%d)\n",
-                                dev->devnum, fmt->iface, fmt->altsetting, err);
+                        dev_err(&dev->dev,
+                                "%d:%d: return to setting 0 failed (%d)\n",
+                                fmt->iface, fmt->altsetting, err);
                         return -EIO;
                 }
                 subs->interface = -1;
@@ -482,12 +484,13 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
             subs->altset_idx != fmt->altset_idx) {
                 err = usb_set_interface(dev, fmt->iface, fmt->altsetting);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed (%d)\n",
-                                   dev->devnum, fmt->iface, fmt->altsetting, err);
+                        dev_err(&dev->dev,
+                                "%d:%d: usb_set_interface failed (%d)\n",
+                                fmt->iface, fmt->altsetting, err);
                         return -EIO;
                 }
-                snd_printdd(KERN_INFO "setting usb interface %d:%d\n",
-                                fmt->iface, fmt->altsetting);
+                dev_dbg(&dev->dev, "setting usb interface %d:%d\n",
+                        fmt->iface, fmt->altsetting);
                 subs->interface = fmt->iface;
                 subs->altset_idx = fmt->altset_idx;
 
@@ -523,20 +526,23 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
  * - Requested PCM format is not supported.
  * - Requested sample rate is not supported.
  */
-static int match_endpoint_audioformats(struct audioformat *fp,
-        struct audioformat *match, int rate,
-        snd_pcm_format_t pcm_format)
+static int match_endpoint_audioformats(struct snd_usb_substream *subs,
+                                       struct audioformat *fp,
+                                       struct audioformat *match, int rate,
+                                       snd_pcm_format_t pcm_format)
 {
         int i;
         int score = 0;
 
         if (fp->channels < 1) {
-                snd_printdd("%s: (fmt @%p) no channels\n", __func__, fp);
+                dev_dbg(&subs->dev->dev,
+                        "%s: (fmt @%p) no channels\n", __func__, fp);
                 return 0;
         }
 
         if (!(fp->formats & pcm_format_to_bits(pcm_format))) {
-                snd_printdd("%s: (fmt @%p) no match for format %d\n", __func__,
+                dev_dbg(&subs->dev->dev,
+                        "%s: (fmt @%p) no match for format %d\n", __func__,
                         fp, pcm_format);
                 return 0;
         }
@@ -548,7 +554,8 @@ static int match_endpoint_audioformats(struct audioformat *fp,
                 }
         }
         if (!score) {
-                snd_printdd("%s: (fmt @%p) no match for rate %d\n", __func__,
+                dev_dbg(&subs->dev->dev,
+                        "%s: (fmt @%p) no match for rate %d\n", __func__,
                         fp, rate);
                 return 0;
         }
@@ -556,7 +563,8 @@ static int match_endpoint_audioformats(struct audioformat *fp,
         if (fp->channels == match->channels)
                 score++;
 
-        snd_printdd("%s: (fmt @%p) score %d\n", __func__, fp, score);
+        dev_dbg(&subs->dev->dev,
+                "%s: (fmt @%p) score %d\n", __func__, fp, score);
 
         return score;
 }
@@ -587,7 +595,8 @@ static int configure_sync_endpoint(struct snd_usb_substream *subs)
 
         /* Try to find the best matching audioformat. */
         list_for_each_entry(fp, &sync_subs->fmt_list, list) {
-                int score = match_endpoint_audioformats(fp, subs->cur_audiofmt,
+                int score = match_endpoint_audioformats(subs,
+                                                        fp, subs->cur_audiofmt,
                         subs->cur_rate, subs->pcm_format);
 
                 if (score > cur_score) {
@@ -597,7 +606,8 @@ static int configure_sync_endpoint(struct snd_usb_substream *subs)
         }
 
         if (unlikely(sync_fp == NULL)) {
-                snd_printk(KERN_ERR "%s: no valid audioformat for sync ep %x found\n",
+                dev_err(&subs->dev->dev,
+                        "%s: no valid audioformat for sync ep %x found\n",
                         __func__, sync_subs->ep_num);
                 return -EINVAL;
         }
@@ -609,7 +619,8 @@ static int configure_sync_endpoint(struct snd_usb_substream *subs)
         if (sync_fp->channels != subs->channels) {
                 sync_period_bytes = (subs->period_bytes / subs->channels) *
                         sync_fp->channels;
-                snd_printdd("%s: adjusted sync ep period bytes (%d -> %d)\n",
+                dev_dbg(&subs->dev->dev,
+                        "%s: adjusted sync ep period bytes (%d -> %d)\n",
                         __func__, subs->period_bytes, sync_period_bytes);
         }
 
@@ -685,7 +696,8 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
 
         fmt = find_format(subs);
         if (!fmt) {
-                snd_printd(KERN_DEBUG "cannot set format: format = %#x, rate = %d, channels = %d\n",
+                dev_dbg(&subs->dev->dev,
+                        "cannot set format: format = %#x, rate = %d, channels = %d\n",
                            subs->pcm_format, subs->cur_rate, subs->channels);
                 return -EINVAL;
         }
@@ -742,7 +754,7 @@ static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
         int ret;
 
         if (! subs->cur_audiofmt) {
-                snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
+                dev_err(&subs->dev->dev, "no format is specified!\n");
                 return -ENXIO;
         }
 
@@ -1235,7 +1247,8 @@ static void retire_capture_urb(struct snd_usb_substream *subs,
         for (i = 0; i < urb->number_of_packets; i++) {
                 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset + subs->pkt_offset_adj;
                 if (urb->iso_frame_desc[i].status && printk_ratelimit()) {
-                        snd_printdd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
+                        dev_dbg(&subs->dev->dev, "frame %d active: %d\n",
+                                i, urb->iso_frame_desc[i].status);
                         // continue;
                 }
                 bytes = urb->iso_frame_desc[i].actual_length;
@@ -1245,7 +1258,8 @@ static void retire_capture_urb(struct snd_usb_substream *subs,
                 if (bytes % (runtime->sample_bits >> 3) != 0) {
                         int oldbytes = bytes;
                         bytes = frames * stride;
-                        snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
+                        dev_warn(&subs->dev->dev,
+                                 "Corrected urb data len. %d->%d\n",
                                                         oldbytes, bytes);
                 }
                 /* update the current pointer */
@@ -1488,7 +1502,8 @@ static void retire_playback_urb(struct snd_usb_substream *subs,
          * on two reads of a counter updated every ms.
          */
         if (abs(est_delay - subs->last_delay) * 1000 > runtime->rate * 2)
-                snd_printk(KERN_DEBUG "delay: estimated %d, actual %d\n",
+                dev_dbg(&subs->dev->dev,
+                        "delay: estimated %d, actual %d\n",
                         est_delay, subs->last_delay);
 
         if (!subs->running) {
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
index 89730707614c..7c57f2268dd7 100644
--- a/sound/usb/quirks.c
+++ b/sound/usb/quirks.c
@@ -110,7 +110,7 @@ static int create_standard_audio_quirk(struct snd_usb_audio *chip,
         altsd = get_iface_desc(alts);
         err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber);
         if (err < 0) {
-                snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
+                usb_audio_err(chip, "cannot setup if %d: error %d\n",
                            altsd->bInterfaceNumber, err);
                 return err;
         }
@@ -135,7 +135,7 @@ static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
 
         fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
         if (!fp) {
-                snd_printk(KERN_ERR "cannot memdup\n");
+                usb_audio_err(chip, "cannot memdup\n");
                 return -ENOMEM;
         }
         if (fp->nr_rates > MAX_NR_RATES) {
@@ -464,7 +464,7 @@ static int create_uaxx_quirk(struct snd_usb_audio *chip,
                 fp->rate_max = fp->rate_min = 96000;
                 break;
         default:
-                snd_printk(KERN_ERR "unknown sample rate\n");
+                usb_audio_err(chip, "unknown sample rate\n");
                 kfree(fp);
                 return -ENXIO;
         }
@@ -536,7 +536,7 @@ int snd_usb_create_quirk(struct snd_usb_audio *chip,
         if (quirk->type < QUIRK_TYPE_COUNT) {
                 return quirk_funcs[quirk->type](chip, iface, driver, quirk);
         } else {
-                snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
+                usb_audio_err(chip, "invalid quirk type %d\n", quirk->type);
                 return -ENXIO;
         }
 }
@@ -555,18 +555,21 @@ static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interfac
 
         if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
             le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
-                snd_printdd("sending Extigy boot sequence...\n");
+                dev_dbg(&dev->dev, "sending Extigy boot sequence...\n");
                 /* Send message to force it to reconnect with full interface. */
                 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
                                       0x10, 0x43, 0x0001, 0x000a, NULL, 0);
-                if (err < 0) snd_printdd("error sending boot message: %d\n", err);
+                if (err < 0)
+                        dev_dbg(&dev->dev, "error sending boot message: %d\n", err);
                 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
                                 &dev->descriptor, sizeof(dev->descriptor));
                 config = dev->actconfig;
-                if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err);
+                if (err < 0)
+                        dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
                 err = usb_reset_configuration(dev);
-                if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err);
-                snd_printdd("extigy_boot: new boot length = %d\n",
+                if (err < 0)
+                        dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
+                dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n",
                             le16_to_cpu(get_cfg_desc(config)->wTotalLength));
                 return -ENODEV; /* quit this anyway */
         }
@@ -594,7 +597,7 @@ static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev)
         int err;
 
         if (dev->actconfig->desc.bConfigurationValue == 1) {
-                snd_printk(KERN_INFO "usb-audio: "
+                dev_info(&dev->dev,
                            "Fast Track Pro switching to config #2\n");
                 /* This function has to be available by the usb core module.
                  * if it is not avialable the boot quirk has to be left out
@@ -603,14 +606,15 @@ static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev)
                  */
                 err = usb_driver_set_configuration(dev, 2);
                 if (err < 0)
-                        snd_printdd("error usb_driver_set_configuration: %d\n",
-                                    err);
+                        dev_dbg(&dev->dev,
+                                "error usb_driver_set_configuration: %d\n",
+                                err);
                 /* Always return an error, so that we stop creating a device
                    that will just be destroyed and recreated with a new
                    configuration */
                 return -ENODEV;
         } else
-                snd_printk(KERN_INFO "usb-audio: Fast Track Pro config OK\n");
+                dev_info(&dev->dev, "Fast Track Pro config OK\n");
 
         return 0;
 }
@@ -779,11 +783,11 @@ static int snd_usb_mbox2_boot_quirk(struct usb_device *dev)
         fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength);
 
         if (fwsize != MBOX2_FIRMWARE_SIZE) {
-                snd_printk(KERN_ERR "usb-audio: Invalid firmware size=%d.\n", fwsize);
+                dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize);
                 return -ENODEV;
         }
 
-        snd_printd("usb-audio: Sending Digidesign Mbox 2 boot sequence...\n");
+        dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n");
 
         count = 0;
         bootresponse[0] = MBOX2_BOOT_LOADING;
@@ -794,32 +798,32 @@ static int snd_usb_mbox2_boot_quirk(struct usb_device *dev)
                         0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012);
                 if (bootresponse[0] == MBOX2_BOOT_READY)
                         break;
-                snd_printd("usb-audio: device not ready, resending boot sequence...\n");
+                dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n");
                 count++;
         }
 
         if (bootresponse[0] != MBOX2_BOOT_READY) {
-                snd_printk(KERN_ERR "usb-audio: Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]);
+                dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]);
                 return -ENODEV;
         }
 
-        snd_printdd("usb-audio: device initialised!\n");
+        dev_dbg(&dev->dev, "device initialised!\n");
 
         err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
                 &dev->descriptor, sizeof(dev->descriptor));
         config = dev->actconfig;
         if (err < 0)
-                snd_printd("error usb_get_descriptor: %d\n", err);
+                dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
 
         err = usb_reset_configuration(dev);
         if (err < 0)
-                snd_printd("error usb_reset_configuration: %d\n", err);
-        snd_printdd("mbox2_boot: new boot length = %d\n",
+                dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
+        dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n",
                 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
 
         mbox2_setup_48_24_magic(dev);
 
-        snd_printk(KERN_INFO "usb-audio: Digidesign Mbox 2: 24bit 48kHz");
+        dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz");
 
         return 0; /* Successful boot */
 }
@@ -865,7 +869,7 @@ static int quattro_skip_setting_quirk(struct snd_usb_audio *chip,
                                 return 1; /* skip this altsetting */
                 }
         }
-        snd_printdd(KERN_INFO
+        usb_audio_dbg(chip,
                     "using altsetting %d for interface %d config %d\n",
                     altno, iface, chip->setup);
         return 0; /* keep this altsetting */
@@ -932,7 +936,7 @@ static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip,
                         return 1;
         }
 
-        snd_printdd(KERN_INFO
+        usb_audio_dbg(chip,
                     "using altsetting %d for interface %d config %d\n",
                     altno, iface, chip->setup);
         return 0; /* keep this altsetting */
diff --git a/sound/usb/stream.c b/sound/usb/stream.c
index 2fb71be5e100..310a3822d2b7 100644
--- a/sound/usb/stream.c
+++ b/sound/usb/stream.c
@@ -411,10 +411,9 @@ static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip,
 
         if (!csep || csep->bLength < 7 ||
             csep->bDescriptorSubtype != UAC_EP_GENERAL) {
-                snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
-                           " class specific endpoint descriptor\n",
-                           chip->dev->devnum, iface_no,
-                           altsd->bAlternateSetting);
+                usb_audio_warn(chip,
+                               "%u:%d : no or invalid class specific endpoint descriptor\n",
+                               iface_no, altsd->bAlternateSetting);
                 return 0;
         }
 
@@ -533,8 +532,8 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
                 /* get audio formats */
                 switch (protocol) {
                 default:
-                        snd_printdd(KERN_WARNING "%d:%u:%d: unknown interface protocol %#02x, assuming v1\n",
-                                    dev->devnum, iface_no, altno, protocol);
+                        dev_dbg(&dev->dev, "%u:%d: unknown interface protocol %#02x, assuming v1\n",
+                                iface_no, altno, protocol);
                         protocol = UAC_VERSION_1;
                         /* fall through */
 
@@ -544,14 +543,16 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
                         struct uac_input_terminal_descriptor *iterm;
 
                         if (!as) {
-                                snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
-                                           dev->devnum, iface_no, altno);
+                                dev_err(&dev->dev,
+                                        "%u:%d : UAC_AS_GENERAL descriptor not found\n",
+                                        iface_no, altno);
                                 continue;
                         }
 
                         if (as->bLength < sizeof(*as)) {
-                                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
-                                           dev->devnum, iface_no, altno);
+                                dev_err(&dev->dev,
+                                        "%u:%d : invalid UAC_AS_GENERAL desc\n",
+                                        iface_no, altno);
                                 continue;
                         }
 
@@ -574,14 +575,16 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
                                 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
 
                         if (!as) {
-                                snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
-                                           dev->devnum, iface_no, altno);
+                                dev_err(&dev->dev,
+                                        "%u:%d : UAC_AS_GENERAL descriptor not found\n",
+                                        iface_no, altno);
                                 continue;
                         }
 
                         if (as->bLength < sizeof(*as)) {
-                                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
-                                           dev->devnum, iface_no, altno);
+                                dev_err(&dev->dev,
+                                        "%u:%d : invalid UAC_AS_GENERAL desc\n",
+                                        iface_no, altno);
                                 continue;
                         }
 
@@ -607,8 +610,9 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
                                 break;
                         }
 
-                        snd_printk(KERN_ERR "%d:%u:%d : bogus bTerminalLink %d\n",
-                                   dev->devnum, iface_no, altno, as->bTerminalLink);
+                        dev_err(&dev->dev,
+                                "%u:%d : bogus bTerminalLink %d\n",
+                                iface_no, altno, as->bTerminalLink);
                         continue;
                 }
                 }
@@ -616,14 +620,16 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
                 /* get format type */
                 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE);
                 if (!fmt) {
-                        snd_printk(KERN_ERR "%d:%u:%d : no UAC_FORMAT_TYPE desc\n",
-                                   dev->devnum, iface_no, altno);
+                        dev_err(&dev->dev,
+                                "%u:%d : no UAC_FORMAT_TYPE desc\n",
+                                iface_no, altno);
                         continue;
                 }
                 if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) ||
                     ((protocol == UAC_VERSION_2) && (fmt->bLength < 6))) {
-                        snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
-                                   dev->devnum, iface_no, altno);
+                        dev_err(&dev->dev,
+                                "%u:%d : invalid UAC_FORMAT_TYPE desc\n",
+                                iface_no, altno);
                         continue;
                 }
 
@@ -644,7 +650,7 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
 
                 fp = kzalloc(sizeof(*fp), GFP_KERNEL);
                 if (! fp) {
-                        snd_printk(KERN_ERR "cannot malloc\n");
+                        dev_err(&dev->dev, "cannot malloc\n");
                         return -ENOMEM;
                 }
 
@@ -707,7 +713,7 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
                         chconfig = 0;
                 fp->chmap = convert_chmap(fp->channels, chconfig, protocol);
 
-                snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint %#x\n", dev->devnum, iface_no, altno, fp->endpoint);
+                dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint);
                 err = snd_usb_add_audio_stream(chip, stream, fp);
                 if (err < 0) {
                         kfree(fp->rate_table);
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index 5d2fe0530745..25c4c7e217de 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -60,6 +60,15 @@ struct snd_usb_audio {
         struct usb_host_interface *ctrl_intf;   /* the audio control interface */
 };
 
+#define usb_audio_err(chip, fmt, args...) \
+        dev_err(&(chip)->dev->dev, fmt, ##args)
+#define usb_audio_warn(chip, fmt, args...) \
+        dev_warn(&(chip)->dev->dev, fmt, ##args)
+#define usb_audio_info(chip, fmt, args...) \
+        dev_info(&(chip)->dev->dev, fmt, ##args)
+#define usb_audio_dbg(chip, fmt, args...) \
+        dev_dbg(&(chip)->dev->dev, fmt, ##args)
+
 /*
  * Information about devices with broken descriptors
  */