- Mutexify midi(4). The driver runs under the giant lock by default.

If you ever want to run midi(4) out of the giant lock, uncomment
MIDI_OUTOFGIANT in midi.h. Confirmed to work for csamidi with WITNESS
and INVARIANTS.

- midi_info, midi_open and seq_info are now tailqs, allowing arbitrary
numbers of devices to be configured.

- Do not send an active sensing message to reset midi modules.

- Clone /dev/sequencer*. /dev/sequencer0 and /dev/sequencer are generated
upon initialization.

8 files changed, 1385 insertions, 756 deletions

diff --git a/sys/dev/sound/midi/midi.c b/sys/dev/sound/midi/midi.c
index 1b504bc..3d6a16c 100644
--- a/sys/dev/sound/midi/midi.c
+++ b/sys/dev/sound/midi/midi.c
@@ -38,7 +38,7 @@
  * board-specific probe routine. If successful, a pointer to the
  * correct mididev_info is stored in mididev_last_probed, for subsequent
  * use in the attach routine. The generic attach routine copies
- * the template to a permanent descriptor (midi_info[unit] and
+ * the template to a permanent descriptor (midi_info and
  * friends), initializes all generic parameters, and calls the
  * board-specific attach routine.
  *
@@ -90,8 +90,11 @@ static struct cdevsw midi_cdevsw = {
  * descriptors for active devices. also used as the public softc
  * of a device.
  */
-static mididev_info midi_info[NMIDI_MAX];
+static TAILQ_HEAD(,_mididev_info) midi_info;
 static int nmidi, nsynth;
+/* Mutex to protect midi_info, nmidi and nsynth. */
+static struct mtx midiinfo_mtx;
+static int midiinfo_mtx_init;
 
 /* These make the buffer for /dev/midistat */
 static int midistatbusy;
@@ -99,33 +102,39 @@ static char midistatbuf[4096];
 static int midistatptr;
 
 /*
- * This is the generic init routine
+ * This is the generic init routine.
+ * Must be called after device-specific init.
  */
 int
 midiinit(mididev_info *d, device_t dev)
 {
 	int unit;
 
-	if (midi_devclass == NULL) {
-		midi_devclass = device_get_devclass(dev);
-		make_dev(&midi_cdevsw, MIDIMKMINOR(0, MIDI_DEV_STATUS),
-			 UID_ROOT, GID_WHEEL, 0444, "midistat");
-	}
-
-	unit = device_get_unit(dev);
-	make_dev(&midi_cdevsw, MIDIMKMINOR(unit, MIDI_DEV_MIDIN),
-		 UID_ROOT, GID_WHEEL, 0666, "midi%d", unit);
-
 	/*
 	 * initialize standard parameters for the device. This can be
 	 * overridden by device-specific configurations but better do
 	 * here the generic things.
 	 */
 
-	d->unit = device_get_unit(dev);
+	unit = d->unit;
 	d->softc = device_get_softc(dev);
 	d->dev = dev;
 	d->magic = MAGIC(d->unit); /* debugging... */
+	d->flags = 0;
+	d->fflags = 0;
+	d->midi_dbuf_in.unit_size = 1;
+	d->midi_dbuf_out.unit_size = 1;
+	d->midi_dbuf_passthru.unit_size = 1;
+
+	mtx_unlock(&d->flagqueue_mtx);
+
+	if (midi_devclass == NULL) {
+		midi_devclass = device_get_devclass(dev);
+		make_dev(&midi_cdevsw, MIDIMKMINOR(0, MIDI_DEV_STATUS),
+			 UID_ROOT, GID_WHEEL, 0444, "midistat");
+	}
+	make_dev(&midi_cdevsw, MIDIMKMINOR(unit, MIDI_DEV_MIDIN),
+		 UID_ROOT, GID_WHEEL, 0666, "midi%d", unit);
 
 	return 0 ;
 }
@@ -156,21 +165,55 @@ get_mididev_info(dev_t i_dev, int *unit)
 mididev_info *
 get_mididev_info_unit(int unit)
 {
-	mididev_info *d;
+	mididev_info *md;
 
-	if (unit >= nmidi + nsynth) {
-		DEB(printf("get_mididev_info_unit: unit %d is not configured.\n", u));
-		return NULL;
+	/* XXX */
+	if (!midiinfo_mtx_init) {
+		midiinfo_mtx_init = 1;
+		mtx_init(&midiinfo_mtx, "midinf", MTX_DEF);
+		TAILQ_INIT(&midi_info);
+	}
+
+	mtx_lock(&midiinfo_mtx);
+	TAILQ_FOREACH(md, &midi_info, md_link) {
+		if (md->unit == unit)
+			break;
 	}
-	d = &midi_info[unit];
+	mtx_unlock(&midiinfo_mtx);
 
-	return d;
+	return md;
 }
 
 /* Create a new midi device info structure. */
+/* TODO: lock md, then exit. */
 mididev_info *
-create_mididev_info_unit(int *unit, int type)
+create_mididev_info_unit(int type, mididev_info *mdinf, synthdev_info *syninf)
 {
+	int unit;
+	mididev_info *md, *mdnew;
+
+	/* XXX */
+	if (!midiinfo_mtx_init) {
+		midiinfo_mtx_init = 1;
+		mtx_init(&midiinfo_mtx, "midinf", MTX_DEF);
+		TAILQ_INIT(&midi_info);
+	}
+
+	/* As malloc(9) might block, allocate mididev_info now. */
+	mdnew = malloc(sizeof(mididev_info), M_DEVBUF, M_WAITOK | M_ZERO);
+	if (mdnew == NULL)
+		return NULL;
+	bcopy(mdinf, mdnew, sizeof(mididev_info));
+	bcopy(syninf, &mdnew->synth, sizeof(synthdev_info));
+	midibuf_init(&mdnew->midi_dbuf_in);
+	midibuf_init(&mdnew->midi_dbuf_out);
+	midibuf_init(&mdnew->midi_dbuf_passthru);
+	mtx_init(&mdnew->flagqueue_mtx, "midflq", MTX_DEF);
+	mtx_init(&mdnew->synth.vc_mtx, "synsvc", MTX_DEF);
+	mtx_init(&mdnew->synth.status_mtx, "synsst", MTX_DEF);
+
+	mtx_lock(&midiinfo_mtx);
+
 	/* XXX midi_info is still static. */
 	switch (type) {
 	case MDT_MIDI:
@@ -180,12 +223,34 @@ create_mididev_info_unit(int *unit, int type)
 		nsynth++;
 		break;
 	default:
+		mtx_unlock(&midiinfo_mtx);
+		midibuf_destroy(&mdnew->midi_dbuf_in);
+		midibuf_destroy(&mdnew->midi_dbuf_out);
+		midibuf_destroy(&mdnew->midi_dbuf_passthru);
+		mtx_destroy(&mdnew->flagqueue_mtx);
+		mtx_destroy(&mdnew->synth.vc_mtx);
+		mtx_destroy(&mdnew->synth.status_mtx);
+		free(mdnew, M_DEVBUF);
 		panic("unsupported device type");
-		break;
+		return NULL;
+	}
+
+	for (unit = 0 ; ; unit++) {
+		TAILQ_FOREACH(md, &midi_info, md_link) {
+			if (md->unit == unit)
+				break;
+		}
+		if (md == NULL)
+			break;
 	}
 
-	*unit = nmidi + nsynth - 1;
-	return get_mididev_info_unit(*unit);
+	mdnew->unit = unit;
+	mtx_lock(&mdnew->flagqueue_mtx);
+	TAILQ_INSERT_TAIL(&midi_info, mdnew, md_link);
+
+	mtx_unlock(&midiinfo_mtx);
+
+	return mdnew;
 }
 
 /* Return the number of configured devices. */
@@ -206,73 +271,136 @@ mididev_info_number(void)
 static int
 midiopen(dev_t i_dev, int flags, int mode, struct proc * p)
 {
+	int ret;
+
+	MIDI_DROP_GIANT_NOSWITCH();
+
 	switch (MIDIDEV(i_dev)) {
 	case MIDI_DEV_MIDIN:
-		return midi_open(i_dev, flags, mode, p);
+		ret = midi_open(i_dev, flags, mode, p);
+		break;
 	case MIDI_DEV_STATUS:
-		return midistat_open(i_dev, flags, mode, p);
+		ret = midistat_open(i_dev, flags, mode, p);
+		break;
+	default:
+		ret = ENXIO;
+		break;
 	}
 
-	return (ENXIO);
+	MIDI_PICKUP_GIANT();
+
+	return (ret);
 }
 
 static int
 midiclose(dev_t i_dev, int flags, int mode, struct proc * p)
 {
+	int ret;
+
+	MIDI_DROP_GIANT_NOSWITCH();
+
 	switch (MIDIDEV(i_dev)) {
 	case MIDI_DEV_MIDIN:
-		return midi_close(i_dev, flags, mode, p);
+		ret = midi_close(i_dev, flags, mode, p);
+		break;
 	case MIDI_DEV_STATUS:
-		return midistat_close(i_dev, flags, mode, p);
+		ret = midistat_close(i_dev, flags, mode, p);
+		break;
+	default:
+		ret = ENXIO;
+		break;
 	}
 
-	return (ENXIO);
+	MIDI_PICKUP_GIANT();
+
+	return (ret);
 }
 
 static int
 midiread(dev_t i_dev, struct uio * buf, int flag)
 {
+	int ret;
+
+	MIDI_DROP_GIANT_NOSWITCH();
+
 	switch (MIDIDEV(i_dev)) {
 	case MIDI_DEV_MIDIN:
-		return midi_read(i_dev, buf, flag);
+		ret = midi_read(i_dev, buf, flag);
+		break;
 	case MIDI_DEV_STATUS:
-		return midistat_read(i_dev, buf, flag);
+		ret = midistat_read(i_dev, buf, flag);
+		break;
+	default:
+		ret = ENXIO;
+		break;
 	}
 
-	return (ENXIO);
+	MIDI_PICKUP_GIANT();
+
+	return (ret);
 }
 
 static int
 midiwrite(dev_t i_dev, struct uio * buf, int flag)
 {
+	int ret;
+
+	MIDI_DROP_GIANT_NOSWITCH();
+
 	switch (MIDIDEV(i_dev)) {
 	case MIDI_DEV_MIDIN:
-		return midi_write(i_dev, buf, flag);
+		ret = midi_write(i_dev, buf, flag);
+		break;
+	default:
+		ret = ENXIO;
+		break;
 	}
 
-	return (ENXIO);
+	MIDI_PICKUP_GIANT();
+
+	return (ret);
 }
 
 static int
 midiioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p)
 {
+	int ret;
+
+	MIDI_DROP_GIANT_NOSWITCH();
+
 	switch (MIDIDEV(i_dev)) {
 	case MIDI_DEV_MIDIN:
-		return midi_ioctl(i_dev, cmd, arg, mode, p);
+		ret = midi_ioctl(i_dev, cmd, arg, mode, p);
+		break;
+	default:
+		ret = ENXIO;
+		break;
 	}
 
-	return (ENXIO);
+	MIDI_PICKUP_GIANT();
+
+	return (ret);
 }
 
 static int
 midipoll(dev_t i_dev, int events, struct proc * p)
 {
+	int ret;
+
+	MIDI_DROP_GIANT_NOSWITCH();
+
 	switch (MIDIDEV(i_dev)) {
 	case MIDI_DEV_MIDIN:
-		return midi_poll(i_dev, events, p);
+		ret = midi_poll(i_dev, events, p);
+		break;
+	default:
+		ret = ENXIO;
+		break;
 	}
 
-	return (ENXIO);
+	MIDI_PICKUP_GIANT();
+
+	return (ret);
 }
 
 /*
@@ -282,7 +410,7 @@ midipoll(dev_t i_dev, int events, struct proc * p)
 int
 midi_open(dev_t i_dev, int flags, int mode, struct proc * p)
 {
-	int dev, unit, s, ret;
+	int dev, unit, ret;
 	mididev_info *d;
 
 	dev = minor(i_dev);
@@ -294,12 +422,11 @@ midi_open(dev_t i_dev, int flags, int mode, struct proc * p)
 	if (d == NULL)
 		return (ENXIO);
 
-	s = splmidi();
-
 	/* Mark this device busy. */
+	mtx_lock(&d->flagqueue_mtx);
 	device_busy(d->dev);
 	if ((d->flags & MIDI_F_BUSY) != 0) {
-		splx(s);
+		mtx_unlock(&d->flagqueue_mtx);
 		DEB(printf("opl_open: unit %d is busy.\n", unit));
 		return (EBUSY);
 	}
@@ -308,27 +435,27 @@ midi_open(dev_t i_dev, int flags, int mode, struct proc * p)
 	d->fflags = flags;
 
 	/* Init the queue. */
-	if ((d->fflags & FREAD) != 0)
-		midibuf_init(&d->midi_dbuf_in);
-	if ((d->fflags & FWRITE) != 0) {
-		midibuf_init(&d->midi_dbuf_out);
-		midibuf_init(&d->midi_dbuf_passthru);
+	if ((flags & FREAD) != 0)
+		midibuf_clear(&d->midi_dbuf_in);
+	if ((flags & FWRITE) != 0) {
+		midibuf_clear(&d->midi_dbuf_out);
+		midibuf_clear(&d->midi_dbuf_passthru);
 	}
 
+	mtx_unlock(&d->flagqueue_mtx);
+
 	if (d->open == NULL)
 		ret = 0;
 	else
 		ret = d->open(i_dev, flags, mode, p);
 
-	splx(s);
-
 	return (ret);
 }
 
 int
 midi_close(dev_t i_dev, int flags, int mode, struct proc * p)
 {
-	int dev, unit, s, ret;
+	int dev, unit, ret;
 	mididev_info *d;
 
 	dev = minor(i_dev);
@@ -339,14 +466,20 @@ midi_close(dev_t i_dev, int flags, int mode, struct proc * p)
 	if (d == NULL)
 		return (ENXIO);
 
-	s = splmidi();
+	mtx_lock(&d->flagqueue_mtx);
+
+	/* Stop recording and playing. */
+	if ((d->flags & MIDI_F_READING) != 0)
+		d->callback(d, MIDI_CB_ABORT | MIDI_CB_RD);
+	if ((d->flags & MIDI_F_WRITING) != 0)
+		d->callback(d, MIDI_CB_ABORT | MIDI_CB_WR);
 
 	/* Clear the queues. */
 	if ((d->fflags & FREAD) != 0)
-		midibuf_init(&d->midi_dbuf_in);
+		midibuf_clear(&d->midi_dbuf_in);
 	if ((d->fflags & FWRITE) != 0) {
-		midibuf_init(&d->midi_dbuf_out);
-		midibuf_init(&d->midi_dbuf_passthru);
+		midibuf_clear(&d->midi_dbuf_out);
+		midibuf_clear(&d->midi_dbuf_passthru);
 	}
 
 	/* Stop playing and unmark this device busy. */
@@ -355,21 +488,24 @@ midi_close(dev_t i_dev, int flags, int mode, struct proc * p)
 
 	device_unbusy(d->dev);
 
+	mtx_unlock(&d->flagqueue_mtx);
+
 	if (d->close == NULL)
 		ret = 0;
 	else
 		ret = d->close(i_dev, flags, mode, p);
 
-	splx(s);
-
 	return (ret);
 }
 
 int
 midi_read(dev_t i_dev, struct uio * buf, int flag)
 {
-	int dev, unit, s, len, ret;
+	int dev, unit, len, ret;
 	mididev_info *d ;
+#if defined(MIDI_OUTOFGIANT)
+	char *buf2; /* XXX Until uiomove(9) becomes MP-safe. */
+#endif /* MIDI_OUTOFGIANT */
 
 	dev = minor(i_dev);
 
@@ -380,27 +516,50 @@ midi_read(dev_t i_dev, struct uio * buf, int flag)
 		return (ENXIO);
 
 	ret = 0;
-	s = splmidi();
+
+#if defined(MIDI_OUTOFGIANT)
+	mtx_lock(&Giant);
+	buf2 = malloc(buf->uio_resid, M_DEVBUF, M_WAITOK);
+	mtx_unlock(&Giant);
+	if (buf2 == NULL)
+		return (ENOMEM);
+#endif /* MIDI_OUTOFGIANT */
+
+	mtx_lock(&d->flagqueue_mtx);
 
 	/* Begin recording. */
 	d->callback(d, MIDI_CB_START | MIDI_CB_RD);
 
+	len = 0;
+
 	/* Have we got the data to read? */
 	if ((d->flags & MIDI_F_NBIO) != 0 && d->midi_dbuf_in.rl == 0)
 		ret = EAGAIN;
 	else {
+#if defined(MIDI_OUTOFGIANT)
 		len = buf->uio_resid;
-		ret = midibuf_uioread(&d->midi_dbuf_in, buf, len);
+		if ((d->flags & MIDI_F_NBIO) != 0 && len > d->midi_dbuf_in.rl)
+			len = d->midi_dbuf_in.rl;
+		ret = midibuf_seqread(&d->midi_dbuf_in, buf2, len, &d->flagqueue_mtx);
+#else
+		len = buf->uio_resid;
+		ret = midibuf_uioread(&d->midi_dbuf_in, buf, len, &d->flagqueue_mtx);
+#endif /* MIDI_OUTOFGIANT */
 		if (ret < 0)
 			ret = -ret;
 		else
 			ret = 0;
 	}
 
-	if (ret == 0 && d->read != NULL)
-		ret = d->read(i_dev, buf, flag);
+	mtx_unlock(&d->flagqueue_mtx);
 
-	splx(s);
+#if defined(MIDI_OUTOFGIANT)
+	mtx_lock(&Giant);
+	if (ret == 0)
+		uiomove((caddr_t)buf2, len, buf);
+	free(buf2, M_DEVBUF);
+	mtx_unlock(&Giant);
+#endif /* MIDI_OUTOFGIANT */
 
 	return (ret);
 }
@@ -408,8 +567,12 @@ midi_read(dev_t i_dev, struct uio * buf, int flag)
 int
 midi_write(dev_t i_dev, struct uio * buf, int flag)
 {
-	int dev, unit, s, len, ret;
+	int dev, unit, len, ret;
 	mididev_info *d;
+#if defined(MIDI_OUTOFGIANT)
+	char *buf2, *p; /* XXX Until uiomove(9) becomes MP-safe. */
+	int resid;
+#endif /* MIDI_OUTOFGIANT */
 
 	dev = minor(i_dev);
 	d = get_mididev_info(i_dev, &unit);
@@ -420,33 +583,60 @@ midi_write(dev_t i_dev, struct uio * buf, int flag)
 		return (ENXIO);
 
 	ret = 0;
-	s = splmidi();
 
-	/* Begin playing. */
-	d->callback(d, MIDI_CB_START | MIDI_CB_WR);
+#if defined(MIDI_OUTOFGIANT)
+	resid = buf->uio_resid;
+	mtx_lock(&d->flagqueue_mtx);
+	if (resid > d->midi_dbuf_out.fl &&
+	    (d->flags & MIDI_F_NBIO))
+		resid = d->midi_dbuf_out.fl;
+	mtx_unlock(&d->flagqueue_mtx);
+	mtx_lock(&Giant);
+	buf2 = p = malloc(resid, M_DEVBUF, M_WAITOK);
+	if (buf2 == NULL) {
+		mtx_unlock(&Giant);
+		return (ENOMEM);
+	}
+	ret = uiomove((caddr_t)buf2, resid, buf);
+#endif /* MIDI_OUTOFGIANT */
+
+	mtx_lock(&d->flagqueue_mtx);
 
 	/* Have we got the data to write? */
-	if ((d->flags & MIDI_F_NBIO) != 0 && d->midi_dbuf_out.fl == 0)
+	if ((d->flags & MIDI_F_NBIO) != 0 && d->midi_dbuf_out.fl == 0) {
+		/* Begin playing. */
+		d->callback(d, MIDI_CB_START | MIDI_CB_WR);
 		ret = EAGAIN;
-	else {
+	} else {
+#if defined(MIDI_OUTOFGIANT)
+		len = resid - (p - buf2);
+#else
 		len = buf->uio_resid;
+#endif /* MIDI_OUTOFGIANT */
 		if (len > d->midi_dbuf_out.fl &&
 		    (d->flags & MIDI_F_NBIO))
 			len = d->midi_dbuf_out.fl;
-		ret = midibuf_uiowrite(&d->midi_dbuf_out, buf, len);
+#if defined(MIDI_OUTOFGIANT)
+		ret = midibuf_seqwrite(&d->midi_dbuf_out, p, len, &d->flagqueue_mtx);
+#else
+		ret = midibuf_uiowrite(&d->midi_dbuf_out, buf, len, &d->flagqueue_mtx);
+#endif /* MIDI_OUTOFGIANT */
 		if (ret < 0)
 			ret = -ret;
-		else
+		else {
+			/* Begin playing. */
+			d->callback(d, MIDI_CB_START | MIDI_CB_WR);
 			ret = 0;
+		}
 	}
 
-	/* Begin playing. */
-	d->callback(d, MIDI_CB_START | MIDI_CB_WR);
-
-	if (ret == 0 && d->write != NULL)
-		ret = d->write(i_dev, buf, flag);
+	mtx_unlock(&d->flagqueue_mtx);
 
-	splx(s);
+#if defined(MIDI_OUTOFGIANT)
+	mtx_lock(&Giant);
+	free(buf2, M_DEVBUF);
+	mtx_unlock(&Giant);
+#endif /* MIDI_OUTOFGIANT */
 
 	return (ret);
 }
@@ -470,7 +660,6 @@ midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p)
 	int ret = ENOSYS, dev, unit;
 	mididev_info *d;
 	struct snd_size *sndsize;
-	u_long s;
 
 	dev = minor(i_dev);
 	d = get_mididev_info(i_dev, &unit);
@@ -492,7 +681,6 @@ midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p)
 	 * all routines are called with int. blocked. Make sure that
 	 * ints are re-enabled when calling slow or blocking functions!
 	 */
-	s = splmidi();
 	switch(cmd) {
 
 		/*
@@ -504,10 +692,14 @@ midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p)
 
 	case AIOSSIZE:     /* set the current blocksize */
 		sndsize = (struct snd_size *)arg;
+		mtx_lock(&d->flagqueue_mtx);
 		if (sndsize->play_size <= d->midi_dbuf_out.unit_size && sndsize->rec_size <= d->midi_dbuf_in.unit_size) {
-			d->flags &= ~MIDI_F_HAS_SIZE;
 			d->midi_dbuf_out.blocksize = d->midi_dbuf_out.unit_size;
 			d->midi_dbuf_in.blocksize = d->midi_dbuf_in.unit_size;
+			sndsize->play_size = d->midi_dbuf_out.blocksize;
+			sndsize->rec_size = d->midi_dbuf_in.blocksize;
+			d->flags &= ~MIDI_F_HAS_SIZE;
+			mtx_unlock(&d->flagqueue_mtx);
 		}
 		else {
 			if (sndsize->play_size > d->midi_dbuf_out.bufsize / 4)
@@ -521,27 +713,36 @@ midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p)
 			d->midi_dbuf_in.blocksize =
 			    ((sndsize->rec_size + d->midi_dbuf_in.unit_size - 1)
 			     / d->midi_dbuf_in.unit_size) * d->midi_dbuf_in.unit_size;
+			sndsize->play_size = d->midi_dbuf_out.blocksize;
+			sndsize->rec_size = d->midi_dbuf_in.blocksize;
 			d->flags |= MIDI_F_HAS_SIZE;
+			mtx_unlock(&d->flagqueue_mtx);
 		}
-		/* FALLTHROUGH */
+
+		ret = 0;
+		break;
+
 	case AIOGSIZE:	/* get the current blocksize */
 		sndsize = (struct snd_size *)arg;
+		mtx_lock(&d->flagqueue_mtx);
 		sndsize->play_size = d->midi_dbuf_out.blocksize;
 		sndsize->rec_size = d->midi_dbuf_in.blocksize;
+		mtx_unlock(&d->flagqueue_mtx);
 
 		ret = 0;
 		break;
 
 	case AIOSTOP:
+		mtx_lock(&d->flagqueue_mtx);
 		if (*(int *)arg == AIOSYNC_PLAY) /* play */
 			*(int *)arg = d->callback(d, MIDI_CB_STOP | MIDI_CB_WR);
 		else if (*(int *)arg == AIOSYNC_CAPTURE)
 			*(int *)arg = d->callback(d, MIDI_CB_STOP | MIDI_CB_RD);
 		else {
-			splx(s);
 			DEB(printf("AIOSTOP: bad channel 0x%x\n", *(int *)arg));
 			*(int *)arg = 0 ;
 		}
+		mtx_unlock(&d->flagqueue_mtx);
 		break ;
 
 	case AIOSYNC:
@@ -561,20 +762,25 @@ midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p)
 		    break;
 
 	case FIONBIO: /* set/clear non-blocking i/o */
