Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

31 files changed, 447 insertions, 241 deletions

diff --git a/sound/core/control.c b/sound/core/control.c
index 45a818002d99..f8c5be464510 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -279,33 +279,31 @@ void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
 
 EXPORT_SYMBOL(snd_ctl_free_one);
 
-static unsigned int snd_ctl_hole_check(struct snd_card *card,
-                                       unsigned int count)
+static bool snd_ctl_remove_numid_conflict(struct snd_card *card,
+                                          unsigned int count)
 {
         struct snd_kcontrol *kctl;
 
         list_for_each_entry(kctl, &card->controls, list) {
-                if ((kctl->id.numid <= card->last_numid &&
-                     kctl->id.numid + kctl->count > card->last_numid) ||
-                    (kctl->id.numid <= card->last_numid + count - 1 &&
-                     kctl->id.numid + kctl->count > card->last_numid + count - 1))
-                        return card->last_numid = kctl->id.numid + kctl->count - 1;
+                if (kctl->id.numid < card->last_numid + 1 + count &&
+                    kctl->id.numid + kctl->count > card->last_numid + 1) {
+                        card->last_numid = kctl->id.numid + kctl->count - 1;
+                        return true;
+                }
         }
-        return card->last_numid;
+        return false;
 }
 
 static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
 {
-        unsigned int last_numid, iter = 100000;
+        unsigned int iter = 100000;
 
-        last_numid = card->last_numid;
-        while (last_numid != snd_ctl_hole_check(card, 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");
                         return -ENOMEM;
                 }
-                last_numid = card->last_numid;
         }
         return 0;
 }
@@ -368,6 +366,70 @@ int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
 EXPORT_SYMBOL(snd_ctl_add);
 
 /**
+ * snd_ctl_replace - replace the control instance of the card
+ * @card: the card instance
+ * @kcontrol: the control instance to replace
+ * @add_on_replace: add the control if not already added
+ *
+ * Replaces the given control.  If the given control does not exist
+ * and the add_on_replace flag is set, the control is added.  If the
+ * control exists, it is destroyed first.
+ *
+ * Returns zero if successful, or a negative error code on failure.
+ *
+ * It frees automatically the control which cannot be added or replaced.
+ */
+int snd_ctl_replace(struct snd_card *card, struct snd_kcontrol *kcontrol,
+                    bool add_on_replace)
+{
+        struct snd_ctl_elem_id id;
+        unsigned int idx;
+        struct snd_kcontrol *old;
+        int ret;
+
+        if (!kcontrol)
+                return -EINVAL;
+        if (snd_BUG_ON(!card || !kcontrol->info)) {
+                ret = -EINVAL;
+                goto error;
+        }
+        id = kcontrol->id;
+        down_write(&card->controls_rwsem);
+        old = snd_ctl_find_id(card, &id);
+        if (!old) {
+                if (add_on_replace)
+                        goto add;
+                up_write(&card->controls_rwsem);
+                ret = -EINVAL;
+                goto error;
+        }
+        ret = snd_ctl_remove(card, old);
+        if (ret < 0) {
+                up_write(&card->controls_rwsem);
+                goto error;
+        }
+add:
+        if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
+                up_write(&card->controls_rwsem);
+                ret = -ENOMEM;
+                goto error;
+        }
+        list_add_tail(&kcontrol->list, &card->controls);
+        card->controls_count += kcontrol->count;
+        kcontrol->id.numid = card->last_numid + 1;
+        card->last_numid += kcontrol->count;
+        up_write(&card->controls_rwsem);
+        for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
+                snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
+        return 0;
+
+error:
+        snd_ctl_free_one(kcontrol);
+        return ret;
+}
+EXPORT_SYMBOL(snd_ctl_replace);
+
+/**
  * snd_ctl_remove - remove the control from the card and release it
  * @card: the card instance
  * @kcontrol: the control instance to remove
@@ -466,6 +528,52 @@ error:
 }
 
 /**
+ * snd_ctl_activate_id - activate/inactivate the control of the given id
+ * @card: the card instance
+ * @id: the control id to activate/inactivate
+ * @active: non-zero to activate
+ *
+ * Finds the control instance with the given id, and activate or
+ * inactivate the control together with notification, if changed.
+ *
+ * Returns 0 if unchanged, 1 if changed, or a negative error code on failure.
+ */
+int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id,
+                        int active)
+{
+        struct snd_kcontrol *kctl;
+        struct snd_kcontrol_volatile *vd;
+        unsigned int index_offset;
+        int ret;
+
+        down_write(&card->controls_rwsem);
+        kctl = snd_ctl_find_id(card, id);
+        if (kctl == NULL) {
+                ret = -ENOENT;
+                goto unlock;
+        }
+        index_offset = snd_ctl_get_ioff(kctl, &kctl->id);
+        vd = &kctl->vd[index_offset];
+        ret = 0;
+        if (active) {
+                if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE))
+                        goto unlock;
+                vd->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        } else {
+                if (vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE)
+                        goto unlock;
+                vd->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        }
+        ret = 1;
+ unlock:
+        up_write(&card->controls_rwsem);
+        if (ret > 0)
+                snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, id);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_ctl_activate_id);
+
+/**
  * snd_ctl_rename_id - replace the id of a control on the card
  * @card: the card instance
  * @src_id: the old id
@@ -596,13 +704,12 @@ static int snd_ctl_elem_list(struct snd_card *card,
         struct snd_ctl_elem_list list;
         struct snd_kcontrol *kctl;
         struct snd_ctl_elem_id *dst, *id;
-        unsigned int offset, space, first, jidx;
+        unsigned int offset, space, jidx;
         
         if (copy_from_user(&list, _list, sizeof(list)))
                 return -EFAULT;
         offset = list.offset;
         space = list.space;
-        first = 0;
         /* try limit maximum space */
         if (space > 16384)
                 return -ENOMEM;
@@ -1488,7 +1595,7 @@ int snd_ctl_create(struct snd_card *card)
 }
 
 /*
- * Frequently used control callbacks
+ * Frequently used control callbacks/helpers
  */
 int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol,
                               struct snd_ctl_elem_info *uinfo)
@@ -1513,3 +1620,29 @@ int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol,
 }
 
 EXPORT_SYMBOL(snd_ctl_boolean_stereo_info);
