mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-24 21:24:00 +08:00
07f4d9d74a
The user-control put and get handlers as well as the tlv do not protect against concurrent access from multiple threads. Since the state of the control is not updated atomically it is possible that either two write operations or a write and a read operation race against each other. Both can lead to arbitrary memory disclosure. This patch introduces a new lock that protects user-controls from concurrent access. Since applications typically access controls sequentially than in parallel a single lock per card should be fine. Signed-off-by: Lars-Peter Clausen <lars@metafoo.de> Acked-by: Jaroslav Kysela <perex@perex.cz> Cc: <stable@vger.kernel.org> Signed-off-by: Takashi Iwai <tiwai@suse.de>
489 lines
15 KiB
C
489 lines
15 KiB
C
#ifndef __SOUND_CORE_H
|
|
#define __SOUND_CORE_H
|
|
|
|
/*
|
|
* Main header file for the ALSA driver
|
|
* Copyright (c) 1994-2001 by Jaroslav Kysela <perex@perex.cz>
|
|
*
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include <linux/device.h>
|
|
#include <linux/sched.h> /* wake_up() */
|
|
#include <linux/mutex.h> /* struct mutex */
|
|
#include <linux/rwsem.h> /* struct rw_semaphore */
|
|
#include <linux/pm.h> /* pm_message_t */
|
|
#include <linux/stringify.h>
|
|
#include <linux/printk.h>
|
|
|
|
/* number of supported soundcards */
|
|
#ifdef CONFIG_SND_DYNAMIC_MINORS
|
|
#define SNDRV_CARDS CONFIG_SND_MAX_CARDS
|
|
#else
|
|
#define SNDRV_CARDS 8 /* don't change - minor numbers */
|
|
#endif
|
|
|
|
#define CONFIG_SND_MAJOR 116 /* standard configuration */
|
|
|
|
/* forward declarations */
|
|
struct pci_dev;
|
|
struct module;
|
|
struct completion;
|
|
|
|
/* device allocation stuff */
|
|
|
|
/* type of the object used in snd_device_*()
|
|
* this also defines the calling order
|
|
*/
|
|
enum snd_device_type {
|
|
SNDRV_DEV_LOWLEVEL,
|
|
SNDRV_DEV_CONTROL,
|
|
SNDRV_DEV_INFO,
|
|
SNDRV_DEV_BUS,
|
|
SNDRV_DEV_CODEC,
|
|
SNDRV_DEV_PCM,
|
|
SNDRV_DEV_COMPRESS,
|
|
SNDRV_DEV_RAWMIDI,
|
|
SNDRV_DEV_TIMER,
|
|
SNDRV_DEV_SEQUENCER,
|
|
SNDRV_DEV_HWDEP,
|
|
SNDRV_DEV_JACK,
|
|
};
|
|
|
|
enum snd_device_state {
|
|
SNDRV_DEV_BUILD,
|
|
SNDRV_DEV_REGISTERED,
|
|
SNDRV_DEV_DISCONNECTED,
|
|
};
|
|
|
|
struct snd_device;
|
|
|
|
struct snd_device_ops {
|
|
int (*dev_free)(struct snd_device *dev);
|
|
int (*dev_register)(struct snd_device *dev);
|
|
int (*dev_disconnect)(struct snd_device *dev);
|
|
};
|
|
|
|
struct snd_device {
|
|
struct list_head list; /* list of registered devices */
|
|
struct snd_card *card; /* card which holds this device */
|
|
enum snd_device_state state; /* state of the device */
|
|
enum snd_device_type type; /* device type */
|
|
void *device_data; /* device structure */
|
|
struct snd_device_ops *ops; /* operations */
|
|
};
|
|
|
|
#define snd_device(n) list_entry(n, struct snd_device, list)
|
|
|
|
/* main structure for soundcard */
|
|
|
|
struct snd_card {
|
|
int number; /* number of soundcard (index to
|
|
snd_cards) */
|
|
|
|
char id[16]; /* id string of this card */
|
|
char driver[16]; /* driver name */
|
|
char shortname[32]; /* short name of this soundcard */
|
|
char longname[80]; /* name of this soundcard */
|
|
char mixername[80]; /* mixer name */
|
|
char components[128]; /* card components delimited with
|
|
space */
|
|
struct module *module; /* top-level module */
|
|
|
|
void *private_data; /* private data for soundcard */
|
|
void (*private_free) (struct snd_card *card); /* callback for freeing of
|
|
private data */
|
|
struct list_head devices; /* devices */
|
|
|
|
unsigned int last_numid; /* last used numeric ID */
|
|
struct rw_semaphore controls_rwsem; /* controls list lock */
|
|
rwlock_t ctl_files_rwlock; /* ctl_files list lock */
|
|
int controls_count; /* count of all controls */
|
|
int user_ctl_count; /* count of all user controls */
|
|
struct list_head controls; /* all controls for this card */
|
|
struct list_head ctl_files; /* active control files */
|
|
struct mutex user_ctl_lock; /* protects user controls against
|
|
concurrent access */
|
|
|
|
struct snd_info_entry *proc_root; /* root for soundcard specific files */
|
|
struct snd_info_entry *proc_id; /* the card id */
|
|
struct proc_dir_entry *proc_root_link; /* number link to real id */
|
|
|
|
struct list_head files_list; /* all files associated to this card */
|
|
struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown
|
|
state */
|
|
spinlock_t files_lock; /* lock the files for this card */
|
|
int shutdown; /* this card is going down */
|
|
struct completion *release_completion;
|
|
struct device *dev; /* device assigned to this card */
|
|
struct device card_dev; /* cardX object for sysfs */
|
|
bool registered; /* card_dev is registered? */
|
|
|
|
#ifdef CONFIG_PM
|
|
unsigned int power_state; /* power state */
|
|
struct mutex power_lock; /* power lock */
|
|
wait_queue_head_t power_sleep;
|
|
#endif
|
|
|
|
#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
|
|
struct snd_mixer_oss *mixer_oss;
|
|
int mixer_oss_change_count;
|
|
#endif
|
|
};
|
|
|
|
#define dev_to_snd_card(p) container_of(p, struct snd_card, card_dev)
|
|
|
|
#ifdef CONFIG_PM
|
|
static inline void snd_power_lock(struct snd_card *card)
|
|
{
|
|
mutex_lock(&card->power_lock);
|
|
}
|
|
|
|
static inline void snd_power_unlock(struct snd_card *card)
|
|
{
|
|
mutex_unlock(&card->power_lock);
|
|
}
|
|
|
|
static inline unsigned int snd_power_get_state(struct snd_card *card)
|
|
{
|
|
return card->power_state;
|
|
}
|
|
|
|
static inline void snd_power_change_state(struct snd_card *card, unsigned int state)
|
|
{
|
|
card->power_state = state;
|
|
wake_up(&card->power_sleep);
|
|
}
|
|
|
|
/* init.c */
|
|
int snd_power_wait(struct snd_card *card, unsigned int power_state);
|
|
|
|
#else /* ! CONFIG_PM */
|
|
|
|
#define snd_power_lock(card) do { (void)(card); } while (0)
|
|
#define snd_power_unlock(card) do { (void)(card); } while (0)
|
|
static inline int snd_power_wait(struct snd_card *card, unsigned int state) { return 0; }
|
|
#define snd_power_get_state(card) ({ (void)(card); SNDRV_CTL_POWER_D0; })
|
|
#define snd_power_change_state(card, state) do { (void)(card); } while (0)
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
struct snd_minor {
|
|
int type; /* SNDRV_DEVICE_TYPE_XXX */
|
|
int card; /* card number */
|
|
int device; /* device number */
|
|
const struct file_operations *f_ops; /* file operations */
|
|
void *private_data; /* private data for f_ops->open */
|
|
struct device *dev; /* device for sysfs */
|
|
struct snd_card *card_ptr; /* assigned card instance */
|
|
};
|
|
|
|
/* return a device pointer linked to each sound device as a parent */
|
|
static inline struct device *snd_card_get_device_link(struct snd_card *card)
|
|
{
|
|
return card ? &card->card_dev : NULL;
|
|
}
|
|
|
|
/* sound.c */
|
|
|
|
extern int snd_major;
|
|
extern int snd_ecards_limit;
|
|
extern struct class *sound_class;
|
|
|
|
void snd_request_card(int card);
|
|
|
|
int snd_register_device_for_dev(int type, struct snd_card *card,
|
|
int dev,
|
|
const struct file_operations *f_ops,
|
|
void *private_data,
|
|
const char *name,
|
|
struct device *device);
|
|
|
|
/**
|
|
* snd_register_device - Register the ALSA device file for the card
|
|
* @type: the device type, SNDRV_DEVICE_TYPE_XXX
|
|
* @card: the card instance
|
|
* @dev: the device index
|
|
* @f_ops: the file operations
|
|
* @private_data: user pointer for f_ops->open()
|
|
* @name: the device file name
|
|
*
|
|
* Registers an ALSA device file for the given card.
|
|
* The operators have to be set in reg parameter.
|
|
*
|
|
* This function uses the card's device pointer to link to the
|
|
* correct &struct device.
|
|
*
|
|
* Return: Zero if successful, or a negative error code on failure.
|
|
*/
|
|
static inline int snd_register_device(int type, struct snd_card *card, int dev,
|
|
const struct file_operations *f_ops,
|
|
void *private_data,
|
|
const char *name)
|
|
{
|
|
return snd_register_device_for_dev(type, card, dev, f_ops,
|
|
private_data, name,
|
|
snd_card_get_device_link(card));
|
|
}
|
|
|
|
int snd_unregister_device(int type, struct snd_card *card, int dev);
|
|
void *snd_lookup_minor_data(unsigned int minor, int type);
|
|
struct device *snd_get_device(int type, struct snd_card *card, int dev);
|
|
|
|
#ifdef CONFIG_SND_OSSEMUL
|
|
int snd_register_oss_device(int type, struct snd_card *card, int dev,
|
|
const struct file_operations *f_ops, void *private_data);
|
|
int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
|
|
void *snd_lookup_oss_minor_data(unsigned int minor, int type);
|
|
#endif
|
|
|
|
int snd_minor_info_init(void);
|
|
int snd_minor_info_done(void);
|
|
|
|
/* sound_oss.c */
|
|
|
|
#ifdef CONFIG_SND_OSSEMUL
|
|
int snd_minor_info_oss_init(void);
|
|
int snd_minor_info_oss_done(void);
|
|
#else
|
|
static inline int snd_minor_info_oss_init(void) { return 0; }
|
|
static inline int snd_minor_info_oss_done(void) { return 0; }
|
|
#endif
|
|
|
|
/* memory.c */
|
|
|
|
int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count);
|
|
int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count);
|
|
|
|
/* init.c */
|
|
|
|
extern struct snd_card *snd_cards[SNDRV_CARDS];
|
|
int snd_card_locked(int card);
|
|
#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
|
|
#define SND_MIXER_OSS_NOTIFY_REGISTER 0
|
|
#define SND_MIXER_OSS_NOTIFY_DISCONNECT 1
|
|
#define SND_MIXER_OSS_NOTIFY_FREE 2
|
|
extern int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int cmd);
|
|
#endif
|
|
|
|
int snd_card_new(struct device *parent, int idx, const char *xid,
|
|
struct module *module, int extra_size,
|
|
struct snd_card **card_ret);
|
|
|
|
int snd_card_disconnect(struct snd_card *card);
|
|
int snd_card_free(struct snd_card *card);
|
|
int snd_card_free_when_closed(struct snd_card *card);
|
|
void snd_card_set_id(struct snd_card *card, const char *id);
|
|
int snd_card_register(struct snd_card *card);
|
|
int snd_card_info_init(void);
|
|
int snd_card_info_done(void);
|
|
int snd_component_add(struct snd_card *card, const char *component);
|
|
int snd_card_file_add(struct snd_card *card, struct file *file);
|
|
int snd_card_file_remove(struct snd_card *card, struct file *file);
|
|
#define snd_card_unref(card) put_device(&(card)->card_dev)
|
|
|
|
#define snd_card_set_dev(card, devptr) ((card)->dev = (devptr))
|
|
|
|
/* device.c */
|
|
|
|
int snd_device_new(struct snd_card *card, enum snd_device_type type,
|
|
void *device_data, struct snd_device_ops *ops);
|
|
int snd_device_register(struct snd_card *card, void *device_data);
|
|
int snd_device_register_all(struct snd_card *card);
|
|
int snd_device_disconnect_all(struct snd_card *card);
|
|
void snd_device_free(struct snd_card *card, void *device_data);
|
|
void snd_device_free_all(struct snd_card *card);
|
|
|
|
/* isadma.c */
|
|
|
|
#ifdef CONFIG_ISA_DMA_API
|
|
#define DMA_MODE_NO_ENABLE 0x0100
|
|
|
|
void snd_dma_program(unsigned long dma, unsigned long addr, unsigned int size, unsigned short mode);
|
|
void snd_dma_disable(unsigned long dma);
|
|
unsigned int snd_dma_pointer(unsigned long dma, unsigned int size);
|
|
#endif
|
|
|
|
/* misc.c */
|
|
struct resource;
|
|
void release_and_free_resource(struct resource *res);
|
|
|
|
/* --- */
|
|
|
|
/* sound printk debug levels */
|
|
enum {
|
|
SND_PR_ALWAYS,
|
|
SND_PR_DEBUG,
|
|
SND_PR_VERBOSE,
|
|
};
|
|
|
|
#if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
|
|
__printf(4, 5)
|
|
void __snd_printk(unsigned int level, const char *file, int line,
|
|
const char *format, ...);
|
|
#else
|
|
#define __snd_printk(level, file, line, format, args...) \
|
|
printk(format, ##args)
|
|
#endif
|
|
|
|
/**
|
|
* snd_printk - printk wrapper
|
|
* @fmt: format string
|
|
*
|
|
* Works like printk() but prints the file and the line of the caller
|
|
* when configured with CONFIG_SND_VERBOSE_PRINTK.
|
|
*/
|
|
#define snd_printk(fmt, args...) \
|
|
__snd_printk(0, __FILE__, __LINE__, fmt, ##args)
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
/**
|
|
* snd_printd - debug printk
|
|
* @fmt: format string
|
|
*
|
|
* Works like snd_printk() for debugging purposes.
|
|
* Ignored when CONFIG_SND_DEBUG is not set.
|
|
*/
|
|
#define snd_printd(fmt, args...) \
|
|
__snd_printk(1, __FILE__, __LINE__, fmt, ##args)
|
|
#define _snd_printd(level, fmt, args...) \
|
|
__snd_printk(level, __FILE__, __LINE__, fmt, ##args)
|
|
|
|
/**
|
|
* snd_BUG - give a BUG warning message and stack trace
|
|
*
|
|
* Calls WARN() if CONFIG_SND_DEBUG is set.
|
|
* Ignored when CONFIG_SND_DEBUG is not set.
|
|
*/
|
|
#define snd_BUG() WARN(1, "BUG?\n")
|
|
|
|
/**
|
|
* Suppress high rates of output when CONFIG_SND_DEBUG is enabled.
|
|
*/
|
|
#define snd_printd_ratelimit() printk_ratelimit()
|
|
|
|
/**
|
|
* snd_BUG_ON - debugging check macro
|
|
* @cond: condition to evaluate
|
|
*
|
|
* Has the same behavior as WARN_ON when CONFIG_SND_DEBUG is set,
|
|
* otherwise just evaluates the conditional and returns the value.
|
|
*/
|
|
#define snd_BUG_ON(cond) WARN_ON((cond))
|
|
|
|
#else /* !CONFIG_SND_DEBUG */
|
|
|
|
__printf(1, 2)
|
|
static inline void snd_printd(const char *format, ...) {}
|
|
__printf(2, 3)
|
|
static inline void _snd_printd(int level, const char *format, ...) {}
|
|
|
|
#define snd_BUG() do { } while (0)
|
|
|
|
#define snd_BUG_ON(condition) ({ \
|
|
int __ret_warn_on = !!(condition); \
|
|
unlikely(__ret_warn_on); \
|
|
})
|
|
|
|
static inline bool snd_printd_ratelimit(void) { return false; }
|
|
|
|
#endif /* CONFIG_SND_DEBUG */
|
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
|
/**
|
|
* snd_printdd - debug printk
|
|
* @format: format string
|
|
*
|
|
* Works like snd_printk() for debugging purposes.
|
|
* Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
|
|
*/
|
|
#define snd_printdd(format, args...) \
|
|
__snd_printk(2, __FILE__, __LINE__, format, ##args)
|
|
#else
|
|
__printf(1, 2)
|
|
static inline void snd_printdd(const char *format, ...) {}
|
|
#endif
|
|
|
|
|
|
#define SNDRV_OSS_VERSION ((3<<16)|(8<<8)|(1<<4)|(0)) /* 3.8.1a */
|
|
|
|
/* for easier backward-porting */
|
|
#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
|
|
#define gameport_set_dev_parent(gp,xdev) ((gp)->dev.parent = (xdev))
|
|
#define gameport_set_port_data(gp,r) ((gp)->port_data = (r))
|
|
#define gameport_get_port_data(gp) (gp)->port_data
|
|
#endif
|
|
|
|
/* PCI quirk list helper */
|
|
struct snd_pci_quirk {
|
|
unsigned short subvendor; /* PCI subvendor ID */
|
|
unsigned short subdevice; /* PCI subdevice ID */
|
|
unsigned short subdevice_mask; /* bitmask to match */
|
|
int value; /* value */
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
|
const char *name; /* name of the device (optional) */
|
|
#endif
|
|
};
|
|
|
|
#define _SND_PCI_QUIRK_ID_MASK(vend, mask, dev) \
|
|
.subvendor = (vend), .subdevice = (dev), .subdevice_mask = (mask)
|
|
#define _SND_PCI_QUIRK_ID(vend, dev) \
|
|
_SND_PCI_QUIRK_ID_MASK(vend, 0xffff, dev)
|
|
#define SND_PCI_QUIRK_ID(vend,dev) {_SND_PCI_QUIRK_ID(vend, dev)}
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
|
#define SND_PCI_QUIRK(vend,dev,xname,val) \
|
|
{_SND_PCI_QUIRK_ID(vend, dev), .value = (val), .name = (xname)}
|
|
#define SND_PCI_QUIRK_VENDOR(vend, xname, val) \
|
|
{_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val), .name = (xname)}
|
|
#define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val) \
|
|
{_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), \
|
|
.value = (val), .name = (xname)}
|
|
#define snd_pci_quirk_name(q) ((q)->name)
|
|
#else
|
|
#define SND_PCI_QUIRK(vend,dev,xname,val) \
|
|
{_SND_PCI_QUIRK_ID(vend, dev), .value = (val)}
|
|
#define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val) \
|
|
{_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), .value = (val)}
|
|
#define SND_PCI_QUIRK_VENDOR(vend, xname, val) \
|
|
{_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val)}
|
|
#define snd_pci_quirk_name(q) ""
|
|
#endif
|
|
|
|
#ifdef CONFIG_PCI
|
|
const struct snd_pci_quirk *
|
|
snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
|
|
|
|
const struct snd_pci_quirk *
|
|
snd_pci_quirk_lookup_id(u16 vendor, u16 device,
|
|
const struct snd_pci_quirk *list);
|
|
#else
|
|
static inline const struct snd_pci_quirk *
|
|
snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline const struct snd_pci_quirk *
|
|
snd_pci_quirk_lookup_id(u16 vendor, u16 device,
|
|
const struct snd_pci_quirk *list)
|
|
{
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
#endif /* __SOUND_CORE_H */
|