Merge branch 'for-next' into for-linus

42 files changed, 519 insertions, 555 deletions

diff --git a/sound/core/control.c b/sound/core/control.c
index d8aa206e8bde..f038f5afafe2 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -151,7 +151,7 @@ void snd_ctl_notify(struct snd_card *card, unsigned int mask,
         if (snd_BUG_ON(!card || !id))
                 return;
         read_lock(&card->ctl_files_rwlock);
-#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
         card->mixer_oss_change_count++;
 #endif
         list_for_each_entry(ctl, &card->ctl_files, list) {
@@ -170,7 +170,7 @@ void snd_ctl_notify(struct snd_card *card, unsigned int mask,
                         ev->mask = mask;
                         list_add_tail(&ev->list, &ctl->events);
                 } else {
-                        snd_printk(KERN_ERR "No memory available to allocate event\n");
+                        dev_err(card->dev, "No memory available to allocate event\n");
                 }
         _found:
                 wake_up(&ctl->change_sleep);
@@ -206,7 +206,7 @@ static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control,
 
         kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
         if (kctl == NULL) {
-                snd_printk(KERN_ERR "Cannot allocate control instance\n");
+                pr_err("ALSA: Cannot allocate control instance\n");
                 return NULL;
         }
         *kctl = *control;
@@ -241,9 +241,8 @@ struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
         if (ncontrol->name) {
                 strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
                 if (strcmp(ncontrol->name, kctl.id.name) != 0)
-                        snd_printk(KERN_WARNING
-                                   "Control name '%s' truncated to '%s'\n",
-                                   ncontrol->name, kctl.id.name);
+                        pr_warn("ALSA: Control name '%s' truncated to '%s'\n",
+                                ncontrol->name, kctl.id.name);
         }
         kctl.id.index = ncontrol->index;
         kctl.count = ncontrol->count ? ncontrol->count : 1;
@@ -306,7 +305,7 @@ static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
         while (snd_ctl_remove_numid_conflict(card, count)) {
                 if (--iter == 0) {
                         /* this situation is very unlikely */
-                        snd_printk(KERN_ERR "unable to allocate new control numid\n");
+                        dev_err(card->dev, "unable to allocate new control numid\n");
                         return -ENOMEM;
                 }
         }
@@ -341,7 +340,7 @@ int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
         down_write(&card->controls_rwsem);
         if (snd_ctl_find_id(card, &id)) {
                 up_write(&card->controls_rwsem);
-                snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
+                dev_err(card->dev, "control %i:%i:%i:%s:%i is already present\n",
                                         id.iface,
                                         id.device,
                                         id.subdevice,
@@ -1406,7 +1405,7 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg
                 }
         }
         up_read(&snd_ioctl_rwsem);
-        snd_printdd("unknown ioctl = 0x%x\n", cmd);
+        dev_dbg(card->dev, "unknown ioctl = 0x%x\n", cmd);
         return -ENOTTY;
 }
 
diff --git a/sound/core/control_compat.c b/sound/core/control_compat.c
index 2bb95a7a8809..b9c0910fb8c4 100644
--- a/sound/core/control_compat.c
+++ b/sound/core/control_compat.c
@@ -247,7 +247,7 @@ static int copy_ctl_value_from_user(struct snd_card *card,
         } else {
                 size = get_elem_size(type, count);
                 if (size < 0) {
-                        printk(KERN_ERR "snd_ioctl32_ctl_elem_value: unknown type %d\n", type);
+                        dev_err(card->dev, "snd_ioctl32_ctl_elem_value: unknown type %d\n", type);
                         return -EINVAL;
                 }
                 if (copy_from_user(data->value.bytes.data,
diff --git a/sound/core/device.c b/sound/core/device.c
index df88defed176..41bec3075ae5 100644
--- a/sound/core/device.c
+++ b/sound/core/device.c
@@ -41,29 +41,73 @@
  *
  * Return: Zero if successful, or a negative error code on failure.
  */
-int snd_device_new(struct snd_card *card, snd_device_type_t type,
+int snd_device_new(struct snd_card *card, enum snd_device_type type,
                    void *device_data, struct snd_device_ops *ops)
 {
         struct snd_device *dev;
+        struct list_head *p;
 
         if (snd_BUG_ON(!card || !device_data || !ops))
                 return -ENXIO;
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (dev == NULL) {
-                snd_printk(KERN_ERR "Cannot allocate device\n");
+                dev_err(card->dev, "Cannot allocate device, type=%d\n", type);
                 return -ENOMEM;
         }
+        INIT_LIST_HEAD(&dev->list);
         dev->card = card;
         dev->type = type;
         dev->state = SNDRV_DEV_BUILD;
         dev->device_data = device_data;
         dev->ops = ops;
-        list_add(&dev->list, &card->devices);   /* add to the head of list */
+
+        /* insert the entry in an incrementally sorted list */
+        list_for_each_prev(p, &card->devices) {
+                struct snd_device *pdev = list_entry(p, struct snd_device, list);
+                if ((unsigned int)pdev->type <= (unsigned int)type)
+                        break;
+        }
+
+        list_add(&dev->list, p);
         return 0;
 }
-
 EXPORT_SYMBOL(snd_device_new);
 
+static int __snd_device_disconnect(struct snd_device *dev)
+{
+        if (dev->state == SNDRV_DEV_REGISTERED) {
+                if (dev->ops->dev_disconnect &&
+                    dev->ops->dev_disconnect(dev))
+                        dev_err(dev->card->dev, "device disconnect failure\n");
+                dev->state = SNDRV_DEV_DISCONNECTED;
+        }
+        return 0;
+}
+
+static void __snd_device_free(struct snd_device *dev)
+{
+        /* unlink */
+        list_del(&dev->list);
+
+        __snd_device_disconnect(dev);
+        if (dev->ops->dev_free) {
+                if (dev->ops->dev_free(dev))
+                        dev_err(dev->card->dev, "device free failure\n");
+        }
+        kfree(dev);
+}
+
+static struct snd_device *look_for_dev(struct snd_card *card, void *device_data)
+{
+        struct snd_device *dev;
+
+        list_for_each_entry(dev, &card->devices, list)
+                if (dev->device_data == device_data)
+                        return dev;
+
+        return NULL;
+}
+
 /**
  * snd_device_free - release the device from the card
  * @card: the card instance
@@ -72,73 +116,33 @@ EXPORT_SYMBOL(snd_device_new);
  * Removes the device from the list on the card and invokes the
  * callbacks, dev_disconnect and dev_free, corresponding to the state.
  * Then release the device.
- *
- * Return: Zero if successful, or a negative error code on failure or if the
- * device not found.
  */
-int snd_device_free(struct snd_card *card, void *device_data)
+void snd_device_free(struct snd_card *card, void *device_data)
 {
         struct snd_device *dev;
         
         if (snd_BUG_ON(!card || !device_data))
-                return -ENXIO;
-        list_for_each_entry(dev, &card->devices, list) {
-                if (dev->device_data != device_data)
-                        continue;
-                /* unlink */
-                list_del(&dev->list);
-                if (dev->state == SNDRV_DEV_REGISTERED &&
-                    dev->ops->dev_disconnect)
-                        if (dev->ops->dev_disconnect(dev))
-                                snd_printk(KERN_ERR
-                                           "device disconnect failure\n");
-                if (dev->ops->dev_free) {
-                        if (dev->ops->dev_free(dev))
-                                snd_printk(KERN_ERR "device free failure\n");
-                }
-                kfree(dev);
-                return 0;
-        }
-        snd_printd("device free %p (from %pF), not found\n", device_data,
-                   __builtin_return_address(0));
-        return -ENXIO;
+                return;
+        dev = look_for_dev(card, device_data);
+        if (dev)
+                __snd_device_free(dev);
+        else
+                dev_dbg(card->dev, "device free %p (from %pF), not found\n",
+                        device_data, __builtin_return_address(0));
 }
-
 EXPORT_SYMBOL(snd_device_free);
 
-/**
- * snd_device_disconnect - disconnect the device
- * @card: the card instance
- * @device_data: the data pointer to disconnect
- *
- * Turns the device into the disconnection state, invoking
- * dev_disconnect callback, if the device was already registered.
- *
- * Usually called from snd_card_disconnect().
- *
- * Return: Zero if successful, or a negative error code on failure or if the
- * device not found.
- */
-int snd_device_disconnect(struct snd_card *card, void *device_data)
+static int __snd_device_register(struct snd_device *dev)
 {
-        struct snd_device *dev;
-
-        if (snd_BUG_ON(!card || !device_data))
-                return -ENXIO;
-        list_for_each_entry(dev, &card->devices, list) {
-                if (dev->device_data != device_data)
-                        continue;
-                if (dev->state == SNDRV_DEV_REGISTERED &&
-                    dev->ops->dev_disconnect) {
-                        if (dev->ops->dev_disconnect(dev))
-                                snd_printk(KERN_ERR "device disconnect failure\n");
-                        dev->state = SNDRV_DEV_DISCONNECTED;
+        if (dev->state == SNDRV_DEV_BUILD) {
+                if (dev->ops->dev_register) {
+                        int err = dev->ops->dev_register(dev);
+                        if (err < 0)
+                                return err;
                 }
-                return 0;
+                dev->state = SNDRV_DEV_REGISTERED;
         }
-        snd_printd("device disconnect %p (from %pF), not found\n", device_data,
-                   __builtin_return_address(0));
-        return -ENXIO;
+        return 0;
 }
 
 /**
@@ -157,26 +161,15 @@ int snd_device_disconnect(struct snd_card *card, void *device_data)
 int snd_device_register(struct snd_card *card, void *device_data)
 {
         struct snd_device *dev;
-        int err;
 
         if (snd_BUG_ON(!card || !device_data))
                 return -ENXIO;
-        list_for_each_entry(dev, &card->devices, list) {
-                if (dev->device_data != device_data)
-                        continue;
-                if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) {
-                        if ((err = dev->ops->dev_register(dev)) < 0)
-                                return err;
-                        dev->state = SNDRV_DEV_REGISTERED;
-                        return 0;
-                }
-                snd_printd("snd_device_register busy\n");
-                return -EBUSY;
-        }
+        dev = look_for_dev(card, device_data);
+        if (dev)
+                return __snd_device_register(dev);
         snd_BUG();
         return -ENXIO;
 }
-
 EXPORT_SYMBOL(snd_device_register);
 
 /*
@@ -191,11 +184,9 @@ int snd_device_register_all(struct snd_card *card)
         if (snd_BUG_ON(!card))
                 return -ENXIO;
         list_for_each_entry(dev, &card->devices, list) {
-                if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) {
-                        if ((err = dev->ops->dev_register(dev)) < 0)
-                                return err;
-                        dev->state = SNDRV_DEV_REGISTERED;
-                }
+                err = __snd_device_register(dev);
+                if (err < 0)
+                        return err;
         }
         return 0;
 }
@@ -211,8 +202,8 @@ int snd_device_disconnect_all(struct snd_card *card)
 
         if (snd_BUG_ON(!card))
                 return -ENXIO;
-        list_for_each_entry(dev, &card->devices, list) {
-                if (snd_device_disconnect(card, dev->device_data) < 0)
+        list_for_each_entry_reverse(dev, &card->devices, list) {
+                if (__snd_device_disconnect(dev) < 0)
                         err = -ENXIO;
         }
         return err;
@@ -222,24 +213,12 @@ int snd_device_disconnect_all(struct snd_card *card)
  * release all the devices on the card.
  * called from init.c
  */
-int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd)
+void snd_device_free_all(struct snd_card *card)
 {
-        struct snd_device *dev;
-        int err;
-        unsigned int range_low, range_high, type;
+        struct snd_device *dev, *next;
 
         if (snd_BUG_ON(!card))
-                return -ENXIO;
-        range_low = (__force unsigned int)cmd * SNDRV_DEV_TYPE_RANGE_SIZE;
-        range_high = range_low + SNDRV_DEV_TYPE_RANGE_SIZE - 1;
-      __again:
-        list_for_each_entry(dev, &card->devices, list) {
-                type = (__force unsigned int)dev->type;
-                if (type >= range_low && type <= range_high) {
-                        if ((err = snd_device_free(card, dev->device_data)) < 0)
-                                return err;
-                        goto __again;
-                }
-        }
-        return 0;
+                return;
+        list_for_each_entry_safe_reverse(dev, next, &card->devices, list)
+                __snd_device_free(dev);
 }
diff --git a/sound/core/hrtimer.c b/sound/core/hrtimer.c
index b8b31c433d64..886be7da989d 100644
--- a/sound/core/hrtimer.c
+++ b/sound/core/hrtimer.c
@@ -126,8 +126,7 @@ static int __init snd_hrtimer_init(void)
 
         hrtimer_get_res(CLOCK_MONOTONIC, &tp);
         if (tp.tv_sec > 0 || !tp.tv_nsec) {
-                snd_printk(KERN_ERR
-                           "snd-hrtimer: Invalid resolution %u.%09u",
+                pr_err("snd-hrtimer: Invalid resolution %u.%09u",
                            (unsigned)tp.tv_sec, (unsigned)tp.tv_nsec);
                 return -EINVAL;
         }
diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c
index d105073298cb..69459e5f712e 100644
--- a/sound/core/hwdep.c
+++ b/sound/core/hwdep.c
@@ -375,7 +375,7 @@ int snd_hwdep_new(struct snd_card *card, char *id, int device,
                 *rhwdep = NULL;
         hwdep = kzalloc(sizeof(*hwdep), GFP_KERNEL);
         if (hwdep == NULL) {
-                snd_printk(KERN_ERR "hwdep: cannot allocate\n");
+                dev_err(card->dev, "hwdep: cannot allocate\n");
                 return -ENOMEM;
         }
         hwdep->card = card;
@@ -395,6 +395,7 @@ int snd_hwdep_new(struct snd_card *card, char *id, int device,
                 *rhwdep = hwdep;
         return 0;
 }
+EXPORT_SYMBOL(snd_hwdep_new);
 
 static int snd_hwdep_free(struct snd_hwdep *hwdep)
 {
@@ -415,37 +416,61 @@ static int snd_hwdep_dev_free(struct snd_device *device)
 static int snd_hwdep_dev_register(struct snd_device *device)
 {
         struct snd_hwdep *hwdep = device->device_data;
+        struct snd_card *card = hwdep->card;
+        struct device *dev;
         int err;
         char name[32];
 
         mutex_lock(&register_mutex);
-        if (snd_hwdep_search(hwdep->card, hwdep->device)) {
+        if (snd_hwdep_search(card, hwdep->device)) {
                 mutex_unlock(&register_mutex);
                 return -EBUSY;
         }
         list_add_tail(&hwdep->list, &snd_hwdep_devices);
         sprintf(name, "hwC%iD%i", hwdep->card->number, hwdep->device);
-        if ((err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP,
-                                       hwdep->card, hwdep->device,
-                                       &snd_hwdep_f_ops, hwdep, name)) < 0) {
-                snd_printk(KERN_ERR "unable to register hardware dependent device %i:%i\n",
-                           hwdep->card->number, hwdep->device);
+        dev = hwdep->dev;
+        if (!dev)
+                dev = snd_card_get_device_link(hwdep->card);
+        err = snd_register_device_for_dev(SNDRV_DEVICE_TYPE_HWDEP,
+                                          hwdep->card, hwdep->device,
+                                          &snd_hwdep_f_ops, hwdep, name, dev);
+        if (err < 0) {
+                dev_err(dev,
+                        "unable to register hardware dependent device %i:%i\n",
+                        card->number, hwdep->device);
                 list_del(&hwdep->list);
                 mutex_unlock(&register_mutex);
                 return err;
         }
+
+        if (hwdep->groups) {
+                struct device *d = snd_get_device(SNDRV_DEVICE_TYPE_HWDEP,
+                                                  hwdep->card, hwdep->device);
+                if (d) {
+                        if (hwdep->private_data)
+                                dev_set_drvdata(d, hwdep->private_data);
+                        err = sysfs_create_groups(&d->kobj, hwdep->groups);
+                        if (err < 0)
+                                dev_warn(dev,
+                                         "hwdep %d:%d: cannot create sysfs groups\n",
+                                         card->number, hwdep->device);
+                        put_device(d);
+                }
+        }
+
 #ifdef CONFIG_SND_OSSEMUL
         hwdep->ossreg = 0;
         if (hwdep->oss_type >= 0) {
                 if ((hwdep->oss_type == SNDRV_OSS_DEVICE_TYPE_DMFM) && (hwdep->device != 0)) {
-                        snd_printk (KERN_WARNING "only hwdep device 0 can be registered as OSS direct FM device!\n");
+                        dev_warn(dev,
+                                 "only hwdep device 0 can be registered as OSS direct FM device!\n");
                 } else {
                         if (snd_register_oss_device(hwdep->oss_type,
-                                                    hwdep->card, hwdep->device,
-                                                    &snd_hwdep_f_ops, hwdep,
-                                                    hwdep->oss_dev) < 0) {
-                                snd_printk(KERN_ERR "unable to register OSS compatibility device %i:%i\n",
-                                           hwdep->card->number, hwdep->device);
+                                                    card, hwdep->device,
+                                                    &snd_hwdep_f_ops, hwdep) < 0) {
+                                dev_err(dev,
+                                        "unable to register OSS compatibility device %i:%i\n",
+                                        card->number, hwdep->device);
                         } else
                                 hwdep->ossreg = 1;
                 }
@@ -543,5 +568,3 @@ static void __exit alsa_hwdep_exit(void)
 
 module_init(alsa_hwdep_init)
 module_exit(alsa_hwdep_exit)
-
-EXPORT_SYMBOL(snd_hwdep_new);
diff --git a/sound/core/info.c b/sound/core/info.c
index e79baa11b60e..051d55b05521 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -418,9 +418,14 @@ static int snd_info_entry_release(struct inode *inode, struct file *file)
                         if (entry->c.text.write) {
                                 entry->c.text.write(entry, data->wbuffer);
                                 if (data->wbuffer->error) {
-                                        snd_printk(KERN_WARNING "data write error to %s (%i)\n",
-                                                entry->name,
-                                                data->wbuffer->error);
+                                        if (entry->card)
+                                                dev_warn(entry->card->dev, "info: data write error to %s (%i)\n",
+                                                         entry->name,
+                                                         data->wbuffer->error);
+                                        else
+                                                pr_warn("ALSA: info: data write error to %s (%i)\n",
+                                                        entry->name,
+                                                        data->wbuffer->error);
                                 }
                         }
                         kfree(data->wbuffer->buffer);
@@ -540,7 +545,7 @@ int __init snd_info_init(void)
                 snd_oss_root = entry;
         }
 #endif
-#if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if IS_ENABLED(CONFIG_SND_SEQUENCER)
         {
                 struct snd_info_entry *entry;
                 if ((entry = snd_info_create_module_entry(THIS_MODULE, "seq", NULL)) == NULL)
@@ -567,7 +572,7 @@ int __exit snd_info_done(void)
         snd_minor_info_done();
         snd_info_version_done();
         if (snd_proc_root) {
-#if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if IS_ENABLED(CONFIG_SND_SEQUENCER)
                 snd_info_free_entry(snd_seq_root);
 #endif
 #ifdef CONFIG_SND_OSSEMUL
diff --git a/sound/core/init.c b/sound/core/init.c
index 0d42fcda0de2..5ee83845c5de 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -28,6 +28,7 @@
 #include <linux/time.h>
 #include <linux/ctype.h>
 #include <linux/pm.h>
+#include <linux/completion.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -94,7 +95,7 @@ static int module_slot_match(struct module *module, int idx)
         return match;
 }
 
-#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
 int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
 EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
 #endif
@@ -112,11 +113,11 @@ static inline int init_info_for_card(struct snd_card *card)
         struct snd_info_entry *entry;
 
         if ((err = snd_info_card_register(card)) < 0) {
-                snd_printd("unable to create card info\n");
+                dev_dbg(card->dev, "unable to create card info\n");
                 return err;
         }
         if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) {
-                snd_printd("unable to create card entry\n");
+                dev_dbg(card->dev, "unable to create card entry\n");
                 return err;
         }
         entry->c.text.read = snd_card_id_read;
@@ -156,8 +157,17 @@ static int get_slot_from_bitmask(int mask, int (*check)(struct module *, int),
         return mask; /* unchanged */
 }
 
+static int snd_card_do_free(struct snd_card *card);
+static const struct attribute_group *card_dev_attr_groups[];
+
+static void release_card_device(struct device *dev)
+{
+        snd_card_do_free(dev_to_snd_card(dev));
+}
+
 /**
- *  snd_card_create - create and initialize a soundcard structure
+ *  snd_card_new - create and initialize a soundcard structure
+ *  @parent: the parent device object
  *  @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
  *  @xid: card identification (ASCII string)
  *  @module: top level module for locking
@@ -172,7 +182,7 @@ static int get_slot_from_bitmask(int mask, int (*check)(struct module *, int),
  *
  *  Return: Zero if successful or a negative error code.
  */
-int snd_card_create(int idx, const char *xid,
+int snd_card_new(struct device *parent, int idx, const char *xid,
                     struct module *module, int extra_size,
                     struct snd_card **card_ret)
 {
@@ -188,6 +198,8 @@ int snd_card_create(int idx, const char *xid,
         card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
         if (!card)
                 return -ENOMEM;
+        if (extra_size > 0)
+                card->private_data = (char *)card + sizeof(struct snd_card);
         if (xid)
                 strlcpy(card->id, xid, sizeof(card->id));
         err = 0;
@@ -205,14 +217,16 @@ int snd_card_create(int idx, const char *xid,
                 err = -ENODEV;
         if (err < 0) {
                 mutex_unlock(&snd_card_mutex);
-                snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i), error: %d\n",
+                dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
                          idx, snd_ecards_limit - 1, err);
-                goto __error;
+                kfree(card);
+                return err;
         }
         set_bit(idx, snd_cards_lock);           /* lock it */
         if (idx >= snd_ecards_limit)
                 snd_ecards_limit = idx + 1; /* increase the limit */
         mutex_unlock(&snd_card_mutex);
+        card->dev = parent;
         card->number = idx;
         card->module = module;
         INIT_LIST_HEAD(&card->devices);
@@ -222,36 +236,42 @@ int snd_card_create(int idx, const char *xid,
         INIT_LIST_HEAD(&card->ctl_files);
         spin_lock_init(&card->files_lock);
         INIT_LIST_HEAD(&card->files_list);
-        init_waitqueue_head(&card->shutdown_sleep);
-        atomic_set(&card->refcount, 0);
 #ifdef CONFIG_PM
         mutex_init(&card->power_lock);
         init_waitqueue_head(&card->power_sleep);
 #endif
+
+        device_initialize(&card->card_dev);
+        card->card_dev.parent = parent;
+        card->card_dev.class = sound_class;
+        card->card_dev.release = release_card_device;
+        card->card_dev.groups = card_dev_attr_groups;
+        err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
+        if (err < 0)
+                goto __error;
+
         /* the control interface cannot be accessed from the user space until */
         /* snd_cards_bitmask and snd_cards are set with snd_card_register */
         err = snd_ctl_create(card);
         if (err < 0) {
-                snd_printk(KERN_ERR "unable to register control minors\n");
+                dev_err(parent, "unable to register control minors\n");
                 goto __error;
         }
         err = snd_info_card_create(card);
         if (err < 0) {
-                snd_printk(KERN_ERR "unable to create card info\n");
+                dev_err(parent, "unable to create card info\n");
                 goto __error_ctl;
         }
-        if (extra_size > 0)
-                card->private_data = (char *)card + sizeof(struct snd_card);
         *card_ret = card;
         return 0;
 
       __error_ctl:
-        snd_device_free_all(card, SNDRV_DEV_CMD_PRE);
+        snd_device_free_all(card);
       __error:
-        kfree(card);
+        put_device(&card->card_dev);
         return err;
 }
-EXPORT_SYMBOL(snd_card_create);
+EXPORT_SYMBOL(snd_card_new);
 
 /* return non-zero if a card is already locked */
 int snd_card_locked(int card)
@@ -394,7 +414,7 @@ int snd_card_disconnect(struct snd_card *card)
         /* phase 3: notify all connected devices about disconnection */
         /* at this point, they cannot respond to any calls except release() */
 
-#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
         if (snd_mixer_oss_notify_callback)
                 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
 #endif
@@ -402,12 +422,12 @@ int snd_card_disconnect(struct snd_card *card)
         /* notify all devices that we are disconnected */
         err = snd_device_disconnect_all(card);
         if (err < 0)
-                snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number);
+                dev_err(card->dev, "not all devices for card %i can be disconnected\n", card->number);
 
         snd_info_card_disconnect(card);
-        if (card->card_dev) {
-                device_unregister(card->card_dev);
-                card->card_dev = NULL;
+        if (card->registered) {
+                device_del(&card->card_dev);
+                card->registered = false;
         }
 #ifdef CONFIG_PM
         wake_up(&card->power_sleep);
@@ -430,81 +450,48 @@ EXPORT_SYMBOL(snd_card_disconnect);
  */
 static int snd_card_do_free(struct snd_card *card)
 {
-#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
         if (snd_mixer_oss_notify_callback)
                 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
 #endif
-        if (snd_device_free_all(card, SNDRV_DEV_CMD_PRE) < 0) {
-                snd_printk(KERN_ERR "unable to free all devices (pre)\n");
-                /* Fatal, but this situation should never occur */
-        }
-        if (snd_device_free_all(card, SNDRV_DEV_CMD_NORMAL) < 0) {
-                snd_printk(KERN_ERR "unable to free all devices (normal)\n");
-                /* Fatal, but this situation should never occur */
-        }
-        if (snd_device_free_all(card, SNDRV_DEV_CMD_POST) < 0) {
-                snd_printk(KERN_ERR "unable to free all devices (post)\n");
-                /* Fatal, but this situation should never occur */
-        }
+        snd_device_free_all(card);
         if (card->private_free)
                 card->private_free(card);
         snd_info_free_entry(card->proc_id);
         if (snd_info_card_free(card) < 0) {
-                snd_printk(KERN_WARNING "unable to free card info\n");
+                dev_warn(card->dev, "unable to free card info\n");
                 /* Not fatal error */
         }
+        if (card->release_completion)
+                complete(card->release_completion);
         kfree(card);
         return 0;
 }
 
-/**
- * snd_card_unref - release the reference counter
- * @card: the card instance
- *
- * Decrements the reference counter.  When it reaches to zero, wake up
- * the sleeper and call the destructor if needed.
- */
-void snd_card_unref(struct snd_card *card)
-{
-        if (atomic_dec_and_test(&card->refcount)) {
-                wake_up(&card->shutdown_sleep);
-                if (card->free_on_last_close)
-                        snd_card_do_free(card);
-        }
-}
-EXPORT_SYMBOL(snd_card_unref);
-
 int snd_card_free_when_closed(struct snd_card *card)
 {
-        int ret;
-
-        atomic_inc(&card->refcount);
-        ret = snd_card_disconnect(card);
-        if (ret) {
-                atomic_dec(&card->refcount);
+        int ret = snd_card_disconnect(card);
+        if (ret)
                 return ret;
-        }
-
-        card->free_on_last_close = 1;
-        if (atomic_dec_and_test(&card->refcount))
-                snd_card_do_free(card);
+        put_device(&card->card_dev);
         return 0;
 }
-
 EXPORT_SYMBOL(snd_card_free_when_closed);
 
 int snd_card_free(struct snd_card *card)
 {
-        int ret = snd_card_disconnect(card);
+        struct completion released;
+        int ret;
+
+        init_completion(&released);
+        card->release_completion = &released;
+        ret = snd_card_free_when_closed(card);
         if (ret)
                 return ret;
-
         /* wait, until all devices are ready for the free operation */
-        wait_event(card->shutdown_sleep, !atomic_read(&card->refcount));
-        snd_card_do_free(card);
+        wait_for_completion(&released);
         return 0;
 }
-
 EXPORT_SYMBOL(snd_card_free);
 
 /* retrieve the last word of shortname or longname */
@@ -598,7 +585,7 @@ static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
                 goto again;
         }
         /* last resort... */
-        snd_printk(KERN_ERR "unable to set card id (%s)\n", id);
+        dev_err(card->dev, "unable to set card id (%s)\n", id);
         if (card->proc_root->name)
                 strlcpy(card->id, card->proc_root->name, sizeof(card->id));
 }
@@ -626,15 +613,15 @@ static ssize_t
 card_id_show_attr(struct device *dev,
                   struct device_attribute *attr, char *buf)
 {
-        struct snd_card *card = dev_get_drvdata(dev);
-        return snprintf(buf, PAGE_SIZE, "%s\n", card ? card->id : "(null)");
+        struct snd_card *card = container_of(dev, struct snd_card, card_dev);
+        return snprintf(buf, PAGE_SIZE, "%s\n", card->id);
 }
 
 static ssize_t
 card_id_store_attr(struct device *dev, struct device_attribute *attr,
                    const char *buf, size_t count)
 {
-        struct snd_card *card = dev_get_drvdata(dev);
+        struct snd_card *card = container_of(dev, struct snd_card, card_dev);
         char buf1[sizeof(card->id)];
         size_t copy = count > sizeof(card->id) - 1 ?
                                         sizeof(card->id) - 1 : count;
@@ -660,19 +647,32 @@ card_id_store_attr(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-static struct device_attribute card_id_attrs =
-        __ATTR(id, S_IRUGO | S_IWUSR, card_id_show_attr, card_id_store_attr);
+static DEVICE_ATTR(id, S_IRUGO | S_IWUSR, card_id_show_attr, card_id_store_attr);
 
 static ssize_t
 card_number_show_attr(struct device *dev,
                      struct device_attribute *attr, char *buf)
 {
-        struct snd_card *card = dev_get_drvdata(dev);
-        return snprintf(buf, PAGE_SIZE, "%i\n", card ? card->number : -1);
+        struct snd_card *card = container_of(dev, struct snd_card, card_dev);
+        return snprintf(buf, PAGE_SIZE, "%i\n", card->number);
 }
 
-static struct device_attribute card_number_attrs =
-        __ATTR(number, S_IRUGO, card_number_show_attr, NULL);
+static DEVICE_ATTR(number, S_IRUGO, card_number_show_attr, NULL);
+
+static struct attribute *card_dev_attrs[] = {
+        &dev_attr_id.attr,
+        &dev_attr_number.attr,
+        NULL
+};
+
+static struct attribute_group card_dev_attr_group = {
+        .attrs  = card_dev_attrs,
+};
+
+static const struct attribute_group *card_dev_attr_groups[] = {
+        &card_dev_attr_group,
+        NULL
+};
 
 /**
  *  snd_card_register - register the soundcard
@@ -692,12 +692,11 @@ int snd_card_register(struct snd_card *card)
         if (snd_BUG_ON(!card))
                 return -EINVAL;
 
-        if (!card->card_dev) {
-                card->card_dev = device_create(sound_class, card->dev,
-                                               MKDEV(0, 0), card,
-                                               "card%i", card->number);
-                if (IS_ERR(card->card_dev))
-                        card->card_dev = NULL;
+        if (!card->registered) {
+                err = device_add(&card->card_dev);
+                if (err < 0)
+                        return err;
+                card->registered = true;
         }
 
         if ((err = snd_device_register_all(card)) < 0)
@@ -723,19 +722,10 @@ int snd_card_register(struct snd_card *card)
         snd_cards[card->number] = card;
         mutex_unlock(&snd_card_mutex);
         init_info_for_card(card);
-#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
         if (snd_mixer_oss_notify_callback)
                 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
 #endif
-        if (card->card_dev) {
-                err = device_create_file(card->card_dev, &card_id_attrs);
-                if (err < 0)
-                        return err;
-                err = device_create_file(card->card_dev, &card_number_attrs);
-                if (err < 0)
-                        return err;
-        }
-
         return 0;
 }
 
@@ -908,7 +898,7 @@ int snd_card_file_add(struct snd_card *card, struct file *file)
                 return -ENODEV;
         }
         list_add(&mfile->list, &card->files_list);
-        atomic_inc(&card->refcount);
+        get_device(&card->card_dev);
         spin_unlock(&card->files_lock);
         return 0;
 }
@@ -947,11 +937,11 @@ int snd_card_file_remove(struct snd_card *card, struct file *file)
         }
         spin_unlock(&card->files_lock);
         if (!found) {
-                snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file);
+                dev_err(card->dev, "card file remove problem (%p)\n", file);
                 return -ENOENT;
         }
         kfree(found);
-        snd_card_unref(card);
+        put_device(&card->card_dev);
         return 0;
 }
 
diff --git a/sound/core/isadma.c b/sound/core/isadma.c
index e2b386156a4c..31e8544d7f2d 100644
--- a/sound/core/isadma.c
+++ b/sound/core/isadma.c
@@ -106,7 +106,7 @@ unsigned int snd_dma_pointer(unsigned long dma, unsigned int size)
                 result = result1;
 #ifdef CONFIG_SND_DEBUG
         if (result > size)
-                snd_printk(KERN_ERR "pointer (0x%x) for DMA #%ld is greater than transfer size (0x%x)\n", result, dma, size);
+                pr_err("ALSA: pointer (0x%x) for DMA #%ld is greater than transfer size (0x%x)\n", result, dma, size);
 #endif
         if (result >= size || result == 0)
                 return 0;
diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c
index 4595f93d151e..082509eb805d 100644
--- a/sound/core/memalloc.c
+++ b/sound/core/memalloc.c
@@ -207,7 +207,7 @@ int snd_dma_alloc_pages(int type, struct device *device, size_t size,
                 break;
 #endif
         default:
-                printk(KERN_ERR "snd-malloc: invalid device type %d\n", type);
+                pr_err("snd-malloc: invalid device type %d\n", type);
                 dmab->area = NULL;
                 dmab->addr = 0;
                 return -ENXIO;
@@ -284,7 +284,7 @@ void snd_dma_free_pages(struct snd_dma_buffer *dmab)
                 break;
 #endif
         default:
-                printk(KERN_ERR "snd-malloc: invalid device type %d\n", dmab->dev.type);
+                pr_err("snd-malloc: invalid device type %d\n", dmab->dev.type);
         }
 }
 
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index e8a1d18774b2..5e6349f00ecd 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -1187,7 +1187,8 @@ static void snd_mixer_oss_proc_write(struct snd_info_entry *entry,
                         if (oss_mixer_names[ch] && strcmp(oss_mixer_names[ch], str) == 0)
                                 break;
                 if (ch >= SNDRV_OSS_MAX_MIXERS) {
-                        snd_printk(KERN_ERR "mixer_oss: invalid OSS volume '%s'\n", str);
+                        pr_err("ALSA: mixer_oss: invalid OSS volume '%s'\n",
+                               str);
                         continue;
                 }
                 cptr = snd_info_get_str(str, cptr, sizeof(str));
@@ -1201,7 +1202,7 @@ static void snd_mixer_oss_proc_write(struct snd_info_entry *entry,
                 snd_info_get_str(idxstr, cptr, sizeof(idxstr));
                 idx = simple_strtoul(idxstr, NULL, 10);
                 if (idx >= 0x4000) { /* too big */
-                        snd_printk(KERN_ERR "mixer_oss: invalid index %d\n", idx);
+                        pr_err("ALSA: mixer_oss: invalid index %d\n", idx);
                         continue;
                 }
                 mutex_lock(&mixer->reg_mutex);
@@ -1212,7 +1213,7 @@ static void snd_mixer_oss_proc_write(struct snd_info_entry *entry,
                         goto __unlock;
                 tbl = kmalloc(sizeof(*tbl), GFP_KERNEL);
                 if (! tbl) {
-                        snd_printk(KERN_ERR "mixer_oss: no memory\n");
+                        pr_err("ALSA: mixer_oss: no memory\n");
                         goto __unlock;
                 }
                 tbl->oss_id = ch;
@@ -1343,20 +1344,18 @@ static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd)
         struct snd_mixer_oss *mixer;
 
         if (cmd == SND_MIXER_OSS_NOTIFY_REGISTER) {
-                char name[128];
                 int idx, err;
 
                 mixer = kcalloc(2, sizeof(*mixer), GFP_KERNEL);
                 if (mixer == NULL)
                         return -ENOMEM;
                 mutex_init(&mixer->reg_mutex);
-                sprintf(name, "mixer%i%i", card->number, 0);
                 if ((err = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER,
                                                    card, 0,
-                                                   &snd_mixer_oss_f_ops, card,
-                                                   name)) < 0) {
-                        snd_printk(KERN_ERR "unable to register OSS mixer device %i:%i\n",
-                                   card->number, 0);
+                                                   &snd_mixer_oss_f_ops, card)) < 0) {
+                        dev_err(card->dev,
+                                "unable to register OSS mixer device %i:%i\n",
+                                card->number, 0);
                         kfree(mixer);
                         return err;
                 }
@@ -1365,7 +1364,8 @@ static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd)
                 if (*card->mixername)
                         strlcpy(mixer->name, card->mixername, sizeof(mixer->name));
                 else
-                        strlcpy(mixer->name, name, sizeof(mixer->name));
+                        snprintf(mixer->name, sizeof(mixer->name),
+                                 "mixer%i", card->number);
 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
                 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIXERS,
                                       card->number,
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index 4c1cc51772e6..ada69d7a8d70 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -854,7 +854,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         params = kmalloc(sizeof(*params), GFP_KERNEL);
         sparams = kmalloc(sizeof(*sparams), GFP_KERNEL);
         if (!sw_params || !params || !sparams) {
-                snd_printd("No memory\n");
+                pcm_dbg(substream->pcm, "No memory\n");
                 err = -ENOMEM;
                 goto failure;
         }
@@ -877,7 +877,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         }
         err = snd_pcm_hw_param_mask(substream, sparams, SNDRV_PCM_HW_PARAM_ACCESS, &mask);
         if (err < 0) {
-                snd_printd("No usable accesses\n");
+                pcm_dbg(substream->pcm, "No usable accesses\n");
                 err = -EINVAL;
                 goto failure;
         }
@@ -902,7 +902,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
                                 break;
                 }
                 if ((__force int)sformat > (__force int)SNDRV_PCM_FORMAT_LAST) {
-                        snd_printd("Cannot find a format!!!\n");
+                        pcm_dbg(substream->pcm, "Cannot find a format!!!\n");
                         err = -EINVAL;
                         goto failure;
                 }
@@ -942,14 +942,16 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
                 if ((err = snd_pcm_plug_format_plugins(substream,
                                                        params, 
                                                        sparams)) < 0) {
-                        snd_printd("snd_pcm_plug_format_plugins failed: %i\n", err);
+                        pcm_dbg(substream->pcm,
+                                "snd_pcm_plug_format_plugins failed: %i\n", err);
                         snd_pcm_oss_plugin_clear(substream);
                         goto failure;
                 }
                 if (runtime->oss.plugin_first) {
                         struct snd_pcm_plugin *plugin;
                         if ((err = snd_pcm_plugin_build_io(substream, sparams, &plugin)) < 0) {
-                                snd_printd("snd_pcm_plugin_build_io failed: %i\n", err);
+                                pcm_dbg(substream->pcm,
+                                        "snd_pcm_plugin_build_io failed: %i\n", err);
                                 snd_pcm_oss_plugin_clear(substream);
                                 goto failure;
                         }
@@ -983,7 +985,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
 
         if ((err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, sparams)) < 0) {
-                snd_printd("HW_PARAMS failed: %i\n", err);
+                pcm_dbg(substream->pcm, "HW_PARAMS failed: %i\n", err);
                 goto failure;
         }
 
@@ -1016,7 +1018,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         }
 
         if ((err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_SW_PARAMS, sw_params)) < 0) {
-                snd_printd("SW_PARAMS failed: %i\n", err);
+                pcm_dbg(substream->pcm, "SW_PARAMS failed: %i\n", err);
                 goto failure;
         }
 
@@ -1110,7 +1112,8 @@ static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream)
 
         err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL);
         if (err < 0) {
-                snd_printd("snd_pcm_oss_prepare: SNDRV_PCM_IOCTL_PREPARE failed\n");
+                pcm_dbg(substream->pcm,
+                        "snd_pcm_oss_prepare: SNDRV_PCM_IOCTL_PREPARE failed\n");
                 return err;
         }
         runtime->oss.prepare = 0;
@@ -1175,12 +1178,10 @@ snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const
                 if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
                     runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
-                        if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
-                                printk(KERN_DEBUG "pcm_oss: write: "
-                                       "recovering from XRUN\n");
-                        else
-                                printk(KERN_DEBUG "pcm_oss: write: "
-                                       "recovering from SUSPEND\n");
+                        pcm_dbg(substream->pcm,
+                                "pcm_oss: write: recovering from %s\n",
+                                runtime->status->state == SNDRV_PCM_STATE_XRUN ?
+                                "XRUN" : "SUSPEND");
 #endif
                         ret = snd_pcm_oss_prepare(substream);
                         if (ret < 0)
@@ -1213,12 +1214,10 @@ snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *p
                 if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
                     runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
-                        if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
-                                printk(KERN_DEBUG "pcm_oss: read: "
-                                       "recovering from XRUN\n");
-                        else
-                                printk(KERN_DEBUG "pcm_oss: read: "
-                                       "recovering from SUSPEND\n");
+                        pcm_dbg(substream->pcm,
+                                "pcm_oss: read: recovering from %s\n",
+                                runtime->status->state == SNDRV_PCM_STATE_XRUN ?
+                                "XRUN" : "SUSPEND");
 #endif
                         ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
                         if (ret < 0)
@@ -1261,12 +1260,10 @@ snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void
                 if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
                     runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
-                        if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
-                                printk(KERN_DEBUG "pcm_oss: writev: "
-                                       "recovering from XRUN\n");
-                        else
-                                printk(KERN_DEBUG "pcm_oss: writev: "
-                                       "recovering from SUSPEND\n");
+                        pcm_dbg(substream->pcm,
+                                "pcm_oss: writev: recovering from %s\n",
+                                runtime->status->state == SNDRV_PCM_STATE_XRUN ?
+                                "XRUN" : "SUSPEND");
 #endif
                         ret = snd_pcm_oss_prepare(substream);
                         if (ret < 0)
@@ -1299,12 +1296,10 @@ snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void *
                 if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
                     runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
-                        if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
-                                printk(KERN_DEBUG "pcm_oss: readv: "
-                                       "recovering from XRUN\n");
-                        else
-                                printk(KERN_DEBUG "pcm_oss: readv: "
-                                       "recovering from SUSPEND\n");
+                        pcm_dbg(substream->pcm,
+                                "pcm_oss: readv: recovering from %s\n",
+                                runtime->status->state == SNDRV_PCM_STATE_XRUN ?
+                                "XRUN" : "SUSPEND");
 #endif
                         ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
                         if (ret < 0)
@@ -1561,7 +1556,7 @@ static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size)
         init_waitqueue_entry(&wait, current);
         add_wait_queue(&runtime->sleep, &wait);
 #ifdef OSS_DEBUG
-        printk(KERN_DEBUG "sync1: size = %li\n", size);
+        pcm_dbg(substream->pcm, "sync1: size = %li\n", size);
 #endif
         while (1) {
                 result = snd_pcm_oss_write2(substream, runtime->oss.buffer, size, 1);
@@ -1587,7 +1582,8 @@ static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size)
                         break;
                 }
                 if (res == 0) {
-                        snd_printk(KERN_ERR "OSS sync error - DMA timeout\n");
+                        pcm_err(substream->pcm,
+                                "OSS sync error - DMA timeout\n");
                         result = -EIO;
                         break;
                 }