+		mtx_lock(&d->flagqueue_mtx);
 		if ( *(int *)arg == 0 )
 			d->flags &= ~MIDI_F_NBIO ;
 		else
 			d->flags |= MIDI_F_NBIO ;
+		mtx_unlock(&d->flagqueue_mtx);
 		break ;
 
 	case MIOSPASSTHRU: /* set/clear passthru */
+		mtx_lock(&d->flagqueue_mtx);
 		if ( *(int *)arg == 0 )
 			d->flags &= ~MIDI_F_PASSTHRU ;
 		else
 			d->flags |= MIDI_F_PASSTHRU ;
 
 		/* Init the queue. */
-		midibuf_init(&d->midi_dbuf_passthru);
+		midibuf_clear(&d->midi_dbuf_passthru);
+
+		mtx_unlock(&d->flagqueue_mtx);
 
 		/* FALLTHROUGH */
 	case MIOGPASSTHRU: /* get passthru */
@@ -590,14 +796,13 @@ midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p)
 		ret = EINVAL;
 		break ;
 	}
-	splx(s);
 	return ret ;
 }
 
 int
 midi_poll(dev_t i_dev, int events, struct proc * p)
 {
-	int unit, dev, ret, s, lim;
+	int unit, dev, ret, lim;
 	mididev_info *d;
 
 	dev = minor(i_dev);
@@ -606,11 +811,9 @@ midi_poll(dev_t i_dev, int events, struct proc * p)
 	if (d == NULL)
 		return (ENXIO);
 
-	if (d->poll)
-		ret = d->poll(i_dev, events, p);
-
 	ret = 0;
-	s = splmidi();
+
+	mtx_lock(&d->flagqueue_mtx);
 
 	/* Look up the apropriate queue and select it. */
 	if ((events & (POLLOUT | POLLWRNORM)) != 0) {
@@ -645,7 +848,8 @@ midi_poll(dev_t i_dev, int events, struct proc * p)
 			/* We can write now. */
 			ret |= events & (POLLIN | POLLRDNORM);
 	}
-	splx(s);
+
+	mtx_unlock(&d->flagqueue_mtx);
 
 	return (ret);
 }
@@ -657,6 +861,36 @@ midi_intr(mididev_info *d)
 		d->intr(d->intrarg, d);
 }
 
+/* Flush the output queue. */
+#define MIDI_SYNC_TIMEOUT 1
+int
+midi_sync(mididev_info *d)
+{
+	int i, rl;
+
+	mtx_assert(&d->flagqueue_mtx, MA_OWNED);
+
+	while (d->midi_dbuf_out.rl > 0) {
+		if ((d->flags & MIDI_F_WRITING) == 0)
+			d->callback(d, MIDI_CB_START | MIDI_CB_WR);
+		rl = d->midi_dbuf_out.rl;
+		i = msleep(&d->midi_dbuf_out.tsleep_out, &d->flagqueue_mtx, PRIBIO | PCATCH, "midsnc", (d->midi_dbuf_out.bufsize * 10 * hz / 38400) + MIDI_SYNC_TIMEOUT * hz);
+		if (i == EINTR || i == ERESTART) {
+			if (i == EINTR)
+				d->callback(d, MIDI_CB_STOP | MIDI_CB_WR);
+			return (i);
+		}
+		if (i == EWOULDBLOCK && rl == d->midi_dbuf_out.rl) {
+			/* A queue seems to be stuck up. Give up and clear the queue. */
+			d->callback(d, MIDI_CB_STOP | MIDI_CB_WR);
+			midibuf_clear(&d->midi_dbuf_out);
+			return (0);
+		}
+	}
+
+	return 0;
+}
+
 /*
  * These handle the status message of the midi drivers.
  */
@@ -705,8 +939,8 @@ midi_initstatus(char *buf, int size)
 
 	p = 0;
 	p += snprintf(buf, size, "FreeBSD Midi Driver (newmidi) %s %s\nInstalled devices:\n", __DATE__, __TIME__);
