Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef __SOUND_CORE_H |
| 2 | #define __SOUND_CORE_H |
| 3 | |
| 4 | /* |
| 5 | * Main header file for the ALSA driver |
Jaroslav Kysela | c1017a4 | 2007-10-15 09:50:19 +0200 | [diff] [blame] | 6 | * Copyright (c) 1994-2001 by Jaroslav Kysela <perex@perex.cz> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * |
| 8 | * |
| 9 | * This program is free software; you can redistribute it and/or modify |
| 10 | * it under the terms of the GNU General Public License as published by |
| 11 | * the Free Software Foundation; either version 2 of the License, or |
| 12 | * (at your option) any later version. |
| 13 | * |
| 14 | * This program is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 17 | * GNU General Public License for more details. |
| 18 | * |
| 19 | * You should have received a copy of the GNU General Public License |
| 20 | * along with this program; if not, write to the Free Software |
| 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 22 | * |
| 23 | */ |
| 24 | |
| 25 | #include <linux/sched.h> /* wake_up() */ |
Ingo Molnar | 1a60d4c | 2006-01-16 16:29:08 +0100 | [diff] [blame] | 26 | #include <linux/mutex.h> /* struct mutex */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <linux/rwsem.h> /* struct rw_semaphore */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #include <linux/pm.h> /* pm_message_t */ |
Takashi Iwai | 9d19f48 | 2006-09-06 14:27:46 +0200 | [diff] [blame] | 29 | #include <linux/device.h> |
Takashi Iwai | 5ef0346 | 2008-08-08 17:06:01 +0200 | [diff] [blame] | 30 | #include <linux/stringify.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | |
Takashi Iwai | 9004acc | 2008-01-08 18:13:27 +0100 | [diff] [blame] | 32 | /* number of supported soundcards */ |
| 33 | #ifdef CONFIG_SND_DYNAMIC_MINORS |
| 34 | #define SNDRV_CARDS 32 |
| 35 | #else |
| 36 | #define SNDRV_CARDS 8 /* don't change - minor numbers */ |
| 37 | #endif |
| 38 | |
| 39 | #define CONFIG_SND_MAJOR 116 /* standard configuration */ |
| 40 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | /* forward declarations */ |
| 42 | #ifdef CONFIG_PCI |
| 43 | struct pci_dev; |
| 44 | #endif |
Paul Gortmaker | de47725 | 2011-05-26 13:46:22 -0400 | [diff] [blame] | 45 | struct module; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | |
| 47 | /* device allocation stuff */ |
| 48 | |
| 49 | #define SNDRV_DEV_TYPE_RANGE_SIZE 0x1000 |
| 50 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 51 | typedef int __bitwise snd_device_type_t; |
| 52 | #define SNDRV_DEV_TOPLEVEL ((__force snd_device_type_t) 0) |
| 53 | #define SNDRV_DEV_CONTROL ((__force snd_device_type_t) 1) |
| 54 | #define SNDRV_DEV_LOWLEVEL_PRE ((__force snd_device_type_t) 2) |
| 55 | #define SNDRV_DEV_LOWLEVEL_NORMAL ((__force snd_device_type_t) 0x1000) |
| 56 | #define SNDRV_DEV_PCM ((__force snd_device_type_t) 0x1001) |
| 57 | #define SNDRV_DEV_RAWMIDI ((__force snd_device_type_t) 0x1002) |
| 58 | #define SNDRV_DEV_TIMER ((__force snd_device_type_t) 0x1003) |
| 59 | #define SNDRV_DEV_SEQUENCER ((__force snd_device_type_t) 0x1004) |
| 60 | #define SNDRV_DEV_HWDEP ((__force snd_device_type_t) 0x1005) |
| 61 | #define SNDRV_DEV_INFO ((__force snd_device_type_t) 0x1006) |
| 62 | #define SNDRV_DEV_BUS ((__force snd_device_type_t) 0x1007) |
| 63 | #define SNDRV_DEV_CODEC ((__force snd_device_type_t) 0x1008) |
Mark Brown | e76d8ce | 2008-07-28 19:05:35 +0100 | [diff] [blame] | 64 | #define SNDRV_DEV_JACK ((__force snd_device_type_t) 0x1009) |
Omair Mohammed Abdullah | 3eafc95 | 2011-12-23 10:36:36 +0530 | [diff] [blame^] | 65 | #define SNDRV_DEV_COMPRESS ((__force snd_device_type_t) 0x100A) |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 66 | #define SNDRV_DEV_LOWLEVEL ((__force snd_device_type_t) 0x2000) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 68 | typedef int __bitwise snd_device_state_t; |
| 69 | #define SNDRV_DEV_BUILD ((__force snd_device_state_t) 0) |
| 70 | #define SNDRV_DEV_REGISTERED ((__force snd_device_state_t) 1) |
| 71 | #define SNDRV_DEV_DISCONNECTED ((__force snd_device_state_t) 2) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 73 | typedef int __bitwise snd_device_cmd_t; |
| 74 | #define SNDRV_DEV_CMD_PRE ((__force snd_device_cmd_t) 0) |
| 75 | #define SNDRV_DEV_CMD_NORMAL ((__force snd_device_cmd_t) 1) |
| 76 | #define SNDRV_DEV_CMD_POST ((__force snd_device_cmd_t) 2) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 78 | struct snd_device; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 80 | struct snd_device_ops { |
| 81 | int (*dev_free)(struct snd_device *dev); |
| 82 | int (*dev_register)(struct snd_device *dev); |
| 83 | int (*dev_disconnect)(struct snd_device *dev); |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 84 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 86 | struct snd_device { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | struct list_head list; /* list of registered devices */ |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 88 | struct snd_card *card; /* card which holds this device */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | snd_device_state_t state; /* state of the device */ |
| 90 | snd_device_type_t type; /* device type */ |
| 91 | void *device_data; /* device structure */ |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 92 | struct snd_device_ops *ops; /* operations */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | }; |
| 94 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 95 | #define snd_device(n) list_entry(n, struct snd_device, list) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | /* main structure for soundcard */ |
| 98 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 99 | struct snd_card { |
Henrik Kretzschmar | d5750f6 | 2005-06-29 19:31:06 +0200 | [diff] [blame] | 100 | int number; /* number of soundcard (index to |
| 101 | snd_cards) */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | |
| 103 | char id[16]; /* id string of this card */ |
| 104 | char driver[16]; /* driver name */ |
| 105 | char shortname[32]; /* short name of this soundcard */ |
| 106 | char longname[80]; /* name of this soundcard */ |
| 107 | char mixername[80]; /* mixer name */ |
Takashi Iwai | ff33f23 | 2008-10-07 11:38:09 +0200 | [diff] [blame] | 108 | char components[128]; /* card components delimited with |
Henrik Kretzschmar | d5750f6 | 2005-06-29 19:31:06 +0200 | [diff] [blame] | 109 | space */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | struct module *module; /* top-level module */ |
| 111 | |
| 112 | void *private_data; /* private data for soundcard */ |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 113 | void (*private_free) (struct snd_card *card); /* callback for freeing of |
Henrik Kretzschmar | d5750f6 | 2005-06-29 19:31:06 +0200 | [diff] [blame] | 114 | private data */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | struct list_head devices; /* devices */ |
| 116 | |
| 117 | unsigned int last_numid; /* last used numeric ID */ |
| 118 | struct rw_semaphore controls_rwsem; /* controls list lock */ |
| 119 | rwlock_t ctl_files_rwlock; /* ctl_files list lock */ |
| 120 | int controls_count; /* count of all controls */ |
| 121 | int user_ctl_count; /* count of all user controls */ |
| 122 | struct list_head controls; /* all controls for this card */ |
| 123 | struct list_head ctl_files; /* active control files */ |
| 124 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 125 | struct snd_info_entry *proc_root; /* root for soundcard specific files */ |
| 126 | struct snd_info_entry *proc_id; /* the card id */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | struct proc_dir_entry *proc_root_link; /* number link to real id */ |
| 128 | |
Takashi Iwai | 118dd6b | 2009-02-23 16:35:21 +0100 | [diff] [blame] | 129 | struct list_head files_list; /* all files associated to this card */ |
Henrik Kretzschmar | d5750f6 | 2005-06-29 19:31:06 +0200 | [diff] [blame] | 130 | struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown |
| 131 | state */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | spinlock_t files_lock; /* lock the files for this card */ |
| 133 | int shutdown; /* this card is going down */ |
Takashi Iwai | c461482 | 2006-06-23 14:38:23 +0200 | [diff] [blame] | 134 | int free_on_last_close; /* free in context of file_release */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | wait_queue_head_t shutdown_sleep; |
Takashi Iwai | 7d2aae1 | 2007-01-26 12:40:31 +0100 | [diff] [blame] | 136 | struct device *dev; /* device assigned to this card */ |
Takashi Iwai | 7d2aae1 | 2007-01-26 12:40:31 +0100 | [diff] [blame] | 137 | struct device *card_dev; /* cardX object for sysfs */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | |
| 139 | #ifdef CONFIG_PM |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | unsigned int power_state; /* power state */ |
Ingo Molnar | 1a60d4c | 2006-01-16 16:29:08 +0100 | [diff] [blame] | 141 | struct mutex power_lock; /* power lock */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | wait_queue_head_t power_sleep; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | #endif |
| 144 | |
| 145 | #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 146 | struct snd_mixer_oss *mixer_oss; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | int mixer_oss_change_count; |
| 148 | #endif |
| 149 | }; |
| 150 | |
| 151 | #ifdef CONFIG_PM |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 152 | static inline void snd_power_lock(struct snd_card *card) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | { |
Ingo Molnar | 1a60d4c | 2006-01-16 16:29:08 +0100 | [diff] [blame] | 154 | mutex_lock(&card->power_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 157 | static inline void snd_power_unlock(struct snd_card *card) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | { |
Ingo Molnar | 1a60d4c | 2006-01-16 16:29:08 +0100 | [diff] [blame] | 159 | mutex_unlock(&card->power_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | } |
| 161 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 162 | static inline unsigned int snd_power_get_state(struct snd_card *card) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | { |
| 164 | return card->power_state; |
| 165 | } |
| 166 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 167 | static inline void snd_power_change_state(struct snd_card *card, unsigned int state) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | { |
| 169 | card->power_state = state; |
| 170 | wake_up(&card->power_sleep); |
| 171 | } |
Henrik Kretzschmar | d5750f6 | 2005-06-29 19:31:06 +0200 | [diff] [blame] | 172 | |
| 173 | /* init.c */ |
Takashi Iwai | cbac4b0 | 2006-03-27 12:38:07 +0200 | [diff] [blame] | 174 | int snd_power_wait(struct snd_card *card, unsigned int power_state); |
Henrik Kretzschmar | d5750f6 | 2005-06-29 19:31:06 +0200 | [diff] [blame] | 175 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | #else /* ! CONFIG_PM */ |
| 177 | |
| 178 | #define snd_power_lock(card) do { (void)(card); } while (0) |
| 179 | #define snd_power_unlock(card) do { (void)(card); } while (0) |
Linus Torvalds | 6fdb94b | 2006-04-02 14:37:36 -0700 | [diff] [blame] | 180 | static inline int snd_power_wait(struct snd_card *card, unsigned int state) { return 0; } |
Mike Frysinger | 363129e | 2010-10-16 13:24:52 -0400 | [diff] [blame] | 181 | #define snd_power_get_state(card) ({ (void)(card); SNDRV_CTL_POWER_D0; }) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | #define snd_power_change_state(card, state) do { (void)(card); } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 183 | |
| 184 | #endif /* CONFIG_PM */ |
| 185 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 186 | struct snd_minor { |
Clemens Ladisch | 2af677f | 2005-11-20 14:03:48 +0100 | [diff] [blame] | 187 | int type; /* SNDRV_DEVICE_TYPE_XXX */ |
Clemens Ladisch | 6983b72 | 2005-11-20 14:05:49 +0100 | [diff] [blame] | 188 | int card; /* card number */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | int device; /* device number */ |
Arjan van de Ven | 99ac48f | 2006-03-28 01:56:41 -0800 | [diff] [blame] | 190 | const struct file_operations *f_ops; /* file operations */ |
Clemens Ladisch | f87135f | 2005-11-20 14:06:59 +0100 | [diff] [blame] | 191 | void *private_data; /* private data for f_ops->open */ |
Greg Kroah-Hartman | d80f19f | 2006-08-07 22:19:37 -0700 | [diff] [blame] | 192 | struct device *dev; /* device for sysfs */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | }; |
| 194 | |
Takashi Iwai | 7d2aae1 | 2007-01-26 12:40:31 +0100 | [diff] [blame] | 195 | /* return a device pointer linked to each sound device as a parent */ |
| 196 | static inline struct device *snd_card_get_device_link(struct snd_card *card) |
| 197 | { |
Takashi Iwai | 7d2aae1 | 2007-01-26 12:40:31 +0100 | [diff] [blame] | 198 | return card ? card->card_dev : NULL; |
Takashi Iwai | 7d2aae1 | 2007-01-26 12:40:31 +0100 | [diff] [blame] | 199 | } |
| 200 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | /* sound.c */ |
| 202 | |
Clemens Ladisch | f190286 | 2005-10-24 17:05:03 +0200 | [diff] [blame] | 203 | extern int snd_major; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | extern int snd_ecards_limit; |
Greg Kroah-Hartman | d80f19f | 2006-08-07 22:19:37 -0700 | [diff] [blame] | 205 | extern struct class *sound_class; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | |
| 207 | void snd_request_card(int card); |
| 208 | |
Johannes Berg | 12b131c | 2006-10-05 15:05:34 +0200 | [diff] [blame] | 209 | int snd_register_device_for_dev(int type, struct snd_card *card, |
| 210 | int dev, |
| 211 | const struct file_operations *f_ops, |
| 212 | void *private_data, |
| 213 | const char *name, |
| 214 | struct device *device); |
| 215 | |
| 216 | /** |
| 217 | * snd_register_device - Register the ALSA device file for the card |
| 218 | * @type: the device type, SNDRV_DEVICE_TYPE_XXX |
| 219 | * @card: the card instance |
| 220 | * @dev: the device index |
| 221 | * @f_ops: the file operations |
| 222 | * @private_data: user pointer for f_ops->open() |
| 223 | * @name: the device file name |
| 224 | * |
| 225 | * Registers an ALSA device file for the given card. |
| 226 | * The operators have to be set in reg parameter. |
| 227 | * |
| 228 | * This function uses the card's device pointer to link to the |
| 229 | * correct &struct device. |
| 230 | * |
| 231 | * Returns zero if successful, or a negative error code on failure. |
| 232 | */ |
| 233 | static inline int snd_register_device(int type, struct snd_card *card, int dev, |
| 234 | const struct file_operations *f_ops, |
| 235 | void *private_data, |
| 236 | const char *name) |
| 237 | { |
| 238 | return snd_register_device_for_dev(type, card, dev, f_ops, |
| 239 | private_data, name, |
Takashi Iwai | c2902c8 | 2007-02-09 16:25:48 +0100 | [diff] [blame] | 240 | snd_card_get_device_link(card)); |
Johannes Berg | 12b131c | 2006-10-05 15:05:34 +0200 | [diff] [blame] | 241 | } |
| 242 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 243 | int snd_unregister_device(int type, struct snd_card *card, int dev); |
Clemens Ladisch | f87135f | 2005-11-20 14:06:59 +0100 | [diff] [blame] | 244 | void *snd_lookup_minor_data(unsigned int minor, int type); |
Takashi Iwai | 9d19f48 | 2006-09-06 14:27:46 +0200 | [diff] [blame] | 245 | int snd_add_device_sysfs_file(int type, struct snd_card *card, int dev, |
Greg Kroah-Hartman | d80f19f | 2006-08-07 22:19:37 -0700 | [diff] [blame] | 246 | struct device_attribute *attr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | |
| 248 | #ifdef CONFIG_SND_OSSEMUL |
Clemens Ladisch | 2af677f | 2005-11-20 14:03:48 +0100 | [diff] [blame] | 249 | int snd_register_oss_device(int type, struct snd_card *card, int dev, |
Arjan van de Ven | 99ac48f | 2006-03-28 01:56:41 -0800 | [diff] [blame] | 250 | const struct file_operations *f_ops, void *private_data, |
Clemens Ladisch | f87135f | 2005-11-20 14:06:59 +0100 | [diff] [blame] | 251 | const char *name); |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 252 | int snd_unregister_oss_device(int type, struct snd_card *card, int dev); |
Clemens Ladisch | f87135f | 2005-11-20 14:06:59 +0100 | [diff] [blame] | 253 | void *snd_lookup_oss_minor_data(unsigned int minor, int type); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | #endif |
| 255 | |
| 256 | int snd_minor_info_init(void); |
| 257 | int snd_minor_info_done(void); |
| 258 | |
| 259 | /* sound_oss.c */ |
| 260 | |
| 261 | #ifdef CONFIG_SND_OSSEMUL |
| 262 | int snd_minor_info_oss_init(void); |
| 263 | int snd_minor_info_oss_done(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | #else |
Pavel Machek | ad5fada | 2008-04-14 18:31:35 +0200 | [diff] [blame] | 265 | static inline int snd_minor_info_oss_init(void) { return 0; } |
| 266 | static inline int snd_minor_info_oss_done(void) { return 0; } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 267 | #endif |
| 268 | |
| 269 | /* memory.c */ |
| 270 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count); |
| 272 | int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count); |
| 273 | |
| 274 | /* init.c */ |
| 275 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 276 | extern struct snd_card *snd_cards[SNDRV_CARDS]; |
Takashi Iwai | 746df94 | 2006-05-15 19:49:05 +0200 | [diff] [blame] | 277 | int snd_card_locked(int card); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) |
| 279 | #define SND_MIXER_OSS_NOTIFY_REGISTER 0 |
| 280 | #define SND_MIXER_OSS_NOTIFY_DISCONNECT 1 |
| 281 | #define SND_MIXER_OSS_NOTIFY_FREE 2 |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 282 | extern int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int cmd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | #endif |
| 284 | |
Takashi Iwai | 53fb1e6 | 2008-12-28 16:32:08 +0100 | [diff] [blame] | 285 | int snd_card_create(int idx, const char *id, |
| 286 | struct module *module, int extra_size, |
| 287 | struct snd_card **card_ret); |
| 288 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 289 | int snd_card_disconnect(struct snd_card *card); |
| 290 | int snd_card_free(struct snd_card *card); |
Takashi Iwai | c461482 | 2006-06-23 14:38:23 +0200 | [diff] [blame] | 291 | int snd_card_free_when_closed(struct snd_card *card); |
Jaroslav Kysela | 10a8ebb | 2009-06-02 12:02:38 +0200 | [diff] [blame] | 292 | void snd_card_set_id(struct snd_card *card, const char *id); |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 293 | int snd_card_register(struct snd_card *card); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | int snd_card_info_init(void); |
| 295 | int snd_card_info_done(void); |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 296 | int snd_component_add(struct snd_card *card, const char *component); |
| 297 | int snd_card_file_add(struct snd_card *card, struct file *file); |
| 298 | int snd_card_file_remove(struct snd_card *card, struct file *file); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | |
Pavel Machek | edab938 | 2008-04-01 15:33:22 +0200 | [diff] [blame] | 300 | #define snd_card_set_dev(card, devptr) ((card)->dev = (devptr)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 301 | |
| 302 | /* device.c */ |
| 303 | |
Takashi Iwai | 512bbd6 | 2005-11-17 13:51:18 +0100 | [diff] [blame] | 304 | int snd_device_new(struct snd_card *card, snd_device_type_t type, |
| 305 | void *device_data, struct snd_device_ops *ops); |
| 306 | int snd_device_register(struct snd_card *card, void *device_data); |
| 307 | int snd_device_register_all(struct snd_card *card); |
| 308 | int snd_device_disconnect(struct snd_card *card, void *device_data); |
| 309 | int snd_device_disconnect_all(struct snd_card *card); |
| 310 | int snd_device_free(struct snd_card *card, void *device_data); |
| 311 | int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 312 | |
| 313 | /* isadma.c */ |
| 314 | |
Al Viro | 276bd31 | 2005-08-23 22:45:06 +0100 | [diff] [blame] | 315 | #ifdef CONFIG_ISA_DMA_API |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 316 | #define DMA_MODE_NO_ENABLE 0x0100 |
| 317 | |
| 318 | void snd_dma_program(unsigned long dma, unsigned long addr, unsigned int size, unsigned short mode); |
| 319 | void snd_dma_disable(unsigned long dma); |
| 320 | unsigned int snd_dma_pointer(unsigned long dma, unsigned int size); |
Al Viro | 276bd31 | 2005-08-23 22:45:06 +0100 | [diff] [blame] | 321 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | |
| 323 | /* misc.c */ |
Takashi Iwai | b709e57 | 2005-10-11 17:28:58 +0200 | [diff] [blame] | 324 | struct resource; |
Takashi Iwai | b1d5776 | 2005-10-10 11:56:31 +0200 | [diff] [blame] | 325 | void release_and_free_resource(struct resource *res); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | /* --- */ |
| 328 | |
Takashi Iwai | 36ce99c | 2009-08-27 16:45:07 +0200 | [diff] [blame] | 329 | #if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK) |
Joe Perches | b9075fa | 2011-10-31 17:11:33 -0700 | [diff] [blame] | 330 | __printf(4, 5) |
Takashi Iwai | 36ce99c | 2009-08-27 16:45:07 +0200 | [diff] [blame] | 331 | void __snd_printk(unsigned int level, const char *file, int line, |
Joe Perches | b9075fa | 2011-10-31 17:11:33 -0700 | [diff] [blame] | 332 | const char *format, ...); |
Takashi Iwai | 36ce99c | 2009-08-27 16:45:07 +0200 | [diff] [blame] | 333 | #else |
| 334 | #define __snd_printk(level, file, line, format, args...) \ |
Takashi Iwai | cf0baf1 | 2009-08-28 07:22:05 +0200 | [diff] [blame] | 335 | printk(format, ##args) |
Takashi Iwai | 36ce99c | 2009-08-27 16:45:07 +0200 | [diff] [blame] | 336 | #endif |
| 337 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | /** |
| 339 | * snd_printk - printk wrapper |
| 340 | * @fmt: format string |
| 341 | * |
Takashi Iwai | f66fced | 2008-11-07 09:37:22 +0100 | [diff] [blame] | 342 | * Works like printk() but prints the file and the line of the caller |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | * when configured with CONFIG_SND_VERBOSE_PRINTK. |
| 344 | */ |
| 345 | #define snd_printk(fmt, args...) \ |
Takashi Iwai | 36ce99c | 2009-08-27 16:45:07 +0200 | [diff] [blame] | 346 | __snd_printk(0, __FILE__, __LINE__, fmt, ##args) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 347 | |
| 348 | #ifdef CONFIG_SND_DEBUG |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 349 | /** |
| 350 | * snd_printd - debug printk |
Martin Waitz | 0863afb | 2006-01-09 20:53:55 -0800 | [diff] [blame] | 351 | * @fmt: format string |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | * |
Pavel Machek | edab938 | 2008-04-01 15:33:22 +0200 | [diff] [blame] | 353 | * Works like snd_printk() for debugging purposes. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 354 | * Ignored when CONFIG_SND_DEBUG is not set. |
| 355 | */ |
| 356 | #define snd_printd(fmt, args...) \ |
Takashi Iwai | 36ce99c | 2009-08-27 16:45:07 +0200 | [diff] [blame] | 357 | __snd_printk(1, __FILE__, __LINE__, fmt, ##args) |
Takashi Iwai | 7c22f1a | 2005-10-10 11:46:31 +0200 | [diff] [blame] | 358 | |
Takashi Iwai | f66fced | 2008-11-07 09:37:22 +0100 | [diff] [blame] | 359 | /** |
| 360 | * snd_BUG - give a BUG warning message and stack trace |
| 361 | * |
| 362 | * Calls WARN() if CONFIG_SND_DEBUG is set. |
| 363 | * Ignored when CONFIG_SND_DEBUG is not set. |
| 364 | */ |
Takashi Iwai | bdbecf5 | 2008-08-08 17:18:08 +0200 | [diff] [blame] | 365 | #define snd_BUG() WARN(1, "BUG?\n") |
Takashi Iwai | f66fced | 2008-11-07 09:37:22 +0100 | [diff] [blame] | 366 | |
| 367 | /** |
| 368 | * snd_BUG_ON - debugging check macro |
| 369 | * @cond: condition to evaluate |
| 370 | * |
| 371 | * When CONFIG_SND_DEBUG is set, this macro evaluates the given condition, |
| 372 | * and call WARN() and returns the value if it's non-zero. |
| 373 | * |
| 374 | * When CONFIG_SND_DEBUG is not set, this just returns zero, and the given |
| 375 | * condition is ignored. |
| 376 | * |
| 377 | * NOTE: the argument won't be evaluated at all when CONFIG_SND_DEBUG=n. |
| 378 | * Thus, don't put any statement that influences on the code behavior, |
| 379 | * such as pre/post increment, to the argument of this macro. |
| 380 | * If you want to evaluate and give a warning, use standard WARN_ON(). |
| 381 | */ |
Takashi Iwai | 5ef0346 | 2008-08-08 17:06:01 +0200 | [diff] [blame] | 382 | #define snd_BUG_ON(cond) WARN((cond), "BUG? (%s)\n", __stringify(cond)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | |
| 384 | #else /* !CONFIG_SND_DEBUG */ |
| 385 | |
Andrew Morton | fcef783 | 2008-11-06 12:05:21 -0800 | [diff] [blame] | 386 | #define snd_printd(fmt, args...) do { } while (0) |
| 387 | #define snd_BUG() do { } while (0) |
Takashi Iwai | 945eed0 | 2008-11-07 09:08:15 +0100 | [diff] [blame] | 388 | static inline int __snd_bug_on(int cond) |
Andrew Morton | fcef783 | 2008-11-06 12:05:21 -0800 | [diff] [blame] | 389 | { |
| 390 | return 0; |
| 391 | } |
Takashi Iwai | 945eed0 | 2008-11-07 09:08:15 +0100 | [diff] [blame] | 392 | #define snd_BUG_ON(cond) __snd_bug_on(0 && (cond)) /* always false */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 393 | |
| 394 | #endif /* CONFIG_SND_DEBUG */ |
| 395 | |
Takashi Iwai | 62cf872 | 2008-05-20 12:15:15 +0200 | [diff] [blame] | 396 | #ifdef CONFIG_SND_DEBUG_VERBOSE |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | /** |
| 398 | * snd_printdd - debug printk |
| 399 | * @format: format string |
| 400 | * |
Pavel Machek | edab938 | 2008-04-01 15:33:22 +0200 | [diff] [blame] | 401 | * Works like snd_printk() for debugging purposes. |
Takashi Iwai | 62cf872 | 2008-05-20 12:15:15 +0200 | [diff] [blame] | 402 | * Ignored when CONFIG_SND_DEBUG_VERBOSE is not set. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 403 | */ |
Takashi Iwai | 36ce99c | 2009-08-27 16:45:07 +0200 | [diff] [blame] | 404 | #define snd_printdd(format, args...) \ |
| 405 | __snd_printk(2, __FILE__, __LINE__, format, ##args) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | #else |
Takashi Iwai | 36ce99c | 2009-08-27 16:45:07 +0200 | [diff] [blame] | 407 | #define snd_printdd(format, args...) do { } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 408 | #endif |
| 409 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 410 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 411 | #define SNDRV_OSS_VERSION ((3<<16)|(8<<8)|(1<<4)|(0)) /* 3.8.1a */ |
| 412 | |
| 413 | /* for easier backward-porting */ |
| 414 | #if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | #define gameport_set_dev_parent(gp,xdev) ((gp)->dev.parent = (xdev)) |
| 416 | #define gameport_set_port_data(gp,r) ((gp)->port_data = (r)) |
| 417 | #define gameport_get_port_data(gp) (gp)->port_data |
| 418 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | |
Takashi Iwai | d9ea472 | 2006-11-24 15:34:06 +0100 | [diff] [blame] | 420 | /* PCI quirk list helper */ |
| 421 | struct snd_pci_quirk { |
| 422 | unsigned short subvendor; /* PCI subvendor ID */ |
| 423 | unsigned short subdevice; /* PCI subdevice ID */ |
Takashi Iwai | 8bd4bb7 | 2009-01-30 17:27:45 +0100 | [diff] [blame] | 424 | unsigned short subdevice_mask; /* bitmask to match */ |
Takashi Iwai | d9ea472 | 2006-11-24 15:34:06 +0100 | [diff] [blame] | 425 | int value; /* value */ |
Takashi Iwai | 62cf872 | 2008-05-20 12:15:15 +0200 | [diff] [blame] | 426 | #ifdef CONFIG_SND_DEBUG_VERBOSE |
Takashi Iwai | d9ea472 | 2006-11-24 15:34:06 +0100 | [diff] [blame] | 427 | const char *name; /* name of the device (optional) */ |
| 428 | #endif |
| 429 | }; |
| 430 | |
Takashi Iwai | 8bd4bb7 | 2009-01-30 17:27:45 +0100 | [diff] [blame] | 431 | #define _SND_PCI_QUIRK_ID_MASK(vend, mask, dev) \ |
| 432 | .subvendor = (vend), .subdevice = (dev), .subdevice_mask = (mask) |
| 433 | #define _SND_PCI_QUIRK_ID(vend, dev) \ |
| 434 | _SND_PCI_QUIRK_ID_MASK(vend, 0xffff, dev) |
Takashi Iwai | d9ea472 | 2006-11-24 15:34:06 +0100 | [diff] [blame] | 435 | #define SND_PCI_QUIRK_ID(vend,dev) {_SND_PCI_QUIRK_ID(vend, dev)} |
Takashi Iwai | 62cf872 | 2008-05-20 12:15:15 +0200 | [diff] [blame] | 436 | #ifdef CONFIG_SND_DEBUG_VERBOSE |
Takashi Iwai | d9ea472 | 2006-11-24 15:34:06 +0100 | [diff] [blame] | 437 | #define SND_PCI_QUIRK(vend,dev,xname,val) \ |
| 438 | {_SND_PCI_QUIRK_ID(vend, dev), .value = (val), .name = (xname)} |
Takashi Iwai | 8bd4bb7 | 2009-01-30 17:27:45 +0100 | [diff] [blame] | 439 | #define SND_PCI_QUIRK_VENDOR(vend, xname, val) \ |
| 440 | {_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val), .name = (xname)} |
| 441 | #define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val) \ |
| 442 | {_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), \ |
| 443 | .value = (val), .name = (xname)} |
Takashi Iwai | d9ea472 | 2006-11-24 15:34:06 +0100 | [diff] [blame] | 444 | #else |
| 445 | #define SND_PCI_QUIRK(vend,dev,xname,val) \ |
| 446 | {_SND_PCI_QUIRK_ID(vend, dev), .value = (val)} |
Takashi Iwai | 8bd4bb7 | 2009-01-30 17:27:45 +0100 | [diff] [blame] | 447 | #define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val) \ |
| 448 | {_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), .value = (val)} |
| 449 | #define SND_PCI_QUIRK_VENDOR(vend, xname, val) \ |
| 450 | {_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val)} |
Takashi Iwai | d9ea472 | 2006-11-24 15:34:06 +0100 | [diff] [blame] | 451 | #endif |
| 452 | |
| 453 | const struct snd_pci_quirk * |
| 454 | snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list); |
| 455 | |
Takashi Iwai | d145827 | 2010-01-14 09:16:52 +0100 | [diff] [blame] | 456 | const struct snd_pci_quirk * |
| 457 | snd_pci_quirk_lookup_id(u16 vendor, u16 device, |
| 458 | const struct snd_pci_quirk *list); |
Takashi Iwai | d9ea472 | 2006-11-24 15:34:06 +0100 | [diff] [blame] | 459 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | #endif /* __SOUND_CORE_H */ |