ALSA: core: sparse cleanups
authorClemens Ladisch <clemens@ladisch.de>
Mon, 14 Feb 2011 10:00:47 +0000 (11:00 +0100)
committerTakashi Iwai <tiwai@suse.de>
Mon, 14 Feb 2011 16:10:11 +0000 (17:10 +0100)
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:
include/sound/mixer_oss.h
include/sound/pcm.h
sound/core/device.c
sound/core/memalloc.c
sound/core/oss/linear.c
sound/core/oss/mixer_oss.c
sound/core/oss/mulaw.c
sound/core/oss/pcm_oss.c
sound/core/oss/pcm_plugin.c
sound/core/oss/pcm_plugin.h
sound/core/oss/route.c
sound/core/pcm.c
sound/core/pcm_misc.c
sound/core/pcm_native.c
sound/core/seq/seq_clientmgr.c
sound/core/seq/seq_memory.c
sound/core/seq/seq_memory.h
sound/core/vmaster.c

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