+
+/**
+ * snd_ctl_enum_info - fills the info structure for an enumerated control
+ * @info: the structure to be filled
+ * @channels: the number of the control's channels; often one
+ * @items: the number of control values; also the size of @names
+ * @names: an array containing the names of all control values
+ *
+ * Sets all required fields in @info to their appropriate values.
+ * If the control's accessibility is not the default (readable and writable),
+ * the caller has to fill @info->access.
+ */
+int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels,
+                      unsigned int items, const char *const names[])
+{
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = channels;
+        info->value.enumerated.items = items;
+        if (info->value.enumerated.item >= items)
+                info->value.enumerated.item = items - 1;
+        strlcpy(info->value.enumerated.name,
+                names[info->value.enumerated.item],
+                sizeof(info->value.enumerated.name));
+        return 0;
+}
+EXPORT_SYMBOL(snd_ctl_enum_info);
diff --git a/sound/core/device.c b/sound/core/device.c
index a67dfac08c03..2d1ad4b0cd65 100644
--- a/sound/core/device.c
+++ b/sound/core/device.c
@@ -225,15 +225,16 @@ int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd)
 {
         struct snd_device *dev;
         int err;
-        unsigned int range_low, range_high;
+        unsigned int range_low, range_high, type;
 
         if (snd_BUG_ON(!card))
                 return -ENXIO;
-        range_low = cmd * SNDRV_DEV_TYPE_RANGE_SIZE;
+        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) {
-                if (dev->type >= range_low && dev->type <= range_high) {
+                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;
diff --git a/sound/core/hrtimer.c b/sound/core/hrtimer.c
index 7730575bfadd..b8b31c433d64 100644
--- a/sound/core/hrtimer.c
+++ b/sound/core/hrtimer.c
@@ -45,12 +45,13 @@ static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
 {
         struct snd_hrtimer *stime = container_of(hrt, struct snd_hrtimer, hrt);
         struct snd_timer *t = stime->timer;
+        unsigned long oruns;
 
         if (!atomic_read(&stime->running))
                 return HRTIMER_NORESTART;
 
-        hrtimer_forward_now(hrt, ns_to_ktime(t->sticks * resolution));
-        snd_timer_interrupt(stime->timer, t->sticks);
+        oruns = hrtimer_forward_now(hrt, ns_to_ktime(t->sticks * resolution));
+        snd_timer_interrupt(stime->timer, t->sticks * oruns);
 
         if (!atomic_read(&stime->running))
                 return HRTIMER_NORESTART;
@@ -104,7 +105,7 @@ static int snd_hrtimer_stop(struct snd_timer *t)
 }
 
 static struct snd_timer_hardware hrtimer_hw = {
-        .flags =        SNDRV_TIMER_HW_AUTO,
+        .flags =        SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_TASKLET,
         .open =         snd_hrtimer_open,
         .close =        snd_hrtimer_close,
         .start =        snd_hrtimer_start,
diff --git a/sound/core/info.c b/sound/core/info.c
index b70564ed8b37..7077f601da5a 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -23,7 +23,6 @@
 #include <linux/time.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/string.h>
 #include <sound/core.h>
 #include <sound/minors.h>
diff --git a/sound/core/init.c b/sound/core/init.c
index ec4a50ce5656..2c041bb36ab3 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -342,7 +342,6 @@ static const struct file_operations snd_shutdown_f_ops =
 int snd_card_disconnect(struct snd_card *card)
 {
         struct snd_monitor_file *mfile;
-        struct file *file;
         int err;
 
         if (!card)
@@ -366,8 +365,6 @@ int snd_card_disconnect(struct snd_card *card)
         
         spin_lock(&card->files_lock);
         list_for_each_entry(mfile, &card->files_list, list) {
-                file = mfile->file;
-
                 /* it's critical part, use endless loop */
                 /* we have no room to fail */
                 mfile->disconnected_f_op = mfile->file->f_op;
@@ -395,12 +392,10 @@ int snd_card_disconnect(struct snd_card *card)
                 snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number);
 
         snd_info_card_disconnect(card);
-#ifndef CONFIG_SYSFS_DEPRECATED
         if (card->card_dev) {
                 device_unregister(card->card_dev);
                 card->card_dev = NULL;
         }
-#endif
 #ifdef CONFIG_PM
         wake_up(&card->power_sleep);
 #endif
@@ -516,7 +511,7 @@ static void snd_card_set_id_no_lock(struct snd_card *card, const char *nid)
         id = card->id;
         
         if (*id == '\0')
-                strcpy(id, "default");
+                strcpy(id, "Default");
 
         while (1) {
                 if (loops-- == 0) {
@@ -573,7 +568,6 @@ void snd_card_set_id(struct snd_card *card, const char *nid)
 }
 EXPORT_SYMBOL(snd_card_set_id);
 
-#ifndef CONFIG_SYSFS_DEPRECATED
 static ssize_t
 card_id_show_attr(struct device *dev,
                   struct device_attribute *attr, char *buf)
@@ -607,11 +601,16 @@ card_id_store_attr(struct device *dev, struct device_attribute *attr,
                 return -EEXIST;
         }
         for (idx = 0; idx < snd_ecards_limit; idx++) {
-                if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1))
-                        goto __exist;
+                if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1)) {
+                        if (card == snd_cards[idx])
+                                goto __ok;
+                        else
+                                goto __exist;
+                }
         }
         strcpy(card->id, buf1);
         snd_info_card_id_change(card);
+__ok:
         mutex_unlock(&snd_card_mutex);
 
         return count;
@@ -630,7 +629,6 @@ card_number_show_attr(struct device *dev,
 
 static struct device_attribute card_number_attrs =
         __ATTR(number, S_IRUGO, card_number_show_attr, NULL);
-#endif /* CONFIG_SYSFS_DEPRECATED */
 
 /**
  *  snd_card_register - register the soundcard
@@ -641,7 +639,7 @@ static struct device_attribute card_number_attrs =
  *  external accesses.  Thus, you should call this function at the end
  *  of the initialization of the card.
  *
- *  Returns zero otherwise a negative error code if the registrain failed.
+ *  Returns zero otherwise a negative error code if the registration failed.
  */
 int snd_card_register(struct snd_card *card)
 {
@@ -649,7 +647,7 @@ int snd_card_register(struct snd_card *card)
 
         if (snd_BUG_ON(!card))
                 return -EINVAL;
-#ifndef CONFIG_SYSFS_DEPRECATED
+
         if (!card->card_dev) {
                 card->card_dev = device_create(sound_class, card->dev,
                                                MKDEV(0, 0), card,
@@ -657,7 +655,7 @@ int snd_card_register(struct snd_card *card)
                 if (IS_ERR(card->card_dev))
                         card->card_dev = NULL;
         }
-#endif
+
         if ((err = snd_device_register_all(card)) < 0)
                 return err;
         mutex_lock(&snd_card_mutex);
@@ -674,7 +672,6 @@ int snd_card_register(struct snd_card *card)
         if (snd_mixer_oss_notify_callback)
                 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
 #endif
-#ifndef CONFIG_SYSFS_DEPRECATED
         if (card->card_dev) {
                 err = device_create_file(card->card_dev, &card_id_attrs);
                 if (err < 0)
@@ -683,7 +680,7 @@ int snd_card_register(struct snd_card *card)
                 if (err < 0)
                         return err;
         }
-#endif
+
         return 0;
 }
 
@@ -848,6 +845,7 @@ int snd_card_file_add(struct snd_card *card, struct file *file)
                 return -ENOMEM;
         mfile->file = file;
         mfile->disconnected_f_op = NULL;
+        INIT_LIST_HEAD(&mfile->shutdown_list);
         spin_lock(&card->files_lock);
         if (card->shutdown) {
                 spin_unlock(&card->files_lock);
@@ -883,6 +881,9 @@ int snd_card_file_remove(struct snd_card *card, struct file *file)
         list_for_each_entry(mfile, &card->files_list, list) {
                 if (mfile->file == file) {
                         list_del(&mfile->list);
+                        spin_lock(&shutdown_lock);
+                        list_del(&mfile->shutdown_list);
+                        spin_unlock(&shutdown_lock);
                         if (mfile->disconnected_f_op)
                                 fops_put(mfile->disconnected_f_op);
                         found = mfile;
diff --git a/sound/core/jack.c b/sound/core/jack.c
index 4902ae568730..53b53e97c896 100644
--- a/sound/core/jack.c
+++ b/sound/core/jack.c
@@ -141,6 +141,7 @@ int snd_jack_new(struct snd_card *card, const char *id, int type,
 
 fail_input:
         input_free_device(jack->input_dev);
+        kfree(jack->id);
         kfree(jack);
         return err;
 }
diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c
index 9e92441f9b78..16bd9c03679b 100644
--- a/sound/core/memalloc.c
+++ b/sound/core/memalloc.c
@@ -192,7 +192,8 @@ int snd_dma_alloc_pages(int type, struct device *device, size_t size,
         dmab->bytes = 0;
         switch (type) {
         case SNDRV_DMA_TYPE_CONTINUOUS:
-                dmab->area = snd_malloc_pages(size, (unsigned long)device);
+                dmab->area = snd_malloc_pages(size,
+                                        (__force gfp_t)(unsigned long)device);
                 dmab->addr = 0;
                 break;
 #ifdef CONFIG_HAS_DMA
diff --git a/sound/core/misc.c b/sound/core/misc.c
index 2c41825c836e..eb9fe2e1d291 100644
--- a/sound/core/misc.c
+++ b/sound/core/misc.c
@@ -58,26 +58,6 @@ static const char *sanity_file_name(const char *path)
         else
                 return path;
 }
-
-/* print file and line with a certain printk prefix */
-static int print_snd_pfx(unsigned int level, const char *path, int line,
-                         const char *format)
-{
-        const char *file = sanity_file_name(path);
-        char tmp[] = "<0>";
-        const char *pfx = level ? KERN_DEBUG : KERN_DEFAULT;
-        int ret = 0;
-
-        if (format[0] == '<' && format[2] == '>') {
-                tmp[1] = format[1];
-                pfx = tmp;
-                ret = 1;
-        }
-        printk("%sALSA %s:%d: ", pfx, file, line);
-        return ret;
-}
-#else
-#define print_snd_pfx(level, path, line, format)        0
 #endif
 
 #if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
@@ -85,15 +65,29 @@ void __snd_printk(unsigned int level, const char *path, int line,
                   const char *format, ...)
 {
         va_list args;
-        
+#ifdef CONFIG_SND_VERBOSE_PRINTK
+        struct va_format vaf;
+        char verbose_fmt[] = KERN_DEFAULT "ALSA %s:%d %pV";
+#endif
+
 #ifdef CONFIG_SND_DEBUG 
         if (debug < level)
                 return;
 #endif
+
         va_start(args, format);
-        if (print_snd_pfx(level, path, line, format))
-                format += 3; /* skip the printk level-prefix */
+#ifdef CONFIG_SND_VERBOSE_PRINTK
+        vaf.fmt = format;
+        vaf.va = &args;
+        if (format[0] == '<' && format[2] == '>') {
+                memcpy(verbose_fmt, format, 3);
+                vaf.fmt = format + 3;
+        } else if (level)
+                memcpy(verbose_fmt, KERN_DEBUG, 3);
+        printk(verbose_fmt, sanity_file_name(path), line, &vaf);
+#else
         vprintk(format, args);
+#endif
         va_end(args);
 }
 EXPORT_SYMBOL_GPL(__snd_printk);
diff --git a/sound/core/oss/linear.c b/sound/core/oss/linear.c
index 4c1d16827199..2045697f449d 100644
--- a/sound/core/oss/linear.c
+++ b/sound/core/oss/linear.c
@@ -90,11 +90,8 @@ static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin,
                                struct snd_pcm_plugin_channel *dst_channels,
                                snd_pcm_uframes_t frames)
 {
-        struct linear_priv *data;
-
         if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
                 return -ENXIO;
-        data = (struct linear_priv *)plugin->extra_data;
         if (frames == 0)
                 return 0;
 #ifdef CONFIG_SND_DEBUG
@@ -114,7 +111,8 @@ static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin,
         return frames;
 }
 
-static void init_data(struct linear_priv *data, int src_format, int dst_format)
+static void init_data(struct linear_priv *data,
+                      snd_pcm_format_t src_format, snd_pcm_format_t dst_format)
 {
         int src_le, dst_le, src_bytes, dst_bytes;
 
@@ -140,9 +138,9 @@ static void init_data(struct linear_priv *data, int src_format, int dst_format)
         if (snd_pcm_format_signed(src_format) !=
             snd_pcm_format_signed(dst_format)) {
                 if (dst_le)
-                        data->flip = cpu_to_le32(0x80000000);
+                        data->flip = (__force u32)cpu_to_le32(0x80000000);
                 else
-                        data->flip = cpu_to_be32(0x80000000);
+                        data->flip = (__force u32)cpu_to_be32(0x80000000);
         }
 }
 
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index f50ebf20df96..d8359cfeca15 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -77,7 +77,7 @@ static int snd_mixer_oss_release(struct inode *inode, struct file *file)
         struct snd_mixer_oss_file *fmixer;
 
         if (file->private_data) {
-                fmixer = (struct snd_mixer_oss_file *) file->private_data;
+                fmixer = file->private_data;
                 module_put(fmixer->card->module);
                 snd_card_file_remove(fmixer->card, file);
                 kfree(fmixer);
@@ -190,9 +190,10 @@ static int snd_mixer_oss_get_recsrc(struct snd_mixer_oss_file *fmixer)
                 return -EIO;
         if (mixer->put_recsrc && mixer->get_recsrc) {   /* exclusive */
                 int err;
-                if ((err = mixer->get_recsrc(fmixer, &result)) < 0)
+                unsigned int index;
+                if ((err = mixer->get_recsrc(fmixer, &index)) < 0)
                         return err;
-                result = 1 << result;
+                result = 1 << index;
         } else {
                 struct snd_mixer_oss_slot *pslot;
                 int chn;
@@ -214,6 +215,7 @@ static int snd_mixer_oss_set_recsrc(struct snd_mixer_oss_file *fmixer, int recsr
         struct snd_mixer_oss *mixer = fmixer->mixer;
         struct snd_mixer_oss_slot *pslot;
         int chn, active;
+        unsigned int index;
         int result = 0;
 
         if (mixer == NULL)
@@ -222,8 +224,8 @@ static int snd_mixer_oss_set_recsrc(struct snd_mixer_oss_file *fmixer, int recsr
                 if (recsrc & ~mixer->oss_recsrc)
                         recsrc &= ~mixer->oss_recsrc;
                 mixer->put_recsrc(fmixer, ffz(~recsrc));
-                mixer->get_recsrc(fmixer, &result);
-                result = 1 << result;
+                mixer->get_recsrc(fmixer, &index);
+                result = 1 << index;
         }
         for (chn = 0; chn < 31; chn++) {
                 pslot = &mixer->slots[chn];
@@ -368,7 +370,7 @@ static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int
 
 static long snd_mixer_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        return snd_mixer_oss_ioctl1((struct snd_mixer_oss_file *) file->private_data, cmd, arg);
+        return snd_mixer_oss_ioctl1(file->private_data, cmd, arg);
 }
 
 int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg)
@@ -582,7 +584,7 @@ static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer,
                                      struct snd_mixer_oss_slot *pslot,
                                      int *left, int *right)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         
         *left = *right = 100;
         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
@@ -618,8 +620,10 @@ static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file *fmixer,
         if (numid == ID_UNKNOWN)
                 return;
         down_read(&card->controls_rwsem);
-        if ((kctl = snd_ctl_find_numid(card, numid)) == NULL)
+        if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
+                up_read(&card->controls_rwsem);
                 return;
+        }
         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
         if (uinfo == NULL || uctl == NULL)
@@ -658,7 +662,7 @@ static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file *fmixer,
                 return;
         down_read(&card->controls_rwsem);
         if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) {
-                up_read(&fmixer->card->controls_rwsem);
+                up_read(&card->controls_rwsem);
                 return;
         }
         uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);
@@ -691,7 +695,7 @@ static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer,
                                      struct snd_mixer_oss_slot *pslot,
                                      int left, int right)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         
         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
@@ -740,7 +744,7 @@ static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
                                         struct snd_mixer_oss_slot *pslot,
                                         int *active)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         int left, right;
         
         left = right = 1;
@@ -753,7 +757,7 @@ static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer,
                                            struct snd_mixer_oss_slot *pslot,
                                            int *active)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         int left, right;
         
         left = right = 1;
@@ -766,7 +770,7 @@ static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
                                         struct snd_mixer_oss_slot *pslot,
                                         int active)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         
         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], active, active, 0);
         return 0;