@@ -1618,7 +1614,7 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                 mutex_lock(&runtime->oss.params_lock);
                 if (runtime->oss.buffer_used > 0) {
 #ifdef OSS_DEBUG
-                        printk(KERN_DEBUG "sync: buffer_used\n");
+                        pcm_dbg(substream->pcm, "sync: buffer_used\n");
 #endif
                         size = (8 * (runtime->oss.period_bytes - runtime->oss.buffer_used) + 7) / width;
                         snd_pcm_format_set_silence(format,
@@ -1631,7 +1627,7 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                         }
                 } else if (runtime->oss.period_ptr > 0) {
 #ifdef OSS_DEBUG
-                        printk(KERN_DEBUG "sync: period_ptr\n");
+                        pcm_dbg(substream->pcm, "sync: period_ptr\n");
 #endif
                         size = runtime->oss.period_bytes - runtime->oss.period_ptr;
                         snd_pcm_format_set_silence(format,
@@ -1983,7 +1979,7 @@ static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int tr
         int err, cmd;
 
 #ifdef OSS_DEBUG
-        printk(KERN_DEBUG "pcm_oss: trigger = 0x%x\n", trigger);
+        pcm_dbg(substream->pcm, "pcm_oss: trigger = 0x%x\n", trigger);
 #endif
         
         psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
@@ -2203,9 +2199,9 @@ static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stre
         }
 
 #ifdef OSS_DEBUG
-        printk(KERN_DEBUG "pcm_oss: space: bytes = %i, fragments = %i, "
-               "fragstotal = %i, fragsize = %i\n",
-               info.bytes, info.fragments, info.fragstotal, info.fragsize);
+        pcm_dbg(substream->pcm,
+                "pcm_oss: space: bytes = %i, fragments = %i, fragstotal = %i, fragsize = %i\n",
+                info.bytes, info.fragments, info.fragstotal, info.fragsize);
 #endif
         if (copy_to_user(_info, &info, sizeof(info)))
                 return -EFAULT;
@@ -2215,7 +2211,7 @@ static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stre
 static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct buffmem_desc __user * _info)
 {
         // it won't be probably implemented
-        // snd_printd("TODO: snd_pcm_oss_get_mapbuf\n");
+        // pr_debug("TODO: snd_pcm_oss_get_mapbuf\n");
         return -EINVAL;
 }
 
