 @@ -1,1144 +1,1144 @@
-/*	$NetBSD: audio.c,v 1.28.2.4 2019/11/19 12:58:29 martin Exp $	*/
+/*	$NetBSD: audio.c,v 1.28.2.5 2020/01/02 09:18:15 martin 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 			-	- +	(*1)
  *	freem 			-	- +	(*1)
  *	round_buffersize 	-	x
  *	get_props 		-	x	Called at attach time
  *	trigger_output 		x	x +
  *	trigger_input 		x	x +
  *	dev_ioctl 		-	x
  *	get_locks 		-	-	Called at attach time
+ *
  * *1 Note: Before 8.0, since these have been called only at attach time,
  *   neither lock were necessary.  Currently, on the other hand, since
  *   these may be also called after attach, the thread lock is required.
+ *
  * 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.28.2.4 2019/11/19 12:58:29 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.28.2.5 2020/01/02 09:18:15 martin Exp $");
 #ifdef _KERNEL_OPT
 #include "audio.h"
 #include "midi.h"
 #endif
 #if NAUDIO > 0
 #ifdef _KERNEL
 #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.h>
 #include "ioconf.h"
 #endif /* _KERNEL */
 /*
  * 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)
 /* Device timeout in msec */
 #define AUDIO_TIMEOUT	(3000)
 /* #define AUDIO_PM_IDLE */
 #ifdef AUDIO_PM_IDLE
 int audio_idle_timeout = 30;
 #endif
 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 int  audio_enter_exclusive(struct audio_softc *);
 static void audio_exit_exclusive(struct audio_softc *);
 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_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_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,
 	audio_format2_t *, 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 *, int, int *,
 	audio_format2_t *, audio_format2_t *);
 static int audio_hw_probe_fmt(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_remove(struct audio_softc *);
 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 }
 };
 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 || hw_if->get_locks == NULL) {
 		panic("audioattach: missing hw_if method");
+	}
 	hw_if->get_locks(hdlp, &sc->sc_intr_lock, &sc->sc_lock);
 #ifdef DIAGNOSTIC
 	if (hw_if->query_format == NULL ||
 	    hw_if->set_format == NULL ||
 	    (hw_if->start_output == NULL && hw_if->trigger_output == NULL) ||
 	    (hw_if->start_input == NULL && hw_if->trigger_input == NULL) ||
 	    hw_if->halt_output == NULL ||
 	    hw_if->halt_input == NULL ||
 	    hw_if->getdev == NULL ||
 	    hw_if->set_port == NULL ||
 	    hw_if->get_port == NULL ||
 	    hw_if->query_devinfo == NULL ||
 	    hw_if->get_props == NULL) {
 		aprint_error(": missing method\n");
 		return;
+	}
 #endif
 	sc->hw_if = hw_if;
 	sc->hw_hdl = hdlp;
 	sc->hw_dev = parent;
 	sc->sc_blk_ms = AUDIO_BLK_MS;
 	SLIST_INIT(&sc->sc_files);
 	cv_init(&sc->sc_exlockcv, "audiolk");
 	mutex_enter(sc->sc_lock);
 	sc->sc_props = hw_if->get_props(sc->hw_hdl);
 	mutex_exit(sc->sc_lock);
 	/* MMAP is now supported by upper layer.  */
 	sc->sc_props |= AUDIO_PROP_MMAP;
 	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);
 	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));
 	mutex_enter(sc->sc_lock);
 	error = audio_hw_probe(sc, has_indep, &mode, &phwfmt, &rhwfmt);
 	if (error) {
 		mutex_exit(sc->sc_lock);
 		aprint_error_dev(self, "audio_hw_probe failed, "
 		    "error = %d\n", error);
 		goto bad;
+	}
 	if (mode == 0) {
 		mutex_exit(sc->sc_lock);
 		aprint_error_dev(self, "audio_hw_probe failed, no mode\n");
 		goto bad;
+	}
 	/* Init hardware. */
 	/* hw_probe() also validates [pr]hwfmt.  */
 	error = audio_hw_set_format(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
 	if (error) {
 		mutex_exit(sc->sc_lock);
 		aprint_error_dev(self, "audio_hw_set_format failed, "
 		    "error = %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);
 	mutex_exit(sc->sc_lock);
 	if (sc->sc_pmixer == NULL && sc->sc_rmixer == NULL) {
 		aprint_error_dev(self, "audio_mixers_init failed, "
 		    "error = %d\n", error);
 		goto bad;
+	}
 	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);
 	return;
 bad:
 	/* Clearing hw_if means that device is attached but disabled. */
 	sc->hw_if = NULL;
 	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,
 @@ -2065,3672 +2065,3614 @@ audio_open(dev_t dev, struct audio_softc
 		error = fd_clone(fp, fd, flags, &audio_fileops, af);
 		KASSERT(error == EMOVEFD);
+	}
 	TRACEF(3, af, "done");
 	return error;
 	/*
 	 * Since track here is not yet linked to sc_files,
 	 * you can call track_destroy() without sc_intr_lock.
 	 */
 bad3:
 	if (sc->sc_popens + sc->sc_ropens == 0) {
 		if (sc->hw_if->close) {
 			mutex_enter(sc->sc_intr_lock);
 			sc->hw_if->close(sc->hw_hdl);
 			mutex_exit(sc->sc_intr_lock);
+		}
+	}
 bad2:
 	if (af->rtrack) {
 		audio_track_destroy(af->rtrack);
 		af->rtrack = NULL;
+	}
 	if (af->ptrack) {
 		audio_track_destroy(af->ptrack);
 		af->ptrack = NULL;
+	}
 bad1:
 	kmem_free(af, sizeof(*af));
 	return error;
+}
 /*
  * Must NOT called with sc_lock nor sc_exlock held.
  */
 int
 audio_close(struct audio_softc *sc, audio_file_t *file)
+{
 	audio_track_t *oldtrack;
 	int error;
 	KASSERT(!mutex_owned(sc->sc_lock));
 	TRACEF(1, file, "%spid=%d.%d po=%d ro=%d",
 	    (audiodebug >= 3) ? "start " : "",
 	    (int)curproc->p_pid, (int)curlwp->l_lid,
 	    sc->sc_popens, sc->sc_ropens);
 	KASSERTMSG(sc->sc_popens + sc->sc_ropens > 0,
 	    "sc->sc_popens=%d, sc->sc_ropens=%d",
 	    sc->sc_popens, sc->sc_ropens);
 	/*
 	 * Drain first.
 	 * It must be done before acquiring exclusive lock.
 	 */
 	if (file->ptrack) {
 		mutex_enter(sc->sc_lock);
 		audio_track_drain(sc, file->ptrack);
 		mutex_exit(sc->sc_lock);
+	}
 	/* Then, acquire exclusive lock to protect counters. */
 	/* XXX what should I do when an error occurs? */
 	error = audio_enter_exclusive(sc);
 	if (error)
 		return error;
 	if (file->ptrack) {
 		/* Call hw halt_output if this is the last playback track. */
 		if (sc->sc_popens == 1 && sc->sc_pbusy) {
 			error = audio_pmixer_halt(sc);
 			if (error) {
 				device_printf(sc->sc_dev,
 				    "halt_output failed with %d\n", error);
+			}
+		}
 		/* Destroy the track. */
 		oldtrack = file->ptrack;
 		mutex_enter(sc->sc_intr_lock);
 		file->ptrack = NULL;
 		mutex_exit(sc->sc_intr_lock);
 		TRACET(3, oldtrack, "dropframes=%" PRIu64,
 		    oldtrack->dropframes);
 		audio_track_destroy(oldtrack);
 		KASSERT(sc->sc_popens > 0);
 		sc->sc_popens--;
 		/* Restore mixing volume if all tracks are gone. */
 		if (sc->sc_popens == 0) {
 			mutex_enter(sc->sc_intr_lock);
 			sc->sc_pmixer->volume = 256;
 			sc->sc_pmixer->voltimer = 0;
 			mutex_exit(sc->sc_intr_lock);
+		}
+	}
 	if (file->rtrack) {
 		/* Call hw halt_input if this is the last recording track. */
 		if (sc->sc_ropens == 1 && sc->sc_rbusy) {
 			error = audio_rmixer_halt(sc);
 			if (error) {
 				device_printf(sc->sc_dev,
 				    "halt_input failed with %d\n", error);
+			}
+		}
 		/* Destroy the track. */
 		oldtrack = file->rtrack;
 		mutex_enter(sc->sc_intr_lock);
 		file->rtrack = NULL;
 		mutex_exit(sc->sc_intr_lock);
 		TRACET(3, oldtrack, "dropframes=%" PRIu64,
 		    oldtrack->dropframes);
 		audio_track_destroy(oldtrack);
 		KASSERT(sc->sc_ropens > 0);
 		sc->sc_ropens--;
+	}
 	/* Call hw close if this is the last track. */
 	if (sc->sc_popens + sc->sc_ropens == 0) {
 		if (sc->hw_if->close) {
 			TRACE(2, "hw_if close");
 			mutex_enter(sc->sc_intr_lock);
 			sc->hw_if->close(sc->hw_hdl);
 			mutex_exit(sc->sc_intr_lock);
+		}
 		kauth_cred_free(sc->sc_cred);
+	}
 	mutex_enter(sc->sc_intr_lock);
 	SLIST_REMOVE(&sc->sc_files, file, audio_file, entry);
 	mutex_exit(sc->sc_intr_lock);
 	TRACE(3, "done");
 	audio_exit_exclusive(sc);
 	return 0;
+}
 int
 audio_read(struct audio_softc *sc, struct uio *uio, int ioflag,
 	audio_file_t *file)
+{
 	audio_track_t *track;
 	audio_ring_t *usrbuf;
 	audio_ring_t *input;
 	int error;
 	KASSERT(!mutex_owned(sc->sc_lock));
 	/*
 	 * On half-duplex hardware, O_RDWR is treated as O_WRONLY.
 	 * However read() system call itself can be called because it's
 	 * opened with O_RDWR.  So in this case, deny this read().
 	 */
 	track = file->rtrack;
 	if (track == NULL) {
 		return EBADF;
+	}
 	/* I think it's better than EINVAL. */
 	if (track->mmapped)
 		return EPERM;
 	TRACET(2, track, "resid=%zd", uio->uio_resid);
 #ifdef AUDIO_PM_IDLE
 	mutex_enter(sc->sc_lock);
 	if (device_is_active(&sc->sc_dev) || sc->sc_idle)
 		device_active(&sc->sc_dev, DVA_SYSTEM);
 	mutex_exit(sc->sc_lock);
 #endif
 	usrbuf = &track->usrbuf;
 	input = track->input;
 	/*
 	 * The first read starts rmixer.
 	 */
 	error = audio_enter_exclusive(sc);
 	if (error)
 		return error;
 	if (sc->sc_rbusy == false)
 		audio_rmixer_start(sc);
 	audio_exit_exclusive(sc);
 	error = 0;
 	while (uio->uio_resid > 0 && error == 0) {
 		int bytes;
 		TRACET(3, track,
 		    "while resid=%zd input=%d/%d/%d usrbuf=%d/%d/H%d",
 		    uio->uio_resid,
 		    input->head, input->used, input->capacity,
 		    usrbuf->head, usrbuf->used, track->usrbuf_usedhigh);
 		/* Wait when buffers are empty. */
 		mutex_enter(sc->sc_lock);
 		for (;;) {
 			bool empty;
 			audio_track_lock_enter(track);
 			empty = (input->used == 0 && usrbuf->used == 0);
 			audio_track_lock_exit(track);
 			if (!empty)
 				break;
 			if ((ioflag & IO_NDELAY)) {
 				mutex_exit(sc->sc_lock);
 				return EWOULDBLOCK;
+			}
 			TRACET(3, track, "sleep");
 			error = audio_track_waitio(sc, track);
 			if (error) {
 				mutex_exit(sc->sc_lock);
 				return error;
+			}
+		}
 		mutex_exit(sc->sc_lock);
 		audio_track_lock_enter(track);
 		audio_track_record(track);
 		/* uiomove from usrbuf as much as possible. */
 		bytes = uimin(usrbuf->used, uio->uio_resid);
 		while (bytes > 0) {
 			int head = usrbuf->head;
 			int len = uimin(bytes, usrbuf->capacity - head);
 			error = uiomove((uint8_t *)usrbuf->mem + head, len,
 			    uio);
 			if (error) {
 				audio_track_lock_exit(track);
 				device_printf(sc->sc_dev,
 				    "uiomove(len=%d) failed with %d\n",
 				    len, error);
 				goto abort;
+			}
 			auring_take(usrbuf, len);
 			track->useriobytes += len;
 			TRACET(3, track, "uiomove(len=%d) usrbuf=%d/%d/C%d",
 			    len,
 			    usrbuf->head, usrbuf->used, usrbuf->capacity);
 			bytes -= len;
+		}
 		audio_track_lock_exit(track);
+	}
 abort:
 	return error;
+}
 /*
  * Clear file's playback and/or record track buffer immediately.
  */
 static void
 audio_file_clear(struct audio_softc *sc, audio_file_t *file)
+{
 	if (file->ptrack)
 		audio_track_clear(sc, file->ptrack);
 	if (file->rtrack)
 		audio_track_clear(sc, file->rtrack);
+}
 int
 audio_write(struct audio_softc *sc, struct uio *uio, int ioflag,
 	audio_file_t *file)
+{
 	audio_track_t *track;
 	audio_ring_t *usrbuf;
 	audio_ring_t *outbuf;
 	int error;
 	KASSERT(!mutex_owned(sc->sc_lock));
 	track = file->ptrack;
 	KASSERT(track);
 	/* I think it's better than EINVAL. */
 	if (track->mmapped)
 		return EPERM;
 	TRACET(2, track, "%sresid=%zd pid=%d.%d ioflag=0x%x",
 	    audiodebug >= 3 ? "begin " : "",
 	    uio->uio_resid, (int)curproc->p_pid, (int)curlwp->l_lid, ioflag);
 	if (uio->uio_resid == 0) {
 		track->eofcounter++;
 		return 0;
+	}
 #ifdef AUDIO_PM_IDLE
 	mutex_enter(sc->sc_lock);
 	if (device_is_active(&sc->sc_dev) || sc->sc_idle)
 		device_active(&sc->sc_dev, DVA_SYSTEM);
 	mutex_exit(sc->sc_lock);
 #endif
 	usrbuf = &track->usrbuf;
 	outbuf = &track->outbuf;
 	/*
 	 * The first write starts pmixer.
 	 */
 	error = audio_enter_exclusive(sc);
 	if (error)
 		return error;
 	if (sc->sc_pbusy == false)
 		audio_pmixer_start(sc, false);
 	audio_exit_exclusive(sc);
 	track->pstate = AUDIO_STATE_RUNNING;
 	error = 0;
 	while (uio->uio_resid > 0 && error == 0) {
 		int bytes;
 		TRACET(3, track, "while resid=%zd usrbuf=%d/%d/H%d",
 		    uio->uio_resid,
 		    usrbuf->head, usrbuf->used, track->usrbuf_usedhigh);
 		/* Wait when buffers are full. */
 		mutex_enter(sc->sc_lock);
 		for (;;) {
 			bool full;
 			audio_track_lock_enter(track);
 			full = (usrbuf->used >= track->usrbuf_usedhigh &&
 			    outbuf->used >= outbuf->capacity);
 			audio_track_lock_exit(track);
 			if (!full)
 				break;
 			if ((ioflag & IO_NDELAY)) {
 				error = EWOULDBLOCK;
 				mutex_exit(sc->sc_lock);
 				goto abort;
+			}
 			TRACET(3, track, "sleep usrbuf=%d/H%d",
 			    usrbuf->used, track->usrbuf_usedhigh);
 			error = audio_track_waitio(sc, track);
 			if (error) {
 				mutex_exit(sc->sc_lock);
 				goto abort;
+			}
+		}
 		mutex_exit(sc->sc_lock);
 		audio_track_lock_enter(track);
 		/* uiomove to usrbuf as much as possible. */
 		bytes = uimin(track->usrbuf_usedhigh - usrbuf->used,
 		    uio->uio_resid);
 		while (bytes > 0) {
 			int tail = auring_tail(usrbuf);
 			int len = uimin(bytes, usrbuf->capacity - tail);
 			error = uiomove((uint8_t *)usrbuf->mem + tail, len,
 			    uio);
 			if (error) {
 				audio_track_lock_exit(track);
 				device_printf(sc->sc_dev,
 				    "uiomove(len=%d) failed with %d\n",
 				    len, error);
 				goto abort;
+			}
 			auring_push(usrbuf, len);
 			track->useriobytes += len;
 			TRACET(3, track, "uiomove(len=%d) usrbuf=%d/%d/C%d",
 			    len,
 			    usrbuf->head, usrbuf->used, usrbuf->capacity);
 			bytes -= len;
+		}
 		/* Convert them as much as possible. */
 		while (usrbuf->used >= track->usrbuf_blksize &&
 		    outbuf->used < outbuf->capacity) {
 			audio_track_play(track);
+		}
 		audio_track_lock_exit(track);
+	}
 abort:
 	TRACET(3, track, "done error=%d", error);
 	return error;
+}
 int
 audio_ioctl(dev_t dev, struct audio_softc *sc, u_long cmd, void *addr, int flag,
 	struct lwp *l, audio_file_t *file)
+{
 	struct audio_offset *ao;
 	struct audio_info ai;
 	audio_track_t *track;
 	audio_encoding_t *ae;
 	audio_format_query_t *query;
 	u_int stamp;
 	u_int offs;
 	int fd;
 	int index;
 	int error;
 	KASSERT(!mutex_owned(sc->sc_lock));
 #if defined(AUDIO_DEBUG)
 	const char *ioctlnames[] = {
 		" AUDIO_GETINFO",	/* 21 */
 		" AUDIO_SETINFO",	/* 22 */
 		" AUDIO_DRAIN",		/* 23 */
 		" AUDIO_FLUSH",		/* 24 */
 		" AUDIO_WSEEK",		/* 25 */
 		" AUDIO_RERROR",	/* 26 */
 		" AUDIO_GETDEV",	/* 27 */
 		" AUDIO_GETENC",	/* 28 */
 		" AUDIO_GETFD",		/* 29 */
 		" AUDIO_SETFD",		/* 30 */
 		" AUDIO_PERROR",	/* 31 */
 		" AUDIO_GETIOFFS",	/* 32 */
 		" AUDIO_GETOOFFS",	/* 33 */
 		" AUDIO_GETPROPS",	/* 34 */
 		" AUDIO_GETBUFINFO",	/* 35 */
 		" AUDIO_SETCHAN",	/* 36 */
 		" AUDIO_GETCHAN",	/* 37 */
 		" AUDIO_QUERYFORMAT",	/* 38 */
 		" AUDIO_GETFORMAT",	/* 39 */
 		" AUDIO_SETFORMAT",	/* 40 */
 	};
 	int nameidx = (cmd & 0xff);
 	const char *ioctlname = "";
 	if (21 <= nameidx && nameidx <= 21 + __arraycount(ioctlnames))
 		ioctlname = ioctlnames[nameidx - 21];
 	TRACEF(2, file, "(%lu,'%c',%lu)%s pid=%d.%d",
 	    IOCPARM_LEN(cmd), (char)IOCGROUP(cmd), cmd&0xff, ioctlname,
 	    (int)curproc->p_pid, (int)l->l_lid);
 #endif
 	error = 0;
 	switch (cmd) {
 	case FIONBIO:
 		/* All handled in the upper FS layer. */
 		break;
 	case FIONREAD:
 		/* Get the number of bytes that can be read. */
 		if (file->rtrack) {
 			*(int *)addr = audio_track_readablebytes(file->rtrack);
 		} else {
 			*(int *)addr = 0;
+		}
 		break;
 	case FIOASYNC:
 		/* Set/Clear ASYNC I/O. */
 		if (*(int *)addr) {
 			file->async_audio = curproc->p_pid;
 			TRACEF(2, file, "FIOASYNC pid %d", file->async_audio);
 		} else {
 			file->async_audio = 0;
 			TRACEF(2, file, "FIOASYNC off");
+		}
 		break;
 	case AUDIO_FLUSH:
 		/* XXX TODO: clear errors and restart? */
 		audio_file_clear(sc, file);
 		break;
 	case AUDIO_RERROR:
 		/*
 		 * Number of read bytes dropped.  We don't know where
 		 * or when they were dropped (including conversion stage).
 		 * Therefore, the number of accurate bytes or samples is
 		 * also unknown.
 		 */
 		track = file->rtrack;
 		if (track) {
 			*(int *)addr = frametobyte(&track->usrbuf.fmt,
 			    track->dropframes);
+		}
 		break;
 	case AUDIO_PERROR:
 		/*
 		 * Number of write bytes dropped.  We don't know where
 		 * or when they were dropped (including conversion stage).
 		 * Therefore, the number of accurate bytes or samples is
 		 * also unknown.
 		 */
 		track = file->ptrack;
 		if (track) {
 			*(int *)addr = frametobyte(&track->usrbuf.fmt,
 			    track->dropframes);
+		}
 		break;
 	case AUDIO_GETIOFFS:
 		/* XXX TODO */
 		ao = (struct audio_offset *)addr;
 		ao->samples = 0;
 		ao->deltablks = 0;
 		ao->offset = 0;
 		break;
 	case AUDIO_GETOOFFS:
 		ao = (struct audio_offset *)addr;
 		track = file->ptrack;
 		if (track == NULL) {
 			ao->samples = 0;
 			ao->deltablks = 0;
 			ao->offset = 0;
 			break;
+		}
 		mutex_enter(sc->sc_lock);
 		mutex_enter(sc->sc_intr_lock);
 		/* figure out where next DMA will start */
 		stamp = track->usrbuf_stamp;
 		offs = track->usrbuf.head;
 		mutex_exit(sc->sc_intr_lock);
 		mutex_exit(sc->sc_lock);
 		ao->samples = stamp;
 		ao->deltablks = (stamp / track->usrbuf_blksize) -
 		    (track->usrbuf_stamp_last / track->usrbuf_blksize);
 		track->usrbuf_stamp_last = stamp;
 		offs = rounddown(offs, track->usrbuf_blksize)
 		    + track->usrbuf_blksize;
 		if (offs >= track->usrbuf.capacity)
 			offs -= track->usrbuf.capacity;
 		ao->offset = offs;
 		TRACET(3, track, "GETOOFFS: samples=%u deltablks=%u offset=%u",
 		    ao->samples, ao->deltablks, ao->offset);
 		break;
 	case AUDIO_WSEEK:
 		/* XXX return value does not include outbuf one. */
 		if (file->ptrack)
 			*(u_long *)addr = file->ptrack->usrbuf.used;
 		break;
 	case AUDIO_SETINFO:
 		error = audio_enter_exclusive(sc);
 		if (error)
 			break;
 		error = audio_file_setinfo(sc, file, (struct audio_info *)addr);
 		if (error) {
 			audio_exit_exclusive(sc);
 			break;
+		}
 		/* XXX TODO: update last_ai if /dev/sound ? */
 		if (ISDEVSOUND(dev))
 			error = audiogetinfo(sc, &sc->sc_ai, 0, file);
 		audio_exit_exclusive(sc);
 		break;
 	case AUDIO_GETINFO:
 		error = audio_enter_exclusive(sc);
 		if (error)
 			break;
 		error = audiogetinfo(sc, (struct audio_info *)addr, 1, file);
 		audio_exit_exclusive(sc);
 		break;
 	case AUDIO_GETBUFINFO:
 		mutex_enter(sc->sc_lock);
 		error = audiogetinfo(sc, (struct audio_info *)addr, 0, file);
 		mutex_exit(sc->sc_lock);
 		break;
 	case AUDIO_DRAIN:
 		if (file->ptrack) {
 			mutex_enter(sc->sc_lock);
 			error = audio_track_drain(sc, file->ptrack);
 			mutex_exit(sc->sc_lock);
+		}
 		break;
 	case AUDIO_GETDEV:
 		mutex_enter(sc->sc_lock);
 		error = sc->hw_if->getdev(sc->hw_hdl, (audio_device_t *)addr);
 		mutex_exit(sc->sc_lock);
 		break;
 	case AUDIO_GETENC:
 		ae = (audio_encoding_t *)addr;
 		index = ae->index;
 		if (index < 0 || index >= __arraycount(audio_encodings)) {
 			error = EINVAL;
 			break;
+		}
 		*ae = audio_encodings[index];
 		ae->index = index;
 		/*
 		 * EMULATED always.
 		 * EMULATED flag at that time used to mean that it could
 		 * not be passed directly to the hardware as-is.  But
 		 * currently, all formats including hardware native is not
 		 * passed directly to the hardware.  So I set EMULATED
 		 * flag for all formats.
 		 */
 		ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
 		break;
 	case AUDIO_GETFD:
 		/*
 		 * Returns the current setting of full duplex mode.
 		 * If HW has full duplex mode and there are two mixers,
 		 * it is full duplex.  Otherwise half duplex.
 		 */
 		mutex_enter(sc->sc_lock);
 		fd = (sc->sc_props & AUDIO_PROP_FULLDUPLEX)
 		    && (sc->sc_pmixer && sc->sc_rmixer);
 		mutex_exit(sc->sc_lock);
 		*(int *)addr = fd;
 		break;
 	case AUDIO_GETPROPS:
 		*(int *)addr = sc->sc_props;
 		break;
 	case AUDIO_QUERYFORMAT:
 		query = (audio_format_query_t *)addr;
 		if (sc->hw_if->query_format) {
 			mutex_enter(sc->sc_lock);
 			error = sc->hw_if->query_format(sc->hw_hdl, query);
 			mutex_exit(sc->sc_lock);
 			/* Hide internal infomations */
 			query->fmt.driver_data = NULL;
 		} else {
 			error = ENODEV;
+		}
 		break;
 	case AUDIO_GETFORMAT:
 		audio_mixers_get_format(sc, (struct audio_info *)addr);
 		break;
 	case AUDIO_SETFORMAT:
 		mutex_enter(sc->sc_lock);
 		audio_mixers_get_format(sc, &ai);
 		error = audio_mixers_set_format(sc, (struct audio_info *)addr);
 		if (error) {
 			/* Rollback */
 			audio_mixers_set_format(sc, &ai);
+		}
 		mutex_exit(sc->sc_lock);
 		break;
 	case AUDIO_SETFD:
 	case AUDIO_SETCHAN:
 	case AUDIO_GETCHAN:
 		/* Obsoleted */
 		break;
 	default:
 		if (sc->hw_if->dev_ioctl) {
 			error = audio_enter_exclusive(sc);
 			if (error)
 				break;
 			error = sc->hw_if->dev_ioctl(sc->hw_hdl,
 			    cmd, addr, flag, l);
 			audio_exit_exclusive(sc);
 		} else {
 			TRACEF(2, file, "unknown ioctl");
 			error = EINVAL;
+		}
 		break;
+	}
 	TRACEF(2, file, "(%lu,'%c',%lu)%s result %d",
 	    IOCPARM_LEN(cmd), (char)IOCGROUP(cmd), cmd&0xff, ioctlname,
 	    error);
 	return error;
+}
 /*
  * Returns the number of bytes that can be read on recording buffer.
  */
 static __inline int
 audio_track_readablebytes(const audio_track_t *track)
+{
 	int bytes;
 	KASSERT(track);
 	KASSERT(track->mode == AUMODE_RECORD);
 	/*
 	 * Although usrbuf is primarily readable data, recorded data
 	 * also stays in track->input until reading.  So it is necessary
 	 * to add it.  track->input is in frame, usrbuf is in byte.
 	 */
 	bytes = track->usrbuf.used +
 	    track->input->used * frametobyte(&track->usrbuf.fmt, 1);
 	return bytes;
+}
 int
 audio_poll(struct audio_softc *sc, int events, struct lwp *l,
 	audio_file_t *file)
+{
 	audio_track_t *track;
 	int revents;
 	bool in_is_valid;
 	bool out_is_valid;
 	KASSERT(!mutex_owned(sc->sc_lock));
 #if defined(AUDIO_DEBUG)
 #define POLLEV_BITMAP "\177\020" \
 	    "b\10WRBAND\0" \
 	    "b\7RDBAND\0" "b\6RDNORM\0" "b\5NVAL\0" "b\4HUP\0" \
 	    "b\3ERR\0" "b\2OUT\0" "b\1PRI\0" "b\0IN\0"
 	char evbuf[64];
 	snprintb(evbuf, sizeof(evbuf), POLLEV_BITMAP, events);
 	TRACEF(2, file, "pid=%d.%d events=%s",
 	    (int)curproc->p_pid, (int)l->l_lid, evbuf);
 #endif
 	revents = 0;
 	in_is_valid = false;
 	out_is_valid = false;
 	if (events & (POLLIN | POLLRDNORM)) {
 		track = file->rtrack;
 		if (track) {
 			int used;
 			in_is_valid = true;
 			used = audio_track_readablebytes(track);
 			if (used > 0)
 				revents |= events & (POLLIN | POLLRDNORM);
+		}
+	}
 	if (events & (POLLOUT | POLLWRNORM)) {
 		track = file->ptrack;
 		if (track) {
 			out_is_valid = true;
 			if (track->usrbuf.used <= track->usrbuf_usedlow)
 				revents |= events & (POLLOUT | POLLWRNORM);
+		}
+	}
 	if (revents == 0) {
 		mutex_enter(sc->sc_lock);
 		if (in_is_valid) {
 			TRACEF(3, file, "selrecord rsel");
 			selrecord(l, &sc->sc_rsel);
+		}
 		if (out_is_valid) {
 			TRACEF(3, file, "selrecord wsel");
 			selrecord(l, &sc->sc_wsel);
+		}
 		mutex_exit(sc->sc_lock);
+	}
 #if defined(AUDIO_DEBUG)
 	snprintb(evbuf, sizeof(evbuf), POLLEV_BITMAP, revents);
 	TRACEF(2, file, "revents=%s", evbuf);
 #endif
 	return revents;
+}
 static const struct filterops audioread_filtops = {
 	.f_isfd = 1,
 	.f_attach = NULL,
 	.f_detach = filt_audioread_detach,
 	.f_event = filt_audioread_event,
 };
 static void
 filt_audioread_detach(struct knote *kn)
+{
 	struct audio_softc *sc;
 	audio_file_t *file;
 	file = kn->kn_hook;
 	sc = file->sc;
 	TRACEF(3, file, "");
 	mutex_enter(sc->sc_lock);
 	SLIST_REMOVE(&sc->sc_rsel.sel_klist, kn, knote, kn_selnext);
 	mutex_exit(sc->sc_lock);
+}
 static int
 filt_audioread_event(struct knote *kn, long hint)
+{
 	audio_file_t *file;
 	audio_track_t *track;
 	file = kn->kn_hook;
 	track = file->rtrack;
 	/*
 	 * kn_data must contain the number of bytes can be read.
 	 * The return value indicates whether the event occurs or not.
 	 */
 	if (track == NULL) {
 		/* can not read with this descriptor. */
 		kn->kn_data = 0;
 		return 0;
+	}
 	kn->kn_data = audio_track_readablebytes(track);
 	TRACEF(3, file, "data=%" PRId64, kn->kn_data);
 	return kn->kn_data > 0;
+}
 static const struct filterops audiowrite_filtops = {
 	.f_isfd = 1,
 	.f_attach = NULL,
 	.f_detach = filt_audiowrite_detach,
 	.f_event = filt_audiowrite_event,
 };
 static void
 filt_audiowrite_detach(struct knote *kn)
+{
 	struct audio_softc *sc;
 	audio_file_t *file;
 	file = kn->kn_hook;
 	sc = file->sc;
 	TRACEF(3, file, "");
 	mutex_enter(sc->sc_lock);
 	SLIST_REMOVE(&sc->sc_wsel.sel_klist, kn, knote, kn_selnext);
 	mutex_exit(sc->sc_lock);
+}
 static int
 filt_audiowrite_event(struct knote *kn, long hint)
+{
 	audio_file_t *file;
 	audio_track_t *track;
 	file = kn->kn_hook;
 	track = file->ptrack;
 	/*
 	 * kn_data must contain the number of bytes can be write.
 	 * The return value indicates whether the event occurs or not.
 	 */
 	if (track == NULL) {
 		/* can not write with this descriptor. */
 		kn->kn_data = 0;
 		return 0;
+	}
 	kn->kn_data = track->usrbuf_usedhigh - track->usrbuf.used;
 	TRACEF(3, file, "data=%" PRId64, kn->kn_data);
 	return (track->usrbuf.used < track->usrbuf_usedlow);
+}
 int
 audio_kqfilter(struct audio_softc *sc, audio_file_t *file, struct knote *kn)
+{
 	struct klist *klist;
 	KASSERT(!mutex_owned(sc->sc_lock));
 	TRACEF(3, file, "kn=%p kn_filter=%x", kn, (int)kn->kn_filter);
 	switch (kn->kn_filter) {
 	case EVFILT_READ:
 		klist = &sc->sc_rsel.sel_klist;
 		kn->kn_fop = &audioread_filtops;
 		break;
 	case EVFILT_WRITE:
 		klist = &sc->sc_wsel.sel_klist;
 		kn->kn_fop = &audiowrite_filtops;
 		break;
 	default:
 		return EINVAL;
+	}
 	kn->kn_hook = file;
 	mutex_enter(sc->sc_lock);
 	SLIST_INSERT_HEAD(klist, kn, kn_selnext);
 	mutex_exit(sc->sc_lock);
 	return 0;
+}
 int
 audio_mmap(struct audio_softc *sc, off_t *offp, size_t len, int prot,
 	int *flagsp, int *advicep, struct uvm_object **uobjp, int *maxprotp,
 	audio_file_t *file)
+{
 	audio_track_t *track;
 	vsize_t vsize;
 	int error;
 	KASSERT(!mutex_owned(sc->sc_lock));
 	TRACEF(2, file, "off=%lld, prot=%d", (long long)(*offp), prot);
 	if (*offp < 0)
 		return EINVAL;
 #if 0
 	/* XXX
 	 * The idea here was to use the protection to determine if
 	 * we are mapping the read or write buffer, but it fails.
 	 * The VM system is broken in (at least) two ways.
 	 * 1) If you map memory VM_PROT_WRITE you SIGSEGV
 	 *    when writing to it, so VM_PROT_READ|VM_PROT_WRITE
 	 *    has to be used for mmapping the play buffer.
 	 * 2) Even if calling mmap() with VM_PROT_READ|VM_PROT_WRITE
 	 *    audio_mmap will get called at some point with VM_PROT_READ
 	 *    only.
 	 * So, alas, we always map the play buffer for now.
 	 */
 	if (prot == (VM_PROT_READ|VM_PROT_WRITE) ||
 	    prot == VM_PROT_WRITE)
 		track = file->ptrack;
 	else if (prot == VM_PROT_READ)
 		track = file->rtrack;
 	else
 		return EINVAL;
 #else
 	track = file->ptrack;
 #endif
 	if (track == NULL)
 		return EACCES;
 	vsize = roundup2(MAX(track->usrbuf.capacity, PAGE_SIZE), PAGE_SIZE);
 	if (len > vsize)
 		return EOVERFLOW;
 	if (*offp > (uint)(vsize - len))
 		return EOVERFLOW;
 	/* XXX TODO: what happens when mmap twice. */
 	if (!track->mmapped) {
 		track->mmapped = true;
 		if (!track->is_pause) {
 			error = audio_enter_exclusive(sc);
 			if (error)
 				return error;
 			if (sc->sc_pbusy == false)
 				audio_pmixer_start(sc, true);
 			audio_exit_exclusive(sc);
+		}
 		/* XXX mmapping record buffer is not supported */
+	}
 	/* get ringbuffer */
 	*uobjp = track->uobj;
 	/* Acquire a reference for the mmap.  munmap will release. */
 	uao_reference(*uobjp);
 	*maxprotp = prot;
 	*advicep = UVM_ADV_RANDOM;
 	*flagsp = MAP_SHARED;
 	return 0;
+}
 /*
  * /dev/audioctl has to be able to open at any time without interference
  * with any /dev/audio or /dev/sound.
  */
 static int
 audioctl_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
 	struct lwp *l)
