 @@ -1,2419 +1,2417 @@
-/*	$NetBSD: audio.c,v 1.91.2.3 2021/03/21 21:09:09 thorpej Exp $	*/
+/*	$NetBSD: audio.c,v 1.91.2.4 2021/03/28 19:55:37 thorpej Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1991-1993 Regents of the University of California.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the Computer Systems
  *	Engineering Group at Lawrence Berkeley Laboratory.
  * 4. Neither the name of the University nor of the Laboratory may be used
  *    to endorse or promote products derived from this software without
  *    specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Locking: there are three locks per device.
+ *
  * - sc_lock, provided by the underlying driver.  This is an adaptive lock,
  *   returned in the second parameter to hw_if->get_locks().  It is known
  *   as the "thread lock".
+ *
  *   It serializes access to state in all places except the
  *   driver's interrupt service routine.  This lock is taken from process
  *   context (example: access to /dev/audio).  It is also taken from soft
  *   interrupt handlers in this module, primarily to serialize delivery of
  *   wakeups.  This lock may be used/provided by modules external to the
  *   audio subsystem, so take care not to introduce a lock order problem.
  *   LONG TERM SLEEPS MUST NOT OCCUR WITH THIS LOCK HELD.
+ *
  * - sc_intr_lock, provided by the underlying driver.  This may be either a
  *   spinlock (at IPL_SCHED or IPL_VM) or an adaptive lock (IPL_NONE or
  *   IPL_SOFT*), returned in the first parameter to hw_if->get_locks().  It
  *   is known as the "interrupt lock".
+ *
  *   It provides atomic access to the device's hardware state, and to audio
  *   channel data that may be accessed by the hardware driver's ISR.
  *   In all places outside the ISR, sc_lock must be held before taking
  *   sc_intr_lock.  This is to ensure that groups of hardware operations are
  *   made atomically.  SLEEPS CANNOT OCCUR WITH THIS LOCK HELD.
+ *
  * - sc_exlock, private to this module.  This is a variable protected by
  *   sc_lock.  It is known as the "critical section".
  *   Some operations release sc_lock in order to allocate memory, to wait
  *   for in-flight I/O to complete, to copy to/from user context, etc.
  *   sc_exlock provides a critical section even under the circumstance.
  *   "+" in following list indicates the interfaces which necessary to be
  *   protected by sc_exlock.
+ *
  * List of hardware interface methods, and which locks are held when each
  * is called by this module:
+ *
  *	METHOD			INTR	THREAD  NOTES
  *	----------------------- ------- -------	-------------------------
  *	open 			x	x +
  *	close 			x	x +
  *	query_format		-	x
  *	set_format		-	x
  *	round_blocksize		-	x
  *	commit_settings		-	x
  *	init_output 		x	x
  *	init_input 		x	x
  *	start_output 		x	x +
  *	start_input 		x	x +
  *	halt_output 		x	x +
  *	halt_input 		x	x +
  *	speaker_ctl 		x	x
  *	getdev 			-	x
  *	set_port 		-	x +
  *	get_port 		-	x +
  *	query_devinfo 		-	x
  *	allocm 			-	- +
  *	freem 			-	- +
  *	round_buffersize 	-	x
  *	get_props 		-	-	Called at attach time
  *	trigger_output 		x	x +
  *	trigger_input 		x	x +
  *	dev_ioctl 		-	x
  *	get_locks 		-	-	Called at attach time
+ *
  * In addition, there is an additional lock.
+ *
  * - track->lock.  This is an atomic variable and is similar to the
  *   "interrupt lock".  This is one for each track.  If any thread context
  *   (and software interrupt context) and hardware interrupt context who
  *   want to access some variables on this track, they must acquire this
  *   lock before.  It protects track's consistency between hardware
  *   interrupt context and others.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.91.2.3 2021/03/21 21:09:09 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.91.2.4 2021/03/28 19:55:37 thorpej Exp $");
 #ifdef _KERNEL_OPT
 #include "audio.h"
 #include "midi.h"
 #endif
 #if NAUDIO > 0
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/audioio.h>
 #include <sys/conf.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/fcntl.h>
 #include <sys/file.h>
 #include <sys/filedesc.h>
 #include <sys/intr.h>
 #include <sys/ioctl.h>
 #include <sys/kauth.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/malloc.h>
 #include <sys/mman.h>
 #include <sys/module.h>
 #include <sys/poll.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/select.h>
 #include <sys/signalvar.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <sys/syslog.h>
 #include <sys/vnode.h>
 #include <dev/audio/audio_if.h>
 #include <dev/audio/audiovar.h>
 #include <dev/audio/audiodef.h>
 #include <dev/audio/linear.h>
 #include <dev/audio/mulaw.h>
 #include <machine/endian.h>
 #include <uvm/uvm_extern.h>
 #include "ioconf.h"
 /*
  * 0: No debug logs
  * 1: action changes like open/close/set_format...
  * 2: + normal operations like read/write/ioctl...
  * 3: + TRACEs except interrupt
  * 4: + TRACEs including interrupt
  */
 //#define AUDIO_DEBUG 1
 #if defined(AUDIO_DEBUG)
 int audiodebug = AUDIO_DEBUG;
 static void audio_vtrace(struct audio_softc *sc, const char *, const char *,
 	const char *, va_list);
 static void audio_trace(struct audio_softc *sc, const char *, const char *, ...)
 	__printflike(3, 4);
 static void audio_tracet(const char *, audio_track_t *, const char *, ...)
 	__printflike(3, 4);
 static void audio_tracef(const char *, audio_file_t *, const char *, ...)
 	__printflike(3, 4);
 /* XXX sloppy memory logger */
 static void audio_mlog_init(void);
 static void audio_mlog_free(void);
 static void audio_mlog_softintr(void *);
 extern void audio_mlog_flush(void);
 extern void audio_mlog_printf(const char *, ...);
 static int mlog_refs;		/* reference counter */
 static char *mlog_buf[2];	/* double buffer */
 static int mlog_buflen;		/* buffer length */
 static int mlog_used;		/* used length */
 static int mlog_full;		/* number of dropped lines by buffer full */
 static int mlog_drop;		/* number of dropped lines by busy */
 static volatile uint32_t mlog_inuse;	/* in-use */
 static int mlog_wpage;		/* active page */
 static void *mlog_sih;		/* softint handle */
 static void
 audio_mlog_init(void)
+{
 	mlog_refs++;
 	if (mlog_refs > 1)
 		return;
 	mlog_buflen = 4096;
 	mlog_buf[0] = kmem_zalloc(mlog_buflen, KM_SLEEP);
 	mlog_buf[1] = kmem_zalloc(mlog_buflen, KM_SLEEP);
 	mlog_used = 0;
 	mlog_full = 0;
 	mlog_drop = 0;
 	mlog_inuse = 0;
 	mlog_wpage = 0;
 	mlog_sih = softint_establish(SOFTINT_SERIAL, audio_mlog_softintr, NULL);
 	if (mlog_sih == NULL)
 		printf("%s: softint_establish failed\n", __func__);
+}
 static void
 audio_mlog_free(void)
+{
 	mlog_refs--;
 	if (mlog_refs > 0)
 		return;
 	audio_mlog_flush();
 	if (mlog_sih)
 		softint_disestablish(mlog_sih);
 	kmem_free(mlog_buf[0], mlog_buflen);
 	kmem_free(mlog_buf[1], mlog_buflen);
+}
 /*
  * Flush memory buffer.
  * It must not be called from hardware interrupt context.
  */
 void
 audio_mlog_flush(void)
+{
 	if (mlog_refs == 0)
 		return;
 	/* Nothing to do if already in use ? */
 	if (atomic_swap_32(&mlog_inuse, 1) == 1)
 		return;
 	int rpage = mlog_wpage;
 	mlog_wpage ^= 1;
 	mlog_buf[mlog_wpage][0] = '\0';
 	mlog_used = 0;
 	atomic_swap_32(&mlog_inuse, 0);
 	if (mlog_buf[rpage][0] != '\0') {
 		printf("%s", mlog_buf[rpage]);
 		if (mlog_drop > 0)
 			printf("mlog_drop %d\n", mlog_drop);
 		if (mlog_full > 0)
 			printf("mlog_full %d\n", mlog_full);
+	}
 	mlog_full = 0;
 	mlog_drop = 0;
+}
 static void
 audio_mlog_softintr(void *cookie)
+{
 	audio_mlog_flush();
+}
 void
 audio_mlog_printf(const char *fmt, ...)
+{
 	int len;
 	va_list ap;
 	if (atomic_swap_32(&mlog_inuse, 1) == 1) {
 		/* already inuse */
 		mlog_drop++;
 		return;
+	}
 	va_start(ap, fmt);
 	len = vsnprintf(
 	    mlog_buf[mlog_wpage] + mlog_used,
 	    mlog_buflen - mlog_used,
 	    fmt, ap);
 	va_end(ap);
 	mlog_used += len;
 	if (mlog_buflen - mlog_used <= 1) {
 		mlog_full++;
+	}
 	atomic_swap_32(&mlog_inuse, 0);
 	if (mlog_sih)
 		softint_schedule(mlog_sih);
+}
 /* trace functions */
 static void
 audio_vtrace(struct audio_softc *sc, const char *funcname, const char *header,
 	const char *fmt, va_list ap)