@@ -2519,7 +2515,7 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long
         if (((cmd >> 8) & 0xff) != 'P')
                 return -EINVAL;
 #ifdef OSS_DEBUG
-        printk(KERN_DEBUG "pcm_oss: ioctl = 0x%x\n", cmd);
+        pr_debug("pcm_oss: ioctl = 0x%x\n", cmd);
 #endif
         switch (cmd) {
         case SNDCTL_DSP_RESET:
@@ -2646,7 +2642,7 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long
         case SNDCTL_DSP_PROFILE:
                 return 0;       /* silently ignore */
         default:
-                snd_printd("pcm_oss: unknown command = 0x%x\n", cmd);
+                pr_debug("pcm_oss: unknown command = 0x%x\n", cmd);
         }
         return -EINVAL;
 }
@@ -2673,8 +2669,9 @@ static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t coun
 #else
         {
                 ssize_t res = snd_pcm_oss_read1(substream, buf, count);
-                printk(KERN_DEBUG "pcm_oss: read %li bytes "
-                       "(returned %li bytes)\n", (long)count, (long)res);
+                pcm_dbg(substream->pcm,
+                        "pcm_oss: read %li bytes (returned %li bytes)\n",
+                        (long)count, (long)res);
                 return res;
         }
 #endif
@@ -2693,7 +2690,7 @@ static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size
         substream->f_flags = file->f_flags & O_NONBLOCK;
         result = snd_pcm_oss_write1(substream, buf, count);
 #ifdef OSS_DEBUG
-        printk(KERN_DEBUG "pcm_oss: write %li bytes (wrote %li bytes)\n",
+        pcm_dbg(substream->pcm, "pcm_oss: write %li bytes (wrote %li bytes)\n",
                (long)count, (long)result);
 #endif
         return result;
@@ -2772,7 +2769,7 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area)
         int err;
 
 #ifdef OSS_DEBUG
-        printk(KERN_DEBUG "pcm_oss: mmap begin\n");
+        pr_debug("pcm_oss: mmap begin\n");
 #endif
         pcm_oss_file = file->private_data;
         switch ((area->vm_flags & (VM_READ | VM_WRITE))) {
@@ -2822,7 +2819,7 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area)
         runtime->silence_threshold = 0;
         runtime->silence_size = 0;
 #ifdef OSS_DEBUG
-        printk(KERN_DEBUG "pcm_oss: mmap ok, bytes = 0x%x\n",
+        pr_debug("pcm_oss: mmap ok, bytes = 0x%x\n",
                runtime->oss.mmap_bytes);
 #endif
         /* In mmap mode we never stop */
@@ -3007,12 +3004,10 @@ static const struct file_operations snd_pcm_oss_f_reg =
 
 static void register_oss_dsp(struct snd_pcm *pcm, int index)
 {
-        char name[128];
-        sprintf(name, "dsp%i%i", pcm->card->number, pcm->device);
         if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
                                     pcm->card, index, &snd_pcm_oss_f_reg,
-                                    pcm, name) < 0) {
-                snd_printk(KERN_ERR "unable to register OSS PCM device %i:%i\n",
+                                    pcm) < 0) {
+                pcm_err(pcm, "unable to register OSS PCM device %i:%i\n",
                            pcm->card->number, pcm->device);
         }
 }
