1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
5 * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006
6 * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org>
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31#ifdef HAVE_KERNEL_OPTION_HEADERS
32#include "opt_snd.h"
33#endif
34
35#include <dev/sound/pcm/sound.h>
36#include <sys/ctype.h>
37#include <sys/lock.h>
38#include <sys/rwlock.h>
39#include <sys/sysent.h>
40
41#include <vm/vm.h>
42#include <vm/vm_object.h>
43#include <vm/vm_page.h>
44#include <vm/vm_pager.h>
45
46SND_DECLARE_FILE("$FreeBSD$");
47
48static int dsp_mmap_allow_prot_exec = 0;
49SYSCTL_INT(_hw_snd, OID_AUTO, compat_linux_mmap, CTLFLAG_RWTUN,
50    &dsp_mmap_allow_prot_exec, 0,
51    "linux mmap compatibility (-1=force disable 0=auto 1=force enable)");
52
53static int dsp_basename_clone = 1;
54SYSCTL_INT(_hw_snd, OID_AUTO, basename_clone, CTLFLAG_RWTUN,
55    &dsp_basename_clone, 0,
56    "DSP basename cloning (0: Disable; 1: Enabled)");
57
58struct dsp_cdevinfo {
59	struct pcm_channel *rdch, *wrch;
60	struct pcm_channel *volch;
61	int busy, simplex;
62	TAILQ_ENTRY(dsp_cdevinfo) link;
63};
64
65#define PCM_RDCH(x)		(((struct dsp_cdevinfo *)(x)->si_drv1)->rdch)
66#define PCM_WRCH(x)		(((struct dsp_cdevinfo *)(x)->si_drv1)->wrch)
67#define PCM_VOLCH(x)		(((struct dsp_cdevinfo *)(x)->si_drv1)->volch)
68#define PCM_SIMPLEX(x)		(((struct dsp_cdevinfo *)(x)->si_drv1)->simplex)
69
70#define DSP_CDEVINFO_CACHESIZE	8
71
72#define DSP_REGISTERED(x, y)	(PCM_REGISTERED(x) &&			\
73				 (y) != NULL && (y)->si_drv1 != NULL)
74
75#define OLDPCM_IOCTL
76
77static d_open_t dsp_open;
78static d_close_t dsp_close;
79static d_read_t dsp_read;
80static d_write_t dsp_write;
81static d_ioctl_t dsp_ioctl;
82static d_poll_t dsp_poll;
83static d_mmap_t dsp_mmap;
84static d_mmap_single_t dsp_mmap_single;
85
86struct cdevsw dsp_cdevsw = {
87	.d_version =	D_VERSION,
88	.d_open =	dsp_open,
89	.d_close =	dsp_close,
90	.d_read =	dsp_read,
91	.d_write =	dsp_write,
92	.d_ioctl =	dsp_ioctl,
93	.d_poll =	dsp_poll,
94	.d_mmap =	dsp_mmap,
95	.d_mmap_single = dsp_mmap_single,
96	.d_name =	"dsp",
97};
98
99static eventhandler_tag dsp_ehtag = NULL;
100static int dsp_umax = -1;
101static int dsp_cmax = -1;
102
103static int dsp_oss_syncgroup(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_syncgroup *group);
104static int dsp_oss_syncstart(int sg_id);
105static int dsp_oss_policy(struct pcm_channel *wrch, struct pcm_channel *rdch, int policy);
106static int dsp_oss_cookedmode(struct pcm_channel *wrch, struct pcm_channel *rdch, int enabled);
107static int dsp_oss_getchnorder(struct pcm_channel *wrch, struct pcm_channel *rdch, unsigned long long *map);
108static int dsp_oss_setchnorder(struct pcm_channel *wrch, struct pcm_channel *rdch, unsigned long long *map);
109static int dsp_oss_getchannelmask(struct pcm_channel *wrch, struct pcm_channel *rdch, int *mask);
110#ifdef OSSV4_EXPERIMENT
111static int dsp_oss_getlabel(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_label_t *label);
112static int dsp_oss_setlabel(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_label_t *label);
113static int dsp_oss_getsong(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_longname_t *song);
114static int dsp_oss_setsong(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_longname_t *song);
115static int dsp_oss_setname(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_longname_t *name);
116#endif
117
118static struct snddev_info *
119dsp_get_info(struct cdev *dev)
120{
121	return (devclass_get_softc(pcm_devclass, PCMUNIT(dev)));
122}
123
124static uint32_t
125dsp_get_flags(struct cdev *dev)
126{
127	device_t bdev;
128
129	bdev = devclass_get_device(pcm_devclass, PCMUNIT(dev));
130
131	return ((bdev != NULL) ? pcm_getflags(bdev) : 0xffffffff);
132}
133
134static void
135dsp_set_flags(struct cdev *dev, uint32_t flags)
136{
137	device_t bdev;
138
139	bdev = devclass_get_device(pcm_devclass, PCMUNIT(dev));
140
141	if (bdev != NULL)
142		pcm_setflags(bdev, flags);
143}
144
145/*
146 * return the channels associated with an open device instance.
147 * lock channels specified.
148 */
149static int
150getchns(struct cdev *dev, struct pcm_channel **rdch, struct pcm_channel **wrch,
151    uint32_t prio)
152{
153	struct snddev_info *d;
154	struct pcm_channel *ch;
155	uint32_t flags;
156
157	if (PCM_SIMPLEX(dev) != 0) {
158		d = dsp_get_info(dev);
159		if (!PCM_REGISTERED(d))
160			return (ENXIO);
161		PCM_LOCK(d);
162		PCM_WAIT(d);
163		PCM_ACQUIRE(d);
164		/*
165		 * Note: order is important -
166		 *       pcm flags -> prio query flags -> wild guess
167		 */
168		ch = NULL;
169		flags = dsp_get_flags(dev);
170		if (flags & SD_F_PRIO_WR) {
171			ch = PCM_RDCH(dev);
172			PCM_RDCH(dev) = NULL;
173		} else if (flags & SD_F_PRIO_RD) {
174			ch = PCM_WRCH(dev);
175			PCM_WRCH(dev) = NULL;
176		} else if (prio & SD_F_PRIO_WR) {
177			ch = PCM_RDCH(dev);
178			PCM_RDCH(dev) = NULL;
179			flags |= SD_F_PRIO_WR;
180		} else if (prio & SD_F_PRIO_RD) {
181			ch = PCM_WRCH(dev);
182			PCM_WRCH(dev) = NULL;
183			flags |= SD_F_PRIO_RD;
184		} else if (PCM_WRCH(dev) != NULL) {
185			ch = PCM_RDCH(dev);
186			PCM_RDCH(dev) = NULL;
187			flags |= SD_F_PRIO_WR;
188		} else if (PCM_RDCH(dev) != NULL) {
189			ch = PCM_WRCH(dev);
190			PCM_WRCH(dev) = NULL;
191			flags |= SD_F_PRIO_RD;
192		}
193		PCM_SIMPLEX(dev) = 0;
194		dsp_set_flags(dev, flags);
195		if (ch != NULL) {
196			CHN_LOCK(ch);
197			pcm_chnref(ch, -1);
198			pcm_chnrelease(ch);
199		}
200		PCM_RELEASE(d);
201		PCM_UNLOCK(d);
202	}
203
204	*rdch = PCM_RDCH(dev);
205	*wrch = PCM_WRCH(dev);
206
207	if (*rdch != NULL && (prio & SD_F_PRIO_RD))
208		CHN_LOCK(*rdch);
209	if (*wrch != NULL && (prio & SD_F_PRIO_WR))
210		CHN_LOCK(*wrch);
211
212	return (0);
213}
214
215/* unlock specified channels */
216static void
217relchns(struct cdev *dev, struct pcm_channel *rdch, struct pcm_channel *wrch,
218    uint32_t prio)
219{
220	if (wrch != NULL && (prio & SD_F_PRIO_WR))
221		CHN_UNLOCK(wrch);
222	if (rdch != NULL && (prio & SD_F_PRIO_RD))
223		CHN_UNLOCK(rdch);
224}
225
226static void
227dsp_cdevinfo_alloc(struct cdev *dev,
228    struct pcm_channel *rdch, struct pcm_channel *wrch,
229    struct pcm_channel *volch)
230{
231	struct snddev_info *d;
232	struct dsp_cdevinfo *cdi;
233	int simplex;
234
235	d = dsp_get_info(dev);
236
237	KASSERT(PCM_REGISTERED(d) && dev != NULL && dev->si_drv1 == NULL &&
238	    ((rdch == NULL && wrch == NULL) || rdch != wrch),
239	    ("bogus %s(), what are you trying to accomplish here?", __func__));
240	PCM_BUSYASSERT(d);
241	PCM_LOCKASSERT(d);
242
243	simplex = (dsp_get_flags(dev) & SD_F_SIMPLEX) ? 1 : 0;
244
245	/*
246	 * Scan for free instance entry and put it into the end of list.
247	 * Create new one if necessary.
248	 */
249	TAILQ_FOREACH(cdi, &d->dsp_cdevinfo_pool, link) {
250		if (cdi->busy != 0)
251			break;
252		cdi->rdch = rdch;
253		cdi->wrch = wrch;
254		cdi->volch = volch;
255		cdi->simplex = simplex;
256		cdi->busy = 1;
257		TAILQ_REMOVE(&d->dsp_cdevinfo_pool, cdi, link);
258		TAILQ_INSERT_TAIL(&d->dsp_cdevinfo_pool, cdi, link);
259		dev->si_drv1 = cdi;
260		return;
261	}
262	PCM_UNLOCK(d);
263	cdi = malloc(sizeof(*cdi), M_DEVBUF, M_WAITOK | M_ZERO);
264	PCM_LOCK(d);
265	cdi->rdch = rdch;
266	cdi->wrch = wrch;
267	cdi->volch = volch;
268	cdi->simplex = simplex;
269	cdi->busy = 1;
270	TAILQ_INSERT_TAIL(&d->dsp_cdevinfo_pool, cdi, link);
271	dev->si_drv1 = cdi;
272}
273
274static void
275dsp_cdevinfo_free(struct cdev *dev)
276{
277	struct snddev_info *d;
278	struct dsp_cdevinfo *cdi, *tmp;
279	uint32_t flags;
280	int i;
281
282	d = dsp_get_info(dev);
283
284	KASSERT(PCM_REGISTERED(d) && dev != NULL && dev->si_drv1 != NULL &&
285	    PCM_RDCH(dev) == NULL && PCM_WRCH(dev) == NULL &&
286	    PCM_VOLCH(dev) == NULL,
287	    ("bogus %s(), what are you trying to accomplish here?", __func__));
288	PCM_BUSYASSERT(d);
289	PCM_LOCKASSERT(d);
290
291	cdi = dev->si_drv1;
292	dev->si_drv1 = NULL;
293	cdi->rdch = NULL;
294	cdi->wrch = NULL;
295	cdi->volch = NULL;
296	cdi->simplex = 0;
297	cdi->busy = 0;
298
299	/*
300	 * Once it is free, move it back to the beginning of list for
301	 * faster new entry allocation.
302	 */
303	TAILQ_REMOVE(&d->dsp_cdevinfo_pool, cdi, link);
304	TAILQ_INSERT_HEAD(&d->dsp_cdevinfo_pool, cdi, link);
305
306	/*
307	 * Scan the list, cache free entries up to DSP_CDEVINFO_CACHESIZE.
308	 * Reset simplex flags.
309	 */
310	flags = dsp_get_flags(dev) & ~SD_F_PRIO_SET;
311	i = DSP_CDEVINFO_CACHESIZE;
312	TAILQ_FOREACH_SAFE(cdi, &d->dsp_cdevinfo_pool, link, tmp) {
313		if (cdi->busy != 0) {
314			if (cdi->simplex == 0) {
315				if (cdi->rdch != NULL)
316					flags |= SD_F_PRIO_RD;
317				if (cdi->wrch != NULL)
318					flags |= SD_F_PRIO_WR;
319			}
320		} else {
321			if (i == 0) {
322				TAILQ_REMOVE(&d->dsp_cdevinfo_pool, cdi, link);
323				free(cdi, M_DEVBUF);
324			} else
325				i--;
326		}
327	}
328	dsp_set_flags(dev, flags);
329}
330
331void
332dsp_cdevinfo_init(struct snddev_info *d)
333{
334	struct dsp_cdevinfo *cdi;
335	int i;
336
337	KASSERT(d != NULL, ("NULL snddev_info"));
338	PCM_BUSYASSERT(d);
339	PCM_UNLOCKASSERT(d);
340
341	TAILQ_INIT(&d->dsp_cdevinfo_pool);
342	for (i = 0; i < DSP_CDEVINFO_CACHESIZE; i++) {
343		cdi = malloc(sizeof(*cdi), M_DEVBUF, M_WAITOK | M_ZERO);
344		TAILQ_INSERT_HEAD(&d->dsp_cdevinfo_pool, cdi, link);
345	}
346}
347
348void
349dsp_cdevinfo_flush(struct snddev_info *d)
350{
351	struct dsp_cdevinfo *cdi, *tmp;
352
353	KASSERT(d != NULL, ("NULL snddev_info"));
354	PCM_BUSYASSERT(d);
355	PCM_UNLOCKASSERT(d);
356
357	cdi = TAILQ_FIRST(&d->dsp_cdevinfo_pool);
358	while (cdi != NULL) {
359		tmp = TAILQ_NEXT(cdi, link);
360		free(cdi, M_DEVBUF);
361		cdi = tmp;
362	}
363	TAILQ_INIT(&d->dsp_cdevinfo_pool);
364}
365
366/* duplex / simplex cdev type */
367enum {
368	DSP_CDEV_TYPE_RDONLY,		/* simplex read-only (record)   */
369	DSP_CDEV_TYPE_WRONLY,		/* simplex write-only (play)    */
370	DSP_CDEV_TYPE_RDWR		/* duplex read, write, or both  */
371};
372
373enum {
374	DSP_CDEV_VOLCTL_NONE,
375	DSP_CDEV_VOLCTL_READ,
376	DSP_CDEV_VOLCTL_WRITE
377};
378
379#define DSP_F_VALID(x)		((x) & (FREAD | FWRITE))
380#define DSP_F_DUPLEX(x)		(((x) & (FREAD | FWRITE)) == (FREAD | FWRITE))
381#define DSP_F_SIMPLEX(x)	(!DSP_F_DUPLEX(x))
382#define DSP_F_READ(x)		((x) & FREAD)
383#define DSP_F_WRITE(x)		((x) & FWRITE)
384
385static const struct {
386	int type;
387	char *name;
388	char *sep;
389	char *alias;
390	int use_sep;
391	int hw;
392	int max;
393	int volctl;
394	uint32_t fmt, spd;
395	int query;
396} dsp_cdevs[] = {
397	{ SND_DEV_DSP,         "dsp",    ".", NULL, 0, 0, 0, 0,
398	  SND_FORMAT(AFMT_U8, 1, 0),     DSP_DEFAULT_SPEED,
399	  DSP_CDEV_TYPE_RDWR },
400	{ SND_DEV_AUDIO,       "audio",  ".", NULL, 0, 0, 0, 0,
401	  SND_FORMAT(AFMT_MU_LAW, 1, 0), DSP_DEFAULT_SPEED,
402	  DSP_CDEV_TYPE_RDWR },
403	{ SND_DEV_DSP16,       "dspW",   ".", NULL, 0, 0, 0, 0,
404	  SND_FORMAT(AFMT_S16_LE, 1, 0), DSP_DEFAULT_SPEED,
405	  DSP_CDEV_TYPE_RDWR },
406	{ SND_DEV_DSPHW_PLAY,  "dsp",   ".p", NULL, 1, 1, SND_MAXHWCHAN, 1,
407	  SND_FORMAT(AFMT_S16_LE, 2, 0), 48000, DSP_CDEV_TYPE_WRONLY },
408	{ SND_DEV_DSPHW_VPLAY, "dsp",  ".vp", NULL, 1, 1, SND_MAXVCHANS, 1,
409	  SND_FORMAT(AFMT_S16_LE, 2, 0), 48000, DSP_CDEV_TYPE_WRONLY },
410	{ SND_DEV_DSPHW_REC,   "dsp",   ".r", NULL, 1, 1, SND_MAXHWCHAN, 1,
411	  SND_FORMAT(AFMT_S16_LE, 2, 0), 48000, DSP_CDEV_TYPE_RDONLY },
412	{ SND_DEV_DSPHW_VREC,  "dsp",  ".vr", NULL, 1, 1, SND_MAXVCHANS, 1,
413	  SND_FORMAT(AFMT_S16_LE, 2, 0), 48000, DSP_CDEV_TYPE_RDONLY },
414	{ SND_DEV_DSPHW_CD,    "dspcd",  ".", NULL, 0, 0, 0, 0,
415	  SND_FORMAT(AFMT_S16_LE, 2, 0), 44100, DSP_CDEV_TYPE_RDWR   },
416	/* Low priority, OSSv4 aliases. */
417	{ SND_DEV_DSP,      "dsp_ac3",   ".", "dsp", 0, 0, 0, 0,
418	  SND_FORMAT(AFMT_U8, 1, 0),     DSP_DEFAULT_SPEED,
419	  DSP_CDEV_TYPE_RDWR },
420	{ SND_DEV_DSP,     "dsp_mmap",   ".", "dsp", 0, 0, 0, 0,
421	  SND_FORMAT(AFMT_U8, 1, 0),     DSP_DEFAULT_SPEED,
422	  DSP_CDEV_TYPE_RDWR },
423	{ SND_DEV_DSP,  "dsp_multich",   ".", "dsp", 0, 0, 0, 0,
424	  SND_FORMAT(AFMT_U8, 1, 0),     DSP_DEFAULT_SPEED,
425	  DSP_CDEV_TYPE_RDWR },
426	{ SND_DEV_DSP, "dsp_spdifout",   ".", "dsp", 0, 0, 0, 0,
427	  SND_FORMAT(AFMT_U8, 1, 0),     DSP_DEFAULT_SPEED,
428	  DSP_CDEV_TYPE_RDWR },
429	{ SND_DEV_DSP,  "dsp_spdifin",   ".", "dsp", 0, 0, 0, 0,
430	  SND_FORMAT(AFMT_U8, 1, 0),     DSP_DEFAULT_SPEED,
431	  DSP_CDEV_TYPE_RDWR },
432};
433
434#define DSP_FIXUP_ERROR()		do {				\
435	prio = dsp_get_flags(i_dev);					\
436	if (!DSP_F_VALID(flags))					\
437		error = EINVAL;						\
438	if (!DSP_F_DUPLEX(flags) &&					\
439	    ((DSP_F_READ(flags) && d->reccount == 0) ||			\
440	    (DSP_F_WRITE(flags) && d->playcount == 0)))			\
441		error = ENOTSUP;					\
442	else if (!DSP_F_DUPLEX(flags) && (prio & SD_F_SIMPLEX) &&	\
443	    ((DSP_F_READ(flags) && (prio & SD_F_PRIO_WR)) ||		\
444	    (DSP_F_WRITE(flags) && (prio & SD_F_PRIO_RD))))		\
445		error = EBUSY;						\
446	else if (DSP_REGISTERED(d, i_dev))				\
447		error = EBUSY;						\
448} while (0)
449
450static int
451dsp_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
452{
453	struct pcm_channel *rdch, *wrch;
454	struct snddev_info *d;
455	uint32_t fmt, spd, prio, volctl;
456	int i, error, rderror, wrerror, devtype, wdevunit, rdevunit;
457
458	/* Kind of impossible.. */
459	if (i_dev == NULL || td == NULL)
460		return (ENODEV);
461
462	d = dsp_get_info(i_dev);
463	if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
464		return (EBADF);
465
466	PCM_GIANT_ENTER(d);
467
468	/* Lock snddev so nobody else can monkey with it. */
469	PCM_LOCK(d);
470	PCM_WAIT(d);
471
472	/*
473	 * Try to acquire cloned device before someone else pick it.
474	 * ENODEV means this is not a cloned droids.
475	 */
476	error = snd_clone_acquire(i_dev);
477	if (!(error == 0 || error == ENODEV)) {
478		DSP_FIXUP_ERROR();
479		PCM_UNLOCK(d);
480		PCM_GIANT_EXIT(d);
481		return (error);
482	}
483
484	error = 0;
485	DSP_FIXUP_ERROR();
486
487	if (error != 0) {
488		(void)snd_clone_release(i_dev);
489		PCM_UNLOCK(d);
490		PCM_GIANT_EXIT(d);
491		return (error);
492	}
493
494	/*
495	 * That is just enough. Acquire and unlock pcm lock so
496	 * the other will just have to wait until we finish doing
497	 * everything.
498	 */
499	PCM_ACQUIRE(d);
500	PCM_UNLOCK(d);
501
502	devtype = PCMDEV(i_dev);
503	wdevunit = -1;
504	rdevunit = -1;
505	fmt = 0;
506	spd = 0;
507	volctl = DSP_CDEV_VOLCTL_NONE;
508
509	for (i = 0; i < (sizeof(dsp_cdevs) / sizeof(dsp_cdevs[0])); i++) {
510		if (devtype != dsp_cdevs[i].type || dsp_cdevs[i].alias != NULL)
511			continue;
512		/*
513		 * Volume control only valid for DSPHW devices,
514		 * and it must be opened in opposite direction be it
515		 * simplex or duplex. Anything else will be handled
516		 * as usual.
517		 */
518		if (dsp_cdevs[i].query == DSP_CDEV_TYPE_WRONLY) {
519			if (dsp_cdevs[i].volctl != 0 &&
520			    DSP_F_READ(flags)) {
521				volctl = DSP_CDEV_VOLCTL_WRITE;
522				flags &= ~FREAD;
523				flags |= FWRITE;
524			}
525			if (DSP_F_READ(flags)) {
526				(void)snd_clone_release(i_dev);
527				PCM_RELEASE_QUICK(d);
528				PCM_GIANT_EXIT(d);
529				return (ENOTSUP);
530			}
531			wdevunit = dev2unit(i_dev);
532		} else if (dsp_cdevs[i].query == DSP_CDEV_TYPE_RDONLY) {
533			if (dsp_cdevs[i].volctl != 0 &&
534			    DSP_F_WRITE(flags)) {
535				volctl = DSP_CDEV_VOLCTL_READ;
536				flags &= ~FWRITE;
537				flags |= FREAD;
538			}
539			if (DSP_F_WRITE(flags)) {
540				(void)snd_clone_release(i_dev);
541				PCM_RELEASE_QUICK(d);
542				PCM_GIANT_EXIT(d);
543				return (ENOTSUP);
544			}
545			rdevunit = dev2unit(i_dev);
546		}
547		fmt = dsp_cdevs[i].fmt;
548		spd = dsp_cdevs[i].spd;
549		break;
550	}
551
552	/* No matching devtype? */
553	if (fmt == 0 || spd == 0)
554		panic("impossible devtype %d", devtype);
555
556	rdch = NULL;
557	wrch = NULL;
558	rderror = 0;
559	wrerror = 0;
560
561	/*
562	 * if we get here, the open request is valid- either:
563	 *   * we were previously not open
564	 *   * we were open for play xor record and the opener wants
565	 *     the non-open direction
566	 */
567	if (DSP_F_READ(flags)) {
568		/* open for read */
569		rderror = pcm_chnalloc(d, &rdch, PCMDIR_REC,
570		    td->td_proc->p_pid, td->td_proc->p_comm, rdevunit);
571
572		if (rderror == 0 && chn_reset(rdch, fmt, spd) != 0)
573			rderror = ENXIO;
574
575		if (volctl == DSP_CDEV_VOLCTL_READ)
576			rderror = 0;
577
578		if (rderror != 0) {
579			if (rdch != NULL)
580				pcm_chnrelease(rdch);
581			if (!DSP_F_DUPLEX(flags)) {
582				(void)snd_clone_release(i_dev);
583				PCM_RELEASE_QUICK(d);
584				PCM_GIANT_EXIT(d);
585				return (rderror);
586			}
587			rdch = NULL;
588		} else if (volctl == DSP_CDEV_VOLCTL_READ) {
589			if (rdch != NULL) {
590				pcm_chnref(rdch, 1);
591				pcm_chnrelease(rdch);
592			}
593		} else {
594			if (flags & O_NONBLOCK)
595				rdch->flags |= CHN_F_NBIO;
596			if (flags & O_EXCL)
597				rdch->flags |= CHN_F_EXCLUSIVE;
598			pcm_chnref(rdch, 1);
599			if (volctl == DSP_CDEV_VOLCTL_NONE)
600				chn_vpc_reset(rdch, SND_VOL_C_PCM, 0);
601		 	CHN_UNLOCK(rdch);
602		}
603	}
604
605	if (DSP_F_WRITE(flags)) {
606		/* open for write */
607		wrerror = pcm_chnalloc(d, &wrch, PCMDIR_PLAY,
608		    td->td_proc->p_pid, td->td_proc->p_comm, wdevunit);
609
610		if (wrerror == 0 && chn_reset(wrch, fmt, spd) != 0)
611			wrerror = ENXIO;
612
613		if (volctl == DSP_CDEV_VOLCTL_WRITE)
614			wrerror = 0;
615
616		if (wrerror != 0) {
617			if (wrch != NULL)
618				pcm_chnrelease(wrch);
619			if (!DSP_F_DUPLEX(flags)) {
620				if (rdch != NULL) {
621					/*
622					 * Lock, deref and release previously
623					 * created record channel
624					 */
625					CHN_LOCK(rdch);
626					pcm_chnref(rdch, -1);
627					pcm_chnrelease(rdch);
628				}
629				(void)snd_clone_release(i_dev);
630				PCM_RELEASE_QUICK(d);
631				PCM_GIANT_EXIT(d);
632				return (wrerror);
633			}
634			wrch = NULL;
635		} else if (volctl == DSP_CDEV_VOLCTL_WRITE) {
636			if (wrch != NULL) {
637				pcm_chnref(wrch, 1);
638				pcm_chnrelease(wrch);
639			}
640		} else {
641			if (flags & O_NONBLOCK)
642				wrch->flags |= CHN_F_NBIO;
643			if (flags & O_EXCL)
644				wrch->flags |= CHN_F_EXCLUSIVE;
645			pcm_chnref(wrch, 1);
646			if (volctl == DSP_CDEV_VOLCTL_NONE)
647				chn_vpc_reset(wrch, SND_VOL_C_PCM, 0);
648			CHN_UNLOCK(wrch);
649		}
650	}
651
652
653	PCM_LOCK(d);
654
655	/*
656	 * We're done. Allocate channels information for this cdev.
657	 */
658	switch (volctl) {
659	case DSP_CDEV_VOLCTL_READ:
660		KASSERT(wrch == NULL, ("wrch=%p not null!", wrch));
661		dsp_cdevinfo_alloc(i_dev, NULL, NULL, rdch);
662		break;
663	case DSP_CDEV_VOLCTL_WRITE:
664		KASSERT(rdch == NULL, ("rdch=%p not null!", rdch));
665		dsp_cdevinfo_alloc(i_dev, NULL, NULL, wrch);
666		break;
667	case DSP_CDEV_VOLCTL_NONE:
668	default:
669		if (wrch == NULL && rdch == NULL) {
670			(void)snd_clone_release(i_dev);
671			PCM_RELEASE(d);
672			PCM_UNLOCK(d);
673			PCM_GIANT_EXIT(d);
674			if (wrerror != 0)
675				return (wrerror);
676			if (rderror != 0)
677				return (rderror);
678			return (EINVAL);
679		}
680		dsp_cdevinfo_alloc(i_dev, rdch, wrch, NULL);
681		if (rdch != NULL)
682			CHN_INSERT_HEAD(d, rdch, channels.pcm.opened);
683		if (wrch != NULL)
684			CHN_INSERT_HEAD(d, wrch, channels.pcm.opened);
685		break;
686	}
687
688	/*
689	 * Increase clone refcount for its automatic garbage collector.
690	 */
691	(void)snd_clone_ref(i_dev);
692
693	PCM_RELEASE(d);
694	PCM_UNLOCK(d);
695
696	PCM_GIANT_LEAVE(d);
697
698	return (0);
699}
700
701static int
702dsp_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
703{
704	struct pcm_channel *rdch, *wrch, *volch;
705	struct snddev_info *d;
706	int sg_ids, rdref, wdref;
707
708	d = dsp_get_info(i_dev);
709	if (!DSP_REGISTERED(d, i_dev))
710		return (EBADF);
711
712	PCM_GIANT_ENTER(d);
713
714	PCM_LOCK(d);
715	PCM_WAIT(d);
716	PCM_ACQUIRE(d);
717
718	rdch = PCM_RDCH(i_dev);
719	wrch = PCM_WRCH(i_dev);
720	volch = PCM_VOLCH(i_dev);
721
722	PCM_RDCH(i_dev) = NULL;
723	PCM_WRCH(i_dev) = NULL;
724	PCM_VOLCH(i_dev) = NULL;
725
726	rdref = -1;
727	wdref = -1;
728
729	if (volch != NULL) {
730		if (volch == rdch)
731			rdref--;
732		else if (volch == wrch)
733			wdref--;
734		else {
735			CHN_LOCK(volch);
736			pcm_chnref(volch, -1);
737			CHN_UNLOCK(volch);
738		}
739	}
740
741	if (rdch != NULL)
742		CHN_REMOVE(d, rdch, channels.pcm.opened);
743	if (wrch != NULL)
744		CHN_REMOVE(d, wrch, channels.pcm.opened);
745
746	if (rdch != NULL || wrch != NULL) {
747		PCM_UNLOCK(d);
748		if (rdch != NULL) {
749			/*
750			 * The channel itself need not be locked because:
751			 *   a)  Adding a channel to a syncgroup happens only
752			 *       in dsp_ioctl(), which cannot run concurrently
753			 *       to dsp_close().
754			 *   b)  The syncmember pointer (sm) is protected by
755			 *       the global syncgroup list lock.
756			 *   c)  A channel can't just disappear, invalidating
757			 *       pointers, unless it's closed/dereferenced
758			 *       first.
759			 */
760			PCM_SG_LOCK();
761			sg_ids = chn_syncdestroy(rdch);
762			PCM_SG_UNLOCK();
763			if (sg_ids != 0)
764				free_unr(pcmsg_unrhdr, sg_ids);
765
766			CHN_LOCK(rdch);
767			pcm_chnref(rdch, rdref);
768			chn_abort(rdch); /* won't sleep */
769			rdch->flags &= ~(CHN_F_RUNNING | CHN_F_MMAP |
770			    CHN_F_DEAD | CHN_F_EXCLUSIVE);
771			chn_reset(rdch, 0, 0);
772			pcm_chnrelease(rdch);
773		}
774		if (wrch != NULL) {
775			/*
776			 * Please see block above.
777			 */
778			PCM_SG_LOCK();
779			sg_ids = chn_syncdestroy(wrch);
780			PCM_SG_UNLOCK();
781			if (sg_ids != 0)
782				free_unr(pcmsg_unrhdr, sg_ids);
783
784			CHN_LOCK(wrch);
785			pcm_chnref(wrch, wdref);
786			chn_flush(wrch); /* may sleep */
787			wrch->flags &= ~(CHN_F_RUNNING | CHN_F_MMAP |
788			    CHN_F_DEAD | CHN_F_EXCLUSIVE);
789			chn_reset(wrch, 0, 0);
790			pcm_chnrelease(wrch);
791		}
792		PCM_LOCK(d);
793	}
794
795	dsp_cdevinfo_free(i_dev);
796	/*
797	 * Release clone busy state and unref it so the automatic
798	 * garbage collector will get the hint and do the remaining
799	 * cleanup process.
800	 */
801	(void)snd_clone_release(i_dev);
802
803	/*
804	 * destroy_dev() might sleep, so release pcm lock
805	 * here and rely on pcm cv serialization.
806	 */
807	PCM_UNLOCK(d);
808	(void)snd_clone_unref(i_dev);
809	PCM_LOCK(d);
810
811	PCM_RELEASE(d);
812	PCM_UNLOCK(d);
813
814	PCM_GIANT_LEAVE(d);
815
816	return (0);
817}
818
819static __inline int
820dsp_io_ops(struct cdev *i_dev, struct uio *buf)
821{
822	struct snddev_info *d;
823	struct pcm_channel **ch, *rdch, *wrch;
824	int (*chn_io)(struct pcm_channel *, struct uio *);
825	int prio, ret;
826	pid_t runpid;
827
828	KASSERT(i_dev != NULL && buf != NULL &&
829	    (buf->uio_rw == UIO_READ || buf->uio_rw == UIO_WRITE),
830	    ("%s(): io train wreck!", __func__));
831
832	d = dsp_get_info(i_dev);
833	if (PCM_DETACHING(d) || !DSP_REGISTERED(d, i_dev))
834		return (EBADF);
835
836	PCM_GIANT_ENTER(d);
837
838	switch (buf->uio_rw) {
839	case UIO_READ:
840		prio = SD_F_PRIO_RD;
841		ch = &rdch;
842		chn_io = chn_read;
843		break;
844	case UIO_WRITE:
845		prio = SD_F_PRIO_WR;
846		ch = &wrch;
847		chn_io = chn_write;
848		break;
849	default:
850		panic("invalid/corrupted uio direction: %d", buf->uio_rw);
851		break;
852	}
853
854	rdch = NULL;
855	wrch = NULL;
856	runpid = buf->uio_td->td_proc->p_pid;
857
858	getchns(i_dev, &rdch, &wrch, prio);
859
860	if (*ch == NULL || !((*ch)->flags & CHN_F_BUSY)) {
861		PCM_GIANT_EXIT(d);
862		return (EBADF);
863	}
864
865	if (((*ch)->flags & (CHN_F_MMAP | CHN_F_DEAD)) ||
866	    (((*ch)->flags & CHN_F_RUNNING) && (*ch)->pid != runpid)) {
867		relchns(i_dev, rdch, wrch, prio);
868		PCM_GIANT_EXIT(d);
869		return (EINVAL);
870	} else if (!((*ch)->flags & CHN_F_RUNNING)) {
871		(*ch)->flags |= CHN_F_RUNNING;
872		(*ch)->pid = runpid;
873	}
874
875	/*
876	 * chn_read/write must give up channel lock in order to copy bytes
877	 * from/to userland, so up the "in progress" counter to make sure
878	 * someone else doesn't come along and muss up the buffer.
879	 */
880	++(*ch)->inprog;
881	ret = chn_io(*ch, buf);
882	--(*ch)->inprog;
883
884	CHN_BROADCAST(&(*ch)->cv);
885
886	relchns(i_dev, rdch, wrch, prio);
887
888	PCM_GIANT_LEAVE(d);
889
890	return (ret);
891}
892
893static int
894dsp_read(struct cdev *i_dev, struct uio *buf, int flag)
895{
896	return (dsp_io_ops(i_dev, buf));
897}
898
899static int
900dsp_write(struct cdev *i_dev, struct uio *buf, int flag)
901{
902	return (dsp_io_ops(i_dev, buf));
903}
904
905static int
906dsp_get_volume_channel(struct cdev *dev, struct pcm_channel **volch)
907{
908	struct snddev_info *d;
909	struct pcm_channel *c;
910	int unit;
911
912	KASSERT(dev != NULL && volch != NULL,
913	    ("%s(): NULL query dev=%p volch=%p", __func__, dev, volch));
914
915	d = dsp_get_info(dev);
916	if (!PCM_REGISTERED(d)) {
917		*volch = NULL;
918		return (EINVAL);
919	}
920
921	PCM_UNLOCKASSERT(d);
922
923	*volch = NULL;
924
925	c = PCM_VOLCH(dev);
926	if (c != NULL) {
927		if (!(c->feederflags & (1 << FEEDER_VOLUME)))
928			return (-1);
929		*volch = c;
930		return (0);
931	}
932
933	PCM_LOCK(d);
934	PCM_WAIT(d);
935	PCM_ACQUIRE(d);
936
937	unit = dev2unit(dev);
938
939	CHN_FOREACH(c, d, channels.pcm) {
940		CHN_LOCK(c);
941		if (c->unit != unit) {
942			CHN_UNLOCK(c);
943			continue;
944		}
945		*volch = c;
946		pcm_chnref(c, 1);
947		PCM_VOLCH(dev) = c;
948		CHN_UNLOCK(c);
949		PCM_RELEASE(d);
950		PCM_UNLOCK(d);
951		return ((c->feederflags & (1 << FEEDER_VOLUME)) ? 0 : -1);
952	}
953
954	PCM_RELEASE(d);
955	PCM_UNLOCK(d);
956
957	return (EINVAL);
958}
959
960static int
961dsp_ioctl_channel(struct cdev *dev, struct pcm_channel *volch, u_long cmd,
962    caddr_t arg)
963{
964	struct snddev_info *d;
965	struct pcm_channel *rdch, *wrch;
966	int j, devtype, ret;
967
968	d = dsp_get_info(dev);
969	if (!PCM_REGISTERED(d) || !(dsp_get_flags(dev) & SD_F_VPC))
970		return (-1);
971
972	PCM_UNLOCKASSERT(d);
973
974	j = cmd & 0xff;
975
976	rdch = PCM_RDCH(dev);
977	wrch = PCM_WRCH(dev);
978
979	/* No specific channel, look into cache */
980	if (volch == NULL)
981		volch = PCM_VOLCH(dev);
982
983	/* Look harder */
984	if (volch == NULL) {
985		if (j == SOUND_MIXER_RECLEV && rdch != NULL)
986			volch = rdch;
987		else if (j == SOUND_MIXER_PCM && wrch != NULL)
988			volch = wrch;
989	}
990
991	devtype = PCMDEV(dev);
992
993	/* Look super harder */
994	if (volch == NULL &&
995	    (devtype == SND_DEV_DSPHW_PLAY || devtype == SND_DEV_DSPHW_VPLAY ||
996	    devtype == SND_DEV_DSPHW_REC || devtype == SND_DEV_DSPHW_VREC)) {
997		ret = dsp_get_volume_channel(dev, &volch);
998		if (ret != 0)
999			return (ret);
1000		if (volch == NULL)
1001			return (EINVAL);
1002	}
1003
1004	/* Final validation */
1005	if (volch != NULL) {
1006		CHN_LOCK(volch);
1007		if (!(volch->feederflags & (1 << FEEDER_VOLUME))) {
1008			CHN_UNLOCK(volch);
1009			return (-1);
1010		}
1011		if (volch->direction == PCMDIR_PLAY)
1012			wrch = volch;
1013		else
1014			rdch = volch;
1015	}
1016
1017	ret = EINVAL;
1018
1019	if (volch != NULL &&
1020	    ((j == SOUND_MIXER_PCM && volch->direction == PCMDIR_PLAY) ||
1021	    (j == SOUND_MIXER_RECLEV && volch->direction == PCMDIR_REC))) {
1022		if ((cmd & ~0xff) == MIXER_WRITE(0)) {
1023			int left, right, center;
1024
1025			left = *(int *)arg & 0x7f;
1026			right = ((*(int *)arg) >> 8) & 0x7f;
1027			center = (left + right) >> 1;
1028			chn_setvolume_multi(volch, SND_VOL_C_PCM, left, right,
1029			    center);
1030		} else if ((cmd & ~0xff) == MIXER_READ(0)) {
1031			*(int *)arg = CHN_GETVOLUME(volch,
1032				SND_VOL_C_PCM, SND_CHN_T_FL);
1033			*(int *)arg |= CHN_GETVOLUME(volch,
1034				SND_VOL_C_PCM, SND_CHN_T_FR) << 8;
1035		}
1036		ret = 0;
1037	} else if (rdch != NULL || wrch != NULL) {
1038		switch (j) {
1039		case SOUND_MIXER_DEVMASK:
1040		case SOUND_MIXER_CAPS:
1041		case SOUND_MIXER_STEREODEVS:
1042			if ((cmd & ~0xff) == MIXER_READ(0)) {
1043				*(int *)arg = 0;
1044				if (rdch != NULL)
1045					*(int *)arg |= SOUND_MASK_RECLEV;
1046				if (wrch != NULL)
1047					*(int *)arg |= SOUND_MASK_PCM;
1048			}
1049			ret = 0;
1050			break;
1051		case SOUND_MIXER_RECMASK:
1052		case SOUND_MIXER_RECSRC:
1053			if ((cmd & ~0xff) == MIXER_READ(0))
1054				*(int *)arg = 0;
1055			ret = 0;
1056			break;
1057		default:
1058			break;
1059		}
1060	}
1061
1062	if (volch != NULL)
1063		CHN_UNLOCK(volch);
1064
1065	return (ret);
1066}
1067
1068static int
1069dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
1070    struct thread *td)
1071{
1072    	struct pcm_channel *chn, *rdch, *wrch;
1073	struct snddev_info *d;
1074	u_long xcmd;
1075	int *arg_i, ret, tmp;
1076
1077	d = dsp_get_info(i_dev);
1078	if (PCM_DETACHING(d) || !DSP_REGISTERED(d, i_dev))
1079		return (EBADF);
1080
1081	PCM_GIANT_ENTER(d);
1082
1083	arg_i = (int *)arg;
1084	ret = 0;
1085	xcmd = 0;
1086	chn = NULL;
1087
1088	if (IOCGROUP(cmd) == 'M') {
1089		if (cmd == OSS_GETVERSION) {
1090			*arg_i = SOUND_VERSION;
1091			PCM_GIANT_EXIT(d);
1092			return (0);
1093		}
1094		ret = dsp_ioctl_channel(i_dev, PCM_VOLCH(i_dev), cmd, arg);
1095		if (ret != -1) {
1096			PCM_GIANT_EXIT(d);
1097			return (ret);
1098		}
1099
1100		if (d->mixer_dev != NULL) {
1101			PCM_ACQUIRE_QUICK(d);
1102			ret = mixer_ioctl_cmd(d->mixer_dev, cmd, arg, -1, td,
1103			    MIXER_CMD_DIRECT);
1104			PCM_RELEASE_QUICK(d);
1105		} else
1106			ret = EBADF;
1107
1108		PCM_GIANT_EXIT(d);
1109
1110		return (ret);
1111	}
1112
1113	/*
1114	 * Certain ioctls may be made on any type of device (audio, mixer,
1115	 * and MIDI).  Handle those special cases here.
1116	 */
1117	if (IOCGROUP(cmd) == 'X') {
1118		PCM_ACQUIRE_QUICK(d);
1119		switch(cmd) {
1120		case SNDCTL_SYSINFO:
1121			sound_oss_sysinfo((oss_sysinfo *)arg);
1122			break;
1123		case SNDCTL_CARDINFO:
1124			ret = sound_oss_card_info((oss_card_info *)arg);
1125			break;
1126		case SNDCTL_AUDIOINFO:
1127		case SNDCTL_AUDIOINFO_EX:
1128		case SNDCTL_ENGINEINFO:
1129			ret = dsp_oss_audioinfo(i_dev, (oss_audioinfo *)arg);
1130			break;
1131		case SNDCTL_MIXERINFO:
1132			ret = mixer_oss_mixerinfo(i_dev, (oss_mixerinfo *)arg);
1133			break;
1134		default:
1135			ret = EINVAL;
1136		}
1137		PCM_RELEASE_QUICK(d);
1138		PCM_GIANT_EXIT(d);
1139		return (ret);
1140	}
1141
1142	getchns(i_dev, &rdch, &wrch, 0);
1143
1144	if (wrch != NULL && (wrch->flags & CHN_F_DEAD))
1145		wrch = NULL;
1146	if (rdch != NULL && (rdch->flags & CHN_F_DEAD))
1147		rdch = NULL;
1148
1149	if (wrch == NULL && rdch == NULL) {
1150		PCM_GIANT_EXIT(d);
1151		return (EINVAL);
1152	}
1153
1154    	switch(cmd) {
1155#ifdef OLDPCM_IOCTL
1156    	/*
1157     	 * we start with the new ioctl interface.
1158     	 */
1159    	case AIONWRITE:	/* how many bytes can write ? */
1160		if (wrch) {
1161			CHN_LOCK(wrch);
1162/*
1163		if (wrch && wrch->bufhard.dl)
1164			while (chn_wrfeed(wrch) == 0);
1165*/
1166			*arg_i = sndbuf_getfree(wrch->bufsoft);
1167			CHN_UNLOCK(wrch);
1168		} else {
1169			*arg_i = 0;
1170			ret = EINVAL;
1171		}
1172		break;
1173
1174    	case AIOSSIZE:     /* set the current blocksize */
1175		{
1176	    		struct snd_size *p = (struct snd_size *)arg;
1177
1178			p->play_size = 0;
1179			p->rec_size = 0;
1180			PCM_ACQUIRE_QUICK(d);
1181	    		if (wrch) {
1182				CHN_LOCK(wrch);
1183				chn_setblocksize(wrch, 2, p->play_size);
1184				p->play_size = sndbuf_getblksz(wrch->bufsoft);
1185				CHN_UNLOCK(wrch);
1186			}
1187	    		if (rdch) {
1188				CHN_LOCK(rdch);
1189				chn_setblocksize(rdch, 2, p->rec_size);
1190				p->rec_size = sndbuf_getblksz(rdch->bufsoft);
1191				CHN_UNLOCK(rdch);
1192			}
1193			PCM_RELEASE_QUICK(d);
1194		}
1195		break;
1196    	case AIOGSIZE:	/* get the current blocksize */
1197		{
1198	    		struct snd_size *p = (struct snd_size *)arg;
1199
1200	    		if (wrch) {
1201				CHN_LOCK(wrch);
1202				p->play_size = sndbuf_getblksz(wrch->bufsoft);
1203				CHN_UNLOCK(wrch);
1204			}
1205	    		if (rdch) {
1206				CHN_LOCK(rdch);
1207				p->rec_size = sndbuf_getblksz(rdch->bufsoft);
1208				CHN_UNLOCK(rdch);
1209			}
1210		}
1211		break;
1212
1213    	case AIOSFMT:
1214    	case AIOGFMT:
1215		{
1216	    		snd_chan_param *p = (snd_chan_param *)arg;
1217
1218			if (cmd == AIOSFMT &&
1219			    ((p->play_format != 0 && p->play_rate == 0) ||
1220			    (p->rec_format != 0 && p->rec_rate == 0))) {
1221				ret = EINVAL;
1222				break;
1223			}
1224			PCM_ACQUIRE_QUICK(d);
1225	    		if (wrch) {
1226				CHN_LOCK(wrch);
1227				if (cmd == AIOSFMT && p->play_format != 0) {
1228					chn_setformat(wrch,
1229					    SND_FORMAT(p->play_format,
1230					    AFMT_CHANNEL(wrch->format),
1231					    AFMT_EXTCHANNEL(wrch->format)));
1232					chn_setspeed(wrch, p->play_rate);
1233				}
1234	    			p->play_rate = wrch->speed;
1235	    			p->play_format = AFMT_ENCODING(wrch->format);
1236				CHN_UNLOCK(wrch);
1237			} else {
1238	    			p->play_rate = 0;
1239	    			p->play_format = 0;
1240	    		}
1241	    		if (rdch) {
1242				CHN_LOCK(rdch);
1243				if (cmd == AIOSFMT && p->rec_format != 0) {
1244					chn_setformat(rdch,
1245					    SND_FORMAT(p->rec_format,
1246					    AFMT_CHANNEL(rdch->format),
1247					    AFMT_EXTCHANNEL(rdch->format)));
1248					chn_setspeed(rdch, p->rec_rate);
1249				}
1250				p->rec_rate = rdch->speed;
1251				p->rec_format = AFMT_ENCODING(rdch->format);
1252				CHN_UNLOCK(rdch);
1253			} else {
1254	    			p->rec_rate = 0;
1255	    			p->rec_format = 0;
1256	    		}
1257			PCM_RELEASE_QUICK(d);
1258		}
1259		break;
1260
1261    	case AIOGCAP:     /* get capabilities */
1262		{
1263	    		snd_capabilities *p = (snd_capabilities *)arg;
1264			struct pcmchan_caps *pcaps = NULL, *rcaps = NULL;
1265			struct cdev *pdev;
1266
1267			PCM_LOCK(d);
1268			if (rdch) {
1269				CHN_LOCK(rdch);
1270				rcaps = chn_getcaps(rdch);
1271			}
1272			if (wrch) {
1273				CHN_LOCK(wrch);
1274				pcaps = chn_getcaps(wrch);
1275			}
1276	    		p->rate_min = max(rcaps? rcaps->minspeed : 0,
1277	                      		  pcaps? pcaps->minspeed : 0);
1278	    		p->rate_max = min(rcaps? rcaps->maxspeed : 1000000,
1279	                      		  pcaps? pcaps->maxspeed : 1000000);
1280	    		p->bufsize = min(rdch? sndbuf_getsize(rdch->bufsoft) : 1000000,
1281	                     		 wrch? sndbuf_getsize(wrch->bufsoft) : 1000000);
1282			/* XXX bad on sb16 */
1283	    		p->formats = (rdch? chn_getformats(rdch) : 0xffffffff) &
1284			 	     (wrch? chn_getformats(wrch) : 0xffffffff);
1285			if (rdch && wrch)
1286				p->formats |= (dsp_get_flags(i_dev) & SD_F_SIMPLEX)? 0 : AFMT_FULLDUPLEX;
1287			pdev = d->mixer_dev;
1288	    		p->mixers = 1; /* default: one mixer */
1289	    		p->inputs = pdev->si_drv1? mix_getdevs(pdev->si_drv1) : 0;
1290	    		p->left = p->right = 100;
1291			if (wrch)
1292				CHN_UNLOCK(wrch);
1293			if (rdch)
1294				CHN_UNLOCK(rdch);
1295			PCM_UNLOCK(d);
1296		}
1297		break;
1298
1299    	case AIOSTOP:
1300		if (*arg_i == AIOSYNC_PLAY && wrch) {
1301			CHN_LOCK(wrch);
1302			*arg_i = chn_abort(wrch);
1303			CHN_UNLOCK(wrch);
1304		} else if (*arg_i == AIOSYNC_CAPTURE && rdch) {
1305			CHN_LOCK(rdch);
1306			*arg_i = chn_abort(rdch);
1307			CHN_UNLOCK(rdch);
1308		} else {
1309	   	 	printf("AIOSTOP: bad channel 0x%x\n", *arg_i);
1310	    		*arg_i = 0;
1311		}
1312		break;
1313
1314    	case AIOSYNC:
1315		printf("AIOSYNC chan 0x%03lx pos %lu unimplemented\n",
1316	    		((snd_sync_parm *)arg)->chan, ((snd_sync_parm *)arg)->pos);
1317		break;
1318#endif
1319	/*
1320	 * here follow the standard ioctls (filio.h etc.)
1321	 */
1322    	case FIONREAD: /* get # bytes to read */
1323		if (rdch) {
1324			CHN_LOCK(rdch);
1325/*			if (rdch && rdch->bufhard.dl)
1326				while (chn_rdfeed(rdch) == 0);
1327*/
1328			*arg_i = sndbuf_getready(rdch->bufsoft);
1329			CHN_UNLOCK(rdch);
1330		} else {
1331			*arg_i = 0;
1332			ret = EINVAL;
1333		}
1334		break;
1335
1336    	case FIOASYNC: /*set/clear async i/o */
1337		DEB( printf("FIOASYNC\n") ; )
1338		break;
1339
1340    	case SNDCTL_DSP_NONBLOCK: /* set non-blocking i/o */
1341    	case FIONBIO: /* set/clear non-blocking i/o */
1342		if (rdch) {
1343			CHN_LOCK(rdch);
1344			if (cmd == SNDCTL_DSP_NONBLOCK || *arg_i)
1345				rdch->flags |= CHN_F_NBIO;
1346			else
1347				rdch->flags &= ~CHN_F_NBIO;
1348			CHN_UNLOCK(rdch);
1349		}
1350		if (wrch) {
1351			CHN_LOCK(wrch);
1352			if (cmd == SNDCTL_DSP_NONBLOCK || *arg_i)
1353				wrch->flags |= CHN_F_NBIO;
1354			else
1355				wrch->flags &= ~CHN_F_NBIO;
1356			CHN_UNLOCK(wrch);
1357		}
1358		break;
1359
1360    	/*
1361	 * Finally, here is the linux-compatible ioctl interface
1362	 */
1363#define THE_REAL_SNDCTL_DSP_GETBLKSIZE _IOWR('P', 4, int)
1364    	case THE_REAL_SNDCTL_DSP_GETBLKSIZE:
1365    	case SNDCTL_DSP_GETBLKSIZE:
1366		chn = wrch ? wrch : rdch;
1367		if (chn) {
1368			CHN_LOCK(chn);
1369			*arg_i = sndbuf_getblksz(chn->bufsoft);
1370			CHN_UNLOCK(chn);
1371		} else {
1372			*arg_i = 0;
1373			ret = EINVAL;
1374		}
1375		break;
1376
1377    	case SNDCTL_DSP_SETBLKSIZE:
1378		RANGE(*arg_i, 16, 65536);
1379		PCM_ACQUIRE_QUICK(d);
1380		if (wrch) {
1381			CHN_LOCK(wrch);
1382			chn_setblocksize(wrch, 2, *arg_i);
1383			CHN_UNLOCK(wrch);
1384		}
1385		if (rdch) {
1386			CHN_LOCK(rdch);
1387			chn_setblocksize(rdch, 2, *arg_i);
1388			CHN_UNLOCK(rdch);
1389		}
1390		PCM_RELEASE_QUICK(d);
1391		break;
1392
1393    	case SNDCTL_DSP_RESET:
1394		DEB(printf("dsp reset\n"));
1395		if (wrch) {
1396			CHN_LOCK(wrch);
1397			chn_abort(wrch);
1398			chn_resetbuf(wrch);
1399			CHN_UNLOCK(wrch);
1400		}
1401		if (rdch) {
1402			CHN_LOCK(rdch);
1403			chn_abort(rdch);
1404			chn_resetbuf(rdch);
1405			CHN_UNLOCK(rdch);
1406		}
1407		break;
1408
1409    	case SNDCTL_DSP_SYNC:
1410		DEB(printf("dsp sync\n"));
1411		/* chn_sync may sleep */
1412		if (wrch) {
1413			CHN_LOCK(wrch);
1414			chn_sync(wrch, 0);
1415			CHN_UNLOCK(wrch);
1416		}
1417		break;
1418
1419    	case SNDCTL_DSP_SPEED:
1420		/* chn_setspeed may sleep */
1421		tmp = 0;
1422		PCM_ACQUIRE_QUICK(d);
1423		if (wrch) {
1424			CHN_LOCK(wrch);
1425			ret = chn_setspeed(wrch, *arg_i);
1426			tmp = wrch->speed;
1427			CHN_UNLOCK(wrch);
1428		}
1429		if (rdch && ret == 0) {
1430			CHN_LOCK(rdch);
1431			ret = chn_setspeed(rdch, *arg_i);
1432			if (tmp == 0)
1433				tmp = rdch->speed;
1434			CHN_UNLOCK(rdch);
1435		}
1436		PCM_RELEASE_QUICK(d);
1437		*arg_i = tmp;
1438		break;
1439
1440    	case SOUND_PCM_READ_RATE:
1441		chn = wrch ? wrch : rdch;
1442		if (chn) {
1443			CHN_LOCK(chn);
1444			*arg_i = chn->speed;
1445			CHN_UNLOCK(chn);
1446		} else {
1447			*arg_i = 0;
1448			ret = EINVAL;
1449		}
1450		break;
1451
1452    	case SNDCTL_DSP_STEREO:
1453		tmp = -1;
1454		*arg_i = (*arg_i)? 2 : 1;
1455		PCM_ACQUIRE_QUICK(d);
1456		if (wrch) {
1457			CHN_LOCK(wrch);
1458			ret = chn_setformat(wrch,
1459			    SND_FORMAT(wrch->format, *arg_i, 0));
1460			tmp = (AFMT_CHANNEL(wrch->format) > 1)? 1 : 0;
1461			CHN_UNLOCK(wrch);
1462		}
1463		if (rdch && ret == 0) {
1464			CHN_LOCK(rdch);
1465			ret = chn_setformat(rdch,
1466			    SND_FORMAT(rdch->format, *arg_i, 0));
1467			if (tmp == -1)
1468				tmp = (AFMT_CHANNEL(rdch->format) > 1)? 1 : 0;
1469			CHN_UNLOCK(rdch);
1470		}
1471		PCM_RELEASE_QUICK(d);
1472		*arg_i = tmp;
1473		break;
1474
1475    	case SOUND_PCM_WRITE_CHANNELS:
1476/*	case SNDCTL_DSP_CHANNELS: ( == SOUND_PCM_WRITE_CHANNELS) */
1477		if (*arg_i < 0) {
1478			*arg_i = 0;
1479			ret = EINVAL;
1480			break;
1481		}
1482		if (*arg_i != 0) {
1483			struct pcmchan_matrix *m;
1484			uint32_t ext;
1485
1486			tmp = 0;
1487			if (*arg_i > SND_CHN_MAX)
1488				*arg_i = SND_CHN_MAX;
1489
1490			m = feeder_matrix_default_channel_map(*arg_i);
1491			if (m != NULL)
1492				ext = m->ext;
1493			else
1494				ext = 0;
1495
1496			PCM_ACQUIRE_QUICK(d);
1497	  		if (wrch) {
1498				CHN_LOCK(wrch);
1499				ret = chn_setformat(wrch,
1500				    SND_FORMAT(wrch->format, *arg_i, ext));
1501				tmp = AFMT_CHANNEL(wrch->format);
1502				CHN_UNLOCK(wrch);
1503			}
1504			if (rdch && ret == 0) {
1505				CHN_LOCK(rdch);
1506				ret = chn_setformat(rdch,
1507				    SND_FORMAT(rdch->format, *arg_i, ext));
1508				if (tmp == 0)
1509					tmp = AFMT_CHANNEL(rdch->format);
1510				CHN_UNLOCK(rdch);
1511			}
1512			PCM_RELEASE_QUICK(d);
1513			*arg_i = tmp;
1514		} else {
1515			chn = wrch ? wrch : rdch;
1516			CHN_LOCK(chn);
1517			*arg_i = AFMT_CHANNEL(chn->format);
1518			CHN_UNLOCK(chn);
1519		}
1520		break;
1521
1522    	case SOUND_PCM_READ_CHANNELS:
1523		chn = wrch ? wrch : rdch;
1524		if (chn) {
1525			CHN_LOCK(chn);
1526			*arg_i = AFMT_CHANNEL(chn->format);
1527			CHN_UNLOCK(chn);
1528		} else {
1529			*arg_i = 0;
1530			ret = EINVAL;
1531		}
1532		break;
1533
1534    	case SNDCTL_DSP_GETFMTS:	/* returns a mask of supported fmts */
1535		chn = wrch ? wrch : rdch;
1536		if (chn) {
1537			CHN_LOCK(chn);
1538			*arg_i = chn_getformats(chn);
1539			CHN_UNLOCK(chn);
1540		} else {
1541			*arg_i = 0;
1542			ret = EINVAL;
1543		}
1544		break;
1545
1546    	case SNDCTL_DSP_SETFMT:	/* sets _one_ format */
1547		if (*arg_i != AFMT_QUERY) {
1548			tmp = 0;
1549			PCM_ACQUIRE_QUICK(d);
1550			if (wrch) {
1551				CHN_LOCK(wrch);
1552				ret = chn_setformat(wrch, SND_FORMAT(*arg_i,
1553				    AFMT_CHANNEL(wrch->format),
1554				    AFMT_EXTCHANNEL(wrch->format)));
1555				tmp = wrch->format;
1556				CHN_UNLOCK(wrch);
1557			}
1558			if (rdch && ret == 0) {
1559				CHN_LOCK(rdch);
1560				ret = chn_setformat(rdch, SND_FORMAT(*arg_i,
1561				    AFMT_CHANNEL(rdch->format),
1562				    AFMT_EXTCHANNEL(rdch->format)));
1563				if (tmp == 0)
1564					tmp = rdch->format;
1565				CHN_UNLOCK(rdch);
1566			}
1567			PCM_RELEASE_QUICK(d);
1568			*arg_i = AFMT_ENCODING(tmp);
1569		} else {
1570			chn = wrch ? wrch : rdch;
1571			CHN_LOCK(chn);
1572			*arg_i = AFMT_ENCODING(chn->format);
1573			CHN_UNLOCK(chn);
1574		}
1575		break;
1576
1577    	case SNDCTL_DSP_SETFRAGMENT:
1578		DEB(printf("SNDCTL_DSP_SETFRAGMENT 0x%08x\n", *(int *)arg));
1579		{
1580			uint32_t fragln = (*arg_i) & 0x0000ffff;
1581			uint32_t maxfrags = ((*arg_i) & 0xffff0000) >> 16;
1582			uint32_t fragsz;
1583			uint32_t r_maxfrags, r_fragsz;
1584
1585			RANGE(fragln, 4, 16);
1586			fragsz = 1 << fragln;
1587
1588			if (maxfrags == 0)
1589				maxfrags = CHN_2NDBUFMAXSIZE / fragsz;
1590			if (maxfrags < 2)
1591				maxfrags = 2;
1592			if (maxfrags * fragsz > CHN_2NDBUFMAXSIZE)
1593				maxfrags = CHN_2NDBUFMAXSIZE / fragsz;
1594
1595			DEB(printf("SNDCTL_DSP_SETFRAGMENT %d frags, %d sz\n", maxfrags, fragsz));
1596			PCM_ACQUIRE_QUICK(d);
1597		    	if (rdch) {
1598				CHN_LOCK(rdch);
1599				ret = chn_setblocksize(rdch, maxfrags, fragsz);
1600				r_maxfrags = sndbuf_getblkcnt(rdch->bufsoft);
1601				r_fragsz = sndbuf_getblksz(rdch->bufsoft);
1602				CHN_UNLOCK(rdch);
1603			} else {
1604				r_maxfrags = maxfrags;
1605				r_fragsz = fragsz;
1606			}
1607		    	if (wrch && ret == 0) {
1608				CHN_LOCK(wrch);
1609				ret = chn_setblocksize(wrch, maxfrags, fragsz);
1610 				maxfrags = sndbuf_getblkcnt(wrch->bufsoft);
1611				fragsz = sndbuf_getblksz(wrch->bufsoft);
1612				CHN_UNLOCK(wrch);
1613			} else { /* use whatever came from the read channel */
1614				maxfrags = r_maxfrags;
1615				fragsz = r_fragsz;
1616			}
1617			PCM_RELEASE_QUICK(d);
1618
1619			fragln = 0;
1620			while (fragsz > 1) {
1621				fragln++;
1622				fragsz >>= 1;
1623			}
1624	    		*arg_i = (maxfrags << 16) | fragln;
1625		}
1626		break;
1627
1628    	case SNDCTL_DSP_GETISPACE:
1629		/* return the size of data available in the input queue */
1630		{
1631	    		audio_buf_info *a = (audio_buf_info *)arg;
1632	    		if (rdch) {
1633	        		struct snd_dbuf *bs = rdch->bufsoft;
1634
1635				CHN_LOCK(rdch);
1636				a->bytes = sndbuf_getready(bs);
1637	        		a->fragments = a->bytes / sndbuf_getblksz(bs);
1638	        		a->fragstotal = sndbuf_getblkcnt(bs);
1639	        		a->fragsize = sndbuf_getblksz(bs);
1640				CHN_UNLOCK(rdch);
1641	    		} else
1642				ret = EINVAL;
1643		}
1644		break;
1645
1646    	case SNDCTL_DSP_GETOSPACE:
1647		/* return space available in the output queue */
1648		{
1649	    		audio_buf_info *a = (audio_buf_info *)arg;
1650	    		if (wrch) {
1651	        		struct snd_dbuf *bs = wrch->bufsoft;
1652
1653				CHN_LOCK(wrch);
1654				/* XXX abusive DMA update: chn_wrupdate(wrch); */
1655				a->bytes = sndbuf_getfree(bs);
1656	        		a->fragments = a->bytes / sndbuf_getblksz(bs);
1657	        		a->fragstotal = sndbuf_getblkcnt(bs);
1658	        		a->fragsize = sndbuf_getblksz(bs);
1659				CHN_UNLOCK(wrch);
1660	    		} else
1661				ret = EINVAL;
1662		}
1663		break;
1664
1665    	case SNDCTL_DSP_GETIPTR:
1666		{
1667	    		count_info *a = (count_info *)arg;
1668	    		if (rdch) {
1669	        		struct snd_dbuf *bs = rdch->bufsoft;
1670
1671				CHN_LOCK(rdch);
1672				/* XXX abusive DMA update: chn_rdupdate(rdch); */
1673	        		a->bytes = sndbuf_gettotal(bs);
1674	        		a->blocks = sndbuf_getblocks(bs) - rdch->blocks;
1675	        		a->ptr = sndbuf_getfreeptr(bs);
1676				rdch->blocks = sndbuf_getblocks(bs);
1677				CHN_UNLOCK(rdch);
1678	    		} else
1679				ret = EINVAL;
1680		}
1681		break;
1682
1683    	case SNDCTL_DSP_GETOPTR:
1684		{
1685	    		count_info *a = (count_info *)arg;
1686	    		if (wrch) {
1687	        		struct snd_dbuf *bs = wrch->bufsoft;
1688
1689				CHN_LOCK(wrch);
1690				/* XXX abusive DMA update: chn_wrupdate(wrch); */
1691	        		a->bytes = sndbuf_gettotal(bs);
1692	        		a->blocks = sndbuf_getblocks(bs) - wrch->blocks;
1693	        		a->ptr = sndbuf_getreadyptr(bs);
1694				wrch->blocks = sndbuf_getblocks(bs);
1695				CHN_UNLOCK(wrch);
1696	    		} else
1697				ret = EINVAL;
1698		}
1699		break;
1700
1701    	case SNDCTL_DSP_GETCAPS:
1702		PCM_LOCK(d);
1703		*arg_i = PCM_CAP_REALTIME | PCM_CAP_MMAP | PCM_CAP_TRIGGER;
1704		if (rdch && wrch && !(dsp_get_flags(i_dev) & SD_F_SIMPLEX))
1705			*arg_i |= PCM_CAP_DUPLEX;
1706		if (rdch && (rdch->flags & CHN_F_VIRTUAL) != 0)
1707			*arg_i |= PCM_CAP_VIRTUAL;
1708		if (wrch && (wrch->flags & CHN_F_VIRTUAL) != 0)
1709			*arg_i |= PCM_CAP_VIRTUAL;
1710		PCM_UNLOCK(d);
1711		break;
1712
1713    	case SOUND_PCM_READ_BITS:
1714		chn = wrch ? wrch : rdch;
1715		if (chn) {
1716			CHN_LOCK(chn);
1717			if (chn->format & AFMT_8BIT)
1718				*arg_i = 8;
1719			else if (chn->format & AFMT_16BIT)
1720				*arg_i = 16;
1721			else if (chn->format & AFMT_24BIT)
1722				*arg_i = 24;
1723			else if (chn->format & AFMT_32BIT)
1724				*arg_i = 32;
1725			else
1726				ret = EINVAL;
1727			CHN_UNLOCK(chn);
1728		} else {
1729			*arg_i = 0;
1730			ret = EINVAL;
1731		}
1732		break;
1733
1734    	case SNDCTL_DSP_SETTRIGGER:
1735		if (rdch) {
1736			CHN_LOCK(rdch);
1737			rdch->flags &= ~CHN_F_NOTRIGGER;
1738		    	if (*arg_i & PCM_ENABLE_INPUT)
1739				chn_start(rdch, 1);
1740			else {
1741				chn_abort(rdch);
1742				chn_resetbuf(rdch);
1743				rdch->flags |= CHN_F_NOTRIGGER;
1744			}
1745			CHN_UNLOCK(rdch);
1746		}
1747		if (wrch) {
1748			CHN_LOCK(wrch);
1749			wrch->flags &= ~CHN_F_NOTRIGGER;
1750		    	if (*arg_i & PCM_ENABLE_OUTPUT)
1751				chn_start(wrch, 1);
1752			else {
1753				chn_abort(wrch);
1754				chn_resetbuf(wrch);
1755				wrch->flags |= CHN_F_NOTRIGGER;
1756			}
1757			CHN_UNLOCK(wrch);
1758		}
1759		break;
1760
1761    	case SNDCTL_DSP_GETTRIGGER:
1762		*arg_i = 0;
1763		if (wrch) {
1764			CHN_LOCK(wrch);
1765			if (wrch->flags & CHN_F_TRIGGERED)
1766				*arg_i |= PCM_ENABLE_OUTPUT;
1767			CHN_UNLOCK(wrch);
1768		}
1769		if (rdch) {
1770			CHN_LOCK(rdch);
1771			if (rdch->flags & CHN_F_TRIGGERED)
1772				*arg_i |= PCM_ENABLE_INPUT;
1773			CHN_UNLOCK(rdch);
1774		}
1775		break;
1776
1777	case SNDCTL_DSP_GETODELAY:
1778		if (wrch) {
1779	        	struct snd_dbuf *bs = wrch->bufsoft;
1780
1781			CHN_LOCK(wrch);
1782			/* XXX abusive DMA update: chn_wrupdate(wrch); */
1783			*arg_i = sndbuf_getready(bs);
1784			CHN_UNLOCK(wrch);
1785		} else
1786			ret = EINVAL;
1787		break;
1788
1789    	case SNDCTL_DSP_POST:
1790		if (wrch) {
1791			CHN_LOCK(wrch);
1792			wrch->flags &= ~CHN_F_NOTRIGGER;
1793			chn_start(wrch, 1);
1794			CHN_UNLOCK(wrch);
1795		}
1796		break;
1797
1798	case SNDCTL_DSP_SETDUPLEX:
1799		/*
1800		 * switch to full-duplex mode if card is in half-duplex
1801		 * mode and is able to work in full-duplex mode
1802		 */
1803		PCM_LOCK(d);
1804		if (rdch && wrch && (dsp_get_flags(i_dev) & SD_F_SIMPLEX))
1805			dsp_set_flags(i_dev, dsp_get_flags(i_dev)^SD_F_SIMPLEX);
1806		PCM_UNLOCK(d);
1807		break;
1808
1809	/*
1810	 * The following four ioctls are simple wrappers around mixer_ioctl
1811	 * with no further processing.  xcmd is short for "translated
1812	 * command".
1813	 */
1814	case SNDCTL_DSP_GETRECVOL:
1815		if (xcmd == 0) {
1816			xcmd = SOUND_MIXER_READ_RECLEV;
1817			chn = rdch;
1818		}
1819		/* FALLTHROUGH */
1820	case SNDCTL_DSP_SETRECVOL:
1821		if (xcmd == 0) {
1822			xcmd = SOUND_MIXER_WRITE_RECLEV;
1823			chn = rdch;
1824		}
1825		/* FALLTHROUGH */
1826	case SNDCTL_DSP_GETPLAYVOL:
1827		if (xcmd == 0) {
1828			xcmd = SOUND_MIXER_READ_PCM;
1829			chn = wrch;
1830		}
1831		/* FALLTHROUGH */
1832	case SNDCTL_DSP_SETPLAYVOL:
1833		if (xcmd == 0) {
1834			xcmd = SOUND_MIXER_WRITE_PCM;
1835			chn = wrch;
1836		}
1837
1838		ret = dsp_ioctl_channel(i_dev, chn, xcmd, arg);
1839		if (ret != -1) {
1840			PCM_GIANT_EXIT(d);
1841			return (ret);
1842		}
1843
1844		if (d->mixer_dev != NULL) {
1845			PCM_ACQUIRE_QUICK(d);
1846			ret = mixer_ioctl_cmd(d->mixer_dev, xcmd, arg, -1, td,
1847			    MIXER_CMD_DIRECT);
1848			PCM_RELEASE_QUICK(d);
1849		} else
1850			ret = ENOTSUP;
1851
1852		break;
1853
1854	case SNDCTL_DSP_GET_RECSRC_NAMES:
1855	case SNDCTL_DSP_GET_RECSRC:
1856	case SNDCTL_DSP_SET_RECSRC:
1857		if (d->mixer_dev != NULL) {
1858			PCM_ACQUIRE_QUICK(d);
1859			ret = mixer_ioctl_cmd(d->mixer_dev, cmd, arg, -1, td,
1860			    MIXER_CMD_DIRECT);
1861			PCM_RELEASE_QUICK(d);
1862		} else
1863			ret = ENOTSUP;
1864		break;
1865
1866	/*
1867	 * The following 3 ioctls aren't very useful at the moment.  For
1868	 * now, only a single channel is associated with a cdev (/dev/dspN
1869	 * instance), so there's only a single output routing to use (i.e.,
1870	 * the wrch bound to this cdev).
1871	 */
1872	case SNDCTL_DSP_GET_PLAYTGT_NAMES:
1873		{
1874			oss_mixer_enuminfo *ei;
1875			ei = (oss_mixer_enuminfo *)arg;
1876			ei->dev = 0;
1877			ei->ctrl = 0;
1878			ei->version = 0; /* static for now */
1879			ei->strindex[0] = 0;
1880
1881			if (wrch != NULL) {
1882				ei->nvalues = 1;
1883				strlcpy(ei->strings, wrch->name,
1884					sizeof(ei->strings));
1885			} else {
1886				ei->nvalues = 0;
1887				ei->strings[0] = '\0';
1888			}
1889		}
1890		break;
1891	case SNDCTL_DSP_GET_PLAYTGT:
1892	case SNDCTL_DSP_SET_PLAYTGT:	/* yes, they are the same for now */
1893		/*
1894		 * Re: SET_PLAYTGT
1895		 *   OSSv4: "The value that was accepted by the device will
1896		 *   be returned back in the variable pointed by the
1897		 *   argument."
1898		 */
1899		if (wrch != NULL)
1900			*arg_i = 0;
1901		else
1902			ret = EINVAL;
1903		break;
1904
1905	case SNDCTL_DSP_SILENCE:
1906	/*
1907	 * Flush the software (pre-feed) buffer, but try to minimize playback
1908	 * interruption.  (I.e., record unplayed samples with intent to
1909	 * restore by SNDCTL_DSP_SKIP.) Intended for application "pause"
1910	 * functionality.
1911	 */
1912		if (wrch == NULL)
1913			ret = EINVAL;
1914		else {
1915			struct snd_dbuf *bs;
1916			CHN_LOCK(wrch);
1917			while (wrch->inprog != 0)
1918				cv_wait(&wrch->cv, wrch->lock);
1919			bs = wrch->bufsoft;
1920			if ((bs->shadbuf != NULL) && (sndbuf_getready(bs) > 0)) {
1921				bs->sl = sndbuf_getready(bs);
1922				sndbuf_dispose(bs, bs->shadbuf, sndbuf_getready(bs));
1923				sndbuf_fillsilence(bs);
1924				chn_start(wrch, 0);
1925			}
1926			CHN_UNLOCK(wrch);
1927		}
1928		break;
1929
1930	case SNDCTL_DSP_SKIP:
1931	/*
1932	 * OSSv4 docs: "This ioctl call discards all unplayed samples in the
1933	 * playback buffer by moving the current write position immediately
1934	 * before the point where the device is currently reading the samples."
1935	 */
1936		if (wrch == NULL)
1937			ret = EINVAL;
1938		else {
1939			struct snd_dbuf *bs;
1940			CHN_LOCK(wrch);
1941			while (wrch->inprog != 0)
1942				cv_wait(&wrch->cv, wrch->lock);
1943			bs = wrch->bufsoft;
1944			if ((bs->shadbuf != NULL) && (bs->sl > 0)) {
1945				sndbuf_softreset(bs);
1946				sndbuf_acquire(bs, bs->shadbuf, bs->sl);
1947				bs->sl = 0;
1948				chn_start(wrch, 0);
1949			}
1950			CHN_UNLOCK(wrch);
1951		}
1952		break;
1953
1954	case SNDCTL_DSP_CURRENT_OPTR:
1955	case SNDCTL_DSP_CURRENT_IPTR:
1956	/**
1957	 * @note Changing formats resets the buffer counters, which differs
1958	 * 	 from the 4Front drivers.  However, I don't expect this to be
1959	 * 	 much of a problem.
1960	 *
1961	 * @note In a test where @c CURRENT_OPTR is called immediately after write
1962	 * 	 returns, this driver is about 32K samples behind whereas
1963	 * 	 4Front's is about 8K samples behind.  Should determine source
1964	 * 	 of discrepancy, even if only out of curiosity.
1965	 *
1966	 * @todo Actually test SNDCTL_DSP_CURRENT_IPTR.
1967	 */
1968		chn = (cmd == SNDCTL_DSP_CURRENT_OPTR) ? wrch : rdch;
1969		if (chn == NULL)
1970			ret = EINVAL;
1971		else {
1972			struct snd_dbuf *bs;
1973			/* int tmp; */
1974
1975			oss_count_t *oc = (oss_count_t *)arg;
1976
1977			CHN_LOCK(chn);
1978			bs = chn->bufsoft;
1979#if 0
1980			tmp = (sndbuf_getsize(b) + chn_getptr(chn) - sndbuf_gethwptr(b)) % sndbuf_getsize(b);
1981			oc->samples = (sndbuf_gettotal(b) + tmp) / sndbuf_getalign(b);
1982			oc->fifo_samples = (sndbuf_getready(b) - tmp) / sndbuf_getalign(b);
1983#else
1984			oc->samples = sndbuf_gettotal(bs) / sndbuf_getalign(bs);
1985			oc->fifo_samples = sndbuf_getready(bs) / sndbuf_getalign(bs);
1986#endif
1987			CHN_UNLOCK(chn);
1988		}
1989		break;
1990
1991	case SNDCTL_DSP_HALT_OUTPUT:
1992	case SNDCTL_DSP_HALT_INPUT:
1993		chn = (cmd == SNDCTL_DSP_HALT_OUTPUT) ? wrch : rdch;
1994		if (chn == NULL)
1995			ret = EINVAL;
1996		else {
1997			CHN_LOCK(chn);
1998			chn_abort(chn);
1999			CHN_UNLOCK(chn);
2000		}
2001		break;
2002
2003	case SNDCTL_DSP_LOW_WATER:
2004	/*
2005	 * Set the number of bytes required to attract attention by
2006	 * select/poll.
2007	 */
2008		if (wrch != NULL) {
2009			CHN_LOCK(wrch);
2010			wrch->lw = (*arg_i > 1) ? *arg_i : 1;
2011			CHN_UNLOCK(wrch);
2012		}
2013		if (rdch != NULL) {
2014			CHN_LOCK(rdch);
2015			rdch->lw = (*arg_i > 1) ? *arg_i : 1;
2016			CHN_UNLOCK(rdch);
2017		}
2018		break;
2019
2020	case SNDCTL_DSP_GETERROR:
2021	/*
2022	 * OSSv4 docs:  "All errors and counters will automatically be
2023	 * cleared to zeroes after the call so each call will return only
2024	 * the errors that occurred after the previous invocation. ... The
2025	 * play_underruns and rec_overrun fields are the only useful fields
2026	 * returned by OSS 4.0."
2027	 */
2028		{
2029			audio_errinfo *ei = (audio_errinfo *)arg;
2030
2031			bzero((void *)ei, sizeof(*ei));
2032
2033			if (wrch != NULL) {
2034				CHN_LOCK(wrch);
2035				ei->play_underruns = wrch->xruns;
2036				wrch->xruns = 0;
2037				CHN_UNLOCK(wrch);
2038			}
2039			if (rdch != NULL) {
2040				CHN_LOCK(rdch);
2041				ei->rec_overruns = rdch->xruns;
2042				rdch->xruns = 0;
2043				CHN_UNLOCK(rdch);
2044			}
2045		}
2046		break;
2047
2048	case SNDCTL_DSP_SYNCGROUP:
2049		PCM_ACQUIRE_QUICK(d);
2050		ret = dsp_oss_syncgroup(wrch, rdch, (oss_syncgroup *)arg);
2051		PCM_RELEASE_QUICK(d);
2052		break;
2053
2054	case SNDCTL_DSP_SYNCSTART:
2055		PCM_ACQUIRE_QUICK(d);
2056		ret = dsp_oss_syncstart(*arg_i);
2057		PCM_RELEASE_QUICK(d);
2058		break;
2059
2060	case SNDCTL_DSP_POLICY:
2061		PCM_ACQUIRE_QUICK(d);
2062		ret = dsp_oss_policy(wrch, rdch, *arg_i);
2063		PCM_RELEASE_QUICK(d);
2064		break;
2065
2066	case SNDCTL_DSP_COOKEDMODE:
2067		PCM_ACQUIRE_QUICK(d);
2068		if (!(dsp_get_flags(i_dev) & SD_F_BITPERFECT))
2069			ret = dsp_oss_cookedmode(wrch, rdch, *arg_i);
2070		PCM_RELEASE_QUICK(d);
2071		break;
2072	case SNDCTL_DSP_GET_CHNORDER:
2073		PCM_ACQUIRE_QUICK(d);
2074		ret = dsp_oss_getchnorder(wrch, rdch, (unsigned long long *)arg);
2075		PCM_RELEASE_QUICK(d);
2076		break;
2077	case SNDCTL_DSP_SET_CHNORDER:
2078		PCM_ACQUIRE_QUICK(d);
2079		ret = dsp_oss_setchnorder(wrch, rdch, (unsigned long long *)arg);
2080		PCM_RELEASE_QUICK(d);
2081		break;
2082	case SNDCTL_DSP_GETCHANNELMASK:		/* XXX vlc */
2083		PCM_ACQUIRE_QUICK(d);
2084		ret = dsp_oss_getchannelmask(wrch, rdch, (int *)arg);
2085		PCM_RELEASE_QUICK(d);
2086		break;
2087	case SNDCTL_DSP_BIND_CHANNEL:		/* XXX what?!? */
2088		ret = EINVAL;
2089		break;
2090#ifdef	OSSV4_EXPERIMENT
2091	/*
2092	 * XXX The following ioctls are not yet supported and just return
2093	 * EINVAL.
2094	 */
2095	case SNDCTL_DSP_GETOPEAKS:
2096	case SNDCTL_DSP_GETIPEAKS:
2097		chn = (cmd == SNDCTL_DSP_GETOPEAKS) ? wrch : rdch;
2098		if (chn == NULL)
2099			ret = EINVAL;
2100		else {
2101			oss_peaks_t *op = (oss_peaks_t *)arg;
2102			int lpeak, rpeak;
2103
2104			CHN_LOCK(chn);
2105			ret = chn_getpeaks(chn, &lpeak, &rpeak);
2106			if (ret == -1)
2107				ret = EINVAL;
2108			else {
2109				(*op)[0] = lpeak;
2110				(*op)[1] = rpeak;
2111			}
2112			CHN_UNLOCK(chn);
2113		}
2114		break;
2115
2116	/*
2117	 * XXX Once implemented, revisit this for proper cv protection
2118	 *     (if necessary).
2119	 */
2120	case SNDCTL_GETLABEL:
2121		ret = dsp_oss_getlabel(wrch, rdch, (oss_label_t *)arg);
2122		break;
2123	case SNDCTL_SETLABEL:
2124		ret = dsp_oss_setlabel(wrch, rdch, (oss_label_t *)arg);
2125		break;
2126	case SNDCTL_GETSONG:
2127		ret = dsp_oss_getsong(wrch, rdch, (oss_longname_t *)arg);
2128		break;
2129	case SNDCTL_SETSONG:
2130		ret = dsp_oss_setsong(wrch, rdch, (oss_longname_t *)arg);
2131		break;
2132	case SNDCTL_SETNAME:
2133		ret = dsp_oss_setname(wrch, rdch, (oss_longname_t *)arg);
2134		break;
2135#if 0
2136	/**
2137	 * @note The S/PDIF interface ioctls, @c SNDCTL_DSP_READCTL and
2138	 * @c SNDCTL_DSP_WRITECTL have been omitted at the suggestion of
2139	 * 4Front Technologies.
2140	 */
2141	case SNDCTL_DSP_READCTL:
2142	case SNDCTL_DSP_WRITECTL:
2143		ret = EINVAL;
2144		break;
2145#endif	/* !0 (explicitly omitted ioctls) */
2146
2147#endif	/* !OSSV4_EXPERIMENT */
2148    	case SNDCTL_DSP_MAPINBUF:
2149    	case SNDCTL_DSP_MAPOUTBUF:
2150    	case SNDCTL_DSP_SETSYNCRO:
2151		/* undocumented */
2152
2153    	case SNDCTL_DSP_SUBDIVIDE:
2154    	case SOUND_PCM_WRITE_FILTER:
2155    	case SOUND_PCM_READ_FILTER:
2156		/* dunno what these do, don't sound important */
2157
2158    	default:
2159		DEB(printf("default ioctl fn 0x%08lx fail\n", cmd));
2160		ret = EINVAL;
2161		break;
2162    	}
2163
2164	PCM_GIANT_LEAVE(d);
2165
2166    	return (ret);
2167}
2168
2169static int
2170dsp_poll(struct cdev *i_dev, int events, struct thread *td)
2171{
2172	struct snddev_info *d;
2173	struct pcm_channel *wrch, *rdch;
2174	int ret, e;
2175
2176	d = dsp_get_info(i_dev);
2177	if (PCM_DETACHING(d) || !DSP_REGISTERED(d, i_dev)) {
2178		/* XXX many clients don't understand POLLNVAL */
2179		return (events & (POLLHUP | POLLPRI | POLLIN |
2180		    POLLRDNORM | POLLOUT | POLLWRNORM));
2181	}
2182	PCM_GIANT_ENTER(d);
2183
2184	wrch = NULL;
2185	rdch = NULL;
2186	ret = 0;
2187
2188	getchns(i_dev, &rdch, &wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
2189
2190	if (wrch != NULL && !(wrch->flags & CHN_F_DEAD)) {
2191		e = (events & (POLLOUT | POLLWRNORM));
2192		if (e)
2193			ret |= chn_poll(wrch, e, td);
2194	}
2195
2196	if (rdch != NULL && !(rdch->flags & CHN_F_DEAD)) {
2197		e = (events & (POLLIN | POLLRDNORM));
2198		if (e)
2199			ret |= chn_poll(rdch, e, td);
2200	}
2201
2202	relchns(i_dev, rdch, wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
2203
2204	PCM_GIANT_LEAVE(d);
2205
2206	return (ret);
2207}
2208
2209static int
2210dsp_mmap(struct cdev *i_dev, vm_ooffset_t offset, vm_paddr_t *paddr,
2211    int nprot, vm_memattr_t *memattr)
2212{
2213
2214	/*
2215	 * offset is in range due to checks in dsp_mmap_single().
2216	 * XXX memattr is not honored.
2217	 */
2218	*paddr = vtophys(offset);
2219	return (0);
2220}
2221
2222static int
2223dsp_mmap_single(struct cdev *i_dev, vm_ooffset_t *offset,
2224    vm_size_t size, struct vm_object **object, int nprot)
2225{
2226	struct snddev_info *d;
2227	struct pcm_channel *wrch, *rdch, *c;
2228
2229	/*
2230	 * Reject PROT_EXEC by default. It just doesn't makes sense.
2231	 * Unfortunately, we have to give up this one due to linux_mmap
2232	 * changes.
2233	 *
2234	 * https://lists.freebsd.org/pipermail/freebsd-emulation/2007-June/003698.html
2235	 *
2236	 */
2237#ifdef SV_ABI_LINUX
2238	if ((nprot & PROT_EXEC) && (dsp_mmap_allow_prot_exec < 0 ||
2239	    (dsp_mmap_allow_prot_exec == 0 &&
2240	    SV_CURPROC_ABI() != SV_ABI_LINUX)))
2241#else
2242	if ((nprot & PROT_EXEC) && dsp_mmap_allow_prot_exec < 1)
2243#endif
2244		return (EINVAL);
2245
2246	/*
2247	 * PROT_READ (alone) selects the input buffer.
2248	 * PROT_WRITE (alone) selects the output buffer.
2249	 * PROT_WRITE|PROT_READ together select the output buffer.
2250	 */
2251	if ((nprot & (PROT_READ | PROT_WRITE)) == 0)
2252		return (EINVAL);
2253
2254	d = dsp_get_info(i_dev);
2255	if (PCM_DETACHING(d) || !DSP_REGISTERED(d, i_dev))
2256		return (EINVAL);
2257
2258	PCM_GIANT_ENTER(d);
2259
2260	getchns(i_dev, &rdch, &wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
2261
2262	c = ((nprot & PROT_WRITE) != 0) ? wrch : rdch;
2263	if (c == NULL || (c->flags & CHN_F_MMAP_INVALID) ||
2264	    (*offset  + size) > sndbuf_getsize(c->bufsoft) ||
2265	    (wrch != NULL && (wrch->flags & CHN_F_MMAP_INVALID)) ||
2266	    (rdch != NULL && (rdch->flags & CHN_F_MMAP_INVALID))) {
2267		relchns(i_dev, rdch, wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
2268		PCM_GIANT_EXIT(d);
2269		return (EINVAL);
2270	}
2271
2272	if (wrch != NULL)
2273		wrch->flags |= CHN_F_MMAP;
2274	if (rdch != NULL)
2275		rdch->flags |= CHN_F_MMAP;
2276
2277	*offset = (uintptr_t)sndbuf_getbufofs(c->bufsoft, *offset);
2278	relchns(i_dev, rdch, wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
2279	*object = vm_pager_allocate(OBJT_DEVICE, i_dev,
2280	    size, nprot, *offset, curthread->td_ucred);
2281
2282	PCM_GIANT_LEAVE(d);
2283
2284	if (*object == NULL)
2285		 return (EINVAL);
2286	return (0);
2287}
2288
2289/* So much for dev_stdclone() */
2290static int
2291dsp_stdclone(char *name, char *namep, char *sep, int use_sep, int *u, int *c)
2292{
2293	size_t len;
2294
2295	len = strlen(namep);
2296
2297	if (bcmp(name, namep, len) != 0)
2298		return (ENODEV);
2299
2300	name += len;
2301
2302	if (isdigit(*name) == 0)
2303		return (ENODEV);
2304
2305	len = strlen(sep);
2306
2307	if (*name == '0' && !(name[1] == '\0' || bcmp(name + 1, sep, len) == 0))
2308		return (ENODEV);
2309
2310	for (*u = 0; isdigit(*name) != 0; name++) {
2311		*u *= 10;
2312		*u += *name - '0';
2313		if (*u > dsp_umax)
2314			return (ENODEV);
2315	}
2316
2317	if (*name == '\0')
2318		return ((use_sep == 0) ? 0 : ENODEV);
2319
2320	if (bcmp(name, sep, len) != 0 || isdigit(name[len]) == 0)
2321		return (ENODEV);
2322
2323	name += len;
2324
2325	if (*name == '0' && name[1] != '\0')
2326		return (ENODEV);
2327
2328	for (*c = 0; isdigit(*name) != 0; name++) {
2329		*c *= 10;
2330		*c += *name - '0';
2331		if (*c > dsp_cmax)
2332			return (ENODEV);
2333	}
2334
2335	if (*name != '\0')
2336		return (ENODEV);
2337
2338	return (0);
2339}
2340
2341static void
2342dsp_clone(void *arg,
2343    struct ucred *cred,
2344    char *name, int namelen, struct cdev **dev)
2345{
2346	struct snddev_info *d;
2347	struct snd_clone_entry *ce;
2348	struct pcm_channel *c;
2349	int i, unit, udcmask, cunit, devtype, devhw, devcmax, tumax;
2350	char *devname, *devcmp, *devsep;
2351
2352	KASSERT(dsp_umax >= 0 && dsp_cmax >= 0, ("Uninitialized unit!"));
2353
2354	if (*dev != NULL)
2355		return;
2356
2357	unit = -1;
2358	cunit = -1;
2359	devtype = -1;
2360	devhw = 0;
2361	devcmax = -1;
2362	tumax = -1;
2363	devname = NULL;
2364	devsep = NULL;
2365
2366	for (i = 0; unit == -1 &&
2367	    i < (sizeof(dsp_cdevs) / sizeof(dsp_cdevs[0])); i++) {
2368		devtype = dsp_cdevs[i].type;
2369		devcmp = dsp_cdevs[i].name;
2370		devsep = dsp_cdevs[i].sep;
2371		devname = dsp_cdevs[i].alias;
2372		if (devname == NULL)
2373			devname = devcmp;
2374		devhw = dsp_cdevs[i].hw;
2375		devcmax = dsp_cdevs[i].max - 1;
2376		if (strcmp(name, devcmp) == 0) {
2377			if (dsp_basename_clone != 0)
2378				unit = snd_unit;
2379		} else if (dsp_stdclone(name, devcmp, devsep,
2380		    dsp_cdevs[i].use_sep, &unit, &cunit) != 0) {
2381			unit = -1;
2382			cunit = -1;
2383		}
2384	}
2385
2386	d = devclass_get_softc(pcm_devclass, unit);
2387	if (!PCM_REGISTERED(d) || d->clones == NULL)
2388		return;
2389
2390	/* XXX Need Giant magic entry ??? */
2391
2392	PCM_LOCK(d);
2393	if (snd_clone_disabled(d->clones)) {
2394		PCM_UNLOCK(d);
2395		return;
2396	}
2397
2398	PCM_WAIT(d);
2399	PCM_ACQUIRE(d);
2400	PCM_UNLOCK(d);
2401
2402	udcmask = snd_u2unit(unit) | snd_d2unit(devtype);
2403
2404	if (devhw != 0) {
2405		KASSERT(devcmax <= dsp_cmax,
2406		    ("overflow: devcmax=%d, dsp_cmax=%d", devcmax, dsp_cmax));
2407		if (cunit > devcmax) {
2408			PCM_RELEASE_QUICK(d);
2409			return;
2410		}
2411		udcmask |= snd_c2unit(cunit);
2412		CHN_FOREACH(c, d, channels.pcm) {
2413			CHN_LOCK(c);
2414			if (c->unit != udcmask) {
2415				CHN_UNLOCK(c);
2416				continue;
2417			}
2418			CHN_UNLOCK(c);
2419			udcmask &= ~snd_c2unit(cunit);
2420			/*
2421			 * Temporarily increase clone maxunit to overcome
2422			 * vchan flexibility.
2423			 *
2424			 * # sysctl dev.pcm.0.play.vchans=256
2425			 * dev.pcm.0.play.vchans: 1 -> 256
2426			 * # cat /dev/zero > /dev/dsp0.vp255 &
2427			 * [1] 17296
2428			 * # sysctl dev.pcm.0.play.vchans=0
2429			 * dev.pcm.0.play.vchans: 256 -> 1
2430			 * # fg
2431			 * [1]  + running    cat /dev/zero > /dev/dsp0.vp255
2432			 * ^C
2433			 * # cat /dev/zero > /dev/dsp0.vp255
2434			 * zsh: operation not supported: /dev/dsp0.vp255
2435			 */
2436			tumax = snd_clone_getmaxunit(d->clones);
2437			if (cunit > tumax)
2438				snd_clone_setmaxunit(d->clones, cunit);
2439			else
2440				tumax = -1;
2441			goto dsp_clone_alloc;
2442		}
2443		/*
2444		 * Ok, so we're requesting unallocated vchan, but still
2445		 * within maximum vchan limit.
2446		 */
2447		if (((devtype == SND_DEV_DSPHW_VPLAY && d->pvchancount > 0) ||
2448		    (devtype == SND_DEV_DSPHW_VREC && d->rvchancount > 0)) &&
2449		    cunit < snd_maxautovchans) {
2450			udcmask &= ~snd_c2unit(cunit);
2451			tumax = snd_clone_getmaxunit(d->clones);
2452			if (cunit > tumax)
2453				snd_clone_setmaxunit(d->clones, cunit);
2454			else
2455				tumax = -1;
2456			goto dsp_clone_alloc;
2457		}
2458		PCM_RELEASE_QUICK(d);
2459		return;
2460	}
2461
2462dsp_clone_alloc:
2463	ce = snd_clone_alloc(d->clones, dev, &cunit, udcmask);
2464	if (tumax != -1)
2465		snd_clone_setmaxunit(d->clones, tumax);
2466	if (ce != NULL) {
2467		udcmask |= snd_c2unit(cunit);
2468		*dev = make_dev(&dsp_cdevsw, PCMMINOR(udcmask),
2469		    UID_ROOT, GID_WHEEL, 0666, "%s%d%s%d",
2470		    devname, unit, devsep, cunit);
2471		snd_clone_register(ce, *dev);
2472	}
2473
2474	PCM_RELEASE_QUICK(d);
2475
2476	if (*dev != NULL)
2477		dev_ref(*dev);
2478}
2479
2480static void
2481dsp_sysinit(void *p)
2482{
2483	if (dsp_ehtag != NULL)
2484		return;
2485	/* initialize unit numbering */
2486	snd_unit_init();
2487	dsp_umax = PCMMAXUNIT;
2488	dsp_cmax = PCMMAXCHAN;
2489	dsp_ehtag = EVENTHANDLER_REGISTER(dev_clone, dsp_clone, 0, 1000);
2490}
2491
2492static void
2493dsp_sysuninit(void *p)
2494{
2495	if (dsp_ehtag == NULL)
2496		return;
2497	EVENTHANDLER_DEREGISTER(dev_clone, dsp_ehtag);
2498	dsp_ehtag = NULL;
2499}
2500
2501SYSINIT(dsp_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, dsp_sysinit, NULL);
2502SYSUNINIT(dsp_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, dsp_sysuninit, NULL);
2503
2504char *
2505dsp_unit2name(char *buf, size_t len, int unit)
2506{
2507	int i, dtype;
2508
2509	KASSERT(buf != NULL && len != 0,
2510	    ("bogus buf=%p len=%ju", buf, (uintmax_t)len));
2511
2512	dtype = snd_unit2d(unit);
2513
2514	for (i = 0; i < (sizeof(dsp_cdevs) / sizeof(dsp_cdevs[0])); i++) {
2515		if (dtype != dsp_cdevs[i].type || dsp_cdevs[i].alias != NULL)
2516			continue;
2517		snprintf(buf, len, "%s%d%s%d", dsp_cdevs[i].name,
2518		    snd_unit2u(unit), dsp_cdevs[i].sep, snd_unit2c(unit));
2519		return (buf);
2520	}
2521
2522	return (NULL);
2523}
2524
2525/**
2526 * @brief Handler for SNDCTL_AUDIOINFO.
2527 *
2528 * Gathers information about the audio device specified in ai->dev.  If
2529 * ai->dev == -1, then this function gathers information about the current
2530 * device.  If the call comes in on a non-audio device and ai->dev == -1,
2531 * return EINVAL.
2532 *
2533 * This routine is supposed to go practically straight to the hardware,
2534 * getting capabilities directly from the sound card driver, side-stepping
2535 * the intermediate channel interface.
2536 *
2537 * Note, however, that the usefulness of this command is significantly
2538 * decreased when requesting info about any device other than the one serving
2539 * the request. While each snddev_channel refers to a specific device node,
2540 * the converse is *not* true.  Currently, when a sound device node is opened,
2541 * the sound subsystem scans for an available audio channel (or channels, if
2542 * opened in read+write) and then assigns them to the si_drv[12] private
2543 * data fields.  As a result, any information returned linking a channel to
2544 * a specific character device isn't necessarily accurate.
2545 *
2546 * @note
2547 * Calling threads must not hold any snddev_info or pcm_channel locks.
2548 *
2549 * @param dev		device on which the ioctl was issued
2550 * @param ai		ioctl request data container
2551 *
2552 * @retval 0		success
2553 * @retval EINVAL	ai->dev specifies an invalid device
2554 *
2555 * @todo Verify correctness of Doxygen tags.  ;)
2556 */
2557int
2558dsp_oss_audioinfo(struct cdev *i_dev, oss_audioinfo *ai)
2559{
2560	struct pcmchan_caps *caps;
2561	struct pcm_channel *ch;
2562	struct snddev_info *d;
2563	uint32_t fmts;
2564	int i, nchan, *rates, minch, maxch;
2565	char *devname, buf[CHN_NAMELEN];
2566
2567	/*
2568	 * If probing the device that received the ioctl, make sure it's a
2569	 * DSP device.  (Users may use this ioctl with /dev/mixer and
2570	 * /dev/midi.)
2571	 */
2572	if (ai->dev == -1 && i_dev->si_devsw != &dsp_cdevsw)
2573		return (EINVAL);
2574
2575	ch = NULL;
2576	devname = NULL;
2577	nchan = 0;
2578	bzero(buf, sizeof(buf));
2579
2580	/*
2581	 * Search for the requested audio device (channel).  Start by
2582	 * iterating over pcm devices.
2583	 */
2584	for (i = 0; pcm_devclass != NULL &&
2585	    i < devclass_get_maxunit(pcm_devclass); i++) {
2586		d = devclass_get_softc(pcm_devclass, i);
2587		if (!PCM_REGISTERED(d))
2588			continue;
2589
2590		/* XXX Need Giant magic entry ??? */
2591
2592		/* See the note in function docblock */
2593		PCM_UNLOCKASSERT(d);
2594		PCM_LOCK(d);
2595
2596		CHN_FOREACH(ch, d, channels.pcm) {
2597			CHN_UNLOCKASSERT(ch);
2598			CHN_LOCK(ch);
2599			if (ai->dev == -1) {
2600				if (DSP_REGISTERED(d, i_dev) &&
2601				    (ch == PCM_RDCH(i_dev) ||	/* record ch */
2602				    ch == PCM_WRCH(i_dev))) {	/* playback ch */
2603					devname = dsp_unit2name(buf,
2604					    sizeof(buf), ch->unit);
2605				}
2606			} else if (ai->dev == nchan) {
2607				devname = dsp_unit2name(buf, sizeof(buf),
2608				    ch->unit);
2609			}
2610			if (devname != NULL)
2611				break;
2612			CHN_UNLOCK(ch);
2613			++nchan;
2614		}
2615
2616		if (devname != NULL) {
2617			/*
2618			 * At this point, the following synchronization stuff
2619			 * has happened:
2620			 * - a specific PCM device is locked.
2621			 * - a specific audio channel has been locked, so be
2622			 *   sure to unlock when exiting;
2623			 */
2624
2625			caps = chn_getcaps(ch);
2626
2627			/*
2628			 * With all handles collected, zero out the user's
2629			 * container and begin filling in its fields.
2630			 */
2631			bzero((void *)ai, sizeof(oss_audioinfo));
2632
2633			ai->dev = nchan;
2634			strlcpy(ai->name, ch->name,  sizeof(ai->name));
2635
2636			if ((ch->flags & CHN_F_BUSY) == 0)
2637				ai->busy = 0;
2638			else
2639				ai->busy = (ch->direction == PCMDIR_PLAY) ? OPEN_WRITE : OPEN_READ;
2640
2641			/**
2642			 * @note
2643			 * @c cmd - OSSv4 docs: "Only supported under Linux at
2644			 *    this moment." Cop-out, I know, but I'll save
2645			 *    running around in the process table for later.
2646			 *    Is there a risk of leaking information?
2647			 */
2648			ai->pid = ch->pid;
2649
2650			/*
2651			 * These flags stolen from SNDCTL_DSP_GETCAPS handler.
2652			 * Note, however, that a single channel operates in
2653			 * only one direction, so PCM_CAP_DUPLEX is out.
2654			 */
2655			/**
2656			 * @todo @c SNDCTL_AUDIOINFO::caps - Make drivers keep
2657			 *       these in pcmchan::caps?
2658			 */
2659			ai->caps = PCM_CAP_REALTIME | PCM_CAP_MMAP | PCM_CAP_TRIGGER |
2660			    ((ch->flags & CHN_F_VIRTUAL) ? PCM_CAP_VIRTUAL : 0) |
2661			    ((ch->direction == PCMDIR_PLAY) ? PCM_CAP_OUTPUT : PCM_CAP_INPUT);
2662
2663			/*
2664			 * Collect formats supported @b natively by the
2665			 * device.  Also determine min/max channels.  (I.e.,
2666			 * mono, stereo, or both?)
2667			 *
2668			 * If any channel is stereo, maxch = 2;
2669			 * if all channels are stereo, minch = 2, too;
2670			 * if any channel is mono, minch = 1;
2671			 * and if all channels are mono, maxch = 1.
2672			 */
2673			minch = 0;
2674			maxch = 0;
2675			fmts = 0;
2676			for (i = 0; caps->fmtlist[i]; i++) {
2677				fmts |= caps->fmtlist[i];
2678				if (AFMT_CHANNEL(caps->fmtlist[i]) > 1) {
2679					minch = (minch == 0) ? 2 : minch;
2680					maxch = 2;
2681				} else {
2682					minch = 1;
2683					maxch = (maxch == 0) ? 1 : maxch;
2684				}
2685			}
2686
2687			if (ch->direction == PCMDIR_PLAY)
2688				ai->oformats = fmts;
2689			else
2690				ai->iformats = fmts;
2691
2692			/**
2693			 * @note
2694			 * @c magic - OSSv4 docs: "Reserved for internal use
2695			 *    by OSS."
2696			 *
2697			 * @par
2698			 * @c card_number - OSSv4 docs: "Number of the sound
2699			 *    card where this device belongs or -1 if this
2700			 *    information is not available.  Applications
2701			 *    should normally not use this field for any
2702			 *    purpose."
2703			 */
2704			ai->card_number = -1;
2705			/**
2706			 * @todo @c song_name - depends first on
2707			 *          SNDCTL_[GS]ETSONG @todo @c label - depends
2708			 *          on SNDCTL_[GS]ETLABEL
2709			 * @todo @c port_number - routing information?
2710			 */
2711			ai->port_number = -1;
2712			ai->mixer_dev = (d->mixer_dev != NULL) ? PCMUNIT(d->mixer_dev) : -1;
2713			/**
2714			 * @note
2715			 * @c real_device - OSSv4 docs:  "Obsolete."
2716			 */
2717			ai->real_device = -1;
2718			strlcpy(ai->devnode, "/dev/", sizeof(ai->devnode));
2719			strlcat(ai->devnode, devname, sizeof(ai->devnode));
2720			ai->enabled = device_is_attached(d->dev) ? 1 : 0;
2721			/**
2722			 * @note
2723			 * @c flags - OSSv4 docs: "Reserved for future use."
2724			 *
2725			 * @note
2726			 * @c binding - OSSv4 docs: "Reserved for future use."
2727			 *
2728			 * @todo @c handle - haven't decided how to generate
2729			 *       this yet; bus, vendor, device IDs?
2730			 */
2731			ai->min_rate = caps->minspeed;
2732			ai->max_rate = caps->maxspeed;
2733
2734			ai->min_channels = minch;
2735			ai->max_channels = maxch;
2736
2737			ai->nrates = chn_getrates(ch, &rates);
2738			if (ai->nrates > OSS_MAX_SAMPLE_RATES)
2739				ai->nrates = OSS_MAX_SAMPLE_RATES;
2740
2741			for (i = 0; i < ai->nrates; i++)
2742				ai->rates[i] = rates[i];
2743
2744			ai->next_play_engine = 0;
2745			ai->next_rec_engine = 0;
2746
2747			CHN_UNLOCK(ch);
2748		}
2749
2750		PCM_UNLOCK(d);
2751
2752		if (devname != NULL)
2753			return (0);
2754	}
2755
2756	/* Exhausted the search -- nothing is locked, so return. */
2757	return (EINVAL);
2758}
2759
2760/**
2761 * @brief Assigns a PCM channel to a sync group.
2762 *
2763 * Sync groups are used to enable audio operations on multiple devices
2764 * simultaneously.  They may be used with any number of devices and may
2765 * span across applications.  Devices are added to groups with
2766 * the SNDCTL_DSP_SYNCGROUP ioctl, and operations are triggered with the
2767 * SNDCTL_DSP_SYNCSTART ioctl.
2768 *
2769 * If the @c id field of the @c group parameter is set to zero, then a new
2770 * sync group is created.  Otherwise, wrch and rdch (if set) are added to
2771 * the group specified.
2772 *
2773 * @todo As far as memory allocation, should we assume that things are
2774 * 	 okay and allocate with M_WAITOK before acquiring channel locks,
2775 * 	 freeing later if not?
2776 *
2777 * @param wrch	output channel associated w/ device (if any)
2778 * @param rdch	input channel associated w/ device (if any)
2779 * @param group Sync group parameters
2780 *
2781 * @retval 0		success
2782 * @retval non-zero	error to be propagated upstream
2783 */
2784static int
2785dsp_oss_syncgroup(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_syncgroup *group)
2786{
2787	struct pcmchan_syncmember *smrd, *smwr;
2788	struct pcmchan_syncgroup *sg;
2789	int ret, sg_ids[3];
2790
2791	smrd = NULL;
2792	smwr = NULL;
2793	sg = NULL;
2794	ret = 0;
2795
2796	/*
2797	 * Free_unr() may sleep, so store released syncgroup IDs until after
2798	 * all locks are released.
2799	 */
2800	sg_ids[0] = sg_ids[1] = sg_ids[2] = 0;
2801
2802	PCM_SG_LOCK();
2803
2804	/*
2805	 * - Insert channel(s) into group's member list.
2806	 * - Set CHN_F_NOTRIGGER on channel(s).
2807	 * - Stop channel(s).
2808	 */
2809
2810	/*
2811	 * If device's channels are already mapped to a group, unmap them.
2812	 */
2813	if (wrch) {
2814		CHN_LOCK(wrch);
2815		sg_ids[0] = chn_syncdestroy(wrch);
2816	}
2817
2818	if (rdch) {
2819		CHN_LOCK(rdch);
2820		sg_ids[1] = chn_syncdestroy(rdch);
2821	}
2822
2823	/*
2824	 * Verify that mode matches character device properites.
2825	 *  - Bail if PCM_ENABLE_OUTPUT && wrch == NULL.
2826	 *  - Bail if PCM_ENABLE_INPUT && rdch == NULL.
2827	 */
2828	if (((wrch == NULL) && (group->mode & PCM_ENABLE_OUTPUT)) ||
2829	    ((rdch == NULL) && (group->mode & PCM_ENABLE_INPUT))) {
2830		ret = EINVAL;
2831		goto out;
2832	}
2833
2834	/*
2835	 * An id of zero indicates the user wants to create a new
2836	 * syncgroup.
2837	 */
2838	if (group->id == 0) {
2839		sg = (struct pcmchan_syncgroup *)malloc(sizeof(*sg), M_DEVBUF, M_NOWAIT);
2840		if (sg != NULL) {
2841			SLIST_INIT(&sg->members);
2842			sg->id = alloc_unr(pcmsg_unrhdr);
2843
2844			group->id = sg->id;
2845			SLIST_INSERT_HEAD(&snd_pcm_syncgroups, sg, link);
2846		} else
2847			ret = ENOMEM;
2848	} else {
2849		SLIST_FOREACH(sg, &snd_pcm_syncgroups, link) {
2850			if (sg->id == group->id)
2851				break;
2852		}
2853		if (sg == NULL)
2854			ret = EINVAL;
2855	}
2856
2857	/* Couldn't create or find a syncgroup.  Fail. */
2858	if (sg == NULL)
2859		goto out;
2860
2861	/*
2862	 * Allocate a syncmember, assign it and a channel together, and
2863	 * insert into syncgroup.
2864	 */
2865	if (group->mode & PCM_ENABLE_INPUT) {
2866		smrd = (struct pcmchan_syncmember *)malloc(sizeof(*smrd), M_DEVBUF, M_NOWAIT);
2867		if (smrd == NULL) {
2868			ret = ENOMEM;
2869			goto out;
2870		}
2871
2872		SLIST_INSERT_HEAD(&sg->members, smrd, link);
2873		smrd->parent = sg;
2874		smrd->ch = rdch;
2875
2876		chn_abort(rdch);
2877		rdch->flags |= CHN_F_NOTRIGGER;
2878		rdch->sm = smrd;
2879	}
2880
2881	if (group->mode & PCM_ENABLE_OUTPUT) {
2882		smwr = (struct pcmchan_syncmember *)malloc(sizeof(*smwr), M_DEVBUF, M_NOWAIT);
2883		if (smwr == NULL) {
2884			ret = ENOMEM;
2885			goto out;
2886		}
2887
2888		SLIST_INSERT_HEAD(&sg->members, smwr, link);
2889		smwr->parent = sg;
2890		smwr->ch = wrch;
2891
2892		chn_abort(wrch);
2893		wrch->flags |= CHN_F_NOTRIGGER;
2894		wrch->sm = smwr;
2895	}
2896
2897
2898out:
2899	if (ret != 0) {
2900		if (smrd != NULL)
2901			free(smrd, M_DEVBUF);
2902		if ((sg != NULL) && SLIST_EMPTY(&sg->members)) {
2903			sg_ids[2] = sg->id;
2904			SLIST_REMOVE(&snd_pcm_syncgroups, sg, pcmchan_syncgroup, link);
2905			free(sg, M_DEVBUF);
2906		}
2907
2908		if (wrch)
2909			wrch->sm = NULL;
2910		if (rdch)
2911			rdch->sm = NULL;
2912	}
2913
2914	if (wrch)
2915		CHN_UNLOCK(wrch);
2916	if (rdch)
2917		CHN_UNLOCK(rdch);
2918
2919	PCM_SG_UNLOCK();
2920
2921	if (sg_ids[0])
2922		free_unr(pcmsg_unrhdr, sg_ids[0]);
2923	if (sg_ids[1])
2924		free_unr(pcmsg_unrhdr, sg_ids[1]);
2925	if (sg_ids[2])
2926		free_unr(pcmsg_unrhdr, sg_ids[2]);
2927
2928	return (ret);
2929}
2930
2931/**
2932 * @brief Launch a sync group into action
2933 *
2934 * Sync groups are established via SNDCTL_DSP_SYNCGROUP.  This function
2935 * iterates over all members, triggering them along the way.
2936 *
2937 * @note Caller must not hold any channel locks.
2938 *
2939 * @param sg_id	sync group identifier
2940 *
2941 * @retval 0	success
2942 * @retval non-zero	error worthy of propagating upstream to user
2943 */
2944static int
2945dsp_oss_syncstart(int sg_id)
2946{
2947	struct pcmchan_syncmember *sm, *sm_tmp;
2948	struct pcmchan_syncgroup *sg;
2949	struct pcm_channel *c;
2950	int ret, needlocks;
2951
2952	/* Get the synclists lock */
2953	PCM_SG_LOCK();
2954
2955	do {
2956		ret = 0;
2957		needlocks = 0;
2958
2959		/* Search for syncgroup by ID */
2960		SLIST_FOREACH(sg, &snd_pcm_syncgroups, link) {
2961			if (sg->id == sg_id)
2962				break;
2963		}
2964
2965		/* Return EINVAL if not found */
2966		if (sg == NULL) {
2967			ret = EINVAL;
2968			break;
2969		}
2970
2971		/* Any removals resulting in an empty group should've handled this */
2972		KASSERT(!SLIST_EMPTY(&sg->members), ("found empty syncgroup"));
2973
2974		/*
2975		 * Attempt to lock all member channels - if any are already
2976		 * locked, unlock those acquired, sleep for a bit, and try
2977		 * again.
2978		 */
2979		SLIST_FOREACH(sm, &sg->members, link) {
2980			if (CHN_TRYLOCK(sm->ch) == 0) {
2981				int timo = hz * 5/1000;
2982				if (timo < 1)
2983					timo = 1;
2984
2985				/* Release all locked channels so far, retry */
2986				SLIST_FOREACH(sm_tmp, &sg->members, link) {
2987					/* sm is the member already locked */
2988					if (sm == sm_tmp)
2989						break;
2990					CHN_UNLOCK(sm_tmp->ch);
2991				}
2992
2993				/** @todo Is PRIBIO correct/ */
2994				ret = msleep(sm, &snd_pcm_syncgroups_mtx,
2995				    PRIBIO | PCATCH, "pcmsg", timo);
2996				if (ret == EINTR || ret == ERESTART)
2997					break;
2998
2999				needlocks = 1;
3000				ret = 0; /* Assumes ret == EAGAIN... */
3001			}
3002		}
3003	} while (needlocks && ret == 0);
3004
3005	/* Proceed only if no errors encountered. */
3006	if (ret == 0) {
3007		/* Launch channels */
3008		while ((sm = SLIST_FIRST(&sg->members)) != NULL) {
3009			SLIST_REMOVE_HEAD(&sg->members, link);
3010
3011			c = sm->ch;
3012			c->sm = NULL;
3013			chn_start(c, 1);
3014			c->flags &= ~CHN_F_NOTRIGGER;
3015			CHN_UNLOCK(c);
3016
3017			free(sm, M_DEVBUF);
3018		}
3019
3020		SLIST_REMOVE(&snd_pcm_syncgroups, sg, pcmchan_syncgroup, link);
3021		free(sg, M_DEVBUF);
3022	}
3023
3024	PCM_SG_UNLOCK();
3025
3026	/*
3027	 * Free_unr() may sleep, so be sure to give up the syncgroup lock
3028	 * first.
3029	 */
3030	if (ret == 0)
3031		free_unr(pcmsg_unrhdr, sg_id);
3032
3033	return (ret);
3034}
3035
3036/**
3037 * @brief Handler for SNDCTL_DSP_POLICY
3038 *
3039 * The SNDCTL_DSP_POLICY ioctl is a simpler interface to control fragment
3040 * size and count like with SNDCTL_DSP_SETFRAGMENT.  Instead of the user
3041 * specifying those two parameters, s/he simply selects a number from 0..10
3042 * which corresponds to a buffer size.  Smaller numbers request smaller
3043 * buffers with lower latencies (at greater overhead from more frequent
3044 * interrupts), while greater numbers behave in the opposite manner.
3045 *
3046 * The 4Front spec states that a value of 5 should be the default.  However,
3047 * this implementation deviates slightly by using a linear scale without
3048 * consulting drivers.  I.e., even though drivers may have different default
3049 * buffer sizes, a policy argument of 5 will have the same result across
3050 * all drivers.
3051 *
3052 * See http://manuals.opensound.com/developer/SNDCTL_DSP_POLICY.html for
3053 * more information.
3054 *
3055 * @todo When SNDCTL_DSP_COOKEDMODE is supported, it'll be necessary to
3056 * 	 work with hardware drivers directly.
3057 *
3058 * @note PCM channel arguments must not be locked by caller.
3059 *
3060 * @param wrch	Pointer to opened playback channel (optional; may be NULL)
3061 * @param rdch	" recording channel (optional; may be NULL)
3062 * @param policy Integer from [0:10]
3063 *
3064 * @retval 0	constant (for now)
3065 */
3066static int
3067dsp_oss_policy(struct pcm_channel *wrch, struct pcm_channel *rdch, int policy)
3068{
3069	int ret;
3070
3071	if (policy < CHN_POLICY_MIN || policy > CHN_POLICY_MAX)
3072		return (EIO);
3073
3074	/* Default: success */
3075	ret = 0;
3076
3077	if (rdch) {
3078		CHN_LOCK(rdch);
3079		ret = chn_setlatency(rdch, policy);
3080		CHN_UNLOCK(rdch);
3081	}
3082
3083	if (wrch && ret == 0) {
3084		CHN_LOCK(wrch);
3085		ret = chn_setlatency(wrch, policy);
3086		CHN_UNLOCK(wrch);
3087	}
3088
3089	if (ret)
3090		ret = EIO;
3091
3092	return (ret);
3093}
3094
3095/**
3096 * @brief Enable or disable "cooked" mode
3097 *
3098 * This is a handler for @c SNDCTL_DSP_COOKEDMODE.  When in cooked mode, which
3099 * is the default, the sound system handles rate and format conversions
3100 * automatically (ex: user writing 11025Hz/8 bit/unsigned but card only
3101 * operates with 44100Hz/16bit/signed samples).
3102 *
3103 * Disabling cooked mode is intended for applications wanting to mmap()
3104 * a sound card's buffer space directly, bypassing the FreeBSD 2-stage
3105 * feeder architecture, presumably to gain as much control over audio
3106 * hardware as possible.
3107 *
3108 * See @c http://manuals.opensound.com/developer/SNDCTL_DSP_COOKEDMODE.html
3109 * for more details.
3110 *
3111 * @param wrch		playback channel (optional; may be NULL)
3112 * @param rdch		recording channel (optional; may be NULL)
3113 * @param enabled	0 = raw mode, 1 = cooked mode
3114 *
3115 * @retval EINVAL	Operation not yet supported.
3116 */
3117static int
3118dsp_oss_cookedmode(struct pcm_channel *wrch, struct pcm_channel *rdch, int enabled)
3119{
3120
3121	/*
3122	 * XXX I just don't get it. Why don't they call it
3123	 * "BITPERFECT" ~ SNDCTL_DSP_BITPERFECT !?!?.
3124	 * This is just plain so confusing, incoherent,
3125	 * <insert any non-printable characters here>.
3126	 */
3127	if (!(enabled == 1 || enabled == 0))
3128		return (EINVAL);
3129
3130	/*
3131	 * I won't give in. I'm inverting its logic here and now.
3132	 * Brag all you want, but "BITPERFECT" should be the better
3133	 * term here.
3134	 */
3135	enabled ^= 0x00000001;
3136
3137	if (wrch != NULL) {
3138		CHN_LOCK(wrch);
3139		wrch->flags &= ~CHN_F_BITPERFECT;
3140		wrch->flags |= (enabled != 0) ? CHN_F_BITPERFECT : 0x00000000;
3141		CHN_UNLOCK(wrch);
3142	}
3143
3144	if (rdch != NULL) {
3145		CHN_LOCK(rdch);
3146		rdch->flags &= ~CHN_F_BITPERFECT;
3147		rdch->flags |= (enabled != 0) ? CHN_F_BITPERFECT : 0x00000000;
3148		CHN_UNLOCK(rdch);
3149	}
3150
3151	return (0);
3152}
3153
3154/**
3155 * @brief Retrieve channel interleaving order
3156 *
3157 * This is the handler for @c SNDCTL_DSP_GET_CHNORDER.
3158 *
3159 * See @c http://manuals.opensound.com/developer/SNDCTL_DSP_GET_CHNORDER.html
3160 * for more details.
3161 *
3162 * @note As the ioctl definition is still under construction, FreeBSD
3163 * 	 does not currently support SNDCTL_DSP_GET_CHNORDER.
3164 *
3165 * @param wrch	playback channel (optional; may be NULL)
3166 * @param rdch	recording channel (optional; may be NULL)
3167 * @param map	channel map (result will be stored there)
3168 *
3169 * @retval EINVAL	Operation not yet supported.
3170 */
3171static int
3172dsp_oss_getchnorder(struct pcm_channel *wrch, struct pcm_channel *rdch, unsigned long long *map)
3173{
3174	struct pcm_channel *ch;
3175	int ret;
3176
3177	ch = (wrch != NULL) ? wrch : rdch;
3178	if (ch != NULL) {
3179		CHN_LOCK(ch);
3180		ret = chn_oss_getorder(ch, map);
3181		CHN_UNLOCK(ch);
3182	} else
3183		ret = EINVAL;
3184
3185	return (ret);
3186}
3187
3188/**
3189 * @brief Specify channel interleaving order
3190 *
3191 * This is the handler for @c SNDCTL_DSP_SET_CHNORDER.
3192 *
3193 * @note As the ioctl definition is still under construction, FreeBSD
3194 * 	 does not currently support @c SNDCTL_DSP_SET_CHNORDER.
3195 *
3196 * @param wrch	playback channel (optional; may be NULL)
3197 * @param rdch	recording channel (optional; may be NULL)
3198 * @param map	channel map
3199 *
3200 * @retval EINVAL	Operation not yet supported.
3201 */
3202static int
3203dsp_oss_setchnorder(struct pcm_channel *wrch, struct pcm_channel *rdch, unsigned long long *map)
3204{
3205	int ret;
3206
3207	ret = 0;
3208
3209	if (wrch != NULL) {
3210		CHN_LOCK(wrch);
3211		ret = chn_oss_setorder(wrch, map);
3212		CHN_UNLOCK(wrch);
3213	}
3214
3215	if (ret == 0 && rdch != NULL) {
3216		CHN_LOCK(rdch);
3217		ret = chn_oss_setorder(rdch, map);
3218		CHN_UNLOCK(rdch);
3219	}
3220
3221	return (ret);
3222}
3223
3224static int
3225dsp_oss_getchannelmask(struct pcm_channel *wrch, struct pcm_channel *rdch,
3226    int *mask)
3227{
3228	struct pcm_channel *ch;
3229	uint32_t chnmask;
3230	int ret;
3231
3232	chnmask = 0;
3233	ch = (wrch != NULL) ? wrch : rdch;
3234
3235	if (ch != NULL) {
3236		CHN_LOCK(ch);
3237		ret = chn_oss_getmask(ch, &chnmask);
3238		CHN_UNLOCK(ch);
3239	} else
3240		ret = EINVAL;
3241
3242	if (ret == 0)
3243		*mask = chnmask;
3244
3245	return (ret);
3246}
3247
3248#ifdef OSSV4_EXPERIMENT
3249/**
3250 * @brief Retrieve an audio device's label
3251 *
3252 * This is a handler for the @c SNDCTL_GETLABEL ioctl.
3253 *
3254 * See @c http://manuals.opensound.com/developer/SNDCTL_GETLABEL.html
3255 * for more details.
3256 *
3257 * From Hannu@4Front:  "For example ossxmix (just like some HW mixer
3258 * consoles) can show variable "labels" for certain controls. By default
3259 * the application name (say quake) is shown as the label but
3260 * applications may change the labels themselves."
3261 *
3262 * @note As the ioctl definition is still under construction, FreeBSD
3263 * 	 does not currently support @c SNDCTL_GETLABEL.
3264 *
3265 * @param wrch	playback channel (optional; may be NULL)
3266 * @param rdch	recording channel (optional; may be NULL)
3267 * @param label	label gets copied here
3268 *
3269 * @retval EINVAL	Operation not yet supported.
3270 */
3271static int
3272dsp_oss_getlabel(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_label_t *label)
3273{
3274	return (EINVAL);
3275}
3276
3277/**
3278 * @brief Specify an audio device's label
3279 *
3280 * This is a handler for the @c SNDCTL_SETLABEL ioctl.  Please see the
3281 * comments for @c dsp_oss_getlabel immediately above.
3282 *
3283 * See @c http://manuals.opensound.com/developer/SNDCTL_GETLABEL.html
3284 * for more details.
3285 *
3286 * @note As the ioctl definition is still under construction, FreeBSD
3287 * 	 does not currently support SNDCTL_SETLABEL.
3288 *
3289 * @param wrch	playback channel (optional; may be NULL)
3290 * @param rdch	recording channel (optional; may be NULL)
3291 * @param label	label gets copied from here
3292 *
3293 * @retval EINVAL	Operation not yet supported.
3294 */
3295static int
3296dsp_oss_setlabel(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_label_t *label)
3297{
3298	return (EINVAL);
3299}
3300
3301/**
3302 * @brief Retrieve name of currently played song
3303 *
3304 * This is a handler for the @c SNDCTL_GETSONG ioctl.  Audio players could
3305 * tell the system the name of the currently playing song, which would be
3306 * visible in @c /dev/sndstat.
3307 *
3308 * See @c http://manuals.opensound.com/developer/SNDCTL_GETSONG.html
3309 * for more details.
3310 *
3311 * @note As the ioctl definition is still under construction, FreeBSD
3312 * 	 does not currently support SNDCTL_GETSONG.
3313 *
3314 * @param wrch	playback channel (optional; may be NULL)
3315 * @param rdch	recording channel (optional; may be NULL)
3316 * @param song	song name gets copied here
3317 *
3318 * @retval EINVAL	Operation not yet supported.
3319 */
3320static int
3321dsp_oss_getsong(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_longname_t *song)
3322{
3323	return (EINVAL);
3324}
3325
3326/**
3327 * @brief Retrieve name of currently played song
3328 *
3329 * This is a handler for the @c SNDCTL_SETSONG ioctl.  Audio players could
3330 * tell the system the name of the currently playing song, which would be
3331 * visible in @c /dev/sndstat.
3332 *
3333 * See @c http://manuals.opensound.com/developer/SNDCTL_SETSONG.html
3334 * for more details.
3335 *
3336 * @note As the ioctl definition is still under construction, FreeBSD
3337 * 	 does not currently support SNDCTL_SETSONG.
3338 *
3339 * @param wrch	playback channel (optional; may be NULL)
3340 * @param rdch	recording channel (optional; may be NULL)
3341 * @param song	song name gets copied from here
3342 *
3343 * @retval EINVAL	Operation not yet supported.
3344 */
3345static int
3346dsp_oss_setsong(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_longname_t *song)
3347{
3348	return (EINVAL);
3349}
3350
3351/**
3352 * @brief Rename a device
3353 *
3354 * This is a handler for the @c SNDCTL_SETNAME ioctl.
3355 *
3356 * See @c http://manuals.opensound.com/developer/SNDCTL_SETNAME.html for
3357 * more details.
3358 *
3359 * From Hannu@4Front:  "This call is used to change the device name
3360 * reported in /dev/sndstat and ossinfo. So instead of  using some generic
3361 * 'OSS loopback audio (MIDI) driver' the device may be given a meaningfull
3362 * name depending on the current context (for example 'OSS virtual wave table
3363 * synth' or 'VoIP link to London')."
3364 *
3365 * @note As the ioctl definition is still under construction, FreeBSD
3366 * 	 does not currently support SNDCTL_SETNAME.
3367 *
3368 * @param wrch	playback channel (optional; may be NULL)
3369 * @param rdch	recording channel (optional; may be NULL)
3370 * @param name	new device name gets copied from here
3371 *
3372 * @retval EINVAL	Operation not yet supported.
3373 */
3374static int
3375dsp_oss_setname(struct pcm_channel *wrch, struct pcm_channel *rdch, oss_longname_t *name)
3376{
3377	return (EINVAL);
3378}
3379#endif	/* !OSSV4_EXPERIMENT */
3380