-	for (i = 0 ; i < NMIDI_MAX ; i++) {
-		md = &midi_info[i];
+	for (i = 0 ; i < mididev_info_number() ; i++) {
+		md = get_mididev_info_unit(i);
 		if (!MIDICONFED(md))
 			continue;
 		dev = devclass_get_device(midi_devclass, i);
@@ -723,15 +957,13 @@ midi_initstatus(char *buf, int size)
 static int
 midi_readstatus(char *buf, int *ptr, struct uio *uio)
 {
-	int s, len;
+	int len;
 
-	s = splmidi();
 	len = min(uio->uio_resid, strlen(&buf[*ptr]));
 	if (len > 0) {
 		uiomove(&buf[*ptr], len, uio);
 		*ptr += len;
 	}
-	splx(s);
 
 	return (0);
 }
diff --git a/sys/dev/sound/midi/midi.h b/sys/dev/sound/midi/midi.h
index b0982c8..d9b81c7 100644
--- a/sys/dev/sound/midi/midi.h
+++ b/sys/dev/sound/midi/midi.h
@@ -65,6 +65,7 @@
 #include <sys/rman.h>
 #include <sys/mman.h>
 #include <sys/poll.h>
+#include <sys/mutex.h>
 
 #include <dev/sound/midi/miditypes.h>
 #include <dev/sound/midi/midibuf.h>
@@ -72,6 +73,31 @@
 
 #define MIDI_CDEV_MAJOR 30
 
+/*#define MIDI_OUTOFGIANT*/
+
+#if defined(MIDI_OUTOFGIANT)
+#define MIDI_DROP_GIANT			DROP_GIANT
+#define MIDI_DROP_GIANT_NOSWITCH	DROP_GIANT_NOSWITCH
+#define MIDI_PICKUP_GIANT		PICKUP_GIANT
+#define MIDI_PARTIAL_PICKUP_GIANT	PARTIAL_PICKUP_GIANT
+#else
+#define MIDI_DROP_GIANT()
+#define MIDI_DROP_GIANT_NOSWITCH()
+#define MIDI_PICKUP_GIANT()
+#define MIDI_PARTIAL_PICKUP_GIANT()
+#endif /* MIDI_OUTOFGIANT */
+
+
+/*
+ * The order of mutex lock (from the first to the last)
+ *
+ * 1. sequencer flags, queues, timer and device list
+ * 2. midi synth voice and channel
+ * 3. midi synth status
+ * 4. generic midi flags and queues
+ * 5. midi device
+ */
+
 /*
  * descriptor of midi operations ...
  *
@@ -89,10 +115,7 @@ struct _mididev_info {
 
 	d_open_t *open;
 	d_close_t *close;
-	d_read_t *read;
-	d_write_t *write;
 	d_ioctl_t *ioctl;
-	d_poll_t *poll;
 	midi_callback_t *callback;
 
 	/*
@@ -133,6 +156,9 @@ struct _mididev_info {
 			 * mss codec type, etc. etc.
 			 */
 
+	struct mtx flagqueue_mtx; /* Mutex to protect flags and queues */
+
+	/* Queues */
 	midi_dbuf midi_dbuf_in; /* midi input event/message queue */
 	midi_dbuf midi_dbuf_out; /* midi output event/message queue */
 	midi_dbuf midi_dbuf_passthru; /* midi passthru event/message queue */
@@ -142,6 +168,7 @@ struct _mididev_info {
          * Generic things like busy flag, speed, etc are here.
          */
 
+	/* Flags */
 	volatile u_long  flags ;     /* 32 bits, used for various purposes. */
 	int fflags; /* file flag */
 
@@ -211,6 +238,12 @@ struct _mididev_info {
 
 	/* This is the status message to display via /dev/midistat */
 	char midistat[128];
+
+	/* The tailq entry of the next midi device. */
+	TAILQ_ENTRY(_mididev_info) md_link;
+
+	/* The tailq entry of the next midi device opened by a sequencer. */
+	TAILQ_ENTRY(_mididev_info) md_linkseq;
 } ;
 
 /*
@@ -243,7 +276,7 @@ struct _mididev_info {
 /*
  * finally, all default parameters
  */
-#define MIDI_BUFFSIZE (4 * 1024) /* XXX */
+#define MIDI_BUFFSIZE (1024) /* XXX */
 
 /*
  * some macros for debugging purposes
@@ -263,7 +296,7 @@ struct _mididev_info {
 /* This provides an access to the mididev_info. */
 	mididev_info *get_mididev_info(dev_t i_dev, int *unit);
 	mididev_info *get_mididev_info_unit(int unit);
-	mididev_info *create_mididev_info_unit(int *unit, int type);
+	mididev_info *create_mididev_info_unit(int type, mididev_info *mdinf, synthdev_info *syninf);
 	int mididev_info_number(void);
 #define MDT_MIDI	(0)
 #define MDT_SYNTH	(1)
@@ -279,10 +312,8 @@ struct _mididev_info {
 /* Common interrupt handler */
 void midi_intr(mididev_info *);
 
-/*
- * library functions (in midi.c)
- */
-#define splmidi() spltty()
+/* Sync output */
+int midi_sync(mididev_info *);
 
 /*
  * Minor numbers for the midi driver.
diff --git a/sys/dev/sound/midi/midibuf.c b/sys/dev/sound/midi/midibuf.c
index 5922a5b..e1f15c7 100644
--- a/sys/dev/sound/midi/midibuf.c
+++ b/sys/dev/sound/midi/midibuf.c
@@ -44,6 +44,7 @@
 static void queuerawdata(midi_dbuf *dbuf, char *data, int len);
 static void queueuiodata(midi_dbuf *dbuf, struct uio *buf, int len);
 static void dequeuerawdata(midi_dbuf *dbuf, char *data, int len);
+static void undequeuerawdata(midi_dbuf *dbuf, char *data, int len);
 static void copyrawdata(midi_dbuf *dbuf, char *data, int len);
 static void dequeueuiodata(midi_dbuf *dbuf, struct uio *buf, int len);
 
@@ -57,7 +58,23 @@ midibuf_init(midi_dbuf *dbuf)
 {
 	if (dbuf->buf != NULL)
 		free(dbuf->buf, M_DEVBUF);
-	dbuf->buf = malloc(MIDI_BUFFSIZE, M_DEVBUF, M_NOWAIT);
+	dbuf->buf = malloc(MIDI_BUFFSIZE, M_DEVBUF, M_WAITOK | M_ZERO);
+
+	return (midibuf_clear(dbuf));
+}
+
+int
+midibuf_destroy(midi_dbuf *dbuf)
+{
+	if (dbuf->buf != NULL)
+		free(dbuf->buf, M_DEVBUF);
+
+	return (0);
+}
+
+int
+midibuf_clear(midi_dbuf *dbuf)
+{
 	bzero(dbuf->buf, MIDI_BUFFSIZE);
 	dbuf->bufsize = MIDI_BUFFSIZE;
 	dbuf->rp = dbuf->fp = 0;
@@ -77,7 +94,7 @@ midibuf_init(midi_dbuf *dbuf)
 
 /* The sequencer calls this function to queue data. */
 int
-midibuf_seqwrite(midi_dbuf *dbuf, u_char* data, int len)
+midibuf_seqwrite(midi_dbuf *dbuf, u_char* data, int len, struct mtx *m)
 {
 	int i, lwrt, lwritten;
 
@@ -104,7 +121,7 @@ midibuf_seqwrite(midi_dbuf *dbuf, u_char* data, int len)
 		/* Have we got still more data to write? */
 		if (len > 0) {
 			/* Yes, sleep until we have enough space. */
-			i = tsleep((void *)&dbuf->tsleep_out, PRIBIO | PCATCH, "mbsqwt", 0);
+			i = msleep((void *)&dbuf->tsleep_out, m, PRIBIO | PCATCH, "mbsqwt", 0);
 			if (i == EINTR || i == ERESTART)
 				return (-i);
 		}
@@ -115,7 +132,7 @@ midibuf_seqwrite(midi_dbuf *dbuf, u_char* data, int len)
 
 /* sndwrite calls this function to queue data. */
 int
-midibuf_uiowrite(midi_dbuf *dbuf, struct uio *buf, int len)
+midibuf_uiowrite(midi_dbuf *dbuf, struct uio *buf, int len, struct mtx *m)
 {
 	int i, lwrt, lwritten;
 
@@ -141,7 +158,7 @@ midibuf_uiowrite(midi_dbuf *dbuf, struct uio *buf, int len)
 		/* Have we got still more data to write? */
 		if (len > 0) {
 			/* Yes, sleep until we have enough space. */
-			i = tsleep(&dbuf->tsleep_out, PRIBIO | PCATCH, "mbuiwt", 0);
+			i = msleep(&dbuf->tsleep_out, m, PRIBIO | PCATCH, "mbuiwt", 0);
 			if (i == EINTR || i == ERESTART)
 				return (-i);
 		}
@@ -202,7 +219,7 @@ midibuf_input_intr(midi_dbuf *dbuf, u_char *data, int len)
 
 /* The sequencer calls this function to dequeue data. */
 int
-midibuf_seqread(midi_dbuf *dbuf, u_char* data, int len)
+midibuf_seqread(midi_dbuf *dbuf, u_char* data, int len, struct mtx *m)
 {
 	int i, lrd, lread;
 
@@ -216,7 +233,7 @@ midibuf_seqread(midi_dbuf *dbuf, u_char* data, int len)
 		/* Have we got data to read? */
 		if ((lrd = DATA_AVAIL(dbuf)) == 0) {
 			/* No, sleep until we have data ready to read. */
-			i = tsleep(&dbuf->tsleep_in, PRIBIO | PCATCH, "mbsqrd", 0);
+			i = msleep(&dbuf->tsleep_in, m, PRIBIO | PCATCH, "mbsqrd", 0);
 			if (i == EINTR || i == ERESTART)
 				return (-i);
 			if (i == EWOULDBLOCK)
@@ -240,9 +257,49 @@ midibuf_seqread(midi_dbuf *dbuf, u_char* data, int len)
 	return (lread);
 }
 
+/* The sequencer calls this function to undo dequeued data. */
+int
+midibuf_sequnread(midi_dbuf *dbuf, u_char* data, int len, struct mtx *m)
+{
+	int i, lrd, lunread;
+
+	/* Is this a real queue? */
+	if (dbuf == (midi_dbuf *)NULL)
+		return (0);
+
+	lunread = 0;
+	/* Write down every single byte. */
+	while (len > 0) {
+		/* Have we got data to read? */
+		if ((lrd = SPACE_AVAIL(dbuf)) == 0) {
+			/* No, sleep until we have data ready to read. */
+			i = msleep(&dbuf->tsleep_in, m, PRIBIO | PCATCH, "mbsqur", 0);
+			if (i == EINTR || i == ERESTART)
+				return (-i);
+			if (i == EWOULDBLOCK)
+				continue;
+			/* Find out the number of bytes to unread. */
+			lrd = SPACE_AVAIL(dbuf);
+		}
+
+		if (lrd > len)
+			lrd = len;
+		if (lrd > 0) {
+			/* We can read some data now. Dequeue the data. */
+			undequeuerawdata(dbuf, data, lrd);
+
+			lunread += lrd;
+			len -= lrd;
+			data += lrd;
+		}
+	}
+
+	return (lunread);
+}
+
 /* The sequencer calls this function to copy data without dequeueing. */
 int
-midibuf_seqcopy(midi_dbuf *dbuf, u_char* data, int len)
+midibuf_seqcopy(midi_dbuf *dbuf, u_char* data, int len, struct mtx *m)
 {
 	int i, lrd, lread;
 
@@ -256,7 +313,7 @@ midibuf_seqcopy(midi_dbuf *dbuf, u_char* data, int len)
 		/* Have we got data to read? */
 		if ((lrd = DATA_AVAIL(dbuf)) == 0) {
 			/* No, sleep until we have data ready to read. */
-			i = tsleep(&dbuf->tsleep_in, PRIBIO | PCATCH, "mbsqrd", 0);
+			i = msleep(&dbuf->tsleep_in, m, PRIBIO | PCATCH, "mbsqrd", 0);
 			if (i == EINTR || i == ERESTART)
 				return (-i);
 			if (i == EWOULDBLOCK)
@@ -282,7 +339,7 @@ midibuf_seqcopy(midi_dbuf *dbuf, u_char* data, int len)
 
 /* sndread calls this function to dequeue data. */
 int
-midibuf_uioread(midi_dbuf *dbuf, struct uio *buf, int len)
+midibuf_uioread(midi_dbuf *dbuf, struct uio *buf, int len, struct mtx *m)
 {
 	int i, lrd, lread;
 
@@ -295,7 +352,7 @@ midibuf_uioread(midi_dbuf *dbuf, struct uio *buf, int len)
 		/* Have we got data to read? */
 		if ((lrd = DATA_AVAIL(dbuf)) == 0) {
 			/* No, sleep until we have data ready to read. */
-			i = tsleep(&dbuf->tsleep_in, PRIBIO | PCATCH, "mbuird", 0);
+			i = msleep(&dbuf->tsleep_in, m, PRIBIO | PCATCH, "mbuird", 0);
 			if (i == EINTR || i == ERESTART)
 				return (-i);
 			if (i == EWOULDBLOCK)
@@ -385,6 +442,28 @@ dequeuerawdata(midi_dbuf *dbuf, char *data, int len)
 		selwakeup(&dbuf->sel);
 }
 
+/* Undo the last dequeue. */
+static void
+undequeuerawdata(midi_dbuf *dbuf, char *data, int len)
+{
+	/* Copy the data. */
+	if (dbuf->rp < len) {
+		memcpy(dbuf->buf, data + (len - dbuf->rp), dbuf->rp);
+		memcpy(dbuf->buf + (dbuf->bufsize - (len - dbuf->rp)), data, len - dbuf->rp);
+	} else
+		memcpy(dbuf->buf + (dbuf->rp - len), data, len);
+
+	/* Adjust the pointer and the length counters. */
+	dbuf->rp = (dbuf->rp - len + dbuf->bufsize) % dbuf->bufsize;
+	dbuf->rl += len;
+	dbuf->fl -= len;
+
+	/* Wake up the processes sleeping on queueing. */
+	wakeup(&dbuf->tsleep_in);
+	if (dbuf->sel.si_pid && dbuf->rl >= dbuf->blocksize)
+		selwakeup(&dbuf->sel);
+}
+
 static void
 copyrawdata(midi_dbuf *dbuf, char *data, int len)
 {
diff --git a/sys/dev/sound/midi/midibuf.h b/sys/dev/sound/midi/midibuf.h
index d40019d..68a7a37 100644
--- a/sys/dev/sound/midi/midibuf.h
+++ b/sys/dev/sound/midi/midibuf.h
@@ -55,10 +55,13 @@ typedef struct _midi_dbuf {
  * These are the midi buffer methods, used in midi interface devices.
  */
 int midibuf_init(midi_dbuf *dbuf);
-int midibuf_seqwrite(midi_dbuf *dbuf, u_char* data, int len);
-int midibuf_uiowrite(midi_dbuf *dbuf, struct uio *buf, int len);
+int midibuf_destroy(midi_dbuf *dbuf);
+int midibuf_clear(midi_dbuf *dbuf);
+int midibuf_seqwrite(midi_dbuf *dbuf, u_char* data, int len, struct mtx *m);
+int midibuf_uiowrite(midi_dbuf *dbuf, struct uio *buf, int len, struct mtx *m);
 int midibuf_output_intr(midi_dbuf *dbuf, u_char *data, int len);
 int midibuf_input_intr(midi_dbuf *dbuf, u_char *data, int len);
-int midibuf_seqread(midi_dbuf *dbuf, u_char* data, int len);
-int midibuf_seqcopy(midi_dbuf *dbuf, u_char* data, int len);
-int midibuf_uioread(midi_dbuf *dbuf, struct uio *buf, int len);
+int midibuf_seqread(midi_dbuf *dbuf, u_char* data, int len, struct mtx *m);
+int midibuf_sequnread(midi_dbuf *dbuf, u_char* data, int len, struct mtx *m);
+int midibuf_seqcopy(midi_dbuf *dbuf, u_char* data, int len, struct mtx *m);
+int midibuf_uioread(midi_dbuf *dbuf, struct uio *buf, int len, struct mtx *m);
diff --git a/sys/dev/sound/midi/midisynth.c b/sys/dev/sound/midi/midisynth.c
index 481f79c..63b4423 100644
--- a/sys/dev/sound/midi/midisynth.c
+++ b/sys/dev/sound/midi/midisynth.c
@@ -107,7 +107,7 @@ static int synth_leavesysex(mididev_info *md);
 static int
 synth_killnote(mididev_info *md, int chn, int note, int vel)
 {
-	int unit, msg, chp;
+	int unit;
 	synthdev_info *sd;
 	u_char c[3];
 
@@ -120,41 +120,21 @@ synth_killnote(mididev_info *md, int chn, int note, int vel)
 	if (synth_leavesysex(md) == EAGAIN)
 		return (EAGAIN);
 
-	msg = sd->prev_out_status & 0xf0;
-	chp = sd->prev_out_status & 0x0f;
-
-	if (chp == chn && ((msg == 0x90 && vel == 64) || msg == 0x80)) {
-		/* Use running status. */
-		c[0] = (u_char)note;
-		if (msg == 0x90)
-			/* The note was on. */
-			c[1] = 0;
-		else
-			c[1] = (u_char)vel;
-
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 2, 1) == EAGAIN)
-			return (EAGAIN);
+	if (vel == 64) {
+		c[0] = 0x90 | (chn & 0x0f); /* Note on. */
+		c[1] = (u_char)note;
+		c[2] = 0;
 	} else {
-		if (vel == 64) {
-			c[0] = 0x90 | (chn & 0x0f); /* Note on. */
-			c[1] = (u_char)note;
-			c[2] = 0;
-		} else {
-			c[0] = 0x80 | (chn & 0x0f); /* Note off. */
-			c[1] = (u_char)note;
-			c[2] = (u_char)vel;
-		}
-
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
-			return EAGAIN;
-		/* Update the status. */
-		sd->prev_out_status = c[0];
+		c[0] = 0x80 | (chn & 0x0f); /* Note off. */
+		c[1] = (u_char)note;
+		c[2] = (u_char)vel;
 	}
 
+	if (synth_prefixcmd(md, c[0]))
+		return (0);
+	if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
+		return EAGAIN;
+
 	return (0);
 }
 
@@ -178,8 +158,6 @@ synth_setinstr(mididev_info *md, int chn, int instr)
 	c[1] = (u_char)instr;
 	if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
 		return (EAGAIN);
-	/* Update the status. */
-	sd->prev_out_status = c[0];
 
 	return (0);
 }
@@ -187,7 +165,7 @@ synth_setinstr(mididev_info *md, int chn, int instr)
 static int
 synth_startnote(mididev_info *md, int chn, int note, int vel)
 {
-	int unit, msg, chp;
+	int unit;
 	synthdev_info *sd;
 	u_char c[3];
 
@@ -200,28 +178,13 @@ synth_startnote(mididev_info *md, int chn, int note, int vel)
 	if (synth_leavesysex(md) == EAGAIN)
 		return (EAGAIN);
 
-	msg = sd->prev_out_status & 0xf0;
-	chp = sd->prev_out_status & 0x0f;
-
-	if (chp == chn && msg == 0x90) {
-		/* Use running status. */
-		c[0] = (u_char)note;
-		c[1] = (u_char)vel;
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 2, 1) == EAGAIN)
-			return (EAGAIN);
-	} else {
-		c[0] = 0x90 | (chn & 0x0f); /* Note on. */
-		c[1] = (u_char)note;
-		c[2] = (u_char)vel;
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
-			return (EAGAIN);
-		/* Update the status. */
-		sd->prev_out_status = c[0];
-	}
+	c[0] = 0x90 | (chn & 0x0f); /* Note on. */
+	c[1] = (u_char)note;
+	c[2] = (u_char)vel;
+	if (synth_prefixcmd(md, c[0]))
+		return (0);
+	if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
+		return (EAGAIN);
 
 	return (0);
 }
@@ -292,8 +255,6 @@ synth_loadpatch(mididev_info *md, int format, struct uio *buf, int offs, int cou
 		}
 		if (!first_byte && (c[i] & 0x80) != 0) {
 			md->synth.writeraw(md, c, i + 1, 0);
-			/* Update the status. */
-			sd->prev_out_status = c[i];
 			return (0);
 		}
 		first_byte = 0;
@@ -302,7 +263,6 @@ synth_loadpatch(mididev_info *md, int format, struct uio *buf, int offs, int cou
 	if (!eox_seen) {
 		c[0] = 0xf7;
 		md->synth.writeraw(md, c, 1, 0);
-		sd->prev_out_status = c[0];
 	}
 
 	return (0);
@@ -318,7 +278,7 @@ synth_panning(mididev_info *md, int chn, int pan)
 static int
 synth_aftertouch(mididev_info *md, int chn, int press)
 {
-	int unit, msg, chp;
+	int unit;
 	synthdev_info *sd;
 	u_char c[2];
 
@@ -330,26 +290,12 @@ synth_aftertouch(mididev_info *md, int chn, int press)
 	if (synth_leavesysex(md) == EAGAIN)
 		return (EAGAIN);
 
-	msg = sd->prev_out_status & 0xf0;
-	chp = sd->prev_out_status & 0x0f;
-
-	if (chp == chn && msg == 0xd0) {
-		/* Use running status. */
-		c[0] = (u_char)press;
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 1, 1) == EAGAIN)
-			return (EAGAIN);
-	} else {
-		c[0] = 0xd0 | (chn & 0x0f); /* Channel Pressure. */
-		c[1] = (u_char)press;
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 2, 1) == EAGAIN)
-			return (EAGAIN);
-		/* Update the status. */
-		sd->prev_out_status = c[0];
-	}
+	c[0] = 0xd0 | (chn & 0x0f); /* Channel Pressure. */
+	c[1] = (u_char)press;
+	if (synth_prefixcmd(md, c[0]))
+		return (0);
+	if (md->synth.writeraw(md, c, 2, 1) == EAGAIN)
+		return (EAGAIN);
 
 	return (0);
 }
@@ -357,7 +303,7 @@ synth_aftertouch(mididev_info *md, int chn, int press)
 static int
 synth_controller(mididev_info *md, int chn, int ctrlnum, int val)
 {
-	int unit, msg, chp;
+	int unit;
 	synthdev_info *sd;
 	u_char c[3];
 
@@ -369,27 +315,12 @@ synth_controller(mididev_info *md, int chn, int ctrlnum, int val)
 	if (synth_leavesysex(md) == EAGAIN)
 		return (EAGAIN);
 
-	msg = sd->prev_out_status & 0xf0;
-	chp = sd->prev_out_status & 0x0f;
-
-	if (chp == chn && msg == 0xb0) {
-		/* Use running status. */
-		c[0] = (u_char)ctrlnum;
-		c[1] = (u_char)val & 0x7f;
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 2, 1) == EAGAIN)
-			return (EAGAIN);
-	} else {
-		c[0] = 0xb0 | (chn & 0x0f); /* Control Message. */
-		c[1] = (u_char)ctrlnum;
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
-			return (EAGAIN);
-		/* Update the status. */
-		sd->prev_out_status = c[0];
-	}
+	c[0] = 0xb0 | (chn & 0x0f); /* Control Message. */
+	c[1] = (u_char)ctrlnum;
+	if (synth_prefixcmd(md, c[0]))
+		return (0);
+	if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
+		return (EAGAIN);
 
 	return (0);
 }
@@ -403,7 +334,7 @@ synth_patchmgr(mididev_info *md, struct patmgr_info *rec)
 static int
 synth_bender(mididev_info *md, int chn, int val)
 {
-	int unit, msg, chp;
+	int unit;
 	synthdev_info *sd;
 	u_char c[3];
 
@@ -415,28 +346,13 @@ synth_bender(mididev_info *md, int chn, int val)
 	if (synth_leavesysex(md) == EAGAIN)
 		return (EAGAIN);
 
-	msg = sd->prev_out_status & 0xf0;
-	chp = sd->prev_out_status & 0x0f;
-
-	if (chp == chn && msg == 0xe0) {
-		/* Use running status. */
-		c[0] = (u_char)val & 0x7f;
-		c[1] = (u_char)(val >> 7) & 0x7f;
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 2, 1) == EAGAIN)
-			return (EAGAIN);
-	} else {
-		c[0] = 0xe0 | (chn & 0x0f); /* Pitch bend. */
-		c[1] = (u_char)val & 0x7f;
-		c[2] = (u_char)(val >> 7) & 0x7f;
-		if (synth_prefixcmd(md, c[0]))
-			return (0);
-		if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
-			return (EAGAIN);
-		/* Update the status. */
-		sd->prev_out_status = c[0];
-	}
+	c[0] = 0xe0 | (chn & 0x0f); /* Pitch bend. */
+	c[1] = (u_char)val & 0x7f;
+	c[2] = (u_char)(val >> 7) & 0x7f;
+	if (synth_prefixcmd(md, c[0]))
+		return (0);
+	if (md->synth.writeraw(md, c, 3, 1) == EAGAIN)
+		return (EAGAIN);
 
 	return (0);
 }
@@ -458,30 +374,37 @@ synth_setupvoice(mididev_info *md, int voice, int chn)
 static int
 synth_sendsysex(mididev_info *md, u_char *sysex, int len)
 {
-	int unit, i, j;
+	int unit, i;
 	synthdev_info *sd;
 	u_char c[len];
 
 	unit = md->unit;
 	sd = &md->synth;
 
+	mtx_lock(&sd->status_mtx);
 	for (i = 0 ; i < len ; i++) {
 		switch (sysex[i]) {
 		case 0xf0:
 			/* Sysex begins. */
-			if (synth_prefixcmd(md, 0xf0))
+			if (synth_prefixcmd(md, 0xf0)) {
+				mtx_unlock(&sd->status_mtx);
 				return (0);
+			}
 			sd->sysex_state = 1;
 			break;
 		case 0xf7:
 			/* Sysex ends. */
-			if (!sd->sysex_state)
+			if (!sd->sysex_state) {
+				mtx_unlock(&sd->status_mtx);
 				return (0);
+			}
 			sd->sysex_state = 0;
 			break;
 		default:
-			if (!sd->sysex_state)
+			if (!sd->sysex_state) {
+				mtx_unlock(&sd->status_mtx);
 				return (0);
+			}
 			if ((sysex[i] & 0x80) != 0) {
 				/* A status in a sysex? */
 				sysex[i] = 0xf7;
@@ -493,16 +416,10 @@ synth_sendsysex(mididev_info *md, u_char *sysex, int len)
 		if (!sd->sysex_state)
 			break;
 	}
+	mtx_unlock(&sd->status_mtx);
 	if (md->synth.writeraw(md, c, i, 1) == EAGAIN)
 		return (EAGAIN);
 
-	/* Update the status. */
-	for (j = i - 1 ; j >= 0 ; j--)
-		if ((c[j] & 0x80) != 0) {
-			sd->prev_out_status = c[j];
-			break;
-		}
-
 	return (0);
 }
 
@@ -523,7 +440,7 @@ synth_volumemethod(mididev_info *md, int mode)
 static int
 synth_readraw(mididev_info *md, u_char *buf, int len, int nonblock)
 {
-	int unit, ret, s;
+	int unit, ret;
 
 	if (md == NULL)
 		return (ENXIO);
@@ -534,20 +451,23 @@ synth_readraw(mididev_info *md, u_char *buf, int len, int nonblock)
 		return (EIO);
 	}
 
-	s = splmidi();
+	mtx_lock(&md->flagqueue_mtx);
 
 	/* Begin recording. */
-	md->callback(md, MIDI_CB_START | MIDI_CB_RD);
+	if ((md->flags & MIDI_F_READING) == 0)
+		md->callback(md, MIDI_CB_START | MIDI_CB_RD);
 
 	if (nonblock) {
 		/* Have we got enough data to read? */
-		if (md->midi_dbuf_in.rl < len)
+		if (md->midi_dbuf_in.rl < len) {
+			mtx_unlock(&md->flagqueue_mtx);
 			return (EAGAIN);
+		}
 	}
 
-	ret = midibuf_seqread(&md->midi_dbuf_in, buf, len);
+	ret = midibuf_seqread(&md->midi_dbuf_in, buf, len, &md->flagqueue_mtx);
 
-	splx(s);
+	mtx_unlock(&md->flagqueue_mtx);
 
 	if (ret < 0)
 		ret = -ret;
@@ -560,7 +480,7 @@ synth_readraw(mididev_info *md, u_char *buf, int len, int nonblock)
 static int
 synth_writeraw(mididev_info *md, u_char *buf, int len, int nonblock)
 {
-	int unit, ret, s;
+	int unit, ret;
 
 	if (md == NULL)
 		return (ENXIO);
@@ -573,21 +493,25 @@ synth_writeraw(mididev_info *md, u_char *buf, int len, int nonblock)
 	}
 
 	/* For nonblocking, have we got enough space to write? */
-	if (nonblock && md->midi_dbuf_out.fl < len)
+	mtx_lock(&md->flagqueue_mtx);
+	if (nonblock && md->midi_dbuf_out.fl < len) {
+		/* Begin playing. */
+		md->callback(md, MIDI_CB_START | MIDI_CB_WR);
+		mtx_unlock(&md->flagqueue_mtx);
 		return (EAGAIN);
+	}
 
-	s = splmidi();
+	ret = midibuf_seqwrite(&md->midi_dbuf_out, buf, len, &md->flagqueue_mtx);
 
-	ret = midibuf_seqwrite(&md->midi_dbuf_out, buf, len);
 	if (ret < 0)
 		ret = -ret;
-	else
+	else {
+		/* Begin playing. */
+		md->callback(md, MIDI_CB_START | MIDI_CB_WR);
 		ret = 0;
+	}
 
-	/* Begin playing. */
-	md->callback(md, MIDI_CB_START | MIDI_CB_WR);
-
-	splx(s);
+	mtx_unlock(&md->flagqueue_mtx);
 
 	return (ret);
 }
@@ -606,16 +530,17 @@ synth_leavesysex(mididev_info *md)
 	unit = md->unit;
 	sd = &md->synth;
 
-	if (!sd->sysex_state)
+	mtx_lock(&sd->status_mtx);
+	if (!sd->sysex_state) {
+		mtx_unlock(&sd->status_mtx);
 		return (0);
+	}
 
 	sd->sysex_state = 0;
+	mtx_unlock(&sd->status_mtx);
 	c = 0xf7;
 	if (md->synth.writeraw(md, &c, sizeof(c), 1) == EAGAIN)
 		return (EAGAIN);
-	sd->sysex_state = 0;
-	/* Update the status. */
-	sd->prev_out_status = c;
 
 	return (0);
 }
diff --git a/sys/dev/sound/midi/midisynth.h b/sys/dev/sound/midi/midisynth.h
index d27e62b..db43354 100644
--- a/sys/dev/sound/midi/midisynth.h
+++ b/sys/dev/sound/midi/midisynth.h
@@ -67,6 +67,16 @@ typedef int (mdsy_volumemethod_t)(mididev_info *md, int mode);
 typedef int (mdsy_readraw_t)(mididev_info *md, u_char *buf, int len, int nonblock);
 typedef int (mdsy_writeraw_t)(mididev_info *md, u_char *buf, int len, int nonblock);
 
+/*
+ * The order of mutex lock (from the first to the last)
+ *
+ * 1. sequencer flags, queues, timer and devlice list
+ * 2. midi synth voice and channel
+ * 3. midi synth status
+ * 4. generic midi flags and queues
+ * 5. midi device
+ */
+
 /* This is a midi synthesizer interface and state. */
 struct _synthdev_info {
 	mdsy_killnote_t *killnote;
@@ -88,10 +98,13 @@ struct _synthdev_info {
 	mdsy_readraw_t *readraw;
 	mdsy_writeraw_t *writeraw;
 
+	/* Voice and channel */
+	struct mtx vc_mtx; /* Mutex to protect voice and channel. */
 	struct voice_alloc_info alloc; /* Voice allocation. */
 	struct channel_info chn_info[16]; /* Channel information. */
 
-	u_char prev_out_status; /* Previous status. */
+	/* Status */
+	struct mtx status_mtx; /* Mutex to protect status. */
 	int sysex_state; /* State of sysex transmission. */
 };
 typedef struct _synthdev_info synthdev_info;
diff --git a/sys/dev/sound/midi/sequencer.c b/sys/dev/sound/midi/sequencer.c
index 7b010b4..dd4ce6a 100644
--- a/sys/dev/sound/midi/sequencer.c
+++ b/sys/dev/sound/midi/sequencer.c
@@ -58,6 +58,11 @@ enum {
 	QUEUEFULL
 };
 
+/* Lookup modes */
+#define LOOKUP_EXIST	(0)
+#define LOOKUP_OPEN	(1)
+#define LOOKUP_CLOSE	(2)
+
 /*
  * These functions goes into seq_op_desc to get called
  * from sound.c.
@@ -96,24 +101,35 @@ seqdev_info seq_op_desc = {
 	0, /* XXX This is not an *audio* device! */
 };
 
+
+
 /* Here is the parameter structure per a device. */
 struct seq_softc {
 	seqdev_info *devinfo; /* sequencer device information */
 
+	/* Flags (protected by flag_mtx of mididev_info) */
 	int fflags; /* Access mode */
+	int queueout_pending; /* Pending for the output queue */
 
+	/* Timer counters */
 	u_long seq_time; /* The beggining time of this sequence */
 	u_long prev_event_time; /* The time of the previous event output */
 	u_long prev_input_time; /* The time of the previous event input */
 	u_long prev_wakeup_time; /* The time of the previous wakeup */
-	struct callout_handle timeout_ch; /* Timer callout handler */
+	struct callout timeout_ch; /* Timer callout handler */
 	long timer_current; /* Current timer value */
 	int timer_running; /* State of timer */
-	int midi_open[NMIDI_MAX]; /* State of midi devices. */
 	int pending_timer; /* Timer change operation */
-	int output_threshould; /* Sequence output threshould */
 	int pre_event_timeout; /* Time to wait event input */
-	int queueout_pending; /* Pending for the output queue */
+
+	/* Device list */
+	TAILQ_HEAD(,_mididev_info) midi_open; /* Midi devices opened by this sequencer. */
+
+	/*
+	 * XXX not sure to which category these belong.
+	 * (and some might be no-op)
+	 */
+	int output_threshould; /* Sequence output threshould */
 	snd_sync_parm sync_parm; /* AIOSYNC parameter set */
 	struct proc *sync_proc; /* AIOSYNCing process */
 };
@@ -145,12 +161,15 @@ static struct cdevsw seq_cdevsw = {
 	/* bmaj */	-1
 };
 
-seqdev_info seq_info[NSEQ_MAX] ;
-static int seq_info_inited;
-u_long nseq = NSEQ_MAX;	/* total number of sequencers */
+static TAILQ_HEAD(,_seqdev_info) seq_info;
+/* Mutex to protect seq_info and nseq. */
+static struct mtx seqinfo_mtx;
+static u_long nseq;	/* total number of sequencers */
+static dev_t seq_alias = NODEV;
 
 /* The followings are the local function. */
 static int seq_init(void);
+static int seq_initunit(int unit);
 static int seq_queue(sc_p scp, u_char *note);
 static void seq_startplay(sc_p scp);
 static int seq_playevent(sc_p scp, u_char *event);
@@ -162,7 +181,7 @@ static int seq_copytoinput(sc_p scp, u_char *event, int len);
 static int seq_extended(sc_p scp, u_char *event);
 static int seq_chnvoice(sc_p scp, u_char *event);
 static int seq_findvoice(mididev_info *md, int chn, int note) __unused;
-static int seq_allocvoice(mididev_info *md, int chn, int note) __unused;
+static int seq_allocvoice(sc_p scp, mididev_info *md, int chn, int note) __unused;
 static int seq_chncommon(sc_p scp, u_char *event);
 static int seq_timing(sc_p scp, u_char *event);
 static int seq_local(sc_p scp, u_char *event);
@@ -175,6 +194,10 @@ static void seq_panic(sc_p scp);
 static int seq_sync(sc_p scp);
 
 static seqdev_info *get_seqdev_info(dev_t i_dev, int *unit);
+static seqdev_info *get_seqdev_info_unit(int unit);
+static seqdev_info *create_seqdev_info_unit(int unit, seqdev_info *seq);
+static int lookup_mididev(sc_p scp, int unit, int mode, mididev_info **mdp);
+static void seq_clone(void *arg, char *name, int namelen, dev_t *dev);
 
 /*
  * Here are the main functions to interact to the user process.
@@ -184,57 +207,63 @@ static seqdev_info *get_seqdev_info(dev_t i_dev, int *unit);
 static int
 seq_init(void)
 {
-	int unit;
-	sc_p scp;
-	seqdev_info *devinfo;
-
 	DEB(printf("seq: initing.\n"));
 
-	/* Have we already inited? */
-	if (seq_info_inited)
-		return (1);
+	mtx_init(&seqinfo_mtx, "seqinf", MTX_DEF);
+	TAILQ_INIT(&seq_info);
 
-	for (unit = 0 ; unit < nseq ; unit++) {
-		/* Allocate the softc. */
-		scp = malloc(sizeof(*scp), M_DEVBUF, M_NOWAIT);
-		if (scp == (sc_p)NULL) {
-			printf("seq%d: softc allocation failed.\n", unit);
-			return (1);
-		}
-		bzero(scp, sizeof(*scp));
+	seq_initunit(0);
+	EVENTHANDLER_REGISTER(dev_clone, seq_clone, 0, 1000);
 
-		/* Fill the softc and the seq_info for this unit. */
-		scp->seq_time = seq_gettime();
-		scp->prev_event_time = 0;
-		scp->prev_input_time = 0;
-		scp->prev_wakeup_time = scp->seq_time;
-		callout_handle_init(&scp->timeout_ch);
-		scp->timer_current = 0;
-		scp->timer_running = 0;
-		scp->queueout_pending = 0;
+	DEB(printf("seq: inited.\n"));
 
-		scp->devinfo = devinfo = &seq_info[unit];
-		bcopy(&seq_op_desc, devinfo, sizeof(seq_op_desc));
-		devinfo->unit = unit;
-		devinfo->softc = scp;
-		devinfo->flags = 0;
-		devinfo->midi_dbuf_in.unit_size = devinfo->midi_dbuf_out.unit_size = EV_SZ;
-		midibuf_init(&devinfo->midi_dbuf_in);
-		midibuf_init(&devinfo->midi_dbuf_out);
-
-		make_dev(&seq_cdevsw, MIDIMKMINOR(unit, SND_DEV_SEQ),
-			 UID_ROOT, GID_WHEEL, 0666, "sequencer%d", unit);
-	}
+	return (0);
+}
 
