1 /* SPDX-License-Identifier: GPL-2.0-or-later * <<
2 /* 1 /*
3 * Advanced Linux Sound Architecture - ALSA - 2 * Advanced Linux Sound Architecture - ALSA - Driver
4 * Copyright (c) 1994-2003 by Jaroslav Kysela !! 3 * Copyright (c) 1994-2003 by Jaroslav Kysela <perex@suse.cz>,
5 * Abramo Bagnara 4 * Abramo Bagnara <abramo@alsa-project.org>
>> 5 *
>> 6 *
>> 7 * This program is free software; you can redistribute it and/or modify
>> 8 * it under the terms of the GNU General Public License as published by
>> 9 * the Free Software Foundation; either version 2 of the License, or
>> 10 * (at your option) any later version.
>> 11 *
>> 12 * This program is distributed in the hope that it will be useful,
>> 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> 15 * GNU General Public License for more details.
>> 16 *
>> 17 * You should have received a copy of the GNU General Public License
>> 18 * along with this program; if not, write to the Free Software
>> 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>> 20 *
6 */ 21 */
>> 22
7 #ifndef __SOUND_ASOUND_H 23 #ifndef __SOUND_ASOUND_H
8 #define __SOUND_ASOUND_H 24 #define __SOUND_ASOUND_H
9 25
>> 26 #if defined(LINUX) || defined(__LINUX__) || defined(__linux__)
>> 27
10 #include <linux/ioctl.h> 28 #include <linux/ioctl.h>
>> 29
>> 30 #ifdef __KERNEL__
>> 31
>> 32 #include <linux/types.h>
11 #include <linux/time.h> 33 #include <linux/time.h>
12 #include <asm/byteorder.h> 34 #include <asm/byteorder.h>
13 35
14 #ifdef __LITTLE_ENDIAN !! 36 #if __LITTLE_ENDIAN == 1234
15 #define SNDRV_LITTLE_ENDIAN 37 #define SNDRV_LITTLE_ENDIAN
>> 38 #elif __BIG_ENDIAN == 4321
>> 39 #define SNDRV_BIG_ENDIAN
16 #else 40 #else
17 #ifdef __BIG_ENDIAN !! 41 #error "Unsupported endian..."
>> 42 #endif
>> 43
>> 44 #else /* !__KERNEL__ */
>> 45
>> 46 #include <endian.h>
>> 47 #if __BYTE_ORDER == __LITTLE_ENDIAN
>> 48 #define SNDRV_LITTLE_ENDIAN
>> 49 #elif __BYTE_ORDER == __BIG_ENDIAN
18 #define SNDRV_BIG_ENDIAN 50 #define SNDRV_BIG_ENDIAN
19 #else 51 #else
20 #error "Unsupported endian..." 52 #error "Unsupported endian..."
21 #endif 53 #endif
>> 54
>> 55 #endif /* __KERNEL **/
>> 56
>> 57 #endif /* LINUX */
>> 58
>> 59 #ifndef __KERNEL__
>> 60 #include <sys/time.h>
>> 61 #include <sys/types.h>
22 #endif 62 #endif
23 63
24 #include <uapi/sound/asound.h> !! 64 /*
>> 65 * protocol version
>> 66 */
>> 67
>> 68 #define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)|((minor)<<8)|(subminor))
>> 69 #define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff)
>> 70 #define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff)
>> 71 #define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff)
>> 72 #define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) \
>> 73 (SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) || \
>> 74 (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && \
>> 75 SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion)))
>> 76
>> 77 /****************************************************************************
>> 78 * *
>> 79 * Digital audio interface *
>> 80 * *
>> 81 ****************************************************************************/
>> 82
>> 83 struct sndrv_aes_iec958 {
>> 84 unsigned char status[24]; /* AES/IEC958 channel status bits */
>> 85 unsigned char subcode[147]; /* AES/IEC958 subcode bits */
>> 86 unsigned char pad; /* nothing */
>> 87 unsigned char dig_subframe[4]; /* AES/IEC958 subframe bits */
>> 88 };
>> 89
>> 90 /****************************************************************************
>> 91 * *
>> 92 * Section for driver hardware dependent interface - /dev/snd/hw? *
>> 93 * *
>> 94 ****************************************************************************/
>> 95
>> 96 #define SNDRV_HWDEP_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1)
>> 97
>> 98 enum sndrv_hwdep_iface {
>> 99 SNDRV_HWDEP_IFACE_OPL2 = 0,
>> 100 SNDRV_HWDEP_IFACE_OPL3,
>> 101 SNDRV_HWDEP_IFACE_OPL4,
>> 102 SNDRV_HWDEP_IFACE_SB16CSP, /* Creative Signal Processor */
>> 103 SNDRV_HWDEP_IFACE_EMU10K1, /* FX8010 processor in EMU10K1 chip */
>> 104 SNDRV_HWDEP_IFACE_YSS225, /* Yamaha FX processor */
>> 105 SNDRV_HWDEP_IFACE_ICS2115, /* Wavetable synth */
>> 106 SNDRV_HWDEP_IFACE_SSCAPE, /* Ensoniq SoundScape ISA card (MC68EC000) */
>> 107 SNDRV_HWDEP_IFACE_VX, /* Digigram VX cards */
>> 108 SNDRV_HWDEP_IFACE_MIXART, /* Digigram miXart cards */
>> 109 SNDRV_HWDEP_IFACE_USX2Y, /* Tascam US122, US224 & US428 usb */
>> 110
>> 111 /* Don't forget to change the following: */
>> 112 SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_USX2Y,
>> 113 };
>> 114
>> 115 struct sndrv_hwdep_info {
>> 116 unsigned int device; /* WR: device number */
>> 117 int card; /* R: card number */
>> 118 unsigned char id[64]; /* ID (user selectable) */
>> 119 unsigned char name[80]; /* hwdep name */
>> 120 enum sndrv_hwdep_iface iface; /* hwdep interface */
>> 121 unsigned char reserved[64]; /* reserved for future */
>> 122 };
>> 123
>> 124 /* generic DSP loader */
>> 125 struct sndrv_hwdep_dsp_status {
>> 126 unsigned int version; /* R: driver-specific version */
>> 127 unsigned char id[32]; /* R: driver-specific ID string */
>> 128 unsigned int num_dsps; /* R: number of DSP images to transfer */
>> 129 unsigned int dsp_loaded; /* R: bit flags indicating the loaded DSPs */
>> 130 unsigned int chip_ready; /* R: 1 = initialization finished */
>> 131 unsigned char reserved[16]; /* reserved for future use */
>> 132 };
>> 133
>> 134 struct sndrv_hwdep_dsp_image {
>> 135 unsigned int index; /* W: DSP index */
>> 136 unsigned char name[64]; /* W: ID (e.g. file name) */
>> 137 unsigned char *image; /* W: binary image */
>> 138 size_t length; /* W: size of image in bytes */
>> 139 unsigned long driver_data; /* W: driver-specific data */
>> 140 };
>> 141
>> 142 enum {
>> 143 SNDRV_HWDEP_IOCTL_PVERSION = _IOR ('H', 0x00, int),
>> 144 SNDRV_HWDEP_IOCTL_INFO = _IOR ('H', 0x01, struct sndrv_hwdep_info),
>> 145 SNDRV_HWDEP_IOCTL_DSP_STATUS = _IOR('H', 0x02, struct sndrv_hwdep_dsp_status),
>> 146 SNDRV_HWDEP_IOCTL_DSP_LOAD = _IOW('H', 0x03, struct sndrv_hwdep_dsp_image)
>> 147 };
>> 148
>> 149 /*****************************************************************************
>> 150 * *
>> 151 * Digital Audio (PCM) interface - /dev/snd/pcm?? *
>> 152 * *
>> 153 *****************************************************************************/
>> 154
>> 155 #define SNDRV_PCM_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 5)
>> 156
>> 157 typedef unsigned long sndrv_pcm_uframes_t;
>> 158 typedef long sndrv_pcm_sframes_t;
>> 159
>> 160 enum sndrv_pcm_class {
>> 161 SNDRV_PCM_CLASS_GENERIC = 0, /* standard mono or stereo device */
>> 162 SNDRV_PCM_CLASS_MULTI, /* multichannel device */
>> 163 SNDRV_PCM_CLASS_MODEM, /* software modem class */
>> 164 SNDRV_PCM_CLASS_DIGITIZER, /* digitizer class */
>> 165 /* Don't forget to change the following: */
>> 166 SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER,
>> 167 };
>> 168
>> 169 enum sndrv_pcm_subclass {
>> 170 SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, /* mono or stereo subdevices are mixed together */
>> 171 SNDRV_PCM_SUBCLASS_MULTI_MIX, /* multichannel subdevices are mixed together */
>> 172 /* Don't forget to change the following: */
>> 173 SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX,
>> 174 };
>> 175
>> 176 enum sndrv_pcm_stream {
>> 177 SNDRV_PCM_STREAM_PLAYBACK = 0,
>> 178 SNDRV_PCM_STREAM_CAPTURE,
>> 179 SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE,
>> 180 };
>> 181
>> 182 enum sndrv_pcm_access {
>> 183 SNDRV_PCM_ACCESS_MMAP_INTERLEAVED = 0, /* interleaved mmap */
>> 184 SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED, /* noninterleaved mmap */
>> 185 SNDRV_PCM_ACCESS_MMAP_COMPLEX, /* complex mmap */
>> 186 SNDRV_PCM_ACCESS_RW_INTERLEAVED, /* readi/writei */
>> 187 SNDRV_PCM_ACCESS_RW_NONINTERLEAVED, /* readn/writen */
>> 188 SNDRV_PCM_ACCESS_LAST = SNDRV_PCM_ACCESS_RW_NONINTERLEAVED,
>> 189 };
>> 190
>> 191 enum sndrv_pcm_format {
>> 192 SNDRV_PCM_FORMAT_S8 = 0,
>> 193 SNDRV_PCM_FORMAT_U8,
>> 194 SNDRV_PCM_FORMAT_S16_LE,
>> 195 SNDRV_PCM_FORMAT_S16_BE,
>> 196 SNDRV_PCM_FORMAT_U16_LE,
>> 197 SNDRV_PCM_FORMAT_U16_BE,
>> 198 SNDRV_PCM_FORMAT_S24_LE, /* low three bytes */
>> 199 SNDRV_PCM_FORMAT_S24_BE, /* low three bytes */
>> 200 SNDRV_PCM_FORMAT_U24_LE, /* low three bytes */
>> 201 SNDRV_PCM_FORMAT_U24_BE, /* low three bytes */
>> 202 SNDRV_PCM_FORMAT_S32_LE,
>> 203 SNDRV_PCM_FORMAT_S32_BE,
>> 204 SNDRV_PCM_FORMAT_U32_LE,
>> 205 SNDRV_PCM_FORMAT_U32_BE,
>> 206 SNDRV_PCM_FORMAT_FLOAT_LE, /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */
>> 207 SNDRV_PCM_FORMAT_FLOAT_BE, /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */
>> 208 SNDRV_PCM_FORMAT_FLOAT64_LE, /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */
>> 209 SNDRV_PCM_FORMAT_FLOAT64_BE, /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */
>> 210 SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE, /* IEC-958 subframe, Little Endian */
>> 211 SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE, /* IEC-958 subframe, Big Endian */
>> 212 SNDRV_PCM_FORMAT_MU_LAW,
>> 213 SNDRV_PCM_FORMAT_A_LAW,
>> 214 SNDRV_PCM_FORMAT_IMA_ADPCM,
>> 215 SNDRV_PCM_FORMAT_MPEG,
>> 216 SNDRV_PCM_FORMAT_GSM,
>> 217 SNDRV_PCM_FORMAT_SPECIAL = 31,
>> 218 SNDRV_PCM_FORMAT_S24_3LE = 32, /* in three bytes */
>> 219 SNDRV_PCM_FORMAT_S24_3BE, /* in three bytes */
>> 220 SNDRV_PCM_FORMAT_U24_3LE, /* in three bytes */
>> 221 SNDRV_PCM_FORMAT_U24_3BE, /* in three bytes */
>> 222 SNDRV_PCM_FORMAT_S20_3LE, /* in three bytes */
>> 223 SNDRV_PCM_FORMAT_S20_3BE, /* in three bytes */
>> 224 SNDRV_PCM_FORMAT_U20_3LE, /* in three bytes */
>> 225 SNDRV_PCM_FORMAT_U20_3BE, /* in three bytes */
>> 226 SNDRV_PCM_FORMAT_S18_3LE, /* in three bytes */
>> 227 SNDRV_PCM_FORMAT_S18_3BE, /* in three bytes */
>> 228 SNDRV_PCM_FORMAT_U18_3LE, /* in three bytes */
>> 229 SNDRV_PCM_FORMAT_U18_3BE, /* in three bytes */
>> 230 SNDRV_PCM_FORMAT_LAST = SNDRV_PCM_FORMAT_U18_3BE,
>> 231
>> 232 #ifdef SNDRV_LITTLE_ENDIAN
>> 233 SNDRV_PCM_FORMAT_S16 = SNDRV_PCM_FORMAT_S16_LE,
>> 234 SNDRV_PCM_FORMAT_U16 = SNDRV_PCM_FORMAT_U16_LE,
>> 235 SNDRV_PCM_FORMAT_S24 = SNDRV_PCM_FORMAT_S24_LE,
>> 236 SNDRV_PCM_FORMAT_U24 = SNDRV_PCM_FORMAT_U24_LE,
>> 237 SNDRV_PCM_FORMAT_S32 = SNDRV_PCM_FORMAT_S32_LE,
>> 238 SNDRV_PCM_FORMAT_U32 = SNDRV_PCM_FORMAT_U32_LE,
>> 239 SNDRV_PCM_FORMAT_FLOAT = SNDRV_PCM_FORMAT_FLOAT_LE,
>> 240 SNDRV_PCM_FORMAT_FLOAT64 = SNDRV_PCM_FORMAT_FLOAT64_LE,
>> 241 SNDRV_PCM_FORMAT_IEC958_SUBFRAME = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE,
>> 242 #endif
>> 243 #ifdef SNDRV_BIG_ENDIAN
>> 244 SNDRV_PCM_FORMAT_S16 = SNDRV_PCM_FORMAT_S16_BE,
>> 245 SNDRV_PCM_FORMAT_U16 = SNDRV_PCM_FORMAT_U16_BE,
>> 246 SNDRV_PCM_FORMAT_S24 = SNDRV_PCM_FORMAT_S24_BE,
>> 247 SNDRV_PCM_FORMAT_U24 = SNDRV_PCM_FORMAT_U24_BE,
>> 248 SNDRV_PCM_FORMAT_S32 = SNDRV_PCM_FORMAT_S32_BE,
>> 249 SNDRV_PCM_FORMAT_U32 = SNDRV_PCM_FORMAT_U32_BE,
>> 250 SNDRV_PCM_FORMAT_FLOAT = SNDRV_PCM_FORMAT_FLOAT_BE,
>> 251 SNDRV_PCM_FORMAT_FLOAT64 = SNDRV_PCM_FORMAT_FLOAT64_BE,
>> 252 SNDRV_PCM_FORMAT_IEC958_SUBFRAME = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE,
>> 253 #endif
>> 254 };
>> 255
>> 256 enum sndrv_pcm_subformat {
>> 257 SNDRV_PCM_SUBFORMAT_STD = 0,
>> 258 SNDRV_PCM_SUBFORMAT_LAST = SNDRV_PCM_SUBFORMAT_STD,
>> 259 };
>> 260
>> 261 #define SNDRV_PCM_INFO_MMAP 0x00000001 /* hardware supports mmap */
>> 262 #define SNDRV_PCM_INFO_MMAP_VALID 0x00000002 /* period data are valid during transfer */
>> 263 #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */
>> 264 #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */
>> 265 #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */
>> 266 #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */
>> 267 #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */
>> 268 #define SNDRV_PCM_INFO_BLOCK_TRANSFER 0x00010000 /* hardware transfer block of samples */
>> 269 #define SNDRV_PCM_INFO_OVERRANGE 0x00020000 /* hardware supports ADC (capture) overrange detection */
>> 270 #define SNDRV_PCM_INFO_RESUME 0x00040000 /* hardware supports stream resume after suspend */
>> 271 #define SNDRV_PCM_INFO_PAUSE 0x00080000 /* pause ioctl is supported */
>> 272 #define SNDRV_PCM_INFO_HALF_DUPLEX 0x00100000 /* only half duplex */
>> 273 #define SNDRV_PCM_INFO_JOINT_DUPLEX 0x00200000 /* playback and capture stream are somewhat correlated */
>> 274 #define SNDRV_PCM_INFO_SYNC_START 0x00400000 /* pcm support some kind of sync go */
>> 275
>> 276 enum sndrv_pcm_state {
>> 277 SNDRV_PCM_STATE_OPEN = 0, /* stream is open */
>> 278 SNDRV_PCM_STATE_SETUP, /* stream has a setup */
>> 279 SNDRV_PCM_STATE_PREPARED, /* stream is ready to start */
>> 280 SNDRV_PCM_STATE_RUNNING, /* stream is running */
>> 281 SNDRV_PCM_STATE_XRUN, /* stream reached an xrun */
>> 282 SNDRV_PCM_STATE_DRAINING, /* stream is draining */
>> 283 SNDRV_PCM_STATE_PAUSED, /* stream is paused */
>> 284 SNDRV_PCM_STATE_SUSPENDED, /* hardware is suspended */
>> 285 SNDRV_PCM_STATE_LAST = SNDRV_PCM_STATE_SUSPENDED,
>> 286 };
>> 287
>> 288 enum {
>> 289 SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000,
>> 290 SNDRV_PCM_MMAP_OFFSET_STATUS = 0x80000000,
>> 291 SNDRV_PCM_MMAP_OFFSET_CONTROL = 0x81000000,
>> 292 };
>> 293
>> 294 union sndrv_pcm_sync_id {
>> 295 unsigned char id[16];
>> 296 unsigned short id16[8];
>> 297 unsigned int id32[4];
>> 298 };
>> 299
>> 300 struct sndrv_pcm_info {
>> 301 unsigned int device; /* RO/WR (control): device number */
>> 302 unsigned int subdevice; /* RO/WR (control): subdevice number */
>> 303 enum sndrv_pcm_stream stream; /* RO/WR (control): stream number */
>> 304 int card; /* R: card number */
>> 305 unsigned char id[64]; /* ID (user selectable) */
>> 306 unsigned char name[80]; /* name of this device */
>> 307 unsigned char subname[32]; /* subdevice name */
>> 308 enum sndrv_pcm_class dev_class; /* SNDRV_PCM_CLASS_* */
>> 309 enum sndrv_pcm_subclass dev_subclass; /* SNDRV_PCM_SUBCLASS_* */
>> 310 unsigned int subdevices_count;
>> 311 unsigned int subdevices_avail;
>> 312 union sndrv_pcm_sync_id sync; /* hardware synchronization ID */
>> 313 unsigned char reserved[64]; /* reserved for future... */
>> 314 };
>> 315
>> 316 enum sndrv_pcm_hw_param {
>> 317 SNDRV_PCM_HW_PARAM_ACCESS = 0, /* Access type */
>> 318 SNDRV_PCM_HW_PARAM_FIRST_MASK = SNDRV_PCM_HW_PARAM_ACCESS,
>> 319 SNDRV_PCM_HW_PARAM_FORMAT, /* Format */
>> 320 SNDRV_PCM_HW_PARAM_SUBFORMAT, /* Subformat */
>> 321 SNDRV_PCM_HW_PARAM_LAST_MASK = SNDRV_PCM_HW_PARAM_SUBFORMAT,
>> 322
>> 323 SNDRV_PCM_HW_PARAM_SAMPLE_BITS = 8, /* Bits per sample */
>> 324 SNDRV_PCM_HW_PARAM_FIRST_INTERVAL = SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
>> 325 SNDRV_PCM_HW_PARAM_FRAME_BITS, /* Bits per frame */
>> 326 SNDRV_PCM_HW_PARAM_CHANNELS, /* Channels */
>> 327 SNDRV_PCM_HW_PARAM_RATE, /* Approx rate */
>> 328 SNDRV_PCM_HW_PARAM_PERIOD_TIME, /* Approx distance between interrupts
>> 329 in us */
>> 330 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, /* Approx frames between interrupts */
>> 331 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, /* Approx bytes between interrupts */
>> 332 SNDRV_PCM_HW_PARAM_PERIODS, /* Approx interrupts per buffer */
>> 333 SNDRV_PCM_HW_PARAM_BUFFER_TIME, /* Approx duration of buffer in us */
>> 334 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, /* Size of buffer in frames */
>> 335 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, /* Size of buffer in bytes */
>> 336 SNDRV_PCM_HW_PARAM_TICK_TIME, /* Approx tick duration in us */
>> 337 SNDRV_PCM_HW_PARAM_LAST_INTERVAL = SNDRV_PCM_HW_PARAM_TICK_TIME
>> 338 };
>> 339
>> 340 #define SNDRV_PCM_HW_PARAMS_RUNTIME (1<<0)
>> 341
>> 342 struct sndrv_interval {
>> 343 unsigned int min, max;
>> 344 unsigned int openmin:1,
>> 345 openmax:1,
>> 346 integer:1,
>> 347 empty:1;
>> 348 };
>> 349
>> 350 #define SNDRV_MASK_MAX 256
>> 351
>> 352 struct sndrv_mask {
>> 353 u_int32_t bits[(SNDRV_MASK_MAX+31)/32];
>> 354 };
>> 355
>> 356 struct sndrv_pcm_hw_params {
>> 357 unsigned int flags;
>> 358 struct sndrv_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
>> 359 SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
>> 360 struct sndrv_mask mres[5]; /* reserved masks */
>> 361 struct sndrv_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
>> 362 SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
>> 363 struct sndrv_interval ires[9]; /* reserved intervals */
>> 364 unsigned int rmask; /* W: requested masks */
>> 365 unsigned int cmask; /* R: changed masks */
>> 366 unsigned int info; /* R: Info flags for returned setup */
>> 367 unsigned int msbits; /* R: used most significant bits */
>> 368 unsigned int rate_num; /* R: rate numerator */
>> 369 unsigned int rate_den; /* R: rate denominator */
>> 370 sndrv_pcm_uframes_t fifo_size; /* R: chip FIFO size in frames */
>> 371 unsigned char reserved[64]; /* reserved for future */
>> 372 };
>> 373
>> 374 enum sndrv_pcm_tstamp {
>> 375 SNDRV_PCM_TSTAMP_NONE = 0,
>> 376 SNDRV_PCM_TSTAMP_MMAP,
>> 377 SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_MMAP,
>> 378 };
>> 379
>> 380 struct sndrv_pcm_sw_params {
>> 381 enum sndrv_pcm_tstamp tstamp_mode; /* timestamp mode */
>> 382 unsigned int period_step;
>> 383 unsigned int sleep_min; /* min ticks to sleep */
>> 384 sndrv_pcm_uframes_t avail_min; /* min avail frames for wakeup */
>> 385 sndrv_pcm_uframes_t xfer_align; /* xfer size need to be a multiple */
>> 386 sndrv_pcm_uframes_t start_threshold; /* min hw_avail frames for automatic start */
>> 387 sndrv_pcm_uframes_t stop_threshold; /* min avail frames for automatic stop */
>> 388 sndrv_pcm_uframes_t silence_threshold; /* min distance from noise for silence filling */
>> 389 sndrv_pcm_uframes_t silence_size; /* silence block size */
>> 390 sndrv_pcm_uframes_t boundary; /* pointers wrap point */
>> 391 unsigned char reserved[64]; /* reserved for future */
>> 392 };
>> 393
>> 394 struct sndrv_pcm_channel_info {
>> 395 unsigned int channel;
>> 396 off_t offset; /* mmap offset */
>> 397 unsigned int first; /* offset to first sample in bits */
>> 398 unsigned int step; /* samples distance in bits */
>> 399 };
>> 400
>> 401 struct sndrv_pcm_status {
>> 402 enum sndrv_pcm_state state; /* stream state */
>> 403 struct timespec trigger_tstamp; /* time when stream was started/stopped/paused */
>> 404 struct timespec tstamp; /* reference timestamp */
>> 405 sndrv_pcm_uframes_t appl_ptr; /* appl ptr */
>> 406 sndrv_pcm_uframes_t hw_ptr; /* hw ptr */
>> 407 sndrv_pcm_sframes_t delay; /* current delay in frames */
>> 408 sndrv_pcm_uframes_t avail; /* number of frames available */
>> 409 sndrv_pcm_uframes_t avail_max; /* max frames available on hw since last status */
>> 410 sndrv_pcm_uframes_t overrange; /* count of ADC (capture) overrange detections from last status */
>> 411 enum sndrv_pcm_state suspended_state; /* suspended stream state */
>> 412 unsigned char reserved[60]; /* must be filled with zero */
>> 413 };
>> 414
>> 415 struct sndrv_pcm_mmap_status {
>> 416 enum sndrv_pcm_state state; /* RO: state - SNDRV_PCM_STATE_XXXX */
>> 417 int pad1; /* Needed for 64 bit alignment */
>> 418 sndrv_pcm_uframes_t hw_ptr; /* RO: hw ptr (0...boundary-1) */
>> 419 struct timespec tstamp; /* Timestamp */
>> 420 enum sndrv_pcm_state suspended_state; /* RO: suspended stream state */
>> 421 };
>> 422
>> 423 struct sndrv_pcm_mmap_control {
>> 424 sndrv_pcm_uframes_t appl_ptr; /* RW: appl ptr (0...boundary-1) */
>> 425 sndrv_pcm_uframes_t avail_min; /* RW: min available frames for wakeup */
>> 426 };
>> 427
>> 428 struct sndrv_xferi {
>> 429 sndrv_pcm_sframes_t result;
>> 430 void *buf;
>> 431 sndrv_pcm_uframes_t frames;
>> 432 };
>> 433
>> 434 struct sndrv_xfern {
>> 435 sndrv_pcm_sframes_t result;
>> 436 void **bufs;
>> 437 sndrv_pcm_uframes_t frames;
>> 438 };
>> 439
>> 440 enum {
>> 441 SNDRV_PCM_IOCTL_PVERSION = _IOR('A', 0x00, int),
>> 442 SNDRV_PCM_IOCTL_INFO = _IOR('A', 0x01, struct sndrv_pcm_info),
>> 443 SNDRV_PCM_IOCTL_TSTAMP = _IOW('A', 0x02, int),
>> 444 SNDRV_PCM_IOCTL_HW_REFINE = _IOWR('A', 0x10, struct sndrv_pcm_hw_params),
>> 445 SNDRV_PCM_IOCTL_HW_PARAMS = _IOWR('A', 0x11, struct sndrv_pcm_hw_params),
>> 446 SNDRV_PCM_IOCTL_HW_FREE = _IO('A', 0x12),
>> 447 SNDRV_PCM_IOCTL_SW_PARAMS = _IOWR('A', 0x13, struct sndrv_pcm_sw_params),
>> 448 SNDRV_PCM_IOCTL_STATUS = _IOR('A', 0x20, struct sndrv_pcm_status),
>> 449 SNDRV_PCM_IOCTL_DELAY = _IOR('A', 0x21, sndrv_pcm_sframes_t),
>> 450 SNDRV_PCM_IOCTL_HWSYNC = _IO('A', 0x22),
>> 451 SNDRV_PCM_IOCTL_CHANNEL_INFO = _IOR('A', 0x32, struct sndrv_pcm_channel_info),
>> 452 SNDRV_PCM_IOCTL_PREPARE = _IO('A', 0x40),
>> 453 SNDRV_PCM_IOCTL_RESET = _IO('A', 0x41),
>> 454 SNDRV_PCM_IOCTL_START = _IO('A', 0x42),
>> 455 SNDRV_PCM_IOCTL_DROP = _IO('A', 0x43),
>> 456 SNDRV_PCM_IOCTL_DRAIN = _IO('A', 0x44),
>> 457 SNDRV_PCM_IOCTL_PAUSE = _IOW('A', 0x45, int),
>> 458 SNDRV_PCM_IOCTL_REWIND = _IOW('A', 0x46, sndrv_pcm_uframes_t),
>> 459 SNDRV_PCM_IOCTL_RESUME = _IO('A', 0x47),
>> 460 SNDRV_PCM_IOCTL_XRUN = _IO('A', 0x48),
>> 461 SNDRV_PCM_IOCTL_FORWARD = _IOW('A', 0x49, sndrv_pcm_uframes_t),
>> 462 SNDRV_PCM_IOCTL_WRITEI_FRAMES = _IOW('A', 0x50, struct sndrv_xferi),
>> 463 SNDRV_PCM_IOCTL_READI_FRAMES = _IOR('A', 0x51, struct sndrv_xferi),
>> 464 SNDRV_PCM_IOCTL_WRITEN_FRAMES = _IOW('A', 0x52, struct sndrv_xfern),
>> 465 SNDRV_PCM_IOCTL_READN_FRAMES = _IOR('A', 0x53, struct sndrv_xfern),
>> 466 SNDRV_PCM_IOCTL_LINK = _IOW('A', 0x60, int),
>> 467 SNDRV_PCM_IOCTL_UNLINK = _IO('A', 0x61),
>> 468 };
>> 469
>> 470 /* Trick to make alsa-lib/acinclude.m4 happy */
>> 471 #define SNDRV_PCM_IOCTL_REWIND SNDRV_PCM_IOCTL_REWIND
>> 472
>> 473 /*****************************************************************************
>> 474 * *
>> 475 * MIDI v1.0 interface *
>> 476 * *
>> 477 *****************************************************************************/
>> 478
>> 479 /*
>> 480 * Raw MIDI section - /dev/snd/midi??
>> 481 */
>> 482
>> 483 #define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 0)
>> 484
>> 485 enum sndrv_rawmidi_stream {
>> 486 SNDRV_RAWMIDI_STREAM_OUTPUT = 0,
>> 487 SNDRV_RAWMIDI_STREAM_INPUT,
>> 488 SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT,
>> 489 };
>> 490
>> 491 #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001
>> 492 #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002
>> 493 #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004
>> 494
>> 495 struct sndrv_rawmidi_info {
>> 496 unsigned int device; /* RO/WR (control): device number */
>> 497 unsigned int subdevice; /* RO/WR (control): subdevice number */
>> 498 enum sndrv_rawmidi_stream stream; /* WR: stream */
>> 499 int card; /* R: card number */
>> 500 unsigned int flags; /* SNDRV_RAWMIDI_INFO_XXXX */
>> 501 unsigned char id[64]; /* ID (user selectable) */
>> 502 unsigned char name[80]; /* name of device */
>> 503 unsigned char subname[32]; /* name of active or selected subdevice */
>> 504 unsigned int subdevices_count;
>> 505 unsigned int subdevices_avail;
>> 506 unsigned char reserved[64]; /* reserved for future use */
>> 507 };
>> 508
>> 509 struct sndrv_rawmidi_params {
>> 510 enum sndrv_rawmidi_stream stream;
>> 511 size_t buffer_size; /* queue size in bytes */
>> 512 size_t avail_min; /* minimum avail bytes for wakeup */
>> 513 unsigned int no_active_sensing: 1; /* do not send active sensing byte in close() */
>> 514 unsigned char reserved[16]; /* reserved for future use */
>> 515 };
>> 516
>> 517 struct sndrv_rawmidi_status {
>> 518 enum sndrv_rawmidi_stream stream;
>> 519 struct timespec tstamp; /* Timestamp */
>> 520 size_t avail; /* available bytes */
>> 521 size_t xruns; /* count of overruns since last status (in bytes) */
>> 522 unsigned char reserved[16]; /* reserved for future use */
>> 523 };
>> 524
>> 525 enum {
>> 526 SNDRV_RAWMIDI_IOCTL_PVERSION = _IOR('W', 0x00, int),
>> 527 SNDRV_RAWMIDI_IOCTL_INFO = _IOR('W', 0x01, struct sndrv_rawmidi_info),
>> 528 SNDRV_RAWMIDI_IOCTL_PARAMS = _IOWR('W', 0x10, struct sndrv_rawmidi_params),
>> 529 SNDRV_RAWMIDI_IOCTL_STATUS = _IOWR('W', 0x20, struct sndrv_rawmidi_status),
>> 530 SNDRV_RAWMIDI_IOCTL_DROP = _IOW('W', 0x30, int),
>> 531 SNDRV_RAWMIDI_IOCTL_DRAIN = _IOW('W', 0x31, int),
>> 532 };
>> 533
>> 534 /*
>> 535 * Timer section - /dev/snd/timer
>> 536 */
>> 537
>> 538 #define SNDRV_TIMER_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 1)
>> 539
>> 540 enum sndrv_timer_class {
>> 541 SNDRV_TIMER_CLASS_NONE = -1,
>> 542 SNDRV_TIMER_CLASS_SLAVE = 0,
>> 543 SNDRV_TIMER_CLASS_GLOBAL,
>> 544 SNDRV_TIMER_CLASS_CARD,
>> 545 SNDRV_TIMER_CLASS_PCM,
>> 546 SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM,
>> 547 };
>> 548
>> 549 /* slave timer classes */
>> 550 enum sndrv_timer_slave_class {
>> 551 SNDRV_TIMER_SCLASS_NONE = 0,
>> 552 SNDRV_TIMER_SCLASS_APPLICATION,
>> 553 SNDRV_TIMER_SCLASS_SEQUENCER, /* alias */
>> 554 SNDRV_TIMER_SCLASS_OSS_SEQUENCER, /* alias */
>> 555 SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER,
>> 556 };
>> 557
>> 558 /* global timers (device member) */
>> 559 #define SNDRV_TIMER_GLOBAL_SYSTEM 0
>> 560 #define SNDRV_TIMER_GLOBAL_RTC 1
>> 561
>> 562 /* info flags */
>> 563 #define SNDRV_TIMER_FLG_SLAVE (1<<0) /* cannot be controlled */
>> 564
>> 565 struct sndrv_timer_id {
>> 566 enum sndrv_timer_class dev_class;
>> 567 enum sndrv_timer_slave_class dev_sclass;
>> 568 int card;
>> 569 int device;
>> 570 int subdevice;
>> 571 };
>> 572
>> 573 struct sndrv_timer_ginfo {
>> 574 struct sndrv_timer_id tid; /* requested timer ID */
>> 575 unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */
>> 576 int card; /* card number */
>> 577 unsigned char id[64]; /* timer identification */
>> 578 unsigned char name[80]; /* timer name */
>> 579 unsigned long reserved0; /* reserved for future use */
>> 580 unsigned long resolution; /* average period resolution in ns */
>> 581 unsigned long resolution_min; /* minimal period resolution in ns */
>> 582 unsigned long resolution_max; /* maximal period resolution in ns */
>> 583 unsigned int clients; /* active timer clients */
>> 584 unsigned char reserved[32];
>> 585 };
>> 586
>> 587 struct sndrv_timer_gparams {
>> 588 struct sndrv_timer_id tid; /* requested timer ID */
>> 589 unsigned long period_num; /* requested precise period duration (in seconds) - numerator */
>> 590 unsigned long period_den; /* requested precise period duration (in seconds) - denominator */
>> 591 unsigned char reserved[32];
>> 592 };
>> 593
>> 594 struct sndrv_timer_gstatus {
>> 595 struct sndrv_timer_id tid; /* requested timer ID */
>> 596 unsigned long resolution; /* current period resolution in ns */
>> 597 unsigned long resolution_num; /* precise current period resolution (in seconds) - numerator */
>> 598 unsigned long resolution_den; /* precise current period resolution (in seconds) - denominator */
>> 599 unsigned char reserved[32];
>> 600 };
>> 601
>> 602 struct sndrv_timer_select {
>> 603 struct sndrv_timer_id id; /* bind to timer ID */
>> 604 unsigned char reserved[32]; /* reserved */
>> 605 };
>> 606
>> 607 struct sndrv_timer_info {
>> 608 unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */
>> 609 int card; /* card number */
>> 610 unsigned char id[64]; /* timer identificator */
>> 611 unsigned char name[80]; /* timer name */
>> 612 unsigned long reserved0; /* reserved for future use */
>> 613 unsigned long resolution; /* average period resolution in ns */
>> 614 unsigned char reserved[64]; /* reserved */
>> 615 };
>> 616
>> 617 #define SNDRV_TIMER_PSFLG_AUTO (1<<0) /* auto start, otherwise one-shot */
>> 618 #define SNDRV_TIMER_PSFLG_EXCLUSIVE (1<<1) /* exclusive use, precise start/stop/pause/continue */
>> 619
>> 620 struct sndrv_timer_params {
>> 621 unsigned int flags; /* flags - SNDRV_MIXER_PSFLG_* */
>> 622 unsigned int ticks; /* requested resolution in ticks */
>> 623 unsigned int queue_size; /* total size of queue (32-1024) */
>> 624 unsigned int reserved0; /* reserved, was: failure locations */
>> 625 unsigned int filter; /* event filter (bitmask of SNDRV_TIMER_EVENT_*) */
>> 626 unsigned char reserved[60]; /* reserved */
>> 627 };
>> 628
>> 629 struct sndrv_timer_status {
>> 630 struct timespec tstamp; /* Timestamp - last update */
>> 631 unsigned int resolution; /* current period resolution in ns */
>> 632 unsigned int lost; /* counter of master tick lost */
>> 633 unsigned int overrun; /* count of read queue overruns */
>> 634 unsigned int queue; /* used queue size */
>> 635 unsigned char reserved[64]; /* reserved */
>> 636 };
>> 637
>> 638 enum {
>> 639 SNDRV_TIMER_IOCTL_PVERSION = _IOR('T', 0x00, int),
>> 640 SNDRV_TIMER_IOCTL_NEXT_DEVICE = _IOWR('T', 0x01, struct sndrv_timer_id),
>> 641 SNDRV_TIMER_IOCTL_TREAD = _IOW('T', 0x02, int),
>> 642 SNDRV_TIMER_IOCTL_GINFO = _IOWR('T', 0x03, struct sndrv_timer_ginfo),
>> 643 SNDRV_TIMER_IOCTL_GPARAMS = _IOW('T', 0x04, struct sndrv_timer_gparams),
>> 644 SNDRV_TIMER_IOCTL_GSTATUS = _IOWR('T', 0x05, struct sndrv_timer_gstatus),
>> 645 SNDRV_TIMER_IOCTL_SELECT = _IOW('T', 0x10, struct sndrv_timer_select),
>> 646 SNDRV_TIMER_IOCTL_INFO = _IOR('T', 0x11, struct sndrv_timer_info),
>> 647 SNDRV_TIMER_IOCTL_PARAMS = _IOW('T', 0x12, struct sndrv_timer_params),
>> 648 SNDRV_TIMER_IOCTL_STATUS = _IOR('T', 0x14, struct sndrv_timer_status),
>> 649 SNDRV_TIMER_IOCTL_START = _IO('T', 0x20),
>> 650 SNDRV_TIMER_IOCTL_STOP = _IO('T', 0x21),
>> 651 SNDRV_TIMER_IOCTL_CONTINUE = _IO('T', 0x22),
>> 652 SNDRV_TIMER_IOCTL_PAUSE = _IO('T', 0x23),
>> 653 };
>> 654
>> 655 struct sndrv_timer_read {
>> 656 unsigned int resolution;
>> 657 unsigned int ticks;
>> 658 };
>> 659
>> 660 enum sndrv_timer_event {
>> 661 SNDRV_TIMER_EVENT_RESOLUTION = 0, /* val = resolution in ns */
>> 662 SNDRV_TIMER_EVENT_TICK, /* val = ticks */
>> 663 SNDRV_TIMER_EVENT_START, /* val = resolution in ns */
>> 664 SNDRV_TIMER_EVENT_STOP, /* val = 0 */
>> 665 SNDRV_TIMER_EVENT_CONTINUE, /* val = resolution in ns */
>> 666 SNDRV_TIMER_EVENT_PAUSE, /* val = 0 */
>> 667 /* master timer events for slave timer instances */
>> 668 SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10,
>> 669 SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10,
>> 670 SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10,
>> 671 SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10,
>> 672 };
>> 673
>> 674 struct sndrv_timer_tread {
>> 675 enum sndrv_timer_event event;
>> 676 struct timespec tstamp;
>> 677 unsigned int val;
>> 678 };
>> 679
>> 680 /****************************************************************************
>> 681 * *
>> 682 * Section for driver control interface - /dev/snd/control? *
>> 683 * *
>> 684 ****************************************************************************/
>> 685
>> 686 #define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2)
>> 687
>> 688 struct sndrv_ctl_card_info {
>> 689 int card; /* card number */
>> 690 int pad; /* reserved for future (was type) */
>> 691 unsigned char id[16]; /* ID of card (user selectable) */
>> 692 unsigned char driver[16]; /* Driver name */
>> 693 unsigned char name[32]; /* Short name of soundcard */
>> 694 unsigned char longname[80]; /* name + info text about soundcard */
>> 695 unsigned char reserved_[16]; /* reserved for future (was ID of mixer) */
>> 696 unsigned char mixername[80]; /* visual mixer identification */
>> 697 unsigned char components[80]; /* card components / fine identification, delimited with one space (AC97 etc..) */
>> 698 unsigned char reserved[48]; /* reserved for future */
>> 699 };
>> 700
>> 701 enum sndrv_ctl_elem_type {
>> 702 SNDRV_CTL_ELEM_TYPE_NONE = 0, /* invalid */
>> 703 SNDRV_CTL_ELEM_TYPE_BOOLEAN, /* boolean type */
>> 704 SNDRV_CTL_ELEM_TYPE_INTEGER, /* integer type */
>> 705 SNDRV_CTL_ELEM_TYPE_ENUMERATED, /* enumerated type */
>> 706 SNDRV_CTL_ELEM_TYPE_BYTES, /* byte array */
>> 707 SNDRV_CTL_ELEM_TYPE_IEC958, /* IEC958 (S/PDIF) setup */
>> 708 SNDRV_CTL_ELEM_TYPE_INTEGER64, /* 64-bit integer type */
>> 709 SNDRV_CTL_ELEM_TYPE_LAST = SNDRV_CTL_ELEM_TYPE_INTEGER64,
>> 710 };
>> 711
>> 712 enum sndrv_ctl_elem_iface {
>> 713 SNDRV_CTL_ELEM_IFACE_CARD = 0, /* global control */
>> 714 SNDRV_CTL_ELEM_IFACE_HWDEP, /* hardware dependent device */
>> 715 SNDRV_CTL_ELEM_IFACE_MIXER, /* virtual mixer device */
>> 716 SNDRV_CTL_ELEM_IFACE_PCM, /* PCM device */
>> 717 SNDRV_CTL_ELEM_IFACE_RAWMIDI, /* RawMidi device */
>> 718 SNDRV_CTL_ELEM_IFACE_TIMER, /* timer device */
>> 719 SNDRV_CTL_ELEM_IFACE_SEQUENCER, /* sequencer client */
>> 720 SNDRV_CTL_ELEM_IFACE_LAST = SNDRV_CTL_ELEM_IFACE_SEQUENCER,
>> 721 };
>> 722
>> 723 #define SNDRV_CTL_ELEM_ACCESS_READ (1<<0)
>> 724 #define SNDRV_CTL_ELEM_ACCESS_WRITE (1<<1)
>> 725 #define SNDRV_CTL_ELEM_ACCESS_READWRITE (SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE)
>> 726 #define SNDRV_CTL_ELEM_ACCESS_VOLATILE (1<<2) /* control value may be changed without a notification */
>> 727 #define SNDRV_CTL_ELEM_ACCESS_TIMESTAMP (1<<2) /* when was control changed */
>> 728 #define SNDRV_CTL_ELEM_ACCESS_INACTIVE (1<<8) /* control does actually nothing, but may be updated */
>> 729 #define SNDRV_CTL_ELEM_ACCESS_LOCK (1<<9) /* write lock */
>> 730 #define SNDRV_CTL_ELEM_ACCESS_OWNER (1<<10) /* write lock owner */
>> 731 #define SNDRV_CTL_ELEM_ACCESS_DINDIRECT (1<<30) /* indirect access for matrix dimensions in the info structure */
>> 732 #define SNDRV_CTL_ELEM_ACCESS_INDIRECT (1<<31) /* indirect access for element value in the value structure */
>> 733
>> 734 /* for further details see the ACPI and PCI power management specification */
>> 735 #define SNDRV_CTL_POWER_D0 0x0000 /* full On */
>> 736 #define SNDRV_CTL_POWER_D1 0x0100 /* partial On */
>> 737 #define SNDRV_CTL_POWER_D2 0x0200 /* partial On */
>> 738 #define SNDRV_CTL_POWER_D3 0x0300 /* Off */
>> 739 #define SNDRV_CTL_POWER_D3hot (SNDRV_CTL_POWER_D3|0x0000) /* Off, with power */
>> 740 #define SNDRV_CTL_POWER_D3cold (SNDRV_CTL_POWER_D3|0x0001) /* Off, without power */
>> 741
>> 742 struct sndrv_ctl_elem_id {
>> 743 unsigned int numid; /* numeric identifier, zero = invalid */
>> 744 enum sndrv_ctl_elem_iface iface; /* interface identifier */
>> 745 unsigned int device; /* device/client number */
>> 746 unsigned int subdevice; /* subdevice (substream) number */
>> 747 unsigned char name[44]; /* ASCII name of item */
>> 748 unsigned int index; /* index of item */
>> 749 };
>> 750
>> 751 struct sndrv_ctl_elem_list {
>> 752 unsigned int offset; /* W: first element ID to get */
>> 753 unsigned int space; /* W: count of element IDs to get */
>> 754 unsigned int used; /* R: count of element IDs set */
>> 755 unsigned int count; /* R: count of all elements */
>> 756 struct sndrv_ctl_elem_id *pids; /* R: IDs */
>> 757 unsigned char reserved[50];
>> 758 };
>> 759
>> 760 struct sndrv_ctl_elem_info {
>> 761 struct sndrv_ctl_elem_id id; /* W: element ID */
>> 762 enum sndrv_ctl_elem_type type; /* R: value type - SNDRV_CTL_ELEM_TYPE_* */
>> 763 unsigned int access; /* R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* */
>> 764 unsigned int count; /* count of values */
>> 765 pid_t owner; /* owner's PID of this control */
>> 766 union {
>> 767 struct {
>> 768 long min; /* R: minimum value */
>> 769 long max; /* R: maximum value */
>> 770 long step; /* R: step (0 variable) */
>> 771 } integer;
>> 772 struct {
>> 773 long long min; /* R: minimum value */
>> 774 long long max; /* R: maximum value */
>> 775 long long step; /* R: step (0 variable) */
>> 776 } integer64;
>> 777 struct {
>> 778 unsigned int items; /* R: number of items */
>> 779 unsigned int item; /* W: item number */
>> 780 char name[64]; /* R: value name */
>> 781 } enumerated;
>> 782 unsigned char reserved[128];
>> 783 } value;
>> 784 union {
>> 785 unsigned short d[4]; /* dimensions */
>> 786 unsigned short *d_ptr; /* indirect */
>> 787 } dimen;
>> 788 unsigned char reserved[64-4*sizeof(unsigned short)];
>> 789 };
>> 790
>> 791 struct sndrv_ctl_elem_value {
>> 792 struct sndrv_ctl_elem_id id; /* W: element ID */
>> 793 unsigned int indirect: 1; /* W: use indirect pointer (xxx_ptr member) */
>> 794 union {
>> 795 union {
>> 796 long value[128];
>> 797 long *value_ptr;
>> 798 } integer;
>> 799 union {
>> 800 long long value[64];
>> 801 long long *value_ptr;
>> 802 } integer64;
>> 803 union {
>> 804 unsigned int item[128];
>> 805 unsigned int *item_ptr;
>> 806 } enumerated;
>> 807 union {
>> 808 unsigned char data[512];
>> 809 unsigned char *data_ptr;
>> 810 } bytes;
>> 811 struct sndrv_aes_iec958 iec958;
>> 812 } value; /* RO */
>> 813 struct timespec tstamp;
>> 814 unsigned char reserved[128-sizeof(struct timespec)];
>> 815 };
>> 816
>> 817 enum {
>> 818 SNDRV_CTL_IOCTL_PVERSION = _IOR('U', 0x00, int),
>> 819 SNDRV_CTL_IOCTL_CARD_INFO = _IOR('U', 0x01, struct sndrv_ctl_card_info),
>> 820 SNDRV_CTL_IOCTL_ELEM_LIST = _IOWR('U', 0x10, struct sndrv_ctl_elem_list),
>> 821 SNDRV_CTL_IOCTL_ELEM_INFO = _IOWR('U', 0x11, struct sndrv_ctl_elem_info),
>> 822 SNDRV_CTL_IOCTL_ELEM_READ = _IOWR('U', 0x12, struct sndrv_ctl_elem_value),
>> 823 SNDRV_CTL_IOCTL_ELEM_WRITE = _IOWR('U', 0x13, struct sndrv_ctl_elem_value),
>> 824 SNDRV_CTL_IOCTL_ELEM_LOCK = _IOW('U', 0x14, struct sndrv_ctl_elem_id),
>> 825 SNDRV_CTL_IOCTL_ELEM_UNLOCK = _IOW('U', 0x15, struct sndrv_ctl_elem_id),
>> 826 SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS = _IOWR('U', 0x16, int),
>> 827 SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE = _IOWR('U', 0x20, int),
>> 828 SNDRV_CTL_IOCTL_HWDEP_INFO = _IOR('U', 0x21, struct sndrv_hwdep_info),
>> 829 SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE = _IOR('U', 0x30, int),
>> 830 SNDRV_CTL_IOCTL_PCM_INFO = _IOWR('U', 0x31, struct sndrv_pcm_info),
>> 831 SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE = _IOW('U', 0x32, int),
>> 832 SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE = _IOWR('U', 0x40, int),
>> 833 SNDRV_CTL_IOCTL_RAWMIDI_INFO = _IOWR('U', 0x41, struct sndrv_rawmidi_info),
>> 834 SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE = _IOW('U', 0x42, int),
>> 835 SNDRV_CTL_IOCTL_POWER = _IOWR('U', 0xd0, int),
>> 836 SNDRV_CTL_IOCTL_POWER_STATE = _IOR('U', 0xd1, int),
>> 837 };
>> 838
>> 839 /*
>> 840 * Read interface.
>> 841 */
>> 842
>> 843 enum sndrv_ctl_event_type {
>> 844 SNDRV_CTL_EVENT_ELEM = 0,
>> 845 SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM,
>> 846 };
>> 847
>> 848 #define SNDRV_CTL_EVENT_MASK_VALUE (1<<0) /* element value was changed */
>> 849 #define SNDRV_CTL_EVENT_MASK_INFO (1<<1) /* element info was changed */
>> 850 #define SNDRV_CTL_EVENT_MASK_ADD (1<<2) /* element was added */
>> 851 #define SNDRV_CTL_EVENT_MASK_REMOVE (~0U) /* element was removed */
>> 852
>> 853 struct sndrv_ctl_event {
>> 854 enum sndrv_ctl_event_type type; /* event type - SNDRV_CTL_EVENT_* */
>> 855 union {
>> 856 struct {
>> 857 unsigned int mask;
>> 858 struct sndrv_ctl_elem_id id;
>> 859 } elem;
>> 860 unsigned char data8[60];
>> 861 } data;
>> 862 };
>> 863
>> 864 /*
>> 865 * Control names
>> 866 */
>> 867
>> 868 #define SNDRV_CTL_NAME_NONE ""
>> 869 #define SNDRV_CTL_NAME_PLAYBACK "Playback "
>> 870 #define SNDRV_CTL_NAME_CAPTURE "Capture "
>> 871
>> 872 #define SNDRV_CTL_NAME_IEC958_NONE ""
>> 873 #define SNDRV_CTL_NAME_IEC958_SWITCH "Switch"
>> 874 #define SNDRV_CTL_NAME_IEC958_VOLUME "Volume"
>> 875 #define SNDRV_CTL_NAME_IEC958_DEFAULT "Default"
>> 876 #define SNDRV_CTL_NAME_IEC958_MASK "Mask"
>> 877 #define SNDRV_CTL_NAME_IEC958_CON_MASK "Con Mask"
>> 878 #define SNDRV_CTL_NAME_IEC958_PRO_MASK "Pro Mask"
>> 879 #define SNDRV_CTL_NAME_IEC958_PCM_STREAM "PCM Stream"
>> 880 #define SNDRV_CTL_NAME_IEC958(expl,direction,what) "IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what
>> 881
>> 882 /*
>> 883 *
>> 884 */
>> 885
>> 886 struct sndrv_xferv {
>> 887 const struct iovec *vector;
>> 888 unsigned long count;
>> 889 };
>> 890
>> 891 enum {
>> 892 SNDRV_IOCTL_READV = _IOW('K', 0x00, struct sndrv_xferv),
>> 893 SNDRV_IOCTL_WRITEV = _IOW('K', 0x01, struct sndrv_xferv),
>> 894 };
>> 895
25 #endif /* __SOUND_ASOUND_H */ 896 #endif /* __SOUND_ASOUND_H */
26 897
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.