ALSA: core: sparse cleanups

Change the core code where sparse complains.  In most cases, this means
just adding annotations to confirm that we indeed want to do the dirty
things we're doing.

Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

18 files changed, 160 insertions, 137 deletions

diff --git a/include/sound/mixer_oss.h b/include/sound/mixer_oss.h
index 51fbcb4a277a..13cb0b430a1b 100644
--- a/include/sound/mixer_oss.h
+++ b/include/sound/mixer_oss.h
@@ -73,6 +73,9 @@ struct snd_mixer_oss_file {
         struct snd_mixer_oss *mixer;
 };
 
+int snd_mixer_oss_ioctl_card(struct snd_card *card,
+                             unsigned int cmd, unsigned long arg);
+
 #endif /* CONFIG_SND_MIXER_OSS */
 
 #endif /* __SOUND_MIXER_OSS_H */
diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index e731f8d71934..430a9cc045e2 100644
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
@@ -136,48 +136,49 @@ struct snd_pcm_ops {
                                          SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000)
 #define SNDRV_PCM_RATE_8000_192000      (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
                                          SNDRV_PCM_RATE_192000)
-#define SNDRV_PCM_FMTBIT_S8             (1ULL << SNDRV_PCM_FORMAT_S8)
-#define SNDRV_PCM_FMTBIT_U8             (1ULL << SNDRV_PCM_FORMAT_U8)
-#define SNDRV_PCM_FMTBIT_S16_LE         (1ULL << SNDRV_PCM_FORMAT_S16_LE)
-#define SNDRV_PCM_FMTBIT_S16_BE         (1ULL << SNDRV_PCM_FORMAT_S16_BE)
-#define SNDRV_PCM_FMTBIT_U16_LE         (1ULL << SNDRV_PCM_FORMAT_U16_LE)
-#define SNDRV_PCM_FMTBIT_U16_BE         (1ULL << SNDRV_PCM_FORMAT_U16_BE)
-#define SNDRV_PCM_FMTBIT_S24_LE         (1ULL << SNDRV_PCM_FORMAT_S24_LE)
-#define SNDRV_PCM_FMTBIT_S24_BE         (1ULL << SNDRV_PCM_FORMAT_S24_BE)
-#define SNDRV_PCM_FMTBIT_U24_LE         (1ULL << SNDRV_PCM_FORMAT_U24_LE)
-#define SNDRV_PCM_FMTBIT_U24_BE         (1ULL << SNDRV_PCM_FORMAT_U24_BE)
-#define SNDRV_PCM_FMTBIT_S32_LE         (1ULL << SNDRV_PCM_FORMAT_S32_LE)
-#define SNDRV_PCM_FMTBIT_S32_BE         (1ULL << SNDRV_PCM_FORMAT_S32_BE)
-#define SNDRV_PCM_FMTBIT_U32_LE         (1ULL << SNDRV_PCM_FORMAT_U32_LE)
-#define SNDRV_PCM_FMTBIT_U32_BE         (1ULL << SNDRV_PCM_FORMAT_U32_BE)
-#define SNDRV_PCM_FMTBIT_FLOAT_LE       (1ULL << SNDRV_PCM_FORMAT_FLOAT_LE)
-#define SNDRV_PCM_FMTBIT_FLOAT_BE       (1ULL << SNDRV_PCM_FORMAT_FLOAT_BE)
-#define SNDRV_PCM_FMTBIT_FLOAT64_LE     (1ULL << SNDRV_PCM_FORMAT_FLOAT64_LE)
-#define SNDRV_PCM_FMTBIT_FLOAT64_BE     (1ULL << SNDRV_PCM_FORMAT_FLOAT64_BE)
-#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE (1ULL << SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE)
-#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE (1ULL << SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE)
-#define SNDRV_PCM_FMTBIT_MU_LAW         (1ULL << SNDRV_PCM_FORMAT_MU_LAW)
-#define SNDRV_PCM_FMTBIT_A_LAW          (1ULL << SNDRV_PCM_FORMAT_A_LAW)
-#define SNDRV_PCM_FMTBIT_IMA_ADPCM      (1ULL << SNDRV_PCM_FORMAT_IMA_ADPCM)
-#define SNDRV_PCM_FMTBIT_MPEG           (1ULL << SNDRV_PCM_FORMAT_MPEG)
-#define SNDRV_PCM_FMTBIT_GSM            (1ULL << SNDRV_PCM_FORMAT_GSM)
-#define SNDRV_PCM_FMTBIT_SPECIAL        (1ULL << SNDRV_PCM_FORMAT_SPECIAL)
-#define SNDRV_PCM_FMTBIT_S24_3LE        (1ULL << SNDRV_PCM_FORMAT_S24_3LE)
-#define SNDRV_PCM_FMTBIT_U24_3LE        (1ULL << SNDRV_PCM_FORMAT_U24_3LE)
-#define SNDRV_PCM_FMTBIT_S24_3BE        (1ULL << SNDRV_PCM_FORMAT_S24_3BE)
-#define SNDRV_PCM_FMTBIT_U24_3BE        (1ULL << SNDRV_PCM_FORMAT_U24_3BE)
-#define SNDRV_PCM_FMTBIT_S20_3LE        (1ULL << SNDRV_PCM_FORMAT_S20_3LE)
-#define SNDRV_PCM_FMTBIT_U20_3LE        (1ULL << SNDRV_PCM_FORMAT_U20_3LE)
-#define SNDRV_PCM_FMTBIT_S20_3BE        (1ULL << SNDRV_PCM_FORMAT_S20_3BE)
-#define SNDRV_PCM_FMTBIT_U20_3BE        (1ULL << SNDRV_PCM_FORMAT_U20_3BE)
-#define SNDRV_PCM_FMTBIT_S18_3LE        (1ULL << SNDRV_PCM_FORMAT_S18_3LE)
-#define SNDRV_PCM_FMTBIT_U18_3LE        (1ULL << SNDRV_PCM_FORMAT_U18_3LE)
-#define SNDRV_PCM_FMTBIT_S18_3BE        (1ULL << SNDRV_PCM_FORMAT_S18_3BE)
-#define SNDRV_PCM_FMTBIT_U18_3BE        (1ULL << SNDRV_PCM_FORMAT_U18_3BE)
-#define SNDRV_PCM_FMTBIT_G723_24        (1ULL << SNDRV_PCM_FORMAT_G723_24)
-#define SNDRV_PCM_FMTBIT_G723_24_1B     (1ULL << SNDRV_PCM_FORMAT_G723_24_1B)
-#define SNDRV_PCM_FMTBIT_G723_40        (1ULL << SNDRV_PCM_FORMAT_G723_40)
-#define SNDRV_PCM_FMTBIT_G723_40_1B     (1ULL << SNDRV_PCM_FORMAT_G723_40_1B)
+#define _SNDRV_PCM_FMTBIT(fmt)          (1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt)
+#define SNDRV_PCM_FMTBIT_S8             _SNDRV_PCM_FMTBIT(S8)
+#define SNDRV_PCM_FMTBIT_U8             _SNDRV_PCM_FMTBIT(U8)
+#define SNDRV_PCM_FMTBIT_S16_LE         _SNDRV_PCM_FMTBIT(S16_LE)
+#define SNDRV_PCM_FMTBIT_S16_BE         _SNDRV_PCM_FMTBIT(S16_BE)
+#define SNDRV_PCM_FMTBIT_U16_LE         _SNDRV_PCM_FMTBIT(U16_LE)
+#define SNDRV_PCM_FMTBIT_U16_BE         _SNDRV_PCM_FMTBIT(U16_BE)
+#define SNDRV_PCM_FMTBIT_S24_LE         _SNDRV_PCM_FMTBIT(S24_LE)
+#define SNDRV_PCM_FMTBIT_S24_BE         _SNDRV_PCM_FMTBIT(S24_BE)
+#define SNDRV_PCM_FMTBIT_U24_LE         _SNDRV_PCM_FMTBIT(U24_LE)
+#define SNDRV_PCM_FMTBIT_U24_BE         _SNDRV_PCM_FMTBIT(U24_BE)
+#define SNDRV_PCM_FMTBIT_S32_LE         _SNDRV_PCM_FMTBIT(S32_LE)
+#define SNDRV_PCM_FMTBIT_S32_BE         _SNDRV_PCM_FMTBIT(S32_BE)
+#define SNDRV_PCM_FMTBIT_U32_LE         _SNDRV_PCM_FMTBIT(U32_LE)
+#define SNDRV_PCM_FMTBIT_U32_BE         _SNDRV_PCM_FMTBIT(U32_BE)
+#define SNDRV_PCM_FMTBIT_FLOAT_LE       _SNDRV_PCM_FMTBIT(FLOAT_LE)
+#define SNDRV_PCM_FMTBIT_FLOAT_BE       _SNDRV_PCM_FMTBIT(FLOAT_BE)
+#define SNDRV_PCM_FMTBIT_FLOAT64_LE     _SNDRV_PCM_FMTBIT(FLOAT64_LE)
+#define SNDRV_PCM_FMTBIT_FLOAT64_BE     _SNDRV_PCM_FMTBIT(FLOAT64_BE)
+#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE)
+#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE)
+#define SNDRV_PCM_FMTBIT_MU_LAW         _SNDRV_PCM_FMTBIT(MU_LAW)
+#define SNDRV_PCM_FMTBIT_A_LAW          _SNDRV_PCM_FMTBIT(A_LAW)
+#define SNDRV_PCM_FMTBIT_IMA_ADPCM      _SNDRV_PCM_FMTBIT(IMA_ADPCM)
+#define SNDRV_PCM_FMTBIT_MPEG           _SNDRV_PCM_FMTBIT(MPEG)
+#define SNDRV_PCM_FMTBIT_GSM            _SNDRV_PCM_FMTBIT(GSM)
+#define SNDRV_PCM_FMTBIT_SPECIAL        _SNDRV_PCM_FMTBIT(SPECIAL)
+#define SNDRV_PCM_FMTBIT_S24_3LE        _SNDRV_PCM_FMTBIT(S24_3LE)
+#define SNDRV_PCM_FMTBIT_U24_3LE        _SNDRV_PCM_FMTBIT(U24_3LE)
+#define SNDRV_PCM_FMTBIT_S24_3BE        _SNDRV_PCM_FMTBIT(S24_3BE)
+#define SNDRV_PCM_FMTBIT_U24_3BE        _SNDRV_PCM_FMTBIT(U24_3BE)
+#define SNDRV_PCM_FMTBIT_S20_3LE        _SNDRV_PCM_FMTBIT(S20_3LE)
+#define SNDRV_PCM_FMTBIT_U20_3LE        _SNDRV_PCM_FMTBIT(U20_3LE)
+#define SNDRV_PCM_FMTBIT_S20_3BE        _SNDRV_PCM_FMTBIT(S20_3BE)
+#define SNDRV_PCM_FMTBIT_U20_3BE        _SNDRV_PCM_FMTBIT(U20_3BE)
+#define SNDRV_PCM_FMTBIT_S18_3LE        _SNDRV_PCM_FMTBIT(S18_3LE)
+#define SNDRV_PCM_FMTBIT_U18_3LE        _SNDRV_PCM_FMTBIT(U18_3LE)
+#define SNDRV_PCM_FMTBIT_S18_3BE        _SNDRV_PCM_FMTBIT(S18_3BE)
+#define SNDRV_PCM_FMTBIT_U18_3BE        _SNDRV_PCM_FMTBIT(U18_3BE)
+#define SNDRV_PCM_FMTBIT_G723_24        _SNDRV_PCM_FMTBIT(G723_24)
+#define SNDRV_PCM_FMTBIT_G723_24_1B     _SNDRV_PCM_FMTBIT(G723_24_1B)
+#define SNDRV_PCM_FMTBIT_G723_40        _SNDRV_PCM_FMTBIT(G723_40)
+#define SNDRV_PCM_FMTBIT_G723_40_1B     _SNDRV_PCM_FMTBIT(G723_40_1B)
 
 #ifdef SNDRV_LITTLE_ENDIAN
 #define SNDRV_PCM_FMTBIT_S16            SNDRV_PCM_FMTBIT_S16_LE
@@ -490,7 +491,7 @@ int snd_pcm_info_user(struct snd_pcm_substream *substream,
 int snd_pcm_status(struct snd_pcm_substream *substream,
                    struct snd_pcm_status *status);
 int snd_pcm_start(struct snd_pcm_substream *substream);
-int snd_pcm_stop(struct snd_pcm_substream *substream, int status);
+int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status);
 int snd_pcm_drain_done(struct snd_pcm_substream *substream);
 #ifdef CONFIG_PM
 int snd_pcm_suspend(struct snd_pcm_substream *substream);
@@ -748,8 +749,8 @@ static inline const struct snd_interval *hw_param_interval_c(const struct snd_pc
         return &params->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
 }
 
-#define params_access(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_ACCESS))
-#define params_format(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_FORMAT))
+#define params_access(p) ((__force snd_pcm_access_t)snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_ACCESS)))
+#define params_format(p) ((__force snd_pcm_format_t)snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_FORMAT)))
 #define params_subformat(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_SUBFORMAT))
 #define params_channels(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_CHANNELS)->min
 #define params_rate(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_RATE)->min
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/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 */
 };