-	/* We have inited. */
-	seq_info_inited = 1;
+static int
+seq_initunit(int unit)
+{
+	sc_p scp;
+	seqdev_info *devinfo;
+	dev_t seqdev;
 
-	if (nseq == 1)
-		printf("seq0: Midi sequencer.\n");
-	else
-		printf("seq0-%lu: Midi sequencers.\n", nseq - 1);
+	/* Allocate the softc. */
+	scp = malloc(sizeof(*scp), M_DEVBUF, M_WAITOK | M_ZERO);
+	if (scp == (sc_p)NULL) {
+		printf("seq%d: softc allocation failed.\n", unit);
+		return (1);
+	}
 
-	DEB(printf("seq: inited.\n"));
+	/* Fill the softc and the seq_info for this unit. */
+	scp->seq_time = seq_gettime();
+	scp->prev_event_time = 0;
+	scp->prev_input_time = 0;
+	scp->prev_wakeup_time = scp->seq_time;
+#if defined(MIDI_OUTOFGIANT)
+	callout_init(&scp->timeout_ch, 1);
+#else
+	callout_init(&scp->timeout_ch, 0);
+#endif /* MIDI_OUTOFGIANT */
+	scp->timer_current = 0;
+	scp->timer_running = 0;
+	scp->queueout_pending = 0;
+	TAILQ_INIT(&scp->midi_open);
+
+	scp->devinfo = devinfo = create_seqdev_info_unit(unit, &seq_op_desc);
+	devinfo->midi_dbuf_in.unit_size = devinfo->midi_dbuf_out.unit_size = EV_SZ;
+	devinfo->softc = scp;
+	devinfo->flags = 0;
+	mtx_unlock(&devinfo->flagqueue_mtx);
+
+	seqdev = make_dev(&seq_cdevsw, MIDIMKMINOR(unit, SND_DEV_SEQ),
+			  UID_ROOT, GID_WHEEL, 0666, "sequencer%d", unit);
+	mtx_lock(&seqinfo_mtx);
+	if (seq_alias != NODEV) {
+		destroy_dev(seq_alias);
+		seq_alias = NODEV;
+	}
+	seq_alias = make_dev_alias(seqdev, "sequencer");
+	mtx_unlock(&seqinfo_mtx);
 
 	return (0);
 }
@@ -242,10 +271,9 @@ seq_init(void)
 int
 seq_open(dev_t i_dev, int flags, int mode, struct proc *p)
 {
-	int unit, s, midiunit;
+	int unit;
 	sc_p scp;
 	seqdev_info *sd;
-	mididev_info *md;
 
 	unit = MIDIUNIT(i_dev);
 
@@ -263,10 +291,13 @@ seq_open(dev_t i_dev, int flags, int mode, struct proc *p)
 	}
 	scp = sd->softc;
 
-	s = splmidi();
+	MIDI_DROP_GIANT_NOSWITCH();
+
 	/* Mark this device busy. */
+	mtx_lock(&sd->flagqueue_mtx);
 	if ((sd->flags & SEQ_F_BUSY) != 0) {
-		splx(s);
+		mtx_unlock(&sd->flagqueue_mtx);
+		MIDI_PARTIAL_PICKUP_GIANT();
 		DEB(printf("seq_open: unit %d is busy.\n", unit));
 		return (EBUSY);
 	}
@@ -275,8 +306,8 @@ seq_open(dev_t i_dev, int flags, int mode, struct proc *p)
 	scp->fflags = flags;
 
 	/* Init the queue. */
-	midibuf_init(&sd->midi_dbuf_in);
-	midibuf_init(&sd->midi_dbuf_out);
+	midibuf_clear(&sd->midi_dbuf_in);
+	midibuf_clear(&sd->midi_dbuf_out);
 
 	/* Init timestamp. */
 	scp->seq_time = seq_gettime();
@@ -284,14 +315,9 @@ seq_open(dev_t i_dev, int flags, int mode, struct proc *p)
 	scp->prev_input_time = 0;
 	scp->prev_wakeup_time = scp->seq_time;
 
-	splx(s);
+	mtx_unlock(&sd->flagqueue_mtx);
 
-	/* Open midi devices. */
-	for (midiunit = 0 ; midiunit < mididev_info_number() ; midiunit++) {
-		md = get_mididev_info_unit(midiunit);
-		if (MIDICONFED(md))
-			seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, p);
-	}
+	MIDI_PICKUP_GIANT();
 
 	DEB(printf("seq%d: opened.\n", unit));
 
@@ -301,7 +327,7 @@ seq_open(dev_t i_dev, int flags, int mode, struct proc *p)
 int
 seq_close(dev_t i_dev, int flags, int mode, struct proc *p)
 {
-	int unit, s, i;
+	int unit;
 	sc_p scp;
 	seqdev_info *sd;
 	mididev_info *md;
@@ -322,7 +348,9 @@ seq_close(dev_t i_dev, int flags, int mode, struct proc *p)
 	}
 	scp = sd->softc;
 
-	s = splmidi();
+	MIDI_DROP_GIANT_NOSWITCH();
+
+	mtx_lock(&sd->flagqueue_mtx);
 
 	if (!(sd->flags & MIDI_F_NBIO))
 		seq_sync(scp);
@@ -335,16 +363,16 @@ seq_close(dev_t i_dev, int flags, int mode, struct proc *p)
 	seq_sync(scp);
 
 	/* Clean up the midi device. */
-	for (i = 0 ; i < mididev_info_number() ; i++) {
-		md = get_mididev_info_unit(i);
-		if (MIDICONFED(md))
-			seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, p);
-	}
+	TAILQ_FOREACH(md, &scp->midi_open, md_linkseq)
+		lookup_mididev(scp, md->unit, LOOKUP_CLOSE, NULL);
+	mtx_unlock(&sd->flagqueue_mtx);
 
 	/* Stop playing and unmark this device busy. */
-	sd->flags &= ~(SEQ_F_BUSY | SEQ_F_READING | SEQ_F_WRITING);
+	mtx_lock(&sd->flagqueue_mtx);
+	sd->flags &= ~(SEQ_F_BUSY | SEQ_F_READING | SEQ_F_WRITING | SEQ_F_INSYNC);
+	mtx_unlock(&sd->flagqueue_mtx);
 
-	splx(s);
+	MIDI_PICKUP_GIANT();
 
 	DEB(printf("seq%d: closed.\n", unit));
 
@@ -354,9 +382,12 @@ seq_close(dev_t i_dev, int flags, int mode, struct proc *p)
 int
 seq_read(dev_t i_dev, struct uio *buf, int flag)
 {
-	int unit, ret, s, len;
+	int unit, ret, len;
 	sc_p scp;
 	seqdev_info *sd;
+#if defined(MIDI_OUTOFGIANT)
+	char *buf2; /* XXX Until uiomove(9) becomes MP-safe. */
+#endif /* MIDI_OUTOFGIANT */
 
 	unit = MIDIUNIT(i_dev);
 
@@ -378,23 +409,49 @@ seq_read(dev_t i_dev, struct uio *buf, int flag)
 		return (EIO);
 	}
 
-	s = splmidi();
+#if defined(MIDI_OUTOFGIANT)
+	buf2 = malloc(buf->uio_resid, M_DEVBUF, M_WAITOK);
+	if (buf2 == NULL)
+		return (ENOMEM);
+#endif /* MIDI_OUTOFGIANT */
+
+	MIDI_DROP_GIANT_NOSWITCH();
+
+	mtx_lock(&sd->flagqueue_mtx);
 
 	/* Begin recording. */
-	sd->callback(sd, SEQ_CB_START | SEQ_CB_RD);
+	if ((sd->flags & SEQ_F_READING) == 0)
+		sd->callback(sd, SEQ_CB_START | SEQ_CB_RD);
+
+	len = 0;
 
 	/* Have we got the data to read? */
 	if ((sd->flags & SEQ_F_NBIO) != 0 && sd->midi_dbuf_in.rl == 0)
 		ret = EAGAIN;
 	else {
+#if defined(MIDI_OUTOFGIANT)
+		len = buf->uio_resid;
+		if ((sd->flags & SEQ_F_NBIO) != 0 && len > sd->midi_dbuf_in.rl)
+			len = sd->midi_dbuf_in.rl;
+		ret = midibuf_seqread(&sd->midi_dbuf_in, buf2, len, &sd->flagqueue_mtx);
+#else
 		len = buf->uio_resid;
-		ret = midibuf_uioread(&sd->midi_dbuf_in, buf, len);
+		ret = midibuf_uioread(&sd->midi_dbuf_in, buf, len, &sd->flagqueue_mtx);
+#endif /* MIDI_OUTOFGIANT */
 		if (ret < 0)
 			ret = -ret;
 		else
 			ret = 0;
 	}
-	splx(s);
+	mtx_unlock(&sd->flagqueue_mtx);
+
+	MIDI_PICKUP_GIANT();
+
+#if defined(MIDI_OUTOFGIANT)
+	if (ret == 0)
+		uiomove((caddr_t)buf2, len, buf);
+	free(buf2, M_DEVBUF);
+#endif /* MIDI_OUTOFGIANT */
 
 	return (ret);
 }
@@ -403,7 +460,7 @@ int
 seq_write(dev_t i_dev, struct uio *buf, int flag)
 {
 	u_char event[EV_SZ], ev_code;
-	int unit, count, countorg, midiunit, ev_size, p, ret, s;
+	int unit, count, countorg, midiunit, ev_size, p, ret;
 	sc_p scp;
 	seqdev_info *sd;
 	mididev_info *md;
@@ -432,15 +489,18 @@ seq_write(dev_t i_dev, struct uio *buf, int flag)
 	countorg = buf->uio_resid;
 	count = countorg;
 
-	s = splmidi();
-	/* Begin playing. */
-	sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
-	splx(s);
+	MIDI_DROP_GIANT_NOSWITCH();
 
 	/* Pick up an event. */
 	while (count >= 4) {
+#if defined(MIDI_OUTOFGIANT)
+		mtx_lock(&Giant);
+#endif /* MIDI_OUTOFGIANT */
 		if (uiomove((caddr_t)event, 4, buf))
 			printf("seq_write: user memory mangled?\n");
+#if defined(MIDI_OUTOFGIANT)
+		mtx_unlock(&Giant);
+#endif /* MIDI_OUTOFGIANT */
 		ev_code = event[0];
 
 		/* Have a look at the event code. */
@@ -448,22 +508,18 @@ seq_write(dev_t i_dev, struct uio *buf, int flag)
 
 			/* A long event, these are the patches/samples for a synthesizer. */
 			midiunit = *(u_short *)&event[2];
-			if (midiunit < 0 || midiunit >= mididev_info_number())
-				return (ENXIO);
-			md = get_mididev_info_unit(midiunit);
-			if (!MIDICONFED(md))
-				return (ENXIO);
-			s = splmidi();
-			if ((md->flags & MIDI_F_BUSY) == 0
-			    && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0) {
-				splx(s);
-				return (ENXIO);
+			mtx_lock(&sd->flagqueue_mtx);
+			ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+			mtx_unlock(&sd->flagqueue_mtx);
+			if (ret != 0) {
+				MIDI_PARTIAL_PICKUP_GIANT();
+				return (ret);
 			}
 
 			DEB(printf("seq_write: loading a patch to the unit %d.\n", midiunit));
 
 			ret = md->synth.loadpatch(md, *(short *)&event[0], buf, p + 4, count, 0);
-			splx(s);
+			MIDI_PARTIAL_PICKUP_GIANT();
 			return (ret);
 		}
 
@@ -472,6 +528,7 @@ seq_write(dev_t i_dev, struct uio *buf, int flag)
 			/* Some sort of an extended event. The size is eight bytes. */
 #if notyet
 			if (scp->seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED) {
+				MIDI_PARTIAL_PICKUP_GIANT();
 				printf("seq%d: invalid level two event %x.\n", unit, ev_code);
 				return (EINVAL);
 			}
@@ -480,19 +537,28 @@ seq_write(dev_t i_dev, struct uio *buf, int flag)
 
 			if (count < ev_size) {
 				/* No more data. Start playing now. */
-				s = splmidi();
-				sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
-				splx(s);
+				mtx_lock(&sd->flagqueue_mtx);
+				if ((sd->flags & SEQ_F_WRITING) == 0)
+					sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
+				mtx_unlock(&sd->flagqueue_mtx);
 
+				MIDI_PARTIAL_PICKUP_GIANT();
 				return (0);
 			}
+#if defined(MIDI_OUTOFGIANT)
+			mtx_lock(&Giant);
+#endif /* MIDI_OUTOFGIANT */
 			if (uiomove((caddr_t)&event[4], 4, buf))
 				printf("seq_write: user memory mangled?\n");
+#if defined(MIDI_OUTOFGIANT)
+			mtx_unlock(&Giant);
+#endif /* MIDI_OUTOFGIANT */
 		} else {
 
 			/* Not an extended event. The size is four bytes. */
 #if notyet
 			if (scp->seq_mode == SEQ_2) {
+				MIDI_PARTIAL_PICKUP_GIANT();
 				printf("seq%d: four byte event in level two mode.\n", unit);
 				return (EINVAL);
 			}
@@ -502,40 +568,47 @@ seq_write(dev_t i_dev, struct uio *buf, int flag)
 		if (ev_code == SEQ_MIDIPUTC) {
 			/* An event passed to the midi device itself. */
 			midiunit = event[2];
-			if (midiunit < 0 || midiunit >= mididev_info_number())
-				return (ENXIO);
-			md = get_mididev_info_unit(midiunit);
-			if (!MIDICONFED(md))
-				return (ENXIO);
-			if ((md->flags & MIDI_F_BUSY) == 0
-			    && (ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc)) != 0) {
-				seq_reset(scp);
+			mtx_lock(&sd->flagqueue_mtx);
+			ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+			mtx_unlock(&sd->flagqueue_mtx);
+			if (ret != 0) {
+				MIDI_PARTIAL_PICKUP_GIANT();
 				return (ret);
 			}
 		}
 
 		/*DEB(printf("seq_write: queueing event %d.\n", event[0]));*/
 		/* Now we queue the event. */
+		mtx_lock(&sd->flagqueue_mtx);
 		switch (seq_queue(scp, event)) {
 		case EAGAIN:
-			s = splmidi();
 			/* The queue is full. Start playing now. */
-			sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
-			splx(s);
+			if ((sd->flags & SEQ_F_WRITING) == 0)
+				sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
+			mtx_unlock(&sd->flagqueue_mtx);
+			MIDI_PARTIAL_PICKUP_GIANT();
 			return (0);
 		case EINTR:
+			mtx_unlock(&sd->flagqueue_mtx);
+			MIDI_PARTIAL_PICKUP_GIANT();
 			return (EINTR);
 		case ERESTART:
+			mtx_unlock(&sd->flagqueue_mtx);
+			MIDI_PARTIAL_PICKUP_GIANT();
 			return (ERESTART);
 		}
+		mtx_unlock(&sd->flagqueue_mtx);
 		p += ev_size;
 		count -= ev_size;
 	}
 
 	/* We have written every single data. Start playing now. */
-	s = splmidi();
-	sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
-	splx(s);
+	mtx_lock(&sd->flagqueue_mtx);
+	if ((sd->flags & SEQ_F_WRITING) == 0)
+		sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
+	mtx_unlock(&sd->flagqueue_mtx);
+
+	MIDI_PICKUP_GIANT();
 
 	return (0);
 }
@@ -543,7 +616,7 @@ seq_write(dev_t i_dev, struct uio *buf, int flag)
 int
 seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 {
-	int unit, midiunit, ret, tmp, s, arg2;
+	int unit, midiunit, ret, tmp, arg2;
 	sc_p scp;
 	seqdev_info *sd;
 	mididev_info *md;
@@ -569,6 +642,8 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 	}
 	scp = sd->softc;
 
+	MIDI_DROP_GIANT_NOSWITCH();
+
 	ret = 0;
 
 	switch (cmd) {
@@ -582,10 +657,14 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 
 	case AIOSSIZE:     /* set the current blocksize */
 		sndsize = (struct snd_size *)arg;
+		mtx_lock(&sd->flagqueue_mtx);
 		if (sndsize->play_size <= sd->midi_dbuf_out.unit_size && sndsize->rec_size <= sd->midi_dbuf_in.unit_size) {
-			sd->flags &= ~MIDI_F_HAS_SIZE;
 			sd->midi_dbuf_out.blocksize = sd->midi_dbuf_out.unit_size;
 			sd->midi_dbuf_in.blocksize = sd->midi_dbuf_in.unit_size;
+			sndsize->play_size = sd->midi_dbuf_out.blocksize;
+			sndsize->rec_size = sd->midi_dbuf_in.blocksize;
+			sd->flags &= ~MIDI_F_HAS_SIZE;
+			mtx_unlock(&sd->flagqueue_mtx);
 		}
 		else {
 			if (sndsize->play_size > sd->midi_dbuf_out.bufsize / 4)
@@ -599,53 +678,59 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 			sd->midi_dbuf_in.blocksize =
 			    ((sndsize->rec_size + sd->midi_dbuf_in.unit_size - 1)
 			     / sd->midi_dbuf_in.unit_size) * sd->midi_dbuf_in.unit_size;
+			sndsize->play_size = sd->midi_dbuf_out.blocksize;
+			sndsize->rec_size = sd->midi_dbuf_in.blocksize;
 			sd->flags |= MIDI_F_HAS_SIZE;
-		}
-		/* FALLTHROUGH */
+			mtx_unlock(&sd->flagqueue_mtx);
+		}	
+
+		ret = 0;
+		break;
+
 	case AIOGSIZE:	/* get the current blocksize */
 		sndsize = (struct snd_size *)arg;
+		mtx_lock(&sd->flagqueue_mtx);
 		sndsize->play_size = sd->midi_dbuf_out.blocksize;
 		sndsize->rec_size = sd->midi_dbuf_in.blocksize;
+		mtx_unlock(&sd->flagqueue_mtx);
 
 		ret = 0;
 		break;
 
 	case AIOSTOP:
 		if (*(int *)arg == AIOSYNC_PLAY) {
-			s = splmidi();
 
 			/* Stop writing. */
+			mtx_lock(&sd->flagqueue_mtx);
 			sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_WR);
+			mtx_unlock(&sd->flagqueue_mtx);
 
 			/* Pass the ioctl to the midi devices. */
-			for (midiunit = 0 ; midiunit < mididev_info_number() ; midiunit++) {
-				md = get_mididev_info_unit(midiunit);
-				if (MIDICONFED(md) && scp->midi_open[midiunit] && (md->flags & MIDI_F_WRITING) != 0) {
+			TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
+				if ((md->flags & MIDI_F_WRITING) != 0) {
 					arg2 = *(int *)arg;
-					midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, p);
+					midi_ioctl(MIDIMKDEV(major(i_dev), md->unit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, p);
 				}
 			}
 
 			*(int *)arg = sd->midi_dbuf_out.rl;
-			splx(s);
 		}
 		else if (*(int *)arg == AIOSYNC_CAPTURE) {
-			s = splmidi();
 
 			/* Stop reading. */
+			mtx_lock(&sd->flagqueue_mtx);
 			sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_RD);
+			mtx_unlock(&sd->flagqueue_mtx);
 
 			/* Pass the ioctl to the midi devices. */
-			for (midiunit = 0 ; midiunit < mididev_info_number() ; midiunit++) {
-				md = get_mididev_info_unit(midiunit);
-				if (MIDICONFED(md) && scp->midi_open[midiunit] && (md->flags & MIDI_F_WRITING) != 0) {
+			TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
+				if ((md->flags & MIDI_F_WRITING) != 0) {
 					arg2 = *(int *)arg;
-					midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, p);
+					midi_ioctl(MIDIMKDEV(major(i_dev), md->unit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, p);
 				}
 			}
 
 			*(int *)arg = sd->midi_dbuf_in.rl;
-			splx(s);
 		}
 
 		ret = 0;
@@ -692,7 +777,9 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 		ret = 0;
 		break;
 	case SNDCTL_SEQ_PANIC:
+		mtx_lock(&scp->devinfo->flagqueue_mtx);
 		seq_panic(scp);
+		mtx_unlock(&scp->devinfo->flagqueue_mtx);
 		ret = 0;
 		break;
 	case SNDCTL_SEQ_SYNC:
@@ -700,24 +787,21 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 			ret = 0;
 			break;
 		}
+		mtx_lock(&scp->devinfo->flagqueue_mtx);
 		ret = seq_sync(scp);
+		mtx_unlock(&scp->devinfo->flagqueue_mtx);
 		break;
 	case SNDCTL_SEQ_RESET:
+		mtx_lock(&scp->devinfo->flagqueue_mtx);
 		seq_reset(scp);
+		mtx_unlock(&scp->devinfo->flagqueue_mtx);
 		ret = 0;
 		break;
 	case SNDCTL_SEQ_TESTMIDI:
 		midiunit = *(int *)arg;
-		if (midiunit >= mididev_info_number()) {
-			ret = ENXIO;
-			break;
-		}
-		md = get_mididev_info_unit(midiunit);
-		if (MIDICONFED(md) && !scp->midi_open[midiunit]) {
-			ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
-			break;
-		}
-		ret = 0;
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
 		break;
 	case SNDCTL_SEQ_GETINCOUNT:
 		if (mode == O_WRONLY)
@@ -749,21 +833,11 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 		break;
 	case SNDCTL_SEQ_RESETSAMPLES:
 		midiunit = *(int *)arg;
-		if (midiunit >= mididev_info_number()) {
-			ret = ENXIO;
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (ret != 0)
 			break;
-		}
-		if (!scp->midi_open[midiunit]) {
-			md = get_mididev_info_unit(midiunit);
-			if (MIDICONFED(md)) {
-				ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
-				if (ret != 0)
-					break;
-			} else {
-				ret = EBUSY;
-				break;
-			}
-		}
 		ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p);
 		break;
 	case SNDCTL_SEQ_NRSYNTHS:
@@ -776,97 +850,66 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 		break;
 	case SNDCTL_SYNTH_MEMAVL:
 		midiunit = *(int *)arg;
-		if (midiunit >= mididev_info_number()) {
-			ret = ENXIO;
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (ret != 0)
 			break;
-		}
-		if (!scp->midi_open[midiunit]) {
-			md = get_mididev_info_unit(midiunit);
-			if (MIDICONFED(md)) {
-				ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
-				if (ret != 0)
-					break;
-			} else {
-				ret = EBUSY;
-				break;
-			}
-		}
 		ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p);
 		break;
 	case SNDCTL_FM_4OP_ENABLE:
 		midiunit = *(int *)arg;
-		if (midiunit >= mididev_info_number()) {
-			ret = ENXIO;
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (ret != 0)
 			break;
-		}
-		if (!scp->midi_open[midiunit]) {
-			md = get_mididev_info_unit(midiunit);
-			if (MIDICONFED(md)) {
-				ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
-				if (ret != 0)
-					break;
-			} else {
-				ret = EBUSY;
-				break;
-			}
-		}
 		ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p);
 		break;
 	case SNDCTL_SYNTH_INFO:
 		synthinfo = (struct synth_info *)arg;
 		midiunit = synthinfo->device;
-		if (midiunit >= mididev_info_number()) {
-			ret = ENXIO;
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (ret != 0)
 			break;
-		}
 		ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p);
 		break;
 	case SNDCTL_SEQ_OUTOFBAND:
 		event = (struct seq_event_rec *)arg;
-		s = splmidi();
+		mtx_lock(&sd->flagqueue_mtx);
 		ret = seq_playevent(scp, event->arr);
-		splx(s);
+		mtx_unlock(&sd->flagqueue_mtx);
 		break;
 	case SNDCTL_MIDI_INFO:
 		midiinfo = (struct midi_info *)arg;
 		midiunit = midiinfo->device;
-		if (midiunit >= mididev_info_number()) {
-			ret = ENXIO;
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (ret != 0)
 			break;
-		}
 		ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p);
 		break;
 	case SNDCTL_PMGR_IFACE:
 		patinfo = (struct patmgr_info *)arg;
 		midiunit = patinfo->device;
-		if (midiunit >= mididev_info_number()) {
-			ret = ENXIO;
-			break;
-		}
-		if (!scp->midi_open[midiunit]) {
-			ret = EBUSY;
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (ret != 0)
 			break;
-		}
 		ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p);
 		break;
 	case SNDCTL_PMGR_ACCESS:
 		patinfo = (struct patmgr_info *)arg;
 		midiunit = patinfo->device;
-		if (midiunit >= mididev_info_number()) {
-			ret = ENXIO;
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (ret != 0)
 			break;
-		}
-		if (!scp->midi_open[midiunit]) {
-			md = get_mididev_info_unit(midiunit);
-			if (MIDICONFED(md)) {
-				ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
-				if (ret != 0)
-					break;
-			} else {
-				ret = EBUSY;
-				break;
-			}
-		}
 		ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p);
 		break;
 	case SNDCTL_SEQ_THRESHOLD:
@@ -888,28 +931,24 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
 			ret = EIO;
 			break;
 		}
-		if (!scp->midi_open[0]) {
-			md = get_mididev_info_unit(0);
-			if (MIDICONFED(md)) {
-				ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
-				if (ret != 0)
-					break;
-			} else {
-				ret = EBUSY;
-				break;
-			}
-		}
+		mtx_lock(&sd->flagqueue_mtx);
+		ret = lookup_mididev(scp, 0, LOOKUP_OPEN, &md);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (ret != 0)
+			break;
 		ret = midi_ioctl(MIDIMKDEV(major(i_dev), 0, SND_DEV_MIDIN), cmd, arg, mode, p);
 		break;
 	}
 
+	MIDI_PICKUP_GIANT();
+
 	return (ret);
 }
 
 int
 seq_poll(dev_t i_dev, int events, struct proc *p)
 {
-	int unit, ret, s, lim;
+	int unit, ret, lim;
 	sc_p scp;
 	seqdev_info *sd;
 
@@ -928,8 +967,11 @@ seq_poll(dev_t i_dev, int events, struct proc *p)
 	}
 	scp = sd->softc;
 
+	MIDI_DROP_GIANT_NOSWITCH();
+
+	mtx_lock(&sd->flagqueue_mtx);
+
 	ret = 0;
-	s = splmidi();
 
 	/* Look up the apropriate queue and select it. */
 	if ((events & (POLLOUT | POLLWRNORM)) != 0) {
@@ -964,7 +1006,10 @@ seq_poll(dev_t i_dev, int events, struct proc *p)
 			/* We can write now. */
 			ret |= events & (POLLIN | POLLRDNORM);
 	}
-	splx(s);
+
+	mtx_unlock(&sd->flagqueue_mtx);
+
+	MIDI_PICKUP_GIANT();
 
 	return (ret);
 }
@@ -978,12 +1023,20 @@ seq_intr(void *p, mididev_info *md)
 	sd = (seqdev_info *)p;
 	scp = sd->softc;
 
+	MIDI_DROP_GIANT_NOSWITCH();
+
+	mtx_lock(&sd->flagqueue_mtx);
+
 	/* Restart playing if we have the data to output. */
 	if (scp->queueout_pending)
 		sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
 	/* Check the midi device if we are reading. */
 	if ((sd->flags & SEQ_F_READING) != 0)
 		seq_midiinput(scp, md);
+
+	mtx_unlock(&sd->flagqueue_mtx);
+
+	MIDI_PICKUP_GIANT();
 }
 
 static int
@@ -1001,6 +1054,8 @@ seq_callback(seqdev_info *sd, int reason)
 	scp = sd->softc;
 	unit = sd->unit;
 
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
 	switch (reason & SEQ_CB_REASON_MASK) {
 	case SEQ_CB_START:
 		if ((reason & SEQ_CB_RD) != 0 && (sd->flags & SEQ_F_READING) == 0)
@@ -1013,24 +1068,21 @@ seq_callback(seqdev_info *sd, int reason)
 	case SEQ_CB_STOP:
 	case SEQ_CB_ABORT:
 		if ((reason & SEQ_CB_RD) != 0 && (sd->flags & SEQ_F_READING) != 0) {
-			/* Stop the timer. */
-			scp->seq_time = seq_gettime();
-			scp->prev_input_time = 0;
-
 			/* Stop recording. */
 			sd->flags &= ~SEQ_F_READING;
+			scp->seq_time = seq_gettime();
+			scp->prev_input_time = 0;
 		}
 		if ((reason & SEQ_CB_WR) != 0 && (sd->flags & SEQ_F_WRITING) != 0) {
-			/* Stop the timer. */
-			seq_stoptimer(scp);
-			scp->seq_time = seq_gettime();
-			scp->prev_event_time = 0;
-
 			/* Stop Playing. */
 			sd->flags &= ~SEQ_F_WRITING;
 			scp->queueout_pending = 0;
+			scp->seq_time = seq_gettime();
+			scp->prev_input_time = 0;
+
+			/* Stop the timer. */
+			seq_stoptimer(scp);
 		}
-		break;
 	}
 
 	return (0);
@@ -1043,49 +1095,52 @@ seq_callback(seqdev_info *sd, int reason)
 static int
 seq_queue(sc_p scp, u_char *note)
 {
-	int unit, err, s;
+	int unit, err;
 	seqdev_info *sd;
 
 	sd = scp->devinfo;
 	unit = sd->unit;
 
-	/*DEB(printf("seq%d: queueing.\n", unit));*/
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 
-	s = splmidi();
+	/*DEB(printf("seq%d: queueing.\n", unit));*/
 
-	/* Start playing if we have some data in the queue. */
-	if (sd->midi_dbuf_out.rl >= EV_SZ)
-		sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
+	if ((sd->flags & SEQ_F_INSYNC) != 0) {
+		cv_wait(&sd->insync_cv, &sd->flagqueue_mtx);
+		cv_signal(&sd->insync_cv);
+	}
 
 	if (sd->midi_dbuf_out.fl < EV_SZ) {
 		/* We have no space. Start playing if not yet. */
-		sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
-		if ((sd->flags & SEQ_F_NBIO) != 0 && sd->midi_dbuf_out.fl < EV_SZ) {
+		if ((sd->flags & SEQ_F_WRITING) == 0)
+			sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
+		if ((sd->flags & SEQ_F_NBIO) != 0 && sd->midi_dbuf_out.fl < EV_SZ)
 			/* We would block. */
-			splx(s);
 			return (EAGAIN);
-		} else
+		else {
 			while (sd->midi_dbuf_out.fl < EV_SZ) {
 				/* We have no space. Good night. */
-				err = tsleep(&sd->midi_dbuf_out.tsleep_out, PRIBIO | PCATCH, "seqque", 0);
-				if (err == EINTR)
-					sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR);
+				err = msleep(&sd->midi_dbuf_out.tsleep_out, &sd->flagqueue_mtx, PRIBIO | PCATCH, "seqque", 0);
 				if (err == EINTR || err == ERESTART) {
-					splx(s);
+					if (err == EINTR)
+						sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR);
 					return (err);
 				}
 			}
+		}
 	}
 
 	/* We now have enough space to write. */
-	err = midibuf_seqwrite(&sd->midi_dbuf_out, note, EV_SZ);
-
-	splx(s);
+	err = midibuf_seqwrite(&sd->midi_dbuf_out, note, EV_SZ, &sd->flagqueue_mtx);
 
 	if (err < 0)
 		err = -err;
-	else
+	else {
 		err = 0;
+		/* Start playing if we have some data in the queue. */
+		if (sd->midi_dbuf_out.rl >= EV_SZ && ((sd->flags & SEQ_F_WRITING) == 0))
+			sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
+	}
 
 	return (err);
 }
@@ -1100,26 +1155,21 @@ seq_startplay(sc_p scp)
 	sd = scp->devinfo;
 	unit = sd->unit;
 
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
 	/* Dequeue the events to play. */
 	while (sd->midi_dbuf_out.rl >= EV_SZ) {
 
-		/* We are playing now. */
-		sd->flags |= SEQ_F_WRITING;
-
-		/* We only copy the event, not dequeue. */
-		midibuf_seqcopy(&sd->midi_dbuf_out, event, EV_SZ);
+		midibuf_seqread(&sd->midi_dbuf_out, event, EV_SZ, &sd->flagqueue_mtx);
 
 		switch (seq_playevent(scp, event)) {
 		case TIMERARMED:
-			/* Dequeue the event. */
-			midibuf_seqread(&sd->midi_dbuf_out, event, EV_SZ);
-			/* FALLTHRU */
+			return;
 		case QUEUEFULL:
-			/* We cannot play further. */
+			/* We cannot play any further. */
+			midibuf_sequnread(&sd->midi_dbuf_out, event, EV_SZ, &sd->flagqueue_mtx);
 			return;
 		case MORE:
-			/* Dequeue the event. */
-			midibuf_seqread(&sd->midi_dbuf_out, event, EV_SZ);
 			break;
 		}
 	}
@@ -1139,26 +1189,31 @@ seq_playevent(sc_p scp, u_char *event)
 	sd = scp->devinfo;
 	unit = sd->unit;
 
