1/*-
2 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
3 * Copyright by Hannu Savolainen 1995
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
| 1/*-
2 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
3 * Copyright by Hannu Savolainen 1995
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
|
27 * $FreeBSD: head/sys/dev/sound/pcm/sound.h 170161 2007-05-31 18:43:33Z ariff $
| 27 * $FreeBSD: head/sys/dev/sound/pcm/sound.h 170815 2007-06-16 03:37:28Z ariff $
|
28 */
29
30/*
31 * first, include kernel header files.
32 */
33
34#ifndef _OS_H_
35#define _OS_H_
36
37#ifdef _KERNEL
38#include <sys/param.h>
39#include <sys/systm.h>
40#include <sys/ioccom.h>
41#include <sys/filio.h>
42#include <sys/sockio.h>
43#include <sys/fcntl.h>
44#include <sys/tty.h>
45#include <sys/proc.h>
46#include <sys/kernel.h> /* for DATA_SET */
47#include <sys/module.h>
48#include <sys/conf.h>
49#include <sys/file.h>
50#include <sys/uio.h>
51#include <sys/syslog.h>
52#include <sys/errno.h>
53#include <sys/malloc.h>
54#include <sys/bus.h>
55#if __FreeBSD_version < 500000
56#include <sys/buf.h>
57#endif
58#include <machine/resource.h>
59#include <machine/bus.h>
60#include <sys/rman.h>
61#include <sys/limits.h>
62#include <sys/mman.h>
63#include <sys/poll.h>
64#include <sys/sbuf.h>
65#include <sys/soundcard.h>
66#include <sys/sysctl.h>
67#include <sys/kobj.h>
68#include <vm/vm.h>
69#include <vm/pmap.h>
70
71#undef USING_MUTEX
72#undef USING_DEVFS
73
74#if __FreeBSD_version > 500000
75#include <sys/lock.h>
76#include <sys/mutex.h>
77#include <sys/condvar.h>
78
79#define USING_MUTEX
80#define USING_DEVFS
81#else
82#define INTR_TYPE_AV INTR_TYPE_TTY
83#define INTR_MPSAFE 0
84#endif
85
86#define SND_DYNSYSCTL
87
88struct pcm_channel;
89struct pcm_feeder;
90struct snd_dbuf;
91struct snd_mixer;
92
93#include <dev/sound/pcm/buffer.h>
94#include <dev/sound/pcm/channel.h>
95#include <dev/sound/pcm/feeder.h>
96#include <dev/sound/pcm/mixer.h>
97#include <dev/sound/pcm/dsp.h>
98#include <dev/sound/clone.h>
99#include <dev/sound/unit.h>
100
101#define PCM_SOFTC_SIZE 512
102
103#define SND_STATUSLEN 64
104
105#define SOUND_MODVER 2
106
107#define SOUND_MINVER SOUND_MODVER
108#define SOUND_PREFVER SOUND_MODVER
109#define SOUND_MAXVER SOUND_MODVER
110
111/*
112 * We're abusing the fact that MAXMINOR still have enough room
113 * for our bit twiddling and nobody ever need 512 unique soundcards,
114 * 32 unique device types and 1024 unique cloneable devices for the
115 * next 100 years...
116 */
117
118#define PCMMAXUNIT (snd_max_u())
119#define PCMMAXDEV (snd_max_d())
120#define PCMMAXCHAN (snd_max_c())
121
122#define PCMMAXCLONE PCMMAXCHAN
123
124#define PCMUNIT(x) (snd_unit2u(dev2unit(x)))
125#define PCMDEV(x) (snd_unit2d(dev2unit(x)))
126#define PCMCHAN(x) (snd_unit2c(dev2unit(x)))
127
128/*
129 * By design, limit possible channels for each direction.
130 */
131#define SND_MAXHWCHAN 256
132#define SND_MAXVCHANS SND_MAXHWCHAN
133
134#define SD_F_SIMPLEX 0x00000001
135#define SD_F_AUTOVCHAN 0x00000002
136#define SD_F_SOFTPCMVOL 0x00000004
137#define SD_F_PSWAPLR 0x00000008
138#define SD_F_RSWAPLR 0x00000010
139#define SD_F_DYING 0x00000020
140#define SD_F_SUICIDE 0x00000040
| 28 */
29
30/*
31 * first, include kernel header files.
32 */
33
34#ifndef _OS_H_
35#define _OS_H_
36
37#ifdef _KERNEL
38#include <sys/param.h>
39#include <sys/systm.h>
40#include <sys/ioccom.h>
41#include <sys/filio.h>
42#include <sys/sockio.h>
43#include <sys/fcntl.h>
44#include <sys/tty.h>
45#include <sys/proc.h>
46#include <sys/kernel.h> /* for DATA_SET */
47#include <sys/module.h>
48#include <sys/conf.h>
49#include <sys/file.h>
50#include <sys/uio.h>
51#include <sys/syslog.h>
52#include <sys/errno.h>
53#include <sys/malloc.h>
54#include <sys/bus.h>
55#if __FreeBSD_version < 500000
56#include <sys/buf.h>
57#endif
58#include <machine/resource.h>
59#include <machine/bus.h>
60#include <sys/rman.h>
61#include <sys/limits.h>
62#include <sys/mman.h>
63#include <sys/poll.h>
64#include <sys/sbuf.h>
65#include <sys/soundcard.h>
66#include <sys/sysctl.h>
67#include <sys/kobj.h>
68#include <vm/vm.h>
69#include <vm/pmap.h>
70
71#undef USING_MUTEX
72#undef USING_DEVFS
73
74#if __FreeBSD_version > 500000
75#include <sys/lock.h>
76#include <sys/mutex.h>
77#include <sys/condvar.h>
78
79#define USING_MUTEX
80#define USING_DEVFS
81#else
82#define INTR_TYPE_AV INTR_TYPE_TTY
83#define INTR_MPSAFE 0
84#endif
85
86#define SND_DYNSYSCTL
87
88struct pcm_channel;
89struct pcm_feeder;
90struct snd_dbuf;
91struct snd_mixer;
92
93#include <dev/sound/pcm/buffer.h>
94#include <dev/sound/pcm/channel.h>
95#include <dev/sound/pcm/feeder.h>
96#include <dev/sound/pcm/mixer.h>
97#include <dev/sound/pcm/dsp.h>
98#include <dev/sound/clone.h>
99#include <dev/sound/unit.h>
100
101#define PCM_SOFTC_SIZE 512
102
103#define SND_STATUSLEN 64
104
105#define SOUND_MODVER 2
106
107#define SOUND_MINVER SOUND_MODVER
108#define SOUND_PREFVER SOUND_MODVER
109#define SOUND_MAXVER SOUND_MODVER
110
111/*
112 * We're abusing the fact that MAXMINOR still have enough room
113 * for our bit twiddling and nobody ever need 512 unique soundcards,
114 * 32 unique device types and 1024 unique cloneable devices for the
115 * next 100 years...
116 */
117
118#define PCMMAXUNIT (snd_max_u())
119#define PCMMAXDEV (snd_max_d())
120#define PCMMAXCHAN (snd_max_c())
121
122#define PCMMAXCLONE PCMMAXCHAN
123
124#define PCMUNIT(x) (snd_unit2u(dev2unit(x)))
125#define PCMDEV(x) (snd_unit2d(dev2unit(x)))
126#define PCMCHAN(x) (snd_unit2c(dev2unit(x)))
127
128/*
129 * By design, limit possible channels for each direction.
130 */
131#define SND_MAXHWCHAN 256
132#define SND_MAXVCHANS SND_MAXHWCHAN
133
134#define SD_F_SIMPLEX 0x00000001
135#define SD_F_AUTOVCHAN 0x00000002
136#define SD_F_SOFTPCMVOL 0x00000004
137#define SD_F_PSWAPLR 0x00000008
138#define SD_F_RSWAPLR 0x00000010
139#define SD_F_DYING 0x00000020
140#define SD_F_SUICIDE 0x00000040
|
| 141#define SD_F_BUSY 0x00000080
142#define SD_F_MPSAFE 0x00000100
143#define SD_F_REGISTERED 0x00000200
144
|
141#define SD_F_PRIO_RD 0x10000000
142#define SD_F_PRIO_WR 0x20000000
143#define SD_F_PRIO_SET (SD_F_PRIO_RD | SD_F_PRIO_WR)
144#define SD_F_DIR_SET 0x40000000
145#define SD_F_TRANSIENT 0xf0000000
146
| 145#define SD_F_PRIO_RD 0x10000000
146#define SD_F_PRIO_WR 0x20000000
147#define SD_F_PRIO_SET (SD_F_PRIO_RD | SD_F_PRIO_WR)
148#define SD_F_DIR_SET 0x40000000
149#define SD_F_TRANSIENT 0xf0000000
150
|
| 151#define PCM_ALIVE(x) ((x) != NULL && (x)->lock != NULL && \
152 !((x)->flags & SD_F_DYING))
153#define PCM_REGISTERED(x) (PCM_ALIVE(x) && \
154 ((x)->flags & SD_F_REGISTERED))
155
|
147/* many variables should be reduced to a range. Here define a macro */
148#define RANGE(var, low, high) (var) = \
149 (((var)<(low))? (low) : ((var)>(high))? (high) : (var))
150#define DSP_BUFFSIZE (8192)
151
152/*
153 * Macros for reading/writing PCM sample / int values from bytes array.
154 * Since every process is done using signed integer (and to make our life
155 * less miserable), unsigned sample will be converted to its signed
156 * counterpart and restored during writing back. To avoid overflow,
157 * we truncate 32bit (and only 32bit) samples down to 24bit (see below
158 * for the reason), unless PCM_USE_64BIT_ARITH is defined.
159 */
160
161/*
162 * Automatically turn on 64bit arithmetic on suitable archs
163 * (amd64 64bit, ia64, etc..) for wider 32bit samples / integer processing.
164 */
165#if LONG_BIT >= 64
166#undef PCM_USE_64BIT_ARITH
167#define PCM_USE_64BIT_ARITH 1
168#else
169#if 0
170#undef PCM_USE_64BIT_ARITH
171#define PCM_USE_64BIT_ARITH 1
172#endif
173#endif
174
175#ifdef PCM_USE_64BIT_ARITH
176typedef int64_t intpcm_t;
177#else
178typedef int32_t intpcm_t;
179#endif
180
181/* 32bit fixed point shift */
182#define PCM_FXSHIFT 8
183
184#define PCM_S8_MAX 0x7f
185#define PCM_S8_MIN -0x80
186#define PCM_S16_MAX 0x7fff
187#define PCM_S16_MIN -0x8000
188#define PCM_S24_MAX 0x7fffff
189#define PCM_S24_MIN -0x800000
190#ifdef PCM_USE_64BIT_ARITH
191#if LONG_BIT >= 64
192#define PCM_S32_MAX 0x7fffffffL
193#define PCM_S32_MIN -0x80000000L
194#else
195#define PCM_S32_MAX 0x7fffffffLL
196#define PCM_S32_MIN -0x80000000LL
197#endif
198#else
199#define PCM_S32_MAX 0x7fffffff
200#define PCM_S32_MIN (-0x7fffffff - 1)
201#endif
202
203/* Bytes-per-sample definition */
204#define PCM_8_BPS 1
205#define PCM_16_BPS 2
206#define PCM_24_BPS 3
207#define PCM_32_BPS 4
208
209#if BYTE_ORDER == LITTLE_ENDIAN
210#define PCM_READ_S16_LE(b8) *((int16_t *)(b8))
211#define _PCM_READ_S32_LE(b8) *((int32_t *)(b8))
212#define PCM_READ_S16_BE(b8) \
213 ((int32_t)((b8)[1] | ((int8_t)((b8)[0])) << 8))
214#define _PCM_READ_S32_BE(b8) \
215 ((int32_t)((b8)[3] | (b8)[2] << 8 | (b8)[1] << 16 | \
216 ((int8_t)((b8)[0])) << 24))
217
218#define PCM_WRITE_S16_LE(b8, val) *((int16_t *)(b8)) = (val)
219#define _PCM_WRITE_S32_LE(b8, val) *((int32_t *)(b8)) = (val)
220#define PCM_WRITE_S16_BE(bb8, vval) do { \
221 int32_t val = (vval); \
222 uint8_t *b8 = (bb8); \
223 b8[1] = val; \
224 b8[0] = val >> 8; \
225 } while(0)
226#define _PCM_WRITE_S32_BE(bb8, vval) do { \
227 int32_t val = (vval); \
228 uint8_t *b8 = (bb8); \
229 b8[3] = val; \
230 b8[2] = val >> 8; \
231 b8[1] = val >> 16; \
232 b8[0] = val >> 24; \
233 } while(0)
234
235#define PCM_READ_U16_LE(b8) ((int16_t)(*((uint16_t *)(b8)) ^ 0x8000))
236#define _PCM_READ_U32_LE(b8) ((int32_t)(*((uint32_t *)(b8)) ^ 0x80000000))
237#define PCM_READ_U16_BE(b8) \
238 ((int32_t)((b8)[1] | ((int8_t)((b8)[0] ^ 0x80)) << 8))
239#define _PCM_READ_U32_BE(b8) \
240 ((int32_t)((b8)[3] | (b8)[2] << 8 | (b8)[1] << 16 | \
241 ((int8_t)((b8)[0] ^ 0x80)) << 24))
242
243#define PCM_WRITE_U16_LE(b8, val) *((uint16_t *)(b8)) = (val) ^ 0x8000
244#define _PCM_WRITE_U32_LE(b8, val) *((uint32_t *)(b8)) = (val) ^ 0x80000000
245#define PCM_WRITE_U16_BE(bb8, vval) do { \
246 int32_t val = (vval); \
247 uint8_t *b8 = (bb8); \
248 b8[1] = val; \
249 b8[0] = (val >> 8) ^ 0x80; \
250 } while(0)
251#define _PCM_WRITE_U32_BE(bb8, vval) do { \
252 int32_t val = (vval); \
253 uint8_t *b8 = (bb8); \
254 b8[3] = val; \
255 b8[2] = val >> 8; \
256 b8[1] = val >> 16; \
257 b8[0] = (val >> 24) ^ 0x80; \
258 } while(0)
259#else /* !LITTLE_ENDIAN */
260#define PCM_READ_S16_LE(b8) \
261 ((int32_t)((b8)[0] | ((int8_t)((b8)[1])) << 8))
262#define _PCM_READ_S32_LE(b8) \
263 ((int32_t)((b8)[0] | (b8)[1] << 8 | (b8)[2] << 16 | \
264 ((int8_t)((b8)[3])) << 24))
265#define PCM_READ_S16_BE(b8) *((int16_t *)(b8))
266#define _PCM_READ_S32_BE(b8) *((int32_t *)(b8))
267
268#define PCM_WRITE_S16_LE(bb8, vval) do { \
269 int32_t val = (vval); \
270 uint8_t *b8 = (bb8); \
271 b8[0] = val; \
272 b8[1] = val >> 8; \
273 } while(0)
274#define _PCM_WRITE_S32_LE(bb8, vval) do { \
275 int32_t val = (vval); \
276 uint8_t *b8 = (bb8); \
277 b8[0] = val; \
278 b8[1] = val >> 8; \
279 b8[2] = val >> 16; \
280 b8[3] = val >> 24; \
281 } while(0)
282#define PCM_WRITE_S16_BE(b8, val) *((int16_t *)(b8)) = (val)
283#define _PCM_WRITE_S32_BE(b8, val) *((int32_t *)(b8)) = (val)
284
285#define PCM_READ_U16_LE(b8) \
286 ((int32_t)((b8)[0] | ((int8_t)((b8)[1] ^ 0x80)) << 8))
287#define _PCM_READ_U32_LE(b8) \
288 ((int32_t)((b8)[0] | (b8)[1] << 8 | (b8)[2] << 16 | \
289 ((int8_t)((b8)[3] ^ 0x80)) << 24))
290#define PCM_READ_U16_BE(b8) ((int16_t)(*((uint16_t *)(b8)) ^ 0x8000))
291#define _PCM_READ_U32_BE(b8) ((int32_t)(*((uint32_t *)(b8)) ^ 0x80000000))
292
293#define PCM_WRITE_U16_LE(bb8, vval) do { \
294 int32_t val = (vval); \
295 uint8_t *b8 = (bb8); \
296 b8[0] = val; \
297 b8[1] = (val >> 8) ^ 0x80; \
298 } while(0)
299#define _PCM_WRITE_U32_LE(bb8, vval) do { \
300 int32_t val = (vval); \
301 uint8_t *b8 = (bb8); \
302 b8[0] = val; \
303 b8[1] = val >> 8; \
304 b8[2] = val >> 16; \
305 b8[3] = (val >> 24) ^ 0x80; \
306 } while(0)
307#define PCM_WRITE_U16_BE(b8, val) *((uint16_t *)(b8)) = (val) ^ 0x8000
308#define _PCM_WRITE_U32_BE(b8, val) *((uint32_t *)(b8)) = (val) ^ 0x80000000
309#endif
310
311#define PCM_READ_S24_LE(b8) \
312 ((int32_t)((b8)[0] | (b8)[1] << 8 | ((int8_t)((b8)[2])) << 16))
313#define PCM_READ_S24_BE(b8) \
314 ((int32_t)((b8)[2] | (b8)[1] << 8 | ((int8_t)((b8)[0])) << 16))
315
316#define PCM_WRITE_S24_LE(bb8, vval) do { \
317 int32_t val = (vval); \
318 uint8_t *b8 = (bb8); \
319 b8[0] = val; \
320 b8[1] = val >> 8; \
321 b8[2] = val >> 16; \
322 } while(0)
323#define PCM_WRITE_S24_BE(bb8, vval) do { \
324 int32_t val = (vval); \
325 uint8_t *b8 = (bb8); \
326 b8[2] = val; \
327 b8[1] = val >> 8; \
328 b8[0] = val >> 16; \
329 } while(0)
330
331#define PCM_READ_U24_LE(b8) \
332 ((int32_t)((b8)[0] | (b8)[1] << 8 | \
333 ((int8_t)((b8)[2] ^ 0x80)) << 16))
334#define PCM_READ_U24_BE(b8) \
335 ((int32_t)((b8)[2] | (b8)[1] << 8 | \
336 ((int8_t)((b8)[0] ^ 0x80)) << 16))
337
338#define PCM_WRITE_U24_LE(bb8, vval) do { \
339 int32_t val = (vval); \
340 uint8_t *b8 = (bb8); \
341 b8[0] = val; \
342 b8[1] = val >> 8; \
343 b8[2] = (val >> 16) ^ 0x80; \
344 } while(0)
345#define PCM_WRITE_U24_BE(bb8, vval) do { \
346 int32_t val = (vval); \
347 uint8_t *b8 = (bb8); \
348 b8[2] = val; \
349 b8[1] = val >> 8; \
350 b8[0] = (val >> 16) ^ 0x80; \
351 } while(0)
352
353#ifdef PCM_USE_64BIT_ARITH
354#define PCM_READ_S32_LE(b8) _PCM_READ_S32_LE(b8)
355#define PCM_READ_S32_BE(b8) _PCM_READ_S32_BE(b8)
356#define PCM_WRITE_S32_LE(b8, val) _PCM_WRITE_S32_LE(b8, val)
357#define PCM_WRITE_S32_BE(b8, val) _PCM_WRITE_S32_BE(b8, val)
358
359#define PCM_READ_U32_LE(b8) _PCM_READ_U32_LE(b8)
360#define PCM_READ_U32_BE(b8) _PCM_READ_U32_BE(b8)
361#define PCM_WRITE_U32_LE(b8, val) _PCM_WRITE_U32_LE(b8, val)
362#define PCM_WRITE_U32_BE(b8, val) _PCM_WRITE_U32_BE(b8, val)
363#else /* !PCM_USE_64BIT_ARITH */
364/*
365 * 24bit integer ?!? This is quite unfortunate, eh? Get the fact straight:
366 * Dynamic range for:
367 * 1) Human =~ 140db
368 * 2) 16bit = 96db (close enough)
369 * 3) 24bit = 144db (perfect)
370 * 4) 32bit = 196db (way too much)
371 * 5) Bugs Bunny = Gazillion!@%$Erbzzztt-EINVAL db
372 * Since we're not Bugs Bunny ..uh..err.. avoiding 64bit arithmetic, 24bit
373 * is pretty much sufficient for our signed integer processing.
374 */
375#define PCM_READ_S32_LE(b8) (_PCM_READ_S32_LE(b8) >> PCM_FXSHIFT)
376#define PCM_READ_S32_BE(b8) (_PCM_READ_S32_BE(b8) >> PCM_FXSHIFT)
377#define PCM_WRITE_S32_LE(b8, val) _PCM_WRITE_S32_LE(b8, (val) << PCM_FXSHIFT)
378#define PCM_WRITE_S32_BE(b8, val) _PCM_WRITE_S32_BE(b8, (val) << PCM_FXSHIFT)
379
380#define PCM_READ_U32_LE(b8) (_PCM_READ_U32_LE(b8) >> PCM_FXSHIFT)
381#define PCM_READ_U32_BE(b8) (_PCM_READ_U32_BE(b8) >> PCM_FXSHIFT)
382#define PCM_WRITE_U32_LE(b8, val) _PCM_WRITE_U32_LE(b8, (val) << PCM_FXSHIFT)
383#define PCM_WRITE_U32_BE(b8, val) _PCM_WRITE_U32_BE(b8, (val) << PCM_FXSHIFT)
384#endif
385
386/*
387 * 8bit sample is pretty much useless since it doesn't provide
388 * sufficient dynamic range throughout our filtering process.
389 * For the sake of completeness, declare it anyway.
390 */
391#define PCM_READ_S8(b8) *((int8_t *)(b8))
392#define PCM_READ_S8_NE(b8) PCM_READ_S8(b8)
393#define PCM_READ_U8(b8) ((int8_t)(*((uint8_t *)(b8)) ^ 0x80))
394#define PCM_READ_U8_NE(b8) PCM_READ_U8(b8)
395
396#define PCM_WRITE_S8(b8, val) *((int8_t *)(b8)) = (val)
397#define PCM_WRITE_S8_NE(b8, val) PCM_WRITE_S8(b8, val)
398#define PCM_WRITE_U8(b8, val) *((uint8_t *)(b8)) = (val) ^ 0x80
399#define PCM_WRITE_U8_NE(b8, val) PCM_WRITE_U8(b8, val)
400
401#define PCM_CLAMP_S8(val) \
402 (((val) > PCM_S8_MAX) ? PCM_S8_MAX : \
403 (((val) < PCM_S8_MIN) ? PCM_S8_MIN : (val)))
404#define PCM_CLAMP_S16(val) \
405 (((val) > PCM_S16_MAX) ? PCM_S16_MAX : \
406 (((val) < PCM_S16_MIN) ? PCM_S16_MIN : (val)))
407#define PCM_CLAMP_S24(val) \
408 (((val) > PCM_S24_MAX) ? PCM_S24_MAX : \
409 (((val) < PCM_S24_MIN) ? PCM_S24_MIN : (val)))
410
411#ifdef PCM_USE_64BIT_ARITH
412#define PCM_CLAMP_S32(val) \
413 (((val) > PCM_S32_MAX) ? PCM_S32_MAX : \
414 (((val) < PCM_S32_MIN) ? PCM_S32_MIN : (val)))
415#else
416#define PCM_CLAMP_S32(val) \
417 (((val) > PCM_S24_MAX) ? PCM_S32_MAX : \
418 (((val) < PCM_S24_MIN) ? PCM_S32_MIN : \
419 ((val) << PCM_FXSHIFT)))
420#endif
421
422#define PCM_CLAMP_U8(val) PCM_CLAMP_S8(val)
423#define PCM_CLAMP_U16(val) PCM_CLAMP_S16(val)
424#define PCM_CLAMP_U24(val) PCM_CLAMP_S24(val)
425#define PCM_CLAMP_U32(val) PCM_CLAMP_S32(val)
426
427/* make figuring out what a format is easier. got AFMT_STEREO already */
428#define AFMT_32BIT (AFMT_S32_LE | AFMT_S32_BE | AFMT_U32_LE | AFMT_U32_BE)
429#define AFMT_24BIT (AFMT_S24_LE | AFMT_S24_BE | AFMT_U24_LE | AFMT_U24_BE)
430#define AFMT_16BIT (AFMT_S16_LE | AFMT_S16_BE | AFMT_U16_LE | AFMT_U16_BE)
431#define AFMT_8BIT (AFMT_MU_LAW | AFMT_A_LAW | AFMT_U8 | AFMT_S8)
432#define AFMT_SIGNED (AFMT_S32_LE | AFMT_S32_BE | AFMT_S24_LE | AFMT_S24_BE | \
433 AFMT_S16_LE | AFMT_S16_BE | AFMT_S8)
434#define AFMT_BIGENDIAN (AFMT_S32_BE | AFMT_U32_BE | AFMT_S24_BE | AFMT_U24_BE | \
435 AFMT_S16_BE | AFMT_U16_BE)
436
437struct pcm_channel *fkchan_setup(device_t dev);
438int fkchan_kill(struct pcm_channel *c);
439
440/*
441 * Minor numbers for the sound driver.
442 *
443 * Unfortunately Creative called the codec chip of SB as a DSP. For this
444 * reason the /dev/dsp is reserved for digitized audio use. There is a
445 * device for true DSP processors but it will be called something else.
446 * In v3.0 it's /dev/sndproc but this could be a temporary solution.
447 */
448
449#define SND_DEV_CTL 0 /* Control port /dev/mixer */
450#define SND_DEV_SEQ 1 /* Sequencer /dev/sequencer */
451#define SND_DEV_MIDIN 2 /* Raw midi access */
452#define SND_DEV_DSP 3 /* Digitized voice /dev/dsp */
453#define SND_DEV_AUDIO 4 /* Sparc compatible /dev/audio */
454#define SND_DEV_DSP16 5 /* Like /dev/dsp but 16 bits/sample */
455#define SND_DEV_STATUS 6 /* /dev/sndstat */
456 /* #7 not in use now. */
457#define SND_DEV_SEQ2 8 /* /dev/sequencer, level 2 interface */
458#define SND_DEV_SNDPROC 9 /* /dev/sndproc for programmable devices */
459#define SND_DEV_PSS SND_DEV_SNDPROC /* ? */
460#define SND_DEV_NORESET 10
461
462#define SND_DEV_DSPHW_PLAY 11 /* specific playback channel */
463#define SND_DEV_DSPHW_VPLAY 12 /* specific virtual playback channel */
464#define SND_DEV_DSPHW_REC 13 /* specific record channel */
465#define SND_DEV_DSPHW_VREC 14 /* specific virtual record channel */
466
| 156/* many variables should be reduced to a range. Here define a macro */
157#define RANGE(var, low, high) (var) = \
158 (((var)<(low))? (low) : ((var)>(high))? (high) : (var))
159#define DSP_BUFFSIZE (8192)
160
161/*
162 * Macros for reading/writing PCM sample / int values from bytes array.
163 * Since every process is done using signed integer (and to make our life
164 * less miserable), unsigned sample will be converted to its signed
165 * counterpart and restored during writing back. To avoid overflow,
166 * we truncate 32bit (and only 32bit) samples down to 24bit (see below
167 * for the reason), unless PCM_USE_64BIT_ARITH is defined.
168 */
169
170/*
171 * Automatically turn on 64bit arithmetic on suitable archs
172 * (amd64 64bit, ia64, etc..) for wider 32bit samples / integer processing.
173 */
174#if LONG_BIT >= 64
175#undef PCM_USE_64BIT_ARITH
176#define PCM_USE_64BIT_ARITH 1
177#else
178#if 0
179#undef PCM_USE_64BIT_ARITH
180#define PCM_USE_64BIT_ARITH 1
181#endif
182#endif
183
184#ifdef PCM_USE_64BIT_ARITH
185typedef int64_t intpcm_t;
186#else
187typedef int32_t intpcm_t;
188#endif
189
190/* 32bit fixed point shift */
191#define PCM_FXSHIFT 8
192
193#define PCM_S8_MAX 0x7f
194#define PCM_S8_MIN -0x80
195#define PCM_S16_MAX 0x7fff
196#define PCM_S16_MIN -0x8000
197#define PCM_S24_MAX 0x7fffff
198#define PCM_S24_MIN -0x800000
199#ifdef PCM_USE_64BIT_ARITH
200#if LONG_BIT >= 64
201#define PCM_S32_MAX 0x7fffffffL
202#define PCM_S32_MIN -0x80000000L
203#else
204#define PCM_S32_MAX 0x7fffffffLL
205#define PCM_S32_MIN -0x80000000LL
206#endif
207#else
208#define PCM_S32_MAX 0x7fffffff
209#define PCM_S32_MIN (-0x7fffffff - 1)
210#endif
211
212/* Bytes-per-sample definition */
213#define PCM_8_BPS 1
214#define PCM_16_BPS 2
215#define PCM_24_BPS 3
216#define PCM_32_BPS 4
217
218#if BYTE_ORDER == LITTLE_ENDIAN
219#define PCM_READ_S16_LE(b8) *((int16_t *)(b8))
220#define _PCM_READ_S32_LE(b8) *((int32_t *)(b8))
221#define PCM_READ_S16_BE(b8) \
222 ((int32_t)((b8)[1] | ((int8_t)((b8)[0])) << 8))
223#define _PCM_READ_S32_BE(b8) \
224 ((int32_t)((b8)[3] | (b8)[2] << 8 | (b8)[1] << 16 | \
225 ((int8_t)((b8)[0])) << 24))
226
227#define PCM_WRITE_S16_LE(b8, val) *((int16_t *)(b8)) = (val)
228#define _PCM_WRITE_S32_LE(b8, val) *((int32_t *)(b8)) = (val)
229#define PCM_WRITE_S16_BE(bb8, vval) do { \
230 int32_t val = (vval); \
231 uint8_t *b8 = (bb8); \
232 b8[1] = val; \
233 b8[0] = val >> 8; \
234 } while(0)
235#define _PCM_WRITE_S32_BE(bb8, vval) do { \
236 int32_t val = (vval); \
237 uint8_t *b8 = (bb8); \
238 b8[3] = val; \
239 b8[2] = val >> 8; \
240 b8[1] = val >> 16; \
241 b8[0] = val >> 24; \
242 } while(0)
243
244#define PCM_READ_U16_LE(b8) ((int16_t)(*((uint16_t *)(b8)) ^ 0x8000))
245#define _PCM_READ_U32_LE(b8) ((int32_t)(*((uint32_t *)(b8)) ^ 0x80000000))
246#define PCM_READ_U16_BE(b8) \
247 ((int32_t)((b8)[1] | ((int8_t)((b8)[0] ^ 0x80)) << 8))
248#define _PCM_READ_U32_BE(b8) \
249 ((int32_t)((b8)[3] | (b8)[2] << 8 | (b8)[1] << 16 | \
250 ((int8_t)((b8)[0] ^ 0x80)) << 24))
251
252#define PCM_WRITE_U16_LE(b8, val) *((uint16_t *)(b8)) = (val) ^ 0x8000
253#define _PCM_WRITE_U32_LE(b8, val) *((uint32_t *)(b8)) = (val) ^ 0x80000000
254#define PCM_WRITE_U16_BE(bb8, vval) do { \
255 int32_t val = (vval); \
256 uint8_t *b8 = (bb8); \
257 b8[1] = val; \
258 b8[0] = (val >> 8) ^ 0x80; \
259 } while(0)
260#define _PCM_WRITE_U32_BE(bb8, vval) do { \
261 int32_t val = (vval); \
262 uint8_t *b8 = (bb8); \
263 b8[3] = val; \
264 b8[2] = val >> 8; \
265 b8[1] = val >> 16; \
266 b8[0] = (val >> 24) ^ 0x80; \
267 } while(0)
268#else /* !LITTLE_ENDIAN */
269#define PCM_READ_S16_LE(b8) \
270 ((int32_t)((b8)[0] | ((int8_t)((b8)[1])) << 8))
271#define _PCM_READ_S32_LE(b8) \
272 ((int32_t)((b8)[0] | (b8)[1] << 8 | (b8)[2] << 16 | \
273 ((int8_t)((b8)[3])) << 24))
274#define PCM_READ_S16_BE(b8) *((int16_t *)(b8))
275#define _PCM_READ_S32_BE(b8) *((int32_t *)(b8))
276
277#define PCM_WRITE_S16_LE(bb8, vval) do { \
278 int32_t val = (vval); \
279 uint8_t *b8 = (bb8); \
280 b8[0] = val; \
281 b8[1] = val >> 8; \
282 } while(0)
283#define _PCM_WRITE_S32_LE(bb8, vval) do { \
284 int32_t val = (vval); \
285 uint8_t *b8 = (bb8); \
286 b8[0] = val; \
287 b8[1] = val >> 8; \
288 b8[2] = val >> 16; \
289 b8[3] = val >> 24; \
290 } while(0)
291#define PCM_WRITE_S16_BE(b8, val) *((int16_t *)(b8)) = (val)
292#define _PCM_WRITE_S32_BE(b8, val) *((int32_t *)(b8)) = (val)
293
294#define PCM_READ_U16_LE(b8) \
295 ((int32_t)((b8)[0] | ((int8_t)((b8)[1] ^ 0x80)) << 8))
296#define _PCM_READ_U32_LE(b8) \
297 ((int32_t)((b8)[0] | (b8)[1] << 8 | (b8)[2] << 16 | \
298 ((int8_t)((b8)[3] ^ 0x80)) << 24))
299#define PCM_READ_U16_BE(b8) ((int16_t)(*((uint16_t *)(b8)) ^ 0x8000))
300#define _PCM_READ_U32_BE(b8) ((int32_t)(*((uint32_t *)(b8)) ^ 0x80000000))
301
302#define PCM_WRITE_U16_LE(bb8, vval) do { \
303 int32_t val = (vval); \
304 uint8_t *b8 = (bb8); \
305 b8[0] = val; \
306 b8[1] = (val >> 8) ^ 0x80; \
307 } while(0)
308#define _PCM_WRITE_U32_LE(bb8, vval) do { \
309 int32_t val = (vval); \
310 uint8_t *b8 = (bb8); \
311 b8[0] = val; \
312 b8[1] = val >> 8; \
313 b8[2] = val >> 16; \
314 b8[3] = (val >> 24) ^ 0x80; \
315 } while(0)
316#define PCM_WRITE_U16_BE(b8, val) *((uint16_t *)(b8)) = (val) ^ 0x8000
317#define _PCM_WRITE_U32_BE(b8, val) *((uint32_t *)(b8)) = (val) ^ 0x80000000
318#endif
319
320#define PCM_READ_S24_LE(b8) \
321 ((int32_t)((b8)[0] | (b8)[1] << 8 | ((int8_t)((b8)[2])) << 16))
322#define PCM_READ_S24_BE(b8) \
323 ((int32_t)((b8)[2] | (b8)[1] << 8 | ((int8_t)((b8)[0])) << 16))
324
325#define PCM_WRITE_S24_LE(bb8, vval) do { \
326 int32_t val = (vval); \
327 uint8_t *b8 = (bb8); \
328 b8[0] = val; \
329 b8[1] = val >> 8; \
330 b8[2] = val >> 16; \
331 } while(0)
332#define PCM_WRITE_S24_BE(bb8, vval) do { \
333 int32_t val = (vval); \
334 uint8_t *b8 = (bb8); \
335 b8[2] = val; \
336 b8[1] = val >> 8; \
337 b8[0] = val >> 16; \
338 } while(0)
339
340#define PCM_READ_U24_LE(b8) \
341 ((int32_t)((b8)[0] | (b8)[1] << 8 | \
342 ((int8_t)((b8)[2] ^ 0x80)) << 16))
343#define PCM_READ_U24_BE(b8) \
344 ((int32_t)((b8)[2] | (b8)[1] << 8 | \
345 ((int8_t)((b8)[0] ^ 0x80)) << 16))
346
347#define PCM_WRITE_U24_LE(bb8, vval) do { \
348 int32_t val = (vval); \
349 uint8_t *b8 = (bb8); \
350 b8[0] = val; \
351 b8[1] = val >> 8; \
352 b8[2] = (val >> 16) ^ 0x80; \
353 } while(0)
354#define PCM_WRITE_U24_BE(bb8, vval) do { \
355 int32_t val = (vval); \
356 uint8_t *b8 = (bb8); \
357 b8[2] = val; \
358 b8[1] = val >> 8; \
359 b8[0] = (val >> 16) ^ 0x80; \
360 } while(0)
361
362#ifdef PCM_USE_64BIT_ARITH
363#define PCM_READ_S32_LE(b8) _PCM_READ_S32_LE(b8)
364#define PCM_READ_S32_BE(b8) _PCM_READ_S32_BE(b8)
365#define PCM_WRITE_S32_LE(b8, val) _PCM_WRITE_S32_LE(b8, val)
366#define PCM_WRITE_S32_BE(b8, val) _PCM_WRITE_S32_BE(b8, val)
367
368#define PCM_READ_U32_LE(b8) _PCM_READ_U32_LE(b8)
369#define PCM_READ_U32_BE(b8) _PCM_READ_U32_BE(b8)
370#define PCM_WRITE_U32_LE(b8, val) _PCM_WRITE_U32_LE(b8, val)
371#define PCM_WRITE_U32_BE(b8, val) _PCM_WRITE_U32_BE(b8, val)
372#else /* !PCM_USE_64BIT_ARITH */
373/*
374 * 24bit integer ?!? This is quite unfortunate, eh? Get the fact straight:
375 * Dynamic range for:
376 * 1) Human =~ 140db
377 * 2) 16bit = 96db (close enough)
378 * 3) 24bit = 144db (perfect)
379 * 4) 32bit = 196db (way too much)
380 * 5) Bugs Bunny = Gazillion!@%$Erbzzztt-EINVAL db
381 * Since we're not Bugs Bunny ..uh..err.. avoiding 64bit arithmetic, 24bit
382 * is pretty much sufficient for our signed integer processing.
383 */
384#define PCM_READ_S32_LE(b8) (_PCM_READ_S32_LE(b8) >> PCM_FXSHIFT)
385#define PCM_READ_S32_BE(b8) (_PCM_READ_S32_BE(b8) >> PCM_FXSHIFT)
386#define PCM_WRITE_S32_LE(b8, val) _PCM_WRITE_S32_LE(b8, (val) << PCM_FXSHIFT)
387#define PCM_WRITE_S32_BE(b8, val) _PCM_WRITE_S32_BE(b8, (val) << PCM_FXSHIFT)
388
389#define PCM_READ_U32_LE(b8) (_PCM_READ_U32_LE(b8) >> PCM_FXSHIFT)
390#define PCM_READ_U32_BE(b8) (_PCM_READ_U32_BE(b8) >> PCM_FXSHIFT)
391#define PCM_WRITE_U32_LE(b8, val) _PCM_WRITE_U32_LE(b8, (val) << PCM_FXSHIFT)
392#define PCM_WRITE_U32_BE(b8, val) _PCM_WRITE_U32_BE(b8, (val) << PCM_FXSHIFT)
393#endif
394
395/*
396 * 8bit sample is pretty much useless since it doesn't provide
397 * sufficient dynamic range throughout our filtering process.
398 * For the sake of completeness, declare it anyway.
399 */
400#define PCM_READ_S8(b8) *((int8_t *)(b8))
401#define PCM_READ_S8_NE(b8) PCM_READ_S8(b8)
402#define PCM_READ_U8(b8) ((int8_t)(*((uint8_t *)(b8)) ^ 0x80))
403#define PCM_READ_U8_NE(b8) PCM_READ_U8(b8)
404
405#define PCM_WRITE_S8(b8, val) *((int8_t *)(b8)) = (val)
406#define PCM_WRITE_S8_NE(b8, val) PCM_WRITE_S8(b8, val)
407#define PCM_WRITE_U8(b8, val) *((uint8_t *)(b8)) = (val) ^ 0x80
408#define PCM_WRITE_U8_NE(b8, val) PCM_WRITE_U8(b8, val)
409
410#define PCM_CLAMP_S8(val) \
411 (((val) > PCM_S8_MAX) ? PCM_S8_MAX : \
412 (((val) < PCM_S8_MIN) ? PCM_S8_MIN : (val)))
413#define PCM_CLAMP_S16(val) \
414 (((val) > PCM_S16_MAX) ? PCM_S16_MAX : \
415 (((val) < PCM_S16_MIN) ? PCM_S16_MIN : (val)))
416#define PCM_CLAMP_S24(val) \
417 (((val) > PCM_S24_MAX) ? PCM_S24_MAX : \
418 (((val) < PCM_S24_MIN) ? PCM_S24_MIN : (val)))
419
420#ifdef PCM_USE_64BIT_ARITH
421#define PCM_CLAMP_S32(val) \
422 (((val) > PCM_S32_MAX) ? PCM_S32_MAX : \
423 (((val) < PCM_S32_MIN) ? PCM_S32_MIN : (val)))
424#else
425#define PCM_CLAMP_S32(val) \
426 (((val) > PCM_S24_MAX) ? PCM_S32_MAX : \
427 (((val) < PCM_S24_MIN) ? PCM_S32_MIN : \
428 ((val) << PCM_FXSHIFT)))
429#endif
430
431#define PCM_CLAMP_U8(val) PCM_CLAMP_S8(val)
432#define PCM_CLAMP_U16(val) PCM_CLAMP_S16(val)
433#define PCM_CLAMP_U24(val) PCM_CLAMP_S24(val)
434#define PCM_CLAMP_U32(val) PCM_CLAMP_S32(val)
435
436/* make figuring out what a format is easier. got AFMT_STEREO already */
437#define AFMT_32BIT (AFMT_S32_LE | AFMT_S32_BE | AFMT_U32_LE | AFMT_U32_BE)
438#define AFMT_24BIT (AFMT_S24_LE | AFMT_S24_BE | AFMT_U24_LE | AFMT_U24_BE)
439#define AFMT_16BIT (AFMT_S16_LE | AFMT_S16_BE | AFMT_U16_LE | AFMT_U16_BE)
440#define AFMT_8BIT (AFMT_MU_LAW | AFMT_A_LAW | AFMT_U8 | AFMT_S8)
441#define AFMT_SIGNED (AFMT_S32_LE | AFMT_S32_BE | AFMT_S24_LE | AFMT_S24_BE | \
442 AFMT_S16_LE | AFMT_S16_BE | AFMT_S8)
443#define AFMT_BIGENDIAN (AFMT_S32_BE | AFMT_U32_BE | AFMT_S24_BE | AFMT_U24_BE | \
444 AFMT_S16_BE | AFMT_U16_BE)
445
446struct pcm_channel *fkchan_setup(device_t dev);
447int fkchan_kill(struct pcm_channel *c);
448
449/*
450 * Minor numbers for the sound driver.
451 *
452 * Unfortunately Creative called the codec chip of SB as a DSP. For this
453 * reason the /dev/dsp is reserved for digitized audio use. There is a
454 * device for true DSP processors but it will be called something else.
455 * In v3.0 it's /dev/sndproc but this could be a temporary solution.
456 */
457
458#define SND_DEV_CTL 0 /* Control port /dev/mixer */
459#define SND_DEV_SEQ 1 /* Sequencer /dev/sequencer */
460#define SND_DEV_MIDIN 2 /* Raw midi access */
461#define SND_DEV_DSP 3 /* Digitized voice /dev/dsp */
462#define SND_DEV_AUDIO 4 /* Sparc compatible /dev/audio */
463#define SND_DEV_DSP16 5 /* Like /dev/dsp but 16 bits/sample */
464#define SND_DEV_STATUS 6 /* /dev/sndstat */
465 /* #7 not in use now. */
466#define SND_DEV_SEQ2 8 /* /dev/sequencer, level 2 interface */
467#define SND_DEV_SNDPROC 9 /* /dev/sndproc for programmable devices */
468#define SND_DEV_PSS SND_DEV_SNDPROC /* ? */
469#define SND_DEV_NORESET 10
470
471#define SND_DEV_DSPHW_PLAY 11 /* specific playback channel */
472#define SND_DEV_DSPHW_VPLAY 12 /* specific virtual playback channel */
473#define SND_DEV_DSPHW_REC 13 /* specific record channel */
474#define SND_DEV_DSPHW_VREC 14 /* specific virtual record channel */
475
|
| 476#define SND_DEV_DSPHW_CD 15 /* s16le/stereo 44100Hz CD */
477
478#define SND_DEV_DSP_MMAP 16 /* OSSv4 compatible /dev/dsp_mmap */
479
480#define SND_DEV_LAST SND_DEV_DSP_MMAP
481#define SND_DEV_MAX PCMMAXDEV
482
|
467#define DSP_DEFAULT_SPEED 8000
468
469#define ON 1
470#define OFF 0
471
472extern int pcm_veto_load;
473extern int snd_unit;
474extern int snd_maxautovchans;
475extern int snd_verbose;
476extern devclass_t pcm_devclass;
477extern struct unrhdr *pcmsg_unrhdr;
478
479/*
480 * some macros for debugging purposes
481 * DDB/DEB to enable/disable debugging stuff
482 * BVDDB to enable debugging when bootverbose
483 */
484#define BVDDB(x) if (bootverbose) x
485
486#ifndef DEB
487#define DEB(x)
488#endif
489
490SYSCTL_DECL(_hw_snd);
491
492struct pcm_channel *pcm_getfakechan(struct snddev_info *d);
493int pcm_chnalloc(struct snddev_info *d, struct pcm_channel **ch, int direction, pid_t pid, int devunit);
494int pcm_chnrelease(struct pcm_channel *c);
495int pcm_chnref(struct pcm_channel *c, int ref);
496int pcm_inprog(struct snddev_info *d, int delta);
497
498struct pcm_channel *pcm_chn_create(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls, int dir, int num, void *devinfo);
499int pcm_chn_destroy(struct pcm_channel *ch);
500int pcm_chn_add(struct snddev_info *d, struct pcm_channel *ch);
501int pcm_chn_remove(struct snddev_info *d, struct pcm_channel *ch);
502
503int pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo);
504unsigned int pcm_getbuffersize(device_t dev, unsigned int minbufsz, unsigned int deflt, unsigned int maxbufsz);
505int pcm_register(device_t dev, void *devinfo, int numplay, int numrec);
506int pcm_unregister(device_t dev);
507int pcm_setstatus(device_t dev, char *str);
508u_int32_t pcm_getflags(device_t dev);
509void pcm_setflags(device_t dev, u_int32_t val);
510void *pcm_getdevinfo(device_t dev);
511
512
513int snd_setup_intr(device_t dev, struct resource *res, int flags,
514 driver_intr_t hand, void *param, void **cookiep);
515
516void *snd_mtxcreate(const char *desc, const char *type);
517void snd_mtxfree(void *m);
518void snd_mtxassert(void *m);
519#define snd_mtxlock(m) mtx_lock(m)
520#define snd_mtxunlock(m) mtx_unlock(m)
521
522int sysctl_hw_snd_vchans(SYSCTL_HANDLER_ARGS);
523
524typedef int (*sndstat_handler)(struct sbuf *s, device_t dev, int verbose);
525int sndstat_acquire(struct thread *td);
526int sndstat_release(struct thread *td);
527int sndstat_register(device_t dev, char *str, sndstat_handler handler);
528int sndstat_registerfile(char *str);
529int sndstat_unregister(device_t dev);
530int sndstat_unregisterfile(char *str);
531
532#define SND_DECLARE_FILE(version) \
533 _SND_DECLARE_FILE(__LINE__, version)
534
535#define _SND_DECLARE_FILE(uniq, version) \
536 __SND_DECLARE_FILE(uniq, version)
537
538#define __SND_DECLARE_FILE(uniq, version) \
539 static char sndstat_vinfo[] = version; \
540 SYSINIT(sdf_ ## uniq, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, sndstat_registerfile, sndstat_vinfo); \
541 SYSUNINIT(sdf_ ## uniq, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, sndstat_unregisterfile, sndstat_vinfo);
542
543/* usage of flags in device config entry (config file) */
544#define DV_F_DRQ_MASK 0x00000007 /* mask for secondary drq */
545#define DV_F_DUAL_DMA 0x00000010 /* set to use secondary dma channel */
546
547/* ought to be made obsolete but still used by mss */
548#define DV_F_DEV_MASK 0x0000ff00 /* force device type/class */
549#define DV_F_DEV_SHIFT 8 /* force device type/class */
550
551#define PCM_DEBUG_MTX
552
553/*
554 * this is rather kludgey- we need to duplicate these struct def'ns from sound.c
555 * so that the macro versions of pcm_{,un}lock can dereference them.
556 * we also have to do this now makedev() has gone away.
557 */
558
559struct snddev_info {
560 struct {
561 struct {
562 SLIST_HEAD(, pcm_channel) head;
563 struct {
564 SLIST_HEAD(, pcm_channel) head;
565 } busy;
566 } pcm;
567 } channels;
| 483#define DSP_DEFAULT_SPEED 8000
484
485#define ON 1
486#define OFF 0
487
488extern int pcm_veto_load;
489extern int snd_unit;
490extern int snd_maxautovchans;
491extern int snd_verbose;
492extern devclass_t pcm_devclass;
493extern struct unrhdr *pcmsg_unrhdr;
494
495/*
496 * some macros for debugging purposes
497 * DDB/DEB to enable/disable debugging stuff
498 * BVDDB to enable debugging when bootverbose
499 */
500#define BVDDB(x) if (bootverbose) x
501
502#ifndef DEB
503#define DEB(x)
504#endif
505
506SYSCTL_DECL(_hw_snd);
507
508struct pcm_channel *pcm_getfakechan(struct snddev_info *d);
509int pcm_chnalloc(struct snddev_info *d, struct pcm_channel **ch, int direction, pid_t pid, int devunit);
510int pcm_chnrelease(struct pcm_channel *c);
511int pcm_chnref(struct pcm_channel *c, int ref);
512int pcm_inprog(struct snddev_info *d, int delta);
513
514struct pcm_channel *pcm_chn_create(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls, int dir, int num, void *devinfo);
515int pcm_chn_destroy(struct pcm_channel *ch);
516int pcm_chn_add(struct snddev_info *d, struct pcm_channel *ch);
517int pcm_chn_remove(struct snddev_info *d, struct pcm_channel *ch);
518
519int pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo);
520unsigned int pcm_getbuffersize(device_t dev, unsigned int minbufsz, unsigned int deflt, unsigned int maxbufsz);
521int pcm_register(device_t dev, void *devinfo, int numplay, int numrec);
522int pcm_unregister(device_t dev);
523int pcm_setstatus(device_t dev, char *str);
524u_int32_t pcm_getflags(device_t dev);
525void pcm_setflags(device_t dev, u_int32_t val);
526void *pcm_getdevinfo(device_t dev);
527
528
529int snd_setup_intr(device_t dev, struct resource *res, int flags,
530 driver_intr_t hand, void *param, void **cookiep);
531
532void *snd_mtxcreate(const char *desc, const char *type);
533void snd_mtxfree(void *m);
534void snd_mtxassert(void *m);
535#define snd_mtxlock(m) mtx_lock(m)
536#define snd_mtxunlock(m) mtx_unlock(m)
537
538int sysctl_hw_snd_vchans(SYSCTL_HANDLER_ARGS);
539
540typedef int (*sndstat_handler)(struct sbuf *s, device_t dev, int verbose);
541int sndstat_acquire(struct thread *td);
542int sndstat_release(struct thread *td);
543int sndstat_register(device_t dev, char *str, sndstat_handler handler);
544int sndstat_registerfile(char *str);
545int sndstat_unregister(device_t dev);
546int sndstat_unregisterfile(char *str);
547
548#define SND_DECLARE_FILE(version) \
549 _SND_DECLARE_FILE(__LINE__, version)
550
551#define _SND_DECLARE_FILE(uniq, version) \
552 __SND_DECLARE_FILE(uniq, version)
553
554#define __SND_DECLARE_FILE(uniq, version) \
555 static char sndstat_vinfo[] = version; \
556 SYSINIT(sdf_ ## uniq, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, sndstat_registerfile, sndstat_vinfo); \
557 SYSUNINIT(sdf_ ## uniq, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, sndstat_unregisterfile, sndstat_vinfo);
558
559/* usage of flags in device config entry (config file) */
560#define DV_F_DRQ_MASK 0x00000007 /* mask for secondary drq */
561#define DV_F_DUAL_DMA 0x00000010 /* set to use secondary dma channel */
562
563/* ought to be made obsolete but still used by mss */
564#define DV_F_DEV_MASK 0x0000ff00 /* force device type/class */
565#define DV_F_DEV_SHIFT 8 /* force device type/class */
566
567#define PCM_DEBUG_MTX
568
569/*
570 * this is rather kludgey- we need to duplicate these struct def'ns from sound.c
571 * so that the macro versions of pcm_{,un}lock can dereference them.
572 * we also have to do this now makedev() has gone away.
573 */
574
575struct snddev_info {
576 struct {
577 struct {
578 SLIST_HEAD(, pcm_channel) head;
579 struct {
580 SLIST_HEAD(, pcm_channel) head;
581 } busy;
582 } pcm;
583 } channels;
|
| 584 TAILQ_HEAD(dsp_cdevinfo_linkhead, dsp_cdevinfo) dsp_cdevinfo_pool;
|
568 struct snd_clone *clones;
569 struct pcm_channel *fakechan;
570 unsigned devcount, playcount, reccount, pvchancount, rvchancount ;
571 unsigned flags;
572 int inprog;
573 unsigned int bufsz;
574 void *devinfo;
575 device_t dev;
576 char status[SND_STATUSLEN];
577 struct mtx *lock;
578 struct cdev *mixer_dev;
579 uint32_t pvchanrate, pvchanformat;
580 uint32_t rvchanrate, rvchanformat;
581 struct sysctl_ctx_list play_sysctl_ctx, rec_sysctl_ctx;
582 struct sysctl_oid *play_sysctl_tree, *rec_sysctl_tree;
| 585 struct snd_clone *clones;
586 struct pcm_channel *fakechan;
587 unsigned devcount, playcount, reccount, pvchancount, rvchancount ;
588 unsigned flags;
589 int inprog;
590 unsigned int bufsz;
591 void *devinfo;
592 device_t dev;
593 char status[SND_STATUSLEN];
594 struct mtx *lock;
595 struct cdev *mixer_dev;
596 uint32_t pvchanrate, pvchanformat;
597 uint32_t rvchanrate, rvchanformat;
598 struct sysctl_ctx_list play_sysctl_ctx, rec_sysctl_ctx;
599 struct sysctl_oid *play_sysctl_tree, *rec_sysctl_tree;
|
| 600 struct cv cv;
|
583};
584
585void sound_oss_sysinfo(oss_sysinfo *);
586
587#ifdef PCM_DEBUG_MTX
588#define pcm_lock(d) mtx_lock(((struct snddev_info *)(d))->lock)
589#define pcm_unlock(d) mtx_unlock(((struct snddev_info *)(d))->lock)
590#else
591void pcm_lock(struct snddev_info *d);
592void pcm_unlock(struct snddev_info *d);
593#endif
594
| 601};
602
603void sound_oss_sysinfo(oss_sysinfo *);
604
605#ifdef PCM_DEBUG_MTX
606#define pcm_lock(d) mtx_lock(((struct snddev_info *)(d))->lock)
607#define pcm_unlock(d) mtx_unlock(((struct snddev_info *)(d))->lock)
608#else
609void pcm_lock(struct snddev_info *d);
610void pcm_unlock(struct snddev_info *d);
611#endif
612
|
| 613/*
614 * For PCM_CV_[WAIT | ACQUIRE | RELEASE], be sure to surround these
615 * with pcm_lock/unlock() sequence, or I'll come to gnaw upon you!
616 */
617#ifdef SND_DIAGNOSTIC
618#define PCM_WAIT(x) do { \
619 if (mtx_owned((x)->lock) == 0) \
620 panic("%s(%d): [PCM WAIT] Mutex not owned!", \
621 __func__, __LINE__); \
622 while ((x)->flags & SD_F_BUSY) { \
623 if (snd_verbose > 3) \
624 device_printf((x)->dev, \
625 "%s(%d): [PCM WAIT] calling cv_wait().\n", \
626 __func__, __LINE__); \
627 cv_wait(&(x)->cv, (x)->lock); \
628 } \
629} while(0)
630
631#define PCM_ACQUIRE(x) do { \
632 if (mtx_owned((x)->lock) == 0) \
633 panic("%s(%d): [PCM ACQUIRE] Mutex not owned!", \
634 __func__, __LINE__); \
635 if ((x)->flags & SD_F_BUSY) \
636 panic("%s(%d): [PCM ACQUIRE] " \
637 "Trying to acquire BUSY cv!", __func__, __LINE__); \
638 (x)->flags |= SD_F_BUSY; \
639} while(0)
640
641#define PCM_RELEASE(x) do { \
642 if (mtx_owned((x)->lock) == 0) \
643 panic("%s(%d): [PCM RELEASE] Mutex not owned!", \
644 __func__, __LINE__); \
645 if ((x)->flags & SD_F_BUSY) { \
646 (x)->flags &= ~SD_F_BUSY; \
647 if ((x)->cv.cv_waiters != 0) { \
648 if ((x)->cv.cv_waiters > 1 && snd_verbose > 3) \
649 device_printf((x)->dev, \
650 "%s(%d): [PCM RELEASE] " \
651 "cv_waiters=%d > 1!\n", \
652 __func__, __LINE__, \
653 (x)->cv.cv_waiters); \
654 cv_broadcast(&(x)->cv); \
655 } \
656 } else \
657 panic("%s(%d): [PCM RELEASE] Releasing non-BUSY cv!", \
658 __func__, __LINE__); \
659} while(0)
660
661/* Quick version, for shorter path. */
662#define PCM_ACQUIRE_QUICK(x) do { \
663 if (mtx_owned((x)->lock) != 0) \
664 panic("%s(%d): [PCM ACQUIRE QUICK] Mutex owned!", \
665 __func__, __LINE__); \
666 pcm_lock(x); \
667 PCM_WAIT(x); \
668 PCM_ACQUIRE(x); \
669 pcm_unlock(x); \
670} while(0)
671
672#define PCM_RELEASE_QUICK(x) do { \
673 if (mtx_owned((x)->lock) != 0) \
674 panic("%s(%d): [PCM RELEASE QUICK] Mutex owned!", \
675 __func__, __LINE__); \
676 pcm_lock(x); \
677 PCM_RELEASE(x); \
678 pcm_unlock(x); \
679} while(0)
680
681#define PCM_BUSYASSERT(x) do { \
682 if (!((x) != NULL && ((x)->flags & SD_F_BUSY))) \
683 panic("%s(%d): [PCM BUSYASSERT] " \
684 "Failed, snddev_info=%p", __func__, __LINE__, x); \
685} while(0)
686
687#define PCM_GIANT_ENTER(x) do { \
688 int _pcm_giant = 0; \
689 if (mtx_owned((x)->lock) != 0) \
690 panic("%s(%d): [GIANT ENTER] PCM lock owned!", \
691 __func__, __LINE__); \
692 if (mtx_owned(&Giant) != 0 && snd_verbose > 3) \
693 device_printf((x)->dev, \
694 "%s(%d): [GIANT ENTER] Giant owned!\n", \
695 __func__, __LINE__); \
696 if (!((x)->flags & SD_F_MPSAFE) && mtx_owned(&Giant) == 0) \
697 do { \
698 mtx_lock(&Giant); \
699 _pcm_giant = 1; \
700 } while(0)
701
702#define PCM_GIANT_EXIT(x) do { \
703 if (mtx_owned((x)->lock) != 0) \
704 panic("%s(%d): [GIANT EXIT] PCM lock owned!", \
705 __func__, __LINE__); \
706 if (!(_pcm_giant == 0 || _pcm_giant == 1)) \
707 panic("%s(%d): [GIANT EXIT] _pcm_giant screwed!", \
708 __func__, __LINE__); \
709 if ((x)->flags & SD_F_MPSAFE) { \
710 if (_pcm_giant == 1) \
711 panic("%s(%d): [GIANT EXIT] MPSAFE Giant?", \
712 __func__, __LINE__); \
713 if (mtx_owned(&Giant) != 0 && snd_verbose > 3) \
714 device_printf((x)->dev, \
715 "%s(%d): [GIANT EXIT] Giant owned!\n", \
716 __func__, __LINE__); \
717 } \
718 if (_pcm_giant != 0) { \
719 if (mtx_owned(&Giant) == 0) \
720 panic("%s(%d): [GIANT EXIT] Giant not owned!", \
721 __func__, __LINE__); \
722 _pcm_giant = 0; \
723 mtx_unlock(&Giant); \
724 } \
725} while(0)
726#else /* SND_DIAGNOSTIC */
727#define PCM_WAIT(x) do { \
728 mtx_assert((x)->lock, MA_OWNED); \
729 while ((x)->flags & SD_F_BUSY) \
730 cv_wait(&(x)->cv, (x)->lock); \
731} while(0)
732
733#define PCM_ACQUIRE(x) do { \
734 mtx_assert((x)->lock, MA_OWNED); \
735 KASSERT(!((x)->flags & SD_F_BUSY), \
736 ("%s(%d): [PCM ACQUIRE] Trying to acquire BUSY cv!", \
737 __func__, __LINE__)); \
738 (x)->flags |= SD_F_BUSY; \
739} while(0)
740
741#define PCM_RELEASE(x) do { \
742 mtx_assert((x)->lock, MA_OWNED); \
743 KASSERT((x)->flags & SD_F_BUSY, \
744 ("%s(%d): [PCM RELEASE] Releasing non-BUSY cv!", \
745 __func__, __LINE__)); \
746 (x)->flags &= ~SD_F_BUSY; \
747 if ((x)->cv.cv_waiters != 0) \
748 cv_broadcast(&(x)->cv); \
749} while(0)
750
751/* Quick version, for shorter path. */
752#define PCM_ACQUIRE_QUICK(x) do { \
753 mtx_assert((x)->lock, MA_NOTOWNED); \
754 pcm_lock(x); \
755 PCM_WAIT(x); \
756 PCM_ACQUIRE(x); \
757 pcm_unlock(x); \
758} while(0)
759
760#define PCM_RELEASE_QUICK(x) do { \
761 mtx_assert((x)->lock, MA_NOTOWNED); \
762 pcm_lock(x); \
763 PCM_RELEASE(x); \
764 pcm_unlock(x); \
765} while(0)
766
767#define PCM_BUSYASSERT(x) KASSERT(x != NULL && \
768 ((x)->flags & SD_F_BUSY), \
769 ("%s(%d): [PCM BUSYASSERT] " \
770 "Failed, snddev_info=%p", \
771 __func__, __LINE__, x))
772
773#define PCM_GIANT_ENTER(x) do { \
774 int _pcm_giant = 0; \
775 mtx_assert((x)->lock, MA_NOTOWNED); \
776 if (!((x)->flags & SD_F_MPSAFE) && mtx_owned(&Giant) == 0) \
777 do { \
778 mtx_lock(&Giant); \
779 _pcm_giant = 1; \
780 } while(0)
781
782#define PCM_GIANT_EXIT(x) do { \
783 mtx_assert((x)->lock, MA_NOTOWNED); \
784 KASSERT(_pcm_giant == 0 || _pcm_giant == 1, \
785 ("%s(%d): [GIANT EXIT] _pcm_giant screwed!", \
786 __func__, __LINE__)); \
787 KASSERT(!((x)->flags & SD_F_MPSAFE) || \
788 (((x)->flags & SD_F_MPSAFE) && _pcm_giant == 0), \
789 ("%s(%d): [GIANT EXIT] MPSAFE Giant?", \
790 __func__, __LINE__)); \
791 if (_pcm_giant != 0) { \
792 mtx_assert(&Giant, MA_OWNED); \
793 _pcm_giant = 0; \
794 mtx_unlock(&Giant); \
795 } \
796} while(0)
797#endif /* !SND_DIAGNOSTIC */
798
799#define PCM_GIANT_LEAVE(x) \
800 PCM_GIANT_EXIT(x); \
801} while(0)
802
|
595#ifdef KLD_MODULE
596#define PCM_KLDSTRING(a) ("kld " # a)
597#else
598#define PCM_KLDSTRING(a) ""
599#endif
600
601#endif /* _KERNEL */
602
603#endif /* _OS_H_ */
| 803#ifdef KLD_MODULE
804#define PCM_KLDSTRING(a) ("kld " # a)
805#else
806#define PCM_KLDSTRING(a) ""
807#endif
808
809#endif /* _KERNEL */
810
811#endif /* _OS_H_ */
|