 @@ -1,1144 +1,1144 @@
-/*	$NetBSD: audio.c,v 1.29 2019/08/23 09:41:26 maxv Exp $	*/
+/*	$NetBSD: audio.c,v 1.30 2019/08/29 13:01:07 isaki 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.29 2019/08/23 09:41:26 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.30 2019/08/29 13:01:07 isaki 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,
 @@ -4734,2102 +4734,2126 @@ audio_mixer_init(struct audio_softc *sc,
 			    __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.
  */
 static inline void
 audio_psignal(struct audio_softc *sc, pid_t pid, int signum)
+{
 	proc_t *p;
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(mutex_owned(sc->sc_intr_lock));
 	KASSERT(pid != 0);
 	/*
 	 * psignal() must be called without spin lock held.
 	 * So leave intr_lock temporarily here.
 	 */
 	mutex_exit(sc->sc_intr_lock);
 	mutex_enter(proc_lock);
 	p = proc_find(pid);
 	if (p)
 		psignal(p, signum);
 	mutex_exit(proc_lock);
 	/* Enter intr_lock again */
 	mutex_enter(sc->sc_intr_lock);
+}
 /*
  * This is software interrupt handler for record.
  * It is called from recording hardware interrupt everytime.
  * It does:
  * - Deliver SIGIO for all async processes.
  * - Notify to audio_read() that data has arrived.
  * - selnotify() for select/poll-ing processes.
  */
 /*
  * XXX If a process issues FIOASYNC between hardware interrupt and
  *     software interrupt, (stray) SIGIO will be sent to the process
  *     despite the fact that it has not receive recorded data yet.
  */
 static void
 audio_softintr_rd(void *cookie)
+{
 	struct audio_softc *sc = cookie;
 	audio_file_t *f;
 	proc_t *p;
 	pid_t pid;
 	mutex_enter(sc->sc_lock);
 	mutex_enter(sc->sc_intr_lock);
 	SLIST_FOREACH(f, &sc->sc_files, entry) {
 		audio_track_t *track = f->rtrack;
 		if (track == NULL)
 			continue;
 		TRACET(4, track, "broadcast; inp=%d/%d/%d",
 		    track->input->head,
 		    track->input->used,
 		    track->input->capacity);
 		pid = f->async_audio;
 		if (pid != 0) {
 			TRACEF(4, f, "sending SIGIO %d", pid);
-			mutex_enter(proc_lock);
+			audio_psignal(sc, pid, SIGIO);
 			if ((p = proc_find(pid)) != NULL)
 				psignal(p, SIGIO);
 			mutex_exit(proc_lock);
+		}
+	}
 	mutex_exit(sc->sc_intr_lock);
 	/* Notify that data has arrived. */
 	selnotify(&sc->sc_rsel, 0, NOTE_SUBMIT);
 	KNOTE(&sc->sc_rsel.sel_klist, 0);
 	cv_broadcast(&sc->sc_rmixer->outcv);
 	mutex_exit(sc->sc_lock);
+}
 /*
  * This is software interrupt handler for playback.
  * It is called from playback hardware interrupt everytime.
  * It does:
  * - Deliver SIGIO for all async and writable (used < lowat) processes.
  * - Notify to audio_write() that outbuf block available.
  * - selnotify() for select/poll-ing processes if there are any writable
  *   (used < lowat) processes.  Checking each descriptor will be done by
  *   filt_audiowrite_event().
  */
 static void
 audio_softintr_wr(void *cookie)
+{
 	struct audio_softc *sc = cookie;
 	audio_file_t *f;
 	bool found;
 	proc_t *p;
 	pid_t pid;
 	TRACE(4, "called");
 	found = false;
 	mutex_enter(sc->sc_lock);
 	mutex_enter(sc->sc_intr_lock);
 	SLIST_FOREACH(f, &sc->sc_files, entry) {
 		audio_track_t *track = f->ptrack;
 		if (track == NULL)
 			continue;
 		TRACET(4, track, "broadcast; trseq=%d out=%d/%d/%d",
 		    (int)track->seq,
 		    track->outbuf.head,
 		    track->outbuf.used,
 		    track->outbuf.capacity);
 		/*
 		 * Send a signal if the process is async mode and
 		 * used is lower than lowat.
 		 */
 		if (track->usrbuf.used <= track->usrbuf_usedlow &&
 		    !track->is_pause) {
 			/* For selnotify */
 			found = true;
 			/* For SIGIO */
 			pid = f->async_audio;
 			if (pid != 0) {
 				TRACEF(4, f, "sending SIGIO %d", pid);
-				mutex_enter(proc_lock);
+				audio_psignal(sc, pid, SIGIO);
 				if ((p = proc_find(pid)) != NULL)
 					psignal(p, SIGIO);
 				mutex_exit(proc_lock);
+			}
+		}
+	}
 	mutex_exit(sc->sc_intr_lock);
 	/*
 	 * Notify for select/poll when someone become writable.
 	 * It needs sc_lock (and not sc_intr_lock).
 	 */
 	if (found) {
 		TRACE(4, "selnotify");
 		selnotify(&sc->sc_wsel, 0, NOTE_SUBMIT);
 		KNOTE(&sc->sc_wsel.sel_klist, 0);
+	}
 	/* Notify to audio_write() that outbuf available. */
 	cv_broadcast(&sc->sc_pmixer->outcv);
 	mutex_exit(sc->sc_lock);
+}
 /*
  * Check (and convert) the format *p came from userland.
  * If successful, it writes back the converted format to *p if necessary
  * and returns 0.  Otherwise returns errno (*p may change even this case).
  */
 static int
 audio_check_params(audio_format2_t *p)
