diff options
Diffstat (limited to 'firmware/target/hosted/ibasso/tinyalsa/include')
-rw-r--r-- | firmware/target/hosted/ibasso/tinyalsa/include/sound/asound.h | 820 | ||||
-rw-r--r-- | firmware/target/hosted/ibasso/tinyalsa/include/tinyalsa/asoundlib.h | 260 |
2 files changed, 1080 insertions, 0 deletions
diff --git a/firmware/target/hosted/ibasso/tinyalsa/include/sound/asound.h b/firmware/target/hosted/ibasso/tinyalsa/include/sound/asound.h new file mode 100644 index 0000000000..9dd66fe169 --- /dev/null +++ b/firmware/target/hosted/ibasso/tinyalsa/include/sound/asound.h | |||
@@ -0,0 +1,820 @@ | |||
1 | /**************************************************************************** | ||
2 | **************************************************************************** | ||
3 | *** | ||
4 | *** This header was automatically generated from a Linux kernel header | ||
5 | *** of the same name, to make information necessary for userspace to | ||
6 | *** call into the kernel available to libc. It contains only constants, | ||
7 | *** structures, and macros generated from the original header, and thus, | ||
8 | *** contains no copyrightable information. | ||
9 | *** | ||
10 | **************************************************************************** | ||
11 | ****************************************************************************/ | ||
12 | #ifndef __SOUND_ASOUND_H | ||
13 | #define __SOUND_ASOUND_H | ||
14 | |||
15 | #include <linux/types.h> | ||
16 | |||
17 | #define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)|((minor)<<8)|(subminor)) | ||
18 | #define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff) | ||
19 | #define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff) | ||
20 | #define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff) | ||
21 | #define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) (SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) || (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion))) | ||
22 | |||
23 | struct snd_aes_iec958 { | ||
24 | unsigned char status[24]; | ||
25 | unsigned char subcode[147]; | ||
26 | unsigned char pad; | ||
27 | unsigned char dig_subframe[4]; | ||
28 | }; | ||
29 | |||
30 | #define SNDRV_HWDEP_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) | ||
31 | |||
32 | enum { | ||
33 | SNDRV_HWDEP_IFACE_OPL2 = 0, | ||
34 | SNDRV_HWDEP_IFACE_OPL3, | ||
35 | SNDRV_HWDEP_IFACE_OPL4, | ||
36 | SNDRV_HWDEP_IFACE_SB16CSP, | ||
37 | SNDRV_HWDEP_IFACE_EMU10K1, | ||
38 | SNDRV_HWDEP_IFACE_YSS225, | ||
39 | SNDRV_HWDEP_IFACE_ICS2115, | ||
40 | SNDRV_HWDEP_IFACE_SSCAPE, | ||
41 | SNDRV_HWDEP_IFACE_VX, | ||
42 | SNDRV_HWDEP_IFACE_MIXART, | ||
43 | SNDRV_HWDEP_IFACE_USX2Y, | ||
44 | SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, | ||
45 | SNDRV_HWDEP_IFACE_BLUETOOTH, | ||
46 | SNDRV_HWDEP_IFACE_USX2Y_PCM, | ||
47 | SNDRV_HWDEP_IFACE_PCXHR, | ||
48 | SNDRV_HWDEP_IFACE_SB_RC, | ||
49 | SNDRV_HWDEP_IFACE_HDA, | ||
50 | SNDRV_HWDEP_IFACE_USB_STREAM, | ||
51 | |||
52 | SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_USB_STREAM | ||
53 | }; | ||
54 | |||
55 | struct snd_hwdep_info { | ||
56 | unsigned int device; | ||
57 | int card; | ||
58 | unsigned char id[64]; | ||
59 | unsigned char name[80]; | ||
60 | int iface; | ||
61 | unsigned char reserved[64]; | ||
62 | }; | ||
63 | |||
64 | struct snd_hwdep_dsp_status { | ||
65 | unsigned int version; | ||
66 | unsigned char id[32]; | ||
67 | unsigned int num_dsps; | ||
68 | unsigned int dsp_loaded; | ||
69 | unsigned int chip_ready; | ||
70 | unsigned char reserved[16]; | ||
71 | }; | ||
72 | |||
73 | struct snd_hwdep_dsp_image { | ||
74 | unsigned int index; | ||
75 | unsigned char name[64]; | ||
76 | unsigned char __user *image; | ||
77 | size_t length; | ||
78 | unsigned long driver_data; | ||
79 | }; | ||
80 | |||
81 | #define SNDRV_HWDEP_IOCTL_PVERSION _IOR ('H', 0x00, int) | ||
82 | #define SNDRV_HWDEP_IOCTL_INFO _IOR ('H', 0x01, struct snd_hwdep_info) | ||
83 | #define SNDRV_HWDEP_IOCTL_DSP_STATUS _IOR('H', 0x02, struct snd_hwdep_dsp_status) | ||
84 | #define SNDRV_HWDEP_IOCTL_DSP_LOAD _IOW('H', 0x03, struct snd_hwdep_dsp_image) | ||
85 | |||
86 | #define SNDRV_PCM_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 10) | ||
87 | |||
88 | typedef unsigned long snd_pcm_uframes_t; | ||
89 | typedef signed long snd_pcm_sframes_t; | ||
90 | |||
91 | enum { | ||
92 | SNDRV_PCM_CLASS_GENERIC = 0, | ||
93 | SNDRV_PCM_CLASS_MULTI, | ||
94 | SNDRV_PCM_CLASS_MODEM, | ||
95 | SNDRV_PCM_CLASS_DIGITIZER, | ||
96 | |||
97 | SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER, | ||
98 | }; | ||
99 | |||
100 | enum { | ||
101 | SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, | ||
102 | SNDRV_PCM_SUBCLASS_MULTI_MIX, | ||
103 | |||
104 | SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX, | ||
105 | }; | ||
106 | |||
107 | enum { | ||
108 | SNDRV_PCM_STREAM_PLAYBACK = 0, | ||
109 | SNDRV_PCM_STREAM_CAPTURE, | ||
110 | SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE, | ||
111 | }; | ||
112 | |||
113 | typedef int __bitwise snd_pcm_access_t; | ||
114 | #define SNDRV_PCM_ACCESS_MMAP_INTERLEAVED ((__force snd_pcm_access_t) 0) | ||
115 | #define SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED ((__force snd_pcm_access_t) 1) | ||
116 | #define SNDRV_PCM_ACCESS_MMAP_COMPLEX ((__force snd_pcm_access_t) 2) | ||
117 | #define SNDRV_PCM_ACCESS_RW_INTERLEAVED ((__force snd_pcm_access_t) 3) | ||
118 | #define SNDRV_PCM_ACCESS_RW_NONINTERLEAVED ((__force snd_pcm_access_t) 4) | ||
119 | #define SNDRV_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_RW_NONINTERLEAVED | ||
120 | |||
121 | typedef int __bitwise snd_pcm_format_t; | ||
122 | #define SNDRV_PCM_FORMAT_S8 ((__force snd_pcm_format_t) 0) | ||
123 | #define SNDRV_PCM_FORMAT_U8 ((__force snd_pcm_format_t) 1) | ||
124 | #define SNDRV_PCM_FORMAT_S16_LE ((__force snd_pcm_format_t) 2) | ||
125 | #define SNDRV_PCM_FORMAT_S16_BE ((__force snd_pcm_format_t) 3) | ||
126 | #define SNDRV_PCM_FORMAT_U16_LE ((__force snd_pcm_format_t) 4) | ||
127 | #define SNDRV_PCM_FORMAT_U16_BE ((__force snd_pcm_format_t) 5) | ||
128 | #define SNDRV_PCM_FORMAT_S24_LE ((__force snd_pcm_format_t) 6) | ||
129 | #define SNDRV_PCM_FORMAT_S24_BE ((__force snd_pcm_format_t) 7) | ||
130 | #define SNDRV_PCM_FORMAT_U24_LE ((__force snd_pcm_format_t) 8) | ||
131 | #define SNDRV_PCM_FORMAT_U24_BE ((__force snd_pcm_format_t) 9) | ||
132 | #define SNDRV_PCM_FORMAT_S32_LE ((__force snd_pcm_format_t) 10) | ||
133 | #define SNDRV_PCM_FORMAT_S32_BE ((__force snd_pcm_format_t) 11) | ||
134 | #define SNDRV_PCM_FORMAT_U32_LE ((__force snd_pcm_format_t) 12) | ||
135 | #define SNDRV_PCM_FORMAT_U32_BE ((__force snd_pcm_format_t) 13) | ||
136 | #define SNDRV_PCM_FORMAT_FLOAT_LE ((__force snd_pcm_format_t) 14) | ||
137 | #define SNDRV_PCM_FORMAT_FLOAT_BE ((__force snd_pcm_format_t) 15) | ||
138 | #define SNDRV_PCM_FORMAT_FLOAT64_LE ((__force snd_pcm_format_t) 16) | ||
139 | #define SNDRV_PCM_FORMAT_FLOAT64_BE ((__force snd_pcm_format_t) 17) | ||
140 | #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((__force snd_pcm_format_t) 18) | ||
141 | #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((__force snd_pcm_format_t) 19) | ||
142 | #define SNDRV_PCM_FORMAT_MU_LAW ((__force snd_pcm_format_t) 20) | ||
143 | #define SNDRV_PCM_FORMAT_A_LAW ((__force snd_pcm_format_t) 21) | ||
144 | #define SNDRV_PCM_FORMAT_IMA_ADPCM ((__force snd_pcm_format_t) 22) | ||
145 | #define SNDRV_PCM_FORMAT_MPEG ((__force snd_pcm_format_t) 23) | ||
146 | #define SNDRV_PCM_FORMAT_GSM ((__force snd_pcm_format_t) 24) | ||
147 | #define SNDRV_PCM_FORMAT_SPECIAL ((__force snd_pcm_format_t) 31) | ||
148 | #define SNDRV_PCM_FORMAT_S24_3LE ((__force snd_pcm_format_t) 32) | ||
149 | #define SNDRV_PCM_FORMAT_S24_3BE ((__force snd_pcm_format_t) 33) | ||
150 | #define SNDRV_PCM_FORMAT_U24_3LE ((__force snd_pcm_format_t) 34) | ||
151 | #define SNDRV_PCM_FORMAT_U24_3BE ((__force snd_pcm_format_t) 35) | ||
152 | #define SNDRV_PCM_FORMAT_S20_3LE ((__force snd_pcm_format_t) 36) | ||
153 | #define SNDRV_PCM_FORMAT_S20_3BE ((__force snd_pcm_format_t) 37) | ||
154 | #define SNDRV_PCM_FORMAT_U20_3LE ((__force snd_pcm_format_t) 38) | ||
155 | #define SNDRV_PCM_FORMAT_U20_3BE ((__force snd_pcm_format_t) 39) | ||
156 | #define SNDRV_PCM_FORMAT_S18_3LE ((__force snd_pcm_format_t) 40) | ||
157 | #define SNDRV_PCM_FORMAT_S18_3BE ((__force snd_pcm_format_t) 41) | ||
158 | #define SNDRV_PCM_FORMAT_U18_3LE ((__force snd_pcm_format_t) 42) | ||
159 | #define SNDRV_PCM_FORMAT_U18_3BE ((__force snd_pcm_format_t) 43) | ||
160 | #define SNDRV_PCM_FORMAT_G723_24 ((__force snd_pcm_format_t) 44) | ||
161 | #define SNDRV_PCM_FORMAT_G723_24_1B ((__force snd_pcm_format_t) 45) | ||
162 | #define SNDRV_PCM_FORMAT_G723_40 ((__force snd_pcm_format_t) 46) | ||
163 | #define SNDRV_PCM_FORMAT_G723_40_1B ((__force snd_pcm_format_t) 47) | ||
164 | #define SNDRV_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_G723_40_1B | ||
165 | |||
166 | #ifdef SNDRV_LITTLE_ENDIAN | ||
167 | #define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_LE | ||
168 | #define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_LE | ||
169 | #define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_LE | ||
170 | #define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_LE | ||
171 | #define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_LE | ||
172 | #define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_LE | ||
173 | #define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_LE | ||
174 | #define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_LE | ||
175 | #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE | ||
176 | #endif | ||
177 | #ifdef SNDRV_BIG_ENDIAN | ||
178 | #define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_BE | ||
179 | #define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_BE | ||
180 | #define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_BE | ||
181 | #define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_BE | ||
182 | #define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_BE | ||
183 | #define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_BE | ||
184 | #define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_BE | ||
185 | #define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_BE | ||
186 | #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE | ||
187 | #endif | ||
188 | |||
189 | typedef int __bitwise snd_pcm_subformat_t; | ||
190 | #define SNDRV_PCM_SUBFORMAT_STD ((__force snd_pcm_subformat_t) 0) | ||
191 | #define SNDRV_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_STD | ||
192 | |||
193 | #define SNDRV_PCM_INFO_MMAP 0x00000001 | ||
194 | #define SNDRV_PCM_INFO_MMAP_VALID 0x00000002 | ||
195 | #define SNDRV_PCM_INFO_DOUBLE 0x00000004 | ||
196 | #define SNDRV_PCM_INFO_BATCH 0x00000010 | ||
197 | #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 | ||
198 | #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 | ||
199 | #define SNDRV_PCM_INFO_COMPLEX 0x00000400 | ||
200 | #define SNDRV_PCM_INFO_BLOCK_TRANSFER 0x00010000 | ||
201 | #define SNDRV_PCM_INFO_OVERRANGE 0x00020000 | ||
202 | #define SNDRV_PCM_INFO_RESUME 0x00040000 | ||
203 | #define SNDRV_PCM_INFO_PAUSE 0x00080000 | ||
204 | #define SNDRV_PCM_INFO_HALF_DUPLEX 0x00100000 | ||
205 | #define SNDRV_PCM_INFO_JOINT_DUPLEX 0x00200000 | ||
206 | #define SNDRV_PCM_INFO_SYNC_START 0x00400000 | ||
207 | #define SNDRV_PCM_INFO_NO_PERIOD_WAKEUP 0x00800000 | ||
208 | #define SNDRV_PCM_INFO_FIFO_IN_FRAMES 0x80000000 | ||
209 | |||
210 | typedef int __bitwise snd_pcm_state_t; | ||
211 | #define SNDRV_PCM_STATE_OPEN ((__force snd_pcm_state_t) 0) | ||
212 | #define SNDRV_PCM_STATE_SETUP ((__force snd_pcm_state_t) 1) | ||
213 | #define SNDRV_PCM_STATE_PREPARED ((__force snd_pcm_state_t) 2) | ||
214 | #define SNDRV_PCM_STATE_RUNNING ((__force snd_pcm_state_t) 3) | ||
215 | #define SNDRV_PCM_STATE_XRUN ((__force snd_pcm_state_t) 4) | ||
216 | #define SNDRV_PCM_STATE_DRAINING ((__force snd_pcm_state_t) 5) | ||
217 | #define SNDRV_PCM_STATE_PAUSED ((__force snd_pcm_state_t) 6) | ||
218 | #define SNDRV_PCM_STATE_SUSPENDED ((__force snd_pcm_state_t) 7) | ||
219 | #define SNDRV_PCM_STATE_DISCONNECTED ((__force snd_pcm_state_t) 8) | ||
220 | #define SNDRV_PCM_STATE_LAST SNDRV_PCM_STATE_DISCONNECTED | ||
221 | |||
222 | enum { | ||
223 | SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000, | ||
224 | SNDRV_PCM_MMAP_OFFSET_STATUS = 0x80000000, | ||
225 | SNDRV_PCM_MMAP_OFFSET_CONTROL = 0x81000000, | ||
226 | }; | ||
227 | |||
228 | union snd_pcm_sync_id { | ||
229 | unsigned char id[16]; | ||
230 | unsigned short id16[8]; | ||
231 | unsigned int id32[4]; | ||
232 | }; | ||
233 | |||
234 | struct snd_pcm_info { | ||
235 | unsigned int device; | ||
236 | unsigned int subdevice; | ||
237 | int stream; | ||
238 | int card; | ||
239 | unsigned char id[64]; | ||
240 | unsigned char name[80]; | ||
241 | unsigned char subname[32]; | ||
242 | int dev_class; | ||
243 | int dev_subclass; | ||
244 | unsigned int subdevices_count; | ||
245 | unsigned int subdevices_avail; | ||
246 | union snd_pcm_sync_id sync; | ||
247 | unsigned char reserved[64]; | ||
248 | }; | ||
249 | |||
250 | typedef int snd_pcm_hw_param_t; | ||
251 | #define SNDRV_PCM_HW_PARAM_ACCESS 0 | ||
252 | #define SNDRV_PCM_HW_PARAM_FORMAT 1 | ||
253 | #define SNDRV_PCM_HW_PARAM_SUBFORMAT 2 | ||
254 | #define SNDRV_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_ACCESS | ||
255 | #define SNDRV_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_SUBFORMAT | ||
256 | |||
257 | #define SNDRV_PCM_HW_PARAM_SAMPLE_BITS 8 | ||
258 | #define SNDRV_PCM_HW_PARAM_FRAME_BITS 9 | ||
259 | #define SNDRV_PCM_HW_PARAM_CHANNELS 10 | ||
260 | #define SNDRV_PCM_HW_PARAM_RATE 11 | ||
261 | #define SNDRV_PCM_HW_PARAM_PERIOD_TIME 12 | ||
262 | #define SNDRV_PCM_HW_PARAM_PERIOD_SIZE 13 | ||
263 | #define SNDRV_PCM_HW_PARAM_PERIOD_BYTES 14 | ||
264 | #define SNDRV_PCM_HW_PARAM_PERIODS 15 | ||
265 | #define SNDRV_PCM_HW_PARAM_BUFFER_TIME 16 | ||
266 | #define SNDRV_PCM_HW_PARAM_BUFFER_SIZE 17 | ||
267 | #define SNDRV_PCM_HW_PARAM_BUFFER_BYTES 18 | ||
268 | #define SNDRV_PCM_HW_PARAM_TICK_TIME 19 | ||
269 | #define SNDRV_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_SAMPLE_BITS | ||
270 | #define SNDRV_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_TICK_TIME | ||
271 | |||
272 | #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) | ||
273 | #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) | ||
274 | #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) | ||
275 | |||
276 | struct snd_interval { | ||
277 | unsigned int min, max; | ||
278 | unsigned int openmin:1, | ||
279 | openmax:1, | ||
280 | integer:1, | ||
281 | empty:1; | ||
282 | }; | ||
283 | |||
284 | #define SNDRV_MASK_MAX 256 | ||
285 | |||
286 | struct snd_mask { | ||
287 | __u32 bits[(SNDRV_MASK_MAX+31)/32]; | ||
288 | }; | ||
289 | |||
290 | struct snd_pcm_hw_params { | ||
291 | unsigned int flags; | ||
292 | struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - | ||
293 | SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; | ||
294 | struct snd_mask mres[5]; | ||
295 | struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - | ||
296 | SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; | ||
297 | struct snd_interval ires[9]; | ||
298 | unsigned int rmask; | ||
299 | unsigned int cmask; | ||
300 | unsigned int info; | ||
301 | unsigned int msbits; | ||
302 | unsigned int rate_num; | ||
303 | unsigned int rate_den; | ||
304 | snd_pcm_uframes_t fifo_size; | ||
305 | unsigned char reserved[64]; | ||
306 | }; | ||
307 | |||
308 | enum { | ||
309 | SNDRV_PCM_TSTAMP_NONE = 0, | ||
310 | SNDRV_PCM_TSTAMP_ENABLE, | ||
311 | SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_ENABLE, | ||
312 | }; | ||
313 | |||
314 | struct snd_pcm_sw_params { | ||
315 | int tstamp_mode; | ||
316 | unsigned int period_step; | ||
317 | unsigned int sleep_min; | ||
318 | snd_pcm_uframes_t avail_min; | ||
319 | snd_pcm_uframes_t xfer_align; | ||
320 | snd_pcm_uframes_t start_threshold; | ||
321 | snd_pcm_uframes_t stop_threshold; | ||
322 | snd_pcm_uframes_t silence_threshold; | ||
323 | snd_pcm_uframes_t silence_size; | ||
324 | snd_pcm_uframes_t boundary; | ||
325 | unsigned char reserved[64]; | ||
326 | }; | ||
327 | |||
328 | struct snd_pcm_channel_info { | ||
329 | unsigned int channel; | ||
330 | __kernel_off_t offset; | ||
331 | unsigned int first; | ||
332 | unsigned int step; | ||
333 | }; | ||
334 | |||
335 | struct snd_pcm_status { | ||
336 | snd_pcm_state_t state; | ||
337 | struct timespec trigger_tstamp; | ||
338 | struct timespec tstamp; | ||
339 | snd_pcm_uframes_t appl_ptr; | ||
340 | snd_pcm_uframes_t hw_ptr; | ||
341 | snd_pcm_sframes_t delay; | ||
342 | snd_pcm_uframes_t avail; | ||
343 | snd_pcm_uframes_t avail_max; | ||
344 | snd_pcm_uframes_t overrange; | ||
345 | snd_pcm_state_t suspended_state; | ||
346 | unsigned char reserved[60]; | ||
347 | }; | ||
348 | |||
349 | struct snd_pcm_mmap_status { | ||
350 | snd_pcm_state_t state; | ||
351 | int pad1; | ||
352 | snd_pcm_uframes_t hw_ptr; | ||
353 | struct timespec tstamp; | ||
354 | snd_pcm_state_t suspended_state; | ||
355 | }; | ||
356 | |||
357 | struct snd_pcm_mmap_control { | ||
358 | snd_pcm_uframes_t appl_ptr; | ||
359 | snd_pcm_uframes_t avail_min; | ||
360 | }; | ||
361 | |||
362 | #define SNDRV_PCM_SYNC_PTR_HWSYNC (1<<0) | ||
363 | #define SNDRV_PCM_SYNC_PTR_APPL (1<<1) | ||
364 | #define SNDRV_PCM_SYNC_PTR_AVAIL_MIN (1<<2) | ||
365 | |||
366 | struct snd_pcm_sync_ptr { | ||
367 | unsigned int flags; | ||
368 | union { | ||
369 | struct snd_pcm_mmap_status status; | ||
370 | unsigned char reserved[64]; | ||
371 | } s; | ||
372 | union { | ||
373 | struct snd_pcm_mmap_control control; | ||
374 | unsigned char reserved[64]; | ||
375 | } c; | ||
376 | }; | ||
377 | |||
378 | struct snd_xferi { | ||
379 | snd_pcm_sframes_t result; | ||
380 | void __user *buf; | ||
381 | snd_pcm_uframes_t frames; | ||
382 | }; | ||
383 | |||
384 | struct snd_xfern { | ||
385 | snd_pcm_sframes_t result; | ||
386 | void __user * __user *bufs; | ||
387 | snd_pcm_uframes_t frames; | ||
388 | }; | ||
389 | |||
390 | enum { | ||
391 | SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0, | ||
392 | SNDRV_PCM_TSTAMP_TYPE_MONOTONIC, | ||
393 | SNDRV_PCM_TSTAMP_TYPE_LAST = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC, | ||
394 | }; | ||
395 | |||
396 | #define SNDRV_PCM_IOCTL_PVERSION _IOR('A', 0x00, int) | ||
397 | #define SNDRV_PCM_IOCTL_INFO _IOR('A', 0x01, struct snd_pcm_info) | ||
398 | #define SNDRV_PCM_IOCTL_TSTAMP _IOW('A', 0x02, int) | ||
399 | #define SNDRV_PCM_IOCTL_TTSTAMP _IOW('A', 0x03, int) | ||
400 | #define SNDRV_PCM_IOCTL_HW_REFINE _IOWR('A', 0x10, struct snd_pcm_hw_params) | ||
401 | #define SNDRV_PCM_IOCTL_HW_PARAMS _IOWR('A', 0x11, struct snd_pcm_hw_params) | ||
402 | #define SNDRV_PCM_IOCTL_HW_FREE _IO('A', 0x12) | ||
403 | #define SNDRV_PCM_IOCTL_SW_PARAMS _IOWR('A', 0x13, struct snd_pcm_sw_params) | ||
404 | #define SNDRV_PCM_IOCTL_STATUS _IOR('A', 0x20, struct snd_pcm_status) | ||
405 | #define SNDRV_PCM_IOCTL_DELAY _IOR('A', 0x21, snd_pcm_sframes_t) | ||
406 | #define SNDRV_PCM_IOCTL_HWSYNC _IO('A', 0x22) | ||
407 | #define SNDRV_PCM_IOCTL_SYNC_PTR _IOWR('A', 0x23, struct snd_pcm_sync_ptr) | ||
408 | #define SNDRV_PCM_IOCTL_CHANNEL_INFO _IOR('A', 0x32, struct snd_pcm_channel_info) | ||
409 | #define SNDRV_PCM_IOCTL_PREPARE _IO('A', 0x40) | ||
410 | #define SNDRV_PCM_IOCTL_RESET _IO('A', 0x41) | ||
411 | #define SNDRV_PCM_IOCTL_START _IO('A', 0x42) | ||
412 | #define SNDRV_PCM_IOCTL_DROP _IO('A', 0x43) | ||
413 | #define SNDRV_PCM_IOCTL_DRAIN _IO('A', 0x44) | ||
414 | #define SNDRV_PCM_IOCTL_PAUSE _IOW('A', 0x45, int) | ||
415 | #define SNDRV_PCM_IOCTL_REWIND _IOW('A', 0x46, snd_pcm_uframes_t) | ||
416 | #define SNDRV_PCM_IOCTL_RESUME _IO('A', 0x47) | ||
417 | #define SNDRV_PCM_IOCTL_XRUN _IO('A', 0x48) | ||
418 | #define SNDRV_PCM_IOCTL_FORWARD _IOW('A', 0x49, snd_pcm_uframes_t) | ||
419 | #define SNDRV_PCM_IOCTL_WRITEI_FRAMES _IOW('A', 0x50, struct snd_xferi) | ||
420 | #define SNDRV_PCM_IOCTL_READI_FRAMES _IOR('A', 0x51, struct snd_xferi) | ||
421 | #define SNDRV_PCM_IOCTL_WRITEN_FRAMES _IOW('A', 0x52, struct snd_xfern) | ||
422 | #define SNDRV_PCM_IOCTL_READN_FRAMES _IOR('A', 0x53, struct snd_xfern) | ||
423 | #define SNDRV_PCM_IOCTL_LINK _IOW('A', 0x60, int) | ||
424 | #define SNDRV_PCM_IOCTL_UNLINK _IO('A', 0x61) | ||
425 | |||
426 | #define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 0) | ||
427 | |||
428 | enum { | ||
429 | SNDRV_RAWMIDI_STREAM_OUTPUT = 0, | ||
430 | SNDRV_RAWMIDI_STREAM_INPUT, | ||
431 | SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT, | ||
432 | }; | ||
433 | |||
434 | #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 | ||
435 | #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 | ||
436 | #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 | ||
437 | |||
438 | struct snd_rawmidi_info { | ||
439 | unsigned int device; | ||
440 | unsigned int subdevice; | ||
441 | int stream; | ||
442 | int card; | ||
443 | unsigned int flags; | ||
444 | unsigned char id[64]; | ||
445 | unsigned char name[80]; | ||
446 | unsigned char subname[32]; | ||
447 | unsigned int subdevices_count; | ||
448 | unsigned int subdevices_avail; | ||
449 | unsigned char reserved[64]; | ||
450 | }; | ||
451 | |||
452 | struct snd_rawmidi_params { | ||
453 | int stream; | ||
454 | size_t buffer_size; | ||
455 | size_t avail_min; | ||
456 | unsigned int no_active_sensing: 1; | ||
457 | unsigned char reserved[16]; | ||
458 | }; | ||
459 | |||
460 | struct snd_rawmidi_status { | ||
461 | int stream; | ||
462 | struct timespec tstamp; | ||
463 | size_t avail; | ||
464 | size_t xruns; | ||
465 | unsigned char reserved[16]; | ||
466 | }; | ||
467 | |||
468 | #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) | ||
469 | #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) | ||
470 | #define SNDRV_RAWMIDI_IOCTL_PARAMS _IOWR('W', 0x10, struct snd_rawmidi_params) | ||
471 | #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) | ||
472 | #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) | ||
473 | #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) | ||
474 | |||
475 | #define SNDRV_TIMER_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 6) | ||
476 | |||
477 | enum { | ||
478 | SNDRV_TIMER_CLASS_NONE = -1, | ||
479 | SNDRV_TIMER_CLASS_SLAVE = 0, | ||
480 | SNDRV_TIMER_CLASS_GLOBAL, | ||
481 | SNDRV_TIMER_CLASS_CARD, | ||
482 | SNDRV_TIMER_CLASS_PCM, | ||
483 | SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM, | ||
484 | }; | ||
485 | |||
486 | enum { | ||
487 | SNDRV_TIMER_SCLASS_NONE = 0, | ||
488 | SNDRV_TIMER_SCLASS_APPLICATION, | ||
489 | SNDRV_TIMER_SCLASS_SEQUENCER, | ||
490 | SNDRV_TIMER_SCLASS_OSS_SEQUENCER, | ||
491 | SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER, | ||
492 | }; | ||
493 | |||
494 | #define SNDRV_TIMER_GLOBAL_SYSTEM 0 | ||
495 | #define SNDRV_TIMER_GLOBAL_RTC 1 | ||
496 | #define SNDRV_TIMER_GLOBAL_HPET 2 | ||
497 | #define SNDRV_TIMER_GLOBAL_HRTIMER 3 | ||
498 | |||
499 | #define SNDRV_TIMER_FLG_SLAVE (1<<0) | ||
500 | |||
501 | struct snd_timer_id { | ||
502 | int dev_class; | ||
503 | int dev_sclass; | ||
504 | int card; | ||
505 | int device; | ||
506 | int subdevice; | ||
507 | }; | ||
508 | |||
509 | struct snd_timer_ginfo { | ||
510 | struct snd_timer_id tid; | ||
511 | unsigned int flags; | ||
512 | int card; | ||
513 | unsigned char id[64]; | ||
514 | unsigned char name[80]; | ||
515 | unsigned long reserved0; | ||
516 | unsigned long resolution; | ||
517 | unsigned long resolution_min; | ||
518 | unsigned long resolution_max; | ||
519 | unsigned int clients; | ||
520 | unsigned char reserved[32]; | ||
521 | }; | ||
522 | |||
523 | struct snd_timer_gparams { | ||
524 | struct snd_timer_id tid; | ||
525 | unsigned long period_num; | ||
526 | unsigned long period_den; | ||
527 | unsigned char reserved[32]; | ||
528 | }; | ||
529 | |||
530 | struct snd_timer_gstatus { | ||
531 | struct snd_timer_id tid; | ||
532 | unsigned long resolution; | ||
533 | unsigned long resolution_num; | ||
534 | unsigned long resolution_den; | ||
535 | unsigned char reserved[32]; | ||
536 | }; | ||
537 | |||
538 | struct snd_timer_select { | ||
539 | struct snd_timer_id id; | ||
540 | unsigned char reserved[32]; | ||
541 | }; | ||
542 | |||
543 | struct snd_timer_info { | ||
544 | unsigned int flags; | ||
545 | int card; | ||
546 | unsigned char id[64]; | ||
547 | unsigned char name[80]; | ||
548 | unsigned long reserved0; | ||
549 | unsigned long resolution; | ||
550 | unsigned char reserved[64]; | ||
551 | }; | ||
552 | |||
553 | #define SNDRV_TIMER_PSFLG_AUTO (1<<0) | ||
554 | #define SNDRV_TIMER_PSFLG_EXCLUSIVE (1<<1) | ||
555 | #define SNDRV_TIMER_PSFLG_EARLY_EVENT (1<<2) | ||
556 | |||
557 | struct snd_timer_params { | ||
558 | unsigned int flags; | ||
559 | unsigned int ticks; | ||
560 | unsigned int queue_size; | ||
561 | unsigned int reserved0; | ||
562 | unsigned int filter; | ||
563 | unsigned char reserved[60]; | ||
564 | }; | ||
565 | |||
566 | struct snd_timer_status { | ||
567 | struct timespec tstamp; | ||
568 | unsigned int resolution; | ||
569 | unsigned int lost; | ||
570 | unsigned int overrun; | ||
571 | unsigned int queue; | ||
572 | unsigned char reserved[64]; | ||
573 | }; | ||
574 | |||
575 | #define SNDRV_TIMER_IOCTL_PVERSION _IOR('T', 0x00, int) | ||
576 | #define SNDRV_TIMER_IOCTL_NEXT_DEVICE _IOWR('T', 0x01, struct snd_timer_id) | ||
577 | #define SNDRV_TIMER_IOCTL_TREAD _IOW('T', 0x02, int) | ||
578 | #define SNDRV_TIMER_IOCTL_GINFO _IOWR('T', 0x03, struct snd_timer_ginfo) | ||
579 | #define SNDRV_TIMER_IOCTL_GPARAMS _IOW('T', 0x04, struct snd_timer_gparams) | ||
580 | #define SNDRV_TIMER_IOCTL_GSTATUS _IOWR('T', 0x05, struct snd_timer_gstatus) | ||
581 | #define SNDRV_TIMER_IOCTL_SELECT _IOW('T', 0x10, struct snd_timer_select) | ||
582 | #define SNDRV_TIMER_IOCTL_INFO _IOR('T', 0x11, struct snd_timer_info) | ||
583 | #define SNDRV_TIMER_IOCTL_PARAMS _IOW('T', 0x12, struct snd_timer_params) | ||
584 | #define SNDRV_TIMER_IOCTL_STATUS _IOR('T', 0x14, struct snd_timer_status) | ||
585 | |||
586 | #define SNDRV_TIMER_IOCTL_START _IO('T', 0xa0) | ||
587 | #define SNDRV_TIMER_IOCTL_STOP _IO('T', 0xa1) | ||
588 | #define SNDRV_TIMER_IOCTL_CONTINUE _IO('T', 0xa2) | ||
589 | #define SNDRV_TIMER_IOCTL_PAUSE _IO('T', 0xa3) | ||
590 | |||
591 | struct snd_timer_read { | ||
592 | unsigned int resolution; | ||
593 | unsigned int ticks; | ||
594 | }; | ||
595 | |||
596 | enum { | ||
597 | SNDRV_TIMER_EVENT_RESOLUTION = 0, | ||
598 | SNDRV_TIMER_EVENT_TICK, | ||
599 | SNDRV_TIMER_EVENT_START, | ||
600 | SNDRV_TIMER_EVENT_STOP, | ||
601 | SNDRV_TIMER_EVENT_CONTINUE, | ||
602 | SNDRV_TIMER_EVENT_PAUSE, | ||
603 | SNDRV_TIMER_EVENT_EARLY, | ||
604 | SNDRV_TIMER_EVENT_SUSPEND, | ||
605 | SNDRV_TIMER_EVENT_RESUME, | ||
606 | |||
607 | SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10, | ||
608 | SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10, | ||
609 | SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10, | ||
610 | SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10, | ||
611 | SNDRV_TIMER_EVENT_MSUSPEND = SNDRV_TIMER_EVENT_SUSPEND + 10, | ||
612 | SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10, | ||
613 | }; | ||
614 | |||
615 | struct snd_timer_tread { | ||
616 | int event; | ||
617 | struct timespec tstamp; | ||
618 | unsigned int val; | ||
619 | }; | ||
620 | |||
621 | #define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 6) | ||
622 | |||
623 | struct snd_ctl_card_info { | ||
624 | int card; | ||
625 | int pad; | ||
626 | unsigned char id[16]; | ||
627 | unsigned char driver[16]; | ||
628 | unsigned char name[32]; | ||
629 | unsigned char longname[80]; | ||
630 | unsigned char reserved_[16]; | ||
631 | unsigned char mixername[80]; | ||
632 | unsigned char components[128]; | ||
633 | }; | ||
634 | |||
635 | typedef int __bitwise snd_ctl_elem_type_t; | ||
636 | #define SNDRV_CTL_ELEM_TYPE_NONE ((__force snd_ctl_elem_type_t) 0) | ||
637 | #define SNDRV_CTL_ELEM_TYPE_BOOLEAN ((__force snd_ctl_elem_type_t) 1) | ||
638 | #define SNDRV_CTL_ELEM_TYPE_INTEGER ((__force snd_ctl_elem_type_t) 2) | ||
639 | #define SNDRV_CTL_ELEM_TYPE_ENUMERATED ((__force snd_ctl_elem_type_t) 3) | ||
640 | #define SNDRV_CTL_ELEM_TYPE_BYTES ((__force snd_ctl_elem_type_t) 4) | ||
641 | #define SNDRV_CTL_ELEM_TYPE_IEC958 ((__force snd_ctl_elem_type_t) 5) | ||
642 | #define SNDRV_CTL_ELEM_TYPE_INTEGER64 ((__force snd_ctl_elem_type_t) 6) | ||
643 | #define SNDRV_CTL_ELEM_TYPE_LAST SNDRV_CTL_ELEM_TYPE_INTEGER64 | ||
644 | |||
645 | typedef int __bitwise snd_ctl_elem_iface_t; | ||
646 | #define SNDRV_CTL_ELEM_IFACE_CARD ((__force snd_ctl_elem_iface_t) 0) | ||
647 | #define SNDRV_CTL_ELEM_IFACE_HWDEP ((__force snd_ctl_elem_iface_t) 1) | ||
648 | #define SNDRV_CTL_ELEM_IFACE_MIXER ((__force snd_ctl_elem_iface_t) 2) | ||
649 | #define SNDRV_CTL_ELEM_IFACE_PCM ((__force snd_ctl_elem_iface_t) 3) | ||
650 | #define SNDRV_CTL_ELEM_IFACE_RAWMIDI ((__force snd_ctl_elem_iface_t) 4) | ||
651 | #define SNDRV_CTL_ELEM_IFACE_TIMER ((__force snd_ctl_elem_iface_t) 5) | ||
652 | #define SNDRV_CTL_ELEM_IFACE_SEQUENCER ((__force snd_ctl_elem_iface_t) 6) | ||
653 | #define SNDRV_CTL_ELEM_IFACE_LAST SNDRV_CTL_ELEM_IFACE_SEQUENCER | ||
654 | |||
655 | #define SNDRV_CTL_ELEM_ACCESS_READ (1<<0) | ||
656 | #define SNDRV_CTL_ELEM_ACCESS_WRITE (1<<1) | ||
657 | #define SNDRV_CTL_ELEM_ACCESS_READWRITE (SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE) | ||
658 | #define SNDRV_CTL_ELEM_ACCESS_VOLATILE (1<<2) | ||
659 | #define SNDRV_CTL_ELEM_ACCESS_TIMESTAMP (1<<3) | ||
660 | #define SNDRV_CTL_ELEM_ACCESS_TLV_READ (1<<4) | ||
661 | #define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE (1<<5) | ||
662 | #define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE (SNDRV_CTL_ELEM_ACCESS_TLV_READ|SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) | ||
663 | #define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND (1<<6) | ||
664 | #define SNDRV_CTL_ELEM_ACCESS_INACTIVE (1<<8) | ||
665 | #define SNDRV_CTL_ELEM_ACCESS_LOCK (1<<9) | ||
666 | #define SNDRV_CTL_ELEM_ACCESS_OWNER (1<<10) | ||
667 | #define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK (1<<28) | ||
668 | #define SNDRV_CTL_ELEM_ACCESS_USER (1<<29) | ||
669 | |||
670 | #define SNDRV_CTL_POWER_D0 0x0000 | ||
671 | #define SNDRV_CTL_POWER_D1 0x0100 | ||
672 | #define SNDRV_CTL_POWER_D2 0x0200 | ||
673 | #define SNDRV_CTL_POWER_D3 0x0300 | ||
674 | #define SNDRV_CTL_POWER_D3hot (SNDRV_CTL_POWER_D3|0x0000) | ||
675 | #define SNDRV_CTL_POWER_D3cold (SNDRV_CTL_POWER_D3|0x0001) | ||
676 | |||
677 | struct snd_ctl_elem_id { | ||
678 | unsigned int numid; | ||
679 | snd_ctl_elem_iface_t iface; | ||
680 | unsigned int device; | ||
681 | unsigned int subdevice; | ||
682 | unsigned char name[44]; | ||
683 | unsigned int index; | ||
684 | }; | ||
685 | |||
686 | struct snd_ctl_elem_list { | ||
687 | unsigned int offset; | ||
688 | unsigned int space; | ||
689 | unsigned int used; | ||
690 | unsigned int count; | ||
691 | struct snd_ctl_elem_id __user *pids; | ||
692 | unsigned char reserved[50]; | ||
693 | }; | ||
694 | |||
695 | struct snd_ctl_elem_info { | ||
696 | struct snd_ctl_elem_id id; | ||
697 | snd_ctl_elem_type_t type; | ||
698 | unsigned int access; | ||
699 | unsigned int count; | ||
700 | __kernel_pid_t owner; | ||
701 | union { | ||
702 | struct { | ||
703 | long min; | ||
704 | long max; | ||
705 | long step; | ||
706 | } integer; | ||
707 | struct { | ||
708 | long long min; | ||
709 | long long max; | ||
710 | long long step; | ||
711 | } integer64; | ||
712 | struct { | ||
713 | unsigned int items; | ||
714 | unsigned int item; | ||
715 | char name[64]; | ||
716 | } enumerated; | ||
717 | unsigned char reserved[128]; | ||
718 | } value; | ||
719 | union { | ||
720 | unsigned short d[4]; | ||
721 | unsigned short *d_ptr; | ||
722 | } dimen; | ||
723 | unsigned char reserved[64-4*sizeof(unsigned short)]; | ||
724 | }; | ||
725 | |||
726 | struct snd_ctl_elem_value { | ||
727 | struct snd_ctl_elem_id id; | ||
728 | unsigned int indirect: 1; | ||
729 | union { | ||
730 | union { | ||
731 | long value[128]; | ||
732 | long *value_ptr; | ||
733 | } integer; | ||
734 | union { | ||
735 | long long value[64]; | ||
736 | long long *value_ptr; | ||
737 | } integer64; | ||
738 | union { | ||
739 | unsigned int item[128]; | ||
740 | unsigned int *item_ptr; | ||
741 | } enumerated; | ||
742 | union { | ||
743 | unsigned char data[512]; | ||
744 | unsigned char *data_ptr; | ||
745 | } bytes; | ||
746 | struct snd_aes_iec958 iec958; | ||
747 | } value; | ||
748 | struct timespec tstamp; | ||
749 | unsigned char reserved[128-sizeof(struct timespec)]; | ||
750 | }; | ||
751 | |||
752 | struct snd_ctl_tlv { | ||
753 | unsigned int numid; | ||
754 | unsigned int length; | ||
755 | unsigned int tlv[0]; | ||
756 | }; | ||
757 | |||
758 | #define SNDRV_CTL_IOCTL_PVERSION _IOR('U', 0x00, int) | ||
759 | #define SNDRV_CTL_IOCTL_CARD_INFO _IOR('U', 0x01, struct snd_ctl_card_info) | ||
760 | #define SNDRV_CTL_IOCTL_ELEM_LIST _IOWR('U', 0x10, struct snd_ctl_elem_list) | ||
761 | #define SNDRV_CTL_IOCTL_ELEM_INFO _IOWR('U', 0x11, struct snd_ctl_elem_info) | ||
762 | #define SNDRV_CTL_IOCTL_ELEM_READ _IOWR('U', 0x12, struct snd_ctl_elem_value) | ||
763 | #define SNDRV_CTL_IOCTL_ELEM_WRITE _IOWR('U', 0x13, struct snd_ctl_elem_value) | ||
764 | #define SNDRV_CTL_IOCTL_ELEM_LOCK _IOW('U', 0x14, struct snd_ctl_elem_id) | ||
765 | #define SNDRV_CTL_IOCTL_ELEM_UNLOCK _IOW('U', 0x15, struct snd_ctl_elem_id) | ||
766 | #define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int) | ||
767 | #define SNDRV_CTL_IOCTL_ELEM_ADD _IOWR('U', 0x17, struct snd_ctl_elem_info) | ||
768 | #define SNDRV_CTL_IOCTL_ELEM_REPLACE _IOWR('U', 0x18, struct snd_ctl_elem_info) | ||
769 | #define SNDRV_CTL_IOCTL_ELEM_REMOVE _IOWR('U', 0x19, struct snd_ctl_elem_id) | ||
770 | #define SNDRV_CTL_IOCTL_TLV_READ _IOWR('U', 0x1a, struct snd_ctl_tlv) | ||
771 | #define SNDRV_CTL_IOCTL_TLV_WRITE _IOWR('U', 0x1b, struct snd_ctl_tlv) | ||
772 | #define SNDRV_CTL_IOCTL_TLV_COMMAND _IOWR('U', 0x1c, struct snd_ctl_tlv) | ||
773 | #define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int) | ||
774 | #define SNDRV_CTL_IOCTL_HWDEP_INFO _IOR('U', 0x21, struct snd_hwdep_info) | ||
775 | #define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE _IOR('U', 0x30, int) | ||
776 | #define SNDRV_CTL_IOCTL_PCM_INFO _IOWR('U', 0x31, struct snd_pcm_info) | ||
777 | #define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int) | ||
778 | #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) | ||
779 | #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) | ||
780 | #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) | ||
781 | #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) | ||
782 | #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) | ||
783 | |||
784 | enum sndrv_ctl_event_type { | ||
785 | SNDRV_CTL_EVENT_ELEM = 0, | ||
786 | SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM, | ||
787 | }; | ||
788 | |||
789 | #define SNDRV_CTL_EVENT_MASK_VALUE (1<<0) | ||
790 | #define SNDRV_CTL_EVENT_MASK_INFO (1<<1) | ||
791 | #define SNDRV_CTL_EVENT_MASK_ADD (1<<2) | ||
792 | #define SNDRV_CTL_EVENT_MASK_TLV (1<<3) | ||
793 | #define SNDRV_CTL_EVENT_MASK_REMOVE (~0U) | ||
794 | |||
795 | struct snd_ctl_event { | ||
796 | int type; | ||
797 | union { | ||
798 | struct { | ||
799 | unsigned int mask; | ||
800 | struct snd_ctl_elem_id id; | ||
801 | } elem; | ||
802 | unsigned char data8[60]; | ||
803 | } data; | ||
804 | }; | ||
805 | |||
806 | #define SNDRV_CTL_NAME_NONE "" | ||
807 | #define SNDRV_CTL_NAME_PLAYBACK "Playback " | ||
808 | #define SNDRV_CTL_NAME_CAPTURE "Capture " | ||
809 | |||
810 | #define SNDRV_CTL_NAME_IEC958_NONE "" | ||
811 | #define SNDRV_CTL_NAME_IEC958_SWITCH "Switch" | ||
812 | #define SNDRV_CTL_NAME_IEC958_VOLUME "Volume" | ||
813 | #define SNDRV_CTL_NAME_IEC958_DEFAULT "Default" | ||
814 | #define SNDRV_CTL_NAME_IEC958_MASK "Mask" | ||
815 | #define SNDRV_CTL_NAME_IEC958_CON_MASK "Con Mask" | ||
816 | #define SNDRV_CTL_NAME_IEC958_PRO_MASK "Pro Mask" | ||
817 | #define SNDRV_CTL_NAME_IEC958_PCM_STREAM "PCM Stream" | ||
818 | #define SNDRV_CTL_NAME_IEC958(expl,direction,what) "IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what | ||
819 | |||
820 | #endif | ||
diff --git a/firmware/target/hosted/ibasso/tinyalsa/include/tinyalsa/asoundlib.h b/firmware/target/hosted/ibasso/tinyalsa/include/tinyalsa/asoundlib.h new file mode 100644 index 0000000000..ba58bdcdfc --- /dev/null +++ b/firmware/target/hosted/ibasso/tinyalsa/include/tinyalsa/asoundlib.h | |||
@@ -0,0 +1,260 @@ | |||
1 | /* asoundlib.h | ||
2 | ** | ||
3 | ** Copyright 2011, The Android Open Source Project | ||
4 | ** | ||
5 | ** Redistribution and use in source and binary forms, with or without | ||
6 | ** modification, are permitted provided that the following conditions are met: | ||
7 | ** * Redistributions of source code must retain the above copyright | ||
8 | ** notice, this list of conditions and the following disclaimer. | ||
9 | ** * Redistributions in binary form must reproduce the above copyright | ||
10 | ** notice, this list of conditions and the following disclaimer in the | ||
11 | ** documentation and/or other materials provided with the distribution. | ||
12 | ** * Neither the name of The Android Open Source Project nor the names of | ||
13 | ** its contributors may be used to endorse or promote products derived | ||
14 | ** from this software without specific prior written permission. | ||
15 | ** | ||
16 | ** THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND | ||
17 | ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
18 | ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
19 | ** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE | ||
20 | ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
21 | ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | ||
22 | ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | ||
23 | ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
24 | ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
25 | ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH | ||
26 | ** DAMAGE. | ||
27 | */ | ||
28 | |||
29 | #ifndef ASOUNDLIB_H | ||
30 | #define ASOUNDLIB_H | ||
31 | |||
32 | #include <sys/time.h> | ||
33 | #include <stddef.h> | ||
34 | |||
35 | #if defined(__cplusplus) | ||
36 | extern "C" { | ||
37 | #endif | ||
38 | |||
39 | /* | ||
40 | * PCM API | ||
41 | */ | ||
42 | |||
43 | struct pcm; | ||
44 | |||
45 | #define PCM_OUT 0x00000000 | ||
46 | #define PCM_IN 0x10000000 | ||
47 | #define PCM_MMAP 0x00000001 | ||
48 | #define PCM_NOIRQ 0x00000002 | ||
49 | #define PCM_NORESTART 0x00000004 /* PCM_NORESTART - when set, calls to | ||
50 | * pcm_write for a playback stream will not | ||
51 | * attempt to restart the stream in the case | ||
52 | * of an underflow, but will return -EPIPE | ||
53 | * instead. After the first -EPIPE error, the | ||
54 | * stream is considered to be stopped, and a | ||
55 | * second call to pcm_write will attempt to | ||
56 | * restart the stream. | ||
57 | */ | ||
58 | #define PCM_MONOTONIC 0x00000008 /* see pcm_get_htimestamp */ | ||
59 | |||
60 | /* PCM runtime states */ | ||
61 | #define PCM_STATE_RUNNING 3 | ||
62 | #define PCM_STATE_XRUN 4 | ||
63 | #define PCM_STATE_DRAINING 5 | ||
64 | #define PCM_STATE_SUSPENDED 7 | ||
65 | #define PCM_STATE_DISCONNECTED 8 | ||
66 | |||
67 | /* Bit formats */ | ||
68 | enum pcm_format { | ||
69 | PCM_FORMAT_S16_LE = 0, | ||
70 | PCM_FORMAT_S32_LE, | ||
71 | PCM_FORMAT_S8, | ||
72 | PCM_FORMAT_S24_LE, | ||
73 | |||
74 | PCM_FORMAT_MAX, | ||
75 | }; | ||
76 | |||
77 | /* Bitmask has 256 bits (32 bytes) in asound.h */ | ||
78 | struct pcm_mask { | ||
79 | unsigned int bits[32 / sizeof(unsigned int)]; | ||
80 | }; | ||
81 | |||
82 | /* Configuration for a stream */ | ||
83 | struct pcm_config { | ||
84 | unsigned int channels; | ||
85 | unsigned int rate; | ||
86 | unsigned int period_size; | ||
87 | unsigned int period_count; | ||
88 | enum pcm_format format; | ||
89 | |||
90 | /* Values to use for the ALSA start, stop and silence thresholds. Setting | ||
91 | * any one of these values to 0 will cause the default tinyalsa values to be | ||
92 | * used instead. Tinyalsa defaults are as follows. | ||
93 | * | ||
94 | * start_threshold : period_count * period_size | ||
95 | * stop_threshold : period_count * period_size | ||
96 | * silence_threshold : 0 | ||
97 | */ | ||
98 | unsigned int start_threshold; | ||
99 | unsigned int stop_threshold; | ||
100 | unsigned int silence_threshold; | ||
101 | }; | ||
102 | |||
103 | /* PCM parameters */ | ||
104 | enum pcm_param | ||
105 | { | ||
106 | /* mask parameters */ | ||
107 | PCM_PARAM_ACCESS, | ||
108 | PCM_PARAM_FORMAT, | ||
109 | PCM_PARAM_SUBFORMAT, | ||
110 | /* interval parameters */ | ||
111 | PCM_PARAM_SAMPLE_BITS, | ||
112 | PCM_PARAM_FRAME_BITS, | ||
113 | PCM_PARAM_CHANNELS, | ||
114 | PCM_PARAM_RATE, | ||
115 | PCM_PARAM_PERIOD_TIME, | ||
116 | PCM_PARAM_PERIOD_SIZE, | ||
117 | PCM_PARAM_PERIOD_BYTES, | ||
118 | PCM_PARAM_PERIODS, | ||
119 | PCM_PARAM_BUFFER_TIME, | ||
120 | PCM_PARAM_BUFFER_SIZE, | ||
121 | PCM_PARAM_BUFFER_BYTES, | ||
122 | PCM_PARAM_TICK_TIME, | ||
123 | }; | ||
124 | |||
125 | /* Mixer control types */ | ||
126 | enum mixer_ctl_type { | ||
127 | MIXER_CTL_TYPE_BOOL, | ||
128 | MIXER_CTL_TYPE_INT, | ||
129 | MIXER_CTL_TYPE_ENUM, | ||
130 | MIXER_CTL_TYPE_BYTE, | ||
131 | MIXER_CTL_TYPE_IEC958, | ||
132 | MIXER_CTL_TYPE_INT64, | ||
133 | MIXER_CTL_TYPE_UNKNOWN, | ||
134 | |||
135 | MIXER_CTL_TYPE_MAX, | ||
136 | }; | ||
137 | |||
138 | /* Open and close a stream */ | ||
139 | struct pcm *pcm_open(unsigned int card, unsigned int device, | ||
140 | unsigned int flags, struct pcm_config *config); | ||
141 | int pcm_close(struct pcm *pcm); | ||
142 | int pcm_is_ready(struct pcm *pcm); | ||
143 | |||
144 | /* Obtain the parameters for a PCM */ | ||
145 | struct pcm_params *pcm_params_get(unsigned int card, unsigned int device, | ||
146 | unsigned int flags); | ||
147 | void pcm_params_free(struct pcm_params *pcm_params); | ||
148 | |||
149 | struct pcm_mask *pcm_params_get_mask(struct pcm_params *pcm_params, | ||
150 | enum pcm_param param); | ||
151 | unsigned int pcm_params_get_min(struct pcm_params *pcm_params, | ||
152 | enum pcm_param param); | ||
153 | unsigned int pcm_params_get_max(struct pcm_params *pcm_params, | ||
154 | enum pcm_param param); | ||
155 | |||
156 | /* Returns a human readable reason for the last error */ | ||
157 | const char *pcm_get_error(struct pcm *pcm); | ||
158 | |||
159 | /* Returns the sample size in bits for a PCM format. | ||
160 | * As with ALSA formats, this is the storage size for the format, whereas the | ||
161 | * format represents the number of significant bits. For example, | ||
162 | * PCM_FORMAT_S24_LE uses 32 bits of storage. | ||
163 | */ | ||
164 | unsigned int pcm_format_to_bits(enum pcm_format format); | ||
165 | |||
166 | /* Returns the buffer size (int frames) that should be used for pcm_write. */ | ||
167 | unsigned int pcm_get_buffer_size(struct pcm *pcm); | ||
168 | unsigned int pcm_frames_to_bytes(struct pcm *pcm, unsigned int frames); | ||
169 | unsigned int pcm_bytes_to_frames(struct pcm *pcm, unsigned int bytes); | ||
170 | |||
171 | /* Returns available frames in pcm buffer and corresponding time stamp. | ||
172 | * The clock is CLOCK_MONOTONIC if flag PCM_MONOTONIC was specified in pcm_open, | ||
173 | * otherwise the clock is CLOCK_REALTIME. | ||
174 | * For an input stream, frames available are frames ready for the | ||
175 | * application to read. | ||
176 | * For an output stream, frames available are the number of empty frames available | ||
177 | * for the application to write. | ||
178 | */ | ||
179 | int pcm_get_htimestamp(struct pcm *pcm, unsigned int *avail, | ||
180 | struct timespec *tstamp); | ||
181 | |||
182 | /* Write data to the fifo. | ||
183 | * Will start playback on the first write or on a write that | ||
184 | * occurs after a fifo underrun. | ||
185 | */ | ||
186 | int pcm_write(struct pcm *pcm, const void *data, unsigned int count); | ||
187 | int pcm_read(struct pcm *pcm, void *data, unsigned int count); | ||
188 | |||
189 | /* | ||
190 | * mmap() support. | ||
191 | */ | ||
192 | int pcm_mmap_write(struct pcm *pcm, const void *data, unsigned int count); | ||
193 | int pcm_mmap_read(struct pcm *pcm, void *data, unsigned int count); | ||
194 | int pcm_mmap_begin(struct pcm *pcm, void **areas, unsigned int *offset, | ||
195 | unsigned int *frames); | ||
196 | int pcm_mmap_commit(struct pcm *pcm, unsigned int offset, unsigned int frames); | ||
197 | |||
198 | /* Prepare the PCM substream to be triggerable */ | ||
199 | int pcm_prepare(struct pcm *pcm); | ||
200 | /* Start and stop a PCM channel that doesn't transfer data */ | ||
201 | int pcm_start(struct pcm *pcm); | ||
202 | int pcm_stop(struct pcm *pcm); | ||
203 | |||
204 | /* Interrupt driven API */ | ||
205 | int pcm_wait(struct pcm *pcm, int timeout); | ||
206 | |||
207 | |||
208 | /* | ||
209 | * MIXER API | ||
210 | */ | ||
211 | |||
212 | struct mixer; | ||
213 | struct mixer_ctl; | ||
214 | |||
215 | /* Open and close a mixer */ | ||
216 | struct mixer *mixer_open(unsigned int card); | ||
217 | void mixer_close(struct mixer *mixer); | ||
218 | |||
219 | /* Get info about a mixer */ | ||
220 | const char *mixer_get_name(struct mixer *mixer); | ||
221 | |||
222 | /* Obtain mixer controls */ | ||
223 | unsigned int mixer_get_num_ctls(struct mixer *mixer); | ||
224 | struct mixer_ctl *mixer_get_ctl(struct mixer *mixer, unsigned int id); | ||
225 | struct mixer_ctl *mixer_get_ctl_by_name(struct mixer *mixer, const char *name); | ||
226 | |||
227 | /* Get info about mixer controls */ | ||
228 | const char *mixer_ctl_get_name(struct mixer_ctl *ctl); | ||
229 | enum mixer_ctl_type mixer_ctl_get_type(struct mixer_ctl *ctl); | ||
230 | const char *mixer_ctl_get_type_string(struct mixer_ctl *ctl); | ||
231 | unsigned int mixer_ctl_get_num_values(struct mixer_ctl *ctl); | ||
232 | unsigned int mixer_ctl_get_num_enums(struct mixer_ctl *ctl); | ||
233 | const char *mixer_ctl_get_enum_string(struct mixer_ctl *ctl, | ||
234 | unsigned int enum_id); | ||
235 | |||
236 | /* Some sound cards update their controls due to external events, | ||
237 | * such as HDMI EDID byte data changing when an HDMI cable is | ||
238 | * connected. This API allows the count of elements to be updated. | ||
239 | */ | ||
240 | void mixer_ctl_update(struct mixer_ctl *ctl); | ||
241 | |||
242 | /* Set and get mixer controls */ | ||
243 | int mixer_ctl_get_percent(struct mixer_ctl *ctl, unsigned int id); | ||
244 | int mixer_ctl_set_percent(struct mixer_ctl *ctl, unsigned int id, int percent); | ||
245 | |||
246 | int mixer_ctl_get_value(struct mixer_ctl *ctl, unsigned int id); | ||
247 | int mixer_ctl_get_array(struct mixer_ctl *ctl, void *array, size_t count); | ||
248 | int mixer_ctl_set_value(struct mixer_ctl *ctl, unsigned int id, int value); | ||
249 | int mixer_ctl_set_array(struct mixer_ctl *ctl, const void *array, size_t count); | ||
250 | int mixer_ctl_set_enum_by_string(struct mixer_ctl *ctl, const char *string); | ||
251 | |||
252 | /* Determe range of integer mixer controls */ | ||
253 | int mixer_ctl_get_range_min(struct mixer_ctl *ctl); | ||
254 | int mixer_ctl_get_range_max(struct mixer_ctl *ctl); | ||
255 | |||
256 | #if defined(__cplusplus) | ||
257 | } /* extern "C" */ | ||
258 | #endif | ||
259 | |||
260 | #endif | ||