xref: /freebsd/sys/dev/sound/pcm/mixer.c (revision 7750ad47a9a7dbc83f87158464170c8640723293)
1 /*-
2  * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
3  * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006
4  * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org>
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #ifdef HAVE_KERNEL_OPTION_HEADERS
30 #include "opt_snd.h"
31 #endif
32 
33 #include <dev/sound/pcm/sound.h>
34 
35 #include "feeder_if.h"
36 #include "mixer_if.h"
37 
38 SND_DECLARE_FILE("$FreeBSD$");
39 
40 static MALLOC_DEFINE(M_MIXER, "mixer", "mixer");
41 
42 static int mixer_bypass = 1;
43 TUNABLE_INT("hw.snd.vpc_mixer_bypass", &mixer_bypass);
44 SYSCTL_INT(_hw_snd, OID_AUTO, vpc_mixer_bypass, CTLFLAG_RW,
45     &mixer_bypass, 0,
46     "control channel pcm/rec volume, bypassing real mixer device");
47 
48 #define MIXER_NAMELEN	16
49 struct snd_mixer {
50 	KOBJ_FIELDS;
51 	void *devinfo;
52 	int busy;
53 	int hwvol_muted;
54 	int hwvol_mixer;
55 	int hwvol_step;
56 	int type;
57 	device_t dev;
58 	u_int32_t hwvol_mute_level;
59 	u_int32_t devs;
60 	u_int32_t recdevs;
61 	u_int32_t recsrc;
62 	u_int16_t level[32];
63 	u_int8_t parent[32];
64 	u_int32_t child[32];
65 	u_int8_t realdev[32];
66 	char name[MIXER_NAMELEN];
67 	struct mtx *lock;
68 	oss_mixer_enuminfo enuminfo;
69 	/**
70 	 * Counter is incremented when applications change any of this
71 	 * mixer's controls.  A change in value indicates that persistent
72 	 * mixer applications should update their displays.
73 	 */
74 	int modify_counter;
75 };
76 
77 static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = {
78 	[SOUND_MIXER_VOLUME]	= 75,
79 	[SOUND_MIXER_BASS]	= 50,
80 	[SOUND_MIXER_TREBLE]	= 50,
81 	[SOUND_MIXER_SYNTH]	= 75,
82 	[SOUND_MIXER_PCM]	= 75,
83 	[SOUND_MIXER_SPEAKER]	= 75,
84 	[SOUND_MIXER_LINE]	= 75,
85 	[SOUND_MIXER_MIC] 	= 0,
86 	[SOUND_MIXER_CD]	= 75,
87 	[SOUND_MIXER_IGAIN]	= 0,
88 	[SOUND_MIXER_LINE1]	= 75,
89 	[SOUND_MIXER_VIDEO]	= 75,
90 	[SOUND_MIXER_RECLEV]	= 75,
91 	[SOUND_MIXER_OGAIN]	= 50,
92 	[SOUND_MIXER_MONITOR]	= 75,
93 };
94 
95 static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
96 
97 static d_open_t mixer_open;
98 static d_close_t mixer_close;
99 static d_ioctl_t mixer_ioctl;
100 
101 static struct cdevsw mixer_cdevsw = {
102 	.d_version =	D_VERSION,
103 	.d_open =	mixer_open,
104 	.d_close =	mixer_close,
105 	.d_ioctl =	mixer_ioctl,
106 	.d_name =	"mixer",
107 };
108 
109 /**
110  * Keeps a count of mixer devices; used only by OSSv4 SNDCTL_SYSINFO ioctl.
111  */
112 int mixer_count = 0;
113 
114 static eventhandler_tag mixer_ehtag = NULL;
115 
116 static struct cdev *
117 mixer_get_devt(device_t dev)
118 {
119 	struct snddev_info *snddev;
120 
121 	snddev = device_get_softc(dev);
122 
123 	return snddev->mixer_dev;
124 }
125 
126 static int
127 mixer_lookup(char *devname)
128 {
129 	int i;
130 
131 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
132 		if (strncmp(devname, snd_mixernames[i],
133 		    strlen(snd_mixernames[i])) == 0)
134 			return i;
135 	return -1;
136 }
137 
138 #define MIXER_SET_UNLOCK(x, y)		do {				\
139 	if ((y) != 0)							\
140 		snd_mtxunlock((x)->lock);				\
141 } while (0)
142 
143 #define MIXER_SET_LOCK(x, y)		do {				\
144 	if ((y) != 0)							\
145 		snd_mtxlock((x)->lock);					\
146 } while (0)
147 
148 static int
149 mixer_set_softpcmvol(struct snd_mixer *m, struct snddev_info *d,
150     u_int left, u_int right)
151 {
152 	struct pcm_channel *c;
153 	int dropmtx, acquiremtx;
154 
155 	if (!PCM_REGISTERED(d))
156 		return (EINVAL);
157 
158 	if (mtx_owned(m->lock))
159 		dropmtx = 1;
160 	else
161 		dropmtx = 0;
162 
163 	if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0)
164 		acquiremtx = 0;
165 	else
166 		acquiremtx = 1;
167 
168 	/*
169 	 * Be careful here. If we're coming from cdev ioctl, it is OK to
170 	 * not doing locking AT ALL (except on individual channel) since
171 	 * we've been heavily guarded by pcm cv, or if we're still
172 	 * under Giant influence. Since we also have mix_* calls, we cannot
173 	 * assume such protection and just do the lock as usuall.
174 	 */
175 	MIXER_SET_UNLOCK(m, dropmtx);
176 	MIXER_SET_LOCK(d, acquiremtx);
177 
178 	CHN_FOREACH(c, d, channels.pcm.busy) {
179 		CHN_LOCK(c);
180 		if (c->direction == PCMDIR_PLAY &&
181 		    (c->feederflags & (1 << FEEDER_VOLUME)))
182 			chn_setvolume_multi(c, SND_VOL_C_MASTER, left, right,
183 			    (left + right) >> 1);
184 		CHN_UNLOCK(c);
185 	}
186 
187 	MIXER_SET_UNLOCK(d, acquiremtx);
188 	MIXER_SET_LOCK(m, dropmtx);
189 
190 	return (0);
191 }
192 
193 static int
194 mixer_set_eq(struct snd_mixer *m, struct snddev_info *d,
195     u_int dev, u_int level)
196 {
197 	struct pcm_channel *c;
198 	struct pcm_feeder *f;
199 	int tone, dropmtx, acquiremtx;
200 
201 	if (dev == SOUND_MIXER_TREBLE)
202 		tone = FEEDEQ_TREBLE;
203 	else if (dev == SOUND_MIXER_BASS)
204 		tone = FEEDEQ_BASS;
205 	else
206 		return (EINVAL);
207 
208 	if (!PCM_REGISTERED(d))
209 		return (EINVAL);
210 
211 	if (mtx_owned(m->lock))
212 		dropmtx = 1;
213 	else
214 		dropmtx = 0;
215 
216 	if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0)
217 		acquiremtx = 0;
218 	else
219 		acquiremtx = 1;
220 
221 	/*
222 	 * Be careful here. If we're coming from cdev ioctl, it is OK to
223 	 * not doing locking AT ALL (except on individual channel) since
224 	 * we've been heavily guarded by pcm cv, or if we're still
225 	 * under Giant influence. Since we also have mix_* calls, we cannot
226 	 * assume such protection and just do the lock as usuall.
227 	 */
228 	MIXER_SET_UNLOCK(m, dropmtx);
229 	MIXER_SET_LOCK(d, acquiremtx);
230 
231 	CHN_FOREACH(c, d, channels.pcm.busy) {
232 		CHN_LOCK(c);
233 		f = chn_findfeeder(c, FEEDER_EQ);
234 		if (f != NULL)
235 			(void)FEEDER_SET(f, tone, level);
236 		CHN_UNLOCK(c);
237 	}
238 
239 	MIXER_SET_UNLOCK(d, acquiremtx);
240 	MIXER_SET_LOCK(m, dropmtx);
241 
242 	return (0);
243 }
244 
245 static int
246 mixer_set(struct snd_mixer *m, u_int dev, u_int lev)
247 {
248 	struct snddev_info *d;
249 	u_int l, r, tl, tr;
250 	u_int32_t parent = SOUND_MIXER_NONE, child = 0;
251 	u_int32_t realdev;
252 	int i, dropmtx;
253 
254 	if (m == NULL || dev >= SOUND_MIXER_NRDEVICES ||
255 	    (0 == (m->devs & (1 << dev))))
256 		return -1;
257 
258 	l = min((lev & 0x00ff), 100);
259 	r = min(((lev & 0xff00) >> 8), 100);
260 	realdev = m->realdev[dev];
261 
262 	d = device_get_softc(m->dev);
263 	if (d == NULL)
264 		return -1;
265 
266 	/* It is safe to drop this mutex due to Giant. */
267 	if (!(d->flags & SD_F_MPSAFE) && mtx_owned(m->lock) != 0)
268 		dropmtx = 1;
269 	else
270 		dropmtx = 0;
271 
272 	MIXER_SET_UNLOCK(m, dropmtx);
273 
274 	/* TODO: recursive handling */
275 	parent = m->parent[dev];
276 	if (parent >= SOUND_MIXER_NRDEVICES)
277 		parent = SOUND_MIXER_NONE;
278 	if (parent == SOUND_MIXER_NONE)
279 		child = m->child[dev];
280 
281 	if (parent != SOUND_MIXER_NONE) {
282 		tl = (l * (m->level[parent] & 0x00ff)) / 100;
283 		tr = (r * ((m->level[parent] & 0xff00) >> 8)) / 100;
284 		if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL))
285 			(void)mixer_set_softpcmvol(m, d, tl, tr);
286 		else if (realdev != SOUND_MIXER_NONE &&
287 		    MIXER_SET(m, realdev, tl, tr) < 0) {
288 			MIXER_SET_LOCK(m, dropmtx);
289 			return -1;
290 		}
291 	} else if (child != 0) {
292 		for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
293 			if (!(child & (1 << i)) || m->parent[i] != dev)
294 				continue;
295 			realdev = m->realdev[i];
296 			tl = (l * (m->level[i] & 0x00ff)) / 100;
297 			tr = (r * ((m->level[i] & 0xff00) >> 8)) / 100;
298 			if (i == SOUND_MIXER_PCM &&
299 			    (d->flags & SD_F_SOFTPCMVOL))
300 				(void)mixer_set_softpcmvol(m, d, tl, tr);
301 			else if (realdev != SOUND_MIXER_NONE)
302 				MIXER_SET(m, realdev, tl, tr);
303 		}
304 		realdev = m->realdev[dev];
305 		if (realdev != SOUND_MIXER_NONE &&
306 		    MIXER_SET(m, realdev, l, r) < 0) {
307 				MIXER_SET_LOCK(m, dropmtx);
308 				return -1;
309 		}
310 	} else {
311 		if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL))
312 			(void)mixer_set_softpcmvol(m, d, l, r);
313 		else if ((dev == SOUND_MIXER_TREBLE ||
314 		    dev == SOUND_MIXER_BASS) && (d->flags & SD_F_EQ))
315 			(void)mixer_set_eq(m, d, dev, (l + r) >> 1);
316 		else if (realdev != SOUND_MIXER_NONE &&
317 		    MIXER_SET(m, realdev, l, r) < 0) {
318 			MIXER_SET_LOCK(m, dropmtx);
319 			return -1;
320 		}
321 	}
322 
323 	MIXER_SET_LOCK(m, dropmtx);
324 
325 	m->level[dev] = l | (r << 8);
326 
327 	return 0;
328 }
329 
330 static int
331 mixer_get(struct snd_mixer *mixer, int dev)
332 {
333 	if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev)))
334 		return mixer->level[dev];
335 	else
336 		return -1;
337 }
338 
339 static int
340 mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src)
341 {
342 	struct snddev_info *d;
343 	u_int32_t recsrc;
344 	int dropmtx;
345 
346 	d = device_get_softc(mixer->dev);
347 	if (d == NULL)
348 		return -1;
349 	if (!(d->flags & SD_F_MPSAFE) && mtx_owned(mixer->lock) != 0)
350 		dropmtx = 1;
351 	else
352 		dropmtx = 0;
353 	src &= mixer->recdevs;
354 	if (src == 0)
355 		src = mixer->recdevs & SOUND_MASK_MIC;
356 	if (src == 0)
357 		src = mixer->recdevs & SOUND_MASK_MONITOR;
358 	if (src == 0)
359 		src = mixer->recdevs & SOUND_MASK_LINE;
360 	if (src == 0 && mixer->recdevs != 0)
361 		src = (1 << (ffs(mixer->recdevs) - 1));
362 	/* It is safe to drop this mutex due to Giant. */
363 	MIXER_SET_UNLOCK(mixer, dropmtx);
364 	recsrc = MIXER_SETRECSRC(mixer, src);
365 	MIXER_SET_LOCK(mixer, dropmtx);
366 
367 	mixer->recsrc = recsrc;
368 
369 	return 0;
370 }
371 
372 static int
373 mixer_getrecsrc(struct snd_mixer *mixer)
374 {
375 	return mixer->recsrc;
376 }
377 
378 /**
379  * @brief Retrieve the route number of the current recording device
380  *
381  * OSSv4 assigns routing numbers to recording devices, unlike the previous
382  * API which relied on a fixed table of device numbers and names.  This
383  * function returns the routing number of the device currently selected
384  * for recording.
385  *
386  * For now, this function is kind of a goofy compatibility stub atop the
387  * existing sound system.  (For example, in theory, the old sound system
388  * allows multiple recording devices to be specified via a bitmask.)
389  *
390  * @param m	mixer context container thing
391  *
392  * @retval 0		success
393  * @retval EIDRM	no recording device found (generally not possible)
394  * @todo Ask about error code
395  */
396 static int
397 mixer_get_recroute(struct snd_mixer *m, int *route)
398 {
399 	int i, cnt;
400 
401 	cnt = 0;
402 
403 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
404 		/** @todo can user set a multi-device mask? (== or &?) */
405 		if ((1 << i) == m->recsrc)
406 			break;
407 		if ((1 << i) & m->recdevs)
408 			++cnt;
409 	}
410 
411 	if (i == SOUND_MIXER_NRDEVICES)
412 		return EIDRM;
413 
414 	*route = cnt;
415 	return 0;
416 }
417 
418 /**
419  * @brief Select a device for recording
420  *
421  * This function sets a recording source based on a recording device's
422  * routing number.  Said number is translated to an old school recdev
423  * mask and passed over mixer_setrecsrc.
424  *
425  * @param m	mixer context container thing
426  *
427  * @retval 0		success(?)
428  * @retval EINVAL	User specified an invalid device number
429  * @retval otherwise	error from mixer_setrecsrc
430  */
431 static int
432 mixer_set_recroute(struct snd_mixer *m, int route)
433 {
434 	int i, cnt, ret;
435 
436 	ret = 0;
437 	cnt = 0;
438 
439 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
440 		if ((1 << i) & m->recdevs) {
441 			if (route == cnt)
442 				break;
443 			++cnt;
444 		}
445 	}
446 
447 	if (i == SOUND_MIXER_NRDEVICES)
448 		ret = EINVAL;
449 	else
450 		ret = mixer_setrecsrc(m, (1 << i));
451 
452 	return ret;
453 }
454 
455 void
456 mix_setdevs(struct snd_mixer *m, u_int32_t v)
457 {
458 	struct snddev_info *d;
459 	int i;
460 
461 	if (m == NULL)
462 		return;
463 
464 	d = device_get_softc(m->dev);
465 	if (d != NULL && (d->flags & SD_F_SOFTPCMVOL))
466 		v |= SOUND_MASK_PCM;
467 	if (d != NULL && (d->flags & SD_F_EQ))
468 		v |= SOUND_MASK_TREBLE | SOUND_MASK_BASS;
469 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
470 		if (m->parent[i] < SOUND_MIXER_NRDEVICES)
471 			v |= 1 << m->parent[i];
472 		v |= m->child[i];
473 	}
474 	m->devs = v;
475 }
476 
477 /**
478  * @brief Record mask of available recording devices
479  *
480  * Calling functions are responsible for defining the mask of available
481  * recording devices.  This function records that value in a structure
482  * used by the rest of the mixer code.
483  *
484  * This function also populates a structure used by the SNDCTL_DSP_*RECSRC*
485  * family of ioctls that are part of OSSV4.  All recording device labels
486  * are concatenated in ascending order corresponding to their routing
487  * numbers.  (Ex:  a system might have 0 => 'vol', 1 => 'cd', 2 => 'line',
488  * etc.)  For now, these labels are just the standard recording device
489  * names (cd, line1, etc.), but will eventually be fully dynamic and user
490  * controlled.
491  *
492  * @param m	mixer device context container thing
493  * @param v	mask of recording devices
494  */
495 void
496 mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
497 {
498 	oss_mixer_enuminfo *ei;
499 	char *loc;
500 	int i, nvalues, nwrote, nleft, ncopied;
501 
502 	ei = &m->enuminfo;
503 
504 	nvalues = 0;
505 	nwrote = 0;
506 	nleft = sizeof(ei->strings);
507 	loc = ei->strings;
508 
509 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
510 		if ((1 << i) & v) {
511 			ei->strindex[nvalues] = nwrote;
512 			ncopied = strlcpy(loc, snd_mixernames[i], nleft) + 1;
513 			    /* strlcpy retval doesn't include terminator */
514 
515 			nwrote += ncopied;
516 			nleft -= ncopied;
517 			nvalues++;
518 
519 			/*
520 			 * XXX I don't think this should ever be possible.
521 			 * Even with a move to dynamic device/channel names,
522 			 * each label is limited to ~16 characters, so that'd
523 			 * take a LOT to fill this buffer.
524 			 */
525 			if ((nleft <= 0) || (nvalues >= OSS_ENUM_MAXVALUE)) {
526 				device_printf(m->dev,
527 				    "mix_setrecdevs:  Not enough room to store device names--please file a bug report.\n");
528 				device_printf(m->dev,
529 				    "mix_setrecdevs:  Please include details about your sound hardware, OS version, etc.\n");
530 				break;
531 			}
532 
533 			loc = &ei->strings[nwrote];
534 		}
535 	}
536 
537 	/*
538 	 * NB:	The SNDCTL_DSP_GET_RECSRC_NAMES ioctl ignores the dev
539 	 * 	and ctrl fields.
540 	 */
541 	ei->nvalues = nvalues;
542 	m->recdevs = v;
543 }
544 
545 void
546 mix_setparentchild(struct snd_mixer *m, u_int32_t parent, u_int32_t childs)
547 {
548 	u_int32_t mask = 0;
549 	int i;
550 
551 	if (m == NULL || parent >= SOUND_MIXER_NRDEVICES)
552 		return;
553 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
554 		if (i == parent)
555 			continue;
556 		if (childs & (1 << i)) {
557 			mask |= 1 << i;
558 			if (m->parent[i] < SOUND_MIXER_NRDEVICES)
559 				m->child[m->parent[i]] &= ~(1 << i);
560 			m->parent[i] = parent;
561 			m->child[i] = 0;
562 		}
563 	}
564 	mask &= ~(1 << parent);
565 	m->child[parent] = mask;
566 }
567 
568 void
569 mix_setrealdev(struct snd_mixer *m, u_int32_t dev, u_int32_t realdev)
570 {
571 	if (m == NULL || dev >= SOUND_MIXER_NRDEVICES ||
572 	    !(realdev == SOUND_MIXER_NONE || realdev < SOUND_MIXER_NRDEVICES))
573 		return;
574 	m->realdev[dev] = realdev;
575 }
576 
577 u_int32_t
578 mix_getparent(struct snd_mixer *m, u_int32_t dev)
579 {
580 	if (m == NULL || dev >= SOUND_MIXER_NRDEVICES)
581 		return SOUND_MIXER_NONE;
582 	return m->parent[dev];
583 }
584 
585 u_int32_t
586 mix_getchild(struct snd_mixer *m, u_int32_t dev)
587 {
588 	if (m == NULL || dev >= SOUND_MIXER_NRDEVICES)
589 		return 0;
590 	return m->child[dev];
591 }
592 
593 u_int32_t
594 mix_getdevs(struct snd_mixer *m)
595 {
596 	return m->devs;
597 }
598 
599 u_int32_t
600 mix_getrecdevs(struct snd_mixer *m)
601 {
602 	return m->recdevs;
603 }
604 
605 void *
606 mix_getdevinfo(struct snd_mixer *m)
607 {
608 	return m->devinfo;
609 }
610 
611 static struct snd_mixer *
612 mixer_obj_create(device_t dev, kobj_class_t cls, void *devinfo,
613     int type, const char *desc)
614 {
615 	struct snd_mixer *m;
616 	int i;
617 
618 	KASSERT(dev != NULL && cls != NULL && devinfo != NULL,
619 	    ("%s(): NULL data dev=%p cls=%p devinfo=%p",
620 	    __func__, dev, cls, devinfo));
621 	KASSERT(type == MIXER_TYPE_PRIMARY || type == MIXER_TYPE_SECONDARY,
622 	    ("invalid mixer type=%d", type));
623 
624 	m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO);
625 	snprintf(m->name, sizeof(m->name), "%s:mixer",
626 	    device_get_nameunit(dev));
627 	if (desc != NULL) {
628 		strlcat(m->name, ":", sizeof(m->name));
629 		strlcat(m->name, desc, sizeof(m->name));
630 	}
631 	m->lock = snd_mtxcreate(m->name, (type == MIXER_TYPE_PRIMARY) ?
632 	    "primary pcm mixer" : "secondary pcm mixer");
633 	m->type = type;
634 	m->devinfo = devinfo;
635 	m->busy = 0;
636 	m->dev = dev;
637 	for (i = 0; i < (sizeof(m->parent) / sizeof(m->parent[0])); i++) {
638 		m->parent[i] = SOUND_MIXER_NONE;
639 		m->child[i] = 0;
640 		m->realdev[i] = i;
641 	}
642 
643 	if (MIXER_INIT(m)) {
644 		snd_mtxlock(m->lock);
645 		snd_mtxfree(m->lock);
646 		kobj_delete((kobj_t)m, M_MIXER);
647 		return (NULL);
648 	}
649 
650 	return (m);
651 }
652 
653 int
654 mixer_delete(struct snd_mixer *m)
655 {
656 	KASSERT(m != NULL, ("NULL snd_mixer"));
657 	KASSERT(m->type == MIXER_TYPE_SECONDARY,
658 	    ("%s(): illegal mixer type=%d", __func__, m->type));
659 
660 	/* mixer uninit can sleep --hps */
661 
662 	MIXER_UNINIT(m);
663 
664 	snd_mtxfree(m->lock);
665 	kobj_delete((kobj_t)m, M_MIXER);
666 
667 	--mixer_count;
668 
669 	return (0);
670 }
671 
672 struct snd_mixer *
673 mixer_create(device_t dev, kobj_class_t cls, void *devinfo, const char *desc)
674 {
675 	struct snd_mixer *m;
676 
677 	m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_SECONDARY, desc);
678 
679 	if (m != NULL)
680 		++mixer_count;
681 
682 	return (m);
683 }
684 
685 int
686 mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
687 {
688 	struct snddev_info *snddev;
689 	struct snd_mixer *m;
690 	u_int16_t v;
691 	struct cdev *pdev;
692 	int i, unit, devunit, val;
693 
694 	snddev = device_get_softc(dev);
695 	if (snddev == NULL)
696 		return (-1);
697 
698 	if (resource_int_value(device_get_name(dev),
699 	    device_get_unit(dev), "eq", &val) == 0 && val != 0) {
700 		snddev->flags |= SD_F_EQ;
701 		if ((val & SD_F_EQ_MASK) == val)
702 			snddev->flags |= val;
703 		else
704 			snddev->flags |= SD_F_EQ_DEFAULT;
705 		snddev->eqpreamp = 0;
706 	}
707 
708 	m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_PRIMARY, NULL);
709 	if (m == NULL)
710 		return (-1);
711 
712 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
713 		v = snd_mixerdefaults[i];
714 
715 		if (resource_int_value(device_get_name(dev),
716 		    device_get_unit(dev), snd_mixernames[i], &val) == 0) {
717 			if (val >= 0 && val <= 100) {
718 				v = (u_int16_t) val;
719 			}
720 		}
721 
722 		mixer_set(m, i, v | (v << 8));
723 	}
724 
725 	mixer_setrecsrc(m, 0); /* Set default input. */
726 
727 	unit = device_get_unit(dev);
728 	devunit = snd_mkunit(unit, SND_DEV_CTL, 0);
729 	pdev = make_dev(&mixer_cdevsw, PCMMINOR(devunit),
730 		 UID_ROOT, GID_WHEEL, 0666, "mixer%d", unit);
731 	pdev->si_drv1 = m;
732 	snddev->mixer_dev = pdev;
733 
734 	++mixer_count;
735 
736 	if (bootverbose) {
737 		for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
738 			if (!(m->devs & (1 << i)))
739 				continue;
740 			if (m->realdev[i] != i) {
741 				device_printf(dev, "Mixer \"%s\" -> \"%s\":",
742 				    snd_mixernames[i],
743 				    (m->realdev[i] < SOUND_MIXER_NRDEVICES) ?
744 				    snd_mixernames[m->realdev[i]] : "none");
745 			} else {
746 				device_printf(dev, "Mixer \"%s\":",
747 				    snd_mixernames[i]);
748 			}
749 			if (m->parent[i] < SOUND_MIXER_NRDEVICES)
750 				printf(" parent=\"%s\"",
751 				    snd_mixernames[m->parent[i]]);
752 			if (m->child[i] != 0)
753 				printf(" child=0x%08x", m->child[i]);
754 			printf("\n");
755 		}
756 		if (snddev->flags & SD_F_SOFTPCMVOL)
757 			device_printf(dev, "Soft PCM mixer ENABLED\n");
758 		if (snddev->flags & SD_F_EQ)
759 			device_printf(dev, "EQ Treble/Bass ENABLED\n");
760 	}
761 
762 	return (0);
763 }
764 
765 int
766 mixer_uninit(device_t dev)
767 {
768 	int i;
769 	struct snddev_info *d;
770 	struct snd_mixer *m;
771 	struct cdev *pdev;
772 
773 	d = device_get_softc(dev);
774 	pdev = mixer_get_devt(dev);
775 	if (d == NULL || pdev == NULL || pdev->si_drv1 == NULL)
776 		return EBADF;
777 
778 	m = pdev->si_drv1;
779 	KASSERT(m != NULL, ("NULL snd_mixer"));
780 	KASSERT(m->type == MIXER_TYPE_PRIMARY,
781 	    ("%s(): illegal mixer type=%d", __func__, m->type));
782 
783 	snd_mtxlock(m->lock);
784 
785 	if (m->busy) {
786 		snd_mtxunlock(m->lock);
787 		return EBUSY;
788 	}
789 
790 	/* destroy dev can sleep --hps */
791 
792 	snd_mtxunlock(m->lock);
793 
794 	pdev->si_drv1 = NULL;
795 	destroy_dev(pdev);
796 
797 	snd_mtxlock(m->lock);
798 
799 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
800 		mixer_set(m, i, 0);
801 
802 	mixer_setrecsrc(m, SOUND_MASK_MIC);
803 
804 	snd_mtxunlock(m->lock);
805 
806 	/* mixer uninit can sleep --hps */
807 
808 	MIXER_UNINIT(m);
809 
810 	snd_mtxfree(m->lock);
811 	kobj_delete((kobj_t)m, M_MIXER);
812 
813 	d->mixer_dev = NULL;
814 
815 	--mixer_count;
816 
817 	return 0;
818 }
819 
820 int
821 mixer_reinit(device_t dev)
822 {
823 	struct snd_mixer *m;
824 	struct cdev *pdev;
825 	int i;
826 
827 	pdev = mixer_get_devt(dev);
828 	m = pdev->si_drv1;
829 	snd_mtxlock(m->lock);
830 
831 	i = MIXER_REINIT(m);
832 	if (i) {
833 		snd_mtxunlock(m->lock);
834 		return i;
835 	}
836 
837 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
838 		mixer_set(m, i, m->level[i]);
839 
840 	mixer_setrecsrc(m, m->recsrc);
841 	snd_mtxunlock(m->lock);
842 
843 	return 0;
844 }
845 
846 static int
847 sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS)
848 {
849 	char devname[32];
850 	int error, dev;
851 	struct snd_mixer *m;
852 
853 	m = oidp->oid_arg1;
854 	snd_mtxlock(m->lock);
855 	strlcpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname));
856 	snd_mtxunlock(m->lock);
857 	error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req);
858 	snd_mtxlock(m->lock);
859 	if (error == 0 && req->newptr != NULL) {
860 		dev = mixer_lookup(devname);
861 		if (dev == -1) {
862 			snd_mtxunlock(m->lock);
863 			return EINVAL;
864 		}
865 		else if (dev != m->hwvol_mixer) {
866 			m->hwvol_mixer = dev;
867 			m->hwvol_muted = 0;
868 		}
869 	}
870 	snd_mtxunlock(m->lock);
871 	return error;
872 }
873 
874 int
875 mixer_hwvol_init(device_t dev)
876 {
877 	struct snd_mixer *m;
878 	struct cdev *pdev;
879 
880 	pdev = mixer_get_devt(dev);
881 	m = pdev->si_drv1;
882 
883 	m->hwvol_mixer = SOUND_MIXER_VOLUME;
884 	m->hwvol_step = 5;
885 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
886 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
887             OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, "");
888 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
889 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
890             OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0,
891 	    sysctl_hw_snd_hwvol_mixer, "A", "");
892 	return 0;
893 }
894 
895 void
896 mixer_hwvol_mute(device_t dev)
897 {
898 	struct snd_mixer *m;
899 	struct cdev *pdev;
900 
901 	pdev = mixer_get_devt(dev);
902 	m = pdev->si_drv1;
903 	snd_mtxlock(m->lock);
904 	if (m->hwvol_muted) {
905 		m->hwvol_muted = 0;
906 		mixer_set(m, m->hwvol_mixer, m->hwvol_mute_level);
907 	} else {
908 		m->hwvol_muted++;
909 		m->hwvol_mute_level = mixer_get(m, m->hwvol_mixer);
910 		mixer_set(m, m->hwvol_mixer, 0);
911 	}
912 	snd_mtxunlock(m->lock);
913 }
914 
915 void
916 mixer_hwvol_step(device_t dev, int left_step, int right_step)
917 {
918 	struct snd_mixer *m;
919 	int level, left, right;
920 	struct cdev *pdev;
921 
922 	pdev = mixer_get_devt(dev);
923 	m = pdev->si_drv1;
924 	snd_mtxlock(m->lock);
925 	if (m->hwvol_muted) {
926 		m->hwvol_muted = 0;
927 		level = m->hwvol_mute_level;
928 	} else
929 		level = mixer_get(m, m->hwvol_mixer);
930 	if (level != -1) {
931 		left = level & 0xff;
932 		right = level >> 8;
933 		left += left_step * m->hwvol_step;
934 		if (left < 0)
935 			left = 0;
936 		right += right_step * m->hwvol_step;
937 		if (right < 0)
938 			right = 0;
939 		mixer_set(m, m->hwvol_mixer, left | right << 8);
940 	}
941 	snd_mtxunlock(m->lock);
942 }
943 
944 int
945 mixer_busy(struct snd_mixer *m)
946 {
947 	KASSERT(m != NULL, ("NULL snd_mixer"));
948 
949 	return (m->busy);
950 }
951 
952 int
953 mix_set(struct snd_mixer *m, u_int dev, u_int left, u_int right)
954 {
955 	int ret;
956 
957 	KASSERT(m != NULL, ("NULL snd_mixer"));
958 
959 	snd_mtxlock(m->lock);
960 	ret = mixer_set(m, dev, left | (right << 8));
961 	snd_mtxunlock(m->lock);
962 
963 	return ((ret != 0) ? ENXIO : 0);
964 }
965 
966 int
967 mix_get(struct snd_mixer *m, u_int dev)
968 {
969 	int ret;
970 
971 	KASSERT(m != NULL, ("NULL snd_mixer"));
972 
973 	snd_mtxlock(m->lock);
974 	ret = mixer_get(m, dev);
975 	snd_mtxunlock(m->lock);
976 
977 	return (ret);
978 }
979 
980 int
981 mix_setrecsrc(struct snd_mixer *m, u_int32_t src)
982 {
983 	int ret;
984 
985 	KASSERT(m != NULL, ("NULL snd_mixer"));
986 
987 	snd_mtxlock(m->lock);
988 	ret = mixer_setrecsrc(m, src);
989 	snd_mtxunlock(m->lock);
990 
991 	return ((ret != 0) ? ENXIO : 0);
992 }
993 
994 u_int32_t
995 mix_getrecsrc(struct snd_mixer *m)
996 {
997 	u_int32_t ret;
998 
999 	KASSERT(m != NULL, ("NULL snd_mixer"));
1000 
1001 	snd_mtxlock(m->lock);
1002 	ret = mixer_getrecsrc(m);
1003 	snd_mtxunlock(m->lock);
1004 
1005 	return (ret);
1006 }
1007 
1008 int
1009 mix_get_type(struct snd_mixer *m)
1010 {
1011 	KASSERT(m != NULL, ("NULL snd_mixer"));
1012 
1013 	return (m->type);
1014 }
1015 
1016 /* ----------------------------------------------------------------------- */
1017 
1018 static int
1019 mixer_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
1020 {
1021 	struct snddev_info *d;
1022 	struct snd_mixer *m;
1023 
1024 
1025 	if (i_dev == NULL || i_dev->si_drv1 == NULL)
1026 		return (EBADF);
1027 
1028 	m = i_dev->si_drv1;
1029 	d = device_get_softc(m->dev);
1030 	if (!PCM_REGISTERED(d))
1031 		return (EBADF);
1032 
1033 	/* XXX Need Giant magic entry ??? */
1034 
1035 	snd_mtxlock(m->lock);
1036 	m->busy = 1;
1037 	snd_mtxunlock(m->lock);
1038 
1039 	return (0);
1040 }
1041 
1042 static int
1043 mixer_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
1044 {
1045 	struct snddev_info *d;
1046 	struct snd_mixer *m;
1047 	int ret;
1048 
1049 	if (i_dev == NULL || i_dev->si_drv1 == NULL)
1050 		return (EBADF);
1051 
1052 	m = i_dev->si_drv1;
1053 	d = device_get_softc(m->dev);
1054 	if (!PCM_REGISTERED(d))
1055 		return (EBADF);
1056 
1057 	/* XXX Need Giant magic entry ??? */
1058 
1059 	snd_mtxlock(m->lock);
1060 	ret = (m->busy == 0) ? EBADF : 0;
1061 	m->busy = 0;
1062 	snd_mtxunlock(m->lock);
1063 
1064 	return (ret);
1065 }
1066 
1067 static int
1068 mixer_ioctl_channel(struct cdev *dev, u_long cmd, caddr_t arg, int mode,
1069     struct thread *td, int from)
1070 {
1071 	struct snddev_info *d;
1072 	struct snd_mixer *m;
1073 	struct pcm_channel *c, *rdch, *wrch;
1074 	pid_t pid;
1075 	int j, ret;
1076 
1077 	if (td == NULL || td->td_proc == NULL)
1078 		return (-1);
1079 
1080 	m = dev->si_drv1;
1081 	d = device_get_softc(m->dev);
1082 	j = cmd & 0xff;
1083 
1084 	switch (j) {
1085 	case SOUND_MIXER_PCM:
1086 	case SOUND_MIXER_RECLEV:
1087 	case SOUND_MIXER_DEVMASK:
1088 	case SOUND_MIXER_CAPS:
1089 	case SOUND_MIXER_STEREODEVS:
1090 		break;
1091 	default:
1092 		return (-1);
1093 		break;
1094 	}
1095 
1096 	pid = td->td_proc->p_pid;
1097 	rdch = NULL;
1098 	wrch = NULL;
1099 	c = NULL;
1100 	ret = -1;
1101 
1102 	/*
1103 	 * This is unfair. Imagine single proc opening multiple
1104 	 * instances of same direction. What we do right now
1105 	 * is looking for the first matching proc/pid, and just
1106 	 * that. Nothing more. Consider it done.
1107 	 *
1108 	 * The better approach of controlling specific channel
1109 	 * pcm or rec volume is by doing mixer ioctl
1110 	 * (SNDCTL_DSP_[SET|GET][PLAY|REC]VOL / SOUND_MIXER_[PCM|RECLEV]
1111 	 * on its open fd, rather than cracky mixer bypassing here.
1112 	 */
1113 	CHN_FOREACH(c, d, channels.pcm.opened) {
1114 		CHN_LOCK(c);
1115 		if (c->pid != pid ||
1116 		    !(c->feederflags & (1 << FEEDER_VOLUME))) {
1117 			CHN_UNLOCK(c);
1118 			continue;
1119 		}
1120 		if (rdch == NULL && c->direction == PCMDIR_REC) {
1121 			rdch = c;
1122 			if (j == SOUND_MIXER_RECLEV)
1123 				goto mixer_ioctl_channel_proc;
1124 		} else if (wrch == NULL && c->direction == PCMDIR_PLAY) {
1125 			wrch = c;
1126 			if (j == SOUND_MIXER_PCM)
1127 				goto mixer_ioctl_channel_proc;
1128 		}
1129 		CHN_UNLOCK(c);
1130 		if (rdch != NULL && wrch != NULL)
1131 			break;
1132 	}
1133 
1134 	if (rdch == NULL && wrch == NULL)
1135 		return (-1);
1136 
1137 	if ((j == SOUND_MIXER_DEVMASK || j == SOUND_MIXER_CAPS ||
1138 	    j == SOUND_MIXER_STEREODEVS) &&
1139 	    (cmd & ~0xff) == MIXER_READ(0)) {
1140 		snd_mtxlock(m->lock);
1141 		*(int *)arg = mix_getdevs(m);
1142 		snd_mtxunlock(m->lock);
1143 		if (rdch != NULL)
1144 			*(int *)arg |= SOUND_MASK_RECLEV;
1145 		if (wrch != NULL)
1146 			*(int *)arg |= SOUND_MASK_PCM;
1147 		ret = 0;
1148 	}
1149 
1150 	return (ret);
1151 
1152 mixer_ioctl_channel_proc:
1153 
1154 	KASSERT(c != NULL, ("%s(): NULL channel", __func__));
1155 	CHN_LOCKASSERT(c);
1156 
1157 	if ((cmd & ~0xff) == MIXER_WRITE(0)) {
1158 		int left, right, center;
1159 
1160 		left = *(int *)arg & 0x7f;
1161 		right = (*(int *)arg >> 8) & 0x7f;
1162 		center = (left + right) >> 1;
1163 		chn_setvolume_multi(c, SND_VOL_C_PCM, left, right, center);
1164 	} else if ((cmd & ~0xff) == MIXER_READ(0)) {
1165 		*(int *)arg = CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FL);
1166 		*(int *)arg |=
1167 		    CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FR) << 8;
1168 	}
1169 
1170 	CHN_UNLOCK(c);
1171 
1172 	return (0);
1173 }
1174 
1175 static int
1176 mixer_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
1177     struct thread *td)
1178 {
1179 	struct snddev_info *d;
1180 	int ret;
1181 
1182 	if (i_dev == NULL || i_dev->si_drv1 == NULL)
1183 		return (EBADF);
1184 
1185 	d = device_get_softc(((struct snd_mixer *)i_dev->si_drv1)->dev);
1186 	if (!PCM_REGISTERED(d))
1187 		return (EBADF);
1188 
1189 	PCM_GIANT_ENTER(d);
1190 	PCM_ACQUIRE_QUICK(d);
1191 
1192 	ret = -1;
1193 
1194 	if (mixer_bypass != 0 && (d->flags & SD_F_VPC))
1195 		ret = mixer_ioctl_channel(i_dev, cmd, arg, mode, td,
1196 		    MIXER_CMD_CDEV);
1197 
1198 	if (ret == -1)
1199 		ret = mixer_ioctl_cmd(i_dev, cmd, arg, mode, td,
1200 		    MIXER_CMD_CDEV);
1201 
1202 	PCM_RELEASE_QUICK(d);
1203 	PCM_GIANT_LEAVE(d);
1204 
1205 	return (ret);
1206 }
1207 
1208 /*
1209  * XXX Make sure you can guarantee concurrency safety before calling this
1210  *     function, be it through Giant, PCM_*, etc !
1211  */
1212 int
1213 mixer_ioctl_cmd(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
1214     struct thread *td, int from)
1215 {
1216 	struct snd_mixer *m;
1217 	int ret = EINVAL, *arg_i = (int *)arg;
1218 	int v = -1, j = cmd & 0xff;
1219 
1220 	/*
1221 	 * Certain ioctls may be made on any type of device (audio, mixer,
1222 	 * and MIDI).  Handle those special cases here.
1223 	 */
1224 	if (IOCGROUP(cmd) == 'X') {
1225 		switch (cmd) {
1226 		case SNDCTL_SYSINFO:
1227 			sound_oss_sysinfo((oss_sysinfo *)arg);
1228 			return (0);
1229 		case SNDCTL_CARDINFO:
1230 			return (sound_oss_card_info((oss_card_info *)arg));
1231 	    	case SNDCTL_AUDIOINFO:
1232 	    	case SNDCTL_AUDIOINFO_EX:
1233 	    	case SNDCTL_ENGINEINFO:
1234 			return (dsp_oss_audioinfo(i_dev, (oss_audioinfo *)arg));
1235 		case SNDCTL_MIXERINFO:
1236 			return (mixer_oss_mixerinfo(i_dev, (oss_mixerinfo *)arg));
1237 		}
1238 		return (EINVAL);
1239 	}
1240 
1241 	m = i_dev->si_drv1;
1242 
1243 	if (m == NULL)
1244 		return (EBADF);
1245 
1246 	snd_mtxlock(m->lock);
1247 	if (from == MIXER_CMD_CDEV && !m->busy) {
1248 		snd_mtxunlock(m->lock);
1249 		return (EBADF);
1250 	}
1251 	switch (cmd) {
1252 	case SNDCTL_DSP_GET_RECSRC_NAMES:
1253 		bcopy((void *)&m->enuminfo, arg, sizeof(oss_mixer_enuminfo));
1254 		ret = 0;
1255 		goto done;
1256 	case SNDCTL_DSP_GET_RECSRC:
1257 		ret = mixer_get_recroute(m, arg_i);
1258 		goto done;
1259 	case SNDCTL_DSP_SET_RECSRC:
1260 		ret = mixer_set_recroute(m, *arg_i);
1261 		goto done;
1262 	case OSS_GETVERSION:
1263 		*arg_i = SOUND_VERSION;
1264 		ret = 0;
1265 		goto done;
1266 	}
1267 	if ((cmd & ~0xff) == MIXER_WRITE(0)) {
1268 		if (j == SOUND_MIXER_RECSRC)
1269 			ret = mixer_setrecsrc(m, *arg_i);
1270 		else
1271 			ret = mixer_set(m, j, *arg_i);
1272 		snd_mtxunlock(m->lock);
1273 		return ((ret == 0) ? 0 : ENXIO);
1274 	}
1275 	if ((cmd & ~0xff) == MIXER_READ(0)) {
1276 		switch (j) {
1277 		case SOUND_MIXER_DEVMASK:
1278 		case SOUND_MIXER_CAPS:
1279 		case SOUND_MIXER_STEREODEVS:
1280 			v = mix_getdevs(m);
1281 			break;
1282 		case SOUND_MIXER_RECMASK:
1283 			v = mix_getrecdevs(m);
1284 			break;
1285 		case SOUND_MIXER_RECSRC:
1286 			v = mixer_getrecsrc(m);
1287 			break;
1288 		default:
1289 			v = mixer_get(m, j);
1290 		}
1291 		*arg_i = v;
1292 		snd_mtxunlock(m->lock);
1293 		return ((v != -1) ? 0 : ENXIO);
1294 	}
1295 done:
1296 	snd_mtxunlock(m->lock);
1297 	return (ret);
1298 }
1299 
1300 static void
1301 mixer_clone(void *arg,
1302 #if __FreeBSD_version >= 600034
1303     struct ucred *cred,
1304 #endif
1305     char *name, int namelen, struct cdev **dev)
1306 {
1307 	struct snddev_info *d;
1308 
1309 	if (*dev != NULL)
1310 		return;
1311 	if (strcmp(name, "mixer") == 0) {
1312 		d = devclass_get_softc(pcm_devclass, snd_unit);
1313 		if (PCM_REGISTERED(d) && d->mixer_dev != NULL) {
1314 			*dev = d->mixer_dev;
1315 			dev_ref(*dev);
1316 		}
1317 	}
1318 }
1319 
1320 static void
1321 mixer_sysinit(void *p)
1322 {
1323 	if (mixer_ehtag != NULL)
1324 		return;
1325 	mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000);
1326 }
1327 
1328 static void
1329 mixer_sysuninit(void *p)
1330 {
1331 	if (mixer_ehtag == NULL)
1332 		return;
1333 	EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag);
1334 	mixer_ehtag = NULL;
1335 }
1336 
1337 SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL);
1338 SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL);
1339 
1340 /**
1341  * @brief Handler for SNDCTL_MIXERINFO
1342  *
1343  * This function searches for a mixer based on the numeric ID stored
1344  * in oss_miserinfo::dev.  If set to -1, then information about the
1345  * current mixer handling the request is provided.  Note, however, that
1346  * this ioctl may be made with any sound device (audio, mixer, midi).
1347  *
1348  * @note Caller must not hold any PCM device, channel, or mixer locks.
1349  *
1350  * See http://manuals.opensound.com/developer/SNDCTL_MIXERINFO.html for
1351  * more information.
1352  *
1353  * @param i_dev	character device on which the ioctl arrived
1354  * @param arg	user argument (oss_mixerinfo *)
1355  *
1356  * @retval EINVAL	oss_mixerinfo::dev specified a bad value
1357  * @retval 0		success
1358  */
1359 int
1360 mixer_oss_mixerinfo(struct cdev *i_dev, oss_mixerinfo *mi)
1361 {
1362 	struct snddev_info *d;
1363 	struct snd_mixer *m;
1364 	int nmix, i;
1365 
1366 	/*
1367 	 * If probing the device handling the ioctl, make sure it's a mixer
1368 	 * device.  (This ioctl is valid on audio, mixer, and midi devices.)
1369 	 */
1370 	if (mi->dev == -1 && i_dev->si_devsw != &mixer_cdevsw)
1371 		return (EINVAL);
1372 
1373 	d = NULL;
1374 	m = NULL;
1375 	nmix = 0;
1376 
1377 	/*
1378 	 * There's a 1:1 relationship between mixers and PCM devices, so
1379 	 * begin by iterating over PCM devices and search for our mixer.
1380 	 */
1381 	for (i = 0; pcm_devclass != NULL &&
1382 	    i < devclass_get_maxunit(pcm_devclass); i++) {
1383 		d = devclass_get_softc(pcm_devclass, i);
1384 		if (!PCM_REGISTERED(d))
1385 			continue;
1386 
1387 		/* XXX Need Giant magic entry */
1388 
1389 		/* See the note in function docblock. */
1390 		PCM_UNLOCKASSERT(d);
1391 		PCM_LOCK(d);
1392 
1393 		if (d->mixer_dev != NULL && d->mixer_dev->si_drv1 != NULL &&
1394 		    ((mi->dev == -1 && d->mixer_dev == i_dev) ||
1395 		    mi->dev == nmix)) {
1396 			m = d->mixer_dev->si_drv1;
1397 			mtx_lock(m->lock);
1398 
1399 			/*
1400 			 * At this point, the following synchronization stuff
1401 			 * has happened:
1402 			 * - a specific PCM device is locked.
1403 			 * - a specific mixer device has been locked, so be
1404 			 *   sure to unlock when existing.
1405 			 */
1406 			bzero((void *)mi, sizeof(*mi));
1407 			mi->dev = nmix;
1408 			snprintf(mi->id, sizeof(mi->id), "mixer%d", i);
1409 			strlcpy(mi->name, m->name, sizeof(mi->name));
1410 			mi->modify_counter = m->modify_counter;
1411 			mi->card_number = i;
1412 			/*
1413 			 * Currently, FreeBSD assumes 1:1 relationship between
1414 			 * a pcm and mixer devices, so this is hardcoded to 0.
1415 			 */
1416 			mi->port_number = 0;
1417 
1418 			/**
1419 			 * @todo Fill in @sa oss_mixerinfo::mixerhandle.
1420 			 * @note From 4Front:  "mixerhandle is an arbitrary
1421 			 *       string that identifies the mixer better than
1422 			 *       the device number (mixerinfo.dev).  Device
1423 			 *       numbers may change depending on the order the
1424 			 *       drivers are loaded. However the handle should
1425 			 *       remain the same provided that the sound card
1426 			 *       is not moved to another PCI slot."
1427 			 */
1428 
1429 			/**
1430 			 * @note
1431 			 * @sa oss_mixerinfo::magic is a reserved field.
1432 			 *
1433 			 * @par
1434 			 * From 4Front:  "magic is usually 0. However some
1435 			 * devices may have dedicated setup utilities and the
1436 			 * magic field may contain an unique driver specific
1437 			 * value (managed by [4Front])."
1438 			 */
1439 
1440 			mi->enabled = device_is_attached(m->dev) ? 1 : 0;
1441 			/**
1442 			 * The only flag for @sa oss_mixerinfo::caps is
1443 			 * currently MIXER_CAP_VIRTUAL, which I'm not sure we
1444 			 * really worry about.
1445 			 */
1446 			/**
1447 			 * Mixer extensions currently aren't supported, so
1448 			 * leave @sa oss_mixerinfo::nrext blank for now.
1449 			 */
1450 			/**
1451 			 * @todo Fill in @sa oss_mixerinfo::priority (requires
1452 			 *       touching drivers?)
1453 			 * @note The priority field is for mixer applets to
1454 			 * determine which mixer should be the default, with 0
1455 			 * being least preferred and 10 being most preferred.
1456 			 * From 4Front:  "OSS drivers like ICH use higher
1457 			 * values (10) because such chips are known to be used
1458 			 * only on motherboards.  Drivers for high end pro
1459 			 * devices use 0 because they will never be the
1460 			 * default mixer. Other devices use values 1 to 9
1461 			 * depending on the estimated probability of being the
1462 			 * default device.
1463 			 *
1464 			 * XXX Described by Hannu@4Front, but not found in
1465 			 *     soundcard.h.
1466 			strlcpy(mi->devnode, devtoname(d->mixer_dev),
1467 			sizeof(mi->devnode));
1468 			mi->legacy_device = i;
1469 			 */
1470 			mtx_unlock(m->lock);
1471 		} else
1472 			++nmix;
1473 
1474 		PCM_UNLOCK(d);
1475 
1476 		if (m != NULL)
1477 			return (0);
1478 	}
1479 
1480 	return (EINVAL);
1481 }
1482 
1483 /*
1484  * Allow the sound driver to use the mixer lock to protect its mixer
1485  * data:
1486  */
1487 struct mtx *
1488 mixer_get_lock(struct snd_mixer *m)
1489 {
1490 	if (m->lock == NULL) {
1491 		return (&Giant);
1492 	}
1493 	return (m->lock);
1494 }
1495