@@ -3093,12 +3088,12 @@ static int __init alsa_pcm_oss_init(void)
         /* check device map table */
         for (i = 0; i < SNDRV_CARDS; i++) {
                 if (dsp_map[i] < 0 || dsp_map[i] >= SNDRV_PCM_DEVICES) {
-                        snd_printk(KERN_ERR "invalid dsp_map[%d] = %d\n",
+                        pr_err("ALSA: pcm_oss: invalid dsp_map[%d] = %d\n",
                                    i, dsp_map[i]);
                         dsp_map[i] = 0;
                 }
                 if (adsp_map[i] < 0 || adsp_map[i] >= SNDRV_PCM_DEVICES) {
-                        snd_printk(KERN_ERR "invalid adsp_map[%d] = %d\n",
+                        pr_err("ALSA: pcm_oss: invalid adsp_map[%d] = %d\n",
                                    i, adsp_map[i]);
                         adsp_map[i] = 1;
                 }
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index e1e9e0c999fe..43932e8dce66 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -295,7 +295,7 @@ static const char *snd_pcm_state_name(snd_pcm_state_t state)
         return snd_pcm_state_names[(__force int)state];
 }
 
-#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_PCM_OSS)
 #include <linux/soundcard.h>
 
 static const char *snd_pcm_oss_format_name(int format)
@@ -338,7 +338,8 @@ static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream,
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
         if (! info) {
-                printk(KERN_DEBUG "snd_pcm_proc_info_read: cannot malloc\n");
+                pcm_dbg(substream->pcm,
+                        "snd_pcm_proc_info_read: cannot malloc\n");
                 return;
         }
 
@@ -398,7 +399,7 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
         snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den); 
         snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size);        
         snd_iprintf(buffer, "buffer_size: %lu\n", runtime->buffer_size);        
-#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_PCM_OSS)
         if (substream->oss.oss) {
                 snd_iprintf(buffer, "OSS format: %s\n", snd_pcm_oss_format_name(runtime->oss.format));
                 snd_iprintf(buffer, "OSS channels: %u\n", runtime->oss.channels);       
@@ -651,7 +652,7 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
         struct snd_pcm_str *pstr = &pcm->streams[stream];
         struct snd_pcm_substream *substream, *prev;
 
-#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_PCM_OSS)
         mutex_init(&pstr->oss.setup_mutex);
 #endif
         pstr->stream = stream;
@@ -660,7 +661,7 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
         if (substream_count > 0 && !pcm->internal) {
                 err = snd_pcm_stream_proc_init(pstr);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
+                        pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n");
                         return err;
                 }
         }
@@ -668,7 +669,7 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
         for (idx = 0, prev = NULL; idx < substream_count; idx++) {
                 substream = kzalloc(sizeof(*substream), GFP_KERNEL);
                 if (substream == NULL) {
-                        snd_printk(KERN_ERR "Cannot allocate PCM substream\n");
+                        pcm_err(pcm, "Cannot allocate PCM substream\n");
                         return -ENOMEM;
                 }
                 substream->pcm = pcm;
@@ -685,7 +686,8 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
                 if (!pcm->internal) {
                         err = snd_pcm_substream_proc_init(substream);
                         if (err < 0) {
-                                snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
+                                pcm_err(pcm,
+                                        "Error in snd_pcm_stream_proc_init\n");
                                 if (prev == NULL)
                                         pstr->substream = NULL;
                                 else
@@ -724,7 +726,7 @@ static int _snd_pcm_new(struct snd_card *card, const char *id, int device,
                 *rpcm = NULL;
         pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
         if (pcm == NULL) {
-                snd_printk(KERN_ERR "Cannot allocate PCM\n");
+                dev_err(card->dev, "Cannot allocate PCM\n");
                 return -ENOMEM;
         }
         pcm->card = card;
@@ -807,7 +809,7 @@ EXPORT_SYMBOL(snd_pcm_new_internal);
 static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
 {
         struct snd_pcm_substream *substream, *substream_next;
-#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_PCM_OSS)
         struct snd_pcm_oss_setup *setup, *setupn;
 #endif
         substream = pstr->substream;
@@ -819,7 +821,7 @@ static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
                 substream = substream_next;
         }
         snd_pcm_stream_proc_done(pstr);
-#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_PCM_OSS)
         for (setup = pstr->oss.setup_list; setup; setup = setupn) {
                 setupn = setup->next;
                 kfree(setup->task_name);
@@ -1016,8 +1018,20 @@ static ssize_t show_pcm_class(struct device *dev,
         return snprintf(buf, PAGE_SIZE, "%s\n", str);
 }
 
-static struct device_attribute pcm_attrs =
-        __ATTR(pcm_class, S_IRUGO, show_pcm_class, NULL);
+static DEVICE_ATTR(pcm_class, S_IRUGO, show_pcm_class, NULL);
+static struct attribute *pcm_dev_attrs[] = {
+        &dev_attr_pcm_class.attr,
+        NULL
+};
+
+static struct attribute_group pcm_dev_attr_group = {
+        .attrs  = pcm_dev_attrs,
+};
+
+static const struct attribute_group *pcm_dev_attr_groups[] = {
+        &pcm_dev_attr_group,
+        NULL
+};
 
 static int snd_pcm_dev_register(struct snd_device *device)
 {
@@ -1067,8 +1081,18 @@ static int snd_pcm_dev_register(struct snd_device *device)
                         mutex_unlock(&register_mutex);
                         return err;
                 }
-                snd_add_device_sysfs_file(devtype, pcm->card, pcm->device,
-                                          &pcm_attrs);
+
+                dev = snd_get_device(devtype, pcm->card, pcm->device);
+                if (dev) {
+                        err = sysfs_create_groups(&dev->kobj,
+                                                  pcm_dev_attr_groups);
+                        if (err < 0)
+                                dev_warn(dev,
+                                         "pcm %d:%d: cannot create sysfs groups\n",
+                                         pcm->card->number, pcm->device);
+                        put_device(dev);
+                }
+
                 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
                         snd_pcm_timer_init(substream);
         }
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index a2104671f51d..ce83def9f43b 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -174,7 +174,7 @@ static void xrun(struct snd_pcm_substream *substream)
         if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {
                 char name[16];
                 snd_pcm_debug_name(substream, name, sizeof(name));
-                snd_printd(KERN_DEBUG "XRUN: %s\n", name);
+                pcm_warn(substream->pcm, "XRUN: %s\n", name);
                 dump_stack_on_xrun(substream);
         }
 }
@@ -184,9 +184,7 @@ static void xrun(struct snd_pcm_substream *substream)
         do {                                                            \
                 if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {          \
                         xrun_log_show(substream);                       \
-                        if (snd_printd_ratelimit()) {                   \
-                                snd_printd("PCM: " fmt, ##args);        \
-                        }                                               \
+                        pr_err_ratelimited("ALSA: PCM: " fmt, ##args);  \
                         dump_stack_on_xrun(substream);                  \
                 }                                                       \
         } while (0)
@@ -253,7 +251,7 @@ static void xrun_log_show(struct snd_pcm_substream *substream)
                 entry = &log->entries[idx];
                 if (entry->period_size == 0)
                         break;
-                snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "
+                pr_info("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "
                            "hwptr=%ld/%ld\n",
                            name, entry->in_interrupt ? "[Q] " : "",
                            entry->jiffies,
@@ -342,14 +340,14 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
                 return -EPIPE;
         }
         if (pos >= runtime->buffer_size) {
-                if (snd_printd_ratelimit()) {
+                if (printk_ratelimit()) {
                         char name[16];
                         snd_pcm_debug_name(substream, name, sizeof(name));
                         xrun_log_show(substream);
-                        snd_printd(KERN_ERR  "BUG: %s, pos = %ld, "
-                                   "buffer size = %ld, period size = %ld\n",
-                                   name, pos, runtime->buffer_size,
-                                   runtime->period_size);
+                        pcm_err(substream->pcm,
+                                "BUG: %s, pos = %ld, buffer size = %ld, period size = %ld\n",
+                                name, pos, runtime->buffer_size,
+                                runtime->period_size);
                 }
                 pos = 0;
         }
@@ -394,8 +392,8 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
                         XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {
                 char name[16];
                 snd_pcm_debug_name(substream, name, sizeof(name));
-                snd_printd("%s_update: %s: pos=%u/%u/%u, "
-                           "hwptr=%ld/%ld/%ld/%ld\n",
+                pcm_dbg(substream->pcm,
+                        "%s_update: %s: pos=%u/%u/%u, hwptr=%ld/%ld/%ld/%ld\n",
                            in_interrupt ? "period" : "hwptr",
                            name,
                            (unsigned int)pos,
@@ -1242,6 +1240,7 @@ int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_par
                 return -EINVAL;
         return 0;
 }
+EXPORT_SYMBOL(snd_pcm_hw_constraint_mask64);
 
 /**
  * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
@@ -1941,8 +1940,9 @@ static int wait_for_avail(struct snd_pcm_substream *substream,
                         continue;
                 }
                 if (!tout) {
-                        snd_printd("%s write error (DMA or IRQ trouble?)\n",
-                                   is_playback ? "playback" : "capture");
+                        pcm_dbg(substream->pcm,
+                                "%s write error (DMA or IRQ trouble?)\n",
+                                is_playback ? "playback" : "capture");
                         err = -EIO;
                         break;
                 }
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 01a5e05ede95..b653ab001fba 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -190,12 +190,12 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
                 if (!(params->rmask & (1 << k)))
                         continue;
 #ifdef RULES_DEBUG
-                printk(KERN_DEBUG "%s = ", snd_pcm_hw_param_names[k]);
-                printk("%04x%04x%04x%04x -> ", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
+                pr_debug("%s = ", snd_pcm_hw_param_names[k]);
+                pr_cont("%04x%04x%04x%04x -> ", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
 #endif
                 changed = snd_mask_refine(m, constrs_mask(constrs, k));
 #ifdef RULES_DEBUG
-                printk("%04x%04x%04x%04x\n", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
+                pr_cont("%04x%04x%04x%04x\n", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
 #endif
                 if (changed)
                         params->cmask |= 1 << k;
@@ -210,21 +210,21 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
                 if (!(params->rmask & (1 << k)))
                         continue;
 #ifdef RULES_DEBUG
-                printk(KERN_DEBUG "%s = ", snd_pcm_hw_param_names[k]);
+                pr_debug("%s = ", snd_pcm_hw_param_names[k]);
                 if (i->empty)
-                        printk("empty");
+                        pr_cont("empty");
                 else
-                        printk("%c%u %u%c", 
+                        pr_cont("%c%u %u%c",
                                i->openmin ? '(' : '[', i->min,
                                i->max, i->openmax ? ')' : ']');
-                printk(" -> ");
+                pr_cont(" -> ");
 #endif
                 changed = snd_interval_refine(i, constrs_interval(constrs, k));
 #ifdef RULES_DEBUG
                 if (i->empty)
-                        printk("empty\n");
+                        pr_cont("empty\n");
                 else 
-                        printk("%c%u %u%c\n", 
+                        pr_cont("%c%u %u%c\n",
                                i->openmin ? '(' : '[', i->min,
                                i->max, i->openmax ? ')' : ']');
 #endif
@@ -255,18 +255,18 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
                         if (!doit)
                                 continue;
 #ifdef RULES_DEBUG
-                        printk(KERN_DEBUG "Rule %d [%p]: ", k, r->func);
+                        pr_debug("Rule %d [%p]: ", k, r->func);
                         if (r->var >= 0) {
-                                printk("%s = ", snd_pcm_hw_param_names[r->var]);
+                                pr_cont("%s = ", snd_pcm_hw_param_names[r->var]);
                                 if (hw_is_mask(r->var)) {
                                         m = hw_param_mask(params, r->var);
-                                        printk("%x", *m->bits);
+                                        pr_cont("%x", *m->bits);
                                 } else {
                                         i = hw_param_interval(params, r->var);
                                         if (i->empty)
-                                                printk("empty");
+                                                pr_cont("empty");
                                         else
-                                                printk("%c%u %u%c", 
+                                                pr_cont("%c%u %u%c",
                                                        i->openmin ? '(' : '[', i->min,
                                                        i->max, i->openmax ? ')' : ']');
                                 }
@@ -275,19 +275,19 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
                         changed = r->func(params, r);
 #ifdef RULES_DEBUG
                         if (r->var >= 0) {
-                                printk(" -> ");
+                                pr_cont(" -> ");
                                 if (hw_is_mask(r->var))
-                                        printk("%x", *m->bits);
+                                        pr_cont("%x", *m->bits);
                                 else {
                                         if (i->empty)
-                                                printk("empty");
+                                                pr_cont("empty");
                                         else
-                                                printk("%c%u %u%c", 
+                                                pr_cont("%c%u %u%c",
                                                        i->openmin ? '(' : '[', i->min,
                                                        i->max, i->openmax ? ')' : ']');
                                 }
                         }
-                        printk("\n");
+                        pr_cont("\n");
 #endif
                         rstamps[k] = stamp;
                         if (changed && r->var >= 0) {
@@ -399,7 +399,7 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
                 return -EBADFD;
         }
         snd_pcm_stream_unlock_irq(substream);
-#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_PCM_OSS)
         if (!substream->oss.oss)
 #endif
                 if (atomic_read(&substream->mmap_count))
@@ -954,7 +954,7 @@ static struct action_ops snd_pcm_action_stop = {
  *
  * The state of each stream is then changed to the given state unconditionally.
  *
- * Return: Zero if succesful, or a negative error code.
+ * Return: Zero if successful, or a negative error code.
  */
 int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t state)
 {
@@ -1541,7 +1541,8 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
                         if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
                                 result = -ESTRPIPE;
                         else {
-                                snd_printd("playback drain error (DMA or IRQ trouble?)\n");
+                                dev_dbg(substream->pcm->card->dev,
+                                        "playback drain error (DMA or IRQ trouble?)\n");
                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
                                 result = -EIO;
                         }
@@ -2066,7 +2067,7 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
 
         err = snd_pcm_hw_constraints_init(substream);
         if (err < 0) {
-                snd_printd("snd_pcm_hw_constraints_init failed\n");
+                pcm_dbg(pcm, "snd_pcm_hw_constraints_init failed\n");
                 goto error;
         }
 
@@ -2077,7 +2078,7 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
 
         err = snd_pcm_hw_constraints_complete(substream);
         if (err < 0) {
-                snd_printd("snd_pcm_hw_constraints_complete failed\n");
+                pcm_dbg(pcm, "snd_pcm_hw_constraints_complete failed\n");
                 goto error;
         }
 
@@ -2609,7 +2610,7 @@ static int snd_pcm_common_ioctl1(struct file *file,
                 return res;
         }
         }
-        snd_printd("unknown ioctl = 0x%x\n", cmd);
+        pcm_dbg(substream->pcm, "unknown ioctl = 0x%x\n", cmd);
         return -ENOTTY;
 }
 
diff --git a/sound/core/pcm_timer.c b/sound/core/pcm_timer.c
index b01d9481d632..20ecd8f18080 100644
--- a/sound/core/pcm_timer.c
+++ b/sound/core/pcm_timer.c
@@ -53,7 +53,9 @@ void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream)
                 post *= 2;
         }
         if (rate == 0) {
-                snd_printk(KERN_ERR "pcm timer resolution out of range (rate = %u, period_size = %lu)\n", runtime->rate, runtime->period_size);
+                pcm_err(substream->pcm,
+                        "pcm timer resolution out of range (rate = %u, period_size = %lu)\n",
+                        runtime->rate, runtime->period_size);
                 runtime->timer_resolution = -1;
                 return;
         }
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index 7b596b5751db..6fc71a4c8a51 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -56,6 +56,13 @@ static int snd_rawmidi_dev_disconnect(struct snd_device *device);
 static LIST_HEAD(snd_rawmidi_devices);
 static DEFINE_MUTEX(register_mutex);
 
+#define rmidi_err(rmidi, fmt, args...) \
+        dev_err((rmidi)->card->dev, fmt, ##args)
+#define rmidi_warn(rmidi, fmt, args...) \
+        dev_warn((rmidi)->card->dev, fmt, ##args)
+#define rmidi_dbg(rmidi, fmt, args...) \
+        dev_dbg((rmidi)->card->dev, fmt, ##args)
+
 static struct snd_rawmidi *snd_rawmidi_search(struct snd_card *card, int device)
 {
         struct snd_rawmidi *rawmidi;
@@ -165,6 +172,7 @@ int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream)
         spin_unlock_irqrestore(&runtime->lock, flags);
         return 0;
 }
+EXPORT_SYMBOL(snd_rawmidi_drop_output);
 
 int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream)
 {
@@ -180,7 +188,9 @@ int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream)
         if (signal_pending(current))
                 err = -ERESTARTSYS;
         if (runtime->avail < runtime->buffer_size && !timeout) {
-                snd_printk(KERN_WARNING "rawmidi drain error (avail = %li, buffer_size = %li)\n", (long)runtime->avail, (long)runtime->buffer_size);
+                rmidi_warn(substream->rmidi,
+                           "rawmidi drain error (avail = %li, buffer_size = %li)\n",
+                           (long)runtime->avail, (long)runtime->buffer_size);
                 err = -EIO;
         }
         runtime->drain = 0;
@@ -194,6 +204,7 @@ int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream)
         }
         return err;
 }
+EXPORT_SYMBOL(snd_rawmidi_drain_output);
 
 int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream)
 {
@@ -208,6 +219,7 @@ int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream)
         spin_unlock_irqrestore(&runtime->lock, flags);
         return 0;
 }
