 @@ -1,14 +1,14 @@
-/*	$NetBSD: midi.c,v 1.81 2014/07/25 08:10:35 dholland Exp $	*/
+/*	$NetBSD: midi.c,v 1.81.2.1 2015/01/11 14:13:25 martin Exp $	*/
 /*
  * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (augustss@NetBSD.org), (MIDI FST and Active
  * Sense handling) Chapman Flack (chap@NetBSD.org), and 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
 @@ -21,27 +21,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: midi.c,v 1.81 2014/07/25 08:10:35 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: midi.c,v 1.81.2.1 2015/01/11 14:13:25 martin Exp $");
 #include "midi.h"
 #include "sequencer.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/proc.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 @@ -194,26 +194,31 @@ midiactivate(device_t self, enum devact
 int
 mididetach(device_t self, int flags)
+{
 	struct midi_softc *sc = device_private(self);
 	int maj, mn;
 	DPRINTFN(2,("%s: sc=%p flags=%d\n", __func__, sc, flags));
 	pmf_device_deregister(self);
 	mutex_enter(sc->lock);
 	sc->dying = 1;
 	if (--sc->refcnt >= 0) {
 		/* Wake anything? */
 		(void)cv_timedwait(&sc->detach_cv, sc->lock, hz * 60);
+	}
 	cv_broadcast(&sc->wchan);
 	cv_broadcast(&sc->rchan);
 	mutex_exit(sc->lock);
 	/* locate the major number */
 	maj = cdevsw_lookup_major(&midi_cdevsw);
 	/*
 	 * Nuke the vnodes for any open instances (calls close).
 	 * Will wait until any activity on the device nodes has ceased.
+	 *
 	 * XXXAD NOT YET.
+	 *
 @@ -226,28 +231,37 @@ mididetach(device_t self, int flags)
 		evcnt_detach(&sc->xmt.bytesDiscarded);
 		evcnt_detach(&sc->xmt.incompleteMessages);
+	}
 	if (sc->props & MIDI_PROP_CAN_INPUT) {
 		evcnt_detach(&sc->rcv.bytesDiscarded);
 		evcnt_detach(&sc->rcv.incompleteMessages);
+	}
 	if (sc->sih != NULL) {
 		softint_disestablish(sc->sih);
 		sc->sih = NULL;
+	}
 	mutex_enter(sc->lock);
 	callout_halt(&sc->xmt_asense_co, sc->lock);
 	callout_halt(&sc->rcv_asense_co, sc->lock);
 	mutex_exit(sc->lock);
 	callout_destroy(&sc->xmt_asense_co);
 	callout_destroy(&sc->rcv_asense_co);
 	cv_destroy(&sc->wchan);
 	cv_destroy(&sc->rchan);
 	cv_destroy(&sc->detach_cv);
 	return (0);
+}
 void
 midi_attach(struct midi_softc *sc)
+{
 	struct midi_info mi;
 	kmutex_t *dummy;
 	static int first = 1;
 	if (first) {
 		mutex_init(&hwif_softc_lock, MUTEX_DEFAULT, IPL_NONE);
 @@ -256,29 +270,31 @@ midi_attach(struct midi_softc *sc)
 	sc->hw_if->get_locks(sc->hw_hdl, &sc->lock, &dummy);
 	callout_init(&sc->xmt_asense_co, CALLOUT_MPSAFE);
 	callout_init(&sc->rcv_asense_co, CALLOUT_MPSAFE);
 	callout_setfunc(&sc->xmt_asense_co, midi_xmt_asense, sc);
 	callout_setfunc(&sc->rcv_asense_co, midi_rcv_asense, sc);
 	sc->sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE,
 	    midi_softint, sc);
 	cv_init(&sc->rchan, "midird");
 	cv_init(&sc->wchan, "midiwr");
 	cv_init(&sc->detach_cv, "mididet");
 	sc->dying = 0;
 	sc->isopen = 0;
 	sc->refcnt = 0;
 	mutex_enter(&hwif_softc_lock);
 	mutex_enter(sc->lock);
 	hwif_softc = sc;
 	sc->hw_if->getinfo(sc->hw_hdl, &mi);
 	hwif_softc = NULL;
 	mutex_exit(sc->lock);
 	mutex_exit(&hwif_softc_lock);
 	sc->props = mi.props;
 	if (!(sc->props & MIDI_PROP_NO_OUTPUT)) {
 		evcnt_attach_dynamic(&sc->xmt.bytesDiscarded,
 @@ -854,26 +870,28 @@ static int
 midiclose(dev_t dev, int flags, int ifmt, struct lwp *l)
+{
 	struct midi_softc *sc;
 	const struct midi_hw_if *hw;
 	sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
 	hw = sc->hw_if;
 	DPRINTFN(3,("midiclose %p\n", sc));
 	mutex_enter(sc->lock);
 	/* midi_start_output(sc); anything buffered => pbus already set! */
 	while (sc->pbus) {
 		if (sc->dying)
 			break;
 		DPRINTFN(8,("midiclose sleep ...\n"));
 		cv_wait(&sc->wchan, sc->lock);
+	}
 	sc->isopen = 0;
 	callout_halt(&sc->xmt_asense_co, sc->lock);
 	callout_halt(&sc->rcv_asense_co, sc->lock);
 	hw->close(sc->hw_hdl);
 	sc->seqopen = 0;
 	sc->seq_md = 0;
 	mutex_exit(sc->lock);
 	return 0;
