4 files changed, 64 insertions, 28 deletions

diff --git a/sound/core/init.c b/sound/core/init.c
index fd56afe846e..d5d40d78c40 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -152,15 +152,8 @@ int snd_card_create(int idx, const char *xid,
         card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
         if (!card)
                 return -ENOMEM;
-        if (xid) {
-                if (!snd_info_check_reserved_words(xid)) {
-                        snd_printk(KERN_ERR
-                                   "given id string '%s' is reserved.\n", xid);
-                        err = -EBUSY;
-                        goto __error;
-                }
+        if (xid)
                 strlcpy(card->id, xid, sizeof(card->id));
-        }
         err = 0;
         mutex_lock(&snd_card_mutex);
         if (idx < 0) {
@@ -483,22 +476,28 @@ int snd_card_free(struct snd_card *card)
 
 EXPORT_SYMBOL(snd_card_free);
 
-static void choose_default_id(struct snd_card *card)
+static void snd_card_set_id_no_lock(struct snd_card *card, const char *nid)
 {
         int i, len, idx_flag = 0, loops = SNDRV_CARDS;
-        char *id, *spos;
+        const char *spos, *src;
+        char *id;
         
-        id = spos = card->shortname;    
-        while (*id != '\0') {
-                if (*id == ' ')
-                        spos = id + 1;
-                id++;
+        if (nid == NULL) {
+                id = card->shortname;
+                spos = src = id;
+                while (*id != '\0') {
+                        if (*id == ' ')
+                                spos = id + 1;
+                        id++;
+                }
+        } else {
+                spos = src = nid;
         }
         id = card->id;
         while (*spos != '\0' && !isalnum(*spos))
                 spos++;
         if (isdigit(*spos))
-                *id++ = isalpha(card->shortname[0]) ? card->shortname[0] : 'D';
+                *id++ = isalpha(src[0]) ? src[0] : 'D';
         while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) {
                 if (isalnum(*spos))
                         *id++ = *spos;
@@ -513,7 +512,7 @@ static void choose_default_id(struct snd_card *card)
 
         while (1) {
                 if (loops-- == 0) {
-                        snd_printk(KERN_ERR "unable to choose default card id (%s)\n", id);
+                        snd_printk(KERN_ERR "unable to set card id (%s)\n", id);
                         strcpy(card->id, card->proc_root->name);
                         return;
                 }
@@ -539,14 +538,33 @@ static void choose_default_id(struct snd_card *card)
                         spos = id + len - 2;
                         if ((size_t)len <= sizeof(card->id) - 2)
                                 spos++;
-                        *spos++ = '_';
-                        *spos++ = '1';
-                        *spos++ = '\0';
+                        *(char *)spos++ = '_';
+                        *(char *)spos++ = '1';
+                        *(char *)spos++ = '\0';
                         idx_flag++;
                 }
         }
 }
 
+/**
+ *  snd_card_set_id - set card identification name
+ *  @card: soundcard structure
+ *  @nid: new identification string
+ *
+ *  This function sets the card identification and checks for name
+ *  collisions.
+ */
+void snd_card_set_id(struct snd_card *card, const char *nid)
+{
+        /* check if user specified own card->id */
+        if (card->id[0] != '\0')
+                return;
+        mutex_lock(&snd_card_mutex);
+        snd_card_set_id_no_lock(card, nid);
+        mutex_unlock(&snd_card_mutex);
+}
+EXPORT_SYMBOL(snd_card_set_id);
+
 #ifndef CONFIG_SYSFS_DEPRECATED
 static ssize_t
 card_id_show_attr(struct device *dev,
@@ -640,8 +658,7 @@ int snd_card_register(struct snd_card *card)
                 mutex_unlock(&snd_card_mutex);
                 return 0;
         }
-        if (card->id[0] == '\0')
-                choose_default_id(card);
+        snd_card_set_id_no_lock(card, card->id[0] == '\0' ? NULL : card->id);
         snd_cards[card->number] = card;
         mutex_unlock(&snd_card_mutex);
         init_info_for_card(card);
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index dda000b9684..dbe406b8259 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -31,6 +31,7 @@
 #include <linux/time.h>
 #include <linux/vmalloc.h>
 #include <linux/moduleparam.h>
+#include <linux/math64.h>
 #include <linux/string.h>
 #include <sound/core.h>
 #include <sound/minors.h>
@@ -617,9 +618,7 @@ static long snd_pcm_oss_bytes(struct snd_pcm_substream *substream, long frames)
 #else
         {
                 u64 bsize = (u64)runtime->oss.buffer_bytes * (u64)bytes;
-                u32 rem;
-                div64_32(&bsize, buffer_size, &rem);
-                return (long)bsize;
+                return div_u64(bsize, buffer_size);
         }
 #endif
 }
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 63d088f2265..a7482874c45 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -22,6 +22,7 @@
 
 #include <linux/slab.h>
 #include <linux/time.h>
+#include <linux/math64.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/info.h>
@@ -249,6 +250,17 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
                         new_hw_ptr = hw_base + pos;
                 }
         }