+EXPORT_SYMBOL(snd_rawmidi_drain_input);
 
 /* look for an available substream for the given stream direction;
  * if a specific subdevice is given, try to assign it
@@ -345,6 +357,7 @@ int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice,
                 module_put(rmidi->card->module);
         return err;
 }
+EXPORT_SYMBOL(snd_rawmidi_kernel_open);
 
 static int snd_rawmidi_open(struct inode *inode, struct file *file)
 {
@@ -523,6 +536,7 @@ int snd_rawmidi_kernel_release(struct snd_rawmidi_file *rfile)
         module_put(rmidi->card->module);
         return 0;
 }
+EXPORT_SYMBOL(snd_rawmidi_kernel_release);
 
 static int snd_rawmidi_release(struct inode *inode, struct file *file)
 {
@@ -599,6 +613,7 @@ int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info
         }
         return -ENXIO;
 }
+EXPORT_SYMBOL(snd_rawmidi_info_select);
 
 static int snd_rawmidi_info_select_user(struct snd_card *card,
                                         struct snd_rawmidi_info __user *_info)
@@ -646,6 +661,7 @@ int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream,
         substream->active_sensing = !params->no_active_sensing;
         return 0;
 }
+EXPORT_SYMBOL(snd_rawmidi_output_params);
 
 int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream,
                              struct snd_rawmidi_params * params)
@@ -671,6 +687,7 @@ int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream,
         runtime->avail_min = params->avail_min;
         return 0;
 }
+EXPORT_SYMBOL(snd_rawmidi_input_params);
 
 static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream,
                                      struct snd_rawmidi_status * status)
@@ -802,10 +819,9 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long
                         return -EINVAL;
                 }
         }
-#ifdef CONFIG_SND_DEBUG
         default:
-                snd_printk(KERN_WARNING "rawmidi: unknown command = 0x%x\n", cmd);
-#endif
+                rmidi_dbg(rfile->rmidi,
+                          "rawmidi: unknown command = 0x%x\n", cmd);
         }
         return -ENOTTY;
 }
@@ -875,7 +891,8 @@ int snd_rawmidi_receive(struct snd_rawmidi_substream *substream,
         if (!substream->opened)
                 return -EBADFD;
         if (runtime->buffer == NULL) {
-                snd_printd("snd_rawmidi_receive: input is not active!!!\n");
+                rmidi_dbg(substream->rmidi,
+                          "snd_rawmidi_receive: input is not active!!!\n");
                 return -EINVAL;
         }
         spin_lock_irqsave(&runtime->lock, flags);
@@ -926,6 +943,7 @@ int snd_rawmidi_receive(struct snd_rawmidi_substream *substream,
         spin_unlock_irqrestore(&runtime->lock, flags);
         return result;
 }
+EXPORT_SYMBOL(snd_rawmidi_receive);
 
 static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream,
                                      unsigned char __user *userbuf,
@@ -968,6 +986,7 @@ long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream,
         snd_rawmidi_input_trigger(substream, 1);
         return snd_rawmidi_kernel_read1(substream, NULL/*userbuf*/, buf, count);
 }
+EXPORT_SYMBOL(snd_rawmidi_kernel_read);
 
 static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count,
                                 loff_t *offset)
@@ -1034,7 +1053,8 @@ int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream)
         unsigned long flags;
 
         if (runtime->buffer == NULL) {
-                snd_printd("snd_rawmidi_transmit_empty: output is not active!!!\n");
+                rmidi_dbg(substream->rmidi,
+                          "snd_rawmidi_transmit_empty: output is not active!!!\n");
                 return 1;
         }
         spin_lock_irqsave(&runtime->lock, flags);
@@ -1042,6 +1062,7 @@ int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream)
         spin_unlock_irqrestore(&runtime->lock, flags);
         return result;          
 }
+EXPORT_SYMBOL(snd_rawmidi_transmit_empty);
 
 /**
  * snd_rawmidi_transmit_peek - copy data from the internal buffer
@@ -1065,7 +1086,8 @@ int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
         struct snd_rawmidi_runtime *runtime = substream->runtime;
 
         if (runtime->buffer == NULL) {
-                snd_printd("snd_rawmidi_transmit_peek: output is not active!!!\n");
+                rmidi_dbg(substream->rmidi,
+                          "snd_rawmidi_transmit_peek: output is not active!!!\n");
                 return -EINVAL;
         }
         result = 0;
@@ -1097,11 +1119,12 @@ int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
         spin_unlock_irqrestore(&runtime->lock, flags);
         return result;
 }
+EXPORT_SYMBOL(snd_rawmidi_transmit_peek);
 
 /**
  * snd_rawmidi_transmit_ack - acknowledge the transmission
  * @substream: the rawmidi substream
- * @count: the tranferred count
+ * @count: the transferred count
  *
  * Advances the hardware pointer for the internal output buffer with
  * the given size and updates the condition.
@@ -1115,7 +1138,8 @@ int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
         struct snd_rawmidi_runtime *runtime = substream->runtime;
 
         if (runtime->buffer == NULL) {
-                snd_printd("snd_rawmidi_transmit_ack: output is not active!!!\n");
+                rmidi_dbg(substream->rmidi,
+                          "snd_rawmidi_transmit_ack: output is not active!!!\n");
                 return -EINVAL;
         }
         spin_lock_irqsave(&runtime->lock, flags);
@@ -1131,6 +1155,7 @@ int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
         spin_unlock_irqrestore(&runtime->lock, flags);
         return count;
 }
+EXPORT_SYMBOL(snd_rawmidi_transmit_ack);
 
 /**
  * snd_rawmidi_transmit - copy from the buffer to the device
@@ -1152,6 +1177,7 @@ int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream,
                 return count;
         return snd_rawmidi_transmit_ack(substream, count);
 }
+EXPORT_SYMBOL(snd_rawmidi_transmit);
 
 static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
                                       const unsigned char __user *userbuf,
@@ -1213,6 +1239,7 @@ long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream,
 {
         return snd_rawmidi_kernel_write1(substream, NULL, buf, count);
 }
+EXPORT_SYMBOL(snd_rawmidi_kernel_write);
 
 static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf,
                                  size_t count, loff_t *offset)
@@ -1413,7 +1440,7 @@ static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi,
         for (idx = 0; idx < count; idx++) {
                 substream = kzalloc(sizeof(*substream), GFP_KERNEL);
                 if (substream == NULL) {
-                        snd_printk(KERN_ERR "rawmidi: cannot allocate substream\n");
+                        rmidi_err(rmidi, "rawmidi: cannot allocate substream\n");
                         return -ENOMEM;
                 }
                 substream->stream = direction;
@@ -1458,7 +1485,7 @@ int snd_rawmidi_new(struct snd_card *card, char *id, int device,
                 *rrawmidi = NULL;
         rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL);
         if (rmidi == NULL) {
-                snd_printk(KERN_ERR "rawmidi: cannot allocate\n");
+                dev_err(card->dev, "rawmidi: cannot allocate\n");
                 return -ENOMEM;
         }
         rmidi->card = card;
@@ -1492,6 +1519,7 @@ int snd_rawmidi_new(struct snd_card *card, char *id, int device,
                 *rrawmidi = rmidi;
         return 0;
 }
+EXPORT_SYMBOL(snd_rawmidi_new);
 
 static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream)
 {
@@ -1557,7 +1585,8 @@ static int snd_rawmidi_dev_register(struct snd_device *device)
         if ((err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI,
                                        rmidi->card, rmidi->device,
                                        &snd_rawmidi_f_ops, rmidi, name)) < 0) {
-                snd_printk(KERN_ERR "unable to register rawmidi device %i:%i\n", rmidi->card->number, rmidi->device);
+                rmidi_err(rmidi, "unable to register rawmidi device %i:%i\n",
+                          rmidi->card->number, rmidi->device);
                 list_del(&rmidi->list);
                 mutex_unlock(&register_mutex);
                 return err;
@@ -1574,8 +1603,10 @@ static int snd_rawmidi_dev_register(struct snd_device *device)
         if ((int)rmidi->device == midi_map[rmidi->card->number]) {
                 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI,
                                             rmidi->card, 0, &snd_rawmidi_f_ops,
-                                            rmidi, name) < 0) {
-                        snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 0);
+                                            rmidi) < 0) {
+                        rmidi_err(rmidi,
+                                  "unable to register OSS rawmidi device %i:%i\n",
+                                  rmidi->card->number, 0);
                 } else {
                         rmidi->ossreg++;
 #ifdef SNDRV_OSS_INFO_DEV_MIDI
@@ -1586,8 +1617,10 @@ static int snd_rawmidi_dev_register(struct snd_device *device)
         if ((int)rmidi->device == amidi_map[rmidi->card->number]) {
                 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI,
                                             rmidi->card, 1, &snd_rawmidi_f_ops,
-                                            rmidi, name) < 0) {
-                        snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 1);
+                                            rmidi) < 0) {
+                        rmidi_err(rmidi,
+                                  "unable to register OSS rawmidi device %i:%i\n",
+                                  rmidi->card->number, 1);
                 } else {
                         rmidi->ossreg++;
                 }
@@ -1670,6 +1703,7 @@ void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream,
         list_for_each_entry(substream, &rmidi->streams[stream].substreams, list)
                 substream->ops = ops;
 }
+EXPORT_SYMBOL(snd_rawmidi_set_ops);
 
 /*
  *  ENTRY functions
@@ -1685,11 +1719,13 @@ static int __init alsa_rawmidi_init(void)
         /* check device map table */
         for (i = 0; i < SNDRV_CARDS; i++) {
                 if (midi_map[i] < 0 || midi_map[i] >= SNDRV_RAWMIDI_DEVICES) {
-                        snd_printk(KERN_ERR "invalid midi_map[%d] = %d\n", i, midi_map[i]);
+                        pr_err("ALSA: rawmidi: invalid midi_map[%d] = %d\n",
+                               i, midi_map[i]);
                         midi_map[i] = 0;
                 }
                 if (amidi_map[i] < 0 || amidi_map[i] >= SNDRV_RAWMIDI_DEVICES) {
-                        snd_printk(KERN_ERR "invalid amidi_map[%d] = %d\n", i, amidi_map[i]);
+                        pr_err("ALSA: rawmidi: invalid amidi_map[%d] = %d\n",
+                               i, amidi_map[i]);
                         amidi_map[i] = 1;
                 }
         }
@@ -1706,21 +1742,3 @@ static void __exit alsa_rawmidi_exit(void)
 
 module_init(alsa_rawmidi_init)
 module_exit(alsa_rawmidi_exit)
-
-EXPORT_SYMBOL(snd_rawmidi_output_params);
-EXPORT_SYMBOL(snd_rawmidi_input_params);
-EXPORT_SYMBOL(snd_rawmidi_drop_output);
-EXPORT_SYMBOL(snd_rawmidi_drain_output);
-EXPORT_SYMBOL(snd_rawmidi_drain_input);
-EXPORT_SYMBOL(snd_rawmidi_receive);
-EXPORT_SYMBOL(snd_rawmidi_transmit_empty);
-EXPORT_SYMBOL(snd_rawmidi_transmit_peek);
-EXPORT_SYMBOL(snd_rawmidi_transmit_ack);
-EXPORT_SYMBOL(snd_rawmidi_transmit);
-EXPORT_SYMBOL(snd_rawmidi_new);
-EXPORT_SYMBOL(snd_rawmidi_set_ops);
-EXPORT_SYMBOL(snd_rawmidi_info_select);
-EXPORT_SYMBOL(snd_rawmidi_kernel_open);
-EXPORT_SYMBOL(snd_rawmidi_kernel_release);
-EXPORT_SYMBOL(snd_rawmidi_kernel_read);
-EXPORT_SYMBOL(snd_rawmidi_kernel_write);
diff --git a/sound/core/rtctimer.c b/sound/core/rtctimer.c
index e85e72baff9e..f3420d11a12f 100644
--- a/sound/core/rtctimer.c
+++ b/sound/core/rtctimer.c
@@ -27,7 +27,7 @@
 #include <sound/core.h>
 #include <sound/timer.h>
 
-#if defined(CONFIG_RTC) || defined(CONFIG_RTC_MODULE)
+#if IS_ENABLED(CONFIG_RTC)
 
 #include <linux/mc146818rtc.h>
 
@@ -132,8 +132,7 @@ static int __init rtctimer_init(void)
 
         if (rtctimer_freq < 2 || rtctimer_freq > 8192 ||
             !is_power_of_2(rtctimer_freq)) {
-                snd_printk(KERN_ERR "rtctimer: invalid frequency %d\n",
-                           rtctimer_freq);
+                pr_err("ALSA: rtctimer: invalid frequency %d\n", rtctimer_freq);
                 return -EINVAL;
         }
 
@@ -185,4 +184,4 @@ MODULE_LICENSE("GPL");
 
 MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_RTC));
 
-#endif /* CONFIG_RTC || CONFIG_RTC_MODULE */
+#endif /* IS_ENABLED(CONFIG_RTC) */
diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c
index 8d4d5e853efe..16d42679e43f 100644
--- a/sound/core/seq/oss/seq_oss.c
+++ b/sound/core/seq/oss/seq_oss.c
@@ -39,12 +39,6 @@ MODULE_LICENSE("GPL");
 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_SEQUENCER);
 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MUSIC);
 
-#ifdef SNDRV_SEQ_OSS_DEBUG
-module_param(seq_oss_debug, int, 0644);
-MODULE_PARM_DESC(seq_oss_debug, "debug option");
-int seq_oss_debug = 0;
-#endif
-
 
 /*
  * prototypes
@@ -231,22 +225,19 @@ register_device(void)
         mutex_lock(&register_mutex);
         if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER,
                                           NULL, 0,
-                                          &seq_oss_f_ops, NULL,
-                                          SNDRV_SEQ_OSS_DEVNAME)) < 0) {
-                snd_printk(KERN_ERR "can't register device seq\n");
+                                          &seq_oss_f_ops, NULL)) < 0) {
+                pr_err("ALSA: seq_oss: can't register device seq\n");
                 mutex_unlock(&register_mutex);
                 return rc;
         }
         if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC,
                                           NULL, 0,
-                                          &seq_oss_f_ops, NULL,
-                                          SNDRV_SEQ_OSS_DEVNAME)) < 0) {
-                snd_printk(KERN_ERR "can't register device music\n");
+                                          &seq_oss_f_ops, NULL)) < 0) {
+                pr_err("ALSA: seq_oss: can't register device music\n");
                 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0);
                 mutex_unlock(&register_mutex);
                 return rc;
         }
-        debug_printk(("device registered\n"));
         mutex_unlock(&register_mutex);
         return 0;
 }
@@ -255,11 +246,10 @@ static void
 unregister_device(void)
 {
         mutex_lock(&register_mutex);
-        debug_printk(("device unregistered\n"));
         if (snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC, NULL, 0) < 0)                
-                snd_printk(KERN_ERR "error unregister device music\n");
+                pr_err("ALSA: seq_oss: error unregister device music\n");
         if (snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0) < 0)
-                snd_printk(KERN_ERR "error unregister device seq\n");
+                pr_err("ALSA: seq_oss: error unregister device seq\n");
         mutex_unlock(&register_mutex);
 }
 
diff --git a/sound/core/seq/oss/seq_oss_device.h b/sound/core/seq/oss/seq_oss_device.h
index c0154a959d55..b43924325249 100644
--- a/sound/core/seq/oss/seq_oss_device.h
+++ b/sound/core/seq/oss/seq_oss_device.h
@@ -31,9 +31,6 @@
 #include <sound/seq_kernel.h>
 #include <sound/info.h>
 
-/* enable debug print */
-#define SNDRV_SEQ_OSS_DEBUG
-
 /* max. applications */
 #define SNDRV_SEQ_OSS_MAX_CLIENTS       16
 #define SNDRV_SEQ_OSS_MAX_SYNTH_DEVS    16
