 @@ -1,14 +1,14 @@
-/*	$NetBSD: sequencer.c,v 1.52.14.2 2011/11/20 20:00:15 jmcneill Exp $	*/
+/*	$NetBSD: sequencer.c,v 1.52.14.3 2011/11/22 07:57:23 mrg Exp $	*/
 /*
  * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (augustss@NetBSD.org) and by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -45,27 +45,27 @@
  * o MIDI softc locks.  These can be spinlocks and there can be many of
  *   them, because we can open many MIDI devices.  We take these only in two
  *   places: when enabling redirection from the MIDI device and when
  *   disabling it (open/close).  midiseq_in() is called by the MIDI driver
  *   with its own lock held when passing data into this module.  To avoid
  *   lock order and context problems, we package the received message as a
  *   sequencer_pcqitem_t and put onto a producer-consumer queue.  A soft
  *   interrupt is scheduled to dequeue and decode the message later where we
  *   can safely acquire the sequencer device's sc_lock.  PCQ is lockless for
  *   multiple producer, single consumer settings like this one.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sequencer.c,v 1.52.14.2 2011/11/20 20:00:15 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sequencer.c,v 1.52.14.3 2011/11/22 07:57:23 mrg Exp $");
 #include "sequencer.h"
 #include <sys/param.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include <sys/select.h>
 #include <sys/poll.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/syslog.h>
 @@ -360,56 +360,59 @@ seq_startoutput(struct sequencer_softc *
 	while(!SEQ_QEMPTY(q) && !sc->timeout) {
 		SEQ_QGET(q, cmd);
 		seq_do_command(sc, &cmd);
+	}
+}
 static int
 sequencerclose(dev_t dev, int flags, int ifmt, struct lwp *l)
+{
 	struct sequencer_softc *sc;
 	struct midi_softc *msc;
 	int unit, error;
-	DPRINTF(("sequencerclose: %d\n", dev));
+	DPRINTF(("sequencerclose: %"PRIx64"\n", dev));
 	if ((error = sequencer_enter(dev, &sc)) != 0)
 		return error;
 	seq_drain(sc);
 	if (sc->timeout) {
 		callout_halt(&sc->sc_callout, &sc->lock);
 		sc->timeout = 0;
+	}
 	/* Bin input from MIDI devices. */
 	for (unit = 0; unit < sc->nmidi; unit++) {
 		msc = sc->devs[unit]->msc;
 		mutex_enter(msc->lock);
 		msc->seqopen = 0;
 		mutex_exit(msc->lock);
+	}
 	mutex_exit(&sc->lock);
 	for (unit = 0; unit < sc->nmidi; unit++)
-		midiseq_close(sc->devs[unit]);
+		if (sc->devs[unit] != NULL)
 			midiseq_close(sc->devs[unit]);
 	if (sc->devs != NULL) {
 		KASSERT(sc->ndevs > 0);
 		kmem_free(sc->devs, sc->ndevs * sizeof(struct midi_dev *));
 		sc->devs = NULL;
+	}
 	mutex_enter(&sc->lock);
 	sc->isopen = 0;
 	sequencer_exit(sc);
 	DPRINTF(("sequencerclose: %"PRIx64" done\n", dev));
 	return (0);
+}
 static int
 seq_input_event(struct sequencer_softc *sc, seq_event_t *cmd)
+{
 	struct sequencer_queue *q;
 	proc_t *p;
 	KASSERT(mutex_owned(&sc->lock));
 	DPRINTFN(2, ("seq_input_event: %02x %02x %02x %02x %02x "
 	    "%02x %02x %02x\n", cmd->tag,
 @@ -500,27 +503,27 @@ seq_softintr(void *addr)
+	}
 	seq_input_event(sc, &ev);
 	mutex_exit(&sc->lock);
+}
 static int
 sequencerread(dev_t dev, struct uio *uio, int ioflag)
+{
 	struct sequencer_softc *sc;
 	struct sequencer_queue *q;
 	seq_event_t ev;
 	int error;
-	DPRINTFN(20, ("sequencerread: %d, count=%d, ioflag=%x\n",
+	DPRINTFN(20, ("sequencerread: %"PRIx64", count=%d, ioflag=%x\n",
 	   dev, (int)uio->uio_resid, ioflag));
 	q = &sc->inq;
 	if ((error = sequencer_enter(dev, &sc)) != 0)
 		return error;
 	if (sc->mode == SEQ_OLD) {
 		sequencer_exit(sc);
 		DPRINTFN(-1,("sequencerread: old read\n"));
 		return EINVAL; /* XXX unimplemented */
+	}
 	while (SEQ_QEMPTY(q)) {
 		if (ioflag & IO_NDELAY) {
 			error = EWOULDBLOCK;
 @@ -547,27 +550,27 @@ sequencerread(dev_t dev, struct uio *uio
 	sequencer_exit(sc);
 	return error;
+}
 static int
 sequencerwrite(dev_t dev, struct uio *uio, int ioflag)
+{
 	struct sequencer_softc *sc;
 	struct sequencer_queue *q;
 	int error;
 	seq_event_t cmdbuf;
 	int size;
-	DPRINTFN(2, ("sequencerwrite: %d, count=%d\n", dev,
+	DPRINTFN(2, ("sequencerwrite: %"PRIx64", count=%d\n", dev,
 	    (int)uio->uio_resid));
 	q = &sc->outq;
 	if ((error = sequencer_enter(dev, &sc)) != 0)
 		return error;
 	size = sc->mode == SEQ_NEW ? sizeof cmdbuf : SEQOLD_CMDSIZE;
 	while (uio->uio_resid >= size && error == 0) {
 		mutex_exit(&sc->lock);
 		error = uiomove(&cmdbuf, size, uio);
 		if (error == 0) {
 			if (sc->mode == SEQ_OLD && seq_to_new(&cmdbuf, uio)) {
 				continue;
 @@ -610,27 +613,27 @@ sequencerwrite(dev_t dev, struct uio *ui
 	return error;
+}
 static int
 sequencerioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
+{
 	struct sequencer_softc *sc;
 	struct synth_info *si;
 	struct midi_dev *md;
 	int devno, error, t;
 	struct timeval now;
 	u_long tx;
-	DPRINTFN(2, ("sequencerioctl: %d cmd=0x%08lx\n", dev, cmd));
+	DPRINTFN(2, ("sequencerioctl: %"PRIx64" cmd=0x%08lx\n", dev, cmd));
 	if ((error = sequencer_enter(dev, &sc)) != 0)
 		return error;
 	switch (cmd) {
 	case FIONBIO:
 		/* All handled in the upper FS layer. */
 		break;
 	case FIOASYNC:
 		if (*(int *)addr) {
 			if (sc->async != 0)
 				return EBUSY;
 			sc->async = curproc->p_pid;