+{
 	char buf[256];
 	int n;
 	n = 0;
 	buf[0] = '\0';
 	n += snprintf(buf + n, sizeof(buf) - n, "%s@%d %s",
 	    funcname, device_unit(sc->sc_dev), header);
 	n += vsnprintf(buf + n, sizeof(buf) - n, fmt, ap);
 	if (cpu_intr_p()) {
 		audio_mlog_printf("%s\n", buf);
 	} else {
 		audio_mlog_flush();
 		printf("%s\n", buf);
+	}
+}
 static void
 audio_trace(struct audio_softc *sc, const char *funcname, const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	audio_vtrace(sc, funcname, "", fmt, ap);
 	va_end(ap);
+}
 static void
 audio_tracet(const char *funcname, audio_track_t *track, const char *fmt, ...)
+{
 	char hdr[16];
 	va_list ap;
 	snprintf(hdr, sizeof(hdr), "#%d ", track->id);
 	va_start(ap, fmt);
 	audio_vtrace(track->mixer->sc, funcname, hdr, fmt, ap);
 	va_end(ap);
+}
 static void
 audio_tracef(const char *funcname, audio_file_t *file, const char *fmt, ...)
+{
 	char hdr[32];
 	char phdr[16], rhdr[16];
 	va_list ap;
 	phdr[0] = '\0';
 	rhdr[0] = '\0';
 	if (file->ptrack)
 		snprintf(phdr, sizeof(phdr), "#%d", file->ptrack->id);
 	if (file->rtrack)
 		snprintf(rhdr, sizeof(rhdr), "#%d", file->rtrack->id);
 	snprintf(hdr, sizeof(hdr), "{%s,%s} ", phdr, rhdr);
 	va_start(ap, fmt);
 	audio_vtrace(file->sc, funcname, hdr, fmt, ap);
 	va_end(ap);
+}
 #define DPRINTF(n, fmt...)	do {	\
 	if (audiodebug >= (n)) {	\
 		audio_mlog_flush();	\
 		printf(fmt);		\
 	}				\
 } while (0)
 #define TRACE(n, fmt...)	do { \
 	if (audiodebug >= (n)) audio_trace(sc, __func__, fmt); \
 } while (0)
 #define TRACET(n, t, fmt...)	do { \
 	if (audiodebug >= (n)) audio_tracet(__func__, t, fmt); \
 } while (0)
 #define TRACEF(n, f, fmt...)	do { \
 	if (audiodebug >= (n)) audio_tracef(__func__, f, fmt); \
 } while (0)
 struct audio_track_debugbuf {
 	char usrbuf[32];
 	char codec[32];
 	char chvol[32];
 	char chmix[32];
 	char freq[32];
 	char outbuf[32];
 };
 static void
 audio_track_bufstat(audio_track_t *track, struct audio_track_debugbuf *buf)
+{
 	memset(buf, 0, sizeof(*buf));
 	snprintf(buf->outbuf, sizeof(buf->outbuf), " out=%d/%d/%d",
 	    track->outbuf.head, track->outbuf.used, track->outbuf.capacity);
 	if (track->freq.filter)
 		snprintf(buf->freq, sizeof(buf->freq), " f=%d/%d/%d",
 		    track->freq.srcbuf.head,
 		    track->freq.srcbuf.used,
 		    track->freq.srcbuf.capacity);
 	if (track->chmix.filter)
 		snprintf(buf->chmix, sizeof(buf->chmix), " m=%d",
 		    track->chmix.srcbuf.used);
 	if (track->chvol.filter)
 		snprintf(buf->chvol, sizeof(buf->chvol), " v=%d",
 		    track->chvol.srcbuf.used);
 	if (track->codec.filter)
 		snprintf(buf->codec, sizeof(buf->codec), " e=%d",
 		    track->codec.srcbuf.used);
 	snprintf(buf->usrbuf, sizeof(buf->usrbuf), " usr=%d/%d/H%d",
 	    track->usrbuf.head, track->usrbuf.used, track->usrbuf_usedhigh);
+}
 #else
 #define DPRINTF(n, fmt...)	do { } while (0)
 #define TRACE(n, fmt, ...)	do { } while (0)
 #define TRACET(n, t, fmt, ...)	do { } while (0)
 #define TRACEF(n, f, fmt, ...)	do { } while (0)
 #endif
 #define SPECIFIED(x)	((x) != ~0)
 #define SPECIFIED_CH(x)	((x) != (u_char)~0)
 /*
  * Default hardware blocksize in msec.
+ *
  * We use 10 msec for most modern platforms.  This period is good enough to
  * play audio and video synchronizely.
  * In contrast, for very old platforms, this is usually too short and too
  * severe.  Also such platforms usually can not play video confortably, so
  * it's not so important to make the blocksize shorter.  If the platform
  * defines its own value as __AUDIO_BLK_MS in its <machine/param.h>, it
  * uses this instead.
+ *
  * In either case, you can overwrite AUDIO_BLK_MS by your kernel
  * configuration file if you wish.
  */
 #if !defined(AUDIO_BLK_MS)
 # if defined(__AUDIO_BLK_MS)
 #  define AUDIO_BLK_MS __AUDIO_BLK_MS
 # else
 #  define AUDIO_BLK_MS (10)
 # endif
 #endif
 /* Device timeout in msec */
 #define AUDIO_TIMEOUT	(3000)
 /* #define AUDIO_PM_IDLE */
 #ifdef AUDIO_PM_IDLE
 int audio_idle_timeout = 30;
 #endif
 /* Number of elements of async mixer's pid */
 #define AM_CAPACITY	(4)
 struct portname {
 	const char *name;
 	int mask;
 };
 static int audiomatch(device_t, cfdata_t, void *);
 static void audioattach(device_t, device_t, void *);
 static int audiodetach(device_t, int);
 static int audioactivate(device_t, enum devact);
 static void audiochilddet(device_t, device_t);
 static int audiorescan(device_t, const char *, const int *);
 static int audio_modcmd(modcmd_t, void *);
 #ifdef AUDIO_PM_IDLE
 static void audio_idle(void *);
 static void audio_activity(device_t, devactive_t);
 #endif
 static bool audio_suspend(device_t dv, const pmf_qual_t *);
 static bool audio_resume(device_t dv, const pmf_qual_t *);
 static void audio_volume_down(device_t);
 static void audio_volume_up(device_t);
 static void audio_volume_toggle(device_t);
 static void audio_mixer_capture(struct audio_softc *);
 static void audio_mixer_restore(struct audio_softc *);
 static void audio_softintr_rd(void *);
 static void audio_softintr_wr(void *);
 static void audio_printf(struct audio_softc *, const char *, ...)
 	__printflike(2, 3);
 static int audio_exlock_mutex_enter(struct audio_softc *);
 static void audio_exlock_mutex_exit(struct audio_softc *);
 static int audio_exlock_enter(struct audio_softc *);
 static void audio_exlock_exit(struct audio_softc *);
 static void audio_sc_acquire_foropen(struct audio_softc *, struct psref *);
 static struct audio_softc *audio_sc_acquire_fromfile(audio_file_t *,
 	struct psref *);
 static void audio_sc_release(struct audio_softc *, struct psref *);
 static int audio_track_waitio(struct audio_softc *, audio_track_t *);
 static int audioclose(struct file *);
 static int audioread(struct file *, off_t *, struct uio *, kauth_cred_t, int);
 static int audiowrite(struct file *, off_t *, struct uio *, kauth_cred_t, int);
 static int audioioctl(struct file *, u_long, void *);
 static int audiopoll(struct file *, int);
 static int audiokqfilter(struct file *, struct knote *);
 static int audiommap(struct file *, off_t *, size_t, int, int *, int *,
 	struct uvm_object **, int *);
 static int audiostat(struct file *, struct stat *);
 static void filt_audiowrite_detach(struct knote *);
 static int  filt_audiowrite_event(struct knote *, long);
 static void filt_audioread_detach(struct knote *);
 static int  filt_audioread_event(struct knote *, long);
 static int audio_open(dev_t, struct audio_softc *, int, int, struct lwp *,
 	audio_file_t **);
 static int audio_close(struct audio_softc *, audio_file_t *);
 static int audio_unlink(struct audio_softc *, audio_file_t *);
 static int audio_read(struct audio_softc *, struct uio *, int, audio_file_t *);
 static int audio_write(struct audio_softc *, struct uio *, int, audio_file_t *);
 static void audio_file_clear(struct audio_softc *, audio_file_t *);
 static int audio_ioctl(dev_t, struct audio_softc *, u_long, void *, int,
 	struct lwp *, audio_file_t *);
 static int audio_poll(struct audio_softc *, int, struct lwp *, audio_file_t *);
 static int audio_kqfilter(struct audio_softc *, audio_file_t *, struct knote *);
 static int audio_mmap(struct audio_softc *, off_t *, size_t, int, int *, int *,
 	struct uvm_object **, int *, audio_file_t *);
 static int audioctl_open(dev_t, struct audio_softc *, int, int, struct lwp *);
 static void audio_pintr(void *);
 static void audio_rintr(void *);
 static int audio_query_devinfo(struct audio_softc *, mixer_devinfo_t *);
 static __inline int audio_track_readablebytes(const audio_track_t *);
 static int audio_file_setinfo(struct audio_softc *, audio_file_t *,
 	const struct audio_info *);
 static int audio_track_setinfo_check(audio_track_t *,
 	audio_format2_t *, const struct audio_prinfo *);
 static void audio_track_setinfo_water(audio_track_t *,
 	const struct audio_info *);
 static int audio_hw_setinfo(struct audio_softc *, const struct audio_info *,
 	struct audio_info *);
 static int audio_hw_set_format(struct audio_softc *, int,
 	const audio_format2_t *, const audio_format2_t *,
 	audio_filter_reg_t *, audio_filter_reg_t *);
 static int audiogetinfo(struct audio_softc *, struct audio_info *, int,
 	audio_file_t *);
 static bool audio_can_playback(struct audio_softc *);
 static bool audio_can_capture(struct audio_softc *);
 static int audio_check_params(audio_format2_t *);
 static int audio_mixers_init(struct audio_softc *sc, int,
 	const audio_format2_t *, const audio_format2_t *,
 	const audio_filter_reg_t *, const audio_filter_reg_t *);
 static int audio_select_freq(const struct audio_format *);
 static int audio_hw_probe(struct audio_softc *, audio_format2_t *, int);
 static int audio_hw_validate_format(struct audio_softc *, int,
 	const audio_format2_t *);
 static int audio_mixers_set_format(struct audio_softc *,
 	const struct audio_info *);
 static void audio_mixers_get_format(struct audio_softc *, struct audio_info *);
 static int audio_sysctl_blk_ms(SYSCTLFN_PROTO);
 static int audio_sysctl_multiuser(SYSCTLFN_PROTO);
 #if defined(AUDIO_DEBUG)
 static int audio_sysctl_debug(SYSCTLFN_PROTO);
 static void audio_format2_tostr(char *, size_t, const audio_format2_t *);
 static void audio_print_format2(const char *, const audio_format2_t *) __unused;
 #endif
 static void *audio_realloc(void *, size_t);
 static int audio_realloc_usrbuf(audio_track_t *, int);
 static void audio_free_usrbuf(audio_track_t *);
 static audio_track_t *audio_track_create(struct audio_softc *,
 	audio_trackmixer_t *);
 static void audio_track_destroy(audio_track_t *);
 static audio_filter_t audio_track_get_codec(audio_track_t *,
 	const audio_format2_t *, const audio_format2_t *);
 static int audio_track_set_format(audio_track_t *, audio_format2_t *);
 static void audio_track_play(audio_track_t *);
 static int audio_track_drain(struct audio_softc *, audio_track_t *);
 static void audio_track_record(audio_track_t *);
 static void audio_track_clear(struct audio_softc *, audio_track_t *);
 static int audio_mixer_init(struct audio_softc *, int,
 	const audio_format2_t *, const audio_filter_reg_t *);
 static void audio_mixer_destroy(struct audio_softc *, audio_trackmixer_t *);
 static void audio_pmixer_start(struct audio_softc *, bool);
 static void audio_pmixer_process(struct audio_softc *);
 static void audio_pmixer_agc(audio_trackmixer_t *, int);
 static int  audio_pmixer_mix_track(audio_trackmixer_t *, audio_track_t *, int);
 static void audio_pmixer_output(struct audio_softc *);
 static int  audio_pmixer_halt(struct audio_softc *);
 static void audio_rmixer_start(struct audio_softc *);
 static void audio_rmixer_process(struct audio_softc *);
 static void audio_rmixer_input(struct audio_softc *);
 static int  audio_rmixer_halt(struct audio_softc *);
 static void mixer_init(struct audio_softc *);
 static int mixer_open(dev_t, struct audio_softc *, int, int, struct lwp *);
 static int mixer_close(struct audio_softc *, audio_file_t *);
 static int mixer_ioctl(struct audio_softc *, u_long, void *, int, struct lwp *);
 static void mixer_async_add(struct audio_softc *, pid_t);
 static void mixer_async_remove(struct audio_softc *, pid_t);
 static void mixer_signal(struct audio_softc *);
 static int au_portof(struct audio_softc *, char *, int);
 static void au_setup_ports(struct audio_softc *, struct au_mixer_ports *,
 	mixer_devinfo_t *, const struct portname *);
 static int au_set_lr_value(struct audio_softc *, mixer_ctrl_t *, int, int);
 static int au_get_lr_value(struct audio_softc *, mixer_ctrl_t *, int *, int *);
 static int au_set_gain(struct audio_softc *, struct au_mixer_ports *, int, int);
 static void au_get_gain(struct audio_softc *, struct au_mixer_ports *,
 	u_int *, u_char *);
 static int au_set_port(struct audio_softc *, struct au_mixer_ports *, u_int);
 static int au_get_port(struct audio_softc *, struct au_mixer_ports *);
 static int au_set_monitor_gain(struct audio_softc *, int);
 static int au_get_monitor_gain(struct audio_softc *);
 static int audio_get_port(struct audio_softc *, mixer_ctrl_t *);
 static int audio_set_port(struct audio_softc *, mixer_ctrl_t *);
 static __inline struct audio_params
 format2_to_params(const audio_format2_t *f2)