+{
 	struct file *fp;
 	audio_file_t *af;
 	int fd;
 	int error;
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(sc->sc_exlock);
 	TRACE(1, "");
 	error = fd_allocfile(&fp, &fd);
 	if (error)
 		return error;
 	af = kmem_zalloc(sizeof(audio_file_t), KM_SLEEP);
 	af->sc = sc;
 	af->dev = dev;
 	/* Not necessary to insert sc_files. */
 	error = fd_clone(fp, fd, flags, &audio_fileops, af);
 	KASSERT(error == EMOVEFD);
 	return error;
+}
 /*
  * Reallocate 'memblock' with specified 'bytes' if 'bytes' > 0.
  * Or free 'memblock' and return NULL if 'byte' is zero.
  */
 static void *
 audio_realloc(void *memblock, size_t bytes)
 	if (memblock != NULL) {
 		if (bytes != 0) {
 			return kern_realloc(memblock, bytes, M_NOWAIT);
 		} else {
 			kern_free(memblock);
 			return NULL;
 	} else {
 		if (bytes != 0) {
 			return kern_malloc(bytes, M_NOWAIT);
 		} else {
 			return NULL;
 /*
  * Free 'mem' if available, and initialize the pointer.
  * For this reason, this is implemented as macro.
  */
 #define audio_free(mem)	do {	\
 	if (mem != NULL) {	\
 		kern_free(mem);	\
 		mem = NULL;	\
 	}	\
 } while (0)
 /*
  * (Re)allocate 'memblock' with specified 'bytes'.
  * bytes must not be 0.
  * This function never returns NULL.
  */
 static void *
 audio_realloc(void *memblock, size_t bytes)
+{
 	KASSERT(bytes != 0);
 	audio_free(memblock);
 	return kern_malloc(bytes, M_WAITOK);
+}
 /*
  * (Re)allocate usrbuf with 'newbufsize' bytes.
  * Use this function for usrbuf because only usrbuf can be mmapped.
  * If successful, it updates track->usrbuf.mem, track->usrbuf.capacity and
  * returns 0.  Otherwise, it clears track->usrbuf.mem, track->usrbuf.capacity
  * and returns errno.
  * It must be called before updating usrbuf.capacity.
  */
 static int
 audio_realloc_usrbuf(audio_track_t *track, int newbufsize)
+{
 	struct audio_softc *sc;
 	vaddr_t vstart;
 	vsize_t oldvsize;
 	vsize_t newvsize;
 	int error;
 	KASSERT(newbufsize > 0);
 	sc = track->mixer->sc;
 	/* Get a nonzero multiple of PAGE_SIZE */
 	newvsize = roundup2(MAX(newbufsize, PAGE_SIZE), PAGE_SIZE);
 	if (track->usrbuf.mem != NULL) {
 		oldvsize = roundup2(MAX(track->usrbuf.capacity, PAGE_SIZE),
 		    PAGE_SIZE);
 		if (oldvsize == newvsize) {
 			track->usrbuf.capacity = newbufsize;
 			return 0;
+		}
 		vstart = (vaddr_t)track->usrbuf.mem;
 		uvm_unmap(kernel_map, vstart, vstart + oldvsize);
 		/* uvm_unmap also detach uobj */
 		track->uobj = NULL;		/* paranoia */
 		track->usrbuf.mem = NULL;
+	}
 	/* Create a uvm anonymous object */
 	track->uobj = uao_create(newvsize, 0);
 	/* Map it into the kernel virtual address space */
 	vstart = 0;
 	error = uvm_map(kernel_map, &vstart, newvsize, track->uobj, 0, 0,
 	    UVM_MAPFLAG(UVM_PROT_RW, UVM_PROT_RW, UVM_INH_NONE,
 	    UVM_ADV_RANDOM, 0));
 	if (error) {
 		device_printf(sc->sc_dev, "uvm_map failed with %d\n", error);
 		uao_detach(track->uobj);	/* release reference */
 		goto abort;
+	}
 	error = uvm_map_pageable(kernel_map, vstart, vstart + newvsize,
 	    false, 0);
 	if (error) {
 		device_printf(sc->sc_dev, "uvm_map_pageable failed with %d\n",
 		    error);
 		uvm_unmap(kernel_map, vstart, vstart + newvsize);
 		/* uvm_unmap also detach uobj */
 		goto abort;
+	}
 	track->usrbuf.mem = (void *)vstart;
 	track->usrbuf.capacity = newbufsize;
 	memset(track->usrbuf.mem, 0, newvsize);
 	return 0;
 	/* failure */
 abort:
 	track->uobj = NULL;		/* paranoia */
 	track->usrbuf.mem = NULL;
 	track->usrbuf.capacity = 0;
 	return error;
+}
 /*
  * Free usrbuf (if available).
  */
 static void
 audio_free_usrbuf(audio_track_t *track)
+{
 	vaddr_t vstart;
 	vsize_t vsize;
 	vstart = (vaddr_t)track->usrbuf.mem;
 	vsize = roundup2(MAX(track->usrbuf.capacity, PAGE_SIZE), PAGE_SIZE);
 	if (track->usrbuf.mem != NULL) {
 		/*
 		 * Unmap the kernel mapping.  uvm_unmap releases the
 		 * reference to the uvm object, and this should be the
 		 * last virtual mapping of the uvm object, so no need
 		 * to explicitly release (`detach') the object.
 		 */
 		uvm_unmap(kernel_map, vstart, vstart + vsize);
 		track->uobj = NULL;
 		track->usrbuf.mem = NULL;
 		track->usrbuf.capacity = 0;
+	}
+}
 /*
  * This filter changes the volume for each channel.
  * arg->context points track->ch_volume[].
  */
 static void
 audio_track_chvol(audio_filter_arg_t *arg)
+{
 	int16_t *ch_volume;
 	const aint_t *s;
 	aint_t *d;
 	u_int i;
 	u_int ch;
 	u_int channels;
 	DIAGNOSTIC_filter_arg(arg);
 	KASSERT(arg->srcfmt->channels == arg->dstfmt->channels);
 	KASSERT(arg->context != NULL);
 	KASSERT(arg->srcfmt->channels <= AUDIO_MAX_CHANNELS);
 	s = arg->src;
 	d = arg->dst;
 	ch_volume = arg->context;
 	channels = arg->srcfmt->channels;
 	for (i = 0; i < arg->count; i++) {
 		for (ch = 0; ch < channels; ch++) {
 			aint2_t val;
 			val = *s++;
 			val = AUDIO_SCALEDOWN(val * ch_volume[ch], 8);
 			*d++ = (aint_t)val;
+		}
+	}
+}
 /*
  * This filter performs conversion from stereo (or more channels) to mono.
  */
 static void
 audio_track_chmix_mixLR(audio_filter_arg_t *arg)
+{
 	const aint_t *s;
 	aint_t *d;
 	u_int i;
 	DIAGNOSTIC_filter_arg(arg);
 	s = arg->src;
 	d = arg->dst;
 	for (i = 0; i < arg->count; i++) {
 		*d++ = AUDIO_SCALEDOWN(s[0], 1) + AUDIO_SCALEDOWN(s[1], 1);
 		s += arg->srcfmt->channels;
+	}
+}
 /*
  * This filter performs conversion from mono to stereo (or more channels).
  */
 static void
 audio_track_chmix_dupLR(audio_filter_arg_t *arg)
+{
 	const aint_t *s;
 	aint_t *d;
 	u_int i;
 	u_int ch;
 	u_int dstchannels;
 	DIAGNOSTIC_filter_arg(arg);
 	s = arg->src;
 	d = arg->dst;
 	dstchannels = arg->dstfmt->channels;
 	for (i = 0; i < arg->count; i++) {
 		d[0] = s[0];
 		d[1] = s[0];
 		s++;
 		d += dstchannels;
+	}
 	if (dstchannels > 2) {
 		d = arg->dst;
 		for (i = 0; i < arg->count; i++) {
 			for (ch = 2; ch < dstchannels; ch++) {
 				d[ch] = 0;
+			}
 			d += dstchannels;
+		}
+	}
+}
 /*
  * This filter shrinks M channels into N channels.
  * Extra channels are discarded.
  */
 static void
 audio_track_chmix_shrink(audio_filter_arg_t *arg)
+{
 	const aint_t *s;
 	aint_t *d;
 	u_int i;
 	u_int ch;
 	DIAGNOSTIC_filter_arg(arg);
 	s = arg->src;
 	d = arg->dst;
 	for (i = 0; i < arg->count; i++) {
 		for (ch = 0; ch < arg->dstfmt->channels; ch++) {
 			*d++ = s[ch];
+		}
 		s += arg->srcfmt->channels;
+	}
+}
 /*
  * This filter expands M channels into N channels.
  * Silence is inserted for missing channels.
  */
 static void
 audio_track_chmix_expand(audio_filter_arg_t *arg)
+{
 	const aint_t *s;
 	aint_t *d;
 	u_int i;
 	u_int ch;
 	u_int srcchannels;
 	u_int dstchannels;
 	DIAGNOSTIC_filter_arg(arg);
 	s = arg->src;
 	d = arg->dst;
 	srcchannels = arg->srcfmt->channels;
 	dstchannels = arg->dstfmt->channels;
 	for (i = 0; i < arg->count; i++) {
 		for (ch = 0; ch < srcchannels; ch++) {
 			*d++ = *s++;
+		}
 		for (; ch < dstchannels; ch++) {
 			*d++ = 0;
+		}
+	}
+}
 /*
  * This filter performs frequency conversion (up sampling).
  * It uses linear interpolation.
  */
 static void
 audio_track_freq_up(audio_filter_arg_t *arg)
+{
 	audio_track_t *track;
 	audio_ring_t *src;
 	audio_ring_t *dst;
 	const aint_t *s;
 	aint_t *d;
 	aint_t prev[AUDIO_MAX_CHANNELS];
 	aint_t curr[AUDIO_MAX_CHANNELS];
 	aint_t grad[AUDIO_MAX_CHANNELS];
 	u_int i;
 	u_int t;
 	u_int step;
 	u_int channels;
 	u_int ch;
 	int srcused;
 	track = arg->context;
 	KASSERT(track);
 	src = &track->freq.srcbuf;
 	dst = track->freq.dst;
 	DIAGNOSTIC_ring(dst);
 	DIAGNOSTIC_ring(src);
 	KASSERT(src->used > 0);
 	KASSERT(src->fmt.channels == dst->fmt.channels);
 	KASSERT(src->head % track->mixer->frames_per_block == 0);
 	s = arg->src;
 	d = arg->dst;
 	/*
 	 * In order to faciliate interpolation for each block, slide (delay)
 	 * input by one sample.  As a result, strictly speaking, the output
 	 * phase is delayed by 1/dstfreq.  However, I believe there is no
 	 * observable impact.
+	 *
 	 * Example)
 	 * srcfreq:dstfreq = 1:3
+	 *
 	 *  A - -
 	 *  |
 	 *  |
 	 *  |     B - -
 	 *  +-----+-----> input timeframe
 	 *  0     1
+	 *
 	 *  0     1
 	 *  +-----+-----> input timeframe
 	 *  |     A
 	 *  |   x   x
 	 *  | x       x
 	 *  x          (B)
 	 *  +-+-+-+-+-+-> output timeframe
 	 *  0 1 2 3 4 5
 	 */
 	/* Last samples in previous block */
 	channels = src->fmt.channels;
 	for (ch = 0; ch < channels; ch++) {
 		prev[ch] = track->freq_prev[ch];
 		curr[ch] = track->freq_curr[ch];
 		grad[ch] = curr[ch] - prev[ch];
+	}
 	step = track->freq_step;
 	t = track->freq_current;
 //#define FREQ_DEBUG
 #if defined(FREQ_DEBUG)
 #define PRINTF(fmt...)	printf(fmt)
 #else
 #define PRINTF(fmt...)	do { } while (0)
 #endif
 	srcused = src->used;
 	PRINTF("upstart step=%d leap=%d", step, track->freq_leap);
 	PRINTF(" srcused=%d arg->count=%u", src->used, arg->count);
 	PRINTF(" prev=%d curr=%d grad=%d", prev[0], curr[0], grad[0]);
 	PRINTF(" t=%d\n", t);
 	for (i = 0; i < arg->count; i++) {
 		PRINTF("i=%d t=%5d", i, t);
 		if (t >= 65536) {
 			for (ch = 0; ch < channels; ch++) {
 				prev[ch] = curr[ch];
 				curr[ch] = *s++;
 				grad[ch] = curr[ch] - prev[ch];
+			}
 			PRINTF(" prev=%d s[%d]=%d",
 			    prev[0], src->used - srcused, curr[0]);
 			/* Update */
 			t -= 65536;
 			srcused--;
 			if (srcused < 0) {
 				PRINTF(" break\n");
 				break;
+			}
+		}
 		for (ch = 0; ch < channels; ch++) {
 			*d++ = prev[ch] + (aint2_t)grad[ch] * t / 65536;
 #if defined(FREQ_DEBUG)
 			if (ch == 0)
 				printf(" t=%5d *d=%d", t, d[-1]);
 #endif
+		}
 		t += step;
 		PRINTF("\n");
+	}
 	PRINTF("end prev=%d curr=%d\n", prev[0], curr[0]);
 	auring_take(src, src->used);
 	auring_push(dst, i);
 	/* Adjust */
 	t += track->freq_leap;
 	track->freq_current = t;
 	for (ch = 0; ch < channels; ch++) {
 		track->freq_prev[ch] = prev[ch];
 		track->freq_curr[ch] = curr[ch];
+	}
+}
 /*
  * This filter performs frequency conversion (down sampling).
  * It uses simple thinning.
  */
 static void
 audio_track_freq_down(audio_filter_arg_t *arg)
+{
 	audio_track_t *track;
 	audio_ring_t *src;
 	audio_ring_t *dst;
 	const aint_t *s0;
 	aint_t *d;
 	u_int i;
 	u_int t;
 	u_int step;
 	u_int ch;
 	u_int channels;
 	track = arg->context;
 	KASSERT(track);
 	src = &track->freq.srcbuf;
 	dst = track->freq.dst;
 	DIAGNOSTIC_ring(dst);
 	DIAGNOSTIC_ring(src);
 	KASSERT(src->used > 0);
 	KASSERT(src->fmt.channels == dst->fmt.channels);
 	KASSERTMSG(src->head % track->mixer->frames_per_block == 0,
 	    "src->head=%d fpb=%d",
 	    src->head, track->mixer->frames_per_block);
 	s0 = arg->src;
 	d = arg->dst;
 	t = track->freq_current;
 	step = track->freq_step;
 	channels = dst->fmt.channels;
 	PRINTF("downstart step=%d leap=%d", step, track->freq_leap);
 	PRINTF(" srcused=%d arg->count=%u", src->used, arg->count);
 	PRINTF(" t=%d\n", t);
 	for (i = 0; i < arg->count && t / 65536 < src->used; i++) {
 		const aint_t *s;
 		PRINTF("i=%4d t=%10d", i, t);
 		s = s0 + (t / 65536) * channels;
 		PRINTF(" s=%5ld", (s - s0) / channels);
 		for (ch = 0; ch < channels; ch++) {
 			if (ch == 0) PRINTF(" *s=%d", s[ch]);
 			*d++ = s[ch];
+		}
 		PRINTF("\n");
 		t += step;
+	}
 	t += track->freq_leap;
 	PRINTF("end t=%d\n", t);
 	auring_take(src, src->used);
 	auring_push(dst, i);
 	track->freq_current = t % 65536;
+}
 /*
  * Creates track and returns it.
  */
 audio_track_t *
 audio_track_create(struct audio_softc *sc, audio_trackmixer_t *mixer)
+{
 	audio_track_t *track;
 	static int newid = 0;
 	track = kmem_zalloc(sizeof(*track), KM_SLEEP);
 	track->id = newid++;
 	track->mixer = mixer;
 	track->mode = mixer->mode;
 	/* Do TRACE after id is assigned. */
 	TRACET(3, track, "for %s",
 	    mixer->mode == AUMODE_PLAY ? "playback" : "recording");
 #if defined(AUDIO_SUPPORT_TRACK_VOLUME)
 	track->volume = 256;
 #endif
 	for (int i = 0; i < AUDIO_MAX_CHANNELS; i++) {
 		track->ch_volume[i] = 256;
+	}
 	return track;
+}
 /*
  * Release all resources of the track and track itself.
  * track must not be NULL.  Don't specify the track within the file
  * structure linked from sc->sc_files.
  */
 static void
 audio_track_destroy(audio_track_t *track)
+{
 	KASSERT(track);
 	audio_free_usrbuf(track);
 	audio_free(track->codec.srcbuf.mem);
 	audio_free(track->chvol.srcbuf.mem);
 	audio_free(track->chmix.srcbuf.mem);
 	audio_free(track->freq.srcbuf.mem);
 	audio_free(track->outbuf.mem);
 	kmem_free(track, sizeof(*track));
+}
 /*
  * It returns encoding conversion filter according to src and dst format.
  * If it is not a convertible pair, it returns NULL.  Either src or dst
  * must be internal format.
  */
 static audio_filter_t
 audio_track_get_codec(audio_track_t *track, const audio_format2_t *src,
 	const audio_format2_t *dst)
+{
 	if (audio_format2_is_internal(src)) {
 		if (dst->encoding == AUDIO_ENCODING_ULAW) {
 			return audio_internal_to_mulaw;
 		} else if (dst->encoding == AUDIO_ENCODING_ALAW) {
 			return audio_internal_to_alaw;
 		} else if (audio_format2_is_linear(dst)) {
 			switch (dst->stride) {
 			case 8:
 				return audio_internal_to_linear8;
 			case 16:
 				return audio_internal_to_linear16;
 #if defined(AUDIO_SUPPORT_LINEAR24)
 			case 24:
 				return audio_internal_to_linear24;
 #endif
 			case 32:
 				return audio_internal_to_linear32;
 			default:
 				TRACET(1, track, "unsupported %s stride %d",
 				    "dst", dst->stride);
 				goto abort;
+			}
+		}
 	} else if (audio_format2_is_internal(dst)) {
 		if (src->encoding == AUDIO_ENCODING_ULAW) {
 			return audio_mulaw_to_internal;
 		} else if (src->encoding == AUDIO_ENCODING_ALAW) {
 			return audio_alaw_to_internal;
 		} else if (audio_format2_is_linear(src)) {
 			switch (src->stride) {
 			case 8:
 				return audio_linear8_to_internal;
 			case 16:
 				return audio_linear16_to_internal;
 #if defined(AUDIO_SUPPORT_LINEAR24)
 			case 24:
 				return audio_linear24_to_internal;
 #endif
 			case 32:
 				return audio_linear32_to_internal;
 			default:
 				TRACET(1, track, "unsupported %s stride %d",
 				    "src", src->stride);
 				goto abort;
+			}
+		}
+	}
 	TRACET(1, track, "unsupported encoding");
 abort:
 #if defined(AUDIO_DEBUG)
 	if (audiodebug >= 2) {
 		char buf[100];
 		audio_format2_tostr(buf, sizeof(buf), src);
 		TRACET(2, track, "src %s", buf);
 		audio_format2_tostr(buf, sizeof(buf), dst);
 		TRACET(2, track, "dst %s", buf);
+	}
 #endif
 	return NULL;
+}
 /*
  * Initialize the codec stage of this track as necessary.
  * If successful, it initializes the codec stage as necessary, stores updated
  * last_dst in *last_dstp in any case, and returns 0.
  * Otherwise, it returns errno without modifying *last_dstp.
  */
 static int
 audio_track_init_codec(audio_track_t *track, audio_ring_t **last_dstp)
+{
 	struct audio_softc *sc;
 	audio_ring_t *last_dst;
 	audio_ring_t *srcbuf;
 	audio_format2_t *srcfmt;
 	audio_format2_t *dstfmt;
 	audio_filter_arg_t *arg;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	last_dst = *last_dstp;
 	dstfmt = &last_dst->fmt;
 	srcfmt = &track->inputfmt;
 	srcbuf = &track->codec.srcbuf;
 	error = 0;
 	if (srcfmt->encoding != dstfmt->encoding
 	 || srcfmt->precision != dstfmt->precision
 	 || srcfmt->stride != dstfmt->stride) {
 		track->codec.dst = last_dst;
 		srcbuf->fmt = *dstfmt;
 		srcbuf->fmt.encoding = srcfmt->encoding;
 		srcbuf->fmt.precision = srcfmt->precision;
 		srcbuf->fmt.stride = srcfmt->stride;
 		track->codec.filter = audio_track_get_codec(track,
 		    &srcbuf->fmt, dstfmt);
 		if (track->codec.filter == NULL) {
 			error = EINVAL;
 			goto abort;
+		}
 		srcbuf->head = 0;
 		srcbuf->used = 0;
 		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
 		len = auring_bytelen(srcbuf);
 		srcbuf->mem = audio_realloc(srcbuf->mem, len);
 		if (srcbuf->mem == NULL) {
 			device_printf(sc->sc_dev, "%s: malloc(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 		arg = &track->codec.arg;
 		arg->srcfmt = &srcbuf->fmt;
 		arg->dstfmt = dstfmt;
 		arg->context = NULL;
 		*last_dstp = srcbuf;
 		return 0;
+	}
 abort:
 	track->codec.filter = NULL;
 	audio_free(srcbuf->mem);
 	return error;
+}
 /*
  * Initialize the chvol stage of this track as necessary.
  * If successful, it initializes the chvol stage as necessary, stores updated
  * last_dst in *last_dstp in any case, and returns 0.
  * Otherwise, it returns errno without modifying *last_dstp.
  */
 static int
 audio_track_init_chvol(audio_track_t *track, audio_ring_t **last_dstp)
+{
 	struct audio_softc *sc;
 	audio_ring_t *last_dst;
 	audio_ring_t *srcbuf;
 	audio_format2_t *srcfmt;
 	audio_format2_t *dstfmt;
 	audio_filter_arg_t *arg;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	last_dst = *last_dstp;
 	dstfmt = &last_dst->fmt;
 	srcfmt = &track->inputfmt;
 	srcbuf = &track->chvol.srcbuf;
 	error = 0;
 	/* Check whether channel volume conversion is necessary. */
 	bool use_chvol = false;
 	for (int ch = 0; ch < srcfmt->channels; ch++) {
 		if (track->ch_volume[ch] != 256) {
 			use_chvol = true;
 			break;
+		}
+	}
 	if (use_chvol == true) {
 		track->chvol.dst = last_dst;
 		track->chvol.filter = audio_track_chvol;
 		srcbuf->fmt = *dstfmt;
 		/* no format conversion occurs */
 		srcbuf->head = 0;
 		srcbuf->used = 0;
 		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
 		len = auring_bytelen(srcbuf);
 		srcbuf->mem = audio_realloc(srcbuf->mem, len);
 		if (srcbuf->mem == NULL) {
 			device_printf(sc->sc_dev, "%s: malloc(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 		arg = &track->chvol.arg;
 		arg->srcfmt = &srcbuf->fmt;
 		arg->dstfmt = dstfmt;
 		arg->context = track->ch_volume;
 		*last_dstp = srcbuf;
 		return 0;
+	}
 abort:
 	track->chvol.filter = NULL;
 	audio_free(srcbuf->mem);
 	return error;
+}
 /*
  * Initialize the chmix stage of this track as necessary.
  * If successful, it initializes the chmix stage as necessary, stores updated
  * last_dst in *last_dstp in any case, and returns 0.
  * Otherwise, it returns errno without modifying *last_dstp.
  */
 static int
 audio_track_init_chmix(audio_track_t *track, audio_ring_t **last_dstp)
+{
 	struct audio_softc *sc;
 	audio_ring_t *last_dst;
 	audio_ring_t *srcbuf;
 	audio_format2_t *srcfmt;
 	audio_format2_t *dstfmt;
 	audio_filter_arg_t *arg;
 	u_int srcch;
 	u_int dstch;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	last_dst = *last_dstp;
 	dstfmt = &last_dst->fmt;
 	srcfmt = &track->inputfmt;
 	srcbuf = &track->chmix.srcbuf;
 	error = 0;
 	srcch = srcfmt->channels;
 	dstch = dstfmt->channels;
 	if (srcch != dstch) {
 		track->chmix.dst = last_dst;
 		if (srcch >= 2 && dstch == 1) {
 			track->chmix.filter = audio_track_chmix_mixLR;
 		} else if (srcch == 1 && dstch >= 2) {
 			track->chmix.filter = audio_track_chmix_dupLR;
 		} else if (srcch > dstch) {
 			track->chmix.filter = audio_track_chmix_shrink;
 		} else {
 			track->chmix.filter = audio_track_chmix_expand;
+		}
 		srcbuf->fmt = *dstfmt;
 		srcbuf->fmt.channels = srcch;
 		srcbuf->head = 0;
 		srcbuf->used = 0;
 		/* XXX The buffer size should be able to calculate. */
 		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
 		len = auring_bytelen(srcbuf);
 		srcbuf->mem = audio_realloc(srcbuf->mem, len);
 		if (srcbuf->mem == NULL) {
 			device_printf(sc->sc_dev, "%s: malloc(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 		arg = &track->chmix.arg;
 		arg->srcfmt = &srcbuf->fmt;
 		arg->dstfmt = dstfmt;
 		arg->context = NULL;
 		*last_dstp = srcbuf;
 		return 0;
+	}
 abort:
 	track->chmix.filter = NULL;
 	audio_free(srcbuf->mem);
 	return error;
+}
 /*
  * Initialize the freq stage of this track as necessary.
  * If successful, it initializes the freq stage as necessary, stores updated
  * last_dst in *last_dstp in any case, and returns 0.
  * Otherwise, it returns errno without modifying *last_dstp.
  */
 static int
 audio_track_init_freq(audio_track_t *track, audio_ring_t **last_dstp)
+{
 	struct audio_softc *sc;
 	audio_ring_t *last_dst;
 	audio_ring_t *srcbuf;
 	audio_format2_t *srcfmt;
 	audio_format2_t *dstfmt;
 	audio_filter_arg_t *arg;
 	uint32_t srcfreq;
 	uint32_t dstfreq;
 	u_int dst_capacity;
 	u_int mod;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	last_dst = *last_dstp;
 	dstfmt = &last_dst->fmt;
 	srcfmt = &track->inputfmt;
 	srcbuf = &track->freq.srcbuf;
 	error = 0;
 	srcfreq = srcfmt->sample_rate;
 	dstfreq = dstfmt->sample_rate;
 	if (srcfreq != dstfreq) {
 		track->freq.dst = last_dst;
 		memset(track->freq_prev, 0, sizeof(track->freq_prev));
 		memset(track->freq_curr, 0, sizeof(track->freq_curr));
 		/* freq_step is the ratio of src/dst when let dst 65536. */
 		track->freq_step = (uint64_t)srcfreq * 65536 / dstfreq;
 		dst_capacity = frame_per_block(track->mixer, dstfmt);
 		mod = (uint64_t)srcfreq * 65536 % dstfreq;
 		track->freq_leap = (mod * dst_capacity + dstfreq / 2) / dstfreq;
 		if (track->freq_step < 65536) {
 			track->freq.filter = audio_track_freq_up;
 			/* In order to carry at the first time. */
 			track->freq_current = 65536;
 		} else {
 			track->freq.filter = audio_track_freq_down;
 			track->freq_current = 0;
+		}
 		srcbuf->fmt = *dstfmt;
 		srcbuf->fmt.sample_rate = srcfreq;
 		srcbuf->head = 0;
 		srcbuf->used = 0;
 		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
 		len = auring_bytelen(srcbuf);
 		srcbuf->mem = audio_realloc(srcbuf->mem, len);
 		if (srcbuf->mem == NULL) {
 			device_printf(sc->sc_dev, "%s: malloc(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 		arg = &track->freq.arg;
 		arg->srcfmt = &srcbuf->fmt;
 		arg->dstfmt = dstfmt;/*&last_dst->fmt;*/
 		arg->context = track;
 		*last_dstp = srcbuf;
 		return 0;
+	}
 abort:
 	track->freq.filter = NULL;
 	audio_free(srcbuf->mem);
 	return error;
+}
 /*
  * When playing back: (e.g. if codec and freq stage are valid)
+ *
  *               write
  *                | uiomove
  *                v
  *  usrbuf      [...............]  byte ring buffer (mmap-able)
  *                | memcpy
  *                v
  *  codec.srcbuf[....]             1 block (ring) buffer   <-- stage input
  *       .dst ----+
  *                | convert
  *                v
  *  freq.srcbuf [....]             1 block (ring) buffer
  *      .dst  ----+
  *                | convert
  *                v
  *  outbuf      [...............]  NBLKOUT blocks ring buffer
+ *
+ *
  * When recording:
+ *
  *  freq.srcbuf [...............]  NBLKOUT blocks ring buffer <-- stage input
  *      .dst  ----+
  *                | convert
  *                v
  *  codec.srcbuf[.....]            1 block (ring) buffer
  *       .dst ----+
  *                | convert
  *                v
  *  outbuf      [.....]            1 block (ring) buffer
  *                | memcpy
  *                v
  *  usrbuf      [...............]  byte ring buffer (mmap-able *)
  *                | uiomove
  *                v
  *               read
+ *
  *    *: usrbuf for recording is also mmap-able due to symmetry with
  *       playback buffer, but for now mmap will never happen for recording.
  */
 /*
  * Set the userland format of this track.
  * usrfmt argument should be parameter verified with audio_check_params().
  * It will release and reallocate all internal conversion buffers.
  * It returns 0 if successful.  Otherwise it returns errno with clearing all
  * internal buffers.
  * It must be called without sc_intr_lock since uvm_* routines require non
  * intr_lock state.
  * It must be called with track lock held since it may release and reallocate
  * outbuf.
  */
 static int
 audio_track_set_format(audio_track_t *track, audio_format2_t *usrfmt)
+{
 	struct audio_softc *sc;
 	u_int newbufsize;
 	u_int oldblksize;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	/* usrbuf is the closest buffer to the userland. */
 	track->usrbuf.fmt = *usrfmt;
 	/*
 	 * For references, one block size (in 40msec) is:
 	 *  320 bytes    = 204 blocks/64KB for mulaw/8kHz/1ch
 	 *  7680 bytes   = 8 blocks/64KB for s16/48kHz/2ch
 	 *  30720 bytes  = 90 KB/3blocks for s16/48kHz/8ch
 	 *  61440 bytes  = 180 KB/3blocks for s16/96kHz/8ch
 	 *  245760 bytes = 720 KB/3blocks for s32/192kHz/8ch
+	 *
 	 * For example,
 	 * 1) If usrbuf_blksize = 7056 (s16/44.1k/2ch) and PAGE_SIZE = 8192,
 	 *     newbufsize = rounddown(65536 / 7056) = 63504
 	 *     newvsize = roundup2(63504, PAGE_SIZE) = 65536
 	 *    Therefore it maps 8 * 8K pages and usrbuf->capacity = 63504.
+	 *
 	 * 2) If usrbuf_blksize = 7680 (s16/48k/2ch) and PAGE_SIZE = 4096,
 	 *     newbufsize = rounddown(65536 / 7680) = 61440
 	 *     newvsize = roundup2(61440, PAGE_SIZE) = 61440 (= 15 pages)
 	 *    Therefore it maps 15 * 4K pages and usrbuf->capacity = 61440.
 	 */
 	oldblksize = track->usrbuf_blksize;
 	track->usrbuf_blksize = frametobyte(&track->usrbuf.fmt,
 	    frame_per_block(track->mixer, &track->usrbuf.fmt));
 	track->usrbuf.head = 0;
 	track->usrbuf.used = 0;
 	newbufsize = MAX(track->usrbuf_blksize * AUMINNOBLK, 65536);
 	newbufsize = rounddown(newbufsize, track->usrbuf_blksize);
 	error = audio_realloc_usrbuf(track, newbufsize);
 	if (error) {
 		device_printf(sc->sc_dev, "malloc usrbuf(%d) failed\n",
 		    newbufsize);
 		goto error;
+	}
 	/* Recalc water mark. */
 	if (track->usrbuf_blksize != oldblksize) {
 		if (audio_track_is_playback(track)) {
 			/* Set high at 100%, low at 75%.  */
 			track->usrbuf_usedhigh = track->usrbuf.capacity;
 			track->usrbuf_usedlow = track->usrbuf.capacity * 3 / 4;
 		} else {
 			/* Set high at 100% minus 1block(?), low at 0% */
 			track->usrbuf_usedhigh = track->usrbuf.capacity -
 			    track->usrbuf_blksize;
 			track->usrbuf_usedlow = 0;
+		}
+	}
 	/* Stage buffer */
 	audio_ring_t *last_dst = &track->outbuf;
 	if (audio_track_is_playback(track)) {
 		/* On playback, initialize from the mixer side in order. */
 		track->inputfmt = *usrfmt;
 		track->outbuf.fmt =  track->mixer->track_fmt;
 		if ((error = audio_track_init_freq(track, &last_dst)) != 0)
 			goto error;
 		if ((error = audio_track_init_chmix(track, &last_dst)) != 0)
 			goto error;
 		if ((error = audio_track_init_chvol(track, &last_dst)) != 0)
 			goto error;
 		if ((error = audio_track_init_codec(track, &last_dst)) != 0)
 			goto error;
 	} else {
 		/* On recording, initialize from userland side in order. */
 		track->inputfmt = track->mixer->track_fmt;
 		track->outbuf.fmt = *usrfmt;
 		if ((error = audio_track_init_codec(track, &last_dst)) != 0)
 			goto error;
 		if ((error = audio_track_init_chvol(track, &last_dst)) != 0)
 			goto error;
 		if ((error = audio_track_init_chmix(track, &last_dst)) != 0)
 			goto error;
 		if ((error = audio_track_init_freq(track, &last_dst)) != 0)
 			goto error;
+	}
 #if 0
 	/* debug */
 	if (track->freq.filter) {
 		audio_print_format2("freq src", &track->freq.srcbuf.fmt);
 		audio_print_format2("freq dst", &track->freq.dst->fmt);
+	}
 	if (track->chmix.filter) {
 		audio_print_format2("chmix src", &track->chmix.srcbuf.fmt);
 		audio_print_format2("chmix dst", &track->chmix.dst->fmt);
+	}
 	if (track->chvol.filter) {
 		audio_print_format2("chvol src", &track->chvol.srcbuf.fmt);
 		audio_print_format2("chvol dst", &track->chvol.dst->fmt);
+	}
 	if (track->codec.filter) {
 		audio_print_format2("codec src", &track->codec.srcbuf.fmt);
 		audio_print_format2("codec dst", &track->codec.dst->fmt);
+	}
 #endif
 	/* Stage input buffer */
 	track->input = last_dst;
 	/*
 	 * On the recording track, make the first stage a ring buffer.
 	 * XXX is there a better way?
 	 */
 	if (audio_track_is_record(track)) {
 		track->input->capacity = NBLKOUT *
 		    frame_per_block(track->mixer, &track->input->fmt);
 		len = auring_bytelen(track->input);
 		track->input->mem = audio_realloc(track->input->mem, len);
 		if (track->input->mem == NULL) {
 			device_printf(sc->sc_dev, "malloc input(%d) failed\n",
 			    len);
 			error = ENOMEM;
 			goto error;
+	}
 	/*
 	 * Output buffer.
 	 * On the playback track, its capacity is NBLKOUT blocks.
 	 * On the recording track, its capacity is 1 block.
 	 */
 	track->outbuf.head = 0;
 	track->outbuf.used = 0;
 	track->outbuf.capacity = frame_per_block(track->mixer,
 	    &track->outbuf.fmt);
 	if (audio_track_is_playback(track))
 		track->outbuf.capacity *= NBLKOUT;
 	len = auring_bytelen(&track->outbuf);
 	track->outbuf.mem = audio_realloc(track->outbuf.mem, len);
 	if (track->outbuf.mem == NULL) {
 		device_printf(sc->sc_dev, "malloc outbuf(%d) failed\n", len);
 		error = ENOMEM;
 		goto error;
+	}
 #if defined(AUDIO_DEBUG)
 	if (audiodebug >= 3) {
 		struct audio_track_debugbuf m;
 		memset(&m, 0, sizeof(m));
 		snprintf(m.outbuf, sizeof(m.outbuf), " out=%d",
 		    track->outbuf.capacity * frametobyte(&track->outbuf.fmt,1));
 		if (track->freq.filter)
 			snprintf(m.freq, sizeof(m.freq), " freq=%d",
 			    track->freq.srcbuf.capacity *
 			    frametobyte(&track->freq.srcbuf.fmt, 1));
 		if (track->chmix.filter)
 			snprintf(m.chmix, sizeof(m.chmix), " chmix=%d",
 			    track->chmix.srcbuf.capacity *
 			    frametobyte(&track->chmix.srcbuf.fmt, 1));
 		if (track->chvol.filter)
 			snprintf(m.chvol, sizeof(m.chvol), " chvol=%d",
 			    track->chvol.srcbuf.capacity *
 			    frametobyte(&track->chvol.srcbuf.fmt, 1));
 		if (track->codec.filter)
 			snprintf(m.codec, sizeof(m.codec), " codec=%d",
 			    track->codec.srcbuf.capacity *
 			    frametobyte(&track->codec.srcbuf.fmt, 1));
 		snprintf(m.usrbuf, sizeof(m.usrbuf),
 		    " usr=%d", track->usrbuf.capacity);
 		if (audio_track_is_playback(track)) {
 			TRACET(0, track, "bufsize%s%s%s%s%s%s",
 			    m.outbuf, m.freq, m.chmix,
 			    m.chvol, m.codec, m.usrbuf);
 		} else {
 			TRACET(0, track, "bufsize%s%s%s%s%s%s",
 			    m.freq, m.chmix, m.chvol,
 			    m.codec, m.outbuf, m.usrbuf);
+		}
+	}
 #endif
 	return 0;
 error:
 	audio_free_usrbuf(track);
 	audio_free(track->codec.srcbuf.mem);
 	audio_free(track->chvol.srcbuf.mem);
 	audio_free(track->chmix.srcbuf.mem);
 	audio_free(track->freq.srcbuf.mem);
 	audio_free(track->outbuf.mem);
 	return error;
+}
 /*
  * Fill silence frames (as the internal format) up to 1 block
  * if the ring is not empty and less than 1 block.
  * It returns the number of appended frames.
  */
 static int
 audio_append_silence(audio_track_t *track, audio_ring_t *ring)
+{
 	int fpb;
 	int n;
 	KASSERT(track);
 	KASSERT(audio_format2_is_internal(&ring->fmt));
 	/* XXX is n correct? */
 	/* XXX memset uses frametobyte()? */
 	if (ring->used == 0)
 		return 0;
 	fpb = frame_per_block(track->mixer, &ring->fmt);
 	if (ring->used >= fpb)
 		return 0;
 	n = (ring->capacity - ring->used) % fpb;
 	KASSERT(auring_get_contig_free(ring) >= n);
 	memset(auring_tailptr_aint(ring), 0,
 	    n * ring->fmt.channels * sizeof(aint_t));
 	auring_push(ring, n);
 	return n;
+}
 /*
  * Execute the conversion stage.
  * It prepares arg from this stage and executes stage->filter.
  * It must be called only if stage->filter is not NULL.
+ *
  * For stages other than frequency conversion, the function increments
  * src and dst counters here.  For frequency conversion stage, on the
  * other hand, the function does not touch src and dst counters and
  * filter side has to increment them.
  */
 static void
 audio_apply_stage(audio_track_t *track, audio_stage_t *stage, bool isfreq)
+{
 	audio_filter_arg_t *arg;
 	int srccount;
 	int dstcount;
 	int count;
 	KASSERT(track);
 	KASSERT(stage->filter);
 	srccount = auring_get_contig_used(&stage->srcbuf);
 	dstcount = auring_get_contig_free(stage->dst);
 	if (isfreq) {
 		KASSERTMSG(srccount > 0, "freq but srccount == %d", srccount);
 		count = uimin(dstcount, track->mixer->frames_per_block);
 	} else {
 		count = uimin(srccount, dstcount);
+	}
 	if (count > 0) {
 		arg = &stage->arg;
 		arg->src = auring_headptr(&stage->srcbuf);
 		arg->dst = auring_tailptr(stage->dst);
 		arg->count = count;
 		stage->filter(arg);
 		if (!isfreq) {
 			auring_take(&stage->srcbuf, count);
 			auring_push(stage->dst, count);
+		}
+	}
+}
 /*
  * Produce output buffer for playback from user input buffer.
  * It must be called only if usrbuf is not empty and outbuf is
  * available at least one free block.
  */
 static void
 audio_track_play(audio_track_t *track)
+{
 	audio_ring_t *usrbuf;
 	audio_ring_t *input;
 	int count;
 	int framesize;
 	int bytes;
 	KASSERT(track);
 	KASSERT(track->lock);
 	TRACET(4, track, "start pstate=%d", track->pstate);
 	/* At this point usrbuf must not be empty. */
 	KASSERT(track->usrbuf.used > 0);
 	/* Also, outbuf must be available at least one block. */
 	count = auring_get_contig_free(&track->outbuf);
 	KASSERTMSG(count >= frame_per_block(track->mixer, &track->outbuf.fmt),
 	    "count=%d fpb=%d",
 	    count, frame_per_block(track->mixer, &track->outbuf.fmt));
 	/* XXX TODO: is this necessary for now? */
 	int track_count_0 = track->outbuf.used;
 	usrbuf = &track->usrbuf;
 	input = track->input;
 	/*
 	 * framesize is always 1 byte or more since all formats supported as
 	 * usrfmt(=input) have 8bit or more stride.
 	 */
 	framesize = frametobyte(&input->fmt, 1);
 	KASSERT(framesize >= 1);
 	/* The next stage of usrbuf (=input) must be available. */
 	KASSERT(auring_get_contig_free(input) > 0);
 	/*
 	 * Copy usrbuf up to 1block to input buffer.
 	 * count is the number of frames to copy from usrbuf.
 	 * bytes is the number of bytes to copy from usrbuf.  However it is
 	 * not copied less than one frame.
 	 */
 	count = uimin(usrbuf->used, track->usrbuf_blksize) / framesize;
 	bytes = count * framesize;
 	track->usrbuf_stamp += bytes;
 	if (usrbuf->head + bytes < usrbuf->capacity) {
 		memcpy((uint8_t *)input->mem + auring_tail(input) * framesize,
 		    (uint8_t *)usrbuf->mem + usrbuf->head,
 		    bytes);
 		auring_push(input, count);
 		auring_take(usrbuf, bytes);
 	} else {
 		int bytes1;
 		int bytes2;
 		bytes1 = auring_get_contig_used(usrbuf);
 		KASSERT(bytes1 % framesize == 0);
 		memcpy((uint8_t *)input->mem + auring_tail(input) * framesize,
 		    (uint8_t *)usrbuf->mem + usrbuf->head,
 		    bytes1);
 		auring_push(input, bytes1 / framesize);
 		auring_take(usrbuf, bytes1);
 		bytes2 = bytes - bytes1;
 		memcpy((uint8_t *)input->mem + auring_tail(input) * framesize,
 		    (uint8_t *)usrbuf->mem + usrbuf->head,
 		    bytes2);
 		auring_push(input, bytes2 / framesize);
 		auring_take(usrbuf, bytes2);
+	}
 	/* Encoding conversion */
 	if (track->codec.filter)
 		audio_apply_stage(track, &track->codec, false);
 	/* Channel volume */
 	if (track->chvol.filter)
 		audio_apply_stage(track, &track->chvol, false);
 	/* Channel mix */
 	if (track->chmix.filter)
 		audio_apply_stage(track, &track->chmix, false);
 	/* Frequency conversion */
 	/*
 	 * Since the frequency conversion needs correction for each block,
 	 * it rounds up to 1 block.
 	 */
 	if (track->freq.filter) {
 		int n;
 		n = audio_append_silence(track, &track->freq.srcbuf);
 		if (n > 0) {
 			TRACET(4, track,
 			    "freq.srcbuf add silence %d -> %d/%d/%d",
 			    n,
 			    track->freq.srcbuf.head,
 			    track->freq.srcbuf.used,
 			    track->freq.srcbuf.capacity);
+		}
 		if (track->freq.srcbuf.used > 0) {
 			audio_apply_stage(track, &track->freq, true);
+		}
+	}
 	if (bytes < track->usrbuf_blksize) {
 		/*
 		 * Clear all conversion buffer pointer if the conversion was
 		 * not exactly one block.  These conversion stage buffers are
 		 * certainly circular buffers because of symmetry with the
 		 * previous and next stage buffer.  However, since they are
 		 * treated as simple contiguous buffers in operation, so head
 		 * always should point 0.  This may happen during drain-age.
 		 */
 		TRACET(4, track, "reset stage");
 		if (track->codec.filter) {
 			KASSERT(track->codec.srcbuf.used == 0);
 			track->codec.srcbuf.head = 0;
+		}
 		if (track->chvol.filter) {
 			KASSERT(track->chvol.srcbuf.used == 0);
 			track->chvol.srcbuf.head = 0;
+		}
 		if (track->chmix.filter) {
 			KASSERT(track->chmix.srcbuf.used == 0);
 			track->chmix.srcbuf.head = 0;
+		}
 		if (track->freq.filter) {
 			KASSERT(track->freq.srcbuf.used == 0);
 			track->freq.srcbuf.head = 0;
+		}
+	}
 	if (track->input == &track->outbuf) {
 		track->outputcounter = track->inputcounter;
 	} else {
 		track->outputcounter += track->outbuf.used - track_count_0;
+	}
 #if defined(AUDIO_DEBUG)
 	if (audiodebug >= 3) {
 		struct audio_track_debugbuf m;
 		audio_track_bufstat(track, &m);
 		TRACET(0, track, "end%s%s%s%s%s%s",
 		    m.outbuf, m.freq, m.chvol, m.chmix, m.codec, m.usrbuf);
+	}
 #endif
+}
 /*
  * Produce user output buffer for recording from input buffer.
  */
 static void
 audio_track_record(audio_track_t *track)
+{
 	audio_ring_t *outbuf;
 	audio_ring_t *usrbuf;
 	int count;
 	int bytes;
 	int framesize;
 	KASSERT(track);
 	KASSERT(track->lock);
 	/* Number of frames to process */
 	count = auring_get_contig_used(track->input);
 	count = uimin(count, track->mixer->frames_per_block);
 	if (count == 0) {
 		TRACET(4, track, "count == 0");
 		return;
+	}
 	/* Frequency conversion */
 	if (track->freq.filter) {
 		if (track->freq.srcbuf.used > 0) {
 			audio_apply_stage(track, &track->freq, true);
 			/* XXX should input of freq be from beginning of buf? */
+		}
+	}
 	/* Channel mix */
 	if (track->chmix.filter)
 		audio_apply_stage(track, &track->chmix, false);
 	/* Channel volume */
 	if (track->chvol.filter)
 		audio_apply_stage(track, &track->chvol, false);
 	/* Encoding conversion */
 	if (track->codec.filter)
 		audio_apply_stage(track, &track->codec, false);
 	/* Copy outbuf to usrbuf */
 	outbuf = &track->outbuf;
 	usrbuf = &track->usrbuf;
 	/*
 	 * framesize is always 1 byte or more since all formats supported
 	 * as usrfmt(=output) have 8bit or more stride.
 	 */
 	framesize = frametobyte(&outbuf->fmt, 1);
 	KASSERT(framesize >= 1);
 	/*
 	 * count is the number of frames to copy to usrbuf.
 	 * bytes is the number of bytes to copy to usrbuf.
 	 */
 	count = outbuf->used;
 	count = uimin(count,
 	    (track->usrbuf_usedhigh - usrbuf->used) / framesize);
 	bytes = count * framesize;
 	if (auring_tail(usrbuf) + bytes < usrbuf->capacity) {
 		memcpy((uint8_t *)usrbuf->mem + auring_tail(usrbuf),
 		    (uint8_t *)outbuf->mem + outbuf->head * framesize,
 		    bytes);
 		auring_push(usrbuf, bytes);
 		auring_take(outbuf, count);
 	} else {
 		int bytes1;
 		int bytes2;
 		bytes1 = auring_get_contig_free(usrbuf);
 		KASSERT(bytes1 % framesize == 0);
 		memcpy((uint8_t *)usrbuf->mem + auring_tail(usrbuf),
 		    (uint8_t *)outbuf->mem + outbuf->head * framesize,
 		    bytes1);
 		auring_push(usrbuf, bytes1);
 		auring_take(outbuf, bytes1 / framesize);
 		bytes2 = bytes - bytes1;
 		memcpy((uint8_t *)usrbuf->mem + auring_tail(usrbuf),
 		    (uint8_t *)outbuf->mem + outbuf->head * framesize,
 		    bytes2);
 		auring_push(usrbuf, bytes2);
 		auring_take(outbuf, bytes2 / framesize);
+	}
 	/* XXX TODO: any counters here? */
 #if defined(AUDIO_DEBUG)
 	if (audiodebug >= 3) {
 		struct audio_track_debugbuf m;
 		audio_track_bufstat(track, &m);
 		TRACET(0, track, "end%s%s%s%s%s%s",
 		    m.freq, m.chvol, m.chmix, m.codec, m.outbuf, m.usrbuf);
+	}
 #endif
+}
 /*
  * Calcurate blktime [msec] from mixer(.hwbuf.fmt).
  * Must be called with sc_lock held.
  */
 static u_int
 audio_mixer_calc_blktime(struct audio_softc *sc, audio_trackmixer_t *mixer)
+{
 	audio_format2_t *fmt;
 	u_int blktime;
 	u_int frames_per_block;
 	KASSERT(mutex_owned(sc->sc_lock));
 	fmt = &mixer->hwbuf.fmt;
 	blktime = sc->sc_blk_ms;
 	/*
 	 * If stride is not multiples of 8, special treatment is necessary.
 	 * For now, it is only x68k's vs(4), 4 bit/sample ADPCM.
 	 */
 	if (fmt->stride == 4) {
 		frames_per_block = fmt->sample_rate * blktime / 1000;
 		if ((frames_per_block & 1) != 0)
 			blktime *= 2;
+	}
 #ifdef DIAGNOSTIC
 	else if (fmt->stride % NBBY != 0) {
 		panic("unsupported HW stride %d", fmt->stride);
+	}
 #endif
 	return blktime;
+}
 /*
  * Initialize the mixer corresponding to the mode.
  * Set AUMODE_PLAY to the 'mode' for playback or AUMODE_RECORD for recording.
  * sc->sc_[pr]mixer (corresponding to the 'mode') must be zero-filled.
  * This function returns 0 on sucessful.  Otherwise returns errno.
  * Must be called with sc_lock held.
  */
 static int
 audio_mixer_init(struct audio_softc *sc, int mode,
 	const audio_format2_t *hwfmt, const audio_filter_reg_t *reg)
+{
 	char codecbuf[64];
 	audio_trackmixer_t *mixer;
 	void (*softint_handler)(void *);
 	int len;
 	int blksize;
 	int capacity;
 	size_t bufsize;
 	int hwblks;
 	int blkms;
 	int error;
 	KASSERT(hwfmt != NULL);
 	KASSERT(reg != NULL);
 	KASSERT(mutex_owned(sc->sc_lock));
 	error = 0;
 	if (mode == AUMODE_PLAY)
 		mixer = sc->sc_pmixer;
 	else
 		mixer = sc->sc_rmixer;
 	mixer->sc = sc;
 	mixer->mode = mode;
 	mixer->hwbuf.fmt = *hwfmt;
 	mixer->volume = 256;
 	mixer->blktime_d = 1000;
 	mixer->blktime_n = audio_mixer_calc_blktime(sc, mixer);
 	sc->sc_blk_ms = mixer->blktime_n;
 	hwblks = NBLKHW;
 	mixer->frames_per_block = frame_per_block(mixer, &mixer->hwbuf.fmt);
 	blksize = frametobyte(&mixer->hwbuf.fmt, mixer->frames_per_block);
 	if (sc->hw_if->round_blocksize) {
 		int rounded;
 		audio_params_t p = format2_to_params(&mixer->hwbuf.fmt);
 		rounded = sc->hw_if->round_blocksize(sc->hw_hdl, blksize,
 		    mode, &p);
 		TRACE(1, "round_blocksize %d -> %d", blksize, rounded);
 		if (rounded != blksize) {
 			if ((rounded * NBBY) % (mixer->hwbuf.fmt.stride *
 			    mixer->hwbuf.fmt.channels) != 0) {
 				device_printf(sc->sc_dev,
 				    "blksize not configured %d -> %d\n",
 				    blksize, rounded);
 				return EINVAL;
+			}
 			/* Recalculation */
 			blksize = rounded;
 			mixer->frames_per_block = blksize * NBBY /
 			    (mixer->hwbuf.fmt.stride *
 			     mixer->hwbuf.fmt.channels);
+		}
+	}
 	mixer->blktime_n = mixer->frames_per_block;
 	mixer->blktime_d = mixer->hwbuf.fmt.sample_rate;
 	capacity = mixer->frames_per_block * hwblks;
 	bufsize = frametobyte(&mixer->hwbuf.fmt, capacity);
 	if (sc->hw_if->round_buffersize) {
 		size_t rounded;
 		rounded = sc->hw_if->round_buffersize(sc->hw_hdl, mode,
 		    bufsize);
 		TRACE(1, "round_buffersize %zd -> %zd", bufsize, rounded);
 		if (rounded < bufsize) {
 			/* buffersize needs NBLKHW blocks at least. */
 			device_printf(sc->sc_dev,
 			    "buffersize too small: buffersize=%zd blksize=%d\n",
 			    rounded, blksize);
 			return EINVAL;
+		}
 		if (rounded % blksize != 0) {
 			/* buffersize/blksize constraint mismatch? */
 			device_printf(sc->sc_dev,
 			    "buffersize must be multiple of blksize: "
 			    "buffersize=%zu blksize=%d\n",
 			    rounded, blksize);
 			return EINVAL;
+		}
 		if (rounded != bufsize) {
 			/* Recalcuration */
 			bufsize = rounded;
 			hwblks = bufsize / blksize;
 			capacity = mixer->frames_per_block * hwblks;
+		}
+	}
 	TRACE(1, "buffersize for %s = %zu",
 	    (mode == AUMODE_PLAY) ? "playback" : "recording",
 	    bufsize);
 	mixer->hwbuf.capacity = capacity;
 	/*
 	 * XXX need to release sc_lock for compatibility?
 	 */
 	if (sc->hw_if->allocm) {
 		mixer->hwbuf.mem = sc->hw_if->allocm(sc->hw_hdl, mode, bufsize);
 		if (mixer->hwbuf.mem == NULL) {
 			device_printf(sc->sc_dev, "%s: allocm(%zu) failed\n",
 			    __func__, bufsize);
 			return ENOMEM;
+		}
 	} else {
 		mixer->hwbuf.mem = kmem_alloc(bufsize, KM_SLEEP);
+	}
 	/* From here, audio_mixer_destroy is necessary to exit. */
 	if (mode == AUMODE_PLAY) {
 		cv_init(&mixer->outcv, "audiowr");
 	} else {
 		cv_init(&mixer->outcv, "audiord");
+	}
 	if (mode == AUMODE_PLAY) {
 		softint_handler = audio_softintr_wr;
 	} else {
 		softint_handler = audio_softintr_rd;
+	}
 	mixer->sih = softint_establish(SOFTINT_SERIAL | SOFTINT_MPSAFE,
 	    softint_handler, sc);
 	if (mixer->sih == NULL) {
 		device_printf(sc->sc_dev, "softint_establish failed\n");
 		goto abort;
+	}
 	mixer->track_fmt.encoding = AUDIO_ENCODING_SLINEAR_NE;
 	mixer->track_fmt.precision = AUDIO_INTERNAL_BITS;
 	mixer->track_fmt.stride = AUDIO_INTERNAL_BITS;
 	mixer->track_fmt.channels = mixer->hwbuf.fmt.channels;
 	mixer->track_fmt.sample_rate = mixer->hwbuf.fmt.sample_rate;
 	if (mixer->hwbuf.fmt.encoding == AUDIO_ENCODING_SLINEAR_OE &&
 	    mixer->hwbuf.fmt.precision == AUDIO_INTERNAL_BITS) {
 		mixer->swap_endian = true;
 		TRACE(1, "swap_endian");
+	}
 	if (mode == AUMODE_PLAY) {
 		/* Mixing buffer */
 		mixer->mixfmt = mixer->track_fmt;
 		mixer->mixfmt.precision *= 2;
 		mixer->mixfmt.stride *= 2;
 		/* XXX TODO: use some macros? */
 		len = mixer->frames_per_block * mixer->mixfmt.channels *
 		    mixer->mixfmt.stride / NBBY;
 		mixer->mixsample = audio_realloc(mixer->mixsample, len);
 		if (mixer->mixsample == NULL) {
 			device_printf(sc->sc_dev,
 			    "%s: malloc mixsample(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 	} else {
 		/* No mixing buffer for recording */
+	}
 	if (reg->codec) {
 		mixer->codec = reg->codec;
 		mixer->codecarg.context = reg->context;
 		if (mode == AUMODE_PLAY) {
 			mixer->codecarg.srcfmt = &mixer->track_fmt;
 			mixer->codecarg.dstfmt = &mixer->hwbuf.fmt;
 		} else {
 			mixer->codecarg.srcfmt = &mixer->hwbuf.fmt;
 			mixer->codecarg.dstfmt = &mixer->track_fmt;
+		}
 		mixer->codecbuf.fmt = mixer->track_fmt;
 		mixer->codecbuf.capacity = mixer->frames_per_block;
 		len = auring_bytelen(&mixer->codecbuf);
 		mixer->codecbuf.mem = audio_realloc(mixer->codecbuf.mem, len);
 		if (mixer->codecbuf.mem == NULL) {
 			device_printf(sc->sc_dev,
 			    "%s: malloc codecbuf(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
+		}
+	}
 	/* Succeeded so display it. */
 	codecbuf[0] = '\0';
 	if (mixer->codec || mixer->swap_endian) {
 		snprintf(codecbuf, sizeof(codecbuf), " %s %s:%d",
 		    (mode == AUMODE_PLAY) ? "->" : "<-",
 		    audio_encoding_name(mixer->hwbuf.fmt.encoding),
 		    mixer->hwbuf.fmt.precision);
+	}
 	blkms = mixer->blktime_n * 1000 / mixer->blktime_d;
 	aprint_normal_dev(sc->sc_dev, "%s:%d%s %dch %dHz, blk %dms for %s\n",
 	    audio_encoding_name(mixer->track_fmt.encoding),
 	    mixer->track_fmt.precision,
 	    codecbuf,
 	    mixer->track_fmt.channels,
 	    mixer->track_fmt.sample_rate,
 	    blkms,
 	    (mode == AUMODE_PLAY) ? "playback" : "recording");
 	return 0;
 abort:
 	audio_mixer_destroy(sc, mixer);
 	return error;
+}
 /*
  * Releases all resources of 'mixer'.
  * Note that it does not release the memory area of 'mixer' itself.
  * Must be called with sc_lock held.
  */
 static void
 audio_mixer_destroy(struct audio_softc *sc, audio_trackmixer_t *mixer)
+{
 	int bufsize;
 	KASSERT(mutex_owned(sc->sc_lock));
 	bufsize = frametobyte(&mixer->hwbuf.fmt, mixer->hwbuf.capacity);
 	if (mixer->hwbuf.mem != NULL) {
 		if (sc->hw_if->freem) {
 			sc->hw_if->freem(sc->hw_hdl, mixer->hwbuf.mem, bufsize);
 		} else {
 			kmem_free(mixer->hwbuf.mem, bufsize);
+		}
 		mixer->hwbuf.mem = NULL;
+	}
 	audio_free(mixer->codecbuf.mem);
 	audio_free(mixer->mixsample);
 	cv_destroy(&mixer->outcv);
 	if (mixer->sih) {
 		softint_disestablish(mixer->sih);
 		mixer->sih = NULL;
+	}
+}
 /*
  * Starts playback mixer.
  * Must be called only if sc_pbusy is false.
  * Must be called with sc_lock held.
  * Must not be called from the interrupt context.
  */
 static void
 audio_pmixer_start(struct audio_softc *sc, bool force)
+{
 	audio_trackmixer_t *mixer;
 	int minimum;
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(sc->sc_pbusy == false);
 	mutex_enter(sc->sc_intr_lock);
 	mixer = sc->sc_pmixer;
 	TRACE(2, "%smixseq=%d hwseq=%d hwbuf=%d/%d/%d%s",
 	    (audiodebug >= 3) ? "begin " : "",
 	    (int)mixer->mixseq, (int)mixer->hwseq,
 	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity,
 	    force ? " force" : "");
 	/* Need two blocks to start normally. */
 	minimum = (force) ? 1 : 2;
 	while (mixer->hwbuf.used < mixer->frames_per_block * minimum) {
 		audio_pmixer_process(sc);
+	}
 	/* Start output */
 	audio_pmixer_output(sc);
 	sc->sc_pbusy = true;
 	TRACE(3, "end   mixseq=%d hwseq=%d hwbuf=%d/%d/%d",
 	    (int)mixer->mixseq, (int)mixer->hwseq,
 	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity);
 	mutex_exit(sc->sc_intr_lock);
+}
 /*
  * When playing back with MD filter:
+ *
  *           track track ...
  *               v v
  *                +  mix (with aint2_t)
  *                |  master volume (with aint2_t)
  *                v
  *    mixsample [::::]                  wide-int 1 block (ring) buffer
  *                |
  *                |  convert aint2_t -> aint_t
  *                v
  *    codecbuf  [....]                  1 block (ring) buffer
  *                |
  *                |  convert to hw format
  *                v
  *    hwbuf     [............]          NBLKHW blocks ring buffer
+ *
  * When playing back without MD filter:
+ *
  *    mixsample [::::]                  wide-int 1 block (ring) buffer
  *                |
  *                |  convert aint2_t -> aint_t
  *                |  (with byte swap if necessary)
  *                v
  *    hwbuf     [............]          NBLKHW blocks ring buffer
+ *
  * mixsample: slinear_NE, wide internal precision, HW ch, HW freq.
  * codecbuf:  slinear_NE, internal precision,      HW ch, HW freq.
  * hwbuf:     HW encoding, HW precision,           HW ch, HW freq.
  */
 /*
  * Performs track mixing and converts it to hwbuf.
  * Note that this function doesn't transfer hwbuf to hardware.
  * Must be called with sc_intr_lock held.
  */
 static void
 audio_pmixer_process(struct audio_softc *sc)
+{
 	audio_trackmixer_t *mixer;
 	audio_file_t *f;
 	int frame_count;
 	int sample_count;
 	int mixed;
 	int i;
 	aint2_t *m;
 	aint_t *h;
 	mixer = sc->sc_pmixer;
 	frame_count = mixer->frames_per_block;
 	KASSERT(auring_get_contig_free(&mixer->hwbuf) >= frame_count);
 	sample_count = frame_count * mixer->mixfmt.channels;
 	mixer->mixseq++;
 	/* Mix all tracks */
 	mixed = 0;
 	SLIST_FOREACH(f, &sc->sc_files, entry) {
 		audio_track_t *track = f->ptrack;
 		if (track == NULL)
 			continue;
 		if (track->is_pause) {
 			TRACET(4, track, "skip; paused");
 			continue;
+		}
 		/* Skip if the track is used by process context. */
 		if (audio_track_lock_tryenter(track) == false) {
 			TRACET(4, track, "skip; in use");
 			continue;
+		}
 		/* Emulate mmap'ped track */
 		if (track->mmapped) {
 			auring_push(&track->usrbuf, track->usrbuf_blksize);
 			TRACET(4, track, "mmap; usr=%d/%d/C%d",
 			    track->usrbuf.head,
 			    track->usrbuf.used,
 			    track->usrbuf.capacity);
+		}
 		if (track->outbuf.used < mixer->frames_per_block &&
 		    track->usrbuf.used > 0) {
 			TRACET(4, track, "process");
 			audio_track_play(track);
+		}
 		if (track->outbuf.used > 0) {
 			mixed = audio_pmixer_mix_track(mixer, track, mixed);
 		} else {
 			TRACET(4, track, "skip; empty");
+		}
 		audio_track_lock_exit(track);
+	}
 	if (mixed == 0) {
 		/* Silence */
 		memset(mixer->mixsample, 0,
 		    frametobyte(&mixer->mixfmt, frame_count));
 	} else {
 		if (mixed > 1) {
 			/* If there are multiple tracks, do auto gain control */
 			audio_pmixer_agc(mixer, sample_count);
+		}
 		/* Apply master volume */
 		if (mixer->volume < 256) {
 			m = mixer->mixsample;
 			for (i = 0; i < sample_count; i++) {
 				*m = AUDIO_SCALEDOWN(*m * mixer->volume, 8);
 				m++;
+			}
 			/*
 			 * Recover the volume gradually at the pace of
 			 * several times per second.  If it's too fast, you
 			 * can recognize that the volume changes up and down
 			 * quickly and it's not so comfortable.
 			 */
 			mixer->voltimer += mixer->blktime_n;
 			if (mixer->voltimer * 4 >= mixer->blktime_d) {
 				mixer->volume++;
 				mixer->voltimer = 0;
 #if defined(AUDIO_DEBUG_AGC)
 				TRACE(1, "volume recover: %d", mixer->volume);
 #endif
+			}
+		}
+	}
 	/*
 	 * The rest is the hardware part.
 	 */
 	if (mixer->codec) {
 		h = auring_tailptr_aint(&mixer->codecbuf);
 	} else {
 		h = auring_tailptr_aint(&mixer->hwbuf);
+	}
 	m = mixer->mixsample;
 	if (mixer->swap_endian) {
 		for (i = 0; i < sample_count; i++) {
 			*h++ = bswap16(*m++);
+		}
 	} else {
 		for (i = 0; i < sample_count; i++) {
 			*h++ = *m++;
+		}
+	}
 	/* Hardware driver's codec */
 	if (mixer->codec) {
 		auring_push(&mixer->codecbuf, frame_count);
 		mixer->codecarg.src = auring_headptr(&mixer->codecbuf);
 		mixer->codecarg.dst = auring_tailptr(&mixer->hwbuf);
 		mixer->codecarg.count = frame_count;
 		mixer->codec(&mixer->codecarg);
 		auring_take(&mixer->codecbuf, mixer->codecarg.count);
+	}
 	auring_push(&mixer->hwbuf, frame_count);
 	TRACE(4, "done mixseq=%d hwbuf=%d/%d/%d%s",
 	    (int)mixer->mixseq,
 	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity,
 	    (mixed == 0) ? " silent" : "");
+}
 /*
  * Do auto gain control.
  * Must be called sc_intr_lock held.
  */
 static void
 audio_pmixer_agc(audio_trackmixer_t *mixer, int sample_count)
+{
 	struct audio_softc *sc __unused;
 	aint2_t val;
 	aint2_t maxval;
 	aint2_t minval;
 	aint2_t over_plus;
 	aint2_t over_minus;
 	aint2_t *m;
 	int newvol;
 	int i;
 	sc = mixer->sc;
 	/* Overflow detection */
 	maxval = AINT_T_MAX;
 	minval = AINT_T_MIN;
 	m = mixer->mixsample;
 	for (i = 0; i < sample_count; i++) {
 		val = *m++;
 		if (val > maxval)
 			maxval = val;
 		else if (val < minval)
 			minval = val;
+	}
 	/* Absolute value of overflowed amount */
 	over_plus = maxval - AINT_T_MAX;
 	over_minus = AINT_T_MIN - minval;
 	if (over_plus > 0 || over_minus > 0) {
 		if (over_plus > over_minus) {
 			newvol = (int)((aint2_t)AINT_T_MAX * 256 / maxval);
 		} else {
 			newvol = (int)((aint2_t)AINT_T_MIN * 256 / minval);
+		}
 		/*
 		 * Change the volume only if new one is smaller.
 		 * Reset the timer even if the volume isn't changed.
 		 */
 		if (newvol <= mixer->volume) {
 			mixer->volume = newvol;
 			mixer->voltimer = 0;
 #if defined(AUDIO_DEBUG_AGC)
 			TRACE(1, "auto volume adjust: %d", mixer->volume);
 #endif
+		}
+	}
+}
 /*
  * Mix one track.
  * 'mixed' specifies the number of tracks mixed so far.
  * It returns the number of tracks mixed.  In other words, it returns
  * mixed + 1 if this track is mixed.
  */
 static int
 audio_pmixer_mix_track(audio_trackmixer_t *mixer, audio_track_t *track,
 	int mixed)
+{
 	int count;
 	int sample_count;
 	int remain;
 	int i;
 	const aint_t *s;
 	aint2_t *d;
 	/* XXX TODO: Is this necessary for now? */
 	if (mixer->mixseq < track->seq)
 		return mixed;
 	count = auring_get_contig_used(&track->outbuf);
 	count = uimin(count, mixer->frames_per_block);
 	s = auring_headptr_aint(&track->outbuf);
 	d = mixer->mixsample;
 	/*
 	 * Apply track volume with double-sized integer and perform
 	 * additive synthesis.
+	 *
 	 * XXX If you limit the track volume to 1.0 or less (<= 256),
 	 *     it would be better to do this in the track conversion stage
 	 *     rather than here.  However, if you accept the volume to
 	 *     be greater than 1.0 (> 256), it's better to do it here.
 	 *     Because the operation here is done by double-sized integer.
 	 */
 	sample_count = count * mixer->mixfmt.channels;
 	if (mixed == 0) {
 		/* If this is the first track, assignment can be used. */
 #if defined(AUDIO_SUPPORT_TRACK_VOLUME)
 		if (track->volume != 256) {
 			for (i = 0; i < sample_count; i++) {
 				aint2_t v;
 				v = *s++;
 				*d++ = AUDIO_SCALEDOWN(v * track->volume, 8)
+			}
 		} else
 #endif
+		{
 			for (i = 0; i < sample_count; i++) {
 				*d++ = ((aint2_t)*s++);
+			}
+		}
 		/* Fill silence if the first track is not filled. */
 		for (; i < mixer->frames_per_block * mixer->mixfmt.channels; i++)
 			*d++ = 0;
 	} else {
 		/* If this is the second or later, add it. */
 #if defined(AUDIO_SUPPORT_TRACK_VOLUME)
 		if (track->volume != 256) {
 			for (i = 0; i < sample_count; i++) {
 				aint2_t v;
 				v = *s++;
 				*d++ += AUDIO_SCALEDOWN(v * track->volume, 8);
+			}
 		} else
 #endif
+		{
 			for (i = 0; i < sample_count; i++) {
 				*d++ += ((aint2_t)*s++);
+			}
+		}
+	}
 	auring_take(&track->outbuf, count);
 	/*
 	 * The counters have to align block even if outbuf is less than
 	 * one block. XXX Is this still necessary?
 	 */
 	remain = mixer->frames_per_block - count;
 	if (__predict_false(remain != 0)) {
 		auring_push(&track->outbuf, remain);
 		auring_take(&track->outbuf, remain);
+	}
 	/*
 	 * Update track sequence.
 	 * mixseq has previous value yet at this point.
 	 */
 	track->seq = mixer->mixseq + 1;
 	return mixed + 1;
+}
 /*
  * Output one block from hwbuf to HW.
  * Must be called with sc_intr_lock held.
  */
 static void
 audio_pmixer_output(struct audio_softc *sc)
+{
 	audio_trackmixer_t *mixer;
 	audio_params_t params;
 	void *start;
 	void *end;
 	int blksize;
 	int error;
 	mixer = sc->sc_pmixer;
 	TRACE(4, "pbusy=%d hwbuf=%d/%d/%d",
 	    sc->sc_pbusy,
 	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity);
 	KASSERT(mixer->hwbuf.used >= mixer->frames_per_block);
 	blksize = frametobyte(&mixer->hwbuf.fmt, mixer->frames_per_block);
 	if (sc->hw_if->trigger_output) {
 		/* trigger (at once) */
 		if (!sc->sc_pbusy) {
 			start = mixer->hwbuf.mem;
 			end = (uint8_t *)start + auring_bytelen(&mixer->hwbuf);
 			params = format2_to_params(&mixer->hwbuf.fmt);
 			error = sc->hw_if->trigger_output(sc->hw_hdl,
 			    start, end, blksize, audio_pintr, sc, &params);
 			if (error) {
 				device_printf(sc->sc_dev,
 				    "trigger_output failed with %d\n", error);
 				return;
+			}
+		}
 	} else {
 		/* start (everytime) */
 		start = auring_headptr(&mixer->hwbuf);
 		error = sc->hw_if->start_output(sc->hw_hdl,
 		    start, blksize, audio_pintr, sc);
 		if (error) {
 			device_printf(sc->sc_dev,
 			    "start_output failed with %d\n", error);
 			return;
+		}
+	}
+}
 /*
  * This is an interrupt handler for playback.
  * It is called with sc_intr_lock held.
+ *
  * It is usually called from hardware interrupt.  However, note that
  * for some drivers (e.g. uaudio) it is called from software interrupt.
  */
 static void
 audio_pintr(void *arg)
+{
 	struct audio_softc *sc;
 	audio_trackmixer_t *mixer;
 	sc = arg;
 	KASSERT(mutex_owned(sc->sc_intr_lock));
 	if (sc->sc_dying)
 		return;
 #if defined(DIAGNOSTIC)
 	if (sc->sc_pbusy == false) {
 		device_printf(sc->sc_dev, "stray interrupt\n");
 		return;
+	}
 #endif
 	mixer = sc->sc_pmixer;
 	mixer->hw_complete_counter += mixer->frames_per_block;
 	mixer->hwseq++;
 	auring_take(&mixer->hwbuf, mixer->frames_per_block);
 	TRACE(4,
 	    "HW_INT ++hwseq=%" PRIu64 " cmplcnt=%" PRIu64 " hwbuf=%d/%d/%d",
 	    mixer->hwseq, mixer->hw_complete_counter,
 	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity);
 #if !defined(_KERNEL)
 	/* This is a debug code for userland test. */
 	return;
 #endif
 #if defined(AUDIO_HW_SINGLE_BUFFER)
 	/*
 	 * Create a new block here and output it immediately.
 	 * It makes a latency lower but needs machine power.
 	 */
 	audio_pmixer_process(sc);
 	audio_pmixer_output(sc);
 #else
 	/*
 	 * It is called when block N output is done.
 	 * Output immediately block N+1 created by the last interrupt.
 	 * And then create block N+2 for the next interrupt.
 	 * This method makes playback robust even on slower machines.
 	 * Instead the latency is increased by one block.
 	 */
 	/* At first, output ready block. */
 	if (mixer->hwbuf.used >= mixer->frames_per_block) {
 		audio_pmixer_output(sc);
+	}
 	bool later = false;
 	if (mixer->hwbuf.used < mixer->frames_per_block) {
 		later = true;
+	}
 	/* Then, process next block. */
 	audio_pmixer_process(sc);
 	if (later) {
 		audio_pmixer_output(sc);
+	}
 #endif
 	/*
 	 * When this interrupt is the real hardware interrupt, disabling
 	 * preemption here is not necessary.  But some drivers (e.g. uaudio)
 	 * emulate it by software interrupt, so kpreempt_disable is necessary.
 	 */
 	kpreempt_disable();
 	softint_schedule(mixer->sih);
 	kpreempt_enable();
+}
 /*
  * Starts record mixer.
  * Must be called only if sc_rbusy is false.
  * Must be called with sc_lock held.
  * Must not be called from the interrupt context.
  */
 static void
 audio_rmixer_start(struct audio_softc *sc)
+{
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(sc->sc_rbusy == false);
 	mutex_enter(sc->sc_intr_lock);
 	TRACE(2, "%s", (audiodebug >= 3) ? "begin" : "");
 	audio_rmixer_input(sc);
 	sc->sc_rbusy = true;
 	TRACE(3, "end");
 	mutex_exit(sc->sc_intr_lock);
+}
 /*
  * When recording with MD filter:
+ *
  *    hwbuf     [............]          NBLKHW blocks ring buffer
  *                |
  *                | convert from hw format
  *                v
  *    codecbuf  [....]                  1 block (ring) buffer
  *               |  |
  *               v  v
  *            track track ...
+ *
  * When recording without MD filter:
+ *
  *    hwbuf     [............]          NBLKHW blocks ring buffer
  *               |  |
  *               v  v
  *            track track ...
+ *
  * hwbuf:     HW encoding, HW precision, HW ch, HW freq.
  * codecbuf:  slinear_NE, internal precision, HW ch, HW freq.
  */
 /*
  * Distribute a recorded block to all recording tracks.
  */
 static void
 audio_rmixer_process(struct audio_softc *sc)
+{
 	audio_trackmixer_t *mixer;
 	audio_ring_t *mixersrc;
 	audio_file_t *f;
 	aint_t *p;
 	int count;
 	int bytes;
 	int i;
 	mixer = sc->sc_rmixer;
 	/*
 	 * count is the number of frames to be retrieved this time.
 	 * count should be one block.
 	 */
 	count = auring_get_contig_used(&mixer->hwbuf);
 	count = uimin(count, mixer->frames_per_block);
 	if (count <= 0) {
 		TRACE(4, "count %d: too short", count);
 		return;
+	}
 	bytes = frametobyte(&mixer->track_fmt, count);
 	/* Hardware driver's codec */
 	if (mixer->codec) {
 		mixer->codecarg.src = auring_headptr(&mixer->hwbuf);
 		mixer->codecarg.dst = auring_tailptr(&mixer->codecbuf);
 		mixer->codecarg.count = count;
 		mixer->codec(&mixer->codecarg);
 		auring_take(&mixer->hwbuf, mixer->codecarg.count);
 		auring_push(&mixer->codecbuf, mixer->codecarg.count);
 		mixersrc = &mixer->codecbuf;
 	} else {
 		mixersrc = &mixer->hwbuf;
+	}
 	if (mixer->swap_endian) {
 		/* inplace conversion */
 		p = auring_headptr_aint(mixersrc);
 		for (i = 0; i < count * mixer->track_fmt.channels; i++, p++) {
 			*p = bswap16(*p);
+		}
+	}
 	/* Distribute to all tracks. */
 	SLIST_FOREACH(f, &sc->sc_files, entry) {
 		audio_track_t *track = f->rtrack;
 		audio_ring_t *input;
 		if (track == NULL)
 			continue;
 		if (track->is_pause) {
 			TRACET(4, track, "skip; paused");
 			continue;
+		}
 		if (audio_track_lock_tryenter(track) == false) {
 			TRACET(4, track, "skip; in use");
 			continue;
+		}
 		/* If the track buffer is full, discard the oldest one? */
 		input = track->input;
 		if (input->capacity - input->used < mixer->frames_per_block) {
 			int drops = mixer->frames_per_block -
 			    (input->capacity - input->used);
 			track->dropframes += drops;
 			TRACET(4, track, "drop %d frames: inp=%d/%d/%d",
 			    drops,
 			    input->head, input->used, input->capacity);
 			auring_take(input, drops);
+		}
 		KASSERT(input->used % mixer->frames_per_block == 0);
 		memcpy(auring_tailptr_aint(input),
 		    auring_headptr_aint(mixersrc),
 		    bytes);
 		auring_push(input, count);
 		/* XXX sequence counter? */
 		audio_track_lock_exit(track);
+	}
 	auring_take(mixersrc, count);
+}
 /*
  * Input one block from HW to hwbuf.
  * Must be called with sc_intr_lock held.
  */
 static void
 audio_rmixer_input(struct audio_softc *sc)
+{
 	audio_trackmixer_t *mixer;
 	audio_params_t params;
 	void *start;
 	void *end;
 	int blksize;
 	int error;
 	mixer = sc->sc_rmixer;
 	blksize = frametobyte(&mixer->hwbuf.fmt, mixer->frames_per_block);
 	if (sc->hw_if->trigger_input) {
 		/* trigger (at once) */
 		if (!sc->sc_rbusy) {
 			start = mixer->hwbuf.mem;
 			end = (uint8_t *)start + auring_bytelen(&mixer->hwbuf);
 			params = format2_to_params(&mixer->hwbuf.fmt);
 			error = sc->hw_if->trigger_input(sc->hw_hdl,
 			    start, end, blksize, audio_rintr, sc, &params);
 			if (error) {
 				device_printf(sc->sc_dev,
 				    "trigger_input failed with %d\n", error);
 				return;
+			}
+		}
 	} else {
 		/* start (everytime) */
 		start = auring_tailptr(&mixer->hwbuf);
 		error = sc->hw_if->start_input(sc->hw_hdl,
 		    start, blksize, audio_rintr, sc);
 		if (error) {
 			device_printf(sc->sc_dev,
 			    "start_input failed with %d\n", error);
 			return;
+		}
+	}
+}
 /*
  * This is an interrupt handler for recording.
  * It is called with sc_intr_lock.
+ *
  * It is usually called from hardware interrupt.  However, note that
  * for some drivers (e.g. uaudio) it is called from software interrupt.
  */
 static void
 audio_rintr(void *arg)
+{
 	struct audio_softc *sc;
 	audio_trackmixer_t *mixer;
 	sc = arg;
 	KASSERT(mutex_owned(sc->sc_intr_lock));
 	if (sc->sc_dying)
 		return;
 #if defined(DIAGNOSTIC)
 	if (sc->sc_rbusy == false) {
 		device_printf(sc->sc_dev, "stray interrupt\n");
 		return;
+	}
 #endif
 	mixer = sc->sc_rmixer;
 	mixer->hw_complete_counter += mixer->frames_per_block;
 	mixer->hwseq++;
 	auring_push(&mixer->hwbuf, mixer->frames_per_block);
 	TRACE(4,
 	    "HW_INT ++hwseq=%" PRIu64 " cmplcnt=%" PRIu64 " hwbuf=%d/%d/%d",
 	    mixer->hwseq, mixer->hw_complete_counter,
 	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity);
 	/* Distrubute recorded block */
 	audio_rmixer_process(sc);
 	/* Request next block */
 	audio_rmixer_input(sc);
 	/*
 	 * When this interrupt is the real hardware interrupt, disabling
 	 * preemption here is not necessary.  But some drivers (e.g. uaudio)
 	 * emulate it by software interrupt, so kpreempt_disable is necessary.
 	 */
 	kpreempt_disable();
 	softint_schedule(mixer->sih);
 	kpreempt_enable();
+}
 /*
  * Halts playback mixer.
  * This function also clears related parameters, so call this function
  * instead of calling halt_output directly.
  * Must be called only if sc_pbusy is true.
  * Must be called with sc_lock && sc_exlock held.
  */
 static int
 audio_pmixer_halt(struct audio_softc *sc)
+{
 	int error;
 	TRACE(2, "");
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(sc->sc_exlock);
 	mutex_enter(sc->sc_intr_lock);
 	error = sc->hw_if->halt_output(sc->hw_hdl);
 	mutex_exit(sc->sc_intr_lock);
 	/* Halts anyway even if some error has occurred. */
 	sc->sc_pbusy = false;
 	sc->sc_pmixer->hwbuf.head = 0;
 	sc->sc_pmixer->hwbuf.used = 0;
 	sc->sc_pmixer->mixseq = 0;
 	sc->sc_pmixer->hwseq = 0;
 	return error;
+}
 /*
  * Halts recording mixer.
  * This function also clears related parameters, so call this function
  * instead of calling halt_input directly.
  * Must be called only if sc_rbusy is true.
  * Must be called with sc_lock && sc_exlock held.
  */
 static int
 audio_rmixer_halt(struct audio_softc *sc)
+{
 	int error;
 	TRACE(2, "");
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(sc->sc_exlock);
 	mutex_enter(sc->sc_intr_lock);
 	error = sc->hw_if->halt_input(sc->hw_hdl);
 	mutex_exit(sc->sc_intr_lock);
 	/* Halts anyway even if some error has occurred. */
 	sc->sc_rbusy = false;
 	sc->sc_rmixer->hwbuf.head = 0;
 	sc->sc_rmixer->hwbuf.used = 0;
 	sc->sc_rmixer->mixseq = 0;
 	sc->sc_rmixer->hwseq = 0;
 	return error;
+}
 /*
  * Flush this track.
  * Halts all operations, clears all buffers, reset error counters.
  * XXX I'm not sure...
  */
 static void
 audio_track_clear(struct audio_softc *sc, audio_track_t *track)
+{
 	KASSERT(track);
 	TRACET(3, track, "clear");
 	audio_track_lock_enter(track);
 	track->usrbuf.used = 0;
 	/* Clear all internal parameters. */
 	if (track->codec.filter) {
 		track->codec.srcbuf.used = 0;
 		track->codec.srcbuf.head = 0;
+	}
 	if (track->chvol.filter) {
 		track->chvol.srcbuf.used = 0;
 		track->chvol.srcbuf.head = 0;
+	}
 	if (track->chmix.filter) {
 		track->chmix.srcbuf.used = 0;
 		track->chmix.srcbuf.head = 0;
+	}
 	if (track->freq.filter) {
 		track->freq.srcbuf.used = 0;
 		track->freq.srcbuf.head = 0;
 		if (track->freq_step < 65536)
 			track->freq_current = 65536;
 		else
 			track->freq_current = 0;
 		memset(track->freq_prev, 0, sizeof(track->freq_prev));
 		memset(track->freq_curr, 0, sizeof(track->freq_curr));
+	}
 	/* Clear buffer, then operation halts naturally. */
 	track->outbuf.used = 0;
 	/* Clear counters. */
 	track->dropframes = 0;
 	audio_track_lock_exit(track);
+}
 /*
  * Drain the track.
  * track must be present and for playback.
  * If successful, it returns 0.  Otherwise returns errno.
  * Must be called with sc_lock held.
  */
 static int
 audio_track_drain(struct audio_softc *sc, audio_track_t *track)
+{
 	audio_trackmixer_t *mixer;
 	int done;
 	int error;
 	KASSERT(track);
 	TRACET(3, track, "start");
 	mixer = track->mixer;
 	KASSERT(mutex_owned(sc->sc_lock));
 	/* Ignore them if pause. */
 	if (track->is_pause) {
 		TRACET(3, track, "pause -> clear");
 		track->pstate = AUDIO_STATE_CLEAR;
+	}
 	/* Terminate early here if there is no data in the track. */
 	if (track->pstate == AUDIO_STATE_CLEAR) {
 		TRACET(3, track, "no need to drain");
 		return 0;
+	}
 	track->pstate = AUDIO_STATE_DRAINING;
 	for (;;) {
 		/* I want to display it before condition evaluation. */
 		TRACET(3, track, "pid=%d.%d trkseq=%d hwseq=%d out=%d/%d/%d",
 		    (int)curproc->p_pid, (int)curlwp->l_lid,
 		    (int)track->seq, (int)mixer->hwseq,
 		    track->outbuf.head, track->outbuf.used,
 		    track->outbuf.capacity);
 		/* Condition to terminate */
 		audio_track_lock_enter(track);
 		done = (track->usrbuf.used < frametobyte(&track->inputfmt, 1) &&
 		    track->outbuf.used == 0 &&
 		    track->seq <= mixer->hwseq);
 		audio_track_lock_exit(track);
 		if (done)
 			break;
 		TRACET(3, track, "sleep");
 		error = audio_track_waitio(sc, track);
 		if (error)
 			return error;
 		/* XXX call audio_track_play here ? */
+	}
 	track->pstate = AUDIO_STATE_CLEAR;
 	TRACET(3, track, "done trk_inp=%d trk_out=%d",
 		(int)track->inputcounter, (int)track->outputcounter);
 	return 0;
+}
 /*
  * Send signal to process.
  * This is intended to be called only from audio_softintr_{rd,wr}.
  * Must be called with sc_lock && sc_intr_lock held.
  */