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>

diff --git a/include/sound/mixer_oss.h b/include/sound/mixer_oss.h
index 51fbcb4..13cb0b4 100644 (file)
--- 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 e731f8d..430a9cc 100644 (file)
--- 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 a67dfac..2d1ad4b 100644 (file)
--- 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 9e92441..16bd9c0 100644 (file)
--- 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 4c1d168..13b3f6f 100644 (file)
--- 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 822dd56..d8359cf 100644 (file)
--- 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 f7649d4..7915564 100644 (file)
--- 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 a2e4eb3..23c34a0 100644 (file)
--- 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 6751daa..71cc3dd 100644 (file)
--- 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 b9afab6..a5035c2 100644 (file)
--- 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 bbe25d8..c8171f5 100644 (file)
--- 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 6b4b128..ee9abb2 100644 (file)
--- 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 434af3c..88f02e3 100644 (file)
--- 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 4be45e7..ae42b65 100644 (file)
--- 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 99a485f..f2436d3 100644 (file)
--- 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 7fb5543..7f50c14 100644 (file)
--- 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 63e9143..4a2ec77 100644 (file)
--- 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 3b9b550..a89948a 100644 (file)
--- 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 */
 };