+
+        /* Do jiffies check only in xrun_debug mode */
+        if (!xrun_debug(substream))
+                goto no_jiffies_check;
+
+        /* Skip the jiffies check for hardwares with BATCH flag.
+         * Such hardware usually just increases the position at each IRQ,
+         * thus it can't give any strange position.
+         */
+        if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
+                goto no_jiffies_check;
         hdelta = new_hw_ptr - old_hw_ptr;
         jdelta = jiffies - runtime->hw_ptr_jiffies;
         if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
@@ -272,6 +284,7 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
                 hw_base -= hw_base % runtime->buffer_size;
                 delta = 0;
         }
+ no_jiffies_check:
         if (delta > runtime->period_size + runtime->period_size / 2) {
                 hw_ptr_error(substream,
                              "Lost interrupts? "
@@ -329,7 +342,9 @@ int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
                         hw_base = 0;
                 new_hw_ptr = hw_base + pos;
         }
-        if (((delta * HZ) / runtime->rate) > jdelta + HZ/100) {
+        /* Do jiffies check only in xrun_debug mode */
+        if (xrun_debug(substream) &&
+            ((delta * HZ) / runtime->rate) > jdelta + HZ/100) {
                 hw_ptr_error(substream,
                              "hw_ptr skipping! "
                              "(pos=%ld, delta=%ld, period=%ld, jdelta=%lu/%lu)\n",
@@ -438,7 +453,7 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b,
                 *r = 0;
                 return UINT_MAX;
         }
-        div64_32(&n, c, r);
+        n = div_u64_rem(n, c, r);
         if (n >= UINT_MAX) {
                 *r = 0;
                 return UINT_MAX;
@@ -1471,7 +1486,6 @@ static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
                 runtime->status->hw_ptr %= runtime->buffer_size;
         else
                 runtime->status->hw_ptr = 0;
-        runtime->hw_ptr_jiffies = jiffies;
         snd_pcm_stream_unlock_irqrestore(substream, flags);
         return 0;
 }
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index cb769d415db..45dc53fcfa2 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -849,6 +849,7 @@ 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->status->state = state;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
@@ -962,6 +963,11 @@ static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push)
 {
         if (substream->runtime->trigger_master != substream)
                 return 0;
+        /* The jiffies check in snd_pcm_update_hw_ptr*() is done by
+         * a delta betwen the current jiffies, this gives a large enough
+         * delta, effectively to skip the check once.
+         */
+        substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
         return substream->ops->trigger(substream,
                                        push ? SNDRV_PCM_TRIGGER_PAUSE_PUSH :
                                               SNDRV_PCM_TRIGGER_PAUSE_RELEASE);