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$
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
88 struct pcm_channel;
89 struct pcm_feeder;
90 struct snd_dbuf;
91 struct 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
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
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
185 typedef int64_t intpcm_t;
186 #else
187 typedef 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
446 struct pcm_channel *fkchan_setup(device_t dev);
447 int 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
483 #define DSP_DEFAULT_SPEED 8000
484
485 #define ON 1
486 #define OFF 0
487
488 extern int pcm_veto_load;
489 extern int snd_unit;
490 extern int snd_maxautovchans;
491 extern int snd_verbose;
492 extern devclass_t pcm_devclass;
493 extern 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
506 SYSCTL_DECL(_hw_snd);
507
508 struct pcm_channel *pcm_getfakechan(struct snddev_info *d);
509 int pcm_chnalloc(struct snddev_info *d, struct pcm_channel **ch, int direction, pid_t pid, int devunit);
510 int pcm_chnrelease(struct pcm_channel *c);
511 int pcm_chnref(struct pcm_channel *c, int ref);
512 int pcm_inprog(struct snddev_info *d, int delta);
513
514 struct pcm_channel *pcm_chn_create(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls, int dir, int num, void *devinfo);
515 int pcm_chn_destroy(struct pcm_channel *ch);
516 int pcm_chn_add(struct snddev_info *d, struct pcm_channel *ch);
517 int pcm_chn_remove(struct snddev_info *d, struct pcm_channel *ch);
518
519 int pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo);
520 unsigned int pcm_getbuffersize(device_t dev, unsigned int minbufsz, unsigned int deflt, unsigned int maxbufsz);
521 int pcm_register(device_t dev, void *devinfo, int numplay, int numrec);
522 int pcm_unregister(device_t dev);
523 int pcm_setstatus(device_t dev, char *str);
524 u_int32_t pcm_getflags(device_t dev);
525 void pcm_setflags(device_t dev, u_int32_t val);
526 void *pcm_getdevinfo(device_t dev);
527
528
529 int snd_setup_intr(device_t dev, struct resource *res, int flags,
530 driver_intr_t hand, void *param, void **cookiep);
531
532 void *snd_mtxcreate(const char *desc, const char *type);
533 void snd_mtxfree(void *m);
534 void snd_mtxassert(void *m);
535 #define snd_mtxlock(m) mtx_lock(m)
536 #define snd_mtxunlock(m) mtx_unlock(m)
537
538 int sysctl_hw_snd_vchans(SYSCTL_HANDLER_ARGS);
539
540 typedef int (*sndstat_handler)(struct sbuf *s, device_t dev, int verbose);
541 int sndstat_acquire(struct thread *td);
542 int sndstat_release(struct thread *td);
543 int sndstat_register(device_t dev, char *str, sndstat_handler handler);
544 int sndstat_registerfile(char *str);
545 int sndstat_unregister(device_t dev);
546 int 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
575 struct 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;
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;
601 };
602
603 void 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
609 void pcm_lock(struct snddev_info *d);
610 void 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
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_ */
Cache object: 6a1571bd445ffdc874bf3ad20d35eafe
|