+}
 @@ -942,35 +960,43 @@ midiread(dev_t dev, struct uio *uio, int
 		/* move the bytes */
 		if (appetite > 0) {
 			first = 0;  /* we know we won't return empty-handed */
 			/* do two uiomoves if data wrap around end of buf */
 			if (buf_cur + appetite > buf_end) {
 				DPRINTFN(8,
 					("midiread: uiomove cc=%td (prewrap)\n",
 					buf_end - buf_cur));
 				mutex_exit(sc->lock);
 				error = uiomove(buf_cur, buf_end - buf_cur, uio);
 				mutex_enter(sc->lock);
 				if (error)
 					break;
 				if (sc->dying) {
 					error = EIO;
 					break;
+				}
 				appetite -= buf_end - buf_cur;
 				buf_cur = mb->buf;
+			}
 			DPRINTFN(8, ("midiread: uiomove cc=%d\n", appetite));
 			mutex_exit(sc->lock);
 			error = uiomove(buf_cur, appetite, uio);
 			mutex_enter(sc->lock);
 			if (error)
 				break;
 			if (sc->dying) {
 				error = EIO;
 				break;
+			}
 			buf_cur += appetite;
+		}
 		MIDI_BUF_WRAP(idx);
 		MIDI_BUF_WRAP(buf);
 		MIDI_BUF_CONSUMER_WBACK(mb,idx);
 		MIDI_BUF_CONSUMER_WBACK(mb,buf);
 		if (0 == uio->uio_resid) /* if read satisfied, we're done */
 			break;
 		MIDI_BUF_CONSUMER_REFRESH(mb,idx);
 		if (idx_cur == idx_lim) { /* need to wait for data? */
 			if (!first || sc->rcv_eof) /* never block reader if */
 				break;            /* any data already in hand */
 @@ -1243,33 +1269,33 @@ midi_intr_out(struct midi_softc *sc)
 	while (idx_cur != idx_lim) {
 		if (sc->hw_if_ext) {
 			error = midi_msg_out(sc, &idx_cur, &idx_lim,
 			    &buf_cur, &buf_lim);
 			if (!error ) /* no EINPROGRESS from extended hw_if */
 				armed = 1;
 			break;
+		}
 		/* or, lacking hw_if_ext ... */
 		msglen = MB_IDX_LEN(*idx_cur);
 		error = sc->hw_if->output(sc->hw_hdl, *buf_cur);
 		if (error &&  error != EINPROGRESS)
 			break;
-		++ buf_cur;
+		++buf_cur;
 		MIDI_BUF_WRAP(buf);
-		-- msglen;
+		--msglen;
 		if (msglen)
 			*idx_cur = PACK_MB_IDX(MB_IDX_CAT(*idx_cur),msglen);
 		else {
-			++ idx_cur;
+			++idx_cur;
 			MIDI_BUF_WRAP(idx);
+		}
 		if (!error) {
 			armed = 1;
 			break;
+		}
+	}
 	MIDI_BUF_CONSUMER_WBACK(mb,idx);
 	MIDI_BUF_CONSUMER_WBACK(mb,buf);
 	if (!armed) {
 		sc->pbus = 0;
 		callout_schedule(&sc->xmt_asense_co, MIDI_XMT_ASENSE_PERIOD);
+	}
 @@ -1296,115 +1322,128 @@ midi_start_output(struct midi_softc *sc)
 		return midi_intr_out(sc);
 	return midi_poll_out(sc);
+}
 static int
 real_writebytes(struct midi_softc *sc, u_char *ibuf, int cc)
+{
 	u_char *iend;
 	struct midi_buffer *mb;
 	int arming, count, got;
 	enum fst_form form;
 	MIDI_BUF_DECLARE(idx);
 	MIDI_BUF_DECLARE(buf);
 	int error;
 	KASSERT(mutex_owned(sc->lock));
 	if (sc->dying || !sc->isopen)
 		return EIO;
 	sc->refcnt++;
 	iend = ibuf + cc;
 	mb = &sc->outbuf;
 	arming = 0;
 	/*
 	 * If the hardware uses the extended hw_if, pass it canonicalized
 	 * messages (or compressed ones if it specifically requests, using
 	 * VCOMP form so the bottom half can still pass the op and chan along);
 	 * if it does not, send it compressed messages (using COMPR form as
 	 * there is no need to preserve the status for the bottom half).
 	 */
 	if (NULL == sc->hw_if_ext)
 		form = FST_COMPR;
 	else if (sc->hw_if_ext->compress)
 		form = FST_VCOMP;
 	else
 		form = FST_CANON;
 	MIDI_BUF_PRODUCER_INIT(mb,idx);
 	MIDI_BUF_PRODUCER_INIT(mb,buf);
 	if (sc->dying)
 		return EIO;
 	while (ibuf < iend) {
 		got = midi_fst(&sc->xmt, *ibuf, form);
-		++ ibuf;
+		++ibuf;
 		switch ( got) {
 		case FST_MORE:
 			continue;
 		case FST_ERR:
 		case FST_HUH:
-			return EPROTO;
+			error = EPROTO;
 			goto out;
 		case FST_CHN:
 		case FST_CHV: /* only occurs in VCOMP form */
 		case FST_COM:
 		case FST_RT:
 		case FST_SYX:
 		case FST_SXP:
 			break; /* go add to buffer */
 #if defined(AUDIO_DEBUG) || defined(DIAGNOSTIC)
 		default:
 			printf("midi_wr: midi_fst returned %d?!\n", got);
 #endif
+		}
 		count = sc->xmt.end - sc->xmt.pos;
 		if (0 == count ) /* can happen with stray 0xf7; see midi_fst */
 			continue;
 		/*
 		 * return EWOULDBLOCK if the data passed will not fit in
 		 * the buffer; the caller should have taken steps to avoid that.
 		 * If got==FST_SXP we lose the new status byte, but we're losing
 		 * anyway, so c'est la vie.
 		 */
 		if (idx_cur == idx_lim || count > buf_lim - buf_cur) {
 			MIDI_BUF_PRODUCER_REFRESH(mb,idx); /* get the most */
 			MIDI_BUF_PRODUCER_REFRESH(mb,buf); /*  current facts */
-			if (idx_cur == idx_lim || count > buf_lim - buf_cur)
+			if (idx_cur == idx_lim || count > buf_lim - buf_cur) {
-				return EWOULDBLOCK; /* caller's problem */
+				error = EWOULDBLOCK; /* caller's problem */
 				goto out;
+			}
+		}
 		*idx_cur++ = PACK_MB_IDX(got,count);
 		MIDI_BUF_WRAP(idx);
 		while (count) {
 			*buf_cur++ = *(sc->xmt.pos)++;
 			MIDI_BUF_WRAP(buf);
 			-- count;
+		}
 		if (FST_SXP == got)
 			-- ibuf; /* again with same status byte */
+	}
 	MIDI_BUF_PRODUCER_WBACK(mb,buf);
 	MIDI_BUF_PRODUCER_WBACK(mb,idx);
 	/*
 	 * If the output transfer is not already busy, and there is a message
 	 * buffered, mark it busy, stop the Active Sense callout (what if we're
 	 * too late and it's expired already? No big deal, an extra Active Sense
 	 * never hurt anybody) and start the output transfer once we're out of
 	 * the critical section (pbus==1 will stop anyone else doing the same).
 	 */
 	MIDI_BUF_CONSUMER_INIT(mb,idx); /* check what consumer's got to read */
 	if (!sc->pbus && idx_cur < idx_lim) {
 		sc->pbus = 1;
 		callout_stop(&sc->xmt_asense_co);
 		arming = 1;
+	}
 	return arming ? midi_start_output(sc) : 0;
 	error = arming ? midi_start_output(sc) : 0;
 out:
 	if (--sc->refcnt < 0)
 		cv_broadcast(&sc->detach_cv);
 	return error;
+}
 static int
 midiwrite(dev_t dev, struct uio *uio, int ioflag)
+{
 	struct midi_softc *sc;
 	struct midi_buffer *mb;
 	int error;
 	u_char inp[256];
 	MIDI_BUF_DECLARE(idx);
 	MIDI_BUF_DECLARE(buf);
 	size_t idxspace;
 	size_t bufspace;
 @@ -1412,66 +1451,70 @@ midiwrite(dev_t dev, struct uio *uio, in
 	int pollout = 0;
 	(void)buf_end; (void)idx_end;
 	sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
 	DPRINTFN(6,("midiwrite: %p, unit=%d, count=%lu\n", sc, (int)minor(dev),
 	    (unsigned long)uio->uio_resid));
 	mutex_enter(sc->lock);
 	if (sc->dying) {
 		mutex_exit(sc->lock);
 		return EIO;
+	}
 	sc->refcnt++;
 	mb = &sc->outbuf;
 	error = 0;
 	while (uio->uio_resid > 0 && !error) {
 		/*
 		 * block if necessary for the minimum buffer space to guarantee
 		 * we can write something.
 		 */
 		MIDI_BUF_PRODUCER_INIT(mb,idx); /* init can't go above loop; */
 		MIDI_BUF_PRODUCER_INIT(mb,buf); /* real_writebytes moves cur */
 		for (;;) {
 			idxspace = MIDI_BUF_PRODUCER_REFRESH(mb,idx) - idx_cur;
 			bufspace = MIDI_BUF_PRODUCER_REFRESH(mb,buf) - buf_cur;
 			if (idxspace >= 1 && bufspace >= 3 && !pollout)
 				break;
 			DPRINTFN(8,("midi_write: sleep idx=%zd buf=%zd\n",
 				 idxspace, bufspace));
 			if (ioflag & IO_NDELAY) {
 				/*
 				 * If some amount has already been transferred,
 				 * the common syscall code will automagically
 				 * convert this to success with a short count.
 				 */
-				mutex_exit(sc->lock);
+				error = EWOULDBLOCK;
-				return EWOULDBLOCK;
+				goto out;
+			}
 			if (pollout) {
 				mutex_exit(sc->lock);
 				yield(); /* see midi_poll_output */
 				mutex_enter(sc->lock);
 				pollout = 0;
 			} else
 				error = cv_wait_sig(&sc->wchan, sc->lock);
 			if (sc->dying)
 				error = EIO;
 			if (error) {
 				/*
 				 * Similarly, the common code will handle
 				 * EINTR and ERESTART properly here, changing to
 				 * a short count if something transferred.
 				 */
-				mutex_exit(sc->lock);
+				goto out;
 				return error;
+			}
+		}
 		/*
 		 * The number of bytes we can safely extract from the uio
 		 * depends on the available idx and buf space. Worst case,
 		 * every byte is a message so 1 idx is required per byte.
 		 * Worst case, the first byte completes a 3-byte msg in prior
 		 * state, and every subsequent byte is a Program Change or
 		 * Channel Pressure msg with running status and expands to 2
 		 * bytes, so the buf space reqd is 3+2(n-1) or 2n+1. So limit
 		 * the transfer to the min of idxspace and (bufspace-1)>>1.
 		 */
 @@ -1482,192 +1525,220 @@ midiwrite(dev_t dev, struct uio *uio, in
 			xfrcount = sizeof inp;
 		if (xfrcount > uio->uio_resid)
 			xfrcount = uio->uio_resid;
 		mutex_exit(sc->lock);
 		error = uiomove(inp, xfrcount, uio);
 		mutex_enter(sc->lock);
 #ifdef MIDI_DEBUG
 		if (error)
 		        printf("midi_write:(1) uiomove failed %d; "
 			       "xfrcount=%zu inp=%p\n",
 			       error, xfrcount, inp);
 #endif
-		if ( error )
+		if (error)
 			break;
 		/*
 		 * The number of bytes we extracted being calculated to
 		 * definitely fit in the buffer even with canonicalization,
 		 * there is no excuse for real_writebytes to return EWOULDBLOCK.
 		 */
 		error = real_writebytes(sc, inp, xfrcount);
 		KASSERT(error != EWOULDBLOCK);
 		if (error)
 			break;
 		/*
 		 * If this is a polling device and we just sent a buffer, let's
 		 * not send another without giving some other process a chance.
 		 */
 		if ((sc->props & MIDI_PROP_OUT_INTR) == 0)
 			pollout = 1;
 		DPRINTFN(8,("midiwrite: uio_resid now %zu, props=%d\n",
 		    uio->uio_resid, sc->props));
+	}
 out:
 	if (--sc->refcnt < 0)
 		cv_broadcast(&sc->detach_cv);
 	mutex_exit(sc->lock);
 	return error;
+}
 /*
  * This write routine is only called from sequencer code and expects
  * a write that is smaller than the MIDI buffer.
  */
 int
 midi_writebytes(int unit, u_char *bf, int cc)
+{
 	struct midi_softc *sc =
 	    device_lookup_private(&midi_cd, unit);
 	int error;
 	if (!sc)
 		return EIO;
 	DPRINTFN(7, ("midi_writebytes: %p, unit=%d, cc=%d %#02x %#02x %#02x\n",
                     sc, unit, cc, bf[0], bf[1], bf[2]));
 	mutex_enter(sc->lock);
-	error = real_writebytes(sc, bf, cc);
+	if (sc->dying)
 		error = EIO;
 	else
 		error = real_writebytes(sc, bf, cc);
 	mutex_exit(sc->lock);
 	return error;
+}
 static int
 midiioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
+{
 	struct midi_softc *sc;
 	const struct midi_hw_if *hw;
 	int error;
 	MIDI_BUF_DECLARE(buf);
 	(void)buf_end;
-	sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));;
+	sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
 	if (sc->dying)
 	mutex_enter(sc->lock);
 	if (sc->dying) {
 		mutex_exit(sc->lock);
 		return EIO;
+	}
 	hw = sc->hw_if;
 	error = 0;
 	sc->refcnt++;
 	DPRINTFN(5,("midiioctl: %p cmd=0x%08lx\n", sc, cmd));
 	switch (cmd) {
 	case FIONBIO:
 		/* All handled in the upper layer. */
 		break;
 	case FIONREAD:
 		/*
 		 * This code relies on the current implementation of midi_in
 		 * always updating buf and idx together in a critical section,
 		 * so buf always ends at a message boundary. Document this
 		 * ioctl as always returning a value such that the last message
 		 * included is complete (SysEx the only exception), and then
 		 * make sure the implementation doesn't regress.  NB that
 		 * means if this ioctl returns n and the proc then issues a
 		 * read of n, n bytes will be read, but if the proc issues a
 		 * read of m < n, fewer than m bytes may be read to ensure the
 		 * read ends at a message boundary.
 		 */
 		mutex_enter(sc->lock);
 		MIDI_BUF_CONSUMER_INIT(&sc->inbuf,buf);
 		*(int *)addr = buf_lim - buf_cur;
 		mutex_exit(sc->lock);
 		break;
 	case FIOASYNC:
 		mutex_exit(sc->lock);
 		mutex_enter(proc_lock);
 		if (*(int *)addr) {
 			if (sc->async) {
 				error = EBUSY;
 			} else {
 				sc->async = curproc->p_pid;
+			}
 			DPRINTFN(5,("midi_ioctl: FIOASYNC %d\n",
 			    curproc->p_pid));
 		} else {
 			sc->async = 0;
+		}
 		mutex_exit(proc_lock);
 		mutex_enter(sc->lock);
 		break;
 #if 0
 	case MIDI_PRETIME:
 		/* XXX OSS
 		 * This should set up a read timeout, but that's
 		 * why we have poll(), so there's nothing yet. */
 		error = EINVAL;
 		break;
 #endif
 #ifdef MIDI_SAVE
 	case MIDI_GETSAVE:
 		mutex_exit(sc->lock);
 		error = copyout(&midisave, *(void **)addr, sizeof midisave);
 		mutex_enter(sc->lock);
   		break;
 #endif
 	default:
 		if (hw->ioctl != NULL) {
 			mutex_enter(sc->lock);
 			error = hw->ioctl(sc->hw_hdl, cmd, addr, flag, l);
 		 	mutex_exit(sc->lock);
 		} else {
 			error = EINVAL;
+		}
 		break;
+	}
 	if (--sc->refcnt < 0)
 		cv_broadcast(&sc->detach_cv);
 	mutex_exit(sc->lock);
 	return error;
+}
 static int
 midipoll(dev_t dev, int events, struct lwp *l)
+{
 	struct midi_softc *sc;
 	int revents;
 	MIDI_BUF_DECLARE(idx);
 	MIDI_BUF_DECLARE(buf);
 	(void)buf_end; (void)idx_end;
 	sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
 	revents = 0;
 	DPRINTFN(6,("midipoll: %p events=0x%x\n", sc, events));
 	mutex_enter(sc->lock);
 	if (sc->dying) {
 		mutex_exit(sc->lock);
 		return POLLHUP;
+	}
 	sc->refcnt++;
 	if ((events & (POLLIN | POLLRDNORM)) != 0) {
 		MIDI_BUF_CONSUMER_INIT(&sc->inbuf, idx);
 		if (idx_cur < idx_lim)
 			revents |= events & (POLLIN | POLLRDNORM);
 		else
 			selrecord(l, &sc->rsel);
+	}
 	if ((events & (POLLOUT | POLLWRNORM)) != 0) {
 		MIDI_BUF_PRODUCER_INIT(&sc->outbuf, idx);
 		MIDI_BUF_PRODUCER_INIT(&sc->outbuf, buf);
 		if (idx_lim - idx_cur >= 1 && buf_lim - buf_cur >= 3)
 			revents |= events & (POLLOUT | POLLWRNORM);
 		else
 			selrecord(l, &sc->wsel);
+	}
 	if (--sc->refcnt < 0)
 		cv_broadcast(&sc->detach_cv);
 	mutex_exit(sc->lock);
 	return revents;
+}
 static void
 filt_midirdetach(struct knote *kn)
+{
 	struct midi_softc *sc = kn->kn_hook;
 	mutex_enter(sc->lock);
 	SLIST_REMOVE(&sc->rsel.sel_klist, kn, knote, kn_selnext);
 	mutex_exit(sc->lock);
 @@ -1699,68 +1770,85 @@ filt_midiwdetach(struct knote *kn)
 	mutex_enter(sc->lock);
 	SLIST_REMOVE(&sc->wsel.sel_klist, kn, knote, kn_selnext);
 	mutex_exit(sc->lock);
+}
 static int
 filt_midiwrite(struct knote *kn, long hint)
+{
 	struct midi_softc *sc = kn->kn_hook;
 	MIDI_BUF_DECLARE(idx);
 	MIDI_BUF_DECLARE(buf);
 	mutex_exit(sc->lock);
 	sc->refcnt++;
 	mutex_enter(sc->lock);
 	(void)idx_end; (void)buf_end;
 	if (hint != NOTE_SUBMIT)
 		mutex_enter(sc->lock);
 	MIDI_BUF_PRODUCER_INIT(&sc->outbuf,idx);
 	MIDI_BUF_PRODUCER_INIT(&sc->outbuf,buf);
 	kn->kn_data = ((buf_lim - buf_cur)-1)>>1;
 	if (kn->kn_data > idx_lim - idx_cur)
 		kn->kn_data = idx_lim - idx_cur;
 	if (hint != NOTE_SUBMIT)
 		mutex_exit(sc->lock);
 	// XXXMRG -- move this up, avoid the relock?
 	mutex_enter(sc->lock);
 	if (--sc->refcnt < 0)
 		cv_broadcast(&sc->detach_cv);
 	mutex_exit(sc->lock);
 	return (kn->kn_data > 0);
+}
 static const struct filterops midiwrite_filtops =
 	{ 1, NULL, filt_midiwdetach, filt_midiwrite };
 int
 midikqfilter(dev_t dev, struct knote *kn)
+{
 	struct midi_softc *sc =
 	    device_lookup_private(&midi_cd, MIDIUNIT(dev));
 	struct klist *klist;
 	mutex_exit(sc->lock);
 	sc->refcnt++;
 	mutex_enter(sc->lock);
 	switch (kn->kn_filter) {
 	case EVFILT_READ:
 		klist = &sc->rsel.sel_klist;
 		kn->kn_fop = &midiread_filtops;
 		break;
 	case EVFILT_WRITE:
 		klist = &sc->wsel.sel_klist;
 		kn->kn_fop = &midiwrite_filtops;
 		break;
 	default:
 		return (EINVAL);
+	}
 	kn->kn_hook = sc;
 	mutex_enter(sc->lock);
 	SLIST_INSERT_HEAD(klist, kn, kn_selnext);
 	if (--sc->refcnt < 0)
 		cv_broadcast(&sc->detach_cv);
 	mutex_exit(sc->lock);
 	return (0);
+}
 void
 midi_getinfo(dev_t dev, struct midi_info *mi)
+{
 	struct midi_softc *sc;
 	sc = device_lookup_private(&midi_cd, MIDIUNIT(dev));
 	if (sc == NULL)
 		return;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sequencer.c,v 1.59 2014/07/25 08:10:35 dholland Exp $	*/
+/*	$NetBSD: sequencer.c,v 1.59.2.1 2015/01/11 14:13:25 martin Exp $	*/
 /*
  * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (augustss@NetBSD.org) and 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.
 @@ -45,27 +45,27 @@
  * o MIDI softc locks.  These can be spinlocks and there can be many of
  *   them, because we can open many MIDI devices.  We take these only in two
  *   places: when enabling redirection from the MIDI device and when
  *   disabling it (open/close).  midiseq_in() is called by the MIDI driver
  *   with its own lock held when passing data into this module.  To avoid
  *   lock order and context problems, we package the received message as a
  *   sequencer_pcqitem_t and put onto a producer-consumer queue.  A soft
  *   interrupt is scheduled to dequeue and decode the message later where we
  *   can safely acquire the sequencer device's sc_lock.  PCQ is lockless for
  *   multiple producer, single consumer settings like this one.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sequencer.c,v 1.59 2014/07/25 08:10:35 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sequencer.c,v 1.59.2.1 2015/01/11 14:13:25 martin Exp $");
 #include "sequencer.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/proc.h>
 #include <sys/systm.h>
 #include <sys/syslog.h>
 @@ -164,91 +164,96 @@ const struct cdevsw sequencer_cdevsw = {
 	.d_ioctl = sequencerioctl,
 	.d_stop = nostop,
 	.d_tty = notty,
 	.d_poll = sequencerpoll,
 	.d_mmap = nommap,
 	.d_kqfilter = sequencerkqfilter,
 	.d_discard = nodiscard,
 	.d_flag = D_OTHER | D_MPSAFE
 };
 static LIST_HEAD(, sequencer_softc) sequencers = LIST_HEAD_INITIALIZER(sequencers);
 static kmutex_t sequencer_lock;
 static void
-sequencerdestroy(struct sequencer_softc *sc) {
+sequencerdestroy(struct sequencer_softc *sc)
+{
 	callout_halt(&sc->sc_callout, &sc->lock);
 	callout_destroy(&sc->sc_callout);
 	softint_disestablish(sc->sih);
 	cv_destroy(&sc->rchan);
 	cv_destroy(&sc->wchan);
 	cv_destroy(&sc->lchan);
 	if (sc->pcq)
 		pcq_destroy(sc->pcq);
 	kmem_free(sc, sizeof(*sc));
+}
 static struct sequencer_softc *
-sequencercreate(int unit) {
+sequencercreate(int unit)
+{
 	struct sequencer_softc *sc = kmem_zalloc(sizeof(*sc), KM_SLEEP);
 	if (sc == NULL) {
 #ifdef DIAGNOSTIC
 		printf("%s: out of memory\n", __func__);
 #endif
 		return NULL;
+	}
 	sc->sc_unit = unit;
 	callout_init(&sc->sc_callout, CALLOUT_MPSAFE);
 	sc->sih = softint_establish(SOFTINT_NET | SOFTINT_MPSAFE,
 	    seq_softintr, sc);
 	mutex_init(&sc->lock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&sc->rchan, "midiseqr");
 	cv_init(&sc->wchan, "midiseqw");
 	cv_init(&sc->lchan, "midiseql");
 	sc->pcq = pcq_create(SEQ_MAXQ, KM_SLEEP);
 	if (sc->pcq == NULL) {
 		sequencerdestroy(sc);
 		return NULL;
+	}
 	return sc;
+}
 static struct sequencer_softc *
-sequencerget(int unit) {
+sequencerget(int unit)
+{
 	struct sequencer_softc *sc;
 	if (unit < 0) {
 #ifdef DIAGNOSTIC
 		panic("%s: unit %d!", __func__, unit);
 #endif
 		return NULL;
+	}
 	mutex_enter(&sequencer_lock);
 	LIST_FOREACH(sc, &sequencers, sc_link) {
 		if (sc->sc_unit == unit) {
 			mutex_exit(&sequencer_lock);
 			return sc;
+		}
+	}
 	mutex_exit(&sequencer_lock);
 	if ((sc = sequencercreate(unit)) == NULL)
 		return NULL;
 	mutex_enter(&sequencer_lock);
 	LIST_INSERT_HEAD(&sequencers, sc, sc_link);
 	mutex_exit(&sequencer_lock);
 	return sc;
+}
 #ifdef notyet
 static void
-sequencerput(struct sequencer_softc *sc) {
+sequencerput(struct sequencer_softc *sc)
+{
 	mutex_enter(&sequencer_lock);
 	LIST_REMOVE(sc, sc_link);
 	mutex_exit(&sequencer_lock);
 	sequencerdestroy(sc);
+}
 #endif
 void
 sequencerattach(int n)
+{
 	mutex_init(&sequencer_lock, MUTEX_DEFAULT, IPL_NONE);
+}
 @@ -284,27 +289,27 @@ sequencer_enter(dev_t dev, struct sequen
 		sequencer_exit(sc);
 		return EIO;
+	}
 	*scp = sc;
 	return 0;
+}
 static int
 sequenceropen(dev_t dev, int flags, int ifmt, struct lwp *l)
+{
 	struct sequencer_softc *sc;
 	struct midi_dev *md;
 	struct midi_softc *msc;
-	int error, unit;
+	int error, unit, mdno;
 	DPRINTF(("sequenceropen\n"));
 	if ((error = sequencer_enter(dev, &sc)) != 0)
 		return error;
 	if (sc->isopen != 0) {
 		sequencer_exit(sc);
 		return EBUSY;
+	}
 	if (SEQ_IS_OLD(SEQUENCERUNIT(dev)))
 		sc->mode = SEQ_OLD;
 	else
 @@ -327,39 +332,48 @@ sequenceropen(dev_t dev, int flags, int
 	SEQ_QINIT(&sc->outq);
 	sc->lowat = SEQ_MAXQ / 2;
 	if (sc->ndevs > 0) {
 		mutex_exit(&sc->lock);
 		sc->devs = kmem_alloc(sc->ndevs * sizeof(struct midi_dev *),
 		    KM_SLEEP);
 		for (unit = 0; unit < sc->ndevs; unit++) {
 			md = midiseq_open(unit, flags);
 			if (md) {
 				sc->devs[sc->nmidi++] = md;
 				md->seq = sc;
 				md->doingsysex = 0;
 				DPRINTF(("%s: midi unit %d opened as seq %p\n",
 				    __func__, unit, md));
 			} else {
 				DPRINTF(("%s: midi unit %d not opened as seq\n",
 				    __func__, unit));
+			}
+		}
 		mutex_enter(&sc->lock);
 	} else {
 		sc->devs = NULL;
+	}
 	/* Only now redirect input from MIDI devices. */
-	for (unit = 0; unit < sc->nmidi; unit++) {
+	for (mdno = 0; mdno < sc->nmidi; mdno++) {
-		msc = sc->devs[unit]->msc;
+		extern struct cfdriver midi_cd;
 		mutex_enter(msc->lock);
-		msc->seqopen = 1;
+		msc = device_lookup_private(&midi_cd, sc->devs[mdno]->unit);
-		mutex_exit(msc->lock);
+		if (msc) {
 			mutex_enter(msc->lock);
 			msc->seqopen = 1;
 			mutex_exit(msc->lock);
+		}
+	}
 	seq_reset(sc);
 	sequencer_exit(sc);
 	DPRINTF(("%s: mode=%d, nmidi=%d\n", __func__, sc->mode, sc->nmidi));
 	return 0;
+}
 static int
 seq_drain(struct sequencer_softc *sc)
+{
 	int error;
 @@ -419,58 +433,62 @@ seq_startoutput(struct sequencer_softc *
 	while (!SEQ_QEMPTY(q) && !sc->timeout) {
 		SEQ_QGET(q, cmd);
 		seq_do_command(sc, &cmd);
+	}
+}
 static int
 sequencerclose(dev_t dev, int flags, int ifmt, struct lwp *l)
+{
 	struct sequencer_softc *sc;
 	struct midi_softc *msc;
 	int unit, error;
-	DPRINTF(("sequencerclose: %"PRIx64"\n", dev));
+	DPRINTF(("%s: %"PRIx64"\n", __func__, dev));
 	if ((error = sequencer_enter(dev, &sc)) != 0)
 		return error;
 	seq_drain(sc);
 	if (sc->timeout) {
 		callout_halt(&sc->sc_callout, &sc->lock);
 		sc->timeout = 0;
+	}
 	/* Bin input from MIDI devices. */
 	for (unit = 0; unit < sc->nmidi; unit++) {
-		msc = sc->devs[unit]->msc;
+		extern struct cfdriver midi_cd;
 		mutex_enter(msc->lock);
-		msc->seqopen = 0;
+		msc = device_lookup_private(&midi_cd, unit);
-		mutex_exit(msc->lock);
+		if (msc) {
 			mutex_enter(msc->lock);
 			msc->seqopen = 0;
 			mutex_exit(msc->lock);
+		}
+	}
 	mutex_exit(&sc->lock);
 	for (unit = 0; unit < sc->nmidi; unit++)
 		if (sc->devs[unit] != NULL)
 			midiseq_close(sc->devs[unit]);
 	if (sc->devs != NULL) {
 		KASSERT(sc->ndevs > 0);
 		kmem_free(sc->devs, sc->ndevs * sizeof(struct midi_dev *));
 		sc->devs = NULL;
+	}
 	mutex_enter(&sc->lock);
 	sc->isopen = 0;
 	sequencer_exit(sc);
-	DPRINTF(("sequencerclose: %"PRIx64" done\n", dev));
+	DPRINTF(("%s: %"PRIx64" done\n", __func__, dev));
 	return (0);
+}
 static int
 seq_input_event(struct sequencer_softc *sc, seq_event_t *cmd)
+{
 	struct sequencer_queue *q;
 	KASSERT(mutex_owned(&sc->lock));
 	DPRINTFN(2, ("seq_input_event: %02x %02x %02x %02x %02x "
 	    "%02x %02x %02x\n", cmd->tag,
 @@ -550,41 +568,41 @@ seq_softintr(void *addr)
 	default: /* this is now the point where MIDI_ACKs disappear */
 		mutex_exit(&sc->lock);
 		return;
+	}
 	microtime(&now);
 	if (!sc->timer.running)
 		now = sc->timer.stoptime;
 	SUBTIMEVAL(&now, &sc->timer.reftime);
 	t = now.tv_sec * 1000000 + now.tv_usec;
 	t /= sc->timer.usperdiv;
 	t += sc->timer.divs_lastchange;
 	if (t != sc->input_stamp) {
 		seq_input_event(sc, &SEQ_MK_TIMING(WAIT_ABS, .divisions=t));
-		sc->input_stamp = t; /* XXX wha hoppen if timer is reset? */
+		sc->input_stamp = t; /* XXX what happens if timer is reset? */
+	}
 	seq_input_event(sc, &ev);
 	mutex_exit(&sc->lock);
+}
 static int
 sequencerread(dev_t dev, struct uio *uio, int ioflag)
+{
 	struct sequencer_softc *sc;
 	struct sequencer_queue *q;
 	seq_event_t ev;
 	int error;
-	DPRINTFN(20, ("sequencerread: %"PRIx64", count=%d, ioflag=%x\n",
+	DPRINTFN(2, ("sequencerread: %"PRIx64", count=%d, ioflag=%x\n",
 	   dev, (int)uio->uio_resid, ioflag));
 	if ((error = sequencer_enter(dev, &sc)) != 0)
 		return error;
 	q = &sc->inq;
 	if (sc->mode == SEQ_OLD) {
 		sequencer_exit(sc);
 		DPRINTFN(-1,("sequencerread: old read\n"));
 		return EINVAL; /* XXX unimplemented */
+	}
 	while (SEQ_QEMPTY(q)) {
 		if (ioflag & IO_NDELAY) {
 @@ -691,27 +709,27 @@ sequencerioctl(dev_t dev, u_long cmd, vo
 	if ((error = sequencer_enter(dev, &sc)) != 0)
 		return error;
 	switch (cmd) {
 	case FIONBIO:
 		/* All handled in the upper FS layer. */
 		break;
 	case FIOASYNC:
 		if (*(int *)addr) {
 			if (sc->async != 0)
 				return EBUSY;
 			sc->async = curproc->p_pid;
-			DPRINTF(("sequencer_ioctl: FIOASYNC %d\n",
+			DPRINTF(("%s: FIOASYNC %d\n", __func__,
 			    sc->async));
 		} else {
 			sc->async = 0;
+		}
 		break;
 	case SEQUENCER_RESET:
 		seq_reset(sc);
 		break;
 	case SEQUENCER_PANIC:
 		seq_reset(sc);
 		/* Do more?  OSS doesn't */
 @@ -777,26 +795,27 @@ sequencerioctl(dev_t dev, u_long cmd, vo
 		break;
 	case SEQUENCER_TMR_STOP:
 		error = seq_do_timing(sc, &SEQ_MK_TIMING(STOP));
 		break;
 	case SEQUENCER_TMR_CONTINUE:
 		error = seq_do_timing(sc, &SEQ_MK_TIMING(CONTINUE));
 		break;
 	case SEQUENCER_TMR_TEMPO:
 		error = seq_do_timing(sc,
 		    &SEQ_MK_TIMING(TEMPO, .bpm=*(int *)addr));
 		RECALC_USPERDIV(&sc->timer);
 		if (error == 0)
 			*(int *)addr = sc->timer.tempo_beatpermin;
 		break;
 	case SEQUENCER_TMR_SOURCE:
 		*(int *)addr = SEQUENCER_TMR_INTERNAL;
 		break;
 	case SEQUENCER_TMR_METRONOME:
 		/* noop */
 		break;
 	case SEQUENCER_THRESHOLD:
 @@ -830,27 +849,27 @@ sequencerioctl(dev_t dev, u_long cmd, vo
 	sequencer_exit(sc);
 	return error;
+}
 static int
 sequencerpoll(dev_t dev, int events, struct lwp *l)
+{
 	struct sequencer_softc *sc;
 	int revents = 0;
 	if ((sc = sequencerget(SEQUENCERUNIT(dev))) == NULL)
 		return ENXIO;
-	DPRINTF(("sequencerpoll: %p events=0x%x\n", sc, events));
+	DPRINTF(("%s: %p events=0x%x\n", __func__, sc, events));
 	mutex_enter(&sc->lock);
 	if (events & (POLLIN | POLLRDNORM))
 		if ((sc->flags&FREAD) && !SEQ_QEMPTY(&sc->inq))
 			revents |= events & (POLLIN | POLLRDNORM);
 	if (events & (POLLOUT | POLLWRNORM))
 		if ((sc->flags&FWRITE) && SEQ_QLEN(&sc->outq) < sc->lowat)
 			revents |= events & (POLLOUT | POLLWRNORM);
 	if (revents == 0) {
 		if ((sc->flags&FREAD) && (events & (POLLIN | POLLRDNORM)))
 			selrecord(l, &sc->rsel);
 @@ -961,27 +980,27 @@ sequencerkqfilter(dev_t dev, struct knot
 	mutex_exit(&sc->lock);
 	return (0);
+}
 static void
 seq_reset(struct sequencer_softc *sc)
+{
 	int i, chn;
 	struct midi_dev *md;
 	KASSERT(mutex_owned(&sc->lock));
-	if ( !(sc->flags & FWRITE) )
+	if (!(sc->flags & FWRITE))
 	        return;
 	for (i = 0; i < sc->nmidi; i++) {
 		md = sc->devs[i];
 		midiseq_reset(md);
 		for (chn = 0; chn < MAXCHAN; chn++) {
 			midiseq_ctlchange(md, chn, &SEQ_MK_CHN(CTL_CHANGE,
 			    .controller=MIDI_CTRL_NOTES_OFF));
 			midiseq_ctlchange(md, chn, &SEQ_MK_CHN(CTL_CHANGE,
 			    .controller=MIDI_CTRL_RESET));
 			midiseq_pitchbend(md, chn, &SEQ_MK_CHN(PITCH_BEND,
 			    .value=MIDI_BEND_NEUTRAL));
+		}
+	}
 @@ -1104,27 +1123,27 @@ seq_do_local(struct sequencer_softc *sc,
 static int
 seq_do_sysex(struct sequencer_softc *sc, seq_event_t *b)
+{
 	int dev, i;
 	struct midi_dev *md;
 	uint8_t *bf = b->sysex.buffer;
 	KASSERT(mutex_owned(&sc->lock));
 	dev = b->sysex.device;
 	if (dev < 0 || dev >= sc->nmidi)
 		return (ENXIO);
-	DPRINTF(("seq_do_sysex: dev=%d\n", dev));
+	DPRINTF(("%s: dev=%d\n", __func__, dev));
 	md = sc->devs[dev];
 	if (!md->doingsysex) {
 		midiseq_out(md, (uint8_t[]){MIDI_SYSEX_START}, 1, 0);
 		md->doingsysex = 1;
+	}
 	for (i = 0; i < 6 && bf[i] != 0xff; i++)
+		;
 	midiseq_out(md, bf, i, 0);
 	if (i < 6 || (i > 0 && bf[i-1] == MIDI_SYSEX_END))
 		md->doingsysex = 0;
 	return 0;
 @@ -1156,27 +1175,27 @@ seq_timer_waitabs(struct sequencer_softc
 #ifdef DIAGNOSTIC
 		if (ticks > 20 * hz) {
 			/* Waiting more than 20s */
 			printf("seq_timer_waitabs: funny ticks=%d, "
 			       "usec=%lld\n", ticks, usec);
+		}
 #endif
 		sc->timeout = 1;
 		callout_reset(&sc->sc_callout, ticks,
 		    seq_timeout, sc);
+	}
 #ifdef SEQUENCER_DEBUG
 	else if (tick < 0)
-		DPRINTF(("seq_timer_waitabs: ticks = %d\n", ticks));
+		DPRINTF(("%s: ticks = %d\n", __func__, ticks));
 #endif
+}
 static int
 seq_do_timing(struct sequencer_softc *sc, seq_event_t *b)
+{
 	struct syn_timer *t = &sc->timer;
 	struct timeval when;
 	int error;
 	KASSERT(mutex_owned(&sc->lock));
 	error = 0;
 @@ -1217,31 +1236,31 @@ seq_do_timing(struct sequencer_softc *sc
 		t->divs_lastchange = t->divs_lastevent;
 		microtime(&t->reftime);
 		RECALC_USPERDIV(t);
 		break;
 	case TMR_ECHO:
 		error = seq_input_event(sc, b);
 		break;
 	case TMR_RESET:
 		t->divs_lastevent = t->divs_lastchange = 0;
 		microtime(&t->reftime);
 		break;
 	case TMR_SPP:
 	case TMR_TIMESIG:
-		DPRINTF(("seq_do_timing: unimplemented %02x\n", b->timing.op));
+		DPRINTF(("%s: unimplemented %02x\n", __func__, b->timing.op));
 		error = EINVAL; /* not quite accurate... */
 		break;
 	default:
-		DPRINTF(("seq_timer: unknown %02x\n", b->timing.op));
+		DPRINTF(("%s: unknown %02x\n", __func__, b->timing.op));
 		error = EINVAL;
 		break;
+	}
 	return (error);
+}
 static int
 seq_do_fullsize(struct sequencer_softc *sc, seq_event_t *b, struct uio *uio)
+{
 	struct sysex_info sysex;
 	u_int dev;
 #ifdef DIAGNOSTIC
 @@ -1335,27 +1354,27 @@ seq_to_new(seq_event_t *ev, struct uio *
 		 */
 		*ev = SEQ_MK_TIMING(RESET);
 		break;
 	case SEQOLD_PGMCHANGE:
 		*ev = SEQ_MK_CHN(PGM_CHANGE,
 		    .device=0, .channel=chan, .program=note);
 		break;
 	case SEQOLD_MIDIPUTC:
 		break;		/* interpret in normal mode */
 	case SEQOLD_ECHO:
 	case SEQOLD_PRIVATE:
 	case SEQOLD_EXTENDED:
 	default:
-		DPRINTF(("seq_to_new: not impl 0x%02x\n", cmd));
+		DPRINTF(("%s: not impl 0x%02x\n", __func__, cmd));
 		return EINVAL;
 	/* In case new-style events show up */
 	case SEQ_TIMING:
 	case SEQ_CHN_VOICE:
 	case SEQ_CHN_COMMON:
 	case SEQ_FULLSIZE:
 		break;
+	}
 	return 0;
+}
 /**********************************************/
 @@ -1410,27 +1429,26 @@ midiseq_open(int unit, int flags)
 	/* Only after we have acquired reference via VOP_OPEN(). */
 	midi_getinfo(dev, &mi);
 	oflags = flags;
 	if ((mi.props & MIDI_PROP_CAN_INPUT) == 0)
 	        flags &= ~FREAD;
 	if ((flags & (FREAD|FWRITE)) == 0) {
 		VOP_CLOSE(vp, oflags, kauth_cred_get());
 		vrele(vp);
 	        return NULL;
+	}
 	sc = device_lookup_private(&midi_cd, unit);
 	md = kmem_zalloc(sizeof(*md), KM_SLEEP);
 	md->msc = sc;
 	md->unit = unit;
 	md->name = mi.name;
 	md->subtype = 0;
 	md->nr_voices = 128;	/* XXX */
 	md->instr_bank_size = 128; /* XXX */
 	md->vp = vp;
 	if (mi.props & MIDI_PROP_CAN_INPUT)
 		md->capabilities |= SYNTH_CAP_INPUT;
 	sc->seq_md = md;
 	return (md);
+}
 static void
 @@ -1441,28 +1459,28 @@ midiseq_close(struct midi_dev *md)
 	kmem_free(md, sizeof(*md));
+}
 static void
 midiseq_reset(struct midi_dev *md)
+{
 	/* XXX send GM reset? */
 	DPRINTFN(3, ("midiseq_reset: %d\n", md->unit));
+}
 static int
 midiseq_out(struct midi_dev *md, u_char *bf, u_int cc, int chk)
+{
-	DPRINTFN(5, ("midiseq_out: m=%p, unit=%d, bf[0]=0x%02x, cc=%d\n",
+	DPRINTFN(5, ("midiseq_out: md=%p, unit=%d, bf[0]=0x%02x, cc=%d\n",
-		     md->msc, md->unit, bf[0], cc));
+		     md, md->unit, bf[0], cc));
 	/* midi(4) does running status compression where appropriate. */
 	return midi_writebytes(md->unit, bf, cc);
+}
 /*
  * If the writing process hands us a hidden note-off in a note-on event,
  * we will simply write it that way; no need to special case it here,
  * as midi(4) will always canonicalize or compress as appropriate anyway.
  */
 static int
 midiseq_noteon(struct midi_dev *md, int chan, int key, seq_event_t *ev)
+{

 @@ -1,16 +1,17 @@
-/*	$NetBSD: umidi.c,v 1.65 2013/01/22 21:29:53 jmcneill Exp $	*/
+/*	$NetBSD: umidi.c,v 1.65.12.1 2015/01/11 14:13:25 martin Exp $	*/
 /*
- * Copyright (c) 2001, 2012 The NetBSD Foundation, Inc.
+ * Copyright (c) 2001, 2012, 2014 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Takuya SHIOZAKI (tshiozak@NetBSD.org), (full-size transfers, extended
  * hw_if) Chapman Flack (chap@NetBSD.org), and Matthew R. Green
  * (mrg@eterna.com.au).
+ *
  * 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
 @@ -21,56 +22,205 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: umidi.c,v 1.65 2013/01/22 21:29:53 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: umidi.c,v 1.65.12.1 2015/01/11 14:13:25 martin Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/device.h>
 #include <sys/ioctl.h>
 #include <sys/conf.h>
 #include <sys/file.h>
 #include <sys/select.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/poll.h>
 #include <sys/intr.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdi_util.h>
 #include <dev/auconv.h>
 #include <dev/usb/usbdevs.h>
 #include <dev/usb/uaudioreg.h>
 #include <dev/usb/umidireg.h>
 #include <dev/usb/umidivar.h>
 #include <dev/usb/umidi_quirks.h>
 #include <dev/midi_if.h>
 /* Jack Descriptor */
 #define UMIDI_MS_HEADER	0x01
 #define UMIDI_IN_JACK	0x02
 #define UMIDI_OUT_JACK	0x03
 /* Jack Type */
 #define UMIDI_EMBEDDED	0x01
 #define UMIDI_EXTERNAL	0x02
 /* generic, for iteration */
 typedef struct {
 	uByte		bLength;
 	uByte		bDescriptorType;
 	uByte		bDescriptorSubtype;
 } UPACKED umidi_cs_descriptor_t;
 typedef struct {
 	uByte		bLength;
 	uByte		bDescriptorType;
 	uByte		bDescriptorSubtype;
 	uWord		bcdMSC;
 	uWord		wTotalLength;
 } UPACKED umidi_cs_interface_descriptor_t;
 #define UMIDI_CS_INTERFACE_DESCRIPTOR_SIZE 7
 typedef struct {
 	uByte		bLength;
 	uByte		bDescriptorType;
 	uByte		bDescriptorSubtype;
 	uByte		bNumEmbMIDIJack;
 } UPACKED umidi_cs_endpoint_descriptor_t;
 #define UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE 4
 typedef struct {
 	uByte		bLength;
 	uByte		bDescriptorType;
 	uByte		bDescriptorSubtype;
 	uByte		bJackType;
 	uByte		bJackID;
 } UPACKED umidi_jack_descriptor_t;
 #define	UMIDI_JACK_DESCRIPTOR_SIZE	5
 #define TO_D(p) ((usb_descriptor_t *)(p))
 #define NEXT_D(desc) TO_D((char *)(desc)+(desc)->bLength)
 #define TO_IFD(desc) ((usb_interface_descriptor_t *)(desc))
 #define TO_CSIFD(desc) ((umidi_cs_interface_descriptor_t *)(desc))
 #define TO_EPD(desc) ((usb_endpoint_descriptor_t *)(desc))
 #define TO_CSEPD(desc) ((umidi_cs_endpoint_descriptor_t *)(desc))
 #define UMIDI_PACKET_SIZE 4
 /*
  * hierarchie
+ *
  * <-- parent	       child -->
+ *
  * umidi(sc) -> endpoint -> jack   <- (dynamically assignable) - mididev
  *	   ^	 |    ^	    |
  *	   +-----+    +-----+
  */
 /* midi device */
 struct umidi_mididev {
 	struct umidi_softc	*sc;
 	device_t		mdev;
 	/* */
 	struct umidi_jack	*in_jack;
 	struct umidi_jack	*out_jack;
 	char			*label;
 	size_t			label_len;
 	/* */
 	int			opened;
 	int			closing;
 	int			flags;
 };
 /* Jack Information */
 struct umidi_jack {
 	struct umidi_endpoint	*endpoint;
 	/* */
 	int			cable_number;
 	void			*arg;
 	int			bound;
 	int			opened;
 	unsigned char		*midiman_ppkt;
 	union {
 		struct {
 			void			(*intr)(void *);
 		} out;
 		struct {
 			void			(*intr)(void *, int);
 		} in;
 	} u;
 };
 #define UMIDI_MAX_EPJACKS	16
 typedef unsigned char (*umidi_packet_bufp)[UMIDI_PACKET_SIZE];
 /* endpoint data */
 struct umidi_endpoint {
 	struct umidi_softc	*sc;
 	/* */
 	int			addr;
 	usbd_pipe_handle	pipe;
 	usbd_xfer_handle	xfer;
 	umidi_packet_bufp	buffer;
 	umidi_packet_bufp	next_slot;
 	u_int32_t               buffer_size;
 	int			num_scheduled;
 	int			num_open;
 	int			num_jacks;
 	int			soliciting;
 	void			*solicit_cookie;
 	int			armed;
 	struct umidi_jack	*jacks[UMIDI_MAX_EPJACKS];
 	u_int16_t		this_schedule; /* see UMIDI_MAX_EPJACKS */
 	u_int16_t		next_schedule;
 };
 /* software context */
 struct umidi_softc {
 	device_t		sc_dev;
 	usbd_device_handle	sc_udev;
 	usbd_interface_handle	sc_iface;
 	const struct umidi_quirk	*sc_quirk;
 	int			sc_dying;
 	int			sc_out_num_jacks;
 	struct umidi_jack	*sc_out_jacks;
 	int			sc_in_num_jacks;
 	struct umidi_jack	*sc_in_jacks;
 	struct umidi_jack	*sc_jacks;
 	int			sc_num_mididevs;
 	struct umidi_mididev	*sc_mididevs;
 	int			sc_out_num_endpoints;
 	struct umidi_endpoint	*sc_out_ep;
 	int			sc_in_num_endpoints;
 	struct umidi_endpoint	*sc_in_ep;
 	struct umidi_endpoint	*sc_endpoints;
 	size_t			sc_endpoints_len;
 	int			cblnums_global;
 	kmutex_t		sc_lock;
 	kcondvar_t		sc_cv;
 	kcondvar_t		sc_detach_cv;
 	int			sc_refcnt;
 };
 #ifdef UMIDI_DEBUG
 #define DPRINTF(x)	if (umididebug) printf x
 #define DPRINTFN(n,x)	if (umididebug >= (n)) printf x
 #include <sys/time.h>
 static struct timeval umidi_tv;
 int	umididebug = 0;
 #else
 #define DPRINTF(x)
 #define DPRINTFN(n,x)
 #endif
 #define UMIDI_ENDPOINT_SIZE(sc)	(sizeof(*(sc)->sc_out_ep) * \
 				 (sc->sc_out_num_endpoints + \
 @@ -200,69 +350,74 @@ umidi_attach(device_t parent, device_t s
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	sc->sc_iface = uaa->iface;
 	sc->sc_udev = uaa->device;
 	sc->sc_quirk =
 	    umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno);
 	aprint_normal_dev(self, "");
 	umidi_print_quirk(sc->sc_quirk);
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_USB);
 	cv_init(&sc->sc_cv, "umidopcl");
 	cv_init(&sc->sc_detach_cv, "umidetcv");
 	sc->sc_refcnt = 0;
 	err = alloc_all_endpoints(sc);
 	if (err != USBD_NORMAL_COMPLETION) {
 		aprint_error_dev(self,
 		    "alloc_all_endpoints failed. (err=%d)\n", err);
-		goto error;
+		goto out;
+	}
 	err = alloc_all_jacks(sc);
 	if (err != USBD_NORMAL_COMPLETION) {
 		free_all_endpoints(sc);
 		aprint_error_dev(self, "alloc_all_jacks failed. (err=%d)\n",
 		    err);
-		goto error;
+		goto out_free_endpoints;
+	}
 	aprint_normal_dev(self, "out=%d, in=%d\n",
 	       sc->sc_out_num_jacks, sc->sc_in_num_jacks);
 	err = assign_all_jacks_automatically(sc);
 	if (err != USBD_NORMAL_COMPLETION) {
 		unbind_all_jacks(sc);
 		free_all_jacks(sc);
 		free_all_endpoints(sc);
 		aprint_error_dev(self,
 		    "assign_all_jacks_automatically failed. (err=%d)\n", err);
-		goto error;
+		goto out_free_jacks;
+	}
 	err = attach_all_mididevs(sc);
 	if (err != USBD_NORMAL_COMPLETION) {
 		free_all_jacks(sc);
 		free_all_endpoints(sc);
 		aprint_error_dev(self,
 		    "attach_all_mididevs failed. (err=%d)\n", err);
 		goto out_free_jacks;
+	}
 #ifdef UMIDI_DEBUG
 	dump_sc(sc);
 #endif
 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH,
 			   sc->sc_udev, sc->sc_dev);
 	return;
 error:
 out_free_jacks:
 	unbind_all_jacks(sc);
 	free_all_jacks(sc);
 out_free_endpoints:
 	free_all_endpoints(sc);
 out:
 	aprint_error_dev(self, "disabled.\n");
 	sc->sc_dying = 1;
 	KERNEL_UNLOCK_ONE(curlwp);
 	return;
+}
 void
 umidi_childdet(device_t self, device_t child)
+{
 	int i;
 	struct umidi_softc *sc = device_private(self);
 	KASSERT(sc->sc_mididevs != NULL);
 @@ -289,175 +444,202 @@ umidi_activate(device_t self, enum devac
 	default:
 		DPRINTFN(1,("umidi_activate (%d)\n", act));
 		return EOPNOTSUPP;
+	}
+}
 int
 umidi_detach(device_t self, int flags)
+{
 	struct umidi_softc *sc = device_private(self);
 	DPRINTFN(1,("umidi_detach\n"));
 	mutex_enter(&sc->sc_lock);
 	sc->sc_dying = 1;
 	if (--sc->sc_refcnt >= 0)
 		usb_detach_wait(sc->sc_dev, &sc->sc_detach_cv, &sc->sc_lock);
 	mutex_exit(&sc->sc_lock);
 	detach_all_mididevs(sc, flags);
 	free_all_mididevs(sc);
 	free_all_jacks(sc);
 	free_all_endpoints(sc);
 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
 			   sc->sc_dev);
 	mutex_destroy(&sc->sc_lock);
 	cv_destroy(&sc->sc_detach_cv);
 	cv_destroy(&sc->sc_cv);
 	return 0;
+}
 /*
  * midi_if stuffs
  */
 int
 umidi_open(void *addr,
 	   int flags,
 	   void (*iintr)(void *, int),
 	   void (*ointr)(void *),
 	   void *arg)
+{
 	struct umidi_mididev *mididev = addr;
 	struct umidi_softc *sc = mididev->sc;
 	usbd_status err;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	DPRINTF(("umidi_open: sc=%p\n", sc));
 	if (!sc)
 		return ENXIO;
 	if (mididev->opened)
 		return EBUSY;
 	if (sc->sc_dying)
 		return EIO;
 	mididev->opened = 1;
 	mididev->closing = 0;
 	mididev->flags = flags;
 	if ((mididev->flags & FWRITE) && mididev->out_jack) {
 		err = open_out_jack(mididev->out_jack, arg, ointr);
-		if ( err != USBD_NORMAL_COMPLETION )
+		if (err != USBD_NORMAL_COMPLETION)
 			goto bad;
+	}
 	if ((mididev->flags & FREAD) && mididev->in_jack) {
 		err = open_in_jack(mididev->in_jack, arg, iintr);
-		if ( err != USBD_NORMAL_COMPLETION
+		KASSERT(mididev->opened);
-		&&   err != USBD_IN_PROGRESS )
+		if (err != USBD_NORMAL_COMPLETION &&
 		    err != USBD_IN_PROGRESS) {
 			if (mididev->out_jack)
 				close_out_jack(mididev->out_jack);
 			goto bad;
+		}
+	}
 	return 0;
 bad:
 	mididev->opened = 0;
 	DPRINTF(("umidi_open: usbd_status %d\n", err));
 	KASSERT(mutex_owned(&sc->sc_lock));
 	return USBD_IN_USE == err ? EBUSY : EIO;
+}
 void
 umidi_close(void *addr)
+{
 	struct umidi_mididev *mididev = addr;
 	struct umidi_softc *sc = mididev->sc;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	if (mididev->closing)
 		return;
 	mididev->closing = 1;
-	mutex_spin_exit(&mididev->sc->sc_lock);
+	sc->sc_refcnt++;
 	if ((mididev->flags & FWRITE) && mididev->out_jack)
 		close_out_jack(mididev->out_jack);
 	if ((mididev->flags & FREAD) && mididev->in_jack)
 		close_in_jack(mididev->in_jack);
-	mutex_spin_enter(&mididev->sc->sc_lock);
+	if (--sc->sc_refcnt < 0)
 		usb_detach_broadcast(sc->sc_dev, &sc->sc_detach_cv);
 	mididev->opened = 0;
 	mididev->closing = 0;
+}
 int
 umidi_channelmsg(void *addr, int status, int channel, u_char *msg,
     int len)
+{
 	struct umidi_mididev *mididev = addr;
 	KASSERT(mutex_owned(&mididev->sc->sc_lock));
 	if (!mididev->out_jack || !mididev->opened || mididev->closing)
 		return EIO;
 	return out_jack_output(mididev->out_jack, msg, len, (status>>4)&0xf);
+}
 int
 umidi_commonmsg(void *addr, int status, u_char *msg, int len)
+{
 	struct umidi_mididev *mididev = addr;
 	int cin;
 	KASSERT(mutex_owned(&mididev->sc->sc_lock));
 	if (!mididev->out_jack || !mididev->opened || mididev->closing)
 		return EIO;
 	switch ( len ) {
 	case 1: cin = 5; break;
 	case 2: cin = 2; break;
 	case 3: cin = 3; break;
 	default: return EIO; /* or gcc warns of cin uninitialized */
+	}
 	return out_jack_output(mididev->out_jack, msg, len, cin);
+}
 int
 umidi_sysex(void *addr, u_char *msg, int len)
+{
 	struct umidi_mididev *mididev = addr;
 	int cin;
 	KASSERT(mutex_owned(&mididev->sc->sc_lock));
 	if (!mididev->out_jack || !mididev->opened || mididev->closing)
 		return EIO;
 	switch ( len ) {
 	case 1: cin = 5; break;
 	case 2: cin = 6; break;
 	case 3: cin = (msg[2] == 0xf7) ? 7 : 4; break;
 	default: return EIO; /* or gcc warns of cin uninitialized */
+	}
 	return out_jack_output(mididev->out_jack, msg, len, cin);
+}
 int
 umidi_rtmsg(void *addr, int d)
+{
 	struct umidi_mididev *mididev = addr;
 	u_char msg = d;
 	KASSERT(mutex_owned(&mididev->sc->sc_lock));
 	if (!mididev->out_jack || !mididev->opened || mididev->closing)
 		return EIO;
 	return out_jack_output(mididev->out_jack, &msg, 1, 0xf);
+}
 void
 umidi_getinfo(void *addr, struct midi_info *mi)
+{
 	struct umidi_mididev *mididev = addr;
 	struct umidi_softc *sc = mididev->sc;
 	int mm = UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE);
 	KASSERT(mutex_owned(&sc->sc_lock));
 	mi->name = mididev->label;
 	mi->props = MIDI_PROP_OUT_INTR;
 	if (mididev->in_jack)
 		mi->props |= MIDI_PROP_CAN_INPUT;
 	midi_register_hw_if_ext(mm? &umidi_hw_if_mm : &umidi_hw_if_ext);
+}
 static void
 umidi_get_locks(void *addr, kmutex_t **thread, kmutex_t **intr)
+{
 	struct umidi_mididev *mididev = addr;
 	struct umidi_softc *sc = mididev->sc;
 @@ -646,27 +828,27 @@ alloc_all_endpoints_fixed_ep(struct umid
+		}
 		/*
 		 * MIDISPORT_2X4 inputs on an interrupt rather than a bulk
 		 * endpoint.  The existing input logic in this driver seems
 		 * to work successfully if we just stop treating an interrupt
 		 * endpoint as illegal (or the in_progress status we get on
 		 * the initial transfer).  It does not seem necessary to
 		 * actually use the interrupt flavor of alloc_pipe or make
 		 * other serious rearrangements of logic.  I like that.
 		 */
 		switch ( UE_GET_XFERTYPE(epd->bmAttributes) ) {
 		case UE_BULK:
 		case UE_INTERRUPT:
-			if ( UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress) )
+			if (UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress))
 				break;
 			/*FALLTHROUGH*/
 		default:
 			aprint_error_dev(sc->sc_dev,
 			    "illegal endpoint(in:%d)\n", fp->in_ep[i].ep);
 			err = USBD_INVAL;
 			goto error;
+		}
 		ep->sc = sc;
 		ep->addr = epd->bEndpointAddress;
 		ep->num_jacks = fp->in_ep[i].num_jacks;
 		sc->sc_in_num_jacks += fp->in_ep[i].num_jacks;
 @@ -906,38 +1088,38 @@ alloc_all_jacks(struct umidi_softc *sc)
 	/* allocate/initialize structures */
 	sc->sc_jacks = kmem_zalloc(sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+
 						      sc->sc_out_num_jacks), KM_SLEEP);
 	if (!sc->sc_jacks)
 		return USBD_NOMEM;
 	sc->sc_out_jacks =
 	    sc->sc_out_num_jacks ? sc->sc_jacks : NULL;
 	sc->sc_in_jacks =
 	    sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL;
 	jack = &sc->sc_out_jacks[0];
 	for (i = 0; i < sc->sc_out_num_jacks; i++) {
 		jack->opened = 0;
-		jack->binded = 0;
+		jack->bound = 0;
 		jack->arg = NULL;
 		jack->u.out.intr = NULL;
 		jack->midiman_ppkt = NULL;
 		if (sc->cblnums_global)
 			jack->cable_number = i;
 		jack++;
+	}
 	jack = &sc->sc_in_jacks[0];
 	for (i = 0; i < sc->sc_in_num_jacks; i++) {
 		jack->opened = 0;
-		jack->binded = 0;
+		jack->bound = 0;
 		jack->arg = NULL;
 		jack->u.in.intr = NULL;
 		if (sc->cblnums_global)
 			jack->cable_number = i;
 		jack++;
+	}
 	/* assign each jacks to each endpoints */
 	jack = &sc->sc_out_jacks[0];
 	ep = &sc->sc_out_ep[0];
 	for (i = 0; i < sc->sc_out_num_endpoints; i++) {
 		for (j = 0; j < ep->num_jacks; j++) {
 			jack->endpoint = ep;
 @@ -980,107 +1162,117 @@ free_all_jacks(struct umidi_softc *sc)
 	sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL;
 	mutex_exit(&sc->sc_lock);
 	if (jacks)
 		kmem_free(jacks, len);
+}
 static usbd_status
 bind_jacks_to_mididev(struct umidi_softc *sc,
 		      struct umidi_jack *out_jack,
 		      struct umidi_jack *in_jack,
 		      struct umidi_mididev *mididev)
+{
-	if ((out_jack && out_jack->binded) || (in_jack && in_jack->binded))
+	if ((out_jack && out_jack->bound) || (in_jack && in_jack->bound))
 		return USBD_IN_USE;
 	if (mididev->out_jack || mididev->in_jack)
 		return USBD_IN_USE;
 	if (out_jack)
-		out_jack->binded = 1;
+		out_jack->bound = 1;
 	if (in_jack)
-		in_jack->binded = 1;
+		in_jack->bound = 1;
 	mididev->in_jack = in_jack;
 	mididev->out_jack = out_jack;
 	mididev->closing = 0;
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 unbind_jacks_from_mididev(struct umidi_mididev *mididev)
+{
 	KASSERT(mutex_owned(&mididev->sc->sc_lock));
 	mididev->closing = 1;
 	if ((mididev->flags & FWRITE) && mididev->out_jack)
 		close_out_jack(mididev->out_jack);
 	if ((mididev->flags & FREAD) && mididev->in_jack)
 		close_in_jack(mididev->in_jack);
-	if (mididev->out_jack)
+	if (mididev->out_jack) {
-		mididev->out_jack->binded = 0;
+		mididev->out_jack->bound = 0;
-	if (mididev->in_jack)
+		mididev->out_jack = NULL;
 		mididev->in_jack->binded = 0;
-	mididev->out_jack = mididev->in_jack = NULL;
+	if (mididev->in_jack) {
 		mididev->in_jack->bound = 0;
 		mididev->in_jack = NULL;
+	}
+}
 static void
 unbind_all_jacks(struct umidi_softc *sc)
+{
 	int i;
 	mutex_spin_enter(&sc->sc_lock);
 	if (sc->sc_mididevs)
 		for (i = 0; i < sc->sc_num_mididevs; i++)
 			unbind_jacks_from_mididev(&sc->sc_mididevs[i]);
 	mutex_spin_exit(&sc->sc_lock);
+}
 static usbd_status
 assign_all_jacks_automatically(struct umidi_softc *sc)
+{
 	usbd_status err;
 	int i;
 	struct umidi_jack *out, *in;
 	const signed char *asg_spec;
 	err =
 	    alloc_all_mididevs(sc,
 			       max(sc->sc_out_num_jacks, sc->sc_in_num_jacks));
 	if (err!=USBD_NORMAL_COMPLETION)
 		return err;
-	if ( UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED))
+	if (UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED))
 		asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk,
 					    		  UMQ_TYPE_MD_FIXED);
 	else
 		asg_spec = NULL;
 	for (i = 0; i < sc->sc_num_mididevs; i++) {
 		if (asg_spec != NULL) {
 			if (*asg_spec == -1)
 				out = NULL;
 			else
 				out = &sc->sc_out_jacks[*asg_spec];
 			++ asg_spec;
 			if (*asg_spec == -1)
 				in = NULL;
 			else
 				in = &sc->sc_in_jacks[*asg_spec];
 			++ asg_spec;
 		} else {
 			out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i]
 			                               : NULL;
 			in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i]
 						     : NULL;
+		}
 		err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]);
-		if (err!=USBD_NORMAL_COMPLETION) {
+		if (err != USBD_NORMAL_COMPLETION) {
 			free_all_mididevs(sc);
 			return err;
+		}
+	}
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *))
+{
 	struct umidi_endpoint *ep = jack->endpoint;
 	struct umidi_softc *sc = ep->sc;
 @@ -1122,146 +1314,177 @@ open_in_jack(struct umidi_jack *jack, vo
+{
 	usbd_status err = USBD_NORMAL_COMPLETION;
 	struct umidi_endpoint *ep = jack->endpoint;
 	KASSERT(mutex_owned(&ep->sc->sc_lock));
 	if (jack->opened)
 		return USBD_IN_USE;
 	jack->arg = arg;
 	jack->u.in.intr = intr;
 	jack->opened = 1;
 	if (ep->num_open++ == 0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) {
 		/*
 		 * Can't hold the interrupt lock while calling into USB,
 		 * but we can safely drop it here.
 		 */
 		mutex_exit(&ep->sc->sc_lock);
 		err = start_input_transfer(ep);
 		if (err != USBD_NORMAL_COMPLETION &&
 		    err != USBD_IN_PROGRESS) {
 			ep->num_open--;
+		}
 		mutex_enter(&ep->sc->sc_lock);
+	}
 	return err;
+}
 static void
 close_out_jack(struct umidi_jack *jack)
+{
 	struct umidi_endpoint *ep;
 	struct umidi_softc *sc;
 	u_int16_t mask;
 	int err;
 	if (jack->opened) {
 		ep = jack->endpoint;
 		sc = ep->sc;
 		mutex_spin_enter(&sc->sc_lock);
 		KASSERT(mutex_owned(&sc->sc_lock));
 		mask = 1 << (jack->cable_number);
 		while (mask & (ep->this_schedule | ep->next_schedule)) {
 			err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock,
 			     mstohz(10));
 			if (err)
 				break;
+		}
 		/*
 		 * We can re-enter this function from both close() and
 		 * detach().  Make sure only one of them does this part.
 		 */
 		if (jack->opened) {
 			jack->opened = 0;
 			jack->endpoint->num_open--;
 			ep->this_schedule &= ~mask;
 			ep->next_schedule &= ~mask;
+		}
 		mutex_spin_exit(&sc->sc_lock);
+	}
+}
 static void
 close_in_jack(struct umidi_jack *jack)
+{
 	if (jack->opened) {
 		struct umidi_softc *sc = jack->endpoint->sc;
 		KASSERT(mutex_owned(&sc->sc_lock));
 		jack->opened = 0;
 		if (--jack->endpoint->num_open == 0) {
 			/*
 			 * We have to drop the (interrupt) lock so that
 			 * the USB thread lock can be safely taken by
 			 * the abort operation.  This is safe as this
 			 * either closing or dying will be set proerly.
 			 */
 			mutex_spin_exit(&sc->sc_lock);
 			usbd_abort_pipe(jack->endpoint->pipe);
 			mutex_spin_enter(&sc->sc_lock);
+		}
+	}
+}
 static usbd_status
 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev)
+{
 	if (mididev->sc)
 		return USBD_IN_USE;
 	mididev->sc = sc;
 	describe_mididev(mididev);
 	mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, sc->sc_dev);
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 detach_mididev(struct umidi_mididev *mididev, int flags)
+{
-	if (!mididev->sc)
+	struct umidi_softc *sc = mididev->sc;
 	if (!sc)
 		return USBD_NO_ADDR;
 	mutex_spin_enter(&sc->sc_lock);
 	if (mididev->opened) {
 		umidi_close(mididev);
+	}
 	unbind_jacks_from_mididev(mididev);
 	mutex_spin_exit(&sc->sc_lock);
 	if (mididev->mdev != NULL)
 		config_detach(mididev->mdev, flags);
 	if (NULL != mididev->label) {
 		kmem_free(mididev->label, mididev->label_len);
 		mididev->label = NULL;
+	}
 	mididev->sc = NULL;
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 deactivate_mididev(struct umidi_mididev *mididev)
+{
 	if (mididev->out_jack)
-		mididev->out_jack->binded = 0;
+		mididev->out_jack->bound = 0;
 	if (mididev->in_jack)
-		mididev->in_jack->binded = 0;
+		mididev->in_jack->bound = 0;
+}
 static usbd_status
 alloc_all_mididevs(struct umidi_softc *sc, int nmidi)
+{
 	sc->sc_num_mididevs = nmidi;
 	sc->sc_mididevs = kmem_zalloc(sizeof(*sc->sc_mididevs)*nmidi, KM_SLEEP);
 	if (!sc->sc_mididevs)
 		return USBD_NOMEM;
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 free_all_mididevs(struct umidi_softc *sc)
+{
-	if (sc->sc_mididevs)
+	struct umidi_mididev *mididevs;
-		kmem_free(sc->sc_mididevs,
+	size_t len;
 			  sizeof(*sc->sc_mididevs)*sc->sc_num_mididevs);
 	mutex_enter(&sc->sc_lock);
 	mididevs = sc->sc_mididevs;
 	if (mididevs)
 		  len = sizeof(*sc->sc_mididevs )* sc->sc_num_mididevs;
 	sc->sc_mididevs = NULL;
 	sc->sc_num_mididevs = 0;
 	mutex_exit(&sc->sc_lock);
 	if (mididevs)
 		kmem_free(mididevs, len);
+}
 static usbd_status
 attach_all_mididevs(struct umidi_softc *sc)
+{
 	usbd_status err;
 	int i;
 	if (sc->sc_mididevs)
 		for (i = 0; i < sc->sc_num_mididevs; i++) {
 			err = attach_mididev(sc, &sc->sc_mididevs[i]);
 			if (err != USBD_NORMAL_COMPLETION)
 				return err;
 @@ -1316,38 +1539,38 @@ describe_mididev(struct umidi_mididev *m
 	char in_label[16];
 	char out_label[16];
 	const char *unit_label;
 	char *final_label;
 	struct umidi_softc *sc;
 	int show_ep_in;
 	int show_ep_out;
 	size_t len;
 	sc = md->sc;
 	show_ep_in  = sc-> sc_in_num_endpoints > 1 && !sc->cblnums_global;
 	show_ep_out = sc->sc_out_num_endpoints > 1 && !sc->cblnums_global;
-	if ( NULL == md->in_jack )
+	if (NULL == md->in_jack)
 		in_label[0] = '\0';
-	else if ( show_ep_in )
+	else if (show_ep_in)
 		snprintf(in_label, sizeof in_label, "<%d(%x) ",
 		    md->in_jack->cable_number, md->in_jack->endpoint->addr);
 	else
 		snprintf(in_label, sizeof in_label, "<%d ",
 		    md->in_jack->cable_number);
-	if ( NULL == md->out_jack )
+	if (NULL == md->out_jack)
 		out_label[0] = '\0';
-	else if ( show_ep_out )
+	else if (show_ep_out)
 		snprintf(out_label, sizeof out_label, ">%d(%x) ",
 		    md->out_jack->cable_number, md->out_jack->endpoint->addr);
 	else
 		snprintf(out_label, sizeof out_label, ">%d ",
 		    md->out_jack->cable_number);
 	unit_label = device_xname(sc->sc_dev);
 	len = strlen(in_label) + strlen(out_label) + strlen(unit_label) + 4;
 	final_label = kmem_alloc(len, KM_SLEEP);
 	snprintf(final_label, len, "%s%son %s",
 @@ -1496,34 +1719,38 @@ if ((unsigned char)(p)[1]!=0xFE)				\
  * as midi(4) hands us a complete message at a time, we'll never send one
  * in a dribble of short packets.
  */
 static int
 out_jack_output(struct umidi_jack *out_jack, u_char *src, int len, int cin)
+{
 	struct umidi_endpoint *ep = out_jack->endpoint;
 	struct umidi_softc *sc = ep->sc;
 	unsigned char *packet;
 	int plen;
 	int poff;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	if (sc->sc_dying)
 		return EIO;
 	if (!out_jack->opened)
 		return ENODEV; /* XXX as it was, is this the right errno? */
 	sc->sc_refcnt++;
 #ifdef UMIDI_DEBUG
-	if ( umididebug >= 100 )
+	if (umididebug >= 100)
 		microtime(&umidi_tv);
 #endif
 	DPRINTFN(100, ("umidi out: %"PRIu64".%06"PRIu64"s ep=%p cn=%d len=%d cin=%#x\n",
 	    umidi_tv.tv_sec%100, (uint64_t)umidi_tv.tv_usec,
 	    ep, out_jack->cable_number, len, cin));
 	packet = *ep->next_slot++;
 	KASSERT(ep->buffer_size >=
 	    (ep->next_slot - ep->buffer) * sizeof *ep->buffer);
 	memset(packet, 0, UMIDI_PACKET_SIZE);
 	if (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE)) {
 		if (NULL != out_jack->midiman_ppkt) { /* fill out a prev pkt */
 			poff = 0x0f & (out_jack->midiman_ppkt[3]);
 @@ -1546,37 +1773,40 @@ out_jack_output(struct umidi_jack *out_j
 			memcpy(packet, src, len);
 			packet[3] = MIX_CN_CIN(out_jack->cable_number, len);
 			DPR_PACKET(out, sc, packet);
 			if (len < 3)
 				out_jack->midiman_ppkt = packet;
+		}
 	} else { /* the nice simple USB class-compliant case */
 		packet[0] = MIX_CN_CIN(out_jack->cable_number, cin);
 		memcpy(packet+1, src, len);
 		DPR_PACKET(out, sc, packet);
+	}
 	ep->next_schedule |= 1<<(out_jack->cable_number);
 	++ ep->num_scheduled;
-	if ( !ep->armed  &&  !ep->soliciting ) {
+	if (!ep->armed && !ep->soliciting) {
 		/*
 		 * It would be bad to call out_solicit directly here (the
 		 * caller need not be reentrant) but a soft interrupt allows
 		 * solicit to run immediately the caller exits its critical
 		 * section, and if the caller has more to write we can get it
 		 * before starting the USB transfer, and send a longer one.
 		 */
 		ep->soliciting = 1;
 		softint_schedule(ep->solicit_cookie);
+	}
 	if (--sc->sc_refcnt < 0)
 		usb_detach_broadcast(sc->sc_dev, &sc->sc_detach_cv);
 	return 0;
+}
 static void
 in_intr(usbd_xfer_handle xfer, usbd_private_handle priv,
     usbd_status status)
+{
 	int cn, len, i;
 	struct umidi_endpoint *ep = (struct umidi_endpoint *)priv;
 	struct umidi_softc *sc = ep->sc;
 	struct umidi_jack *jack;
 	unsigned char *packet;
 @@ -1614,27 +1844,27 @@ in_intr(usbd_xfer_handle xfer, usbd_priv
+		}
 		/* 0 <= cn <= 15 by inspection of above code */
 		if (!(jack = ep->jacks[cn]) || cn != jack->cable_number) {
 			DPRINTF(("%s: stray input endpoint %p cable %d len %d: "
 			         "%02X %02X %02X (try CN_SEQ quirk?)\n",
 				 device_xname(ep->sc->sc_dev), ep, cn, len,
 				 (unsigned)data[0],
 				 (unsigned)data[1],
 				 (unsigned)data[2]));
 			mutex_exit(&sc->sc_lock);
 			return;
+		}
-		if (!jack->binded || !jack->opened)
+		if (!jack->bound || !jack->opened)
 			continue;
 		DPRINTFN(500,("%s: input endpoint %p cable %d len %d: "
 		             "%02X %02X %02X\n",
 			     device_xname(ep->sc->sc_dev), ep, cn, len,
 			     (unsigned)data[0],
 			     (unsigned)data[1],
 			     (unsigned)data[2]));
 		if (jack->u.in.intr) {
 			for (i = 0; i < len; i++) {
 				(*jack->u.in.intr)(jack->arg, data[i]);
+			}
 @@ -1649,31 +1879,31 @@ in_intr(usbd_xfer_handle xfer, usbd_priv
 static void
 out_intr(usbd_xfer_handle xfer, usbd_private_handle priv,
     usbd_status status)
+{
 	struct umidi_endpoint *ep = (struct umidi_endpoint *)priv;
 	struct umidi_softc *sc = ep->sc;
 	u_int32_t count;
 	if (sc->sc_dying)
 		return;
 	mutex_enter(&sc->sc_lock);
 #ifdef UMIDI_DEBUG
-	if ( umididebug >= 200 )
+	if (umididebug >= 200)
 		microtime(&umidi_tv);
 #endif
 	usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
-        if ( 0 == count % UMIDI_PACKET_SIZE ) {
+        if (0 == count % UMIDI_PACKET_SIZE) {
 		DPRINTFN(200,("%s: %"PRIu64".%06"PRIu64"s out ep %p xfer length %u\n",
 			     device_xname(ep->sc->sc_dev),
 			     umidi_tv.tv_sec%100, (uint64_t)umidi_tv.tv_usec, ep, count));
         } else {
                 DPRINTF(("%s: output endpoint %p odd transfer length %u\n",
                         device_xname(ep->sc->sc_dev), ep, count));
+        }
 	count /= UMIDI_PACKET_SIZE;
 	/*
 	 * If while the transfer was pending we buffered any new messages,
 	 * move them to the start of the buffer.
 	 */
 @@ -1751,28 +1981,35 @@ out_solicit_locked(void *arg)
 		--which; /* now 1s below mask - count 1s to get index */
 		which -= ((which >> 1) & 0x5555);/* SWAR credit aggregate.org */
 		which = (((which >> 2) & 0x3333) + (which & 0x3333));
 		which = (((which >> 4) + which) & 0x0f0f);
 		which +=  (which >> 8);
 		which &= 0x1f; /* the bit index a/k/a jack number */
 		jack = ep->jacks[which];
 		if (jack->u.out.intr)
 			(*jack->u.out.intr)(jack->arg);
+	}
 	/* intr lock held at loop exit */
-	if (!ep->armed && ep->next_slot > ep->buffer)
+	if (!ep->armed && ep->next_slot > ep->buffer) {
 		/*
 		 * Can't hold the interrupt lock while calling into USB,
 		 * but we can safely drop it here.
 		 */
 		mutex_exit(&ep->sc->sc_lock);
 		ep->armed = (USBD_IN_PROGRESS == start_output_transfer(ep));
 		mutex_enter(&ep->sc->sc_lock);
+	}
 	ep->soliciting = 0;
+}
 /* Entry point for the softintr.  */
 static void
 out_solicit(void *arg)
+{
 	struct umidi_endpoint *ep = arg;
 	struct umidi_softc *sc = ep->sc;
 	mutex_enter(&sc->sc_lock);
 	out_solicit_locked(arg);
 	mutex_exit(&sc->sc_lock);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: midivar.h,v 1.19 2012/04/05 20:25:53 plunky Exp $	*/
+/*	$NetBSD: midivar.h,v 1.19.14.1 2015/01/11 14:13:25 martin Exp $	*/
 /*
  * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (augustss@NetBSD.org) and (midi FST refactoring and
  * Active Sense) Chapman Flack (chap@NetBSD.org).
+ *
  * 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
 @@ -179,26 +179,28 @@ struct midi_state {
 };
 struct midi_softc {
 	device_t dev;		/* Hardware device struct */
 	void	*hw_hdl;	/* Hardware driver handle */
 	const struct	midi_hw_if *hw_if; /* Hardware interface */
 	const struct	midi_hw_if_ext *hw_if_ext; /* see midi_if.h */
 	int	isopen;		/* Open indicator */
 	int	flags;		/* Open flags */
 	int	dying;
 	struct	midi_buffer outbuf;
 	struct	midi_buffer inbuf;
 	int	props;
 	int	refcnt;
 	kcondvar_t detach_cv;
 	kcondvar_t rchan;
 	kcondvar_t wchan;
 	kmutex_t *lock;
 	int	pbus;
 	int	rcv_expect_asense;
 	int	rcv_quiescent;
 	int	rcv_eof;
 	struct	selinfo wsel;	/* write selector */
 	struct	selinfo rsel;	/* read selector */
 	pid_t	async;	/* process who wants audio SIGIO */
 	void	*sih;
 	struct callout xmt_asense_co;

 @@ -45,28 +45,26 @@ ukbdmap.c		wscons key mapping for ukbd
 ukbdvar.h		API for ukbd.c
 ulpt.c			USB printer class driver
 umass.c			USB mass storage wire protocol driver
 umass_isdata.c		In-System Design ATA over bulk-only driver
 umass_isdata.h		  and definitions for it
 umass_quirks.c		Table of strange umass devices
 umass_quirks.h		  and definitions for it
 umass_scsipi.c		umass command protocol driver
 umass_scsipi.h		  and definitions for it
 umassvar.h		definitions for umass.c
 umidi.c			USB MIDI driver
 umidi_quirks.c		Strange MIDI devices
 umidi_quirks.h		  and definitions for it
 umidireg.h		Protocol definitions for umidi.c
 umidivar.h		definitions for umidi.c
 umodem.c		USB modem (CDC ACM) driver
 ums.c			USB mouse driver
 urio.c			USB Diamond Rio500 driver
 urio.h			USB Diamond Rio500 defines
 usb.c			usb (bus) device driver
 usb.h			general USB defines
 usb_mem.c		memory allocation for DMAable memory
 usb_mem.h		API for usb_mem.c
 usb_quirks.c		table of non-conforming USB devices and their problems
 usb_quirks.h		API for usb_quirks.c
 usb_subr.c		various subroutines used by USB code
 usbcdc.h		USB CDC class definitions
 usbdevs			data base of known device

 @@ -1,14 +1,14 @@
-/*	$NetBSD: midi_if.h,v 1.25 2012/04/09 10:18:16 plunky Exp $	*/
+/*	$NetBSD: midi_if.h,v 1.25.14.1 2015/01/11 14:13:25 martin Exp $	*/
 /*
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (augustss@NetBSD.org).
+ *
  * 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.
 @@ -40,31 +40,31 @@ struct midi_info {
 };
 #define MIDI_PROP_OUT_INTR  1
 #define MIDI_PROP_CAN_INPUT 2
 #define MIDI_PROP_NO_OUTPUT 4
 /*
  * XXX expand
+ *
  * List of hardware interface methods, and when locks are held by each
  * called by this module:
+ *
  *	METHOD			INTR	NOTES
  *	----------------------- ------- -------------------------
- *	open 			-
+ *	open 			held
- *	close 			-
+ *	close 			held
- *	output 			-
+ *	output 			held
- *	getinfo 		-	Called at attach time
+ *	getinfo 		held	Called at attach time
- *	ioctl 			-
+ *	ioctl 			held
  *	get_locks 		-	Called at attach time
  */
 struct midi_softc;
 struct midi_hw_if {
 	int	(*open)(void *, int, 	/* open hardware */
 			void (*)(void *, int), /* input callback */
 			void (*)(void *), /* output callback */
 			void *);
 	void	(*close)(void *);		/* close hardware */
 	int	(*output)(void *, int);	/* output a byte */
 	void	(*getinfo)(void *, struct midi_info *);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sequencervar.h,v 1.16 2013/04/27 22:12:42 christos Exp $	*/
+/*	$NetBSD: sequencervar.h,v 1.16.10.1 2015/01/11 14:13:25 martin Exp $	*/
 /*
  * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (augustss@NetBSD.org).
+ *
  * 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.
 @@ -58,27 +58,26 @@ struct sequencer_queue {
 #define SEQ_QLEN(q) ((q)->count)
 struct sequencer_softc;
 #define MAXCHAN 16
 struct midi_dev {
 	const char *name;
 	int	subtype;
 	int	capabilities;
 	int	nr_voices;
 	int	instr_bank_size;
 	int	unit;
 	struct	sequencer_softc *seq;
 	struct	midi_softc *msc;
 	char	doingsysex;	/* doing a SEQ_SYSEX */
 	vnode_t *vp;
 };
 struct sequencer_softc {
 	callout_t sc_callout;
 	kmutex_t lock;
 	kcondvar_t wchan;
 	kcondvar_t rchan;
 	kcondvar_t lchan;
 	int	dvlock;
 	int	dying;
 	u_int	isopen;		/* Open indicator */