+{
 	audio_params_t p;
 	/* validbits/precision <-> precision/stride */
 	p.sample_rate = f2->sample_rate;
 	p.channels    = f2->channels;
 	p.encoding    = f2->encoding;
 	p.validbits   = f2->precision;
 	p.precision   = f2->stride;
 	return p;
+}
 static __inline audio_format2_t
 params_to_format2(const struct audio_params *p)
+{
 	audio_format2_t f2;
 	/* precision/stride <-> validbits/precision */
 	f2.sample_rate = p->sample_rate;
 	f2.channels    = p->channels;
 	f2.encoding    = p->encoding;
 	f2.precision   = p->validbits;
 	f2.stride      = p->precision;
 	return f2;
+}
 /* Return true if this track is a playback track. */
 static __inline bool
 audio_track_is_playback(const audio_track_t *track)
+{
 	return ((track->mode & AUMODE_PLAY) != 0);
+}
 /* Return true if this track is a recording track. */
 static __inline bool
 audio_track_is_record(const audio_track_t *track)
+{
 	return ((track->mode & AUMODE_RECORD) != 0);
+}
 #if 0 /* XXX Not used yet */
 /*
  * Convert 0..255 volume used in userland to internal presentation 0..256.
  */
 static __inline u_int
 audio_volume_to_inner(u_int v)
+{
 	return v < 127 ? v : v + 1;
+}
 /*
  * Convert 0..256 internal presentation to 0..255 volume used in userland.
  */
 static __inline u_int
 audio_volume_to_outer(u_int v)
+{
 	return v < 127 ? v : v - 1;
+}
 #endif /* 0 */
 static dev_type_open(audioopen);
 /* XXXMRG use more dev_type_xxx */
 const struct cdevsw audio_cdevsw = {
 	.d_open = audioopen,
 	.d_close = noclose,
 	.d_read = noread,
 	.d_write = nowrite,
 	.d_ioctl = noioctl,
 	.d_stop = nostop,
 	.d_tty = notty,
 	.d_poll = nopoll,
 	.d_mmap = nommap,
 	.d_kqfilter = nokqfilter,
 	.d_discard = nodiscard,
 	.d_flag = D_OTHER | D_MPSAFE
 };
 const struct fileops audio_fileops = {
 	.fo_name = "audio",
 	.fo_read = audioread,
 	.fo_write = audiowrite,
 	.fo_ioctl = audioioctl,
 	.fo_fcntl = fnullop_fcntl,
 	.fo_stat = audiostat,
 	.fo_poll = audiopoll,
 	.fo_close = audioclose,
 	.fo_mmap = audiommap,
 	.fo_kqfilter = audiokqfilter,
 	.fo_restart = fnullop_restart
 };
 /* The default audio mode: 8 kHz mono mu-law */
 static const struct audio_params audio_default = {
 	.sample_rate = 8000,
 	.encoding = AUDIO_ENCODING_ULAW,
 	.precision = 8,
 	.validbits = 8,
 	.channels = 1,
 };
 static const char *encoding_names[] = {
 	"none",
 	AudioEmulaw,
 	AudioEalaw,
 	"pcm16",
 	"pcm8",
 	AudioEadpcm,
 	AudioEslinear_le,
 	AudioEslinear_be,
 	AudioEulinear_le,
 	AudioEulinear_be,
 	AudioEslinear,
 	AudioEulinear,
 	AudioEmpeg_l1_stream,
 	AudioEmpeg_l1_packets,
 	AudioEmpeg_l1_system,
 	AudioEmpeg_l2_stream,
 	AudioEmpeg_l2_packets,
 	AudioEmpeg_l2_system,
 	AudioEac3,
 };
 /*
  * Returns encoding name corresponding to AUDIO_ENCODING_*.
  * Note that it may return a local buffer because it is mainly for debugging.
  */
 const char *
 audio_encoding_name(int encoding)
