mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-18 08:46:40 +07:00
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>
This commit is contained in:
Clemens Ladisch
Takashi Iwai
parent
88b27fdac8
commit
fea952e5cc
@ -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 */
|
||||
|
||||
@ -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 ¶ms->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
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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];
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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 */
|
||||
};
|
||||
|
||||
Loading…
Reference in New Issue
Block a user