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