+{
 	static char buf[16];
 	if (0 <= encoding && encoding < __arraycount(encoding_names)) {
 		return encoding_names[encoding];
 	} else {
 		snprintf(buf, sizeof(buf), "enc=%d", encoding);
 		return buf;
+	}
+}
 /*
  * Supported encodings used by AUDIO_GETENC.
  * index and flags are set by code.
  * XXX is there any needs for SLINEAR_OE:>=16/ULINEAR_OE:>=16 ?
  */
 static const audio_encoding_t audio_encodings[] = {
 	{ 0, AudioEmulaw,	AUDIO_ENCODING_ULAW,		8,  0 },
 	{ 0, AudioEalaw,	AUDIO_ENCODING_ALAW,		8,  0 },
 	{ 0, AudioEslinear,	AUDIO_ENCODING_SLINEAR,		8,  0 },
 	{ 0, AudioEulinear,	AUDIO_ENCODING_ULINEAR,		8,  0 },
 	{ 0, AudioEslinear_le,	AUDIO_ENCODING_SLINEAR_LE,	16, 0 },
 	{ 0, AudioEulinear_le,	AUDIO_ENCODING_ULINEAR_LE,	16, 0 },
 	{ 0, AudioEslinear_be,	AUDIO_ENCODING_SLINEAR_BE,	16, 0 },
 	{ 0, AudioEulinear_be,	AUDIO_ENCODING_ULINEAR_BE,	16, 0 },
 #if defined(AUDIO_SUPPORT_LINEAR24)
 	{ 0, AudioEslinear_le,	AUDIO_ENCODING_SLINEAR_LE,	24, 0 },
 	{ 0, AudioEulinear_le,	AUDIO_ENCODING_ULINEAR_LE,	24, 0 },
 	{ 0, AudioEslinear_be,	AUDIO_ENCODING_SLINEAR_BE,	24, 0 },
 	{ 0, AudioEulinear_be,	AUDIO_ENCODING_ULINEAR_BE,	24, 0 },
 #endif
 	{ 0, AudioEslinear_le,	AUDIO_ENCODING_SLINEAR_LE,	32, 0 },
 	{ 0, AudioEulinear_le,	AUDIO_ENCODING_ULINEAR_LE,	32, 0 },
 	{ 0, AudioEslinear_be,	AUDIO_ENCODING_SLINEAR_BE,	32, 0 },
 	{ 0, AudioEulinear_be,	AUDIO_ENCODING_ULINEAR_BE,	32, 0 },
 };
 static const struct portname itable[] = {
 	{ AudioNmicrophone,	AUDIO_MICROPHONE },
 	{ AudioNline,		AUDIO_LINE_IN },
 	{ AudioNcd,		AUDIO_CD },
 	{ 0, 0 }
 };
 static const struct portname otable[] = {
 	{ AudioNspeaker,	AUDIO_SPEAKER },
 	{ AudioNheadphone,	AUDIO_HEADPHONE },
 	{ AudioNline,		AUDIO_LINE_OUT },
 	{ 0, 0 }
 };
 static struct psref_class *audio_psref_class __read_mostly;
 CFATTACH_DECL3_NEW(audio, sizeof(struct audio_softc),
     audiomatch, audioattach, audiodetach, audioactivate, audiorescan,
     audiochilddet, DVF_DETACH_SHUTDOWN);
 static int
 audiomatch(device_t parent, cfdata_t match, void *aux)
+{
 	struct audio_attach_args *sa;
 	sa = aux;
 	DPRINTF(1, "%s: type=%d sa=%p hw=%p\n",
 	     __func__, sa->type, sa, sa->hwif);
 	return (sa->type == AUDIODEV_TYPE_AUDIO) ? 1 : 0;
+}
 static void
 audioattach(device_t parent, device_t self, void *aux)
+{
 	struct audio_softc *sc;
 	struct audio_attach_args *sa;
 	const struct audio_hw_if *hw_if;
 	audio_format2_t phwfmt;
 	audio_format2_t rhwfmt;
 	audio_filter_reg_t pfil;
 	audio_filter_reg_t rfil;
 	const struct sysctlnode *node;
 	void *hdlp;
 	bool has_playback;
 	bool has_capture;
 	bool has_indep;
 	bool has_fulldup;
 	int mode;
 	int error;
 	sc = device_private(self);
 	sc->sc_dev = self;
 	sa = (struct audio_attach_args *)aux;
 	hw_if = sa->hwif;
 	hdlp = sa->hdl;
 	if (hw_if == NULL) {
 		panic("audioattach: missing hw_if method");
+	}
 	if (hw_if->get_locks == NULL || hw_if->get_props == NULL) {
 		aprint_error(": missing mandatory method\n");
 		return;
+	}
 	hw_if->get_locks(hdlp, &sc->sc_intr_lock, &sc->sc_lock);
 	sc->sc_props = hw_if->get_props(hdlp);
 	has_playback = (sc->sc_props & AUDIO_PROP_PLAYBACK);
 	has_capture  = (sc->sc_props & AUDIO_PROP_CAPTURE);
 	has_indep    = (sc->sc_props & AUDIO_PROP_INDEPENDENT);
 	has_fulldup  = (sc->sc_props & AUDIO_PROP_FULLDUPLEX);
 #ifdef DIAGNOSTIC
 	if (hw_if->query_format == NULL ||
 	    hw_if->set_format == NULL ||
 	    hw_if->getdev == NULL ||
 	    hw_if->set_port == NULL ||
 	    hw_if->get_port == NULL ||
 	    hw_if->query_devinfo == NULL) {
 		aprint_error(": missing mandatory method\n");
 		return;
+	}
 	if (has_playback) {
 		if ((hw_if->start_output == NULL &&
 		     hw_if->trigger_output == NULL) ||
 		    hw_if->halt_output == NULL) {
 			aprint_error(": missing playback method\n");
+		}
+	}
 	if (has_capture) {
 		if ((hw_if->start_input == NULL &&
 		     hw_if->trigger_input == NULL) ||
 		    hw_if->halt_input == NULL) {
 			aprint_error(": missing capture method\n");
+		}
+	}
 #endif
 	sc->hw_if = hw_if;
 	sc->hw_hdl = hdlp;
 	sc->hw_dev = parent;
 	sc->sc_exlock = 1;
 	sc->sc_blk_ms = AUDIO_BLK_MS;
 	SLIST_INIT(&sc->sc_files);
 	cv_init(&sc->sc_exlockcv, "audiolk");
 	sc->sc_am_capacity = 0;
 	sc->sc_am_used = 0;
 	sc->sc_am = NULL;
 	/* MMAP is now supported by upper layer.  */
 	sc->sc_props |= AUDIO_PROP_MMAP;
 	KASSERT(has_playback || has_capture);
 	/* Unidirectional device must have neither FULLDUP nor INDEPENDENT. */
 	if (!has_playback || !has_capture) {
 		KASSERT(!has_indep);
 		KASSERT(!has_fulldup);
+	}
 	mode = 0;
 	if (has_playback) {
 		aprint_normal(": playback");
 		mode |= AUMODE_PLAY;
+	}
 	if (has_capture) {
 		aprint_normal("%c capture", has_playback ? ',' : ':');
 		mode |= AUMODE_RECORD;
+	}
 	if (has_playback && has_capture) {
 		if (has_fulldup)
 			aprint_normal(", full duplex");
 		else
 			aprint_normal(", half duplex");
 		if (has_indep)
 			aprint_normal(", independent");
+	}
 	aprint_naive("\n");
 	aprint_normal("\n");
 	/* probe hw params */
 	memset(&phwfmt, 0, sizeof(phwfmt));
 	memset(&rhwfmt, 0, sizeof(rhwfmt));
 	memset(&pfil, 0, sizeof(pfil));
 	memset(&rfil, 0, sizeof(rfil));
 	if (has_indep) {
 		int perror, rerror;
 		/* On independent devices, probe separately. */
 		perror = audio_hw_probe(sc, &phwfmt, AUMODE_PLAY);
 		rerror = audio_hw_probe(sc, &rhwfmt, AUMODE_RECORD);
 		if (perror && rerror) {
 			aprint_error_dev(self,
 			    "audio_hw_probe failed: perror=%d, rerror=%d\n",
 			    perror, rerror);
 			goto bad;
+		}
 		if (perror) {
 			mode &= ~AUMODE_PLAY;
 			aprint_error_dev(self, "audio_hw_probe failed: "
 			    "errno=%d, playback disabled\n", perror);
+		}
 		if (rerror) {
 			mode &= ~AUMODE_RECORD;
 			aprint_error_dev(self, "audio_hw_probe failed: "
 			    "errno=%d, capture disabled\n", rerror);
+		}
 	} else {
 		/*
 		 * On non independent devices or uni-directional devices,
 		 * probe once (simultaneously).
 		 */
 		audio_format2_t *fmt = has_playback ? &phwfmt : &rhwfmt;
 		error = audio_hw_probe(sc, fmt, mode);
 		if (error) {
 			aprint_error_dev(self,
 			    "audio_hw_probe failed: errno=%d\n", error);
 			goto bad;
+		}
 		if (has_playback && has_capture)
 			rhwfmt = phwfmt;
+	}
 	/* Init hardware. */
 	/* hw_probe() also validates [pr]hwfmt.  */
 	error = audio_hw_set_format(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
 	if (error) {
 		aprint_error_dev(self,
 		    "audio_hw_set_format failed: errno=%d\n", error);
 		goto bad;
+	}
 	/*
 	 * Init track mixers.  If at least one direction is available on
 	 * attach time, we assume a success.
 	 */
 	error = audio_mixers_init(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
 	if (sc->sc_pmixer == NULL && sc->sc_rmixer == NULL) {
 		aprint_error_dev(self,
 		    "audio_mixers_init failed: errno=%d\n", error);
 		goto bad;
+	}
 	sc->sc_psz = pserialize_create();
 	psref_target_init(&sc->sc_psref, audio_psref_class);
 	selinit(&sc->sc_wsel);
 	selinit(&sc->sc_rsel);
 	/* Initial parameter of /dev/sound */
 	sc->sc_sound_pparams = params_to_format2(&audio_default);
 	sc->sc_sound_rparams = params_to_format2(&audio_default);
 	sc->sc_sound_ppause = false;
 	sc->sc_sound_rpause = false;
 	/* XXX TODO: consider about sc_ai */
 	mixer_init(sc);
 	TRACE(2, "inputs ports=0x%x, input master=%d, "
 	    "output ports=0x%x, output master=%d",
 	    sc->sc_inports.allports, sc->sc_inports.master,
 	    sc->sc_outports.allports, sc->sc_outports.master);
 	sysctl_createv(&sc->sc_log, 0, NULL, &node,
 ,
 	    CTLTYPE_NODE, device_xname(sc->sc_dev),
 	    SYSCTL_DESCR("audio test"),
 	    NULL, 0,
 	    NULL, 0,
 	    CTL_HW,
 	    CTL_CREATE, CTL_EOL);
 	if (node != NULL) {
 		sysctl_createv(&sc->sc_log, 0, NULL, NULL,
 		    CTLFLAG_READWRITE,
 		    CTLTYPE_INT, "blk_ms",
 		    SYSCTL_DESCR("blocksize in msec"),
 		    audio_sysctl_blk_ms, 0, (void *)sc, 0,
 		    CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL);
 		sysctl_createv(&sc->sc_log, 0, NULL, NULL,
 		    CTLFLAG_READWRITE,
 		    CTLTYPE_BOOL, "multiuser",
 		    SYSCTL_DESCR("allow multiple user access"),
 		    audio_sysctl_multiuser, 0, (void *)sc, 0,
 		    CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL);
 #if defined(AUDIO_DEBUG)
 		sysctl_createv(&sc->sc_log, 0, NULL, NULL,
 		    CTLFLAG_READWRITE,
 		    CTLTYPE_INT, "debug",
 		    SYSCTL_DESCR("debug level (0..4)"),
 		    audio_sysctl_debug, 0, (void *)sc, 0,
 		    CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL);
 #endif
+	}
 #ifdef AUDIO_PM_IDLE
 	callout_init(&sc->sc_idle_counter, 0);
 	callout_setfunc(&sc->sc_idle_counter, audio_idle, self);
 #endif
 	if (!pmf_device_register(self, audio_suspend, audio_resume))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 #ifdef AUDIO_PM_IDLE
 	if (!device_active_register(self, audio_activity))
 		aprint_error_dev(self, "couldn't register activity handler\n");
 #endif
 	if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_DOWN,
 	    audio_volume_down, true))
 		aprint_error_dev(self, "couldn't add volume down handler\n");
 	if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_UP,
 	    audio_volume_up, true))
 		aprint_error_dev(self, "couldn't add volume up handler\n");
 	if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_TOGGLE,
 	    audio_volume_toggle, true))
 		aprint_error_dev(self, "couldn't add volume toggle handler\n");
 #ifdef AUDIO_PM_IDLE
 	callout_schedule(&sc->sc_idle_counter, audio_idle_timeout * hz);
 #endif
 #if defined(AUDIO_DEBUG)
 	audio_mlog_init();
 #endif
