2005-04-17 06:20:36 +08:00
|
|
|
#ifndef __SOUND_CORE_H
|
|
|
|
#define __SOUND_CORE_H
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Main header file for the ALSA driver
|
2007-10-15 15:50:19 +08:00
|
|
|
* Copyright (c) 1994-2001 by Jaroslav Kysela <perex@perex.cz>
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2014-01-29 18:46:11 +08:00
|
|
|
#include <linux/device.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/sched.h> /* wake_up() */
|
2006-01-16 23:29:08 +08:00
|
|
|
#include <linux/mutex.h> /* struct mutex */
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/rwsem.h> /* struct rw_semaphore */
|
|
|
|
#include <linux/pm.h> /* pm_message_t */
|
2008-08-08 23:06:01 +08:00
|
|
|
#include <linux/stringify.h>
|
2013-08-17 01:18:59 +08:00
|
|
|
#include <linux/printk.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-09 01:13:27 +08:00
|
|
|
/* number of supported soundcards */
|
|
|
|
#ifdef CONFIG_SND_DYNAMIC_MINORS
|
ALSA: Add kconfig to specify the max card numbers
Currently ALSA supports up to 32 card instances when the dynamic minor
is used. While 32 cards are usually big enough for normal use cases,
there are sometimes weird requirements with more card support.
Actually, this limitation, 32, comes from the index option, where you
can pass the bit mask to assign the card. Other than that, we can
actually give more cards up to the minor number limits (currently 256,
which can be extended more, too).
This patch adds a new Kconfig to specify the max card numbers, and
changes a few places to accept more than 32 cards.
The only incompatibility with high card numbers would be the handling
of index option. The index option can be still used to pass the
bitmask for card assignments, but this works only up to 32 slots.
More than 32, no bitmask style option is available but only a single
slot can be specified via index option.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-05-15 14:46:39 +08:00
|
|
|
#define SNDRV_CARDS CONFIG_SND_MAX_CARDS
|
2008-01-09 01:13:27 +08:00
|
|
|
#else
|
|
|
|
#define SNDRV_CARDS 8 /* don't change - minor numbers */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define CONFIG_SND_MAJOR 116 /* standard configuration */
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* forward declarations */
|
|
|
|
struct pci_dev;
|
2011-05-27 01:46:22 +08:00
|
|
|
struct module;
|
2014-01-29 19:13:43 +08:00
|
|
|
struct completion;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* device allocation stuff */
|
|
|
|
|
ALSA: Use priority list for managing device list
Basically, the device type specifies the priority of the device to be
registered / freed, too. However, the priority value isn't well
utilized but only it's checked as a group. This results in
inconsistent register and free order (where each of them should be in
reversed direction).
This patch simplifies the device list management code by simply
inserting a list entry at creation time in an incremental order for
the priority value. Since we can just follow the link for register,
disconnect and free calls, we don't have to specify the group; so the
whole enum definitions are also simplified as well.
The visible change to outside is that the priorities of some object
types are revisited. For example, now the SNDRV_DEV_LOWLEVEL object
is registered before others (control, PCM, etc) and, in return,
released after others. Similarly, SNDRV_DEV_CODEC is in a lower
priority than SNDRV_DEV_BUS for ensuring the dependency.
Also, the unused SNDRV_DEV_TOPLEVEL, SNDRV_DEV_LOWLEVEL_PRE and
SNDRV_DEV_LOWLEVEL_NORMAL are removed as a cleanup.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2014-01-29 22:53:35 +08:00
|
|
|
/* type of the object used in snd_device_*()
|
|
|
|
* this also defines the calling order
|
|
|
|
*/
|
2014-01-29 22:13:33 +08:00
|
|
|
enum snd_device_type {
|
ALSA: Use priority list for managing device list
Basically, the device type specifies the priority of the device to be
registered / freed, too. However, the priority value isn't well
utilized but only it's checked as a group. This results in
inconsistent register and free order (where each of them should be in
reversed direction).
This patch simplifies the device list management code by simply
inserting a list entry at creation time in an incremental order for
the priority value. Since we can just follow the link for register,
disconnect and free calls, we don't have to specify the group; so the
whole enum definitions are also simplified as well.
The visible change to outside is that the priorities of some object
types are revisited. For example, now the SNDRV_DEV_LOWLEVEL object
is registered before others (control, PCM, etc) and, in return,
released after others. Similarly, SNDRV_DEV_CODEC is in a lower
priority than SNDRV_DEV_BUS for ensuring the dependency.
Also, the unused SNDRV_DEV_TOPLEVEL, SNDRV_DEV_LOWLEVEL_PRE and
SNDRV_DEV_LOWLEVEL_NORMAL are removed as a cleanup.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2014-01-29 22:53:35 +08:00
|
|
|
SNDRV_DEV_LOWLEVEL,
|
|
|
|
SNDRV_DEV_CONTROL,
|
|
|
|
SNDRV_DEV_INFO,
|
|
|
|
SNDRV_DEV_BUS,
|
|
|
|
SNDRV_DEV_CODEC,
|
2014-01-29 22:13:33 +08:00
|
|
|
SNDRV_DEV_PCM,
|
ALSA: Use priority list for managing device list
Basically, the device type specifies the priority of the device to be
registered / freed, too. However, the priority value isn't well
utilized but only it's checked as a group. This results in
inconsistent register and free order (where each of them should be in
reversed direction).
This patch simplifies the device list management code by simply
inserting a list entry at creation time in an incremental order for
the priority value. Since we can just follow the link for register,
disconnect and free calls, we don't have to specify the group; so the
whole enum definitions are also simplified as well.
The visible change to outside is that the priorities of some object
types are revisited. For example, now the SNDRV_DEV_LOWLEVEL object
is registered before others (control, PCM, etc) and, in return,
released after others. Similarly, SNDRV_DEV_CODEC is in a lower
priority than SNDRV_DEV_BUS for ensuring the dependency.
Also, the unused SNDRV_DEV_TOPLEVEL, SNDRV_DEV_LOWLEVEL_PRE and
SNDRV_DEV_LOWLEVEL_NORMAL are removed as a cleanup.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2014-01-29 22:53:35 +08:00
|
|
|
SNDRV_DEV_COMPRESS,
|
2014-01-29 22:13:33 +08:00
|
|
|
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,
|
|
|
|
};
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
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 {
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head list; /* list of registered devices */
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_card *card; /* card which holds this device */
|
2014-01-29 22:13:33 +08:00
|
|
|
enum snd_device_state state; /* state of the device */
|
|
|
|
enum snd_device_type type; /* device type */
|
2005-04-17 06:20:36 +08:00
|
|
|
void *device_data; /* device structure */
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_device_ops *ops; /* operations */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
#define snd_device(n) list_entry(n, struct snd_device, list)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* main structure for soundcard */
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_card {
|
2005-06-30 01:31:06 +08:00
|
|
|
int number; /* number of soundcard (index to
|
|
|
|
snd_cards) */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
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 */
|
2015-12-23 02:09:05 +08:00
|
|
|
char irq_descr[32]; /* Interrupt description */
|
2005-04-17 06:20:36 +08:00
|
|
|
char mixername[80]; /* mixer name */
|
2008-10-07 17:38:09 +08:00
|
|
|
char components[128]; /* card components delimited with
|
2005-06-30 01:31:06 +08:00
|
|
|
space */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct module *module; /* top-level module */
|
|
|
|
|
|
|
|
void *private_data; /* private data for soundcard */
|
2005-11-17 20:51:18 +08:00
|
|
|
void (*private_free) (struct snd_card *card); /* callback for freeing of
|
2005-06-30 01:31:06 +08:00
|
|
|
private data */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head devices; /* devices */
|
|
|
|
|
2015-01-29 23:41:27 +08:00
|
|
|
struct device ctl_dev; /* control device */
|
2005-04-17 06:20:36 +08:00
|
|
|
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 */
|
2014-06-18 19:32:31 +08:00
|
|
|
struct mutex user_ctl_lock; /* protects user controls against
|
|
|
|
concurrent access */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_info_entry *proc_root; /* root for soundcard specific files */
|
|
|
|
struct snd_info_entry *proc_id; /* the card id */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct proc_dir_entry *proc_root_link; /* number link to real id */
|
|
|
|
|
2009-02-23 23:35:21 +08:00
|
|
|
struct list_head files_list; /* all files associated to this card */
|
2005-06-30 01:31:06 +08:00
|
|
|
struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown
|
|
|
|
state */
|
2005-04-17 06:20:36 +08:00
|
|
|
spinlock_t files_lock; /* lock the files for this card */
|
|
|
|
int shutdown; /* this card is going down */
|
2014-01-29 19:13:43 +08:00
|
|
|
struct completion *release_completion;
|
2007-01-26 19:40:31 +08:00
|
|
|
struct device *dev; /* device assigned to this card */
|
2014-01-29 18:46:11 +08:00
|
|
|
struct device card_dev; /* cardX object for sysfs */
|
2015-01-30 19:27:43 +08:00
|
|
|
const struct attribute_group *dev_groups[4]; /* assigned sysfs attr */
|
2014-01-29 18:46:11 +08:00
|
|
|
bool registered; /* card_dev is registered? */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
unsigned int power_state; /* power state */
|
2006-01-16 23:29:08 +08:00
|
|
|
struct mutex power_lock; /* power lock */
|
2005-04-17 06:20:36 +08:00
|
|
|
wait_queue_head_t power_sleep;
|
|
|
|
#endif
|
|
|
|
|
2017-05-12 17:44:03 +08:00
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_mixer_oss *mixer_oss;
|
2005-04-17 06:20:36 +08:00
|
|
|
int mixer_oss_change_count;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2014-01-29 18:46:11 +08:00
|
|
|
#define dev_to_snd_card(p) container_of(p, struct snd_card, card_dev)
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_PM
|
2005-11-17 20:51:18 +08:00
|
|
|
static inline void snd_power_lock(struct snd_card *card)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-01-16 23:29:08 +08:00
|
|
|
mutex_lock(&card->power_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
static inline void snd_power_unlock(struct snd_card *card)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-01-16 23:29:08 +08:00
|
|
|
mutex_unlock(&card->power_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
static inline unsigned int snd_power_get_state(struct snd_card *card)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
return card->power_state;
|
|
|
|
}
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
static inline void snd_power_change_state(struct snd_card *card, unsigned int state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
card->power_state = state;
|
|
|
|
wake_up(&card->power_sleep);
|
|
|
|
}
|
2005-06-30 01:31:06 +08:00
|
|
|
|
|
|
|
/* init.c */
|
2006-03-27 18:38:07 +08:00
|
|
|
int snd_power_wait(struct snd_card *card, unsigned int power_state);
|
2005-06-30 01:31:06 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#else /* ! CONFIG_PM */
|
|
|
|
|
|
|
|
#define snd_power_lock(card) do { (void)(card); } while (0)
|
|
|
|
#define snd_power_unlock(card) do { (void)(card); } while (0)
|
2006-04-03 05:37:36 +08:00
|
|
|
static inline int snd_power_wait(struct snd_card *card, unsigned int state) { return 0; }
|
2010-10-17 01:24:52 +08:00
|
|
|
#define snd_power_get_state(card) ({ (void)(card); SNDRV_CTL_POWER_D0; })
|
2005-04-17 06:20:36 +08:00
|
|
|
#define snd_power_change_state(card, state) do { (void)(card); } while (0)
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_minor {
|
2005-11-20 21:03:48 +08:00
|
|
|
int type; /* SNDRV_DEVICE_TYPE_XXX */
|
2005-11-20 21:05:49 +08:00
|
|
|
int card; /* card number */
|
2005-04-17 06:20:36 +08:00
|
|
|
int device; /* device number */
|
2006-03-28 17:56:41 +08:00
|
|
|
const struct file_operations *f_ops; /* file operations */
|
2005-11-20 21:06:59 +08:00
|
|
|
void *private_data; /* private data for f_ops->open */
|
2006-08-08 13:19:37 +08:00
|
|
|
struct device *dev; /* device for sysfs */
|
2012-10-16 19:05:59 +08:00
|
|
|
struct snd_card *card_ptr; /* assigned card instance */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2007-01-26 19:40:31 +08:00
|
|
|
/* 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)
|
|
|
|
{
|
2014-01-29 18:46:11 +08:00
|
|
|
return card ? &card->card_dev : NULL;
|
2007-01-26 19:40:31 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* sound.c */
|
|
|
|
|
2005-10-24 23:05:03 +08:00
|
|
|
extern int snd_major;
|
2005-04-17 06:20:36 +08:00
|
|
|
extern int snd_ecards_limit;
|
2006-08-08 13:19:37 +08:00
|
|
|
extern struct class *sound_class;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
void snd_request_card(int card);
|
|
|
|
|
2015-01-30 04:32:47 +08:00
|
|
|
void snd_device_initialize(struct device *dev, struct snd_card *card);
|
|
|
|
|
2015-01-30 15:34:58 +08:00
|
|
|
int snd_register_device(int type, struct snd_card *card, int dev,
|
|
|
|
const struct file_operations *f_ops,
|
|
|
|
void *private_data, struct device *device);
|
|
|
|
int snd_unregister_device(struct device *dev);
|
2005-11-20 21:06:59 +08:00
|
|
|
void *snd_lookup_minor_data(unsigned int minor, int type);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_SND_OSSEMUL
|
2005-11-20 21:03:48 +08:00
|
|
|
int snd_register_oss_device(int type, struct snd_card *card, int dev,
|
2014-02-04 20:51:45 +08:00
|
|
|
const struct file_operations *f_ops, void *private_data);
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
|
2005-11-20 21:06:59 +08:00
|
|
|
void *snd_lookup_oss_minor_data(unsigned int minor, int type);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
int snd_minor_info_init(void);
|
|
|
|
|
|
|
|
/* sound_oss.c */
|
|
|
|
|
|
|
|
#ifdef CONFIG_SND_OSSEMUL
|
|
|
|
int snd_minor_info_oss_init(void);
|
|
|
|
#else
|
2008-04-15 00:31:35 +08:00
|
|
|
static inline int snd_minor_info_oss_init(void) { return 0; }
|
2005-04-17 06:20:36 +08:00
|
|
|
#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 */
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
extern struct snd_card *snd_cards[SNDRV_CARDS];
|
2006-05-16 01:49:05 +08:00
|
|
|
int snd_card_locked(int card);
|
2017-05-12 17:44:03 +08:00
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
2005-04-17 06:20:36 +08:00
|
|
|
#define SND_MIXER_OSS_NOTIFY_REGISTER 0
|
|
|
|
#define SND_MIXER_OSS_NOTIFY_DISCONNECT 1
|
|
|
|
#define SND_MIXER_OSS_NOTIFY_FREE 2
|
2005-11-17 20:51:18 +08:00
|
|
|
extern int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int cmd);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
2014-01-29 19:51:12 +08:00
|
|
|
int snd_card_new(struct device *parent, int idx, const char *xid,
|
|
|
|
struct module *module, int extra_size,
|
|
|
|
struct snd_card **card_ret);
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_card_disconnect(struct snd_card *card);
|
|
|
|
int snd_card_free(struct snd_card *card);
|
2006-06-23 20:38:23 +08:00
|
|
|
int snd_card_free_when_closed(struct snd_card *card);
|
2009-06-02 18:02:38 +08:00
|
|
|
void snd_card_set_id(struct snd_card *card, const char *id);
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_card_register(struct snd_card *card);
|
2005-04-17 06:20:36 +08:00
|
|
|
int snd_card_info_init(void);
|
2015-01-30 19:27:43 +08:00
|
|
|
int snd_card_add_dev_attr(struct snd_card *card,
|
|
|
|
const struct attribute_group *group);
|
2005-11-17 20:51:18 +08:00
|
|
|
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);
|
2014-01-29 19:13:43 +08:00
|
|
|
#define snd_card_unref(card) put_device(&(card)->card_dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-04-01 21:33:22 +08:00
|
|
|
#define snd_card_set_dev(card, devptr) ((card)->dev = (devptr))
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* device.c */
|
|
|
|
|
2014-01-29 22:13:33 +08:00
|
|
|
int snd_device_new(struct snd_card *card, enum snd_device_type type,
|
2005-11-17 20:51:18 +08:00
|
|
|
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);
|
2015-02-28 01:01:22 +08:00
|
|
|
void snd_device_disconnect(struct snd_card *card, void *device_data);
|
|
|
|
void snd_device_disconnect_all(struct snd_card *card);
|
2014-02-04 18:36:11 +08:00
|
|
|
void snd_device_free(struct snd_card *card, void *device_data);
|
|
|
|
void snd_device_free_all(struct snd_card *card);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* isadma.c */
|
|
|
|
|
2005-08-24 05:45:06 +08:00
|
|
|
#ifdef CONFIG_ISA_DMA_API
|
2005-04-17 06:20:36 +08:00
|
|
|
#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);
|
2005-08-24 05:45:06 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* misc.c */
|
2005-10-11 23:28:58 +08:00
|
|
|
struct resource;
|
2005-10-10 17:56:31 +08:00
|
|
|
void release_and_free_resource(struct resource *res);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* --- */
|
|
|
|
|
2012-04-10 17:00:35 +08:00
|
|
|
/* sound printk debug levels */
|
|
|
|
enum {
|
|
|
|
SND_PR_ALWAYS,
|
|
|
|
SND_PR_DEBUG,
|
|
|
|
SND_PR_VERBOSE,
|
|
|
|
};
|
|
|
|
|
2009-08-27 22:45:07 +08:00
|
|
|
#if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
|
2011-11-01 08:11:33 +08:00
|
|
|
__printf(4, 5)
|
2009-08-27 22:45:07 +08:00
|
|
|
void __snd_printk(unsigned int level, const char *file, int line,
|
2011-11-01 08:11:33 +08:00
|
|
|
const char *format, ...);
|
2009-08-27 22:45:07 +08:00
|
|
|
#else
|
2016-11-15 05:25:33 +08:00
|
|
|
#define __snd_printk(level, file, line, format, ...) \
|
|
|
|
printk(format, ##__VA_ARGS__)
|
2009-08-27 22:45:07 +08:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* snd_printk - printk wrapper
|
|
|
|
* @fmt: format string
|
|
|
|
*
|
2008-11-07 16:37:22 +08:00
|
|
|
* Works like printk() but prints the file and the line of the caller
|
2005-04-17 06:20:36 +08:00
|
|
|
* when configured with CONFIG_SND_VERBOSE_PRINTK.
|
|
|
|
*/
|
2016-11-15 05:25:33 +08:00
|
|
|
#define snd_printk(fmt, ...) \
|
|
|
|
__snd_printk(0, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
/**
|
|
|
|
* snd_printd - debug printk
|
2006-01-10 12:53:55 +08:00
|
|
|
* @fmt: format string
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-04-01 21:33:22 +08:00
|
|
|
* Works like snd_printk() for debugging purposes.
|
2005-04-17 06:20:36 +08:00
|
|
|
* Ignored when CONFIG_SND_DEBUG is not set.
|
|
|
|
*/
|
2016-11-15 05:25:33 +08:00
|
|
|
#define snd_printd(fmt, ...) \
|
|
|
|
__snd_printk(1, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
|
|
|
#define _snd_printd(level, fmt, ...) \
|
|
|
|
__snd_printk(level, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
2005-10-10 17:46:31 +08:00
|
|
|
|
2008-11-07 16:37:22 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-08-08 23:18:08 +08:00
|
|
|
#define snd_BUG() WARN(1, "BUG?\n")
|
2008-11-07 16:37:22 +08:00
|
|
|
|
2013-08-17 01:18:59 +08:00
|
|
|
/**
|
|
|
|
* Suppress high rates of output when CONFIG_SND_DEBUG is enabled.
|
|
|
|
*/
|
|
|
|
#define snd_printd_ratelimit() printk_ratelimit()
|
|
|
|
|
2008-11-07 16:37:22 +08:00
|
|
|
/**
|
|
|
|
* snd_BUG_ON - debugging check macro
|
|
|
|
* @cond: condition to evaluate
|
|
|
|
*
|
2013-03-05 06:02:59 +08:00
|
|
|
* Has the same behavior as WARN_ON when CONFIG_SND_DEBUG is set,
|
|
|
|
* otherwise just evaluates the conditional and returns the value.
|
2008-11-07 16:37:22 +08:00
|
|
|
*/
|
2013-03-05 06:02:59 +08:00
|
|
|
#define snd_BUG_ON(cond) WARN_ON((cond))
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#else /* !CONFIG_SND_DEBUG */
|
|
|
|
|
2013-01-25 17:54:07 +08:00
|
|
|
__printf(1, 2)
|
|
|
|
static inline void snd_printd(const char *format, ...) {}
|
|
|
|
__printf(2, 3)
|
|
|
|
static inline void _snd_printd(int level, const char *format, ...) {}
|
|
|
|
|
2008-11-07 04:05:21 +08:00
|
|
|
#define snd_BUG() do { } while (0)
|
2013-03-05 06:02:59 +08:00
|
|
|
|
|
|
|
#define snd_BUG_ON(condition) ({ \
|
|
|
|
int __ret_warn_on = !!(condition); \
|
|
|
|
unlikely(__ret_warn_on); \
|
|
|
|
})
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-17 01:18:59 +08:00
|
|
|
static inline bool snd_printd_ratelimit(void) { return false; }
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* CONFIG_SND_DEBUG */
|
|
|
|
|
2008-05-20 18:15:15 +08:00
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* snd_printdd - debug printk
|
|
|
|
* @format: format string
|
|
|
|
*
|
2008-04-01 21:33:22 +08:00
|
|
|
* Works like snd_printk() for debugging purposes.
|
2008-05-20 18:15:15 +08:00
|
|
|
* Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2016-11-15 05:25:33 +08:00
|
|
|
#define snd_printdd(format, ...) \
|
|
|
|
__snd_printk(2, __FILE__, __LINE__, format, ##__VA_ARGS__)
|
2005-04-17 06:20:36 +08:00
|
|
|
#else
|
2013-01-25 17:54:07 +08:00
|
|
|
__printf(1, 2)
|
|
|
|
static inline void snd_printdd(const char *format, ...) {}
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#define SNDRV_OSS_VERSION ((3<<16)|(8<<8)|(1<<4)|(0)) /* 3.8.1a */
|
|
|
|
|
|
|
|
/* for easier backward-porting */
|
2017-05-12 17:44:03 +08:00
|
|
|
#if IS_ENABLED(CONFIG_GAMEPORT)
|
2005-04-17 06:20:36 +08:00
|
|
|
#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
|
|
|
|
|
2006-11-24 22:34:06 +08:00
|
|
|
/* PCI quirk list helper */
|
|
|
|
struct snd_pci_quirk {
|
|
|
|
unsigned short subvendor; /* PCI subvendor ID */
|
|
|
|
unsigned short subdevice; /* PCI subdevice ID */
|
2009-01-31 00:27:45 +08:00
|
|
|
unsigned short subdevice_mask; /* bitmask to match */
|
2006-11-24 22:34:06 +08:00
|
|
|
int value; /* value */
|
2008-05-20 18:15:15 +08:00
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
2006-11-24 22:34:06 +08:00
|
|
|
const char *name; /* name of the device (optional) */
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2009-01-31 00:27:45 +08:00
|
|
|
#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)
|
2006-11-24 22:34:06 +08:00
|
|
|
#define SND_PCI_QUIRK_ID(vend,dev) {_SND_PCI_QUIRK_ID(vend, dev)}
|
2008-05-20 18:15:15 +08:00
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
2006-11-24 22:34:06 +08:00
|
|
|
#define SND_PCI_QUIRK(vend,dev,xname,val) \
|
|
|
|
{_SND_PCI_QUIRK_ID(vend, dev), .value = (val), .name = (xname)}
|
2009-01-31 00:27:45 +08:00
|
|
|
#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)}
|
2013-01-25 17:54:07 +08:00
|
|
|
#define snd_pci_quirk_name(q) ((q)->name)
|
2006-11-24 22:34:06 +08:00
|
|
|
#else
|
|
|
|
#define SND_PCI_QUIRK(vend,dev,xname,val) \
|
|
|
|
{_SND_PCI_QUIRK_ID(vend, dev), .value = (val)}
|
2009-01-31 00:27:45 +08:00
|
|
|
#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)}
|
2013-01-25 17:54:07 +08:00
|
|
|
#define snd_pci_quirk_name(q) ""
|
2006-11-24 22:34:06 +08:00
|
|
|
#endif
|
|
|
|
|
2014-03-01 07:41:31 +08:00
|
|
|
#ifdef CONFIG_PCI
|
2006-11-24 22:34:06 +08:00
|
|
|
const struct snd_pci_quirk *
|
|
|
|
snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
|
|
|
|
|
2010-01-14 16:16:52 +08:00
|
|
|
const struct snd_pci_quirk *
|
|
|
|
snd_pci_quirk_lookup_id(u16 vendor, u16 device,
|
|
|
|
const struct snd_pci_quirk *list);
|
2014-03-01 07:41:31 +08:00
|
|
|
#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;
|
|
|
|
}
|
2012-01-30 17:10:58 +08:00
|
|
|
#endif
|
2006-11-24 22:34:06 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* __SOUND_CORE_H */
|