@@ -776,7 +780,7 @@ static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer,
                                            struct snd_mixer_oss_slot *pslot,
                                            int active)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         
         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], active, active, 1);
         return 0;
@@ -797,7 +801,7 @@ static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned
         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
         if (uinfo == NULL || uctl == NULL) {
                 err = -ENOMEM;
-                goto __unlock;
+                goto __free_only;
         }
         down_read(&card->controls_rwsem);
         kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
@@ -813,7 +817,7 @@ static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned
                 if (!(mixer->mask_recsrc & (1 << idx)))
                         continue;
                 pslot = &mixer->slots[idx];
-                slot = (struct slot *)pslot->private_data;
+                slot = pslot->private_data;
                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
                         continue;
                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
@@ -826,6 +830,7 @@ static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned
         err = 0;
       __unlock:
         up_read(&card->controls_rwsem);
+      __free_only:
         kfree(uctl);
         kfree(uinfo);
         return err;
@@ -847,7 +852,7 @@ static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned
         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
         if (uinfo == NULL || uctl == NULL) {
                 err = -ENOMEM;
-                goto __unlock;
+                goto __free_only;
         }
         down_read(&card->controls_rwsem);
         kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0);
@@ -861,7 +866,7 @@ static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned
                 if (!(mixer->mask_recsrc & (1 << idx)))
                         continue;
                 pslot = &mixer->slots[idx];
-                slot = (struct slot *)pslot->private_data;
+                slot = pslot->private_data;
                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
                         continue;
                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
@@ -880,6 +885,7 @@ static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned
         err = 0;
       __unlock:
         up_read(&card->controls_rwsem);
+      __free_only:
         kfree(uctl);
         kfree(uinfo);
         return err;
@@ -925,7 +931,7 @@ static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *sl
 
 static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn)
 {
-        struct slot *p = (struct slot *)chn->private_data;
+        struct slot *p = chn->private_data;
         if (p) {
                 if (p->allocated && p->assigned) {
                         kfree(p->assigned->name);
diff --git a/sound/core/oss/mulaw.c b/sound/core/oss/mulaw.c
index f7649d4d950b..7915564bd394 100644
--- a/sound/core/oss/mulaw.c
+++ b/sound/core/oss/mulaw.c
@@ -274,7 +274,7 @@ static snd_pcm_sframes_t mulaw_transfer(struct snd_pcm_plugin *plugin,
         return frames;
 }
 
-static void init_data(struct mulaw_priv *data, int format)
+static void init_data(struct mulaw_priv *data, snd_pcm_format_t format)
 {
 #ifdef SNDRV_LITTLE_ENDIAN
         data->cvt_endian = snd_pcm_format_big_endian(format) > 0;
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index 5c8c7dff8ede..23c34a02894b 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -41,6 +41,7 @@
 #include <sound/info.h>
 #include <linux/soundcard.h>
 #include <sound/initval.h>
+#include <sound/mixer_oss.h>
 
 #define OSS_ALSAEMULVER         _SIOR ('M', 249, int)
 
@@ -60,7 +61,6 @@ MODULE_PARM_DESC(nonblock_open, "Don't block opening busy PCM devices.");
 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM);
 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1);
 
-extern int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg);
 static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file);
 static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file);
 static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file);
@@ -453,8 +453,10 @@ static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
         } else {
                 *params = *save;
                 max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
-                if (max < 0)
+                if (max < 0) {
+                        kfree(save);
                         return max;
+                }
                 last = 1;
         }
  _end:
@@ -654,7 +656,7 @@ snd_pcm_uframes_t get_hw_ptr_period(struct snd_pcm_runtime *runtime)
 #define AFMT_AC3         0x00000400
 #define AFMT_VORBIS      0x00000800
 
-static int snd_pcm_oss_format_from(int format)
+static snd_pcm_format_t snd_pcm_oss_format_from(int format)
 {
         switch (format) {
         case AFMT_MU_LAW:       return SNDRV_PCM_FORMAT_MU_LAW;
@@ -678,7 +680,7 @@ static int snd_pcm_oss_format_from(int format)
         }
 }
 
