 @@ -1,14 +1,14 @@
-/*	$NetBSD: audio.c,v 1.297 2017/01/26 04:15:38 nat Exp $	*/
+/*	$NetBSD: audio.c,v 1.298 2017/01/27 05:05:51 nat Exp $	*/
 /*-
  * Copyright (c) 2016 Nathanial Sloss <nathanialsloss@yahoo.com.au>
  * All rights reserved.
+ *
  * 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
 @@ -138,27 +138,27 @@
  *	query_devinfo 		-	x
  *	allocm 			-	-	Called at attach time
  *	freem 			-	-	Called at attach time
  *	round_buffersize 	-	x
  *	mappage 		-	-	Mem. unchanged after attach
  *	get_props 		-	x
  *	trigger_output 		x	x
  *	trigger_input 		x	x
  *	dev_ioctl 		-	x
  *	get_locks 		-	-	Called at attach time
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.297 2017/01/26 04:15:38 nat Exp $");
+__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.298 2017/01/27 05:05:51 nat Exp $");
 #include "audio.h"
 #if NAUDIO > 0
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include <sys/select.h>
 #include <sys/poll.h>
 #include <sys/kmem.h>
 #include <sys/malloc.h>
 @@ -1751,27 +1751,27 @@ audio_init_ringbuffer(struct audio_softc
 	DPRINTF(("audio_init_ringbuffer: final blksize=%d\n", blksize));
 	rp->blksize = blksize;
 	rp->maxblks = nblks;
 	rp->s.end = rp->s.start + nblks * blksize;
 	rp->s.outp = rp->s.inp = rp->s.start;
 	rp->s.used = 0;
 	rp->stamp = 0;
 	rp->stamp_last = 0;
 	rp->fstamp = 0;
 	rp->drops = 0;
 	rp->copying = false;
 	rp->needfill = false;
 	rp->mmapped = false;
-	memset(rp->s.start, 0, blksize * 2);
+	memset(rp->s.start, 0, AU_RING_SIZE);
+}
 int
 audio_initbufs(struct audio_softc *sc, int n)
+{
 	const struct audio_hw_if *hw;
 	struct virtual_channel *vc;
 	int error;
 	DPRINTF(("audio_initbufs: mode=0x%x\n", sc->sc_vchan[n]->sc_mode));
 	vc = sc->sc_vchan[0];
 	hw = sc->hw_if;
 	if (audio_can_capture(sc) || (sc->sc_vchan[n]->sc_open & AUOPEN_READ)) {
 @@ -3215,65 +3215,58 @@ audiostartr(struct audio_softc *sc, int
 	if (sc->sc_rec_started == false) {
 		mix_read(sc);
 		cv_broadcast(&sc->sc_rcondvar);
+	}
 	vc->sc_rbus = true;
 	return 0;
+}
 int
 audiostartp(struct audio_softc *sc, int n)
+{
 	struct virtual_channel *vc = sc->sc_vchan[n];
-	int used, error;
+	int error, used;
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(mutex_owned(sc->sc_intr_lock));
 	error = 0;
 	used = audio_stream_get_used(&vc->sc_mpr.s);
 	DPRINTF(("audiostartp: start=%p used=%d(hi=%d blk=%d) mmapped=%d\n",
 		 vc->sc_mpr.s.start, used, vc->sc_mpr.usedhigh,
 		 vc->sc_mpr.blksize, vc->sc_mpr.mmapped));
 	if (!audio_can_playback(sc))
 		return EINVAL;
 	if (!vc->sc_mpr.mmapped && used < vc->sc_mpr.blksize) {
 		cv_broadcast(&sc->sc_wchan);
 		DPRINTF(("%s: wakeup and return\n", __func__));
 		return 0;
+	}
 	vc->sc_pbus = true;
-	if (sc->sc_opens > 0) {
+	if (sc->sc_trigger_started == false) {
-		mix_func(sc, &vc->sc_mpr, n);
+		audio_mix(sc);
 		mix_write(sc);
 		if (sc->sc_trigger_started == false) {
 			sc->sc_pr.s.inp = audio_stream_add_inp(&sc->sc_pr.s,
 			    sc->sc_pr.s.inp, vc->sc_mpr.blksize);
 			mix_write(sc);
 			audio_mix(sc);
 			vc = sc->sc_vchan[0];
 			if (sc->hw_if->trigger_output == NULL) {
 				vc->sc_mpr.s.outp =
 				    audio_stream_add_outp(&vc->sc_mpr.s,
 				      vc->sc_mpr.s.outp, vc->sc_mpr.blksize);
 			mix_write(sc);
-			cv_broadcast(&sc->sc_condvar);
+		vc = sc->sc_vchan[0];
 		vc->sc_mpr.s.outp =
 		    audio_stream_add_outp(&vc->sc_mpr.s,
 		      vc->sc_mpr.s.outp, vc->sc_mpr.blksize);
 		audio_mix(sc);
 		mix_write(sc);
 		cv_broadcast(&sc->sc_condvar);
+	}
 	return error;
+}
 /*
  * When the play interrupt routine finds that the write isn't keeping
  * the buffer filled it will insert silence in the buffer to make up
  * for this.  The part of the buffer that is filled with silence
  * is kept track of in a very approximate way: it starts at sc_sil_start
  * and extends sc_sil_count bytes.  If there is already silence in
  * the requested area nothing is done; so when the whole buffer is
  * silent nothing happens.  When the writer starts again sc_sil_count
 @@ -3407,41 +3400,41 @@ audio_mix(void *v)
 	int n, i;
 	sc = v;
 	DPRINTF(("PINT MIX\n"));
 	sc->schedule_rih = false;
 	sc->schedule_wih = false;
 	sc->sc_writeme = false;
 	if (sc->sc_dying == true)
 		return;
 	i = sc->sc_opens;
 	blksize = sc->sc_vchan[0]->sc_mpr.blksize;
 	for (n = 1; n < VAUDIOCHANS; n++) {
 		if (!sc->sc_opens || i <= 0)
 			break;		/* ignore interrupt if not open */
 		if (sc->sc_audiopid[n].pid == -1)
 			continue;
 		i--;
 		vc = sc->sc_vchan[n];
 		if (!vc->sc_open)
 			continue;
 		if (!vc->sc_pbus)
 			continue;
 		cb = &vc->sc_mpr;
 		blksize = sc->sc_vchan[0]->sc_mpr.blksize;
 		sc->sc_writeme = true;
 		inp = cb->s.inp;
 		cb->stamp += blksize;
 		if (cb->mmapped) {
 			DPRINTF(("audio_pint: mmapped outp=%p cc=%d inp=%p\n",
 				     cb->s.outp, blksize, cb->s.inp));
 			mix_func(sc, cb, n);
 			continue;
+		}
 #ifdef AUDIO_INTR_TIME
 @@ -3522,47 +3515,47 @@ audio_mix(void *v)
 				    cc);
 				/* Clear next block to keep ahead of the DMA. */
 				used = audio_stream_get_used(&cb->s);
 				if (used + blksize < cb->s.end - cb->s.start) {
 					audio_pint_silence(sc, cb, cb->s.inp,
 					    blksize, n);
+				}
+			}
+		}
 		DPRINTFN(5, ("audio_pint: outp=%p cc=%d\n", cb->s.outp,
 			 blksize));
 		cb->s.outp = audio_stream_add_outp(&cb->s, cb->s.outp, blksize);
 		mix_func(sc, cb, n);
 		cb->s.outp = audio_stream_add_outp(&cb->s, cb->s.outp, blksize);
 		DPRINTFN(2, ("audio_pint: mode=%d pause=%d used=%d lowat=%d\n",
 			     vc->sc_mode, cb->pause,
 			     audio_stream_get_used(vc->sc_pustream),
 			     cb->usedlow));
 		if ((vc->sc_mode & AUMODE_PLAY) && !cb->pause) {
 			if (audio_stream_get_used(&cb->s) <= cb->usedlow)
 				sc->schedule_wih = true;
+		}
 		/* Possible to return one or more "phantom blocks" now. */
 		if (!vc->sc_full_duplex && vc->sc_mode & AUMODE_RECORD)
 				sc->schedule_rih = true;
+	}
 	if (sc->sc_saturate == true && sc->sc_opens > 1)
 		saturate_func(sc);
 	cb = &sc->sc_pr;
-	cb->s.inp = audio_stream_add_inp(&cb->s, cb->s.inp, cb->blksize);
+	cb->s.inp = audio_stream_add_inp(&cb->s, cb->s.inp, blksize);
 	kpreempt_disable();
 	if (sc->schedule_wih == true)
 		softint_schedule(sc->sc_sih_wr);
 	if (sc->schedule_rih == true)
 		softint_schedule(sc->sc_sih_rd);
 	kpreempt_enable();
 	cc = sc->sc_vchan[0]->sc_mpr.blksize;
 	if (sc->sc_writeme == false) {
 		sc->sc_vchan[0]->sc_mpr.drops += cc;
 		cv_broadcast(&sc->sc_wchan);