-	audiorescan(self, "audio", NULL);
+	audiorescan(self, NULL, NULL);
 	sc->sc_exlock = 0;
 	return;
 bad:
 	/* Clearing hw_if means that device is attached but disabled. */
 	sc->hw_if = NULL;
 	sc->sc_exlock = 0;
 	aprint_error_dev(sc->sc_dev, "disabled\n");
 	return;
+}
 /*
  * Initialize hardware mixer.
  * This function is called from audioattach().
  */
 static void
 mixer_init(struct audio_softc *sc)
+{
 	mixer_devinfo_t mi;
 	int iclass, mclass, oclass, rclass;
 	int record_master_found, record_source_found;
 	iclass = mclass = oclass = rclass = -1;
 	sc->sc_inports.index = -1;
 	sc->sc_inports.master = -1;
 	sc->sc_inports.nports = 0;
 	sc->sc_inports.isenum = false;
 	sc->sc_inports.allports = 0;
 	sc->sc_inports.isdual = false;
 	sc->sc_inports.mixerout = -1;
 	sc->sc_inports.cur_port = -1;
 	sc->sc_outports.index = -1;
 	sc->sc_outports.master = -1;
 	sc->sc_outports.nports = 0;
 	sc->sc_outports.isenum = false;
 	sc->sc_outports.allports = 0;
 	sc->sc_outports.isdual = false;
 	sc->sc_outports.mixerout = -1;
 	sc->sc_outports.cur_port = -1;
 	sc->sc_monitor_port = -1;
 	/*
 	 * Read through the underlying driver's list, picking out the class
 	 * names from the mixer descriptions. We'll need them to decode the
 	 * mixer descriptions on the next pass through the loop.
 	 */
 	mutex_enter(sc->sc_lock);
 	for(mi.index = 0; ; mi.index++) {
 		if (audio_query_devinfo(sc, &mi) != 0)
 			break;
 		 /*
 		  * The type of AUDIO_MIXER_CLASS merely introduces a class.
 		  * All the other types describe an actual mixer.
 		  */
 		if (mi.type == AUDIO_MIXER_CLASS) {
 			if (strcmp(mi.label.name, AudioCinputs) == 0)
 				iclass = mi.mixer_class;
 			if (strcmp(mi.label.name, AudioCmonitor) == 0)
 				mclass = mi.mixer_class;
 			if (strcmp(mi.label.name, AudioCoutputs) == 0)
 				oclass = mi.mixer_class;
 			if (strcmp(mi.label.name, AudioCrecord) == 0)
 				rclass = mi.mixer_class;
+		}
+	}
 	mutex_exit(sc->sc_lock);
 	/* Allocate save area.  Ensure non-zero allocation. */
 	sc->sc_nmixer_states = mi.index;
 	sc->sc_mixer_state = kmem_zalloc(sizeof(mixer_ctrl_t) *
 	    (sc->sc_nmixer_states + 1), KM_SLEEP);
 	/*
 	 * This is where we assign each control in the "audio" model, to the
 	 * underlying "mixer" control.  We walk through the whole list once,
 	 * assigning likely candidates as we come across them.
 	 */
 	record_master_found = 0;
 	record_source_found = 0;
 	mutex_enter(sc->sc_lock);
 	for(mi.index = 0; ; mi.index++) {
 		if (audio_query_devinfo(sc, &mi) != 0)
 			break;
 		KASSERT(mi.index < sc->sc_nmixer_states);
 		if (mi.type == AUDIO_MIXER_CLASS)
 			continue;
 		if (mi.mixer_class == iclass) {
 			/*
 			 * AudioCinputs is only a fallback, when we don't
 			 * find what we're looking for in AudioCrecord, so
 			 * check the flags before accepting one of these.
 			 */
 			if (strcmp(mi.label.name, AudioNmaster) == 0
 			    && record_master_found == 0)
 				sc->sc_inports.master = mi.index;
 			if (strcmp(mi.label.name, AudioNsource) == 0
 			    && record_source_found == 0) {
 				if (mi.type == AUDIO_MIXER_ENUM) {
 				    int i;
 				    for(i = 0; i < mi.un.e.num_mem; i++)
 					if (strcmp(mi.un.e.member[i].label.name,
 						    AudioNmixerout) == 0)
 						sc->sc_inports.mixerout =
 						    mi.un.e.member[i].ord;
+				}
 				au_setup_ports(sc, &sc->sc_inports, &mi,
 				    itable);
+			}
 			if (strcmp(mi.label.name, AudioNdac) == 0 &&
 			    sc->sc_outports.master == -1)
 				sc->sc_outports.master = mi.index;
 		} else if (mi.mixer_class == mclass) {
 			if (strcmp(mi.label.name, AudioNmonitor) == 0)
 				sc->sc_monitor_port = mi.index;
 		} else if (mi.mixer_class == oclass) {
 			if (strcmp(mi.label.name, AudioNmaster) == 0)
 				sc->sc_outports.master = mi.index;
 			if (strcmp(mi.label.name, AudioNselect) == 0)
 				au_setup_ports(sc, &sc->sc_outports, &mi,
 				    otable);
 		} else if (mi.mixer_class == rclass) {
 			/*
 			 * These are the preferred mixers for the audio record
 			 * controls, so set the flags here, but don't check.
 			 */
 			if (strcmp(mi.label.name, AudioNmaster) == 0) {
 				sc->sc_inports.master = mi.index;
 				record_master_found = 1;
+			}
 #if 1	/* Deprecated. Use AudioNmaster. */
 			if (strcmp(mi.label.name, AudioNrecord) == 0) {
 				sc->sc_inports.master = mi.index;
 				record_master_found = 1;
+			}
 			if (strcmp(mi.label.name, AudioNvolume) == 0) {
 				sc->sc_inports.master = mi.index;
 				record_master_found = 1;
+			}
 #endif
 			if (strcmp(mi.label.name, AudioNsource) == 0) {
 				if (mi.type == AUDIO_MIXER_ENUM) {
 				    int i;
 				    for(i = 0; i < mi.un.e.num_mem; i++)
 					if (strcmp(mi.un.e.member[i].label.name,
 						    AudioNmixerout) == 0)
 						sc->sc_inports.mixerout =
 						    mi.un.e.member[i].ord;
+				}
 				au_setup_ports(sc, &sc->sc_inports, &mi,
 				    itable);
 				record_source_found = 1;
+			}
+		}
+	}
 	mutex_exit(sc->sc_lock);
+}
 static int
 audioactivate(device_t self, enum devact act)