+{
 	/* Convert obsoleted AUDIO_ENCODING_PCM* */
 	/* XXX Is this conversion right? */
 	if (p->encoding == AUDIO_ENCODING_PCM16) {
 		if (p->precision == 8)
 			p->encoding = AUDIO_ENCODING_ULINEAR;
 		else
 			p->encoding = AUDIO_ENCODING_SLINEAR;
 	} else if (p->encoding == AUDIO_ENCODING_PCM8) {
 		if (p->precision == 8)
 			p->encoding = AUDIO_ENCODING_ULINEAR;
 		else
 			return EINVAL;
+	}
 	/*
 	 * Convert obsoleted AUDIO_ENCODING_[SU]LINEAR without endianness
 	 * suffix.
 	 */
 	if (p->encoding == AUDIO_ENCODING_SLINEAR)
 		p->encoding = AUDIO_ENCODING_SLINEAR_NE;
 	if (p->encoding == AUDIO_ENCODING_ULINEAR)
 		p->encoding = AUDIO_ENCODING_ULINEAR_NE;
 	switch (p->encoding) {
 	case AUDIO_ENCODING_ULAW:
 	case AUDIO_ENCODING_ALAW:
 		if (p->precision != 8)
 			return EINVAL;
 		break;
 	case AUDIO_ENCODING_ADPCM:
 		if (p->precision != 4 && p->precision != 8)
 			return EINVAL;
 		break;
 	case AUDIO_ENCODING_SLINEAR_LE:
 	case AUDIO_ENCODING_SLINEAR_BE:
 	case AUDIO_ENCODING_ULINEAR_LE:
 	case AUDIO_ENCODING_ULINEAR_BE:
 		if (p->precision !=  8 && p->precision != 16 &&
 		    p->precision != 24 && p->precision != 32)
 			return EINVAL;
 		/* 8bit format does not have endianness. */
 		if (p->precision == 8) {
 			if (p->encoding == AUDIO_ENCODING_SLINEAR_OE)
 				p->encoding = AUDIO_ENCODING_SLINEAR_NE;
 			if (p->encoding == AUDIO_ENCODING_ULINEAR_OE)
 				p->encoding = AUDIO_ENCODING_ULINEAR_NE;
+		}
 		if (p->precision > p->stride)
 			return EINVAL;
 		break;
 	case AUDIO_ENCODING_MPEG_L1_STREAM:
 	case AUDIO_ENCODING_MPEG_L1_PACKETS:
 	case AUDIO_ENCODING_MPEG_L1_SYSTEM:
 	case AUDIO_ENCODING_MPEG_L2_STREAM:
 	case AUDIO_ENCODING_MPEG_L2_PACKETS:
 	case AUDIO_ENCODING_MPEG_L2_SYSTEM:
 	case AUDIO_ENCODING_AC3:
 		break;
 	default:
 		return EINVAL;
+	}
 	/* sanity check # of channels*/
 	if (p->channels < 1 || p->channels > AUDIO_MAX_CHANNELS)
 		return EINVAL;
 	return 0;
+}
 /*
  * Initialize playback and record mixers.
  * mode (AUMODE_{PLAY,RECORD}) indicates the mixer to be initalized.
  * phwfmt and rhwfmt indicate the hardware format.  pfil and rfil indicate
  * the filter registration information.  These four must not be NULL.
  * If successful returns 0.  Otherwise returns errno.
  * Must be called with sc_lock held.
  * Must not be called if there are any tracks.
  * Caller should check that the initialization succeed by whether
  * sc_[pr]mixer is not NULL.
  */
 static int
 audio_mixers_init(struct audio_softc *sc, int mode,
 	const audio_format2_t *phwfmt, const audio_format2_t *rhwfmt,
 	const audio_filter_reg_t *pfil, const audio_filter_reg_t *rfil)