-	md = get_mididev_info_unit(0);
-	if (!MIDICONFED(md))
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
+	ret = lookup_mididev(scp, 0, LOOKUP_OPEN, &md);
+	if (ret != 0)
 		return (MORE);
 
 	switch(event[0]) {
 	case SEQ_NOTEOFF:
-		if ((md->flags & MIDI_F_BUSY) != 0 || seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) == 0)
-			if (md->synth.killnote(md, event[1], 255, event[3]) == EAGAIN) {
-				ret = QUEUEFULL;
-				break;
-			}
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.killnote(md, event[1], 255, event[3]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
+			ret = QUEUEFULL;
+			break;
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		ret = MORE;
 		break;
 	case SEQ_NOTEON:
-		if (((md->flags & MIDI_F_BUSY) != 0 || seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) == 0)
-		    && (event[4] < 128 || event[4] == 255))
-			if (md->synth.startnote(md, event[1], event[2], event[3]) == EAGAIN) {
-				ret = QUEUEFULL;
-				break;
-			}
+		mtx_unlock(&sd->flagqueue_mtx);
+		if ((event[4] < 128 || event[4] == 255) && md->synth.startnote(md, event[1], event[2], event[3]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
+			ret = QUEUEFULL;
+			break;
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		ret = MORE;
 		break;
 	case SEQ_WAIT:
@@ -1169,7 +1224,6 @@ seq_playevent(sc_p scp, u_char *event)
 		if (*delay > 0) {
 			/* Arm the timer. */
 			sd->flags |= SEQ_F_WRITING;
-			scp->prev_event_time = *delay;
 			if (seq_requesttimer(scp, *delay)) {
 				ret = TIMERARMED;
 				break;
@@ -1178,11 +1232,13 @@ seq_playevent(sc_p scp, u_char *event)
 		ret = MORE;
 		break;
 	case SEQ_PGMCHANGE:
-		if ((md->flags & MIDI_F_BUSY) != 0 || seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) == 0)
-			if (md->synth.setinstr(md, event[1], event[2]) == EAGAIN) {
-				ret = QUEUEFULL;
-				break;
-			}
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.setinstr(md, event[1], event[2]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
+			ret = QUEUEFULL;
+			break;
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		ret = MORE;
 		break;
 	case SEQ_SYNCTIMER:
@@ -1195,16 +1251,19 @@ seq_playevent(sc_p scp, u_char *event)
 		break;
 	case SEQ_MIDIPUTC:
 		/* Pass through to the midi device. */
-		if (event[2] < mididev_info_number()) {
-			md = get_mididev_info_unit(event[2]);
-			if (MIDICONFED(md) && ((md->flags & MIDI_F_BUSY) != 0 || seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) == 0)) {
-				if (md->synth.writeraw(md, &event[1], sizeof(event[1]), 1) == EAGAIN) {
-					/* The queue was full. Try again later. */
-					ret = QUEUEFULL;
-					break;
-				}
-			}
+		ret = lookup_mididev(scp, event[2], LOOKUP_OPEN, &md);
+		if (ret != 0) {
+			ret = MORE;
+			break;
 		}
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.writeraw(md, &event[1], sizeof(event[1]), 1) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
+			/* The queue was full. Try again later. */
+			ret = QUEUEFULL;
+			break;
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		ret = MORE;
 		break;
 	case SEQ_ECHO:
@@ -1216,13 +1275,18 @@ seq_playevent(sc_p scp, u_char *event)
 		ret = MORE;
 		break;
 	case SEQ_PRIVATE:
-		if (event[1] < mididev_info_number()) {
-			md = get_mididev_info_unit(event[1]);
-			if (MIDICONFED(md) && md->synth.hwcontrol(md, event) == EAGAIN) {
-				ret = QUEUEFULL;
-				break;
-			}
+		ret = lookup_mididev(scp, event[1], LOOKUP_OPEN, &md);
+		if (ret != 0) {
+			ret = MORE;
+			break;
 		}
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.hwcontrol(md, event) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
+			ret = QUEUEFULL;
+			break;
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		ret = MORE;
 		break;
 	case SEQ_EXTENDED:
@@ -1282,15 +1346,20 @@ seq_requesttimer(sc_p scp, int delay)
 
 	/*DEB(printf("seq%d: requested timer at delay of %d.\n", unit, delay));*/
 
+	mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
+
 	cur_time = seq_gettime();
 
+	scp->prev_event_time = delay;
 	if (delay < 0)
 		/* Request a new timer. */
 		delay = -delay;
 	else {
 		rel_base = cur_time - scp->seq_time;
-		if (delay <= rel_base)
+		if (delay <= rel_base) {
+			seq_stoptimer(scp);
 			return 0;
+		}
 		delay -= rel_base;
 	}
 
@@ -1309,8 +1378,9 @@ seq_requesttimer(sc_p scp, int delay)
 	}
 #endif /* notdef */
 
-	scp->timeout_ch = timeout(seq_timer, (void *)scp, delay);
+	callout_reset(&scp->timeout_ch, delay, seq_timer, (void *)scp);
 	scp->timer_running = 1;
+
 	return 1;
 }
 
@@ -1319,8 +1389,10 @@ seq_stoptimer(sc_p scp)
 {
 	/*DEB(printf("seq%d: stopping timer.\n", unit));*/
 
+	mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
+
 	if (scp->timer_running) {
-		untimeout(seq_timer, (void *)scp, scp->timeout_ch);
+		callout_stop(&scp->timeout_ch);
 		scp->timer_running = 0;
 	}
 }
@@ -1333,14 +1405,17 @@ seq_midiinput(sc_p scp, mididev_info *md)
 	u_char event[4];
 	seqdev_info *sd;
 
+	mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
+
 	sd = scp->devinfo;
 	unit = sd->unit;
 
 	/* Can this midi device interrupt for input? */
 	midiunit = md->unit;
-	if (scp->midi_open[midiunit]
-	    && (md->flags & MIDI_F_READING) != 0
-	    && md->intrarg == sd)
+	if (lookup_mididev(scp, midiunit, LOOKUP_EXIST, NULL) != 0)
+		return;
+
+	if ((md->flags & MIDI_F_READING) != 0 && md->intrarg == sd) {
 		/* Read the input data. */
 		while (md->synth.readraw(md, &event[1], sizeof(event[1]), 1) == 0) {
 			tstamp = seq_gettime() - scp->seq_time;
@@ -1355,6 +1430,7 @@ seq_midiinput(sc_p scp, mididev_info *md)
 			event[3] = 0;
 			seq_copytoinput(scp, event, sizeof(event));
 		}
+	}
 }
 
 static int
@@ -1364,6 +1440,8 @@ seq_copytoinput(sc_p scp, u_char *event, int len)
 
 	sd = scp->devinfo;
 
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
 	if (midibuf_input_intr(&sd->midi_dbuf_in, event, len) == -EAGAIN)
 		return (EAGAIN);
 
@@ -1380,42 +1458,67 @@ seq_extended(sc_p scp, u_char *event)
 	sd = scp->devinfo;
 	unit = sd->unit;
 
-	if (event[2] >= mididev_info_number())
-		return (MORE);
-	md = get_mididev_info_unit(event[2]);
-	if (!MIDICONFED(md) && (md->flags & MIDI_F_BUSY) == 0 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0)
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
+	if (lookup_mididev(scp, event[2], LOOKUP_OPEN, &md) != 0)
 		return (MORE);
 
 	switch (event[1]) {
 	case SEQ_NOTEOFF:
-		if (md->synth.killnote(md, event[3], event[4], event[5]) == EAGAIN)
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.killnote(md, event[3], event[4], event[5]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
 			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	case SEQ_NOTEON:
-		if (event[4] < 128 || event[4] == 255)
-			if (md->synth.startnote(md, event[3], event[4], event[5]) == EAGAIN)
-				return (QUEUEFULL);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if ((event[4] < 128 || event[4] == 255) && md->synth.startnote(md, event[3], event[4], event[5]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
+			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	case SEQ_PGMCHANGE:
-		if (md->synth.setinstr(md, event[3], event[4]) == EAGAIN)
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.setinstr(md, event[3], event[4]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
 			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	case SEQ_AFTERTOUCH:
-		if (md->synth.aftertouch(md, event[3], event[4]) == EAGAIN)
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.aftertouch(md, event[3], event[4]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
 			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	case SEQ_BALANCE:
-		if (md->synth.panning(md, event[3], (char)event[4]) == EAGAIN)
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.panning(md, event[3], (char)event[4]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
 			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	case SEQ_CONTROLLER:
-		if (md->synth.controller(md, event[3], event[4], *(short *)&event[5]) == EAGAIN)
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.controller(md, event[3], event[4], *(short *)&event[5]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
 			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	case SEQ_VOLMODE:
-		if (md->synth.volumemethod != NULL)
-			if (md->synth.volumemethod(md, event[3]) == EAGAIN)
-				return (QUEUEFULL);
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.volumemethod != NULL && md->synth.volumemethod(md, event[3]) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
+			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	}
 
@@ -1439,17 +1542,14 @@ seq_chnvoice(sc_p scp, u_char *event)
 
 	sd = scp->devinfo;
 
-	if (dev >= mididev_info_number())
-		return (MORE);
-	md = get_mididev_info_unit(dev);
-	if (!MIDICONFED(md) && (md->flags & MIDI_F_BUSY) == 0 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0)
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
+	if (lookup_mididev(scp, dev, LOOKUP_OPEN, &md) != 0)
 		return (MORE);
 
 #if notyet
-	if (scp->seq_mode == SEQ_2) {
-		if (md->synth.allocvoice)
-			voice = seq_allocvoice(md, chn, note);
-	}
+	if (scp->seq_mode == SEQ_2 && md->synth.allocvoice != NULL)
+		voice = seq_allocvoice(scp, md, chn, note);
 #endif /* notyet */
 	switch (cmd) {
 	case MIDI_NOTEON:
@@ -1457,38 +1557,60 @@ seq_chnvoice(sc_p scp, u_char *event)
 #if notyet
 			if (voice == -1 && scp->seq_mode == SEQ_2 && md->synth.allocvoice)
 				/* This is an internal synthesizer. (FM, GUS, etc) */
-				if ((voice = seq_allocvoice(md, chn, note)) == -EAGAIN)
+				if ((voice = seq_allocvoice(scp, md, chn, note)) == -EAGAIN)
 					return (QUEUEFULL);
 #endif /* notyet */
 			if (voice == -1)
 				voice = chn;
 
 #if notyet
-			if (scp->seq_mode == SEQ_2 && dev < mididev_info_number() && chn == 9) {
+			if (scp->seq_mode == SEQ_2 && chn == 9) {
 				/* This channel is a percussion. The note number is the patch number. */
-				if (md->synth.setinstr(md, voice, 128 + note) == EAGAIN)
+				mtx_unlock(&sd->flagqueue_mtx);
+				if (md->synth.setinstr(md, voice, 128 + note) == EAGAIN) {
+					mtx_lock(&sd->flagqueue_mtx);
 					return (QUEUEFULL);
+				}
+				mtx_lock(&sd->flagqueue_mtx);
+
 				note = 60; /* Middle C. */
 			}
-			if (scp->seq_mode == SEQ_2)
-				if (md->synth.setupvoice(md, voice, chn) == EAGAIN)
+			if (scp->seq_mode == SEQ_2) {
+				mtx_unlock(&sd->flagqueue_mtx);
+				if (md->synth.setupvoice(md, voice, chn) == EAGAIN) {
+					mtx_lock(&sd->flagqueue_mtx);
 					return (QUEUEFULL);
+				}
+				mtx_lock(&sd->flagqueue_mtx);
+			}
 #endif /* notyet */
-			if (md->synth.startnote(md, voice, note, parm) == EAGAIN)
+			mtx_unlock(&sd->flagqueue_mtx);
+			if (md->synth.startnote(md, voice, note, parm) == EAGAIN) {
+				mtx_lock(&sd->flagqueue_mtx);
 				return (QUEUEFULL);
+			}
+			mtx_lock(&sd->flagqueue_mtx);
 		}
 		break;
 	case MIDI_NOTEOFF:
 		if (voice == -1)
 			voice = chn;
-		if (md->synth.killnote(md, voice, note, parm) == EAGAIN)
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.killnote(md, voice, note, parm) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
 			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	case MIDI_KEY_PRESSURE:
 		if (voice == -1)
 			voice = chn;
-		if (md->synth.aftertouch(md, voice, parm) == EAGAIN)
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.aftertouch(md, voice, parm) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
 			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
 		break;
 	}
 
@@ -1503,25 +1625,38 @@ seq_findvoice(mididev_info *md, int chn, int note)
 
 	key = (chn << 8) | (note + 1);
 
+	mtx_lock(&md->synth.vc_mtx);
 	for (i = 0 ; i < md->synth.alloc.max_voice ; i++)
-		if (md->synth.alloc.map[i] == key)
+		if (md->synth.alloc.map[i] == key) {
+			mtx_unlock(&md->synth.vc_mtx);
 			return (i);
+		}
+	mtx_unlock(&md->synth.vc_mtx);
 
 	return (-1);
 }
 
 static int
-seq_allocvoice(mididev_info *md, int chn, int note)
+seq_allocvoice(sc_p scp, mididev_info *md, int chn, int note)
 {
 	int voice;
 	u_short key;
 
+	mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
+
 	key = (chn << 8) | (note + 1);
 
-	if ((voice = md->synth.allocvoice(md, chn, note, &md->synth.alloc)) == -EAGAIN)
+	mtx_unlock(&scp->devinfo->flagqueue_mtx);
+	if ((voice = md->synth.allocvoice(md, chn, note, &md->synth.alloc)) == -EAGAIN) {
+		mtx_lock(&scp->devinfo->flagqueue_mtx);
 		return (-EAGAIN);
+	}
+	mtx_lock(&scp->devinfo->flagqueue_mtx);
+
+	mtx_lock(&md->synth.vc_mtx);
 	md->synth.alloc.map[voice] = key;
 	md->synth.alloc.alloc_times[voice] = md->synth.alloc.timestamp++;
+	mtx_unlock(&md->synth.vc_mtx);
 
 	return (voice);
 }
@@ -1544,77 +1679,113 @@ seq_chncommon(sc_p scp, u_char *event)
 	sd = scp->devinfo;
 	unit = sd->unit;
 
-	if (dev >= mididev_info_number())
-		return (MORE);
-	md = get_mididev_info_unit(dev);
-	if (!MIDICONFED(md) && (md->flags & MIDI_F_BUSY) == 0 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0)
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
+	if (lookup_mididev(scp, dev, LOOKUP_OPEN, &md) != 0)
 		return (MORE);
 
 	switch (cmd) {
 	case MIDI_PGM_CHANGE:
 #if notyet
 		if (scp->seq_mode == SEQ_2) {
+			mtx_lock(&md->synth.vc_mtx);
 			md->synth.chn_info[chn].pgm_num = p1;
-			if (dev < mididev_info_number())
-				if (md->synth.setinstr(md, chn, p1) == EAGAIN)
-					return (QUEUEFULL);
-		} else
+			mtx_unlock(&md->synth.vc_mtx);
+			mtx_unlock(&sd->flagqueue_mtx);
+			if (md->synth.setinstr(md, chn, p1) == EAGAIN) {
+				mtx_lock(&sd->flagqueue_mtx);
+				return (QUEUEFULL);
+			}
+			mtx_lock(&sd->flagqueue_mtx);
+		} else {
 #endif /* notyet */
 			/* For Mode 1. */
-			if (md->synth.setinstr(md, chn, p1) == EAGAIN)
+			mtx_unlock(&sd->flagqueue_mtx);
+			if (md->synth.setinstr(md, chn, p1) == EAGAIN) {	
+				mtx_lock(&sd->flagqueue_mtx);
 				return (QUEUEFULL);
+			}
+			mtx_lock(&sd->flagqueue_mtx);
+#if notyet
+		}
+#endif /* notyet */
 		break;
 	case MIDI_CTL_CHANGE:
+		/* mtx_lock(&md->giant); */
 #if notyet
 		if (scp->seq_mode == SEQ_2) {
 			if (chn < 16 && p1 < 128) {
+				mtx_lock(&md->synth.vc_mtx);
 				md->synth.chn_info[chn].controllers[p1] = w14 & 0x7f;
 				if (p1 < 32)
 					/* We have set the MSB, clear the LSB. */
 					md->synth.chn_info[chn].controllers[p1 + 32] = 0;
-				if (dev < mididev_info_number()) {
-					val = w14 & 0x7f;
-					if (p1 < 64) {
-						/* Combine the MSB and the LSB. */
-						val = ((md->synth.chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
-						    | (md->synth.chn_info[chn].controllers[p1 | 32] & 0x7f);
-						p1 &= ~32;
+				val = w14 & 0x7f;
+				if (p1 < 64) {
+					/* Combine the MSB and the LSB. */
+					val = ((md->synth.chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
+					    | (md->synth.chn_info[chn].controllers[p1 | 32] & 0x7f);
+					p1 &= ~32;
+				}
+				/* Handle all of the notes playing on this channel. */
+				key = ((int)chn << 8);
+				for (i = 0 ; i < md->synth.alloc.max_voice ; i++)
+					if ((md->synth.alloc.map[i] & 0xff00) == key) {
+						mtx_unlock(&md->synth.vc_mtx);
+						mtx_unlock(&sd->flagqueue_mtx);
+						if (md->synth.controller(md, i, p1, val) == EAGAIN) {
+							mtx_lock(&sd->flagqueue_mtx);
+							return (QUEUEFULL);
+						}
+						mtx_lock(&sd->flagqueue_mtx);
+						mtx_lock(&md->synth.vc_mtx);
 					}
-					/* Handle all of the notes playing on this channel. */
-					key = ((int)chn << 8);
-					for (i = 0 ; i < md->synth.alloc.max_voice ; i++)
-						if ((md->synth.alloc.map[i] & 0xff00) == key)
-							if (md->synth.controller(md, i, p1, val) == EAGAIN)
-								return (QUEUEFULL);
-				} else
-					if (md->synth.controller(md, chn, p1, w14) == EAGAIN)
-						return (QUEUEFULL);
+				mtx_unlock(&md->synth.vc_mtx);
 			}
-		} else
+		} else {
 #endif /* notyet */
 			/* For Mode 1. */
-			if (md->synth.controller(md, chn, p1, w14) == EAGAIN)
+			mtx_unlock(&sd->flagqueue_mtx);
+			if (md->synth.controller(md, chn, p1, w14) == EAGAIN) {
+				mtx_lock(&sd->flagqueue_mtx);
 				return (QUEUEFULL);
+			}
+			mtx_lock(&sd->flagqueue_mtx);
+#if notyet
+		}
+#endif /* notyet */
 		break;
 	case MIDI_PITCH_BEND:
 #if notyet
 		if (scp->seq_mode == SEQ_2) {
+			mtx_lock(&md->synth.vc_mtx);
 			md->synth.chn_info[chn].bender_value = w14;
-			if (dev < mididev_info_number()) {
-				/* Handle all of the notes playing on this channel. */
-				key = ((int)chn << 8);
-				for (i = 0 ; i < md->synth.alloc.max_voice ; i++)
-					if ((md->synth.alloc.map[i] & 0xff00) == key)
-						if (md->synth.bender(md, i, w14) == EAGAIN)
-							return (QUEUEFULL);
-			} else
-				if (md->synth.bender(md, chn, w14) == EAGAIN)
-					return (QUEUEFULL);
-		} else
+			/* Handle all of the notes playing on this channel. */
+			key = ((int)chn << 8);
+			for (i = 0 ; i < md->synth.alloc.max_voice ; i++)
+				if ((md->synth.alloc.map[i] & 0xff00) == key) {
+					mtx_unlock(&md->synth.vc_mtx);
+					mtx_unlock(&sd->flagqueue_mtx);
+					if (md->synth.bender(md, i, w14) == EAGAIN) {
+						mtx_lock(&sd->flagqueue_mtx);
+						return (QUEUEFULL);
+					}
+					mtx_lock(&sd->flagqueue_mtx);
+					mtx_lock(&md->synth.vc_mtx);
+				}
+			mtx_unlock(&md->synth.vc_mtx);
+		} else {
 #endif /* notyet */
 			/* For Mode 1. */
-			if (md->synth.bender(md, chn, w14) == EAGAIN)
+			mtx_unlock(&sd->flagqueue_mtx);
+			if (md->synth.bender(md, chn, w14) == EAGAIN) {
+				mtx_lock(&sd->flagqueue_mtx);
 				return (QUEUEFULL);
+			}
+			mtx_lock(&sd->flagqueue_mtx);
+#if notyet
+		}
+#endif /* notyet */
 		break;
 	}
 
@@ -1631,6 +1802,8 @@ seq_timing(sc_p scp, u_char *event)
 	sd = scp->devinfo;
 	unit = sd->unit;
 
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
 	parm = *(long *)&event[4];
 
 #if notyet
@@ -1639,12 +1812,11 @@ seq_timing(sc_p scp, u_char *event)
 #endif /* notyet */
 	switch (event[1]) {
 	case TMR_WAIT_REL:
-		parm += scp->prev_event_time;
-		/* FALLTHRU */
 	case TMR_WAIT_ABS:
+		if (event[1] == TMR_WAIT_REL)
+			parm += scp->prev_event_time;
 		if (parm > 0) {
 			sd->flags |= SEQ_F_WRITING;
-			scp->prev_event_time = parm;
 			if (seq_requesttimer(scp, parm))
 				return (TIMERARMED);
 		}
@@ -1687,6 +1859,8 @@ seq_local(sc_p scp, u_char *event)
 	sd = scp->devinfo;
 	unit = sd->unit;
 
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
 	switch (event[1]) {
 	case LOCL_STARTAUDIO:
 #if notyet
@@ -1708,19 +1882,22 @@ seq_sysex(sc_p scp, u_char *event)
 	sd = scp->devinfo;
 	unit = sd->unit;
 
-	if (event[1] >= mididev_info_number())
-		return (MORE);
-	md = get_mididev_info_unit(event[1]);
-	if (!MIDICONFED(md) || md->synth.sendsysex == NULL
-	    || ((md->flags & MIDI_F_BUSY) == 0 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0))
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
+	if (lookup_mididev(scp, event[1], LOOKUP_OPEN, &md) != 0)
 		return (MORE);
 
 	l = 0;
 	for (i = 0 ; i < 6 && event[i + 2] != 0xff ; i++)
 		l = i + 1;
-	if (l > 0)
-		if (md->synth.sendsysex(md, &event[2], l) == EAGAIN)
+	if (l > 0) {
+		mtx_unlock(&sd->flagqueue_mtx);
+		if (md->synth.sendsysex(md, &event[2], l) == EAGAIN) {
+			mtx_lock(&sd->flagqueue_mtx);
 			return (QUEUEFULL);
+		}
+		mtx_lock(&sd->flagqueue_mtx);
+	}
 
 	return (MORE);
 }
@@ -1729,52 +1906,67 @@ static void
 seq_timer(void *arg)
 {
 	sc_p scp;
+	seqdev_info *sd;
 
 	scp = arg;
+	sd = scp->devinfo;
 
 	/*DEB(printf("seq_timer: timer fired.\n"));*/
 
 	/* Record the current timestamp. */
-	scp->prev_wakeup_time = seq_gettime();
+	mtx_lock(&sd->flagqueue_mtx);
 
+	scp->timer_running = 0;
+	scp->prev_wakeup_time = seq_gettime();
 	seq_startplay(scp);
+
+	mtx_unlock(&sd->flagqueue_mtx);
 }
 
 static int
 seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p)
 {
-	int midiunit, s, err;
+	int midiunit, err, insync;
+
+	mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 
-	if (md == NULL || !MIDICONFED(md)) {
-		DEB(printf("seq_openmidi: midi device does not exist.\n"));
-		return (ENXIO);
-	}
 	midiunit = md->unit;
 
 	DEB(printf("seq_openmidi: opening midi unit %d.\n", midiunit));
 
-	if (!scp->midi_open[midiunit]) {
-		err = midi_open(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, p);
-		if (err != 0) {
-			printf("seq_openmidi: failed to open midi device %d.\n", midiunit);
-			return (err);
-		}
-		s = splmidi();
-		scp->midi_open[midiunit] = 1;
-		md->intr = seq_intr;
-		md->intrarg = scp->devinfo;
-		md->synth.prev_out_status = 0;
-		md->synth.sysex_state = 0;
-		splx(s);
+	err = midi_open(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, p);
+	if (err != 0) {
+		printf("seq_openmidi: failed to open midi device %d.\n", midiunit);
+		return (err);
+	}
+	mtx_lock(&md->synth.status_mtx);
+	mtx_lock(&md->flagqueue_mtx);
+	md->intr = seq_intr;
+	md->intrarg = scp->devinfo;
+	mtx_unlock(&md->flagqueue_mtx);
+	md->synth.sysex_state = 0;
+	mtx_unlock(&md->synth.status_mtx);
+
+	insync = 0;
+	if ((scp->devinfo->flags & SEQ_F_INSYNC) != 0) {
+		insync = 1;
+		cv_wait(&scp->devinfo->insync_cv, &scp->devinfo->flagqueue_mtx);
 	}
 
+	TAILQ_INSERT_TAIL(&scp->midi_open, md, md_linkseq);
+
+	if (insync)
+		cv_signal(&scp->devinfo->insync_cv);
+
 	return (0);
 }
 
 static int
 seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p)
 {
-	int midiunit, s;
+	int midiunit, insync;
+
+	mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 
 	if (md == NULL || !MIDICONFED(md)) {
 		DEB(printf("seq_closemidi: midi device does not exist.\n"));
@@ -1784,28 +1976,38 @@ seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p)
 
 	DEB(printf("seq_closemidi: closing midi unit %d.\n", midiunit));
 
-	if (scp->midi_open[midiunit]) {
-		midi_close(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, p);
-		s = splmidi();
-		scp->midi_open[midiunit] = 0;
-		md->intr = NULL;
-		md->intrarg = NULL;
-		splx(s);
+	midi_close(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, p);
+	mtx_lock(&md->flagqueue_mtx);
+	md->intr = NULL;
+	md->intrarg = NULL;
+	mtx_unlock(&md->flagqueue_mtx);
+
+	insync = 0;
+	if ((scp->devinfo->flags & SEQ_F_INSYNC) != 0) {
+		insync = 1;
+		cv_wait(&scp->devinfo->insync_cv, &scp->devinfo->flagqueue_mtx);
 	}
 
+	TAILQ_REMOVE(&scp->midi_open, md, md_linkseq);
+
+	if (insync)
+		cv_signal(&scp->devinfo->insync_cv);
+
 	return (0);
 }
 
 static void
 seq_panic(sc_p scp)
 {
+	mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
+
 	seq_reset(scp);
 }
 
 static int
 seq_reset(sc_p scp)
 {
-	int unit, i, s, chn;
+	int unit, chn;
 	seqdev_info *sd;
 	mididev_info *md;
 	u_char c[3];
@@ -1813,76 +2015,53 @@ seq_reset(sc_p scp)
 	sd = scp->devinfo;
 	unit = sd->unit;
 
-	s = splmidi();
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
+
+	if ((sd->flags & SEQ_F_INSYNC) != 0) {
+		cv_wait(&sd->insync_cv, &sd->flagqueue_mtx);
+		cv_signal(&sd->insync_cv);
+	}
 
 	/* Stop reading and writing. */
 	sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_RD | SEQ_CB_WR);
 
 	/* Clear the queues. */
-	midibuf_init(&sd->midi_dbuf_in);
-	midibuf_init(&sd->midi_dbuf_out);
+	midibuf_clear(&sd->midi_dbuf_in);
+	midibuf_clear(&sd->midi_dbuf_out);
 
 #if notyet
 	/* Reset the synthesizers. */
-	for (i = 0 ; i < mididev_info_number() ; i++) {
-		md = get_mididev_info_unit(i);
-		if (MIDICONFED(md) && scp->midi_open[i])
-			md->synth.reset(md);
-	}
+	TAILQ_FOREACH(md, &scp->midi_open, md_linkseq)
+		md->synth.reset(md);
 #endif /* notyet */
 
 #if notyet
 	if (scp->seq_mode == SEQ_2) {
-		for (chn = 0 ; chn < 16 ; chn++)
-			for (i = 0 ; i < mididev_info_number() ; i++)
-				if (midi_open[i]) {
-					md = get_mididev_info_unit(i);
-					if (!MIDICONFED(md))
-						continue;
-					if (md->synth.controller(md, chn, 123, 0) == EAGAIN /* All notes off. */
-					    || md->synth.controller(md, chn, 121, 0) == EAGAIN /* Reset all controllers. */
-					    || md->synth.bender(md, chn, 1 << 13) == EAGAIN) { /* Reset pitch bend. */
-						splx(s);
-						return (EAGAIN);
-					}
-				}
-		splx(s);
+		for (chn = 0 ; chn < 16 ; chn++) {
+			TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
+				if (md->synth.controller(md, chn, 123, 0) == EAGAIN /* All notes off. */
+				    || md->synth.controller(md, chn, 121, 0) == EAGAIN /* Reset all controllers. */
+				    || md->synth.bender(md, chn, 1 << 13) == EAGAIN) /* Reset pitch bend. */
+					return (EAGAIN);
+			}
+		}
 	} else {
 #endif /* notyet */
-		splx(s);
-		for (i = 0 ; i < mididev_info_number() ; i++) {
-			md = get_mididev_info_unit(i);
-			if (!MIDICONFED(md))
-				continue;
-
-			/* Send active sensing. */
-			c[0] = 0xfe; /* Active Sensing. */
-			if (md->synth.writeraw(md, c, 1, 0) == EAGAIN)
-				return (EAGAIN);
-			/*
-			 * We need a sleep to reset a midi device using an active sensing.
-			 * SC-88 resets after 420ms...
-			 */
-			tsleep(md, PRIBIO, "seqrst", 500 * hz / 1000);
+		TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
 			for (chn = 0 ; chn < 16 ; chn++) {
 				c[0] = 0xb0 | (chn & 0x0f);
 				c[1] = (u_char)0x78; /* All sound off */
 				c[2] = (u_char)0;
-				if (md->synth.writeraw(md, c, 3, 0) == EAGAIN)
-					return (EAGAIN);
+				md->synth.writeraw(md, c, 3, 0);
 				c[1] = (u_char)0x7b; /* All note off */
-				if (md->synth.writeraw(md, c, 3, 0) == EAGAIN)
-					return (EAGAIN);
+				md->synth.writeraw(md, c, 3, 0);
 				c[1] = (u_char)0x79; /* Reset all controller */
-				if (md->synth.writeraw(md, c, 3, 0) == EAGAIN)
-					return (EAGAIN);
+				md->synth.writeraw(md, c, 3, 0);
 			}
 		}
-		for (i = 0 ; i < mididev_info_number() ; i++){
-			md = get_mididev_info_unit(i);
-			if (MIDICONFED(md))
-				seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
-		}
+		seq_sync(scp);
+		TAILQ_FOREACH(md, &scp->midi_open, md_linkseq)
+			lookup_mididev(scp, md->unit, LOOKUP_CLOSE, NULL);
 #if notyet
 	}
 #endif /* notyet */
@@ -1890,30 +2069,61 @@ seq_reset(sc_p scp)
 	return (0);
 }
 
+#define SEQ_SYNC_TIMEOUT 8
 static int
 seq_sync(sc_p scp)
 {
-	int unit, s, i;
+	int i, rl;
 	seqdev_info *sd;
+	mididev_info *md;
 
 	sd = scp->devinfo;
-	unit = sd->unit;
 
-	s = splmidi();
+	mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 
-	if (sd->midi_dbuf_out.rl >= EV_SZ)
-		sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
+	sd->flags |= SEQ_F_INSYNC;
 
-	while ((sd->flags & SEQ_F_WRITING) != 0 && sd->midi_dbuf_out.rl >= EV_SZ) {
-		i = tsleep(&sd->midi_dbuf_out.tsleep_out, PRIBIO | PCATCH, "seqsnc", 0);
-		if (i == EINTR)
-			sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR);
+	while (sd->midi_dbuf_out.rl >= EV_SZ) {
+		if ((sd->flags & SEQ_F_WRITING) == 0)
+			sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
+		rl = sd->midi_dbuf_out.rl;
+		i = msleep(&sd->midi_dbuf_out.tsleep_out, &sd->flagqueue_mtx, PRIBIO | PCATCH, "seqsnc", SEQ_SYNC_TIMEOUT * hz);
 		if (i == EINTR || i == ERESTART) {
-			splx(s);
+			if (i == EINTR)
+				sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR);
+			sd->flags &= ~SEQ_F_INSYNC;
 			return (i);
 		}
+		if (i == EWOULDBLOCK && rl == sd->midi_dbuf_out.rl && !scp->timer_running) {
+			/* A queue seems to be stuck up. Give up and clear queues. */
+			sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR);
+			midibuf_clear(&sd->midi_dbuf_out);
+			TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
+				mtx_lock(&md->flagqueue_mtx);
+				md->callback(md, MIDI_CB_ABORT | MIDI_CB_WR);
+				midibuf_clear(&md->midi_dbuf_out);
+				mtx_unlock(&md->flagqueue_mtx);
+			}
+			break;
+		}
+	}
+
+	/*
+	 * Since syncing a midi device might block, unlock sd->flagqueue_mtx.
+	 * Keep sd->midi_dbuf_out from writing by setting SEQ_F_INSYNC.
+	 * sd->insync_cv is signalled when sync is finished.
+	 */
+	mtx_unlock(&sd->flagqueue_mtx);
+
+	TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
+		mtx_lock(&md->flagqueue_mtx);
+		midi_sync(md);
+		mtx_unlock(&md->flagqueue_mtx);
 	}
-	splx(s);
+
+	mtx_lock(&sd->flagqueue_mtx);
+	sd->flags &= ~SEQ_F_INSYNC;
+	cv_signal(&sd->insync_cv);
 
 	return (0);
 }
@@ -1927,7 +2137,6 @@ static seqdev_info *
 get_seqdev_info(dev_t i_dev, int *unit)
 {
 	int u;
-	seqdev_info *d = NULL ;
 
 	if (MIDIDEV(i_dev) != SND_DEV_SEQ && MIDIDEV(i_dev) != SND_DEV_SEQ2)
 		return NULL;
@@ -1935,13 +2144,105 @@ get_seqdev_info(dev_t i_dev, int *unit)
 	if (unit)
 		*unit = u ;
 
-	if (u >= NSEQ_MAX) {
-		DEB(printf("get_seqdev_info: unit %d is not configured.\n", u));
+	return get_seqdev_info_unit(u);
+}
+
+/*
+ * a small utility function which, given a unit number, returns
+ * a pointer to the associated mididev_info struct.
+ */
+seqdev_info *
+get_seqdev_info_unit(int unit)
+{
+	seqdev_info *sd;
+
+	mtx_lock(&seqinfo_mtx);
+	TAILQ_FOREACH(sd, &seq_info, sd_link) {
+		if (sd->unit == unit)
+			break;
+	}
+	mtx_unlock(&seqinfo_mtx);
+
+	return sd;
+}
+
+/* Create a new sequencer device info structure. */
+seqdev_info *
+create_seqdev_info_unit(int unit, seqdev_info *seq)
+{
+	seqdev_info *sd, *sdnew;
+
+	/* As malloc(9) might block, allocate seqdev_info now. */
+	sdnew = malloc(sizeof(seqdev_info), M_DEVBUF, M_WAITOK | M_ZERO);
+	if (sdnew == NULL)
 		return NULL;
+	bcopy(seq, sdnew, sizeof(seqdev_info));
+	sdnew->unit = unit;
+	midibuf_init(&sdnew->midi_dbuf_in);
+	midibuf_init(&sdnew->midi_dbuf_out);
+	mtx_init(&sdnew->flagqueue_mtx, "seqflq", MTX_DEF);
+	cv_init(&sdnew->insync_cv, "seqins");
+
+	mtx_lock(&seqinfo_mtx);
+
+	TAILQ_FOREACH(sd, &seq_info, sd_link) {
+		if (sd->unit == unit) {
+			mtx_unlock(&seqinfo_mtx);
+			midibuf_destroy(&sdnew->midi_dbuf_in);
+			midibuf_destroy(&sdnew->midi_dbuf_out);
+			mtx_destroy(&sdnew->flagqueue_mtx);
+			cv_destroy(&sdnew->insync_cv);
+			free(sdnew, M_DEVBUF);
+			return sd;
+		}
+	}
+
+	mtx_lock(&sdnew->flagqueue_mtx);
+	TAILQ_INSERT_TAIL(&seq_info, sdnew, sd_link);
+	nseq++;
+
+	mtx_unlock(&seqinfo_mtx);
+
+	return sdnew;
+}
+
+/*
+ * Look up a midi device by its unit number opened by this sequencer.
+ * If the device is not opened and mode is LOOKUP_OPEN, open the device.
+ */
+static int
+lookup_mididev(sc_p scp, int unit, int mode, mididev_info **mdp)
+{
+	int ret;
+	mididev_info *md;
+
+	if (mdp == NULL)
+		mdp = &md;
+
+	*mdp = NULL;
+
+	mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
+
+	TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
+		if (md->unit == unit) {
+			*mdp = md;
+			if (mode == LOOKUP_CLOSE)
+				return seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
+
+			return (md != NULL && MIDICONFED(md)) ? 0 : ENXIO;
+		}
 	}
-	d = &seq_info[u];
 
-	return d ;
+	if (mode == LOOKUP_OPEN) {
+		md = get_mididev_info_unit(unit);
+		if (md != NULL) {
+			*mdp = md;
+			ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc);
+			return ret;
+		}
+	}
+
+	return ENXIO;
 }
 
 /* XXX These functions are actually redundant. */
@@ -2036,3 +2337,28 @@ seq_modevent(module_t mod, int type, void *data)
 }
 
 DEV_MODULE(seq, seq_modevent, NULL);
+
+static void
+seq_clone(arg, name, namelen, dev)
+	void *arg;
+	char *name;
+	int namelen;
+	dev_t *dev;
+{
+	int u;
+
+	if (*dev != NODEV)
+		return;
+	if (bcmp(name, "sequencer", 9) != 0)
+		return;
+	if (name[10] != '\0' && name[11] != '\0')
+		return;
+	u = name[9] - '0';
+	if (name[10] != '\0') {
+		u *= 10;
+		u += name[10] - '0';
+	}
+	seq_initunit(u);
+	*dev = MIDIMKDEV(SEQ_CDEV_MAJOR, u, MIDI_DEV_SEQ);
+	return;
+}
diff --git a/sys/dev/sound/midi/sequencer.h b/sys/dev/sound/midi/sequencer.h
index e231b06..a81e041 100644
--- a/sys/dev/sound/midi/sequencer.h
+++ b/sys/dev/sound/midi/sequencer.h
@@ -53,6 +53,7 @@
 #include <sys/syslog.h>
 #include <sys/errno.h>
 #include <sys/malloc.h>
+#include <sys/condvar.h>
 #include <machine/clock.h>	/* for DELAY */
 #include <sys/soundcard.h>
 
@@ -70,6 +71,16 @@ typedef struct _seqdev_info seqdev_info;
 typedef int (seq_callback_t)(seqdev_info *sd, int reason);
 
 /*
+ * The order of mutex lock (from the first to the last)
+ *
+ * 1. sequencer flags, queues, timer and device list
+ * 2. midi synth voice and channel
+ * 3. midi synth status
+ * 4. generic midi flags and queues
+ * 5. midi device
+ */
+
+/*
  * descriptor of sequencer operations ...
  *
  */
@@ -128,14 +139,20 @@ struct _seqdev_info {
 			 * mss codec type, etc. etc.
 			 */
 
+	struct mtx flagqueue_mtx; /* Mutex to protect flags and queues */
+	struct cv insync_cv; /* Conditional variable for sync */
+
+	/* Queues */
 	midi_dbuf midi_dbuf_in; /* midi input event/message queue */
 	midi_dbuf midi_dbuf_out; /* midi output event/message queue */
+	
 
         /*
          * these parameters describe the operation of the board.
          * Generic things like busy flag, speed, etc are here.
          */
 
+	/* Flags */
 	volatile u_long  flags ;     /* 32 bits, used for various purposes. */
 
 	/*
@@ -186,6 +203,8 @@ struct _seqdev_info {
 	 */
 #define SEQ_F_INIT              0x4000  /* changed parameters. need init */
 
+#define SEQ_F_INSYNC            0x8000  /* a pending sync */
+
 	int     play_blocksize, rec_blocksize;  /* blocksize for io and dma ops */
 
 #define swsel midi_dbuf_out.sel
@@ -194,6 +213,9 @@ struct _seqdev_info {
 	u_long	magic;
 #define	MAGIC(unit) ( 0xa4d10de0 + unit )
 	void    *device_data ;	/* just in case it is needed...*/
+
+	/* The tailq entry of the next sequencer device. */
+	TAILQ_ENTRY(_seqdev_info) sd_link;
 } ;
 
 
@@ -226,8 +248,6 @@ struct _seqdev_info {
 #define DEB(x)
 #endif
 
-	extern seqdev_info seq_info[NSEQ_MAX] ;
-
 #define MIDI_DEV_SEQ	1	/* Sequencer output /dev/sequencer (FM
 				   synthesizer and MIDI output) */