@@ -46,7 +43,6 @@
 #define SNDRV_SEQ_OSS_VERSION_STR       "0.1.8"
 
 /* device and proc interface name */
-#define SNDRV_SEQ_OSS_DEVNAME           "seq_oss"
 #define SNDRV_SEQ_OSS_PROCNAME          "oss"
 
 
@@ -177,13 +173,4 @@ snd_seq_oss_fill_addr(struct seq_oss_devinfo *dp, struct snd_seq_event *ev,
 /* misc. functions for proc interface */
 char *enabled_str(int bool);
 
-
-/* for debug */
-#ifdef SNDRV_SEQ_OSS_DEBUG
-extern int seq_oss_debug;
-#define debug_printk(x) do { if (seq_oss_debug > 0) snd_printd x; } while (0)
-#else
-#define debug_printk(x) /**/
-#endif
-
 #endif /* __SEQ_OSS_DEVICE_H */
diff --git a/sound/core/seq/oss/seq_oss_init.c b/sound/core/seq/oss/seq_oss_init.c
index b3f39b5ed742..b9184d20c39f 100644
--- a/sound/core/seq/oss/seq_oss_init.c
+++ b/sound/core/seq/oss/seq_oss_init.c
@@ -92,7 +92,6 @@ snd_seq_oss_create_client(void)
                 goto __error;
 
         system_client = rc;
-        debug_printk(("new client = %d\n", rc));
 
         /* create annoucement receiver port */
         memset(port, 0, sizeof(*port));
@@ -190,10 +189,9 @@ snd_seq_oss_open(struct file *file, int level)
 
         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
         if (!dp) {
-                snd_printk(KERN_ERR "can't malloc device info\n");
+                pr_err("ALSA: seq_oss: can't malloc device info\n");
                 return -ENOMEM;
         }
-        debug_printk(("oss_open: dp = %p\n", dp));
 
         dp->cseq = system_client;
         dp->port = -1;
@@ -206,7 +204,7 @@ snd_seq_oss_open(struct file *file, int level)
 
         dp->index = i;
         if (i >= SNDRV_SEQ_OSS_MAX_CLIENTS) {
-                snd_printk(KERN_ERR "too many applications\n");
+                pr_err("ALSA: seq_oss: too many applications\n");
                 rc = -ENOMEM;
                 goto _error;
         }
@@ -216,21 +214,19 @@ snd_seq_oss_open(struct file *file, int level)
         snd_seq_oss_midi_setup(dp);
 
         if (dp->synth_opened == 0 && dp->max_mididev == 0) {
-                /* snd_printk(KERN_ERR "no device found\n"); */
+                /* pr_err("ALSA: seq_oss: no device found\n"); */
                 rc = -ENODEV;
                 goto _error;
         }
 
         /* create port */
-        debug_printk(("create new port\n"));
         rc = create_port(dp);
         if (rc < 0) {
-                snd_printk(KERN_ERR "can't create port\n");
+                pr_err("ALSA: seq_oss: can't create port\n");
                 goto _error;
         }
 
         /* allocate queue */
-        debug_printk(("allocate queue\n"));
         rc = alloc_seq_queue(dp);
         if (rc < 0)
                 goto _error;
@@ -247,7 +243,6 @@ snd_seq_oss_open(struct file *file, int level)
         dp->file_mode = translate_mode(file);
 
         /* initialize read queue */
-        debug_printk(("initialize read queue\n"));
         if (is_read_mode(dp->file_mode)) {
                 dp->readq = snd_seq_oss_readq_new(dp, maxqlen);
                 if (!dp->readq) {
@@ -257,7 +252,6 @@ snd_seq_oss_open(struct file *file, int level)
         }
 
         /* initialize write queue */
-        debug_printk(("initialize write queue\n"));
         if (is_write_mode(dp->file_mode)) {
                 dp->writeq = snd_seq_oss_writeq_new(dp, maxqlen);
                 if (!dp->writeq) {
@@ -267,14 +261,12 @@ snd_seq_oss_open(struct file *file, int level)
         }
 
         /* initialize timer */
-        debug_printk(("initialize timer\n"));
         dp->timer = snd_seq_oss_timer_new(dp);
         if (!dp->timer) {
-                snd_printk(KERN_ERR "can't alloc timer\n");
+                pr_err("ALSA: seq_oss: can't alloc timer\n");
                 rc = -ENOMEM;
                 goto _error;
         }
-        debug_printk(("timer initialized\n"));
 
         /* set private data pointer */
         file->private_data = dp;
@@ -288,7 +280,6 @@ snd_seq_oss_open(struct file *file, int level)
         client_table[dp->index] = dp;
         num_clients++;
 
-        debug_printk(("open done\n"));
         return 0;
 
  _error:
@@ -347,7 +338,6 @@ create_port(struct seq_oss_devinfo *dp)
                 return rc;
 
         dp->port = port.addr.port;
-        debug_printk(("new port = %d\n", port.addr.port));
 
         return 0;
 }
@@ -363,7 +353,6 @@ delete_port(struct seq_oss_devinfo *dp)
                 return 0;
         }
 
-        debug_printk(("delete_port %i\n", dp->port));
         return snd_seq_event_port_detach(dp->cseq, dp->port);
 }
 
@@ -401,7 +390,7 @@ delete_seq_queue(int queue)
         qinfo.queue = queue;
         rc = call_ctl(SNDRV_SEQ_IOCTL_DELETE_QUEUE, &qinfo);
         if (rc < 0)
-                printk(KERN_ERR "seq-oss: unable to delete queue %d (%d)\n", queue, rc);
+                pr_err("ALSA: seq_oss: unable to delete queue %d (%d)\n", queue, rc);
         return rc;
 }
 
@@ -438,21 +427,16 @@ snd_seq_oss_release(struct seq_oss_devinfo *dp)
         client_table[dp->index] = NULL;
         num_clients--;
 
-        debug_printk(("resetting..\n"));
         snd_seq_oss_reset(dp);
 
-        debug_printk(("cleaning up..\n"));
         snd_seq_oss_synth_cleanup(dp);
         snd_seq_oss_midi_cleanup(dp);
 
         /* clear slot */
-        debug_printk(("releasing resource..\n"));
         queue = dp->queue;
         if (dp->port >= 0)
                 delete_port(dp);
         delete_seq_queue(queue);
-
-        debug_printk(("release done\n"));
 }
 
 
@@ -466,7 +450,6 @@ snd_seq_oss_drain_write(struct seq_oss_devinfo *dp)
                 return;
         if (is_write_mode(dp->file_mode) && !is_nonblock_mode(dp->file_mode) &&
             dp->writeq) {
-                debug_printk(("syncing..\n"));
                 while (snd_seq_oss_writeq_sync(dp->writeq))
                         ;
         }
diff --git a/sound/core/seq/oss/seq_oss_ioctl.c b/sound/core/seq/oss/seq_oss_ioctl.c
index 5ac701c903c1..5b8520177b0e 100644
--- a/sound/core/seq/oss/seq_oss_ioctl.c
+++ b/sound/core/seq/oss/seq_oss_ioctl.c
@@ -90,12 +90,10 @@ snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long ca
                 return snd_seq_oss_timer_ioctl(dp->timer, cmd, arg);
 
         case SNDCTL_SEQ_PANIC:
-                debug_printk(("panic\n"));
                 snd_seq_oss_reset(dp);
                 return -EINVAL;
 
         case SNDCTL_SEQ_SYNC:
-                debug_printk(("sync\n"));
                 if (! is_write_mode(dp->file_mode) || dp->writeq == NULL)
                         return 0;
                 while (snd_seq_oss_writeq_sync(dp->writeq))
@@ -105,55 +103,45 @@ snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long ca
                 return 0;
 
         case SNDCTL_SEQ_RESET:
-                debug_printk(("reset\n"));
                 snd_seq_oss_reset(dp);
                 return 0;
 
         case SNDCTL_SEQ_TESTMIDI:
-                debug_printk(("test midi\n"));
                 if (get_user(dev, p))
                         return -EFAULT;
                 return snd_seq_oss_midi_open(dp, dev, dp->file_mode);
 
         case SNDCTL_SEQ_GETINCOUNT:
-                debug_printk(("get in count\n"));
                 if (dp->readq == NULL || ! is_read_mode(dp->file_mode))
                         return 0;
                 return put_user(dp->readq->qlen, p) ? -EFAULT : 0;
 
         case SNDCTL_SEQ_GETOUTCOUNT:
-                debug_printk(("get out count\n"));
                 if (! is_write_mode(dp->file_mode) || dp->writeq == NULL)
                         return 0;
                 return put_user(snd_seq_oss_writeq_get_free_size(dp->writeq), p) ? -EFAULT : 0;
 
         case SNDCTL_SEQ_GETTIME:
-                debug_printk(("get time\n"));
                 return put_user(snd_seq_oss_timer_cur_tick(dp->timer), p) ? -EFAULT : 0;
 
         case SNDCTL_SEQ_RESETSAMPLES:
-                debug_printk(("reset samples\n"));
                 if (get_user(dev, p))
                         return -EFAULT;
                 return snd_seq_oss_synth_ioctl(dp, dev, cmd, carg);
 
         case SNDCTL_SEQ_NRSYNTHS:
-                debug_printk(("nr synths\n"));
                 return put_user(dp->max_synthdev, p) ? -EFAULT : 0;
 
         case SNDCTL_SEQ_NRMIDIS:
-                debug_printk(("nr midis\n"));
                 return put_user(dp->max_mididev, p) ? -EFAULT : 0;
 
         case SNDCTL_SYNTH_MEMAVL:
-                debug_printk(("mem avail\n"));
                 if (get_user(dev, p))
                         return -EFAULT;
                 val = snd_seq_oss_synth_ioctl(dp, dev, cmd, carg);
                 return put_user(val, p) ? -EFAULT : 0;
 
         case SNDCTL_FM_4OP_ENABLE:
-                debug_printk(("4op\n"));
                 if (get_user(dev, p))
                         return -EFAULT;
                 snd_seq_oss_synth_ioctl(dp, dev, cmd, carg);
@@ -161,19 +149,15 @@ snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long ca
 
         case SNDCTL_SYNTH_INFO:
         case SNDCTL_SYNTH_ID:
-                debug_printk(("synth info\n"));
                 return snd_seq_oss_synth_info_user(dp, arg);
 
         case SNDCTL_SEQ_OUTOFBAND:
-                debug_printk(("out of band\n"));
                 return snd_seq_oss_oob_user(dp, arg);
 
         case SNDCTL_MIDI_INFO:
-                debug_printk(("midi info\n"));
                 return snd_seq_oss_midi_info_user(dp, arg);
 
         case SNDCTL_SEQ_THRESHOLD:
-                debug_printk(("threshold\n"));
                 if (! is_write_mode(dp->file_mode))
                         return 0;
                 if (get_user(val, p))
@@ -186,7 +170,6 @@ snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long ca
                 return 0;
 
         case SNDCTL_MIDI_PRETIME:
-                debug_printk(("pretime\n"));
                 if (dp->readq == NULL || !is_read_mode(dp->file_mode))
                         return 0;
                 if (get_user(val, p))
@@ -199,7 +182,6 @@ snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long ca
                 return put_user(val, p) ? -EFAULT : 0;
 
         default:
-                debug_printk(("others\n"));
                 if (! is_write_mode(dp->file_mode))
                         return -EIO;
                 return snd_seq_oss_synth_ioctl(dp, 0, cmd, carg);
diff --git a/sound/core/seq/oss/seq_oss_midi.c b/sound/core/seq/oss/seq_oss_midi.c
index 862d84893ee8..3a4569669efa 100644
--- a/sound/core/seq/oss/seq_oss_midi.c
+++ b/sound/core/seq/oss/seq_oss_midi.c
@@ -153,7 +153,6 @@ snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo)
         struct seq_oss_midi *mdev;
         unsigned long flags;
 
-        debug_printk(("check for MIDI client %d port %d\n", pinfo->addr.client, pinfo->addr.port));
         /* the port must include generic midi */
         if (! (pinfo->type & SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC))
                 return 0;
@@ -175,7 +174,7 @@ snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo)
          * allocate midi info record
          */
         if ((mdev = kzalloc(sizeof(*mdev), GFP_KERNEL)) == NULL) {
-                snd_printk(KERN_ERR "can't malloc midi info\n");
+                pr_err("ALSA: seq_oss: can't malloc midi info\n");
                 return -ENOMEM;
         }
 
@@ -191,7 +190,7 @@ snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo)
 
         /* create MIDI coder */
         if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, &mdev->coder) < 0) {
-                snd_printk(KERN_ERR "can't malloc midi coder\n");
+                pr_err("ALSA: seq_oss: can't malloc midi coder\n");
                 kfree(mdev);
                 return -ENOMEM;
         }
@@ -406,7 +405,6 @@ snd_seq_oss_midi_close(struct seq_oss_devinfo *dp, int dev)
                 return 0;
         }
 
-        debug_printk(("closing client %d port %d mode %d\n", mdev->client, mdev->port, mdev->opened));
         memset(&subs, 0, sizeof(subs));
         if (mdev->opened & PERM_WRITE) {
                 subs.sender = dp->addr;
@@ -470,7 +468,6 @@ snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev)
                 struct snd_seq_event ev;
                 int c;
 
-                debug_printk(("resetting client %d port %d\n", mdev->client, mdev->port));
                 memset(&ev, 0, sizeof(ev));
                 ev.dest.client = mdev->client;
                 ev.dest.port = mdev->port;
diff --git a/sound/core/seq/oss/seq_oss_readq.c b/sound/core/seq/oss/seq_oss_readq.c
index 73661c4ab82a..654d17a5023c 100644
--- a/sound/core/seq/oss/seq_oss_readq.c
+++ b/sound/core/seq/oss/seq_oss_readq.c
@@ -48,12 +48,12 @@ snd_seq_oss_readq_new(struct seq_oss_devinfo *dp, int maxlen)
         struct seq_oss_readq *q;
 
         if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL) {
-                snd_printk(KERN_ERR "can't malloc read queue\n");
+                pr_err("ALSA: seq_oss: can't malloc read queue\n");
                 return NULL;
         }
 
         if ((q->q = kcalloc(maxlen, sizeof(union evrec), GFP_KERNEL)) == NULL) {
-                snd_printk(KERN_ERR "can't malloc read queue buffer\n");
+                pr_err("ALSA: seq_oss: can't malloc read queue buffer\n");
                 kfree(q);
                 return NULL;
         }
diff --git a/sound/core/seq/oss/seq_oss_synth.c b/sound/core/seq/oss/seq_oss_synth.c
index c5b773a1eea9..701feb71b700 100644
--- a/sound/core/seq/oss/seq_oss_synth.c
+++ b/sound/core/seq/oss/seq_oss_synth.c
@@ -106,7 +106,7 @@ snd_seq_oss_synth_register(struct snd_seq_device *dev)
         unsigned long flags;
 
         if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) {
-                snd_printk(KERN_ERR "can't malloc synth info\n");
+                pr_err("ALSA: seq_oss: can't malloc synth info\n");
                 return -ENOMEM;
         }
         rec->seq_device = -1;
@@ -130,7 +130,7 @@ snd_seq_oss_synth_register(struct snd_seq_device *dev)
         if (i >= max_synth_devs) {
                 if (max_synth_devs >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS) {
                         spin_unlock_irqrestore(&register_lock, flags);
-                        snd_printk(KERN_ERR "no more synth slot\n");
+                        pr_err("ALSA: seq_oss: no more synth slot\n");
                         kfree(rec);
                         return -ENOMEM;
                 }
@@ -138,7 +138,6 @@ snd_seq_oss_synth_register(struct snd_seq_device *dev)
         }
         rec->seq_device = i;
         synth_devs[i] = rec;
-        debug_printk(("synth %s registered %d\n", rec->name, i));
         spin_unlock_irqrestore(&register_lock, flags);
         dev->driver_data = rec;
 #ifdef SNDRV_OSS_INFO_DEV_SYNTH
@@ -163,7 +162,7 @@ snd_seq_oss_synth_unregister(struct snd_seq_device *dev)
         }
         if (index >= max_synth_devs) {
                 spin_unlock_irqrestore(&register_lock, flags);
-                snd_printk(KERN_ERR "can't unregister synth\n");
+                pr_err("ALSA: seq_oss: can't unregister synth\n");
                 return -EINVAL;
         }
         synth_devs[index] = NULL;
@@ -248,7 +247,7 @@ snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp)
                 if (info->nr_voices > 0) {
                         info->ch = kcalloc(info->nr_voices, sizeof(struct seq_oss_chinfo), GFP_KERNEL);
                         if (!info->ch) {
-                                snd_printk(KERN_ERR "Cannot malloc\n");
+                                pr_err("ALSA: seq_oss: Cannot malloc voices\n");
                                 rec->oper.close(&info->arg);
                                 module_put(rec->oper.owner);
                                 snd_use_lock_free(&rec->use_lock);
@@ -256,7 +255,6 @@ snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp)
                         }
                         reset_channels(info);
                 }
-                debug_printk(("synth %d assigned\n", i));
                 info->opened++;
                 rec->opened++;
                 dp->synth_opened++;
@@ -326,7 +324,6 @@ snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp)
                         if (rec == NULL)
                                 continue;
                         if (rec->opened > 0) {
-                                debug_printk(("synth %d closed\n", i));
                                 rec->oper.close(&info->arg);
                                 module_put(rec->oper.owner);
                                 rec->opened = 0;
diff --git a/sound/core/seq/oss/seq_oss_timer.c b/sound/core/seq/oss/seq_oss_timer.c
index ab59cbfbcaf2..4f24ea9fad93 100644
--- a/sound/core/seq/oss/seq_oss_timer.c
+++ b/sound/core/seq/oss/seq_oss_timer.c
@@ -233,7 +233,6 @@ snd_seq_oss_timer_ioctl(struct seq_oss_timer *timer, unsigned int cmd, int __use
         int value;
 
         if (cmd == SNDCTL_SEQ_CTRLRATE) {
-                debug_printk(("ctrl rate\n"));
                 /* if *arg == 0, just return the current rate */
                 if (get_user(value, arg))
                         return -EFAULT;
@@ -248,21 +247,16 @@ snd_seq_oss_timer_ioctl(struct seq_oss_timer *timer, unsigned int cmd, int __use
 
         switch (cmd) {
         case SNDCTL_TMR_START:
-                debug_printk(("timer start\n"));
                 return snd_seq_oss_timer_start(timer);
         case SNDCTL_TMR_STOP:
-                debug_printk(("timer stop\n"));
                 return snd_seq_oss_timer_stop(timer);
         case SNDCTL_TMR_CONTINUE:
-                debug_printk(("timer continue\n"));
                 return snd_seq_oss_timer_continue(timer);
         case SNDCTL_TMR_TEMPO:
-                debug_printk(("timer tempo\n"));
                 if (get_user(value, arg))
                         return -EFAULT;
                 return snd_seq_oss_timer_tempo(timer, value);
         case SNDCTL_TMR_TIMEBASE:
-                debug_printk(("timer timebase\n"));
                 if (get_user(value, arg))
                         return -EFAULT;
                 if (value < MIN_OSS_TIMEBASE)
@@ -276,7 +270,6 @@ snd_seq_oss_timer_ioctl(struct seq_oss_timer *timer, unsigned int cmd, int __use
         case SNDCTL_TMR_METRONOME:
         case SNDCTL_TMR_SELECT:
         case SNDCTL_TMR_SOURCE:
-                debug_printk(("timer XXX\n"));
                 /* not supported */
                 return 0;
         }
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 4dc6bae80e15..9ca5e647e54b 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -123,7 +123,7 @@ static inline int snd_seq_write_pool_allocated(struct snd_seq_client *client)
 static struct snd_seq_client *clientptr(int clientid)
 {
         if (clientid < 0 || clientid >= SNDRV_SEQ_MAX_CLIENTS) {
-                snd_printd("Seq: oops. Trying to get pointer to client %d\n",
+                pr_debug("ALSA: seq: oops. Trying to get pointer to client %d\n",
                            clientid);
                 return NULL;
         }
@@ -136,7 +136,7 @@ struct snd_seq_client *snd_seq_client_use_ptr(int clientid)
         struct snd_seq_client *client;
 
         if (clientid < 0 || clientid >= SNDRV_SEQ_MAX_CLIENTS) {
-                snd_printd("Seq: oops. Trying to get pointer to client %d\n",
+                pr_debug("ALSA: seq: oops. Trying to get pointer to client %d\n",
                            clientid);
                 return NULL;
         }
@@ -291,8 +291,8 @@ static void seq_free_client(struct snd_seq_client * client)
         mutex_lock(&register_mutex);
         switch (client->type) {
         case NO_CLIENT:
-                snd_printk(KERN_WARNING "Seq: Trying to free unused client %d\n",
-                           client->number);
+                pr_warn("ALSA: seq: Trying to free unused client %d\n",
+                        client->number);
                 break;
         case USER_CLIENT:
         case KERNEL_CLIENT:
@@ -301,7 +301,7 @@ static void seq_free_client(struct snd_seq_client * client)
                 break;
 
         default:
-                snd_printk(KERN_ERR "Seq: Trying to free client %d with undefined type = %d\n",
+                pr_err("ALSA: seq: Trying to free client %d with undefined type = %d\n",
                            client->number, client->type);
         }
         mutex_unlock(&register_mutex);
@@ -773,7 +773,7 @@ static int broadcast_event(struct snd_seq_client *client,
 static int multicast_event(struct snd_seq_client *client, struct snd_seq_event *event,
                            int atomic, int hop)
 {
-        snd_printd("seq: multicast not supported yet.\n");
+        pr_debug("ALSA: seq: multicast not supported yet.\n");
         return 0; /* ignored */
 }
 #endif /* SUPPORT_BROADCAST */
@@ -794,7 +794,7 @@ static int snd_seq_deliver_event(struct snd_seq_client *client, struct snd_seq_e
 
         hop++;
         if (hop >= SNDRV_SEQ_MAX_HOPS) {
-                snd_printd("too long delivery path (%d:%d->%d:%d)\n",
+                pr_debug("ALSA: seq: too long delivery path (%d:%d->%d:%d)\n",
                            event->source.client, event->source.port,
                            event->dest.client, event->dest.port);
                 return -EMLINK;
@@ -2196,7 +2196,7 @@ static int snd_seq_do_ioctl(struct snd_seq_client *client, unsigned int cmd,
                 if (p->cmd == cmd)
                         return p->func(client, arg);
         }
-        snd_printd("seq unknown ioctl() 0x%x (type='%c', number=0x%02x)\n",
+        pr_debug("ALSA: seq unknown ioctl() 0x%x (type='%c', number=0x%02x)\n",
                    cmd, _IOC_TYPE(cmd), _IOC_NR(cmd));
         return -ENOTTY;
 }
diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c
index 040c60e1da28..91a786a783e1 100644
--- a/sound/core/seq/seq_device.c
+++ b/sound/core/seq/seq_device.c
@@ -168,7 +168,7 @@ void snd_seq_device_load_drivers(void)
 
 /*
  * register a sequencer device
- * card = card info (NULL allowed)
+ * card = card info
  * device = device number (if any)
  * id = id of driver
  * result = return pointer (NULL allowed if unnecessary)
@@ -325,7 +325,7 @@ int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry,
                 return -ENOMEM;
         }
         if (ops->driver & DRIVER_LOADED) {
-                snd_printk(KERN_WARNING "driver_register: driver '%s' already exists\n", id);
+                pr_warn("ALSA: seq: driver_register: driver '%s' already exists\n", id);
                 unlock_driver(ops);
                 snd_seq_autoload_unlock();
                 return -EBUSY;
@@ -398,7 +398,7 @@ int snd_seq_device_unregister_driver(char *id)
                 return -ENXIO;
         if (! (ops->driver & DRIVER_LOADED) ||
             (ops->driver & DRIVER_LOCKED)) {
-                snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n",
+                pr_err("ALSA: seq: driver_unregister: cannot unload driver '%s': status=%x\n",
                            id, ops->driver);
                 unlock_driver(ops);
                 return -EBUSY;
@@ -413,7 +413,7 @@ int snd_seq_device_unregister_driver(char *id)
 
         ops->driver = 0;
         if (ops->num_init_devices > 0)
-                snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n",
+                pr_err("ALSA: seq: free_driver: init_devices > 0!! (%d)\n",
                            ops->num_init_devices);
         mutex_unlock(&ops->reg_mutex);
 
@@ -459,7 +459,7 @@ static int init_device(struct snd_seq_device *dev, struct ops_list *ops)
         if (dev->status != SNDRV_SEQ_DEVICE_FREE)
                 return 0; /* already initialized */
         if (ops->argsize != dev->argsize) {
-                snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
+                pr_err("ALSA: seq: incompatible device '%s' for plug-in '%s' (%d %d)\n",
                            dev->name, ops->id, ops->argsize, dev->argsize);
                 return -EINVAL;
         }
@@ -467,7 +467,7 @@ static int init_device(struct snd_seq_device *dev, struct ops_list *ops)
                 dev->status = SNDRV_SEQ_DEVICE_REGISTERED;
                 ops->num_init_devices++;
         } else {
-                snd_printk(KERN_ERR "init_device failed: %s: %s\n",
+                pr_err("ALSA: seq: init_device failed: %s: %s\n",
                            dev->name, dev->id);
         }
 
@@ -486,7 +486,7 @@ static int free_device(struct snd_seq_device *dev, struct ops_list *ops)
         if (dev->status != SNDRV_SEQ_DEVICE_REGISTERED)
                 return 0; /* not registered */
         if (ops->argsize != dev->argsize) {
-                snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
+                pr_err("ALSA: seq: incompatible device '%s' for plug-in '%s' (%d %d)\n",
                            dev->name, ops->id, ops->argsize, dev->argsize);
                 return -EINVAL;
         }
@@ -495,7 +495,7 @@ static int free_device(struct snd_seq_device *dev, struct ops_list *ops)
                 dev->driver_data = NULL;
                 ops->num_init_devices--;
         } else {
-                snd_printk(KERN_ERR "free_device failed: %s: %s\n",
+                pr_err("ALSA: seq: free_device failed: %s: %s\n",
                            dev->name, dev->id);
         }
 
@@ -559,7 +559,7 @@ static void __exit alsa_seq_device_exit(void)
         snd_info_free_entry(info_entry);
 #endif
         if (num_ops)
-                snd_printk(KERN_ERR "drivers not released (%d)\n", num_ops);
+                pr_err("ALSA: seq: drivers not released (%d)\n", num_ops);
 }
 
 module_init(alsa_seq_device_init)
diff --git a/sound/core/seq/seq_dummy.c b/sound/core/seq/seq_dummy.c
index dbc550716790..ec667f158f19 100644
--- a/sound/core/seq/seq_dummy.c
+++ b/sound/core/seq/seq_dummy.c
@@ -198,7 +198,7 @@ register_client(void)
         int i;
 
         if (ports < 1) {
-                snd_printk(KERN_ERR "invalid number of ports %d\n", ports);
+                pr_err("ALSA: seq_dummy: invalid number of ports %d\n", ports);
                 return -EINVAL;
         }
 
diff --git a/sound/core/seq/seq_fifo.c b/sound/core/seq/seq_fifo.c
index 0d75afa786bc..559989992bef 100644
--- a/sound/core/seq/seq_fifo.c
+++ b/sound/core/seq/seq_fifo.c
@@ -34,7 +34,7 @@ struct snd_seq_fifo *snd_seq_fifo_new(int poolsize)
 
         f = kzalloc(sizeof(*f), GFP_KERNEL);
         if (f == NULL) {
-                snd_printd("malloc failed for snd_seq_fifo_new() \n");
+                pr_debug("ALSA: seq: malloc failed for snd_seq_fifo_new() \n");
                 return NULL;
         }
 
diff --git a/sound/core/seq/seq_lock.c b/sound/core/seq/seq_lock.c
index 2cfe50c71a9d..3b693e924db7 100644
--- a/sound/core/seq/seq_lock.c
+++ b/sound/core/seq/seq_lock.c
@@ -31,12 +31,12 @@ void snd_use_lock_sync_helper(snd_use_lock_t *lockp, const char *file, int line)
         int max_count = 5 * HZ;
 
         if (atomic_read(lockp) < 0) {
-                printk(KERN_WARNING "seq_lock: lock trouble [counter = %d] in %s:%d\n", atomic_read(lockp), file, line);
+                pr_warn("ALSA: seq_lock: lock trouble [counter = %d] in %s:%d\n", atomic_read(lockp), file, line);
                 return;
         }
         while (atomic_read(lockp) > 0) {
                 if (max_count == 0) {
-                        snd_printk(KERN_WARNING "seq_lock: timeout [%d left] in %s:%d\n", atomic_read(lockp), file, line);
+                        pr_warn("ALSA: seq_lock: timeout [%d left] in %s:%d\n", atomic_read(lockp), file, line);
                         break;
                 }
                 schedule_timeout_uninterruptible(1);
diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c
index f478f770bf52..1e206de0c2dd 100644
--- a/sound/core/seq/seq_memory.c
+++ b/sound/core/seq/seq_memory.c
@@ -236,7 +236,7 @@ static int snd_seq_cell_alloc(struct snd_seq_pool *pool,
         init_waitqueue_entry(&wait, current);
         spin_lock_irqsave(&pool->lock, flags);
         if (pool->ptr == NULL) {        /* not initialized */
-                snd_printd("seq: pool is not initialized\n");
+                pr_debug("ALSA: seq: pool is not initialized\n");
                 err = -EINVAL;
                 goto __error;
         }
@@ -388,7 +388,7 @@ int snd_seq_pool_init(struct snd_seq_pool *pool)
 
         pool->ptr = vmalloc(sizeof(struct snd_seq_event_cell) * pool->size);
         if (pool->ptr == NULL) {
-                snd_printd("seq: malloc for sequencer events failed\n");
+                pr_debug("ALSA: seq: malloc for sequencer events failed\n");
                 return -ENOMEM;
         }
 
@@ -431,7 +431,7 @@ int snd_seq_pool_done(struct snd_seq_pool *pool)
 
         while (atomic_read(&pool->counter) > 0) {
                 if (max_count == 0) {
-                        snd_printk(KERN_WARNING "snd_seq_pool_done timeout: %d cells remain\n", atomic_read(&pool->counter));
+                        pr_warn("ALSA: snd_seq_pool_done timeout: %d cells remain\n", atomic_read(&pool->counter));
                         break;
                 }
                 schedule_timeout_uninterruptible(1);
@@ -464,7 +464,7 @@ struct snd_seq_pool *snd_seq_pool_new(int poolsize)
         /* create pool block */
         pool = kzalloc(sizeof(*pool), GFP_KERNEL);
         if (pool == NULL) {
-                snd_printd("seq: malloc failed for pool\n");
+                pr_debug("ALSA: seq: malloc failed for pool\n");
                 return NULL;
         }
         spin_lock_init(&pool->lock);
diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c
index 64069dbf89ca..3e05c55a2880 100644
--- a/sound/core/seq/seq_midi.c
+++ b/sound/core/seq/seq_midi.c
@@ -121,7 +121,7 @@ static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, i
         runtime = substream->runtime;
         if ((tmp = runtime->avail) < count) {
                 if (printk_ratelimit())
-                        snd_printk(KERN_ERR "MIDI output buffer overrun\n");
+                        pr_err("ALSA: seq_midi: MIDI output buffer overrun\n");
                 return -ENOMEM;
         }
         if (snd_rawmidi_kernel_write(substream, buf, count) < count)
@@ -145,7 +145,7 @@ static int event_process_midi(struct snd_seq_event *ev, int direct,
         if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {        /* special case, to save space */
                 if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE) {
                         /* invalid event */
-                        snd_printd("seq_midi: invalid sysex event flags = 0x%x\n", ev->flags);
+                        pr_debug("ALSA: seq_midi: invalid sysex event flags = 0x%x\n", ev->flags);
                         return 0;
                 }
                 snd_seq_dump_var_event(ev, (snd_seq_dump_func_t)dump_midi, substream);
@@ -189,7 +189,7 @@ static int midisynth_subscribe(void *private_data, struct snd_seq_port_subscribe
                                            msynth->subdevice,
                                            SNDRV_RAWMIDI_LFLG_INPUT,
                                            &msynth->input_rfile)) < 0) {
-                snd_printd("midi input open failed!!!\n");
+                pr_debug("ALSA: seq_midi: midi input open failed!!!\n");
                 return err;
         }
         runtime = msynth->input_rfile.input->runtime;
@@ -231,7 +231,7 @@ static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info
                                            msynth->subdevice,
                                            SNDRV_RAWMIDI_LFLG_OUTPUT,
                                            &msynth->output_rfile)) < 0) {
-                snd_printd("midi output open failed!!!\n");
+                pr_debug("ALSA: seq_midi: midi output open failed!!!\n");
                 return err;
         }
         memset(&params, 0, sizeof(params));
diff --git a/sound/core/seq/seq_midi_emul.c b/sound/core/seq/seq_midi_emul.c
index 6f64471ddde3..9b6470cdcf24 100644
--- a/sound/core/seq/seq_midi_emul.c
+++ b/sound/core/seq/seq_midi_emul.c
@@ -89,7 +89,7 @@ snd_midi_process_event(struct snd_midi_op *ops,
         int dest_channel = 0;
 
         if (ev == NULL || chanset == NULL) {
-                snd_printd("ev or chanbase NULL (snd_midi_process_event)\n");
+                pr_debug("ALSA: seq_midi_emul: ev or chanbase NULL (snd_midi_process_event)\n");
                 return;
         }
         if (chanset->channels == NULL)
@@ -98,7 +98,7 @@ snd_midi_process_event(struct snd_midi_op *ops,
         if (snd_seq_ev_is_channel_type(ev)) {
                 dest_channel = ev->data.note.channel;
                 if (dest_channel >= chanset->max_channels) {
-                        snd_printd("dest channel is %d, max is %d\n",
+                        pr_debug("ALSA: seq_midi_emul: dest channel is %d, max is %d\n",
                                    dest_channel, chanset->max_channels);
                         return;
                 }
@@ -232,7 +232,7 @@ snd_midi_process_event(struct snd_midi_op *ops,
         case SNDRV_SEQ_EVENT_ECHO:
         not_yet:
         default:
-                /*snd_printd("Unimplemented event %d\n", ev->type);*/
+                /*pr_debug("ALSA: seq_midi_emul: Unimplemented event %d\n", ev->type);*/
                 break;
         }
 }
diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index 9516e5ce3aad..794a341bf0e5 100644
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -135,14 +135,14 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
                 return NULL;
 
         if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) {
-                snd_printk(KERN_WARNING "too many ports for client %d\n", client->number);
+                pr_warn("ALSA: seq: too many ports for client %d\n", client->number);
                 return NULL;
         }
 
         /* create a new port */
         new_port = kzalloc(sizeof(*new_port), GFP_KERNEL);
         if (! new_port) {
-                snd_printd("malloc failed for registering client port\n");
+                pr_debug("ALSA: seq: malloc failed for registering client port\n");
                 return NULL;    /* failure, out of memory */
         }
         /* init port data */
diff --git a/sound/core/seq/seq_prioq.c b/sound/core/seq/seq_prioq.c
index 29896ab23403..021b02bc9330 100644
--- a/sound/core/seq/seq_prioq.c
+++ b/sound/core/seq/seq_prioq.c
@@ -60,7 +60,7 @@ struct snd_seq_prioq *snd_seq_prioq_new(void)
 
         f = kzalloc(sizeof(*f), GFP_KERNEL);
         if (f == NULL) {
-                snd_printd("oops: malloc failed for snd_seq_prioq_new()\n");
+                pr_debug("ALSA: seq: malloc failed for snd_seq_prioq_new()\n");
                 return NULL;
         }
         
@@ -79,7 +79,7 @@ void snd_seq_prioq_delete(struct snd_seq_prioq **fifo)
         *fifo = NULL;
 
         if (f == NULL) {
-                snd_printd("oops: snd_seq_prioq_delete() called with NULL prioq\n");
+                pr_debug("ALSA: seq: snd_seq_prioq_delete() called with NULL prioq\n");
                 return;
         }
 
@@ -197,7 +197,7 @@ int snd_seq_prioq_cell_in(struct snd_seq_prioq * f,
                 cur = cur->next;
                 if (! --count) {
                         spin_unlock_irqrestore(&f->lock, flags);
-                        snd_printk(KERN_ERR "cannot find a pointer.. infinite loop?\n");
+                        pr_err("ALSA: seq: cannot find a pointer.. infinite loop?\n");
                         return -EINVAL;
                 }
         }
@@ -223,7 +223,7 @@ struct snd_seq_event_cell *snd_seq_prioq_cell_out(struct snd_seq_prioq *f)
         unsigned long flags;
 
         if (f == NULL) {
-                snd_printd("oops: snd_seq_prioq_cell_in() called with NULL prioq\n");
+                pr_debug("ALSA: seq: snd_seq_prioq_cell_in() called with NULL prioq\n");
                 return NULL;
         }
         spin_lock_irqsave(&f->lock, flags);
@@ -248,7 +248,7 @@ struct snd_seq_event_cell *snd_seq_prioq_cell_out(struct snd_seq_prioq *f)
 int snd_seq_prioq_avail(struct snd_seq_prioq * f)
 {
         if (f == NULL) {
-                snd_printd("oops: snd_seq_prioq_cell_in() called with NULL prioq\n");
+                pr_debug("ALSA: seq: snd_seq_prioq_cell_in() called with NULL prioq\n");
                 return 0;
         }
         return f->cells;
@@ -259,7 +259,7 @@ int snd_seq_prioq_avail(struct snd_seq_prioq * f)
 struct snd_seq_event_cell *snd_seq_prioq_cell_peek(struct snd_seq_prioq * f)
 {
         if (f == NULL) {
-                snd_printd("oops: snd_seq_prioq_cell_in() called with NULL prioq\n");
+                pr_debug("ALSA: seq: snd_seq_prioq_cell_in() called with NULL prioq\n");
                 return NULL;
         }
         return f->head;
@@ -321,7 +321,7 @@ void snd_seq_prioq_leave(struct snd_seq_prioq * f, int client, int timestamp)
                         freeprev = cell;
                 } else {
 #if 0
-                        printk(KERN_DEBUG "type = %i, source = %i, dest = %i, "
+                        pr_debug("ALSA: seq: type = %i, source = %i, dest = %i, "
                                "client = %i\n",
                                 cell->event.type,
                                 cell->event.source.client,
diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c
index f9077361c119..aad4878cee55 100644
--- a/sound/core/seq/seq_queue.c
+++ b/sound/core/seq/seq_queue.c
@@ -112,7 +112,7 @@ static struct snd_seq_queue *queue_new(int owner, int locked)
 
         q = kzalloc(sizeof(*q), GFP_KERNEL);
         if (q == NULL) {
-                snd_printd("malloc failed for snd_seq_queue_new()\n");
+                pr_debug("ALSA: seq: malloc failed for snd_seq_queue_new()\n");
                 return NULL;
         }
 
diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c
index 24d44b2f61ac..e73605393eee 100644
--- a/sound/core/seq/seq_timer.c
+++ b/sound/core/seq/seq_timer.c
@@ -57,7 +57,7 @@ struct snd_seq_timer *snd_seq_timer_new(void)
         
         tmr = kzalloc(sizeof(*tmr), GFP_KERNEL);
         if (tmr == NULL) {
-                snd_printd("malloc failed for snd_seq_timer_new() \n");
+                pr_debug("ALSA: seq: malloc failed for snd_seq_timer_new() \n");
                 return NULL;
         }
         spin_lock_init(&tmr->lock);
@@ -78,7 +78,7 @@ void snd_seq_timer_delete(struct snd_seq_timer **tmr)
         *tmr = NULL;
 
         if (t == NULL) {
-                snd_printd("oops: snd_seq_timer_delete() called with NULL timer\n");
+                pr_debug("ALSA: seq: snd_seq_timer_delete() called with NULL timer\n");
                 return;
         }
         t->running = 0;
@@ -199,7 +199,7 @@ int snd_seq_timer_set_ppq(struct snd_seq_timer * tmr, int ppq)
                 /* refuse to change ppq on running timers */
                 /* because it will upset the song position (ticks) */
                 spin_unlock_irqrestore(&tmr->lock, flags);
-                snd_printd("seq: cannot change ppq of a running timer\n");
+                pr_debug("ALSA: seq: cannot change ppq of a running timer\n");
                 return -EBUSY;
         }
 
@@ -252,7 +252,7 @@ int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew,
 
         /* FIXME */
         if (base != SKEW_BASE) {
-                snd_printd("invalid skew base 0x%x\n", base);
+                pr_debug("ALSA: seq: invalid skew base 0x%x\n", base);
                 return -EINVAL;
         }
         spin_lock_irqsave(&tmr->lock, flags);
@@ -292,7 +292,7 @@ int snd_seq_timer_open(struct snd_seq_queue *q)
                 }
         }
         if (err < 0) {
-                snd_printk(KERN_ERR "seq fatal error: cannot create timer (%i)\n", err);
+                pr_err("ALSA: seq fatal error: cannot create timer (%i)\n", err);
                 return err;
         }
         t->callback = snd_seq_timer_interrupt;
diff --git a/sound/core/seq/seq_virmidi.c b/sound/core/seq/seq_virmidi.c
index 4b50e604276d..56e0f4cd3f82 100644
--- a/sound/core/seq/seq_virmidi.c
+++ b/sound/core/seq/seq_virmidi.c
@@ -446,7 +446,7 @@ static int snd_virmidi_dev_register(struct snd_rawmidi *rmidi)
                 /* should check presence of port more strictly.. */
                 break;
         default:
-                snd_printk(KERN_ERR "seq_mode is not set: %d\n", rdev->seq_mode);
+                pr_err("ALSA: seq_virmidi: seq_mode is not set: %d\n", rdev->seq_mode);
                 return -EINVAL;
         }
         return 0;
diff --git a/sound/core/sound.c b/sound/core/sound.c
index 437c25ea6403..38ad1a0dd3f7 100644
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -118,7 +118,7 @@ void *snd_lookup_minor_data(unsigned int minor, int type)
         if (mreg && mreg->type == type) {
                 private_data = mreg->private_data;
                 if (private_data && mreg->card_ptr)
-                        atomic_inc(&mreg->card_ptr->refcount);
+                        get_device(&mreg->card_ptr->card_dev);
         } else
                 private_data = NULL;
         mutex_unlock(&sound_mutex);
@@ -355,22 +355,25 @@ int snd_unregister_device(int type, struct snd_card *card, int dev)
 
 EXPORT_SYMBOL(snd_unregister_device);
 
-int snd_add_device_sysfs_file(int type, struct snd_card *card, int dev,
-                              struct device_attribute *attr)
+/* get the assigned device to the given type and device number;
+ * the caller needs to release it via put_device() after using it
+ */
+struct device *snd_get_device(int type, struct snd_card *card, int dev)
 {
-        int minor, ret = -EINVAL;
-        struct device *d;
+        int minor;
+        struct device *d = NULL;
 
         mutex_lock(&sound_mutex);
         minor = find_snd_minor(type, card, dev);
-        if (minor >= 0 && (d = snd_minors[minor]->dev) != NULL)
-                ret = device_create_file(d, attr);
+        if (minor >= 0) {
+                d = snd_minors[minor]->dev;
+                if (d)
+                        get_device(d);
+        }
         mutex_unlock(&sound_mutex);
-        return ret;
-
+        return d;
 }
-
-EXPORT_SYMBOL(snd_add_device_sysfs_file);
+EXPORT_SYMBOL(snd_get_device);
 
 #ifdef CONFIG_PROC_FS
 /*
@@ -458,7 +461,7 @@ static int __init alsa_sound_init(void)
         snd_major = major;
         snd_ecards_limit = cards_limit;
         if (register_chrdev(major, "alsa", &snd_fops)) {
-                snd_printk(KERN_ERR "unable to register native major device number %d\n", major);
+                pr_err("ALSA core: unable to register native major device number %d\n", major);
                 return -EIO;
         }
         if (snd_info_init() < 0) {
@@ -467,7 +470,7 @@ static int __init alsa_sound_init(void)
         }
         snd_info_minor_register();
 #ifndef MODULE
-        printk(KERN_INFO "Advanced Linux Sound Architecture Driver Initialized.\n");
+        pr_info("Advanced Linux Sound Architecture Driver Initialized.\n");
 #endif
         return 0;
 }
diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c
index 726a49ac9725..573a65eb2b79 100644
--- a/sound/core/sound_oss.c
+++ b/sound/core/sound_oss.c
@@ -21,7 +21,7 @@
 
 #ifdef CONFIG_SND_OSSEMUL
 
-#if !defined(CONFIG_SOUND) && !(defined(MODULE) && defined(CONFIG_SOUND_MODULE))
+#if !IS_ENABLED(CONFIG_SOUND)
 #error "Enable the OSS soundcore multiplexer (CONFIG_SOUND) in the kernel."
 #endif
 
@@ -55,7 +55,7 @@ void *snd_lookup_oss_minor_data(unsigned int minor, int type)
         if (mreg && mreg->type == type) {
                 private_data = mreg->private_data;
                 if (private_data && mreg->card_ptr)
-                        atomic_inc(&mreg->card_ptr->refcount);
+                        get_device(&mreg->card_ptr->card_dev);
         } else
                 private_data = NULL;
         mutex_unlock(&sound_oss_mutex);
@@ -105,8 +105,7 @@ static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
 }
 
 int snd_register_oss_device(int type, struct snd_card *card, int dev,
-                            const struct file_operations *f_ops, void *private_data,
-                            const char *name)
+                            const struct file_operations *f_ops, void *private_data)
 {
         int minor = snd_oss_kernel_minor(type, card, dev);
         int minor_unit;
diff --git a/sound/core/timer.c b/sound/core/timer.c
index 6ddcf06f52f9..cfd455a8ac1a 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -35,9 +35,9 @@
 #include <sound/initval.h>
 #include <linux/kmod.h>
 
-#if defined(CONFIG_SND_HRTIMER) || defined(CONFIG_SND_HRTIMER_MODULE)
+#if IS_ENABLED(CONFIG_SND_HRTIMER)
 #define DEFAULT_TIMER_LIMIT 4
-#elif defined(CONFIG_SND_RTCTIMER) || defined(CONFIG_SND_RTCTIMER_MODULE)
+#elif IS_ENABLED(CONFIG_SND_RTCTIMER)
 #define DEFAULT_TIMER_LIMIT 2
 #else
 #define DEFAULT_TIMER_LIMIT 1
@@ -240,7 +240,8 @@ int snd_timer_open(struct snd_timer_instance **ti,
                 /* open a slave instance */
                 if (tid->dev_sclass <= SNDRV_TIMER_SCLASS_NONE ||
                     tid->dev_sclass > SNDRV_TIMER_SCLASS_OSS_SEQUENCER) {
-                        snd_printd("invalid slave class %i\n", tid->dev_sclass);
+                        pr_debug("ALSA: timer: invalid slave class %i\n",
+                                 tid->dev_sclass);
                         return -EINVAL;
                 }
                 mutex_lock(&register_mutex);
@@ -774,7 +775,7 @@ int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
                 *rtimer = NULL;
         timer = kzalloc(sizeof(*timer), GFP_KERNEL);
         if (timer == NULL) {
-                snd_printk(KERN_ERR "timer: cannot allocate\n");
+                pr_err("ALSA: timer: cannot allocate\n");
                 return -ENOMEM;
         }
         timer->tmr_class = tid->dev_class;
@@ -813,7 +814,7 @@ static int snd_timer_free(struct snd_timer *timer)
         if (! list_empty(&timer->open_list_head)) {
                 struct list_head *p, *n;
                 struct snd_timer_instance *ti;
-                snd_printk(KERN_WARNING "timer %p is busy?\n", timer);
+                pr_warn("ALSA: timer %p is busy?\n", timer);
                 list_for_each_safe(p, n, &timer->open_list_head) {
                         list_del_init(p);
                         ti = list_entry(p, struct snd_timer_instance, open_list);
@@ -1955,12 +1956,10 @@ static int __init alsa_timer_init(void)
 #endif
 
         if ((err = snd_timer_register_system()) < 0)
-                snd_printk(KERN_ERR "unable to register system timer (%i)\n",
-                           err);
+                pr_err("ALSA: unable to register system timer (%i)\n", err);
         if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0,
                                        &snd_timer_f_ops, NULL, "timer")) < 0)
-                snd_printk(KERN_ERR "unable to register timer device (%i)\n",
-                           err);
+                pr_err("ALSA: unable to register timer device (%i)\n", err);
         snd_timer_proc_init();
         return 0;
 }
diff --git a/sound/core/vmaster.c b/sound/core/vmaster.c
index 842a97d5fc3a..6c58e6f73a01 100644
--- a/sound/core/vmaster.c
+++ b/sound/core/vmaster.c
@@ -101,7 +101,7 @@ static int slave_init(struct link_slave *slave)
         if (slave->info.count > 2  ||
             (slave->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER &&
              slave->info.type != SNDRV_CTL_ELEM_TYPE_BOOLEAN)) {
-                snd_printk(KERN_ERR "invalid slave element\n");
+                pr_err("ALSA: vmaster: invalid slave element\n");
                 kfree(uinfo);
                 return -EINVAL;
         }