-static int snd_pcm_oss_format_to(int format)
+static int snd_pcm_oss_format_to(snd_pcm_format_t format)
 {
         switch (format) {
         case SNDRV_PCM_FORMAT_MU_LAW:   return AFMT_MU_LAW;
@@ -841,7 +843,8 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         size_t oss_frame_size;
         int err;
         int direct;
-        int format, sformat, n;
+        snd_pcm_format_t format, sformat;
+        int n;
         struct snd_mask sformat_mask;
         struct snd_mask mask;
 
@@ -866,11 +869,11 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         _snd_pcm_hw_param_min(sparams, SNDRV_PCM_HW_PARAM_PERIODS, 2, 0);
         snd_mask_none(&mask);
         if (atomic_read(&substream->mmap_count))
-                snd_mask_set(&mask, SNDRV_PCM_ACCESS_MMAP_INTERLEAVED);
+                snd_mask_set(&mask, (__force int)SNDRV_PCM_ACCESS_MMAP_INTERLEAVED);
         else {
-                snd_mask_set(&mask, SNDRV_PCM_ACCESS_RW_INTERLEAVED);
+                snd_mask_set(&mask, (__force int)SNDRV_PCM_ACCESS_RW_INTERLEAVED);
                 if (!direct)
-                        snd_mask_set(&mask, SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
+                        snd_mask_set(&mask, (__force int)SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
         }
         err = snd_pcm_hw_param_mask(substream, sparams, SNDRV_PCM_HW_PARAM_ACCESS, &mask);
         if (err < 0) {
@@ -889,19 +892,22 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         else
                 sformat = snd_pcm_plug_slave_format(format, &sformat_mask);
 
-        if (sformat < 0 || !snd_mask_test(&sformat_mask, sformat)) {
-                for (sformat = 0; sformat <= SNDRV_PCM_FORMAT_LAST; sformat++) {
-                        if (snd_mask_test(&sformat_mask, sformat) &&
+        if ((__force int)sformat < 0 ||
+            !snd_mask_test(&sformat_mask, (__force int)sformat)) {
+                for (sformat = (__force snd_pcm_format_t)0;
+                     (__force int)sformat <= (__force int)SNDRV_PCM_FORMAT_LAST;
+                     sformat = (__force snd_pcm_format_t)((__force int)sformat + 1)) {
+                        if (snd_mask_test(&sformat_mask, (__force int)sformat) &&
                             snd_pcm_oss_format_to(sformat) >= 0)
                                 break;
                 }
-                if (sformat > SNDRV_PCM_FORMAT_LAST) {
+                if ((__force int)sformat > (__force int)SNDRV_PCM_FORMAT_LAST) {
                         snd_printd("Cannot find a format!!!\n");
                         err = -EINVAL;
                         goto failure;
                 }
         }
-        err = _snd_pcm_hw_param_set(sparams, SNDRV_PCM_HW_PARAM_FORMAT, sformat, 0);
+        err = _snd_pcm_hw_param_set(sparams, SNDRV_PCM_HW_PARAM_FORMAT, (__force int)sformat, 0);
         if (err < 0)
                 goto failure;
 
@@ -910,9 +916,9 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         } else {
                 _snd_pcm_hw_params_any(params);
                 _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_ACCESS,
-                                      SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
+                                      (__force int)SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
                 _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT,
-                                      snd_pcm_oss_format_from(runtime->oss.format), 0);
+                                      (__force int)snd_pcm_oss_format_from(runtime->oss.format), 0);
                 _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS,
                                       runtime->oss.channels, 0);
                 _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE,
@@ -1183,10 +1189,10 @@ snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const
                 if (in_kernel) {
                         mm_segment_t fs;
                         fs = snd_enter_user();
-                        ret = snd_pcm_lib_write(substream, (void __user *)ptr, frames);
+                        ret = snd_pcm_lib_write(substream, (void __force __user *)ptr, frames);
                         snd_leave_user(fs);
                 } else {
-                        ret = snd_pcm_lib_write(substream, (void __user *)ptr, frames);
+                        ret = snd_pcm_lib_write(substream, (void __force __user *)ptr, frames);
                 }
                 if (ret != -EPIPE && ret != -ESTRPIPE)
                         break;
@@ -1228,10 +1234,10 @@ snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *p
                 if (in_kernel) {
                         mm_segment_t fs;
                         fs = snd_enter_user();
-                        ret = snd_pcm_lib_read(substream, (void __user *)ptr, frames);
+                        ret = snd_pcm_lib_read(substream, (void __force __user *)ptr, frames);
                         snd_leave_user(fs);
                 } else {
-                        ret = snd_pcm_lib_read(substream, (void __user *)ptr, frames);
+                        ret = snd_pcm_lib_read(substream, (void __force __user *)ptr, frames);
                 }
                 if (ret == -EPIPE) {
                         if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
@@ -1331,7 +1337,7 @@ static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const cha
                 struct snd_pcm_plugin_channel *channels;
                 size_t oss_frame_bytes = (runtime->oss.plugin_first->src_width * runtime->oss.plugin_first->src_format.channels) / 8;
                 if (!in_kernel) {
-                        if (copy_from_user(runtime->oss.buffer, (const char __user *)buf, bytes))
+                        if (copy_from_user(runtime->oss.buffer, (const char __force __user *)buf, bytes))
                                 return -EFAULT;
                         buf = runtime->oss.buffer;
                 }
@@ -1427,7 +1433,7 @@ static ssize_t snd_pcm_oss_read2(struct snd_pcm_substream *substream, char *buf,
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_sframes_t frames, frames1;
 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
-        char __user *final_dst = (char __user *)buf;
+        char __user *final_dst = (char __force __user *)buf;
         if (runtime->oss.plugin_first) {
                 struct snd_pcm_plugin_channel *channels;
                 size_t oss_frame_bytes = (runtime->oss.plugin_last->dst_width * runtime->oss.plugin_last->dst_format.channels) / 8;
@@ -1510,16 +1516,19 @@ static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __use
 static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file)
 {
         struct snd_pcm_substream *substream;
+        struct snd_pcm_runtime *runtime;
+        int i;
 
-        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
-        if (substream != NULL) {
-                snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
-                substream->runtime->oss.prepare = 1;
-        }
-        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
-        if (substream != NULL) {
+        for (i = 0; i < 2; i++) { 
+                substream = pcm_oss_file->streams[i];
+                if (!substream)
+                        continue;
+                runtime = substream->runtime;
                 snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
-                substream->runtime->oss.prepare = 1;
+                runtime->oss.prepare = 1;
+                runtime->oss.buffer_used = 0;
+                runtime->oss.prev_hw_ptr_period = 0;
+                runtime->oss.period_ptr = 0;
         }
         return 0;
 }
@@ -1544,6 +1553,7 @@ static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size)
 {
         struct snd_pcm_runtime *runtime;
         ssize_t result = 0;
+        snd_pcm_state_t state;
         long res;
         wait_queue_t wait;
 
@@ -1565,9 +1575,9 @@ static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size)
                 result = 0;
                 set_current_state(TASK_INTERRUPTIBLE);
                 snd_pcm_stream_lock_irq(substream);
-                res = runtime->status->state;
+                state = runtime->status->state;
                 snd_pcm_stream_unlock_irq(substream);
-                if (res != SNDRV_PCM_STATE_RUNNING) {
+                if (state != SNDRV_PCM_STATE_RUNNING) {
                         set_current_state(TASK_RUNNING);
                         break;
                 }
@@ -1653,7 +1663,7 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                                                                    size1);
                                         size1 /= runtime->channels; /* frames */
                                         fs = snd_enter_user();
-                                        snd_pcm_lib_write(substream, (void __user *)runtime->oss.buffer, size1);
+                                        snd_pcm_lib_write(substream, (void __force __user *)runtime->oss.buffer, size1);
                                         snd_leave_user(fs);
                                 }
                         } else if (runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) {
diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c
index 6751daa3bb50..71cc3ddf5c15 100644
--- a/sound/core/oss/pcm_plugin.c
+++ b/sound/core/oss/pcm_plugin.c
@@ -264,7 +264,7 @@ snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *plug, snd_pc
         return frames;
 }
 
-static int snd_pcm_plug_formats(struct snd_mask *mask, int format)
+static int snd_pcm_plug_formats(struct snd_mask *mask, snd_pcm_format_t format)
 {
         struct snd_mask formats = *mask;
         u64 linfmts = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 |
@@ -276,16 +276,16 @@ static int snd_pcm_plug_formats(struct snd_mask *mask, int format)
                        SNDRV_PCM_FMTBIT_U24_3BE | SNDRV_PCM_FMTBIT_S24_3BE |
                        SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_S32_LE |
                        SNDRV_PCM_FMTBIT_U32_BE | SNDRV_PCM_FMTBIT_S32_BE);
-        snd_mask_set(&formats, SNDRV_PCM_FORMAT_MU_LAW);
+        snd_mask_set(&formats, (__force int)SNDRV_PCM_FORMAT_MU_LAW);
         
         if (formats.bits[0] & (u32)linfmts)
                 formats.bits[0] |= (u32)linfmts;
         if (formats.bits[1] & (u32)(linfmts >> 32))
                 formats.bits[1] |= (u32)(linfmts >> 32);
-        return snd_mask_test(&formats, format);
+        return snd_mask_test(&formats, (__force int)format);
 }
 
-static int preferred_formats[] = {
+static snd_pcm_format_t preferred_formats[] = {
         SNDRV_PCM_FORMAT_S16_LE,
         SNDRV_PCM_FORMAT_S16_BE,
         SNDRV_PCM_FORMAT_U16_LE,
@@ -306,24 +306,25 @@ static int preferred_formats[] = {
         SNDRV_PCM_FORMAT_U8
 };
 
-int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask)
+snd_pcm_format_t snd_pcm_plug_slave_format(snd_pcm_format_t format,
+                                           struct snd_mask *format_mask)
 {
         int i;
 
-        if (snd_mask_test(format_mask, format))
+        if (snd_mask_test(format_mask, (__force int)format))
                 return format;
-        if (! snd_pcm_plug_formats(format_mask, format))
-                return -EINVAL;
+        if (!snd_pcm_plug_formats(format_mask, format))
+                return (__force snd_pcm_format_t)-EINVAL;
         if (snd_pcm_format_linear(format)) {
                 unsigned int width = snd_pcm_format_width(format);
                 int unsignd = snd_pcm_format_unsigned(format) > 0;
                 int big = snd_pcm_format_big_endian(format) > 0;
                 unsigned int badness, best = -1;
-                int best_format = -1;
+                snd_pcm_format_t best_format = (__force snd_pcm_format_t)-1;
                 for (i = 0; i < ARRAY_SIZE(preferred_formats); i++) {
-                        int f = preferred_formats[i];
+                        snd_pcm_format_t f = preferred_formats[i];
                         unsigned int w;
-                        if (!snd_mask_test(format_mask, f))
+                        if (!snd_mask_test(format_mask, (__force int)f))
                                 continue;
                         w = snd_pcm_format_width(f);
                         if (w >= width)
@@ -337,17 +338,20 @@ int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask)
                                 best = badness;
                         }
                 }
-                return best_format >= 0 ? best_format : -EINVAL;
+                if ((__force int)best_format >= 0)
+                        return best_format;
+                else
+                        return (__force snd_pcm_format_t)-EINVAL;
         } else {
                 switch (format) {
                 case SNDRV_PCM_FORMAT_MU_LAW:
                         for (i = 0; i < ARRAY_SIZE(preferred_formats); ++i) {
-                                int format1 = preferred_formats[i];
-                                if (snd_mask_test(format_mask, format1))
+                                snd_pcm_format_t format1 = preferred_formats[i];
+                                if (snd_mask_test(format_mask, (__force int)format1))
                                         return format1;
                         }
                 default:
-                        return -EINVAL;
+                        return (__force snd_pcm_format_t)-EINVAL;
                 }
         }
 }
@@ -359,7 +363,7 @@ int snd_pcm_plug_format_plugins(struct snd_pcm_substream *plug,
         struct snd_pcm_plugin_format tmpformat;
         struct snd_pcm_plugin_format dstformat;
         struct snd_pcm_plugin_format srcformat;
-        int src_access, dst_access;
+        snd_pcm_access_t src_access, dst_access;
         struct snd_pcm_plugin *plugin = NULL;
         int err;
         int stream = snd_pcm_plug_stream(plug);
@@ -641,7 +645,7 @@ snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *plug, str
 }
 
 int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_area, size_t dst_offset,
-                         size_t samples, int format)
+                         size_t samples, snd_pcm_format_t format)
 {
         /* FIXME: sub byte resolution and odd dst_offset */
         unsigned char *dst;
@@ -688,7 +692,7 @@ int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_area, size_t dst
 
 int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_area, size_t src_offset,
                       const struct snd_pcm_channel_area *dst_area, size_t dst_offset,
-                      size_t samples, int format)
+                      size_t samples, snd_pcm_format_t format)
 {
         /* FIXME: sub byte resolution and odd dst_offset */
         char *src, *dst;
diff --git a/sound/core/oss/pcm_plugin.h b/sound/core/oss/pcm_plugin.h
index b9afab603711..a5035c2369a6 100644
--- a/sound/core/oss/pcm_plugin.h
+++ b/sound/core/oss/pcm_plugin.h
@@ -46,7 +46,7 @@ struct snd_pcm_plugin_channel {
 };
 
 struct snd_pcm_plugin_format {
-        int format;
+        snd_pcm_format_t format;
         unsigned int rate;
         unsigned int channels;
 };
@@ -58,7 +58,7 @@ struct snd_pcm_plugin {
         struct snd_pcm_plugin_format dst_format;        /* destination format */
         int src_width;                  /* sample width in bits */
         int dst_width;                  /* sample width in bits */
-        int access;
+        snd_pcm_access_t access;
         snd_pcm_sframes_t (*src_frames)(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t dst_frames);
         snd_pcm_sframes_t (*dst_frames)(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t src_frames);
         snd_pcm_sframes_t (*client_channels)(struct snd_pcm_plugin *plugin,
@@ -125,7 +125,8 @@ int snd_pcm_plug_format_plugins(struct snd_pcm_substream *substream,
                                 struct snd_pcm_hw_params *params,
                                 struct snd_pcm_hw_params *slave_params);
 
-int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask);
+snd_pcm_format_t snd_pcm_plug_slave_format(snd_pcm_format_t format,
+                                           struct snd_mask *format_mask);
 
 int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin);
 
@@ -146,12 +147,12 @@ snd_pcm_sframes_t snd_pcm_plugin_client_channels(struct snd_pcm_plugin *plugin,
 
 int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_channel,
                          size_t dst_offset,
-                         size_t samples, int format);
+                         size_t samples, snd_pcm_format_t format);
 int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_channel,
                       size_t src_offset,
                       const struct snd_pcm_channel_area *dst_channel,
                       size_t dst_offset,
-                      size_t samples, int format);
+                      size_t samples, snd_pcm_format_t format);
 
 void *snd_pcm_plug_buf_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t size);
 void snd_pcm_plug_buf_unlock(struct snd_pcm_substream *plug, void *ptr);
