Merge branch 'topic/misc' into for-linus

19 files changed, 125 insertions, 110 deletions

diff --git a/sound/core/control.c b/sound/core/control.c
index db51e4e64984..a08ad57c49b6 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;
 }
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/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/oss/linear.c b/sound/core/oss/linear.c
index 4c1d16827199..13b3f6f49fae 100644
--- a/sound/core/oss/linear.c
+++ b/sound/core/oss/linear.c
@@ -114,7 +114,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 +141,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 822dd56993ca..d8359cfeca15 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -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];
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 a2e4eb324699..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);
@@ -656,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;
@@ -680,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;
@@ -843,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;
 
@@ -868,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) {
@@ -891,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;
 
@@ -912,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,
@@ -1185,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;
@@ -1230,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) {
@@ -1333,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;
                 }
@@ -1429,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;
@@ -1549,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;
 
@@ -1570,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;
                 }
@@ -1658,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 6b4b1287b314..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)
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 4be45e7be8ad..ae42b6509ce4 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -941,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);
 }
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_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/timer.c b/sound/core/timer.c
index ed016329e911..7c1cbf0a0dc4 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -186,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;
@@ -414,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..a89948ae9e8d 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 */
 };