33 files changed, 140 insertions, 210 deletions

diff --git a/sound/arm/aaci.c b/sound/arm/aaci.c
index 1497dce1b04a..c5699863643b 100644
--- a/sound/arm/aaci.c
+++ b/sound/arm/aaci.c
@@ -172,14 +172,15 @@ static unsigned short aaci_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
         return v;
 }
 
-static inline void aaci_chan_wait_ready(struct aaci_runtime *aacirun)
+static inline void
+aaci_chan_wait_ready(struct aaci_runtime *aacirun, unsigned long mask)
 {
         u32 val;
         int timeout = 5000;
 
         do {
                 val = readl(aacirun->base + AACI_SR);
-        } while (val & (SR_TXB|SR_RXB) && timeout--);
+        } while (val & mask && timeout--);
 }
 
 
@@ -208,8 +209,10 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                         writel(0, aacirun->base + AACI_IE);
                         return;
                 }
-                ptr = aacirun->ptr;
 
+                spin_lock(&aacirun->lock);
+
+                ptr = aacirun->ptr;
                 do {
                         unsigned int len = aacirun->fifosz;
                         u32 val;
@@ -217,9 +220,9 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                         if (aacirun->bytes <= 0) {
                                 aacirun->bytes += aacirun->period;
                                 aacirun->ptr = ptr;
-                                spin_unlock(&aaci->lock);
+                                spin_unlock(&aacirun->lock);
                                 snd_pcm_period_elapsed(aacirun->substream);
-                                spin_lock(&aaci->lock);
+                                spin_lock(&aacirun->lock);
                         }
                         if (!(aacirun->cr & CR_EN))
                                 break;
@@ -245,7 +248,10 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                                         ptr = aacirun->start;
                         }
                 } while(1);
+
                 aacirun->ptr = ptr;
+
+                spin_unlock(&aacirun->lock);
         }
 
         if (mask & ISR_URINTR) {
@@ -263,6 +269,8 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                         return;
                 }
 
+                spin_lock(&aacirun->lock);
+
                 ptr = aacirun->ptr;
                 do {
                         unsigned int len = aacirun->fifosz;
@@ -271,9 +279,9 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                         if (aacirun->bytes <= 0) {
                                 aacirun->bytes += aacirun->period;
                                 aacirun->ptr = ptr;
-                                spin_unlock(&aaci->lock);
+                                spin_unlock(&aacirun->lock);
                                 snd_pcm_period_elapsed(aacirun->substream);
-                                spin_lock(&aaci->lock);
+                                spin_lock(&aacirun->lock);
                         }
                         if (!(aacirun->cr & CR_EN))
                                 break;
@@ -301,6 +309,8 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                 } while (1);
 
                 aacirun->ptr = ptr;
+
+                spin_unlock(&aacirun->lock);
         }
 }
 
@@ -310,7 +320,6 @@ static irqreturn_t aaci_irq(int irq, void *devid)
         u32 mask;
         int i;
 
-        spin_lock(&aaci->lock);
         mask = readl(aaci->base + AACI_ALLINTS);
         if (mask) {
                 u32 m = mask;
@@ -320,7 +329,6 @@ static irqreturn_t aaci_irq(int irq, void *devid)
                         }
                 }
         }
-        spin_unlock(&aaci->lock);
 
         return mask ? IRQ_HANDLED : IRQ_NONE;
 }
@@ -330,63 +338,6 @@ static irqreturn_t aaci_irq(int irq, void *devid)
 /*
  * ALSA support.
  */