+{
 	struct audio_softc *sc = device_private(self);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		mutex_enter(sc->sc_lock);
 		sc->sc_dying = true;
 		cv_broadcast(&sc->sc_exlockcv);
 		mutex_exit(sc->sc_lock);
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 static int
 audiodetach(device_t self, int flags)
+{
 	struct audio_softc *sc;
 	struct audio_file *file;
 	int error;
 	sc = device_private(self);
 	TRACE(2, "flags=%d", flags);
 	/* device is not initialized */
 	if (sc->hw_if == NULL)
 		return 0;
 	/* Start draining existing accessors of the device. */
 	error = config_detach_children(self, flags);
 	if (error)
 		return error;
 	/*
 	 * This waits currently running sysctls to finish if exists.
 	 * After this, no more new sysctls will come.
 	 */
 	sysctl_teardown(&sc->sc_log);
 	mutex_enter(sc->sc_lock);
 	sc->sc_dying = true;
 	cv_broadcast(&sc->sc_exlockcv);
 	if (sc->sc_pmixer)
 		cv_broadcast(&sc->sc_pmixer->outcv);
 	if (sc->sc_rmixer)
 		cv_broadcast(&sc->sc_rmixer->outcv);
 	/* Prevent new users */
 	SLIST_FOREACH(file, &sc->sc_files, entry) {
 		atomic_store_relaxed(&file->dying, true);
+	}
 	/*
 	 * Wait for existing users to drain.
 	 * - pserialize_perform waits for all pserialize_read sections on
 	 *   all CPUs; after this, no more new psref_acquire can happen.
 	 * - psref_target_destroy waits for all extant acquired psrefs to
 	 *   be psref_released.
 	 */
 	pserialize_perform(sc->sc_psz);
 	mutex_exit(sc->sc_lock);
 	psref_target_destroy(&sc->sc_psref, audio_psref_class);
 	/*
 	 * We are now guaranteed that there are no calls to audio fileops
 	 * that hold sc, and any new calls with files that were for sc will
 	 * fail.  Thus, we now have exclusive access to the softc.
 	 */
 	sc->sc_exlock = 1;
 	/*
 	 * Clean up all open instances.
 	 * Here, we no longer need any locks to traverse sc_files.
 	 */
 	while ((file = SLIST_FIRST(&sc->sc_files)) != NULL) {
 		audio_unlink(sc, file);
+	}
 	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_DOWN,
 	    audio_volume_down, true);
 	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_UP,
 	    audio_volume_up, true);
 	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_TOGGLE,
 	    audio_volume_toggle, true);
 #ifdef AUDIO_PM_IDLE
 	callout_halt(&sc->sc_idle_counter, sc->sc_lock);
 	device_active_deregister(self, audio_activity);
 #endif
 	pmf_device_deregister(self);
 	/* Free resources */
 	if (sc->sc_pmixer) {
 		audio_mixer_destroy(sc, sc->sc_pmixer);
 		kmem_free(sc->sc_pmixer, sizeof(*sc->sc_pmixer));
+	}
 	if (sc->sc_rmixer) {
 		audio_mixer_destroy(sc, sc->sc_rmixer);
 		kmem_free(sc->sc_rmixer, sizeof(*sc->sc_rmixer));
+	}
 	if (sc->sc_am)
 		kern_free(sc->sc_am);
 	seldestroy(&sc->sc_wsel);
 	seldestroy(&sc->sc_rsel);
 #ifdef AUDIO_PM_IDLE
 	callout_destroy(&sc->sc_idle_counter);
 #endif
 	cv_destroy(&sc->sc_exlockcv);
 #if defined(AUDIO_DEBUG)
 	audio_mlog_free();
 #endif
 	return 0;
+}
 static void
 audiochilddet(device_t self, device_t child)
+{
 	/* we hold no child references, so do nothing */
+}
 static int
 audiosearch(device_t parent, cfdata_t cf, const int *locs, void *aux)
+{
 	if (config_match(parent, cf, aux))
 		config_attach_loc(parent, cf, locs, aux, NULL);
 	return 0;
+}
 static int
 audiorescan(device_t self, const char *ifattr, const int *locators)
+{
 	struct audio_softc *sc = device_private(self);
 	config_search(sc->sc_dev, NULL,
 	    CFARG_SUBMATCH, audiosearch,
 	    CFARG_IATTR, ifattr,
 	    CFARG_LOCATORS, locators,
 	    CFARG_EOL);
 	return 0;
+}
 /*
  * Called from hardware driver.  This is where the MI audio driver gets
  * probed/attached to the hardware driver.
  */
 device_t
 audio_attach_mi(const struct audio_hw_if *ahwp, void *hdlp, device_t dev)
+{
 	struct audio_attach_args arg;
 #ifdef DIAGNOSTIC
 	if (ahwp == NULL) {
 		aprint_error("audio_attach_mi: NULL\n");
 		return 0;
+	}
 #endif
 	arg.type = AUDIODEV_TYPE_AUDIO;
 	arg.hwif = ahwp;
 	arg.hdl = hdlp;
 	return config_found(dev, &arg, audioprint, CFARG_EOL);
+}
 /*
  * audio_printf() outputs fmt... with the audio device name and MD device
  * name prefixed.  If the message is considered to be related to the MD
  * driver, use this one instead of device_printf().
  */
 static void
 audio_printf(struct audio_softc *sc, const char *fmt, ...)
+{
 	va_list ap;
 	printf("%s(%s): ", device_xname(sc->sc_dev), device_xname(sc->hw_dev));
 	va_start(ap, fmt);
 	vprintf(fmt, ap);
 	va_end(ap);
+}
 /*
  * Enter critical section and also keep sc_lock.
  * If successful, returns 0 with sc_lock held.  Otherwise returns errno.
  * Must be called without sc_lock held.
  */
 static int
 audio_exlock_mutex_enter(struct audio_softc *sc)
+{
 	int error;
 	mutex_enter(sc->sc_lock);
 	if (sc->sc_dying) {
 		mutex_exit(sc->sc_lock);
 		return EIO;
+	}
 	while (__predict_false(sc->sc_exlock != 0)) {
 		error = cv_wait_sig(&sc->sc_exlockcv, sc->sc_lock);
 		if (sc->sc_dying)
 			error = EIO;
 		if (error) {
 			mutex_exit(sc->sc_lock);
 			return error;
+		}
+	}
 	/* Acquire */
 	sc->sc_exlock = 1;
 	return 0;
+}
 /*
  * Exit critical section and exit sc_lock.
  * Must be called with sc_lock held.
  */
 static void
 audio_exlock_mutex_exit(struct audio_softc *sc)
+{
 	KASSERT(mutex_owned(sc->sc_lock));
 	sc->sc_exlock = 0;
 	cv_broadcast(&sc->sc_exlockcv);
 	mutex_exit(sc->sc_lock);
+}
 /*
  * Enter critical section.
  * If successful, it returns 0.  Otherwise returns errno.
  * Must be called without sc_lock held.
  * This function returns without sc_lock held.
  */
 static int
 audio_exlock_enter(struct audio_softc *sc)
+{
 	int error;
 	error = audio_exlock_mutex_enter(sc);
 	if (error)
 		return error;
 	mutex_exit(sc->sc_lock);
 	return 0;
+}
 /*
  * Exit critical section.
  * Must be called without sc_lock held.
  */
 static void
 audio_exlock_exit(struct audio_softc *sc)
+{
 	mutex_enter(sc->sc_lock);
 	audio_exlock_mutex_exit(sc);
+}
 /*
  * Increment reference counter for this sc.
  * This is intended to be used for open.
  */
 void
 audio_sc_acquire_foropen(struct audio_softc *sc, struct psref *refp)
+{
 	int s;
 	/* Block audiodetach while we acquire a reference */
 	s = pserialize_read_enter();
 	/*
 	 * We don't examine sc_dying here.  However, all open methods
 	 * call audio_exlock_enter() right after this, so we can examine
 	 * sc_dying in it.
 	 */
 	/* Acquire a reference */
 	psref_acquire(refp, &sc->sc_psref, audio_psref_class);
 	/* Now sc won't go away until we drop the reference count */
 	pserialize_read_exit(s);
+}
 /*
  * Get sc from file, and increment reference counter for this sc.
  * This is intended to be used for methods other than open.
  * If successful, returns sc.  Otherwise returns NULL.
  */
 struct audio_softc *
 audio_sc_acquire_fromfile(audio_file_t *file, struct psref *refp)
+{
 	int s;
 	bool dying;
 	/* Block audiodetach while we acquire a reference */
 	s = pserialize_read_enter();
 	/* If close or audiodetach already ran, tough -- no more audio */
 	dying = atomic_load_relaxed(&file->dying);
 	if (dying) {
 		pserialize_read_exit(s);
 		return NULL;
+	}
 	/* Acquire a reference */
 	psref_acquire(refp, &file->sc->sc_psref, audio_psref_class);
 	/* Now sc won't go away until we drop the reference count */
 	pserialize_read_exit(s);
 	return file->sc;
+}
 /*
  * Decrement reference counter for this sc.
  */
 void
 audio_sc_release(struct audio_softc *sc, struct psref *refp)
+{
 	psref_release(refp, &sc->sc_psref, audio_psref_class);
+}
 /*
  * Wait for I/O to complete, releasing sc_lock.
  * Must be called with sc_lock held.
  */
 static int
 audio_track_waitio(struct audio_softc *sc, audio_track_t *track)