+{
 	int error;
 	KASSERT(phwfmt != NULL);
 	KASSERT(rhwfmt != NULL);
 	KASSERT(pfil != NULL);
 	KASSERT(rfil != NULL);
 	KASSERT(mutex_owned(sc->sc_lock));
 	if ((mode & AUMODE_PLAY)) {
 		if (sc->sc_pmixer == NULL) {
 			sc->sc_pmixer = kmem_zalloc(sizeof(*sc->sc_pmixer),
 			    KM_SLEEP);
 		} else {
 			/* destroy() doesn't free memory. */
 			audio_mixer_destroy(sc, sc->sc_pmixer);
 			memset(sc->sc_pmixer, 0, sizeof(*sc->sc_pmixer));
+		}
 		error = audio_mixer_init(sc, AUMODE_PLAY, phwfmt, pfil);
 		if (error) {
 			aprint_error_dev(sc->sc_dev,
 			    "configuring playback mode failed\n");
 			kmem_free(sc->sc_pmixer, sizeof(*sc->sc_pmixer));
 			sc->sc_pmixer = NULL;
 			return error;
+		}
+	}
 	if ((mode & AUMODE_RECORD)) {
 		if (sc->sc_rmixer == NULL) {
 			sc->sc_rmixer = kmem_zalloc(sizeof(*sc->sc_rmixer),
 			    KM_SLEEP);
 		} else {
 			/* destroy() doesn't free memory. */
 			audio_mixer_destroy(sc, sc->sc_rmixer);
 			memset(sc->sc_rmixer, 0, sizeof(*sc->sc_rmixer));
+		}
 		error = audio_mixer_init(sc, AUMODE_RECORD, rhwfmt, rfil);
 		if (error) {
 			aprint_error_dev(sc->sc_dev,
 			    "configuring record mode failed\n");
 			kmem_free(sc->sc_rmixer, sizeof(*sc->sc_rmixer));
 			sc->sc_rmixer = NULL;
 			return error;
+		}
+	}
 	return 0;
+}
 /*
  * Select a frequency.
  * Prioritize 48kHz and 44.1kHz.  Otherwise choose the highest one.
  * XXX Better algorithm?
  */
 static int
 audio_select_freq(const struct audio_format *fmt)
+{
 	int freq;
 	int high;
 	int low;
 	int j;
 	if (fmt->frequency_type == 0) {
 		low = fmt->frequency[0];
 		high = fmt->frequency[1];
 		freq = 48000;
 		if (low <= freq && freq <= high) {
 			return freq;
+		}
 		freq = 44100;
 		if (low <= freq && freq <= high) {
 			return freq;
+		}
 		return high;
 	} else {
 		for (j = 0; j < fmt->frequency_type; j++) {
 			if (fmt->frequency[j] == 48000) {
 				return fmt->frequency[j];
+			}
+		}
 		high = 0;
 		for (j = 0; j < fmt->frequency_type; j++) {
 			if (fmt->frequency[j] == 44100) {
 				return fmt->frequency[j];
+			}
 			if (fmt->frequency[j] > high) {
 				high = fmt->frequency[j];
+			}
+		}
 		return high;
+	}
+}
 /*
  * Probe playback and/or recording format (depending on *modep).
  * *modep is an in-out parameter.  It indicates the direction to configure
  * as an argument, and the direction configured is written back as out
  * parameter.
  * If successful, probed hardware format is stored into *phwfmt, *rhwfmt
  * depending on *modep, and return 0.  Otherwise it returns errno.
  * Must be called with sc_lock held.
  */
 static int
 audio_hw_probe(struct audio_softc *sc, int is_indep, int *modep,
 	audio_format2_t *phwfmt, audio_format2_t *rhwfmt)
+{
 	audio_format2_t fmt;
 	int mode;
 	int error = 0;
 	KASSERT(mutex_owned(sc->sc_lock));
 	mode = *modep;
 	KASSERTMSG((mode & (AUMODE_PLAY | AUMODE_RECORD)) != 0,
 	    "invalid mode = %x", mode);
 	if (is_indep) {
 		int errorp = 0, errorr = 0;
 		/* On independent devices, probe separately. */
 		if ((mode & AUMODE_PLAY) != 0) {
 			errorp = audio_hw_probe_fmt(sc, phwfmt, AUMODE_PLAY);
 			if (errorp)
 				mode &= ~AUMODE_PLAY;
+		}
 		if ((mode & AUMODE_RECORD) != 0) {
 			errorr = audio_hw_probe_fmt(sc, rhwfmt, AUMODE_RECORD);
 			if (errorr)
 				mode &= ~AUMODE_RECORD;
+		}
 		/* Return error if both play and record probes failed. */
 		if (errorp && errorr)
 			error = errorp;
 	} else {
 		/* On non independent devices, probe simultaneously. */
 		error = audio_hw_probe_fmt(sc, &fmt, mode);
 		if (error) {
 			mode = 0;
 		} else {
 			*phwfmt = fmt;
 			*rhwfmt = fmt;
+		}
+	}
 	*modep = mode;
 	return error;
+}
 /*
  * Choose the most preferred hardware format.
  * If successful, it will store the chosen format into *cand and return 0.
  * Otherwise, return errno.
  * Must be called with sc_lock held.
  */
 static int
 audio_hw_probe_fmt(struct audio_softc *sc, audio_format2_t *cand, int mode)
+{
 	audio_format_query_t query;
 	int cand_score;
 	int score;
 	int i;
 	int error;
 	KASSERT(mutex_owned(sc->sc_lock));
 	/*
 	 * Score each formats and choose the highest one.
+	 *
 	 *                 +---- priority(0-3)
 	 *                 |+--- encoding/precision
 	 *                 ||+-- channels
 	 * score = 0x000000PEC
 	 */
 	cand_score = 0;
 	for (i = 0; ; i++) {
 		memset(&query, 0, sizeof(query));
 		query.index = i;
 		error = sc->hw_if->query_format(sc->hw_hdl, &query);
 		if (error == EINVAL)
 			break;
 		if (error)
 			return error;
 #if defined(AUDIO_DEBUG)
 		DPRINTF(1, "fmt[%d] %c%c pri=%d %s,%d/%dbit,%dch,", i,
 		    (query.fmt.mode & AUMODE_PLAY)   ? 'P' : '-',
 		    (query.fmt.mode & AUMODE_RECORD) ? 'R' : '-',
 		    query.fmt.priority,
 		    audio_encoding_name(query.fmt.encoding),
 		    query.fmt.validbits,
 		    query.fmt.precision,
 		    query.fmt.channels);
 		if (query.fmt.frequency_type == 0) {
 			DPRINTF(1, "{%d-%d",
 			    query.fmt.frequency[0], query.fmt.frequency[1]);
 		} else {
 			int j;
 			for (j = 0; j < query.fmt.frequency_type; j++) {
 				DPRINTF(1, "%c%d",
 				    (j == 0) ? '{' : ',',
 				    query.fmt.frequency[j]);
+			}
+		}
 		DPRINTF(1, "}\n");
 #endif
 		if ((query.fmt.mode & mode) == 0) {
 			DPRINTF(1, "fmt[%d] skip; mode not match %d\n", i,
 			    mode);
 			continue;
+		}
 		if (query.fmt.priority < 0) {
 			DPRINTF(1, "fmt[%d] skip; unsupported encoding\n", i);
 			continue;
+		}
 		/* Score */
 		score = (query.fmt.priority & 3) * 0x100;
 		if (query.fmt.encoding == AUDIO_ENCODING_SLINEAR_NE &&
 		    query.fmt.validbits == AUDIO_INTERNAL_BITS &&
 		    query.fmt.precision == AUDIO_INTERNAL_BITS) {
 			score += 0x20;
 		} else if (query.fmt.encoding == AUDIO_ENCODING_SLINEAR_OE &&
 		    query.fmt.validbits == AUDIO_INTERNAL_BITS &&
 		    query.fmt.precision == AUDIO_INTERNAL_BITS) {
 			score += 0x10;
+		}
 		score += query.fmt.channels;
 		if (score < cand_score) {
 			DPRINTF(1, "fmt[%d] skip; score 0x%x < 0x%x\n", i,
 			    score, cand_score);
 			continue;
+		}
 		/* Update candidate */
 		cand_score = score;
 		cand->encoding    = query.fmt.encoding;
 		cand->precision   = query.fmt.validbits;
 		cand->stride      = query.fmt.precision;
 		cand->channels    = query.fmt.channels;
 		cand->sample_rate = audio_select_freq(&query.fmt);
 		DPRINTF(1, "fmt[%d] candidate (score=0x%x)"
 		    " pri=%d %s,%d/%d,%dch,%dHz\n", i,
 		    cand_score, query.fmt.priority,
 		    audio_encoding_name(query.fmt.encoding),
 		    cand->precision, cand->stride,
 		    cand->channels, cand->sample_rate);
+	}
 	if (cand_score == 0) {
 		DPRINTF(1, "%s no fmt\n", __func__);
 		return ENXIO;
+	}
 	DPRINTF(1, "%s selected: %s,%d/%d,%dch,%dHz\n", __func__,
 	    audio_encoding_name(cand->encoding),
 	    cand->precision, cand->stride, cand->channels, cand->sample_rate);
 	return 0;
+}
 /*
  * Validate fmt with query_format.
  * If fmt is included in the result of query_format, returns 0.
  * Otherwise returns EINVAL.
  * Must be called with sc_lock held.
  */
 static int
 audio_hw_validate_format(struct audio_softc *sc, int mode,
 	const audio_format2_t *fmt)
+{
 	audio_format_query_t query;
 	struct audio_format *q;
 	int index;
 	int error;
 	int j;
 	KASSERT(mutex_owned(sc->sc_lock));
 	/*
 	 * If query_format is not supported by hardware driver,
 	 * a rough check instead will be performed.
 	 * XXX This will gone in the future.
 	 */
 	if (sc->hw_if->query_format == NULL) {
 		if (fmt->encoding != AUDIO_ENCODING_SLINEAR_NE)
 			return EINVAL;
 		if (fmt->precision != AUDIO_INTERNAL_BITS)
 			return EINVAL;
 		if (fmt->stride != AUDIO_INTERNAL_BITS)
 			return EINVAL;
 		return 0;
+	}
 	for (index = 0; ; index++) {
 		query.index = index;
 		error = sc->hw_if->query_format(sc->hw_hdl, &query);
 		if (error == EINVAL)
 			break;
 		if (error)
 			return error;
 		q = &query.fmt;
 		/*
 		 * Note that fmt is audio_format2_t (precision/stride) but
 		 * q is audio_format_t (validbits/precision).
 		 */
 		if ((q->mode & mode) == 0) {
 			continue;
+		}
 		if (fmt->encoding != q->encoding) {
 			continue;
+		}
 		if (fmt->precision != q->validbits) {
 			continue;
+		}
 		if (fmt->stride != q->precision) {
 			continue;
+		}
 		if (fmt->channels != q->channels) {
 			continue;
+		}
 		if (q->frequency_type == 0) {
 			if (fmt->sample_rate < q->frequency[0] ||
 			    fmt->sample_rate > q->frequency[1]) {
 				continue;
+			}
 		} else {
 			for (j = 0; j < q->frequency_type; j++) {
 				if (fmt->sample_rate == q->frequency[j])
 					break;
+			}
 			if (j == query.fmt.frequency_type) {
 				continue;
+			}
+		}
 		/* Matched. */
 		return 0;
+	}
 	return EINVAL;
+}
 /*
  * Set track mixer's format depending on ai->mode.
  * If AUMODE_PLAY is set in ai->mode, it set up the playback mixer
  * with ai.play.{channels, sample_rate}.
  * If AUMODE_RECORD is set in ai->mode, it set up the recording mixer
  * with ai.record.{channels, sample_rate}.
  * All other fields in ai are ignored.
  * If successful returns 0.  Otherwise returns errno.
  * This function does not roll back even if it fails.
  * Must be called with sc_lock held.
  */
 static int
 audio_mixers_set_format(struct audio_softc *sc, const struct audio_info *ai)
+{
 	audio_format2_t phwfmt;
 	audio_format2_t rhwfmt;
 	audio_filter_reg_t pfil;
 	audio_filter_reg_t rfil;
 	int mode;
 	int error;
 	KASSERT(mutex_owned(sc->sc_lock));
 	/*
 	 * Even when setting either one of playback and recording,
 	 * both must be halted.
 	 */
 	if (sc->sc_popens + sc->sc_ropens > 0)
 		return EBUSY;
 	if (!SPECIFIED(ai->mode) || ai->mode == 0)
 		return ENOTTY;
 	/* Only channels and sample_rate are changeable. */
 	mode = ai->mode;
 	if ((mode & AUMODE_PLAY)) {
 		phwfmt.encoding    = ai->play.encoding;
 		phwfmt.precision   = ai->play.precision;
 		phwfmt.stride      = ai->play.precision;
 		phwfmt.channels    = ai->play.channels;
 		phwfmt.sample_rate = ai->play.sample_rate;
+	}
 	if ((mode & AUMODE_RECORD)) {
 		rhwfmt.encoding    = ai->record.encoding;
 		rhwfmt.precision   = ai->record.precision;
 		rhwfmt.stride      = ai->record.precision;
 		rhwfmt.channels    = ai->record.channels;
 		rhwfmt.sample_rate = ai->record.sample_rate;
+	}
 	/* On non-independent devices, use the same format for both. */
 	if ((sc->sc_props & AUDIO_PROP_INDEPENDENT) == 0) {
 		if (mode == AUMODE_RECORD) {
 			phwfmt = rhwfmt;
 		} else {
 			rhwfmt = phwfmt;
+		}
 		mode = AUMODE_PLAY | AUMODE_RECORD;
+	}
 	/* Then, unset the direction not exist on the hardware. */
 	if ((sc->sc_props & AUDIO_PROP_PLAYBACK) == 0)
 		mode &= ~AUMODE_PLAY;
 	if ((sc->sc_props & AUDIO_PROP_CAPTURE) == 0)
 		mode &= ~AUMODE_RECORD;
 	/* debug */
 	if ((mode & AUMODE_PLAY)) {
 		TRACE(1, "play=%s/%d/%d/%dch/%dHz",
 		    audio_encoding_name(phwfmt.encoding),
 		    phwfmt.precision,
 		    phwfmt.stride,
 		    phwfmt.channels,
 		    phwfmt.sample_rate);
+	}
 	if ((mode & AUMODE_RECORD)) {
 		TRACE(1, "rec =%s/%d/%d/%dch/%dHz",
 		    audio_encoding_name(rhwfmt.encoding),
 		    rhwfmt.precision,
 		    rhwfmt.stride,
 		    rhwfmt.channels,
 		    rhwfmt.sample_rate);
+	}
 	/* Check the format */
 	if ((mode & AUMODE_PLAY)) {
 		if (audio_hw_validate_format(sc, AUMODE_PLAY, &phwfmt)) {
 			TRACE(1, "invalid format");
 			return EINVAL;
+		}
+	}
 	if ((mode & AUMODE_RECORD)) {
 		if (audio_hw_validate_format(sc, AUMODE_RECORD, &rhwfmt)) {
 			TRACE(1, "invalid format");
 			return EINVAL;
+		}
+	}
 	/* Configure the mixers. */
 	memset(&pfil, 0, sizeof(pfil));
 	memset(&rfil, 0, sizeof(rfil));
 	error = audio_hw_set_format(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
 	if (error)
 		return error;
 	error = audio_mixers_init(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
 	if (error)
 		return error;
 	return 0;
+}
 /*
  * Store current mixers format into *ai.
  */
 static void
 audio_mixers_get_format(struct audio_softc *sc, struct audio_info *ai)
+{
 	/*
 	 * There is no stride information in audio_info but it doesn't matter.
 	 * trackmixer always treats stride and precision as the same.
 	 */
 	AUDIO_INITINFO(ai);
 	ai->mode = 0;
 	if (sc->sc_pmixer) {
 		audio_format2_t *fmt = &sc->sc_pmixer->track_fmt;
 		ai->play.encoding    = fmt->encoding;
 		ai->play.precision   = fmt->precision;
 		ai->play.channels    = fmt->channels;
 		ai->play.sample_rate = fmt->sample_rate;
 		ai->mode |= AUMODE_PLAY;
+	}
 	if (sc->sc_rmixer) {
 		audio_format2_t *fmt = &sc->sc_rmixer->track_fmt;
 		ai->record.encoding    = fmt->encoding;
 		ai->record.precision   = fmt->precision;
 		ai->record.channels    = fmt->channels;
 		ai->record.sample_rate = fmt->sample_rate;
 		ai->mode |= AUMODE_RECORD;
+	}
+}
 /*
  * audio_info details:
+ *
  * ai.{play,record}.sample_rate		(R/W)
  * ai.{play,record}.encoding		(R/W)
  * ai.{play,record}.precision		(R/W)
  * ai.{play,record}.channels		(R/W)
  *	These specify the playback or recording format.
  *	Ignore members within an inactive track.
+ *
  * ai.mode				(R/W)
  *	It specifies the playback or recording mode, AUMODE_*.
  *	Currently, a mode change operation by ai.mode after opening is
  *	prohibited.  In addition, AUMODE_PLAY_ALL no longer makes sense.
  *	However, it's possible to get or to set for backward compatibility.
+ *
  * ai.{hiwat,lowat}			(R/W)
  *	These specify the high water mark and low water mark for playback
  *	track.  The unit is block.
+ *
  * ai.{play,record}.gain		(R/W)
  *	It specifies the HW mixer volume in 0-255.
  *	It is historical reason that the gain is connected to HW mixer.
+ *
  * ai.{play,record}.balance		(R/W)
  *	It specifies the left-right balance of HW mixer in 0-64.
  *	32 means the center.
  *	It is historical reason that the balance is connected to HW mixer.
+ *
  * ai.{play,record}.port		(R/W)
  *	It specifies the input/output port of HW mixer.
+ *
  * ai.monitor_gain			(R/W)
  *	It specifies the recording monitor gain(?) of HW mixer.
+ *
  * ai.{play,record}.pause		(R/W)
  *	Non-zero means the track is paused.
+ *
  * ai.play.seek				(R/-)
  *	It indicates the number of bytes written but not processed.
  * ai.record.seek			(R/-)
  *	It indicates the number of bytes to be able to read.
+ *
  * ai.{play,record}.avail_ports		(R/-)
  *	Mixer info.
+ *
  * ai.{play,record}.buffer_size		(R/-)
  *	It indicates the buffer size in bytes.  Internally it means usrbuf.
+ *
  * ai.{play,record}.samples		(R/-)
  *	It indicates the total number of bytes played or recorded.
+ *
  * ai.{play,record}.eof			(R/-)
  *	It indicates the number of times reached EOF(?).
+ *
  * ai.{play,record}.error		(R/-)
  *	Non-zero indicates overflow/underflow has occured.
+ *
  * ai.{play,record}.waiting		(R/-)
  *	Non-zero indicates that other process waits to open.
  *	It will never happen anymore.
+ *
  * ai.{play,record}.open		(R/-)
  *	Non-zero indicates the direction is opened by this process(?).
  *	XXX Is this better to indicate that "the device is opened by
  *	at least one process"?
+ *
  * ai.{play,record}.active		(R/-)
  *	Non-zero indicates that I/O is currently active.
+ *
  * ai.blocksize				(R/-)
  *	It indicates the block size in bytes.
  *	XXX The blocksize of playback and recording may be different.
  */
 /*
  * Pause consideration:
+ *
  * The introduction of these two behavior makes pause/unpause operation
  * simple.
  * 1. The first read/write access of the first track makes mixer start.
  * 2. A pause of the last track doesn't make mixer stop.
  */
 /*
  * Set both track's parameters within a file depending on ai.
  * Update sc_sound_[pr]* if set.
  * Must be called with sc_lock and sc_exlock held.
  */
 static int
 audio_file_setinfo(struct audio_softc *sc, audio_file_t *file,
 	const struct audio_info *ai)
+{
 	const struct audio_prinfo *pi;
 	const struct audio_prinfo *ri;
 	audio_track_t *ptrack;
 	audio_track_t *rtrack;
 	audio_format2_t pfmt;
 	audio_format2_t rfmt;
 	int pchanges;
 	int rchanges;
 	int mode;
 	struct audio_info saved_ai;
 	audio_format2_t saved_pfmt;
 	audio_format2_t saved_rfmt;
 	int error;
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(sc->sc_exlock);
 	pi = &ai->play;
 	ri = &ai->record;
 	pchanges = 0;
 	rchanges = 0;
 	ptrack = file->ptrack;
 	rtrack = file->rtrack;
 #if defined(AUDIO_DEBUG)
 	if (audiodebug >= 2) {
 		char buf[256];
 		char p[64];
 		int buflen;
 		int plen;
 #define SPRINTF(var, fmt...) do {	\
 	var##len += snprintf(var + var##len, sizeof(var) - var##len, fmt); \
 } while (0)
 		buflen = 0;
 		plen = 0;
 		if (SPECIFIED(pi->encoding))
 			SPRINTF(p, "/%s", audio_encoding_name(pi->encoding));
 		if (SPECIFIED(pi->precision))
 			SPRINTF(p, "/%dbit", pi->precision);
 		if (SPECIFIED(pi->channels))
 			SPRINTF(p, "/%dch", pi->channels);
 		if (SPECIFIED(pi->sample_rate))
 			SPRINTF(p, "/%dHz", pi->sample_rate);
 		if (plen > 0)
 			SPRINTF(buf, ",play.param=%s", p + 1);
 		plen = 0;
 		if (SPECIFIED(ri->encoding))
 			SPRINTF(p, "/%s", audio_encoding_name(ri->encoding));
 		if (SPECIFIED(ri->precision))
 			SPRINTF(p, "/%dbit", ri->precision);
 		if (SPECIFIED(ri->channels))
 			SPRINTF(p, "/%dch", ri->channels);
 		if (SPECIFIED(ri->sample_rate))
 			SPRINTF(p, "/%dHz", ri->sample_rate);
 		if (plen > 0)
 			SPRINTF(buf, ",record.param=%s", p + 1);
 		if (SPECIFIED(ai->mode))
 			SPRINTF(buf, ",mode=%d", ai->mode);
 		if (SPECIFIED(ai->hiwat))
 			SPRINTF(buf, ",hiwat=%d", ai->hiwat);
 		if (SPECIFIED(ai->lowat))
 			SPRINTF(buf, ",lowat=%d", ai->lowat);
 		if (SPECIFIED(ai->play.gain))
 			SPRINTF(buf, ",play.gain=%d", ai->play.gain);
 		if (SPECIFIED(ai->record.gain))
 			SPRINTF(buf, ",record.gain=%d", ai->record.gain);
 		if (SPECIFIED_CH(ai->play.balance))
 			SPRINTF(buf, ",play.balance=%d", ai->play.balance);
 		if (SPECIFIED_CH(ai->record.balance))
 			SPRINTF(buf, ",record.balance=%d", ai->record.balance);
 		if (SPECIFIED(ai->play.port))
 			SPRINTF(buf, ",play.port=%d", ai->play.port);
 		if (SPECIFIED(ai->record.port))
 			SPRINTF(buf, ",record.port=%d", ai->record.port);
 		if (SPECIFIED(ai->monitor_gain))
 			SPRINTF(buf, ",monitor_gain=%d", ai->monitor_gain);
 		if (SPECIFIED_CH(ai->play.pause))
 			SPRINTF(buf, ",play.pause=%d", ai->play.pause);
 		if (SPECIFIED_CH(ai->record.pause))
 			SPRINTF(buf, ",record.pause=%d", ai->record.pause);
 		if (buflen > 0)
 			TRACE(2, "specified %s", buf + 1);
+	}
 #endif
 	AUDIO_INITINFO(&saved_ai);
 	/* XXX shut up gcc */
 	memset(&saved_pfmt, 0, sizeof(saved_pfmt));
 	memset(&saved_rfmt, 0, sizeof(saved_rfmt));
 	/* Set default value and save current parameters */
 	if (ptrack) {
 		pfmt = ptrack->usrbuf.fmt;
 		saved_pfmt = ptrack->usrbuf.fmt;
 		saved_ai.play.pause = ptrack->is_pause;
+	}
 	if (rtrack) {
 		rfmt = rtrack->usrbuf.fmt;
 		saved_rfmt = rtrack->usrbuf.fmt;
 		saved_ai.record.pause = rtrack->is_pause;
+	}
 	saved_ai.mode = file->mode;
 	/* Overwrite if specified */
 	mode = file->mode;
 	if (SPECIFIED(ai->mode)) {
 		/*
 		 * Setting ai->mode no longer does anything because it's
 		 * prohibited to change playback/recording mode after open
 		 * and AUMODE_PLAY_ALL is obsoleted.  However, it still
 		 * keeps the state of AUMODE_PLAY_ALL itself for backward
 		 * compatibility.
 		 * In the internal, only file->mode has the state of
 		 * AUMODE_PLAY_ALL flag and track->mode in both track does
 		 * not have.
 		 */
 		if ((file->mode & AUMODE_PLAY)) {
 			mode = (file->mode & (AUMODE_PLAY | AUMODE_RECORD))
 			    | (ai->mode & AUMODE_PLAY_ALL);
+		}
+	}
 	if (ptrack) {
 		pchanges = audio_track_setinfo_check(&pfmt, pi);
 		if (pchanges == -1) {
 #if defined(AUDIO_DEBUG)
 			char fmtbuf[64];
 			audio_format2_tostr(fmtbuf, sizeof(fmtbuf), &pfmt);
 			TRACET(1, ptrack, "check play.params failed: %s",
 			    fmtbuf);
 #endif
 			return EINVAL;
+		}
 		if (SPECIFIED(ai->mode))
 			pchanges = 1;
+	}
 	if (rtrack) {
 		rchanges = audio_track_setinfo_check(&rfmt, ri);
 		if (rchanges == -1) {
 #if defined(AUDIO_DEBUG)
 			char fmtbuf[64];
 			audio_format2_tostr(fmtbuf, sizeof(fmtbuf), &rfmt);
 			TRACET(1, rtrack, "check record.params failed: %s",
 			    fmtbuf);
 #endif
 			return EINVAL;
+		}
 		if (SPECIFIED(ai->mode))
 			rchanges = 1;
+	}
 	/*
 	 * Even when setting either one of playback and recording,
 	 * both track must be halted.
 	 */
 	if (pchanges || rchanges) {
 		audio_file_clear(sc, file);
 #if defined(AUDIO_DEBUG)
 		char fmtbuf[64];
 		if (pchanges) {
 			audio_format2_tostr(fmtbuf, sizeof(fmtbuf), &pfmt);
 			DPRINTF(1, "audio track#%d play mode: %s\n",
 			    ptrack->id, fmtbuf);
+		}
 		if (rchanges) {
 			audio_format2_tostr(fmtbuf, sizeof(fmtbuf), &rfmt);
 			DPRINTF(1, "audio track#%d rec  mode: %s\n",
 			    rtrack->id, fmtbuf);
+		}
 #endif
+	}
 	/* Set mixer parameters */
 	error = audio_hw_setinfo(sc, ai, &saved_ai);
 	if (error)
 		goto abort1;
 	/* Set to track and update sticky parameters */
 	error = 0;
 	file->mode = mode;
 	if (ptrack) {
 		if (SPECIFIED_CH(pi->pause)) {
 			ptrack->is_pause = pi->pause;
 			sc->sc_sound_ppause = pi->pause;
+		}
 		if (pchanges) {
 			audio_track_lock_enter(ptrack);
 			error = audio_track_set_format(ptrack, &pfmt);
 			audio_track_lock_exit(ptrack);
 			if (error) {
 				TRACET(1, ptrack, "set play.params failed");
 				goto abort2;
+			}
 			sc->sc_sound_pparams = pfmt;
+		}
 		/* Change water marks after initializing the buffers. */
 		if (SPECIFIED(ai->hiwat) || SPECIFIED(ai->lowat))
 			audio_track_setinfo_water(ptrack, ai);
+	}
 	if (rtrack) {
 		if (SPECIFIED_CH(ri->pause)) {
 			rtrack->is_pause = ri->pause;
 			sc->sc_sound_rpause = ri->pause;
+		}
 		if (rchanges) {
 			audio_track_lock_enter(rtrack);
 			error = audio_track_set_format(rtrack, &rfmt);
 			audio_track_lock_exit(rtrack);
 			if (error) {
 				TRACET(1, rtrack, "set record.params failed");
 				goto abort3;
+			}
 			sc->sc_sound_rparams = rfmt;
+		}
+	}
 	return 0;
 	/* Rollback */
 abort3:
 	if (error != ENOMEM) {
 		rtrack->is_pause = saved_ai.record.pause;
 		audio_track_lock_enter(rtrack);
 		audio_track_set_format(rtrack, &saved_rfmt);
 		audio_track_lock_exit(rtrack);
+	}
 abort2:
 	if (ptrack && error != ENOMEM) {
 		ptrack->is_pause = saved_ai.play.pause;
 		audio_track_lock_enter(ptrack);
 		audio_track_set_format(ptrack, &saved_pfmt);
 		audio_track_lock_exit(ptrack);
 		sc->sc_sound_pparams = saved_pfmt;
 		sc->sc_sound_ppause = saved_ai.play.pause;
+	}
 	file->mode = saved_ai.mode;
 abort1:
 	audio_hw_setinfo(sc, &saved_ai, NULL);
 	return error;
+}
 /*
  * Write SPECIFIED() parameters within info back to fmt.
  * Return value of 1 indicates that fmt is modified.
  * Return value of 0 indicates that fmt is not modified.
  * Return value of -1 indicates that error EINVAL has occurred.
  */
 static int
 audio_track_setinfo_check(audio_format2_t *fmt, const struct audio_prinfo *info)
+{
 	int changes;
 	changes = 0;
 	if (SPECIFIED(info->sample_rate)) {
 		if (info->sample_rate < AUDIO_MIN_FREQUENCY)
 			return -1;
 		if (info->sample_rate > AUDIO_MAX_FREQUENCY)
 			return -1;
 		fmt->sample_rate = info->sample_rate;
 		changes = 1;
+	}
 	if (SPECIFIED(info->encoding)) {
 		fmt->encoding = info->encoding;
 		changes = 1;
+	}
 	if (SPECIFIED(info->precision)) {
 		fmt->precision = info->precision;
 		/* we don't have API to specify stride */
 		fmt->stride = info->precision;
 		changes = 1;
+	}
 	if (SPECIFIED(info->channels)) {
 		fmt->channels = info->channels;
 		changes = 1;
+	}
 	if (changes) {
 		if (audio_check_params(fmt) != 0)
 			return -1;
+	}
 	return changes;
+}
 /*
  * Change water marks for playback track if specfied.
  */
 static void
 audio_track_setinfo_water(audio_track_t *track, const struct audio_info *ai)
+{
 	u_int blks;
 	u_int maxblks;
 	u_int blksize;
 	KASSERT(audio_track_is_playback(track));