-
-struct aaci_stream {
-        unsigned char codec_idx;
-        unsigned char rate_idx;
-};
-
-static struct aaci_stream aaci_streams[] = {
-        [ACSTREAM_FRONT] = {
-                .codec_idx      = 0,
-                .rate_idx       = AC97_RATES_FRONT_DAC,
-        },
-        [ACSTREAM_SURROUND] = {
-                .codec_idx      = 0,
-                .rate_idx       = AC97_RATES_SURR_DAC,
-        },
-        [ACSTREAM_LFE] = {
-                .codec_idx      = 0,
-                .rate_idx       = AC97_RATES_LFE_DAC,
-        },
-};
-
-static inline unsigned int aaci_rate_mask(struct aaci *aaci, int streamid)
-{
-        struct aaci_stream *s = aaci_streams + streamid;
-        return aaci->ac97_bus->codec[s->codec_idx]->rates[s->rate_idx];
-}
-
-static unsigned int rate_list[] = {
-        5512, 8000, 11025, 16000, 22050, 32000, 44100,
-        48000, 64000, 88200, 96000, 176400, 192000
-};
-
-/*
- * Double-rate rule: we can support double rate iff channels == 2
- *  (unimplemented)
- */
-static int
-aaci_rule_rate_by_channels(struct snd_pcm_hw_params *p, struct snd_pcm_hw_rule *rule)
-{
-        struct aaci *aaci = rule->private;
-        unsigned int rate_mask = SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_5512;
-        struct snd_interval *c = hw_param_interval(p, SNDRV_PCM_HW_PARAM_CHANNELS);
-
-        switch (c->max) {
-        case 6:
-                rate_mask &= aaci_rate_mask(aaci, ACSTREAM_LFE);
-        case 4:
-                rate_mask &= aaci_rate_mask(aaci, ACSTREAM_SURROUND);
-        case 2:
-                rate_mask &= aaci_rate_mask(aaci, ACSTREAM_FRONT);
-        }
-
-        return snd_interval_list(hw_param_interval(p, rule->var),
-                                 ARRAY_SIZE(rate_list), rate_list,
-                                 rate_mask);
-}
-
 static struct snd_pcm_hardware aaci_hw_info = {
         .info                   = SNDRV_PCM_INFO_MMAP |
                                   SNDRV_PCM_INFO_MMAP_VALID |
@@ -400,10 +351,7 @@ static struct snd_pcm_hardware aaci_hw_info = {
          */
         .formats                = SNDRV_PCM_FMTBIT_S16_LE,
 
-        /* should this be continuous or knot? */
-        .rates                  = SNDRV_PCM_RATE_CONTINUOUS,
-        .rate_max               = 48000,
-        .rate_min               = 4000,
+        /* rates are setup from the AC'97 codec */
         .channels_min           = 2,
         .channels_max           = 6,
         .buffer_bytes_max       = 64 * 1024,
@@ -423,6 +371,12 @@ static int __aaci_pcm_open(struct aaci *aaci,
         aacirun->substream = substream;
         runtime->private_data = aacirun;
         runtime->hw = aaci_hw_info;
+        runtime->hw.rates = aacirun->pcm->rates;
+        snd_pcm_limit_hw_rates(runtime);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
+            aacirun->pcm->r[1].slots)
+                snd_ac97_pcm_double_rate_rules(runtime);
 
         /*
          * FIXME: ALSA specifies fifo_size in bytes.  If we're in normal
@@ -433,17 +387,6 @@ static int __aaci_pcm_open(struct aaci *aaci,
          */
         runtime->hw.fifo_size = aaci->fifosize * 2;
 
-        /*
-         * Add rule describing hardware rate dependency
-         * on the number of channels.
-         */
-        ret = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                                  aaci_rule_rate_by_channels, aaci,
-                                  SNDRV_PCM_HW_PARAM_CHANNELS,
-                                  SNDRV_PCM_HW_PARAM_RATE, -1);
-        if (ret)
-                goto out;
-
         ret = request_irq(aaci->dev->irq[0], aaci_irq, IRQF_SHARED|IRQF_DISABLED,
                           DRIVER_NAME, aaci);
         if (ret)
@@ -507,18 +450,22 @@ static int aaci_pcm_hw_params(struct snd_pcm_substream *substream,
 
         err = snd_pcm_lib_malloc_pages(substream,
                                        params_buffer_bytes(params));
-        if (err < 0)
-                goto out;
+        if (err >= 0) {
+                unsigned int rate = params_rate(params);
+                int dbl = rate > 48000;
 
-        err = snd_ac97_pcm_open(aacirun->pcm, params_rate(params),
-                                params_channels(params),
-                                aacirun->pcm->r[0].slots);
-        if (err)
-                goto out;
+                err = snd_ac97_pcm_open(aacirun->pcm, rate,
+                                        params_channels(params),
+                                        aacirun->pcm->r[dbl].slots);
 
-        aacirun->pcm_open = 1;
+                aacirun->pcm_open = err == 0;
+                aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;
+                aacirun->fifosz = aaci->fifosize * 4;
+
+                if (aacirun->cr & CR_COMPACT)
+                        aacirun->fifosz >>= 1;
+        }
 
- out:
         return err;
 }
 
@@ -527,7 +474,7 @@ static int aaci_pcm_prepare(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct aaci_runtime *aacirun = runtime->private_data;
 
-        aacirun->start  = (void *)runtime->dma_area;
+        aacirun->start  = runtime->dma_area;
         aacirun->end    = aacirun->start + snd_pcm_lib_buffer_bytes(substream);
         aacirun->ptr    = aacirun->start;
         aacirun->period =
@@ -627,14 +574,9 @@ static int aaci_pcm_playback_hw_params(struct snd_pcm_substream *substream,
          * Enable FIFO, compact mode, 16 bits per sample.
          * FIXME: double rate slots?
          */
-        if (ret >= 0) {
-                aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;
+        if (ret >= 0)
                 aacirun->cr |= channels_to_txmask[channels];
 
-                aacirun->fifosz = aaci->fifosize * 4;
-                if (aacirun->cr & CR_COMPACT)
-                        aacirun->fifosz >>= 1;
-        }
         return ret;
 }
 
@@ -646,7 +588,7 @@ static void aaci_pcm_playback_stop(struct aaci_runtime *aacirun)
         ie &= ~(IE_URIE|IE_TXIE);
         writel(ie, aacirun->base + AACI_IE);
         aacirun->cr &= ~CR_EN;
-        aaci_chan_wait_ready(aacirun);
+        aaci_chan_wait_ready(aacirun, SR_TXB);
         writel(aacirun->cr, aacirun->base + AACI_TXCR);
 }
 
@@ -654,7 +596,7 @@ static void aaci_pcm_playback_start(struct aaci_runtime *aacirun)
 {
         u32 ie;
 
-        aaci_chan_wait_ready(aacirun);
+        aaci_chan_wait_ready(aacirun, SR_TXB);
         aacirun->cr |= CR_EN;
 
         ie = readl(aacirun->base + AACI_IE);
@@ -665,12 +607,12 @@ static void aaci_pcm_playback_start(struct aaci_runtime *aacirun)
 
 static int aaci_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
 {
-        struct aaci *aaci = substream->private_data;
         struct aaci_runtime *aacirun = substream->runtime->private_data;
         unsigned long flags;
         int ret = 0;
 
-        spin_lock_irqsave(&aaci->lock, flags);
+        spin_lock_irqsave(&aacirun->lock, flags);
+
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
                 aaci_pcm_playback_start(aacirun);
@@ -697,7 +639,8 @@ static int aaci_pcm_playback_trigger(struct snd_pcm_substream *substream, int cm
         default:
                 ret = -EINVAL;
         }
-        spin_unlock_irqrestore(&aaci->lock, flags);
+
+        spin_unlock_irqrestore(&aacirun->lock, flags);
 
         return ret;
 }
@@ -721,18 +664,10 @@ static int aaci_pcm_capture_hw_params(struct snd_pcm_substream *substream,
         int ret;
 
         ret = aaci_pcm_hw_params(substream, aacirun, params);
-
-        if (ret >= 0) {
-                aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;
-
+        if (ret >= 0)
                 /* Line in record: slot 3 and 4 */
                 aacirun->cr |= CR_SL3 | CR_SL4;
 
-                aacirun->fifosz = aaci->fifosize * 4;
-
-                if (aacirun->cr & CR_COMPACT)
-                        aacirun->fifosz >>= 1;
-        }
         return ret;
 }
 
@@ -740,7 +675,7 @@ static void aaci_pcm_capture_stop(struct aaci_runtime *aacirun)
 {
         u32 ie;
 
-        aaci_chan_wait_ready(aacirun);
+        aaci_chan_wait_ready(aacirun, SR_RXB);
 
         ie = readl(aacirun->base + AACI_IE);
         ie &= ~(IE_ORIE | IE_RXIE);
@@ -755,7 +690,7 @@ static void aaci_pcm_capture_start(struct aaci_runtime *aacirun)
 {
         u32 ie;
 
-        aaci_chan_wait_ready(aacirun);
+        aaci_chan_wait_ready(aacirun, SR_RXB);
 
 #ifdef DEBUG
         /* RX Timeout value: bits 28:17 in RXCR */
@@ -772,12 +707,11 @@ static void aaci_pcm_capture_start(struct aaci_runtime *aacirun)
 
 static int aaci_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
 {
-        struct aaci *aaci = substream->private_data;
         struct aaci_runtime *aacirun = substream->runtime->private_data;
         unsigned long flags;
         int ret = 0;
 
-        spin_lock_irqsave(&aaci->lock, flags);
+        spin_lock_irqsave(&aacirun->lock, flags);
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -806,7 +740,7 @@ static int aaci_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd
                 ret = -EINVAL;
         }
 
-        spin_unlock_irqrestore(&aaci->lock, flags);
+        spin_unlock_irqrestore(&aacirun->lock, flags);
 
         return ret;
 }
@@ -889,6 +823,12 @@ static struct ac97_pcm ac97_defs[] __devinitdata = {
                                           (1 << AC97_SLOT_PCM_SRIGHT) |
                                           (1 << AC97_SLOT_LFE),
                         },
+                        [1] = {
+                                .slots  = (1 << AC97_SLOT_PCM_LEFT) |
+                                          (1 << AC97_SLOT_PCM_RIGHT) |
+                                          (1 << AC97_SLOT_PCM_LEFT_0) |
+                                          (1 << AC97_SLOT_PCM_RIGHT_0),
+                        },
                 },
         },
         [1] = { /* PCM in */
@@ -1001,7 +941,6 @@ static struct aaci * __devinit aaci_init_card(struct amba_device *dev)
 
         aaci = card->private_data;
         mutex_init(&aaci->ac97_sem);
-        spin_lock_init(&aaci->lock);
         aaci->card = card;
         aaci->dev = dev;
 
@@ -1028,7 +967,7 @@ static int __devinit aaci_init_pcm(struct aaci *aaci)
                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &aaci_playback_ops);
                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &aaci_capture_ops);
                 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                                      NULL, 0, 64 * 104);