+{
 	int error;
 	KASSERT(track);
 	KASSERT(mutex_owned(sc->sc_lock));
 	/* Wait for pending I/O to complete. */
 	error = cv_timedwait_sig(&track->mixer->outcv, sc->sc_lock,
 	    mstohz(AUDIO_TIMEOUT));
 	if (sc->sc_suspending) {
 		/* If it's about to suspend, ignore timeout error. */
 		if (error == EWOULDBLOCK) {
 			TRACET(2, track, "timeout (suspending)");
 			return 0;
+		}
+	}
 	if (sc->sc_dying) {
 		error = EIO;
+	}
 	if (error) {
 		TRACET(2, track, "cv_timedwait_sig failed %d", error);
 		if (error == EWOULDBLOCK)
 			audio_printf(sc, "device timeout\n");
 	} else {
 		TRACET(3, track, "wakeup");
+	}
 	return error;
+}
 /*
  * Try to acquire track lock.
  * It doesn't block if the track lock is already aquired.
  * Returns true if the track lock was acquired, or false if the track
  * lock was already acquired.
  */
 static __inline bool
 audio_track_lock_tryenter(audio_track_t *track)
+{
 	return (atomic_cas_uint(&track->lock, 0, 1) == 0);
+}
 /*
  * Acquire track lock.
  */
 static __inline void
 audio_track_lock_enter(audio_track_t *track)
+{
 	/* Don't sleep here. */
 	while (audio_track_lock_tryenter(track) == false)
+		;
+}
 /*
  * Release track lock.
  */
 static __inline void
 audio_track_lock_exit(audio_track_t *track)
+{
 	atomic_swap_uint(&track->lock, 0);
+}
 static int
 audioopen(dev_t dev, int flags, int ifmt, struct lwp *l)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	int bound;
 	int error;
 	/* Find the device */
 	sc = device_lookup_private(&audio_cd, AUDIOUNIT(dev));
 	if (sc == NULL || sc->hw_if == NULL)
 		return ENXIO;
 	bound = curlwp_bind();
 	audio_sc_acquire_foropen(sc, &sc_ref);
 	error = audio_exlock_enter(sc);
 	if (error)
 		goto done;
 	device_active(sc->sc_dev, DVA_SYSTEM);
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_open(dev, sc, flags, ifmt, l, NULL);
 		break;
 	case AUDIOCTL_DEVICE:
 		error = audioctl_open(dev, sc, flags, ifmt, l);
 		break;
 	case MIXER_DEVICE:
 		error = mixer_open(dev, sc, flags, ifmt, l);
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_exlock_exit(sc);
 done:
 	audio_sc_release(sc, &sc_ref);
 	curlwp_bindx(bound);
 	return error;
+}
 static int
 audioclose(struct file *fp)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	int bound;
 	int error;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	dev = file->dev;
 	error = 0;
 	/*
 	 * audioclose() must
 	 * - unplug track from the trackmixer (and unplug anything from softc),
 	 *   if sc exists.
 	 * - free all memory objects, regardless of sc.
 	 */
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc) {
 		switch (AUDIODEV(dev)) {
 		case SOUND_DEVICE:
 		case AUDIO_DEVICE:
 			error = audio_close(sc, file);
 			break;
 		case AUDIOCTL_DEVICE:
 			error = 0;
 			break;
 		case MIXER_DEVICE:
 			error = mixer_close(sc, file);
 			break;
 		default:
 			error = ENXIO;
 			break;
+		}
 		audio_sc_release(sc, &sc_ref);
+	}
 	curlwp_bindx(bound);
 	/* Free memory objects anyway */
 	TRACEF(2, file, "free memory");
 	if (file->ptrack)
 		audio_track_destroy(file->ptrack);
 	if (file->rtrack)
 		audio_track_destroy(file->rtrack);
 	kmem_free(file, sizeof(*file));
 	fp->f_audioctx = NULL;
 	return error;
+}
 static int
 audioread(struct file *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
 	int ioflag)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	int bound;
 	int error;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	dev = file->dev;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		error = EIO;
 		goto done;
+	}
 	if (fp->f_flag & O_NONBLOCK)
 		ioflag |= IO_NDELAY;
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_read(sc, uio, ioflag, file);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 		error = ENODEV;
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_sc_release(sc, &sc_ref);
 done:
 	curlwp_bindx(bound);
 	return error;
+}
 static int
 audiowrite(struct file *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
 	int ioflag)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	int bound;
 	int error;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	dev = file->dev;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		error = EIO;
 		goto done;
+	}
 	if (fp->f_flag & O_NONBLOCK)
 		ioflag |= IO_NDELAY;
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_write(sc, uio, ioflag, file);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 		error = ENODEV;
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_sc_release(sc, &sc_ref);
 done:
 	curlwp_bindx(bound);
 	return error;
+}
 static int
 audioioctl(struct file *fp, u_long cmd, void *addr)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	struct lwp *l = curlwp;
 	int bound;
 	int error;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	dev = file->dev;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		error = EIO;
 		goto done;
+	}
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 	case AUDIOCTL_DEVICE:
 		mutex_enter(sc->sc_lock);
 		device_active(sc->sc_dev, DVA_SYSTEM);
 		mutex_exit(sc->sc_lock);
 		if (IOCGROUP(cmd) == IOCGROUP(AUDIO_MIXER_READ))
 			error = mixer_ioctl(sc, cmd, addr, fp->f_flag, l);
 		else
 			error = audio_ioctl(dev, sc, cmd, addr, fp->f_flag, l,
 			    file);
 		break;
 	case MIXER_DEVICE:
 		error = mixer_ioctl(sc, cmd, addr, fp->f_flag, l);
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_sc_release(sc, &sc_ref);
 done:
 	curlwp_bindx(bound);
 	return error;
+}
 static int
 audiostat(struct file *fp, struct stat *st)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	int bound;
 	int error;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		error = EIO;
 		goto done;
+	}
 	error = 0;
 	memset(st, 0, sizeof(*st));
 	st->st_dev = file->dev;
 	st->st_uid = kauth_cred_geteuid(fp->f_cred);
 	st->st_gid = kauth_cred_getegid(fp->f_cred);
 	st->st_mode = S_IFCHR;
 	audio_sc_release(sc, &sc_ref);
 done:
 	curlwp_bindx(bound);
 	return error;
+}
 static int
 audiopoll(struct file *fp, int events)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	struct lwp *l = curlwp;
 	int bound;
 	int revents;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	dev = file->dev;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		revents = POLLERR;
 		goto done;
+	}
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		revents = audio_poll(sc, events, l, file);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 		revents = 0;
 		break;
 	default:
 		revents = POLLERR;
 		break;
+	}
 	audio_sc_release(sc, &sc_ref);
 done:
 	curlwp_bindx(bound);
 	return revents;
+}
 static int
 audiokqfilter(struct file *fp, struct knote *kn)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	dev_t dev;
 	int bound;
 	int error;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	dev = file->dev;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		error = EIO;
 		goto done;
+	}
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_kqfilter(sc, file, kn);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 		error = ENODEV;
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_sc_release(sc, &sc_ref);
 done:
 	curlwp_bindx(bound);
 	return error;
+}
 static int
 audiommap(struct file *fp, off_t *offp, size_t len, int prot, int *flagsp,
 	int *advicep, struct uvm_object **uobjp, int *maxprotp)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	dev_t dev;
 	int bound;
 	int error;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	dev = file->dev;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		error = EIO;
 		goto done;
+	}
 	mutex_enter(sc->sc_lock);
 	device_active(sc->sc_dev, DVA_SYSTEM); /* XXXJDM */
 	mutex_exit(sc->sc_lock);
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_mmap(sc, offp, len, prot, flagsp, advicep,
 		    uobjp, maxprotp, file);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 	default:
 		error = ENOTSUP;
 		break;
+	}
 	audio_sc_release(sc, &sc_ref);
 done:
 	curlwp_bindx(bound);
 	return error;
+}
 /* Exported interfaces for audiobell. */
 /*
  * Open for audiobell.
  * It stores allocated file to *filep.
  * If successful returns 0, otherwise errno.
  */
 int
 audiobellopen(dev_t dev, audio_file_t **filep)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	int bound;
 	int error;
 	/* Find the device */
 	sc = device_lookup_private(&audio_cd, AUDIOUNIT(dev));
 	if (sc == NULL || sc->hw_if == NULL)
 		return ENXIO;
 	bound = curlwp_bind();
 	audio_sc_acquire_foropen(sc, &sc_ref);
 	error = audio_exlock_enter(sc);
 	if (error)
 		goto done;
 	device_active(sc->sc_dev, DVA_SYSTEM);
 	error = audio_open(dev, sc, FWRITE, 0, curlwp, filep);
 	audio_exlock_exit(sc);
 done:
 	audio_sc_release(sc, &sc_ref);
 	curlwp_bindx(bound);
 	return error;
+}
 /* Close for audiobell */
 int
 audiobellclose(audio_file_t *file)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	int bound;
 	int error;
 	error = 0;
 	/*
 	 * audiobellclose() must
 	 * - unplug track from the trackmixer if sc exist.
 	 * - free all memory objects, regardless of sc.
 	 */
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc) {
 		error = audio_close(sc, file);
 		audio_sc_release(sc, &sc_ref);
+	}
 	curlwp_bindx(bound);
 	/* Free memory objects anyway */
 	KASSERT(file->ptrack);
 	audio_track_destroy(file->ptrack);
 	KASSERT(file->rtrack == NULL);
 	kmem_free(file, sizeof(*file));
 	return error;