diff --git a/sound/core/oss/route.c b/sound/core/oss/route.c
index bbe25d8c450a..c8171f5783c8 100644
--- a/sound/core/oss/route.c
+++ b/sound/core/oss/route.c
@@ -25,7 +25,7 @@
 #include "pcm_plugin.h"
 
 static void zero_areas(struct snd_pcm_plugin_channel *dvp, int ndsts,
-                       snd_pcm_uframes_t frames, int format)
+                       snd_pcm_uframes_t frames, snd_pcm_format_t format)
 {
         int dst = 0;
         for (; dst < ndsts; ++dst) {
@@ -38,7 +38,7 @@ static void zero_areas(struct snd_pcm_plugin_channel *dvp, int ndsts,
 
 static inline void copy_area(const struct snd_pcm_plugin_channel *src_channel,
                              struct snd_pcm_plugin_channel *dst_channel,
-                             snd_pcm_uframes_t frames, int format)
+                             snd_pcm_uframes_t frames, snd_pcm_format_t format)
 {
         dst_channel->enabled = 1;
         snd_pcm_area_copy(&src_channel->area, 0, &dst_channel->area, 0, frames, format);
@@ -51,7 +51,7 @@ static snd_pcm_sframes_t route_transfer(struct snd_pcm_plugin *plugin,
 {
         int nsrcs, ndsts, dst;
         struct snd_pcm_plugin_channel *dvp;
-        int format;
+        snd_pcm_format_t format;
 
         if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
                 return -ENXIO;
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index ac242a377aea..ee9abb2d9001 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -211,9 +211,9 @@ static char *snd_pcm_format_names[] = {
 
 const char *snd_pcm_format_name(snd_pcm_format_t format)
 {
-        if (format >= ARRAY_SIZE(snd_pcm_format_names))
+        if ((__force unsigned int)format >= ARRAY_SIZE(snd_pcm_format_names))
                 return "Unknown";
-        return snd_pcm_format_names[format];
+        return snd_pcm_format_names[(__force unsigned int)format];
 }
 EXPORT_SYMBOL_GPL(snd_pcm_format_name);
 
@@ -269,12 +269,12 @@ static const char *snd_pcm_stream_name(int stream)
 
 static const char *snd_pcm_access_name(snd_pcm_access_t access)
 {
-        return snd_pcm_access_names[access];
+        return snd_pcm_access_names[(__force int)access];
 }
 
 static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
 {
-        return snd_pcm_subformat_names[subformat];
+        return snd_pcm_subformat_names[(__force int)subformat];
 }
 
 static const char *snd_pcm_tstamp_mode_name(int mode)
@@ -284,7 +284,7 @@ static const char *snd_pcm_tstamp_mode_name(int mode)
 
 static const char *snd_pcm_state_name(snd_pcm_state_t state)
 {
-        return snd_pcm_state_names[state];
+        return snd_pcm_state_names[(__force int)state];
 }
 
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
@@ -364,8 +364,7 @@ static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
 static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
                                              struct snd_info_buffer *buffer)
 {
-        snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data,
-                               buffer);
+        snd_pcm_proc_info_read(entry->private_data, buffer);
 }
 
 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index e23e0e7ab26f..f1341308beda 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -189,6 +189,7 @@ static void xrun(struct snd_pcm_substream *substream)
 #define XRUN_LOG_CNT    10
 
 struct hwptr_log_entry {
+        unsigned int in_interrupt;
         unsigned long jiffies;
         snd_pcm_uframes_t pos;
         snd_pcm_uframes_t period_size;
@@ -204,7 +205,7 @@ struct snd_pcm_hwptr_log {
 };
 
 static void xrun_log(struct snd_pcm_substream *substream,
-                     snd_pcm_uframes_t pos)
+                     snd_pcm_uframes_t pos, int in_interrupt)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_pcm_hwptr_log *log = runtime->hwptr_log;
@@ -220,10 +221,11 @@ static void xrun_log(struct snd_pcm_substream *substream,
                         return;
         }
         entry = &log->entries[log->idx];
+        entry->in_interrupt = in_interrupt;
         entry->jiffies = jiffies;
         entry->pos = pos;
         entry->period_size = runtime->period_size;
-        entry->buffer_size = runtime->buffer_size;;
+        entry->buffer_size = runtime->buffer_size;
         entry->old_hw_ptr = runtime->status->hw_ptr;
         entry->hw_ptr_base = runtime->hw_ptr_base;
         log->idx = (log->idx + 1) % XRUN_LOG_CNT;
@@ -246,9 +248,11 @@ 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: j=%lu, pos=%ld/%ld/%ld, "
+                snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "
                            "hwptr=%ld/%ld\n",
-                           name, entry->jiffies, (unsigned long)entry->pos,
+                           name, entry->in_interrupt ? "[Q] " : "",
+                           entry->jiffies,
+                           (unsigned long)entry->pos,
                            (unsigned long)entry->period_size,
                            (unsigned long)entry->buffer_size,
                            (unsigned long)entry->old_hw_ptr,
@@ -262,7 +266,7 @@ static void xrun_log_show(struct snd_pcm_substream *substream)
 #else /* ! CONFIG_SND_PCM_XRUN_DEBUG */
 
 #define hw_ptr_error(substream, fmt, args...) do { } while (0)
-#define xrun_log(substream, pos)        do { } while (0)
+#define xrun_log(substream, pos, in_interrupt)  do { } while (0)
 #define xrun_log_show(substream)        do { } while (0)
 
 #endif
@@ -326,7 +330,7 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
         }
         pos -= pos % runtime->min_align;
         if (xrun_debug(substream, XRUN_DEBUG_LOG))
-                xrun_log(substream, pos);
+                xrun_log(substream, pos, in_interrupt);
         hw_base = runtime->hw_ptr_base;
         new_hw_ptr = hw_base + pos;
         if (in_interrupt) {
@@ -334,11 +338,15 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
                 /* delta = "expected next hw_ptr" for in_interrupt != 0 */
                 delta = runtime->hw_ptr_interrupt + runtime->period_size;
                 if (delta > new_hw_ptr) {
-                        hw_base += runtime->buffer_size;
-                        if (hw_base >= runtime->boundary)
-                                hw_base = 0;
-                        new_hw_ptr = hw_base + pos;
-                        goto __delta;
+                        /* check for double acknowledged interrupts */
+                        hdelta = jiffies - runtime->hw_ptr_jiffies;
+                        if (hdelta > runtime->hw_ptr_buffer_jiffies/2) {
+                                hw_base += runtime->buffer_size;
+                                if (hw_base >= runtime->boundary)
+                                        hw_base = 0;
+                                new_hw_ptr = hw_base + pos;
+                                goto __delta;
+                        }
                 }
         }
         /* new_hw_ptr might be lower than old_hw_ptr in case when */
@@ -369,6 +377,29 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
                            (unsigned long)new_hw_ptr,
                            (unsigned long)runtime->hw_ptr_base);
         }
+
+        if (runtime->no_period_wakeup) {
+                snd_pcm_sframes_t xrun_threshold;
+                /*
+                 * Without regular period interrupts, we have to check
+                 * the elapsed time to detect xruns.
+                 */
+                jdelta = jiffies - runtime->hw_ptr_jiffies;
+                if (jdelta < runtime->hw_ptr_buffer_jiffies / 2)
+                        goto no_delta_check;
+                hdelta = jdelta - delta * HZ / runtime->rate;
+                xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1;
+                while (hdelta > xrun_threshold) {
+                        delta += runtime->buffer_size;
+                        hw_base += runtime->buffer_size;
+                        if (hw_base >= runtime->boundary)
+                                hw_base = 0;
+                        new_hw_ptr = hw_base + pos;
+                        hdelta -= runtime->hw_ptr_buffer_jiffies;
+                }
+                goto no_delta_check;
+        }
+
         /* something must be really wrong */
         if (delta >= runtime->buffer_size + runtime->period_size) {
                 hw_ptr_error(substream,
@@ -438,6 +469,7 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
                              (long)old_hw_ptr);
         }
 
+ no_delta_check:
         if (runtime->status->hw_ptr == new_hw_ptr)
                 return 0;
 
@@ -1066,8 +1098,10 @@ int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
                 struct snd_pcm_hw_rule *new;
                 unsigned int new_rules = constrs->rules_all + 16;
                 new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
-                if (!new)
+                if (!new) {
+                        va_end(args);
                         return -ENOMEM;
+                }
                 if (constrs->rules) {
                         memcpy(new, constrs->rules,
                                constrs->rules_num * sizeof(*c));
@@ -1083,8 +1117,10 @@ int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
         c->private = private;
         k = 0;
         while (1) {
-                if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps)))
+                if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) {
+                        va_end(args);
                         return -EINVAL;
+                }
                 c->deps[k++] = dep;
                 if (dep < 0)
                         break;