+                                                      NULL, 0, 64 * 1024);
         }
 
         return ret;
@@ -1088,12 +1027,14 @@ static int __devinit aaci_probe(struct amba_device *dev, struct amba_id *id)
         /*
          * Playback uses AACI channel 0
          */
+        spin_lock_init(&aaci->playback.lock);
         aaci->playback.base = aaci->base + AACI_CSCH1;
         aaci->playback.fifo = aaci->base + AACI_DR1;
 
         /*
          * Capture uses AACI channel 0
          */
+        spin_lock_init(&aaci->capture.lock);
         aaci->capture.base = aaci->base + AACI_CSCH1;
         aaci->capture.fifo = aaci->base + AACI_DR1;
 
diff --git a/sound/arm/aaci.h b/sound/arm/aaci.h
index 924f69c1c44c..6a4a2eebdda1 100644
--- a/sound/arm/aaci.h
+++ b/sound/arm/aaci.h
@@ -202,6 +202,7 @@
 struct aaci_runtime {
         void                    __iomem *base;
         void                    __iomem *fifo;
+        spinlock_t              lock;
 
         struct ac97_pcm         *pcm;
         int                     pcm_open;
@@ -232,7 +233,6 @@ struct aaci {
         struct snd_ac97         *ac97;
 
         u32                     maincr;
-        spinlock_t              lock;
 
         struct aaci_runtime     playback;
         struct aaci_runtime     capture;
diff --git a/sound/arm/pxa2xx-ac97.c b/sound/arm/pxa2xx-ac97.c
index b4b48afb6de6..5d9411839cd7 100644
--- a/sound/arm/pxa2xx-ac97.c
+++ b/sound/arm/pxa2xx-ac97.c
@@ -159,7 +159,7 @@ static int pxa2xx_ac97_resume(struct device *dev)
         return ret;
 }
 
-static struct dev_pm_ops pxa2xx_ac97_pm_ops = {
+static const struct dev_pm_ops pxa2xx_ac97_pm_ops = {
         .suspend        = pxa2xx_ac97_suspend,
         .resume         = pxa2xx_ac97_resume,
 };
diff --git a/sound/core/Kconfig b/sound/core/Kconfig
index c15682a2f9db..475455c76610 100644
--- a/sound/core/Kconfig
+++ b/sound/core/Kconfig
@@ -5,6 +5,7 @@ config SND_TIMER
 config SND_PCM
         tristate
         select SND_TIMER
+        select GCD
 
 config SND_HWDEP
         tristate
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 30f410832a25..a27545b23ee9 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -758,7 +758,7 @@ int snd_interval_ratnum(struct snd_interval *i,
                 int diff;
                 if (q == 0)
                         q = 1;
-                den = div_down(num, q);
+                den = div_up(num, q);
                 if (den < rats[k].den_min)
                         continue;
                 if (den > rats[k].den_max)
@@ -794,7 +794,7 @@ int snd_interval_ratnum(struct snd_interval *i,
                         i->empty = 1;
                         return -EINVAL;
                 }
-                den = div_up(num, q);
+                den = div_down(num, q);
                 if (den > rats[k].den_max)
                         continue;
                 if (den < rats[k].den_min)
diff --git a/sound/core/pcm_timer.c b/sound/core/pcm_timer.c
index ca8068b63d6c..b01d9481d632 100644
--- a/sound/core/pcm_timer.c
+++ b/sound/core/pcm_timer.c
@@ -20,6 +20,7 @@
  */
 
 #include <linux/time.h>
+#include <linux/gcd.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/timer.h>
@@ -28,22 +29,6 @@
  *  Timer functions
  */
 
-/* Greatest common divisor */
-static unsigned long gcd(unsigned long a, unsigned long b)
-{
-        unsigned long r;
-        if (a < b) {
-                r = a;
-                a = b;
-                b = r;
-        }
-        while ((r = a % b) != 0) {
-                a = b;
-                b = r;
-        }
-        return b;
-}
-
 void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream)
 {
         unsigned long rate, mult, fsize, l, post;
diff --git a/sound/isa/gus/gus_mem.c b/sound/isa/gus/gus_mem.c
index 661205c4dcea..af888a022fc0 100644
--- a/sound/isa/gus/gus_mem.c
+++ b/sound/isa/gus/gus_mem.c
@@ -127,7 +127,8 @@ static struct snd_gf1_mem_block *snd_gf1_mem_share(struct snd_gf1_mem * alloc,
             !share_id[2] && !share_id[3])
                 return NULL;
         for (block = alloc->first; block; block = block->next)
-                if (!memcmp(share_id, block->share_id, sizeof(share_id)))
+                if (!memcmp(share_id, block->share_id,
+                                sizeof(block->share_id)))
                         return block;
         return NULL;
 }
diff --git a/sound/isa/msnd/msnd_midi.c b/sound/isa/msnd/msnd_midi.c
index cb9aa4c4edd0..4be562b2cf21 100644
--- a/sound/isa/msnd/msnd_midi.c
+++ b/sound/isa/msnd/msnd_midi.c
@@ -162,7 +162,7 @@ int snd_msndmidi_new(struct snd_card *card, int device)
         err = snd_rawmidi_new(card, "MSND-MIDI", device, 1, 1, &rmidi);
         if (err < 0)
                 return err;
-        mpu = kcalloc(1, sizeof(*mpu), GFP_KERNEL);
+        mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
         if (mpu == NULL) {
                 snd_device_free(card, rmidi);
                 return -ENOMEM;
diff --git a/sound/isa/sb/emu8000.c b/sound/isa/sb/emu8000.c
index 96678d5d3834..751762f1c59a 100644
--- a/sound/isa/sb/emu8000.c
+++ b/sound/isa/sb/emu8000.c
@@ -393,8 +393,6 @@ size_dram(struct snd_emu8000 *emu)
 
         while (size < EMU8000_MAX_DRAM) {
 
-                size += 512 * 1024;  /* increment 512kbytes */
-
                 /* Write a unique data on the test address.
                  * if the address is out of range, the data is written on
                  * 0x200000(=EMU8000_DRAM_OFFSET).  Then the id word is
@@ -414,7 +412,9 @@ size_dram(struct snd_emu8000 *emu)
                 /*snd_emu8000_read_wait(emu);*/
                 EMU8000_SMLD_READ(emu); /* discard stale data  */
                 if (EMU8000_SMLD_READ(emu) != UNIQUE_ID2)
-                        break; /* we must have wrapped around */
+                        break; /* no memory at this address */
+
+                size += 512 * 1024;  /* increment 512kbytes */
 
                 snd_emu8000_read_wait(emu);
 
diff --git a/sound/mips/sgio2audio.c b/sound/mips/sgio2audio.c
index 8691f4cf6191..f1d9d16b5486 100644
--- a/sound/mips/sgio2audio.c
+++ b/sound/mips/sgio2audio.c
@@ -609,7 +609,7 @@ static int snd_sgio2audio_pcm_hw_params(struct snd_pcm_substream *substream,
         /* alloc virtual 'dma' area */
         if (runtime->dma_area)
                 vfree(runtime->dma_area);
-        runtime->dma_area = vmalloc(size);
+        runtime->dma_area = vmalloc_user(size);
         if (runtime->dma_area == NULL)
                 return -ENOMEM;
         runtime->dma_bytes = size;
diff --git a/sound/oss/pss.c b/sound/oss/pss.c
index 83f5ee236b12..e19dd5dcc2de 100644
--- a/sound/oss/pss.c
+++ b/sound/oss/pss.c
@@ -269,7 +269,7 @@ static int pss_reset_dsp(pss_confdata * devc)
         unsigned long   i, limit = jiffies + HZ/10;
 
         outw(0x2000, REG(PSS_CONTROL));
-        for (i = 0; i < 32768 && (limit-jiffies >= 0); i++)
+        for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
                 inw(REG(PSS_CONTROL));
         outw(0x0000, REG(PSS_CONTROL));
         return 1;
@@ -369,11 +369,11 @@ static int pss_download_boot(pss_confdata * devc, unsigned char *block, int size
                 outw(0, REG(PSS_DATA));
 
                 limit = jiffies + HZ/10;
-                for (i = 0; i < 32768 && (limit - jiffies >= 0); i++)
+                for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
                         val = inw(REG(PSS_STATUS));
 
                 limit = jiffies + HZ/10;
-                for (i = 0; i < 32768 && (limit-jiffies >= 0); i++)
+                for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
                 {
                         val = inw(REG(PSS_STATUS));
                         if (val & 0x4000)
diff --git a/sound/pci/cs5535audio/Makefile b/sound/pci/cs5535audio/Makefile
index fda7a94c992f..ccc642269b9e 100644
--- a/sound/pci/cs5535audio/Makefile
+++ b/sound/pci/cs5535audio/Makefile
@@ -4,9 +4,7 @@
 
 snd-cs5535audio-y := cs5535audio.o cs5535audio_pcm.o
 snd-cs5535audio-$(CONFIG_PM) += cs5535audio_pm.o
-ifdef CONFIG_MGEODE_LX
 snd-cs5535audio-$(CONFIG_OLPC) += cs5535audio_olpc.o
-endif
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_CS5535AUDIO) += snd-cs5535audio.o
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index 05f56e04849b..91e7faf69bbb 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -389,6 +389,7 @@ probefail_out:
 
 static void __devexit snd_cs5535audio_remove(struct pci_dev *pci)
 {
+        olpc_quirks_cleanup();
         snd_card_free(pci_get_drvdata(pci));
         pci_set_drvdata(pci, NULL);
 }
diff --git a/sound/pci/cs5535audio/cs5535audio.h b/sound/pci/cs5535audio/cs5535audio.h
index 7a298ac662e3..51966d782a3c 100644
--- a/sound/pci/cs5535audio/cs5535audio.h
+++ b/sound/pci/cs5535audio/cs5535audio.h
@@ -99,10 +99,11 @@ int snd_cs5535audio_suspend(struct pci_dev *pci, pm_message_t state);
 int snd_cs5535audio_resume(struct pci_dev *pci);
 #endif
 
-#if defined(CONFIG_OLPC) && defined(CONFIG_MGEODE_LX)
+#ifdef CONFIG_OLPC
 void __devinit olpc_prequirks(struct snd_card *card,
                 struct snd_ac97_template *ac97);
 int __devinit olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97);
+void __devexit olpc_quirks_cleanup(void);
 void olpc_analog_input(struct snd_ac97 *ac97, int on);
 void olpc_mic_bias(struct snd_ac97 *ac97, int on);
 
@@ -128,6 +129,7 @@ static inline int olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)
 {
         return 0;
 }
+static inline void olpc_quirks_cleanup(void) { }
 static inline void olpc_analog_input(struct snd_ac97 *ac97, int on) { }
 static inline void olpc_mic_bias(struct snd_ac97 *ac97, int on) { }
 static inline void olpc_capture_open(struct snd_ac97 *ac97) { }
diff --git a/sound/pci/cs5535audio/cs5535audio_olpc.c b/sound/pci/cs5535audio/cs5535audio_olpc.c
index 5c6814335cd7..50da49be9ae5 100644
--- a/sound/pci/cs5535audio/cs5535audio_olpc.c
+++ b/sound/pci/cs5535audio/cs5535audio_olpc.c
@@ -13,10 +13,13 @@
 #include <sound/info.h>
 #include <sound/control.h>
 #include <sound/ac97_codec.h>
+#include <linux/gpio.h>
 
 #include <asm/olpc.h>
 #include "cs5535audio.h"
 
+#define DRV_NAME "cs5535audio-olpc"
+
 /*
  * OLPC has an additional feature on top of the regular AD1888 codec features.
  * It has an Analog Input mode that is switched into (after disabling the
@@ -38,10 +41,7 @@ void olpc_analog_input(struct snd_ac97 *ac97, int on)
         }
 
         /* set Analog Input through GPIO */
-        if (on)
-                geode_gpio_set(OLPC_GPIO_MIC_AC, GPIO_OUTPUT_VAL);
-        else
-                geode_gpio_clear(OLPC_GPIO_MIC_AC, GPIO_OUTPUT_VAL);
+        gpio_set_value(OLPC_GPIO_MIC_AC, on);
 }
 
 /*
@@ -73,8 +73,7 @@ static int olpc_dc_info(struct snd_kcontrol *kctl,
 
 static int olpc_dc_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *v)
 {
-        v->value.integer.value[0] = geode_gpio_isset(OLPC_GPIO_MIC_AC,
-                        GPIO_OUTPUT_VAL);
+        v->value.integer.value[0] = gpio_get_value(OLPC_GPIO_MIC_AC);
         return 0;
 }
 
@@ -153,6 +152,12 @@ int __devinit olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)
         if (!machine_is_olpc())
                 return 0;
 
+        if (gpio_request(OLPC_GPIO_MIC_AC, DRV_NAME)) {
+                printk(KERN_ERR DRV_NAME ": unable to allocate MIC GPIO\n");
+                return -EIO;
+        }
+        gpio_direction_output(OLPC_GPIO_MIC_AC, 0);
+
         /* drop the original AD1888 HPF control */
         memset(&elem, 0, sizeof(elem));
         elem.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
@@ -169,11 +174,18 @@ int __devinit olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)
         for (i = 0; i < ARRAY_SIZE(olpc_cs5535audio_ctls); i++) {
                 err = snd_ctl_add(card, snd_ctl_new1(&olpc_cs5535audio_ctls[i],
                                 ac97->private_data));
-                if (err < 0)
+                if (err < 0) {
+                        gpio_free(OLPC_GPIO_MIC_AC);
                         return err;
+                }
         }
 
         /* turn off the mic by default */
         olpc_mic_bias(ac97, 0);
         return 0;
 }
+
+void __devexit olpc_quirks_cleanup(void)
+{
+        gpio_free(OLPC_GPIO_MIC_AC);
+}
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index d24328661c6a..40ccb419b6e9 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -24,6 +24,7 @@
 #include <linux/compat.h>
 #include <linux/mutex.h>
 #include <linux/ctype.h>
+#include <linux/string.h>
 #include <linux/firmware.h>
 #include <sound/core.h>
 #include "hda_codec.h"
@@ -428,8 +429,7 @@ static int parse_hints(struct hda_codec *codec, const char *buf)
         char *key, *val;
         struct hda_hint *hint;
 
-        while (isspace(*buf))
-                buf++;
+        buf = skip_spaces(buf);
         if (!*buf || *buf == '#' || *buf == '\n')
                 return 0;
         if (*buf == '=')
@@ -444,8 +444,7 @@ static int parse_hints(struct hda_codec *codec, const char *buf)
                 return -EINVAL;
         }
         *val++ = 0;
-        while (isspace(*val))
-                val++;
+        val = skip_spaces(val);
         remove_trail_spaces(key);
         remove_trail_spaces(val);
         hint = get_hint(codec, key);
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 0877bae5dae1..c7465053d6bb 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -12924,7 +12924,7 @@ static int patch_alc268(struct hda_codec *codec)
         int board_config;
         int i, has_beep, err;
 
-        spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
                 return -ENOMEM;
 
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.c b/sound/pcmcia/pdaudiocf/pdaudiocf.c
index 7717e01fc071..edaa729126bb 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf.c
@@ -143,7 +143,8 @@ static int snd_pdacf_probe(struct pcmcia_device *link)
         link->io.NumPorts1 = 16;
 
         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_FORCED_PULSE;
-        // link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
+        /* FIXME: This driver should be updated to allow for dynamic IRQ sharing */
+        /* link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_FORCED_PULSE; */
 
         link->irq.Handler = pdacf_interrupt;
         link->conf.Attributes = CONF_ENABLE_IRQ;
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c b/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
index d057e6489643..5cfa608823f7 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
@@ -51,7 +51,7 @@ static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t s
                         return 0; /* already enough large */
                 vfree(runtime->dma_area);
         }
-        runtime->dma_area = vmalloc_32(size);
+        runtime->dma_area = vmalloc_32_user(size);
         if (! runtime->dma_area)
                 return -ENOMEM;
         runtime->dma_bytes = size;
diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c
index b69861d52161..3ef16bbc8c83 100644
--- a/sound/soc/codecs/ak4642.c
+++ b/sound/soc/codecs/ak4642.c
@@ -470,7 +470,7 @@ EXPORT_SYMBOL_GPL(soc_codec_dev_ak4642);
 
 static int __init ak4642_modinit(void)
 {
-        int ret;
+        int ret = 0;
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         ret = i2c_add_driver(&ak4642_i2c_driver);
 #endif
diff --git a/sound/soc/codecs/stac9766.c b/sound/soc/codecs/stac9766.c
index bbc72c2ddfca..81b8c9dfe7fc 100644
--- a/sound/soc/codecs/stac9766.c
+++ b/sound/soc/codecs/stac9766.c
@@ -191,6 +191,7 @@ static int ac97_analog_prepare(struct snd_pcm_substream *substream,
         vra = stac9766_ac97_read(codec, AC97_EXTENDED_STATUS);
 
         vra |= 0x1; /* enable variable rate audio */
+        vra &= ~0x4; /* disable SPDIF output */
 
         stac9766_ac97_write(codec, AC97_EXTENDED_STATUS, vra);
 
@@ -221,22 +222,6 @@ static int ac97_digital_prepare(struct snd_pcm_substream *substream,
         return stac9766_ac97_write(codec, reg, runtime->rate);
 }
 
-static int ac97_digital_trigger(struct snd_pcm_substream *substream,
-                                int cmd, struct snd_soc_dai *dai)
-{
-        struct snd_soc_codec *codec = dai->codec;
-        unsigned short vra;
-
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_STOP:
-                vra = stac9766_ac97_read(codec, AC97_EXTENDED_STATUS);
-                vra &= !0x04;
-                stac9766_ac97_write(codec, AC97_EXTENDED_STATUS, vra);
-                break;
-        }
-        return 0;
-}
-
 static int stac9766_set_bias_level(struct snd_soc_codec *codec,
                                    enum snd_soc_bias_level level)
 {
@@ -315,7 +300,6 @@ static struct snd_soc_dai_ops stac9766_dai_ops_analog = {
 
 static struct snd_soc_dai_ops stac9766_dai_ops_digital = {
         .prepare = ac97_digital_prepare,
-        .trigger = ac97_digital_trigger,
 };
 
 struct snd_soc_dai stac9766_dai[] = {
diff --git a/sound/soc/codecs/twl4030.c b/sound/soc/codecs/twl4030.c
index 5f1681f6ca76..2a27f7b56726 100644
--- a/sound/soc/codecs/twl4030.c
+++ b/sound/soc/codecs/twl4030.c
@@ -26,7 +26,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
-#include <linux/i2c/twl4030.h>
+#include <linux/i2c/twl.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -175,7 +175,7 @@ static int twl4030_write(struct snd_soc_codec *codec,
 {
         twl4030_write_reg_cache(codec, reg, value);
         if (likely(reg < TWL4030_REG_SW_SHADOW))
-                return twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value,
+                return twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value,
                                             reg);
         else
                 return 0;
@@ -261,7 +261,7 @@ static void twl4030_power_up(struct snd_soc_codec *codec)
         do {
                 /* this takes a little while, so don't slam i2c */
                 udelay(2000);
-                twl4030_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &byte,
+                twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &byte,
                                     TWL4030_REG_ANAMICL);
         } while ((i++ < 100) &&
                  ((byte & TWL4030_CNCL_OFFSET_START) ==
@@ -542,7 +542,7 @@ static int pin_name##pga_event(struct snd_soc_dapm_widget *w,		\
                 break;                                                  \
         case SND_SOC_DAPM_POST_PMD:                                     \
                 reg_val = twl4030_read_reg_cache(w->codec, reg);        \
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,        \
+                twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,    \
                                         reg_val & (~mask),              \
                                         reg);                           \
                 break;                                                  \
@@ -679,7 +679,7 @@ static void headset_ramp(struct snd_soc_codec *codec, int ramp)
                 mdelay((ramp_base[(hs_pop & TWL4030_RAMP_DELAY) >> 2] /
                         twl4030->sysclk) + 1);
                 /* Bypass the reg_cache to mute the headset */
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+                twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
                                         hs_gain & (~0x0f),
                                         TWL4030_REG_HS_GAIN_SET);
 
diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c
index f82125d9e85a..ebbf11b653a4 100644
--- a/sound/soc/codecs/wm8350.c
+++ b/sound/soc/codecs/wm8350.c
@@ -1340,9 +1340,10 @@ static int wm8350_resume(struct platform_device *pdev)
         return 0;
 }
 
-static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
+static irqreturn_t wm8350_hp_jack_handler(int irq, void *data)
 {
         struct wm8350_data *priv = data;
+        struct wm8350 *wm8350 = priv->codec.control_data;
         u16 reg;
         int report;
         int mask;
@@ -1365,7 +1366,7 @@ static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
 
         if (!jack->jack) {
                 dev_warn(wm8350->dev, "Jack interrupt called with no jack\n");
-                return;
+                return IRQ_NONE;
         }
 
         /* Debounce */
@@ -1378,6 +1379,8 @@ static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
                 report = 0;
 
         snd_soc_jack_report(jack->jack, report, jack->report);
+
+        return IRQ_HANDLED;
 }
 
 /**
@@ -1421,9 +1424,7 @@ int wm8350_hp_jack_detect(struct snd_soc_codec *codec, enum wm8350_jack which,
         wm8350_set_bits(wm8350, WM8350_JACK_DETECT, ena);
 
         /* Sync status */
-        wm8350_hp_jack_handler(wm8350, irq, priv);
-
-        wm8350_unmask_irq(wm8350, irq);
+        wm8350_hp_jack_handler(irq, priv);
 
         return 0;
 }
@@ -1482,12 +1483,16 @@ static int wm8350_probe(struct platform_device *pdev)
         wm8350_set_bits(wm8350, WM8350_ROUT2_VOLUME,
                         WM8350_OUT2_VU | WM8350_OUT2R_MUTE);
 
-        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L);
-        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
+        /* Make sure jack detect is disabled to start off with */
+        wm8350_clear_bits(wm8350, WM8350_JACK_DETECT,
+                          WM8350_JDL_ENA | WM8350_JDR_ENA);
+
         wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L,
-                            wm8350_hp_jack_handler, priv);
+                            wm8350_hp_jack_handler, 0, "Left jack detect",
+                            priv);
         wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R,
-                            wm8350_hp_jack_handler, priv);
+                            wm8350_hp_jack_handler, 0, "Right jack detect",
+                            priv);
 
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
@@ -1516,8 +1521,6 @@ static int wm8350_remove(struct platform_device *pdev)
                           WM8350_JDL_ENA | WM8350_JDR_ENA);
         wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_4, WM8350_TOCLK_ENA);
 
-        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L);
-        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
         wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L);
         wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
 
diff --git a/sound/soc/codecs/wm8900.c b/sound/soc/codecs/wm8900.c
index c9438dd62df3..dbc368c08263 100644
--- a/sound/soc/codecs/wm8900.c
+++ b/sound/soc/codecs/wm8900.c
@@ -199,7 +199,7 @@ static void wm8900_reset(struct snd_soc_codec *codec)
         snd_soc_write(codec, WM8900_REG_RESET, 0);
 
         memcpy(codec->reg_cache, wm8900_reg_defaults,
-               sizeof(codec->reg_cache));
+               sizeof(wm8900_reg_defaults));
 }
 
 static int wm8900_hp_event(struct snd_soc_dapm_widget *w,
diff --git a/sound/soc/codecs/wm8974.c b/sound/soc/codecs/wm8974.c
index 81c57b5c591c..a808675388fc 100644
--- a/sound/soc/codecs/wm8974.c
+++ b/sound/soc/codecs/wm8974.c
@@ -47,7 +47,7 @@ static const u16 wm8974_reg[WM8974_CACHEREGNUM] = {
 };
 
 #define WM8974_POWER1_BIASEN  0x08
-#define WM8974_POWER1_BUFIOEN 0x10
+#define WM8974_POWER1_BUFIOEN 0x04
 
 struct wm8974_priv {
         struct snd_soc_codec codec;
diff --git a/sound/soc/codecs/wm9712.c b/sound/soc/codecs/wm9712.c
index 0ac1215dcd9b..e237bf615129 100644
--- a/sound/soc/codecs/wm9712.c
+++ b/sound/soc/codecs/wm9712.c
@@ -463,7 +463,8 @@ static int ac97_write(struct snd_soc_codec *codec, unsigned int reg,
 {
         u16 *cache = codec->reg_cache;
 
-        soc_ac97_ops.write(codec->ac97, reg, val);
+        if (reg < 0x7c)
+                soc_ac97_ops.write(codec->ac97, reg, val);
         reg = reg >> 1;
         if (reg < (ARRAY_SIZE(wm9712_reg)))
                 cache[reg] = val;
diff --git a/sound/soc/imx/mx27vis_wm8974.c b/sound/soc/imx/mx27vis_wm8974.c
index 0267d2d91685..07d2a248438c 100644
--- a/sound/soc/imx/mx27vis_wm8974.c
+++ b/sound/soc/imx/mx27vis_wm8974.c
@@ -180,7 +180,8 @@ static int mx27vis_hifi_hw_free(struct snd_pcm_substream *substream)
         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
 
         /* disable the PLL */
-        return codec_dai->ops->set_pll(codec_dai, IGNORED_ARG, 0, 0);
+        return codec_dai->ops->set_pll(codec_dai, IGNORED_ARG, IGNORED_ARG,
+                                       0, 0);
 }
 
 /*
diff --git a/sound/soc/omap/sdp3430.c b/sound/soc/omap/sdp3430.c
index c071f9603a38..3c85c0f92823 100644
--- a/sound/soc/omap/sdp3430.c
+++ b/sound/soc/omap/sdp3430.c
@@ -24,7 +24,7 @@
 
 #include <linux/clk.h>
 #include <linux/platform_device.h>
-#include <linux/i2c/twl4030.h>
+#include <linux/i2c/twl.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/soc.h>
@@ -321,11 +321,11 @@ static int __init sdp3430_soc_init(void)
         *(unsigned int *)sdp3430_dai[1].cpu_dai->private_data = 2; /* McBSP3 */
 
         /* Set TWL4030 GPIO6 as EXTMUTE signal */
-        twl4030_i2c_read_u8(TWL4030_MODULE_INTBR, &pin_mux,
+        twl_i2c_read_u8(TWL4030_MODULE_INTBR, &pin_mux,
                                                 TWL4030_INTBR_PMBR1);
         pin_mux &= ~TWL4030_GPIO6_PWM0_MUTE(0x03);
         pin_mux |= TWL4030_GPIO6_PWM0_MUTE(0x02);
-        twl4030_i2c_write_u8(TWL4030_MODULE_INTBR, pin_mux,
+        twl_i2c_write_u8(TWL4030_MODULE_INTBR, pin_mux,
                                                 TWL4030_INTBR_PMBR1);
 
         ret = platform_device_add(sdp3430_snd_device);
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec.c b/sound/soc/s3c24xx/s3c24xx_simtec.c
index d441c3b64631..4984754f3298 100644
--- a/sound/soc/s3c24xx/s3c24xx_simtec.c
+++ b/sound/soc/s3c24xx/s3c24xx_simtec.c
@@ -312,7 +312,7 @@ int simtec_audio_resume(struct device *dev)
         return 0;
 }
 
-struct dev_pm_ops simtec_audio_pmops = {
+const struct dev_pm_ops simtec_audio_pmops = {
         .resume = simtec_audio_resume,
 };
 EXPORT_SYMBOL_GPL(simtec_audio_pmops);
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec.h b/sound/soc/s3c24xx/s3c24xx_simtec.h
index 2714203af161..e18faee30cce 100644
--- a/sound/soc/s3c24xx/s3c24xx_simtec.h
+++ b/sound/soc/s3c24xx/s3c24xx_simtec.h
@@ -15,7 +15,7 @@ extern int simtec_audio_core_probe(struct platform_device *pdev,
 extern int simtec_audio_remove(struct platform_device *pdev);
 
 #ifdef CONFIG_PM
-extern struct dev_pm_ops simtec_audio_pmops;
+extern const struct dev_pm_ops simtec_audio_pmops;
 #define simtec_audio_pm &simtec_audio_pmops
 #else
 #define simtec_audio_pm NULL
diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index 9c49c11c43ce..42813b808389 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
@@ -876,7 +876,7 @@ static int fsi_probe(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
-        if (!res || !irq) {
+        if (!res || (int)irq <= 0) {
                 dev_err(&pdev->dev, "Not enough FSI platform resources.\n");
                 ret = -ENODEV;
                 goto exit;
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index ef8f28284cb9..0a6440c6f54a 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -1236,7 +1236,7 @@ static int soc_poweroff(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops soc_pm_ops = {
+static const struct dev_pm_ops soc_pm_ops = {
         .suspend = soc_suspend,
         .resume = soc_resume,
         .poweroff = soc_poweroff,
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index b074a594c595..4963defee18a 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -752,7 +752,7 @@ static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t s
                         return 0; /* already large enough */
                 vfree(runtime->dma_area);
         }
-        runtime->dma_area = vmalloc(size);
+        runtime->dma_area = vmalloc_user(size);
         if (!runtime->dma_area)
                 return -ENOMEM;
         runtime->dma_bytes = size;