+}
 /* Set sample rate for audiobell */
 int
 audiobellsetrate(audio_file_t *file, u_int sample_rate)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	struct audio_info ai;
 	int bound;
 	int error;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		error = EIO;
 		goto done1;
+	}
 	AUDIO_INITINFO(&ai);
 	ai.play.sample_rate = sample_rate;
 	error = audio_exlock_enter(sc);
 	if (error)
 		goto done2;
 	error = audio_file_setinfo(sc, file, &ai);
 	audio_exlock_exit(sc);
 done2:
 	audio_sc_release(sc, &sc_ref);
 done1:
 	curlwp_bindx(bound);
 	return error;
+}
 /* Playback for audiobell */
 int
 audiobellwrite(audio_file_t *file, struct uio *uio)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	int bound;
 	int error;
 	bound = curlwp_bind();
 	sc = audio_sc_acquire_fromfile(file, &sc_ref);
 	if (sc == NULL) {
 		error = EIO;
 		goto done;
+	}
 	error = audio_write(sc, uio, 0, file);
 	audio_sc_release(sc, &sc_ref);
 done:
 	curlwp_bindx(bound);
 	return error;
+}
 /*
  * Audio driver
  */
 /*
  * Must be called with sc_exlock held and without sc_lock held.
  */
 int
 audio_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
 	struct lwp *l, audio_file_t **bellfile)
+{
 	struct audio_info ai;
 	struct file *fp;
 	audio_file_t *af;
 	audio_ring_t *hwbuf;
 	bool fullduplex;
 	bool cred_held;
 	bool hw_opened;
 	bool rmixer_started;
 	bool inserted;
 	int fd;
 	int error;
 	KASSERT(sc->sc_exlock);
 	TRACE(1, "%sdev=%s flags=0x%x po=%d ro=%d",
 	    (audiodebug >= 3) ? "start " : "",
 	    ISDEVSOUND(dev) ? "sound" : "audio",
 	    flags, sc->sc_popens, sc->sc_ropens);
 	fp = NULL;
 	cred_held = false;
 	hw_opened = false;
 	rmixer_started = false;
 	inserted = false;
 	af = kmem_zalloc(sizeof(audio_file_t), KM_SLEEP);
 	af->sc = sc;
 	af->dev = dev;
 	if ((flags & FWRITE) != 0 && audio_can_playback(sc))
 		af->mode |= AUMODE_PLAY | AUMODE_PLAY_ALL;
 	if ((flags & FREAD) != 0 && audio_can_capture(sc))
 		af->mode |= AUMODE_RECORD;
 	if (af->mode == 0) {
 		error = ENXIO;
 		goto bad;
+	}
 	fullduplex = (sc->sc_props & AUDIO_PROP_FULLDUPLEX);
 	/*
 	 * On half duplex hardware,
 	 * 1. if mode is (PLAY | REC), let mode PLAY.
 	 * 2. if mode is PLAY, let mode PLAY if no rec tracks, otherwise error.
 	 * 3. if mode is REC, let mode REC if no play tracks, otherwise error.
 	 */
 	if (fullduplex == false) {
 		if ((af->mode & AUMODE_PLAY)) {
 			if (sc->sc_ropens != 0) {
 				TRACE(1, "record track already exists");
 				error = ENODEV;
 				goto bad;
+			}
 			/* Play takes precedence */
 			af->mode &= ~AUMODE_RECORD;
+		}
 		if ((af->mode & AUMODE_RECORD)) {
 			if (sc->sc_popens != 0) {
 				TRACE(1, "play track already exists");
 				error = ENODEV;
 				goto bad;
+			}
+		}
+	}
 	/* Create tracks */
 	if ((af->mode & AUMODE_PLAY))
 		af->ptrack = audio_track_create(sc, sc->sc_pmixer);
 	if ((af->mode & AUMODE_RECORD))
 		af->rtrack = audio_track_create(sc, sc->sc_rmixer);
 	/* Set parameters */
 	AUDIO_INITINFO(&ai);
 	if (bellfile) {
 		/* If audiobell, only sample_rate will be set later. */
 		ai.play.sample_rate   = audio_default.sample_rate;
 		ai.play.encoding      = AUDIO_ENCODING_SLINEAR_NE;
 		ai.play.channels      = 1;
 		ai.play.precision     = 16;
 		ai.play.pause         = 0;
 	} else if (ISDEVAUDIO(dev)) {
 		/* If /dev/audio, initialize everytime. */
 		ai.play.sample_rate   = audio_default.sample_rate;
 		ai.play.encoding      = audio_default.encoding;
 		ai.play.channels      = audio_default.channels;
 		ai.play.precision     = audio_default.precision;
 		ai.play.pause         = 0;
 		ai.record.sample_rate = audio_default.sample_rate;
 		ai.record.encoding    = audio_default.encoding;
 		ai.record.channels    = audio_default.channels;
 		ai.record.precision   = audio_default.precision;
 		ai.record.pause       = 0;
 	} else {
 		/* If /dev/sound, take over the previous parameters. */
 		ai.play.sample_rate   = sc->sc_sound_pparams.sample_rate;
 		ai.play.encoding      = sc->sc_sound_pparams.encoding;
 		ai.play.channels      = sc->sc_sound_pparams.channels;
 		ai.play.precision     = sc->sc_sound_pparams.precision;
 		ai.play.pause         = sc->sc_sound_ppause;
 		ai.record.sample_rate = sc->sc_sound_rparams.sample_rate;
 		ai.record.encoding    = sc->sc_sound_rparams.encoding;
 		ai.record.channels    = sc->sc_sound_rparams.channels;
 		ai.record.precision   = sc->sc_sound_rparams.precision;
 		ai.record.pause       = sc->sc_sound_rpause;
+	}
 	error = audio_file_setinfo(sc, af, &ai);
 	if (error)
 		goto bad;
 	if (sc->sc_popens + sc->sc_ropens == 0) {
 		/* First open */
 		sc->sc_cred = kauth_cred_get();
 		kauth_cred_hold(sc->sc_cred);
 		cred_held = true;
 		if (sc->hw_if->open) {
 			int hwflags;
 			/*
 			 * Call hw_if->open() only at first open of
 			 * combination of playback and recording.
 			 * On full duplex hardware, the flags passed to
 			 * hw_if->open() is always (FREAD | FWRITE)
 			 * regardless of this open()'s flags.
 			 * see also dev/isa/aria.c
 			 * On half duplex hardware, the flags passed to
 			 * hw_if->open() is either FREAD or FWRITE.
 			 * see also arch/evbarm/mini2440/audio_mini2440.c
 			 */
 			if (fullduplex) {
 				hwflags = FREAD | FWRITE;
 			} else {
 				/* Construct hwflags from af->mode. */
 				hwflags = 0;
 				if ((af->mode & AUMODE_PLAY) != 0)
 					hwflags |= FWRITE;
 				if ((af->mode & AUMODE_RECORD) != 0)
 					hwflags |= FREAD;
+			}
 			mutex_enter(sc->sc_lock);
 			mutex_enter(sc->sc_intr_lock);
 			error = sc->hw_if->open(sc->hw_hdl, hwflags);
 			mutex_exit(sc->sc_intr_lock);
 			mutex_exit(sc->sc_lock);
 			if (error)
 				goto bad;
+		}
 		/*
 		 * Regardless of whether we called hw_if->open (whether
 		 * hw_if->open exists) or not, we move to the Opened phase
 		 * here.  Therefore from this point, we have to call
 		 * hw_if->close (if exists) whenever abort.
 		 * Note that both of hw_if->{open,close} are optional.
 		 */
 		hw_opened = true;
 		/*
 		 * Set speaker mode when a half duplex.
 		 * XXX I'm not sure this is correct.
 		 */
 		if (1/*XXX*/) {
 			if (sc->hw_if->speaker_ctl) {
 				int on;
 				if (af->ptrack) {
 					on = 1;
 				} else {
 					on = 0;
+				}
 				mutex_enter(sc->sc_lock);
 				mutex_enter(sc->sc_intr_lock);
 				error = sc->hw_if->speaker_ctl(sc->hw_hdl, on);
 				mutex_exit(sc->sc_intr_lock);
 				mutex_exit(sc->sc_lock);
 				if (error)
 					goto bad;
+			}
+		}
 	} else if (sc->sc_multiuser == false) {
 		uid_t euid = kauth_cred_geteuid(kauth_cred_get());
 		if (euid != 0 && euid != kauth_cred_geteuid(sc->sc_cred)) {
 			error = EPERM;
 			goto bad;
+		}
+	}
 	/* Call init_output if this is the first playback open. */
 	if (af->ptrack && sc->sc_popens == 0) {
 		if (sc->hw_if->init_output) {
 			hwbuf = &sc->sc_pmixer->hwbuf;
 			mutex_enter(sc->sc_lock);
 			mutex_enter(sc->sc_intr_lock);
 			error = sc->hw_if->init_output(sc->hw_hdl,
 			    hwbuf->mem,
 			    hwbuf->capacity *
 			    hwbuf->fmt.channels * hwbuf->fmt.stride / NBBY);
 			mutex_exit(sc->sc_intr_lock);
 			mutex_exit(sc->sc_lock);
 			if (error)
 				goto bad;
+		}
+	}
 	/*
 	 * Call init_input and start rmixer, if this is the first recording
 	 * open.  See pause consideration notes.
 	 */
 	if (af->rtrack && sc->sc_ropens == 0) {
 		if (sc->hw_if->init_input) {
 			hwbuf = &sc->sc_rmixer->hwbuf;