@@ -1093,7 +1129,7 @@ int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
         constrs->rules_num++;
         va_end(args);
         return 0;
-}                                   
+}
 
 EXPORT_SYMBOL(snd_pcm_hw_rule_add);
 
@@ -1720,8 +1756,18 @@ static int wait_for_avail(struct snd_pcm_substream *substream,
         wait_queue_t wait;
         int err = 0;
         snd_pcm_uframes_t avail = 0;
-        long tout;
-
+        long wait_time, tout;
+
+        if (runtime->no_period_wakeup)
+                wait_time = MAX_SCHEDULE_TIMEOUT;
+        else {
+                wait_time = 10;
+                if (runtime->rate) {
+                        long t = runtime->period_size * 2 / runtime->rate;
+                        wait_time = max(t, wait_time);
+                }
+                wait_time = msecs_to_jiffies(wait_time * 1000);
+        }
         init_waitqueue_entry(&wait, current);
         add_wait_queue(&runtime->tsleep, &wait);
         for (;;) {
@@ -1729,9 +1775,8 @@ static int wait_for_avail(struct snd_pcm_substream *substream,
                         err = -ERESTARTSYS;
                         break;
                 }
-                set_current_state(TASK_INTERRUPTIBLE);
                 snd_pcm_stream_unlock_irq(substream);
-                tout = schedule_timeout(msecs_to_jiffies(10000));
+                tout = schedule_timeout_interruptible(wait_time);
                 snd_pcm_stream_lock_irq(substream);
                 switch (runtime->status->state) {
                 case SNDRV_PCM_STATE_SUSPENDED:
diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c
index 917e4055ee30..150cb7edffee 100644
--- a/sound/core/pcm_memory.c
+++ b/sound/core/pcm_memory.c
@@ -253,7 +253,7 @@ static int snd_pcm_lib_preallocate_pages1(struct snd_pcm_substream *substream,
  * snd_pcm_lib_preallocate_pages - pre-allocation for the given DMA type
  * @substream: the pcm substream instance
  * @type: DMA type (SNDRV_DMA_TYPE_*)
- * @data: DMA type dependant data
+ * @data: DMA type dependent data
  * @size: the requested pre-allocation size in bytes
  * @max: the max. allowed pre-allocation size
  *
@@ -278,10 +278,10 @@ int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
 EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages);
 
 /**
- * snd_pcm_lib_preallocate_pages_for_all - pre-allocation for continous memory type (all substreams)
+ * snd_pcm_lib_preallocate_pages_for_all - pre-allocation for continuous memory type (all substreams)
  * @pcm: the pcm instance
  * @type: DMA type (SNDRV_DMA_TYPE_*)
- * @data: DMA type dependant data
+ * @data: DMA type dependent data
  * @size: the requested pre-allocation size in bytes
  * @max: the max. allowed pre-allocation size
  *
diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c
index 434af3c56d52..88f02e3866e0 100644
--- a/sound/core/pcm_misc.c
+++ b/sound/core/pcm_misc.c
@@ -35,7 +35,10 @@ struct pcm_format_data {
         unsigned char silence[8];       /* silence data to fill */
 };
 
-static struct pcm_format_data pcm_formats[SNDRV_PCM_FORMAT_LAST+1] = {
+/* we do lots of calculations on snd_pcm_format_t; shut up sparse */
+#define INT     __force int
+
+static struct pcm_format_data pcm_formats[(INT)SNDRV_PCM_FORMAT_LAST+1] = {
         [SNDRV_PCM_FORMAT_S8] = {
                 .width = 8, .phys = 8, .le = -1, .signd = 1,
                 .silence = {},
@@ -215,9 +218,9 @@ static struct pcm_format_data pcm_formats[SNDRV_PCM_FORMAT_LAST+1] = {
 int snd_pcm_format_signed(snd_pcm_format_t format)
 {
         int val;
-        if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
+        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
                 return -EINVAL;
-        if ((val = pcm_formats[format].signd) < 0)
+        if ((val = pcm_formats[(INT)format].signd) < 0)
                 return -EINVAL;
         return val;
 }
@@ -266,9 +269,9 @@ EXPORT_SYMBOL(snd_pcm_format_linear);
 int snd_pcm_format_little_endian(snd_pcm_format_t format)
 {
         int val;
-        if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
+        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
                 return -EINVAL;
-        if ((val = pcm_formats[format].le) < 0)
+        if ((val = pcm_formats[(INT)format].le) < 0)
                 return -EINVAL;
         return val;
 }
@@ -304,9 +307,9 @@ EXPORT_SYMBOL(snd_pcm_format_big_endian);
 int snd_pcm_format_width(snd_pcm_format_t format)
 {
         int val;
-        if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
+        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
                 return -EINVAL;
-        if ((val = pcm_formats[format].width) == 0)
+        if ((val = pcm_formats[(INT)format].width) == 0)
                 return -EINVAL;
         return val;
 }
@@ -323,9 +326,9 @@ EXPORT_SYMBOL(snd_pcm_format_width);
 int snd_pcm_format_physical_width(snd_pcm_format_t format)
 {
         int val;
-        if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
+        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
                 return -EINVAL;
-        if ((val = pcm_formats[format].phys) == 0)
+        if ((val = pcm_formats[(INT)format].phys) == 0)
                 return -EINVAL;
         return val;
 }
@@ -358,11 +361,11 @@ EXPORT_SYMBOL(snd_pcm_format_size);
  */
 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format)
 {
-        if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
+        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
                 return NULL;
-        if (! pcm_formats[format].phys)
+        if (! pcm_formats[(INT)format].phys)
                 return NULL;
-        return pcm_formats[format].silence;
+        return pcm_formats[(INT)format].silence;
 }
 
 EXPORT_SYMBOL(snd_pcm_format_silence_64);
@@ -382,16 +385,16 @@ int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int
         int width;
         unsigned char *dst, *pat;
 
-        if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
+        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
                 return -EINVAL;
         if (samples == 0)
                 return 0;
-        width = pcm_formats[format].phys; /* physical width */
-        pat = pcm_formats[format].silence;
+        width = pcm_formats[(INT)format].phys; /* physical width */
+        pat = pcm_formats[(INT)format].silence;
         if (! width)
                 return -EINVAL;
         /* signed or 1 byte data */
-        if (pcm_formats[format].signd == 1 || width <= 8) {
+        if (pcm_formats[(INT)format].signd == 1 || width <= 8) {
                 unsigned int bytes = samples * width / 8;
                 memset(data, *pat, bytes);
                 return 0;
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index d4eb2ef80784..1c6be91dfb98 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -22,7 +22,6 @@
 #include <linux/mm.h>
 #include <linux/file.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/time.h>
 #include <linux/pm_qos_params.h>
 #include <linux/uio.h>
@@ -142,7 +141,7 @@ int snd_pcm_info_user(struct snd_pcm_substream *substream,
 
 #ifdef RULES_DEBUG
 #define HW_PARAM(v) [SNDRV_PCM_HW_PARAM_##v] = #v
-char *snd_pcm_hw_param_names[] = {
+static const char * const snd_pcm_hw_param_names[] = {
         HW_PARAM(ACCESS),
         HW_PARAM(FORMAT),
         HW_PARAM(SUBFORMAT),
@@ -423,6 +422,9 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
         runtime->info = params->info;
         runtime->rate_num = params->rate_num;
         runtime->rate_den = params->rate_den;
+        runtime->no_period_wakeup =
+                        (params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) &&
+                        (params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP);
 
         bits = snd_pcm_format_physical_width(runtime->format);
         runtime->sample_bits = bits;
@@ -458,7 +460,7 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
                                    PM_QOS_CPU_DMA_LATENCY, usecs);
         return 0;
  _error:
-        /* hardware might be unuseable from this time,
+        /* hardware might be unusable from this time,
            so we force application to retry to set
            the correct hardware parameter settings */
         runtime->status->state = SNDRV_PCM_STATE_OPEN;
@@ -864,6 +866,8 @@ static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state)
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_trigger_tstamp(substream);
         runtime->hw_ptr_jiffies = jiffies;
+        runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / 
+                                                            runtime->rate;
         runtime->status->state = state;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
@@ -937,7 +941,7 @@ static struct action_ops snd_pcm_action_stop = {
  *
  * The state of each stream is then changed to the given state unconditionally.
  */
-int snd_pcm_stop(struct snd_pcm_substream *substream, int state)
+int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t state)
 {
         return snd_pcm_action(&snd_pcm_action_stop, substream, state);
 }
@@ -983,7 +987,7 @@ static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push)
         if (push)
                 snd_pcm_update_hw_ptr(substream);
         /* The jiffies check in snd_pcm_update_hw_ptr*() is done by
-         * a delta betwen the current jiffies, this gives a large enough
+         * a delta between the current jiffies, this gives a large enough
          * delta, effectively to skip the check once.
          */
         substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
@@ -1477,11 +1481,20 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
                         break; /* all drained */
                 init_waitqueue_entry(&wait, current);
                 add_wait_queue(&to_check->sleep, &wait);
-                set_current_state(TASK_INTERRUPTIBLE);
                 snd_pcm_stream_unlock_irq(substream);
                 up_read(&snd_pcm_link_rwsem);
                 snd_power_unlock(card);
-                tout = schedule_timeout(10 * HZ);
+                if (runtime->no_period_wakeup)
+                        tout = MAX_SCHEDULE_TIMEOUT;
+                else {
+                        tout = 10;
+                        if (runtime->rate) {
+                                long t = runtime->period_size * 2 / runtime->rate;
+                                tout = max(t, tout);
+                        }
+                        tout = msecs_to_jiffies(tout * 1000);
+                }
+                tout = schedule_timeout_interruptible(tout);
                 snd_power_lock(card);
                 down_read(&snd_pcm_link_rwsem);
                 snd_pcm_stream_lock_irq(substream);
@@ -1514,13 +1527,11 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
 static int snd_pcm_drop(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime;
-        struct snd_card *card;
         int result = 0;
         
         if (PCM_RUNTIME_CHECK(substream))
                 return -ENXIO;
         runtime = substream->runtime;
-        card = substream->pcm->card;
 
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
             runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED ||
@@ -2052,7 +2063,6 @@ static int snd_pcm_open_file(struct file *file,
 {
         struct snd_pcm_file *pcm_file;
         struct snd_pcm_substream *substream;
-        struct snd_pcm_str *str;
         int err;
 
         if (rpcm_file)
@@ -2069,7 +2079,6 @@ static int snd_pcm_open_file(struct file *file,
         }
         pcm_file->substream = substream;
         if (substream->ref_count == 1) {
-                str = substream->pstr;
                 substream->file = pcm_file;
                 substream->pcm_release = pcm_release_private;
         }
@@ -3011,11 +3020,9 @@ static const struct vm_operations_struct snd_pcm_vm_ops_status =
 static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
                                struct vm_area_struct *area)
 {
-        struct snd_pcm_runtime *runtime;
         long size;
         if (!(area->vm_flags & VM_READ))
                 return -EINVAL;
-        runtime = substream->runtime;
         size = area->vm_end - area->vm_start;
         if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)))
                 return -EINVAL;
@@ -3050,11 +3057,9 @@ static const struct vm_operations_struct snd_pcm_vm_ops_control =
 static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
                                 struct vm_area_struct *area)
 {
-        struct snd_pcm_runtime *runtime;
         long size;
         if (!(area->vm_flags & VM_READ))
                 return -EINVAL;
-        runtime = substream->runtime;
         size = area->vm_end - area->vm_start;
         if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)))
                 return -EINVAL;
@@ -3197,15 +3202,6 @@ int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
 EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
 #endif /* SNDRV_PCM_INFO_MMAP */
 
-/* mmap callback with pgprot_noncached */
-int snd_pcm_lib_mmap_noncached(struct snd_pcm_substream *substream,
-                               struct vm_area_struct *area)
-{
-        area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
-        return snd_pcm_default_mmap(substream, area);
-}
-EXPORT_SYMBOL(snd_pcm_lib_mmap_noncached);
-
 /*
  * mmap DMA buffer
  */
diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c
index f25e3cc7ddfa..a1f1a2f00ccb 100644
--- a/sound/core/seq/oss/seq_oss.c
+++ b/sound/core/seq/oss/seq_oss.c
@@ -220,6 +220,7 @@ static const struct file_operations seq_oss_f_ops =
         .poll =         odev_poll,
         .unlocked_ioctl =       odev_ioctl,
         .compat_ioctl = odev_ioctl_compat,
+        .llseek =       noop_llseek,
 };
 
 static int __init
diff --git a/sound/core/seq/seq.c b/sound/core/seq/seq.c
index bf09a5ad1865..119fddb6fc99 100644
--- a/sound/core/seq/seq.c
+++ b/sound/core/seq/seq.c
@@ -32,6 +32,7 @@
 #include "seq_timer.h"
 #include "seq_system.h"
 #include "seq_info.h"
+#include <sound/minors.h>
 #include <sound/seq_device.h>
 
 #if defined(CONFIG_SND_SEQ_DUMMY_MODULE)
@@ -73,6 +74,9 @@ MODULE_PARM_DESC(seq_default_timer_subdevice, "The default timer subdevice numbe
 module_param(seq_default_timer_resolution, int, 0644);
 MODULE_PARM_DESC(seq_default_timer_resolution, "The default timer resolution in Hz.");
 
+MODULE_ALIAS_CHARDEV(CONFIG_SND_MAJOR, SNDRV_MINOR_SEQUENCER);
+MODULE_ALIAS("devname:snd/seq");
+
 /*
  *  INIT PART
  */
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 99a485f13648..f2436d33fbf7 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -1052,7 +1052,7 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf,
                 } else {
 #ifdef CONFIG_COMPAT
                         if (client->convert32 && snd_seq_ev_is_varusr(&event)) {
-                                void *ptr = compat_ptr(event.data.raw32.d[1]);
+                                void *ptr = (void __force *)compat_ptr(event.data.raw32.d[1]);
                                 event.data.ext.ptr = ptr;
                         }
 #endif
@@ -2407,7 +2407,7 @@ int snd_seq_kernel_client_ctl(int clientid, unsigned int cmd, void *arg)
         if (client == NULL)
                 return -ENXIO;
         fs = snd_enter_user();
-        result = snd_seq_do_ioctl(client, cmd, (void __user *)arg);
+        result = snd_seq_do_ioctl(client, cmd, (void __force __user *)arg);
         snd_leave_user(fs);
         return result;
 }
@@ -2497,9 +2497,6 @@ static void snd_seq_info_dump_ports(struct snd_info_buffer *buffer,
 }
 
 
-void snd_seq_info_pool(struct snd_info_buffer *buffer,
-                       struct snd_seq_pool *pool, char *space);
-
 /* exported to seq_info.c */
 void snd_seq_info_clients_read(struct snd_info_entry *entry, 
                                struct snd_info_buffer *buffer)
diff --git a/sound/core/seq/seq_dummy.c b/sound/core/seq/seq_dummy.c
index f3bdc54b429a..1d7d90ca455e 100644
--- a/sound/core/seq/seq_dummy.c
+++ b/sound/core/seq/seq_dummy.c
@@ -50,7 +50,7 @@
 
         option snd-seq-dummy ports=4
 
-  The modle option "duplex=1" enables duplex operation to the port.
+  The model option "duplex=1" enables duplex operation to the port.
   In duplex mode, a pair of ports are created instead of single port,
   and events are tunneled between pair-ports.  For example, input to
   port A is sent to output port of another port B and vice versa.
diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c
index 7fb55436287f..7f50c1437675 100644
--- a/sound/core/seq/seq_memory.c
+++ b/sound/core/seq/seq_memory.c
@@ -86,7 +86,7 @@ int snd_seq_dump_var_event(const struct snd_seq_event *event,
 
         if (event->data.ext.len & SNDRV_SEQ_EXT_USRPTR) {
                 char buf[32];
-                char __user *curptr = (char __user *)event->data.ext.ptr;
+                char __user *curptr = (char __force __user *)event->data.ext.ptr;
                 while (len > 0) {
                         int size = sizeof(buf);
                         if (len < size)
@@ -157,7 +157,7 @@ int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char
         if (event->data.ext.len & SNDRV_SEQ_EXT_USRPTR) {
                 if (! in_kernel)
                         return -EINVAL;
-                if (copy_from_user(buf, (void __user *)event->data.ext.ptr, len))
+                if (copy_from_user(buf, (void __force __user *)event->data.ext.ptr, len))
                         return -EFAULT;
                 return newlen;
         }
@@ -343,7 +343,7 @@ int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event,
                                 tmp->event = src->event;
                                 src = src->next;
                         } else if (is_usrptr) {
-                                if (copy_from_user(&tmp->event, (char __user *)buf, size)) {
+                                if (copy_from_user(&tmp->event, (char __force __user *)buf, size)) {
                                         err = -EFAULT;
                                         goto __error;
                                 }
diff --git a/sound/core/seq/seq_memory.h b/sound/core/seq/seq_memory.h
index 63e91431a29f..4a2ec779b8a7 100644
--- a/sound/core/seq/seq_memory.h
+++ b/sound/core/seq/seq_memory.h
@@ -24,6 +24,8 @@
 #include <sound/seq_kernel.h>
 #include <linux/poll.h>
 
+struct snd_info_buffer;
+
 /* container for sequencer event (internal use) */
 struct snd_seq_event_cell {
         struct snd_seq_event event;
@@ -99,5 +101,7 @@ void snd_sequencer_memory_done(void);
 /* polling */
 int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file, poll_table *wait);
 
+void snd_seq_info_pool(struct snd_info_buffer *buffer,
+                       struct snd_seq_pool *pool, char *space);
 
 #endif
diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index 3bf7d73ac52e..e12bcd94b6db 100644
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -412,7 +412,7 @@ int snd_seq_get_port_info(struct snd_seq_client_port * port,
  * initialization or termination of devices (see seq_midi.c).
  *
  * If callback_all option is set, the callback function is invoked
- * at each connnection/disconnection. 
+ * at each connection/disconnection. 
  */
 
 static int subscribe_port(struct snd_seq_client *client,
diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c
index e7a8e9e4edb2..f9077361c119 100644
--- a/sound/core/seq/seq_queue.c
+++ b/sound/core/seq/seq_queue.c
@@ -467,13 +467,11 @@ int snd_seq_queue_timer_open(int queueid)
 int snd_seq_queue_timer_close(int queueid)
 {
         struct snd_seq_queue *queue;
-        struct snd_seq_timer *tmr;
         int result = 0;
 
         queue = queueptr(queueid);
         if (queue == NULL)
                 return -EINVAL;
-        tmr = queue->timer;
         snd_seq_timer_close(queue);
         queuefree(queue);
         return result;
diff --git a/sound/core/sound.c b/sound/core/sound.c
index ac42af42b787..1c7a3efe1778 100644
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -21,7 +21,6 @@
 
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/time.h>
 #include <linux/device.h>
 #include <linux/moduleparam.h>
@@ -184,18 +183,27 @@ static int snd_open(struct inode *inode, struct file *file)
 static const struct file_operations snd_fops =
 {
         .owner =        THIS_MODULE,
-        .open =         snd_open
+        .open =         snd_open,
+        .llseek =       noop_llseek,
 };
 
 #ifdef CONFIG_SND_DYNAMIC_MINORS
-static int snd_find_free_minor(void)
+static int snd_find_free_minor(int type)
 {
         int minor;
 
+        /* static minors for module auto loading */
+        if (type == SNDRV_DEVICE_TYPE_SEQUENCER)
+                return SNDRV_MINOR_SEQUENCER;
+        if (type == SNDRV_DEVICE_TYPE_TIMER)
+                return SNDRV_MINOR_TIMER;
+
         for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
-                /* skip minors still used statically for autoloading devices */
-                if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL ||
-                    minor == SNDRV_MINOR_SEQUENCER)
+                /* skip static minors still used for module auto loading */
+                if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL)
+                        continue;
+                if (minor == SNDRV_MINOR_SEQUENCER ||
+                    minor == SNDRV_MINOR_TIMER)
                         continue;
                 if (!snd_minors[minor])
                         return minor;
@@ -269,7 +277,7 @@ int snd_register_device_for_dev(int type, struct snd_card *card, int dev,
         preg->private_data = private_data;
         mutex_lock(&sound_mutex);
 #ifdef CONFIG_SND_DYNAMIC_MINORS
-        minor = snd_find_free_minor();
+        minor = snd_find_free_minor(type);
 #else
         minor = snd_kernel_minor(type, card, dev);
         if (minor >= 0 && snd_minors[minor])
diff --git a/sound/core/timer.c b/sound/core/timer.c
index 13afb60999b9..7c1cbf0a0dc4 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -34,8 +34,8 @@
 #include <sound/initval.h>
 #include <linux/kmod.h>
 
-#if defined(CONFIG_SND_HPET) || defined(CONFIG_SND_HPET_MODULE)
-#define DEFAULT_TIMER_LIMIT 3
+#if defined(CONFIG_SND_HRTIMER) || defined(CONFIG_SND_HRTIMER_MODULE)
+#define DEFAULT_TIMER_LIMIT 4
 #elif defined(CONFIG_SND_RTCTIMER) || defined(CONFIG_SND_RTCTIMER_MODULE)
 #define DEFAULT_TIMER_LIMIT 2
 #else
@@ -52,6 +52,9 @@ MODULE_PARM_DESC(timer_limit, "Maximum global timers in system.");
 module_param(timer_tstamp_monotonic, int, 0444);
 MODULE_PARM_DESC(timer_tstamp_monotonic, "Use posix monotonic clock source for timestamps (default).");
 
+MODULE_ALIAS_CHARDEV(CONFIG_SND_MAJOR, SNDRV_MINOR_TIMER);
+MODULE_ALIAS("devname:snd/timer");
+
 struct snd_timer_user {
         struct snd_timer_instance *timeri;
         int tread;              /* enhanced read with timestamps and events */
@@ -183,9 +186,8 @@ static void snd_timer_check_slave(struct snd_timer_instance *slave)
                 list_for_each_entry(master, &timer->open_list_head, open_list) {
                         if (slave->slave_class == master->slave_class &&
                             slave->slave_id == master->slave_id) {
-                                list_del(&slave->open_list);
-                                list_add_tail(&slave->open_list,
-                                              &master->slave_list_head);
+                                list_move_tail(&slave->open_list,
+                                               &master->slave_list_head);
                                 spin_lock_irq(&slave_active_lock);
                                 slave->master = master;
                                 slave->timer = master->timer;
@@ -411,8 +413,7 @@ static void snd_timer_notify1(struct snd_timer_instance *ti, int event)
 static int snd_timer_start1(struct snd_timer *timer, struct snd_timer_instance *timeri,
                             unsigned long sticks)
 {
-        list_del(&timeri->active_list);
-        list_add_tail(&timeri->active_list, &timer->active_list_head);
+        list_move_tail(&timeri->active_list, &timer->active_list_head);
         if (timer->running) {
                 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
                         goto __start_now;
diff --git a/sound/core/vmaster.c b/sound/core/vmaster.c
index 3b9b550109cb..a39d3d8c2f9c 100644
--- a/sound/core/vmaster.c
+++ b/sound/core/vmaster.c
@@ -18,7 +18,7 @@
  * a subset of information returned via ctl info callback
  */
 struct link_ctl_info {
-        int type;               /* value type */
+        snd_ctl_elem_type_t type; /* value type */
         int count;              /* item count */
         int min_val, max_val;   /* min, max values */
 };
@@ -233,7 +233,7 @@ static void slave_free(struct snd_kcontrol *kcontrol)
  * Add a slave control to the group with the given master control
  *
  * All slaves must be the same type (returning the same information
- * via info callback).  The fucntion doesn't check it, so it's your
+ * via info callback).  The function doesn't check it, so it's your
  * responsibility.
  *
  * Also, some additional limitations: