 @@ -1,14 +1,14 @@
-/*	$NetBSD: audio.c,v 1.28.2.4 2019/11/19 12:58:29 martin Exp $	*/
+/*	$NetBSD: audio.c,v 1.28.2.5 2020/01/02 09:18:15 martin Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -132,27 +132,27 @@
  *   these may be also called after attach, the thread lock is required.
+ *
  * In addition, there is an additional lock.
+ *
  * - track->lock.  This is an atomic variable and is similar to the
  *   "interrupt lock".  This is one for each track.  If any thread context
  *   (and software interrupt context) and hardware interrupt context who
  *   want to access some variables on this track, they must acquire this
  *   lock before.  It protects track's consistency between hardware
  *   interrupt context and others.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.28.2.4 2019/11/19 12:58:29 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.28.2.5 2020/01/02 09:18:15 martin Exp $");
 #ifdef _KERNEL_OPT
 #include "audio.h"
 #include "midi.h"
 #endif
 #if NAUDIO > 0
 #ifdef _KERNEL
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/atomic.h>
 @@ -3051,61 +3051,51 @@ audioctl_open(dev_t dev, struct audio_so
 	af = kmem_zalloc(sizeof(audio_file_t), KM_SLEEP);
 	af->sc = sc;
 	af->dev = dev;
 	/* Not necessary to insert sc_files. */
 	error = fd_clone(fp, fd, flags, &audio_fileops, af);
 	KASSERT(error == EMOVEFD);
 	return error;
+}
 /*
  * Reallocate 'memblock' with specified 'bytes' if 'bytes' > 0.
  * Or free 'memblock' and return NULL if 'byte' is zero.
  */
 static void *
 audio_realloc(void *memblock, size_t bytes)
 	if (memblock != NULL) {
 		if (bytes != 0) {
 			return kern_realloc(memblock, bytes, M_NOWAIT);
 		} else {
 			kern_free(memblock);
 			return NULL;
 	} else {
 		if (bytes != 0) {
 			return kern_malloc(bytes, M_NOWAIT);
 		} else {
 			return NULL;
 /*
  * Free 'mem' if available, and initialize the pointer.
  * For this reason, this is implemented as macro.
  */
 #define audio_free(mem)	do {	\
 	if (mem != NULL) {	\
 		kern_free(mem);	\
 		mem = NULL;	\
 	}	\
 } while (0)
 /*
  * (Re)allocate 'memblock' with specified 'bytes'.
  * bytes must not be 0.
  * This function never returns NULL.
  */
 static void *
 audio_realloc(void *memblock, size_t bytes)
+{
 	KASSERT(bytes != 0);
 	audio_free(memblock);
 	return kern_malloc(bytes, M_WAITOK);
+}
 /*
  * (Re)allocate usrbuf with 'newbufsize' bytes.
  * Use this function for usrbuf because only usrbuf can be mmapped.
  * If successful, it updates track->usrbuf.mem, track->usrbuf.capacity and
  * returns 0.  Otherwise, it clears track->usrbuf.mem, track->usrbuf.capacity
  * and returns errno.
  * It must be called before updating usrbuf.capacity.
  */
 static int
 audio_realloc_usrbuf(audio_track_t *track, int newbufsize)
+{
 	struct audio_softc *sc;
 	vaddr_t vstart;
 	vsize_t oldvsize;
 @@ -3650,38 +3640,36 @@ abort:
 #endif
 	return NULL;
+}
 /*
  * Initialize the codec stage of this track as necessary.
  * If successful, it initializes the codec stage as necessary, stores updated
  * last_dst in *last_dstp in any case, and returns 0.
  * Otherwise, it returns errno without modifying *last_dstp.
  */
 static int
 audio_track_init_codec(audio_track_t *track, audio_ring_t **last_dstp)
+{
 	struct audio_softc *sc;
 	audio_ring_t *last_dst;
 	audio_ring_t *srcbuf;
 	audio_format2_t *srcfmt;
 	audio_format2_t *dstfmt;
 	audio_filter_arg_t *arg;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	last_dst = *last_dstp;
 	dstfmt = &last_dst->fmt;
 	srcfmt = &track->inputfmt;
 	srcbuf = &track->codec.srcbuf;
 	error = 0;
 	if (srcfmt->encoding != dstfmt->encoding
 	 || srcfmt->precision != dstfmt->precision
 	 || srcfmt->stride != dstfmt->stride) {
 		track->codec.dst = last_dst;
 		srcbuf->fmt = *dstfmt;
 		srcbuf->fmt.encoding = srcfmt->encoding;
 @@ -3690,69 +3678,61 @@ audio_track_init_codec(audio_track_t *tr
 		track->codec.filter = audio_track_get_codec(track,
 		    &srcbuf->fmt, dstfmt);
 		if (track->codec.filter == NULL) {
 			error = EINVAL;
 			goto abort;
+		}
 		srcbuf->head = 0;
 		srcbuf->used = 0;
 		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
 		len = auring_bytelen(srcbuf);
 		srcbuf->mem = audio_realloc(srcbuf->mem, len);
 		if (srcbuf->mem == NULL) {
 			device_printf(sc->sc_dev, "%s: malloc(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 		arg = &track->codec.arg;
 		arg->srcfmt = &srcbuf->fmt;
 		arg->dstfmt = dstfmt;
 		arg->context = NULL;
 		*last_dstp = srcbuf;
 		return 0;
+	}
 abort:
 	track->codec.filter = NULL;
 	audio_free(srcbuf->mem);
 	return error;
+}
 /*
  * Initialize the chvol stage of this track as necessary.
  * If successful, it initializes the chvol stage as necessary, stores updated
  * last_dst in *last_dstp in any case, and returns 0.
  * Otherwise, it returns errno without modifying *last_dstp.
  */
 static int
 audio_track_init_chvol(audio_track_t *track, audio_ring_t **last_dstp)
+{
 	struct audio_softc *sc;
 	audio_ring_t *last_dst;
 	audio_ring_t *srcbuf;
 	audio_format2_t *srcfmt;
 	audio_format2_t *dstfmt;
 	audio_filter_arg_t *arg;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	last_dst = *last_dstp;
 	dstfmt = &last_dst->fmt;
 	srcfmt = &track->inputfmt;
 	srcbuf = &track->chvol.srcbuf;
 	error = 0;
 	/* Check whether channel volume conversion is necessary. */
 	bool use_chvol = false;
 	for (int ch = 0; ch < srcfmt->channels; ch++) {
 		if (track->ch_volume[ch] != 256) {
 			use_chvol = true;
 			break;
+		}
 @@ -3760,71 +3740,62 @@ audio_track_init_chvol(audio_track_t *tr
 	if (use_chvol == true) {
 		track->chvol.dst = last_dst;
 		track->chvol.filter = audio_track_chvol;
 		srcbuf->fmt = *dstfmt;
 		/* no format conversion occurs */
 		srcbuf->head = 0;
 		srcbuf->used = 0;
 		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
 		len = auring_bytelen(srcbuf);
 		srcbuf->mem = audio_realloc(srcbuf->mem, len);
 		if (srcbuf->mem == NULL) {
 			device_printf(sc->sc_dev, "%s: malloc(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 		arg = &track->chvol.arg;
 		arg->srcfmt = &srcbuf->fmt;
 		arg->dstfmt = dstfmt;
 		arg->context = track->ch_volume;
 		*last_dstp = srcbuf;
 		return 0;
+	}
 abort:
 	track->chvol.filter = NULL;
 	audio_free(srcbuf->mem);
 	return error;
+}
 /*
  * Initialize the chmix stage of this track as necessary.
  * If successful, it initializes the chmix stage as necessary, stores updated
  * last_dst in *last_dstp in any case, and returns 0.
  * Otherwise, it returns errno without modifying *last_dstp.
  */
 static int
 audio_track_init_chmix(audio_track_t *track, audio_ring_t **last_dstp)
+{
 	struct audio_softc *sc;
 	audio_ring_t *last_dst;
 	audio_ring_t *srcbuf;
 	audio_format2_t *srcfmt;
 	audio_format2_t *dstfmt;
 	audio_filter_arg_t *arg;
 	u_int srcch;
 	u_int dstch;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	last_dst = *last_dstp;
 	dstfmt = &last_dst->fmt;
 	srcfmt = &track->inputfmt;
 	srcbuf = &track->chmix.srcbuf;
 	error = 0;
 	srcch = srcfmt->channels;
 	dstch = dstfmt->channels;
 	if (srcch != dstch) {
 		track->chmix.dst = last_dst;
 		if (srcch >= 2 && dstch == 1) {
 			track->chmix.filter = audio_track_chmix_mixLR;
 @@ -3835,73 +3806,64 @@ audio_track_init_chmix(audio_track_t *tr
 		} else {
 			track->chmix.filter = audio_track_chmix_expand;
+		}
 		srcbuf->fmt = *dstfmt;
 		srcbuf->fmt.channels = srcch;
 		srcbuf->head = 0;
 		srcbuf->used = 0;
 		/* XXX The buffer size should be able to calculate. */
 		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
 		len = auring_bytelen(srcbuf);
 		srcbuf->mem = audio_realloc(srcbuf->mem, len);
 		if (srcbuf->mem == NULL) {
 			device_printf(sc->sc_dev, "%s: malloc(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 		arg = &track->chmix.arg;
 		arg->srcfmt = &srcbuf->fmt;
 		arg->dstfmt = dstfmt;
 		arg->context = NULL;
 		*last_dstp = srcbuf;
 		return 0;
+	}
 abort:
 	track->chmix.filter = NULL;
 	audio_free(srcbuf->mem);
 	return error;
+}
 /*
  * Initialize the freq stage of this track as necessary.
  * If successful, it initializes the freq stage as necessary, stores updated
  * last_dst in *last_dstp in any case, and returns 0.
  * Otherwise, it returns errno without modifying *last_dstp.
  */
 static int
 audio_track_init_freq(audio_track_t *track, audio_ring_t **last_dstp)
+{
 	struct audio_softc *sc;
 	audio_ring_t *last_dst;
 	audio_ring_t *srcbuf;
 	audio_format2_t *srcfmt;
 	audio_format2_t *dstfmt;
 	audio_filter_arg_t *arg;
 	uint32_t srcfreq;
 	uint32_t dstfreq;
 	u_int dst_capacity;
 	u_int mod;
 	u_int len;
 	int error;
 	KASSERT(track);
 	sc = track->mixer->sc;
 	last_dst = *last_dstp;
 	dstfmt = &last_dst->fmt;
 	srcfmt = &track->inputfmt;
 	srcbuf = &track->freq.srcbuf;
 	error = 0;
 	srcfreq = srcfmt->sample_rate;
 	dstfreq = dstfmt->sample_rate;
 	if (srcfreq != dstfreq) {
 		track->freq.dst = last_dst;
 		memset(track->freq_prev, 0, sizeof(track->freq_prev));
 		memset(track->freq_curr, 0, sizeof(track->freq_curr));
 @@ -3920,43 +3882,36 @@ audio_track_init_freq(audio_track_t *tra
 		} else {
 			track->freq.filter = audio_track_freq_down;
 			track->freq_current = 0;
+		}
 		srcbuf->fmt = *dstfmt;
 		srcbuf->fmt.sample_rate = srcfreq;
 		srcbuf->head = 0;
 		srcbuf->used = 0;
 		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
 		len = auring_bytelen(srcbuf);
 		srcbuf->mem = audio_realloc(srcbuf->mem, len);
 		if (srcbuf->mem == NULL) {
 			device_printf(sc->sc_dev, "%s: malloc(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 		arg = &track->freq.arg;
 		arg->srcfmt = &srcbuf->fmt;
 		arg->dstfmt = dstfmt;/*&last_dst->fmt;*/
 		arg->context = track;
 		*last_dstp = srcbuf;
 		return 0;
+	}
 abort:
 	track->freq.filter = NULL;
 	audio_free(srcbuf->mem);
 	return error;
+}
 /*
  * When playing back: (e.g. if codec and freq stage are valid)
+ *
  *               write
  *                | uiomove
  *                v
  *  usrbuf      [...............]  byte ring buffer (mmap-able)
  *                | memcpy
 @@ -4118,32 +4073,26 @@ audio_track_set_format(audio_track_t *tr
 	/* Stage input buffer */
 	track->input = last_dst;
 	/*
 	 * On the recording track, make the first stage a ring buffer.
 	 * XXX is there a better way?
 	 */
 	if (audio_track_is_record(track)) {
 		track->input->capacity = NBLKOUT *
 		    frame_per_block(track->mixer, &track->input->fmt);
 		len = auring_bytelen(track->input);
 		track->input->mem = audio_realloc(track->input->mem, len);
 		if (track->input->mem == NULL) {
 			device_printf(sc->sc_dev, "malloc input(%d) failed\n",
 			    len);
 			error = ENOMEM;
 			goto error;
+	}
 	/*
 	 * Output buffer.
 	 * On the playback track, its capacity is NBLKOUT blocks.
 	 * On the recording track, its capacity is 1 block.
 	 */
 	track->outbuf.head = 0;
 	track->outbuf.used = 0;
 	track->outbuf.capacity = frame_per_block(track->mixer,
 	    &track->outbuf.fmt);
 	if (audio_track_is_playback(track))
 		track->outbuf.capacity *= NBLKOUT;
 @@ -4718,33 +4667,26 @@ audio_mixer_init(struct audio_softc *sc,
 		mixer->swap_endian = true;
 		TRACE(1, "swap_endian");
+	}
 	if (mode == AUMODE_PLAY) {
 		/* Mixing buffer */
 		mixer->mixfmt = mixer->track_fmt;
 		mixer->mixfmt.precision *= 2;
 		mixer->mixfmt.stride *= 2;
 		/* XXX TODO: use some macros? */
 		len = mixer->frames_per_block * mixer->mixfmt.channels *
 		    mixer->mixfmt.stride / NBBY;
 		mixer->mixsample = audio_realloc(mixer->mixsample, len);
 		if (mixer->mixsample == NULL) {
 			device_printf(sc->sc_dev,
 			    "%s: malloc mixsample(%d) failed\n",
 			    __func__, len);
 			error = ENOMEM;
 			goto abort;
 	} else {
 		/* No mixing buffer for recording */
+	}
 	if (reg->codec) {
 		mixer->codec = reg->codec;
 		mixer->codecarg.context = reg->context;
 		if (mode == AUMODE_PLAY) {
 			mixer->codecarg.srcfmt = &mixer->track_fmt;
 			mixer->codecarg.dstfmt = &mixer->hwbuf.fmt;
 		} else {
 			mixer->codecarg.srcfmt = &mixer->hwbuf.fmt;
 			mixer->codecarg.dstfmt = &mixer->track_fmt;