xref: /src/sys/dev/midi.c

/*	$NetBSD: midi.c,v 1.43.2.5 2006/05/20 03:15:32 chap Exp $	*/

/*
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Lennart Augustsson (augustss (at) NetBSD.org).
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *        This product includes software developed by the NetBSD
 *        Foundation, Inc. and its contributors.
 * 4. Neither the name of The NetBSD Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: midi.c,v 1.43.2.5 2006/05/20 03:15:32 chap Exp $");

#include "midi.h"
#include "sequencer.h"

#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/fcntl.h>
#include <sys/vnode.h>
#include <sys/select.h>
#include <sys/poll.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/systm.h>
#include <sys/callout.h>
#include <sys/syslog.h>
#include <sys/kernel.h>
#include <sys/signalvar.h>
#include <sys/conf.h>
#include <sys/audioio.h>
#include <sys/midiio.h>

#include <dev/audio_if.h>
#include <dev/midi_if.h>
#include <dev/midivar.h>

#if NMIDI > 0


#ifdef AUDIO_DEBUG
#define DPRINTF(x)	if (mididebug) printf x
#define DPRINTFN(n,x)	if (mididebug >= (n)) printf x
int	mididebug = 0;
/*
 *      1: detected protocol errors and buffer overflows
 *      2: probe, attach, detach
 *      3: open, close
 *      4: data received except realtime
 *      5: ioctl
 *      6: read, write, poll
 *      7: data transmitted
 *      8: uiomoves, synchronization
 *      9: realtime data received
 */
#else
#define DPRINTF(x)
#define DPRINTFN(n,x)
#endif

int midi_wait;

void	midi_in(void *, int);
void	midi_out(void *);
int	midi_start_output(struct midi_softc *, int, int);
int	midi_sleep_timo(int *, char *, int);
int	midi_sleep(int *, char *);
void	midi_wakeup(int *);
void	midi_initbuf(struct midi_buffer *);
void	midi_timeout(void *);

int	midiprobe(struct device *, struct cfdata *, void *);
void	midiattach(struct device *, struct device *, void *);
int	mididetach(struct device *, int);
int	midiactivate(struct device *, enum devact);

dev_type_open(midiopen);
dev_type_close(midiclose);
dev_type_read(midiread);
dev_type_write(midiwrite);
dev_type_ioctl(midiioctl);
dev_type_poll(midipoll);
dev_type_kqfilter(midikqfilter);

const struct cdevsw midi_cdevsw = {
	midiopen, midiclose, midiread, midiwrite, midiioctl,
	nostop, notty, midipoll, nommap, midikqfilter,
};

CFATTACH_DECL(midi, sizeof(struct midi_softc),
    midiprobe, midiattach, mididetach, midiactivate);

#ifdef MIDI_SAVE
#define MIDI_SAVE_SIZE 100000
int midicnt;
struct {
	int cnt;
	u_char buf[MIDI_SAVE_SIZE];
} midisave;
#define MIDI_GETSAVE		_IOWR('m', 100, int)

#endif

extern struct cfdriver midi_cd;

int
midiprobe(struct device *parent, struct cfdata *match, void *aux)
{
	struct audio_attach_args *sa = aux;

	DPRINTFN(2,("midiprobe: type=%d sa=%p hw=%p\n",
		 sa->type, sa, sa->hwif));
	return (sa->type == AUDIODEV_TYPE_MIDI);
}

void
midiattach(struct device *parent, struct device *self, void *aux)
{
	struct midi_softc *sc = (void *)self;
	struct audio_attach_args *sa = aux;
	struct midi_hw_if *hwp = sa->hwif;
	void *hdlp = sa->hdl;

	DPRINTFN(2, ("MIDI attach\n"));

#ifdef DIAGNOSTIC
	if (hwp == 0 ||
	    hwp->open == 0 ||
	    hwp->close == 0 ||
	    hwp->output == 0 ||
	    hwp->getinfo == 0) {
		printf("midi: missing method\n");
		return;
	}
#endif

	sc->hw_if = hwp;
	sc->hw_hdl = hdlp;
	midi_attach(sc, parent);
}

int
midiactivate(struct device *self, enum devact act)
{
	struct midi_softc *sc = (struct midi_softc *)self;

	switch (act) {
	case DVACT_ACTIVATE:
		return (EOPNOTSUPP);

	case DVACT_DEACTIVATE:
		sc->dying = 1;
		break;
	}
	return (0);
}

int
mididetach(struct device *self, int flags)
{
	struct midi_softc *sc = (struct midi_softc *)self;
	int maj, mn;

	DPRINTFN(2,("midi_detach: sc=%p flags=%d\n", sc, flags));

	sc->dying = 1;

	wakeup(&sc->wchan);
	wakeup(&sc->rchan);

	/* locate the major number */
	maj = cdevsw_lookup_major(&midi_cdevsw);

	/* Nuke the vnodes for any open instances (calls close). */
	mn = self->dv_unit;
	vdevgone(maj, mn, mn, VCHR);

	if ( sc->props & MIDI_PROP_CAN_INPUT ) {
		evcnt_detach(&sc->rcvBytesDiscarded);
		evcnt_detach(&sc->rcvIncompleteMessages);
	}

	return (0);
}

void
midi_attach(struct midi_softc *sc, struct device *parent)
{
	struct midi_info mi;


	callout_init(&sc->sc_callout);
	callout_setfunc(&sc->sc_callout, midi_timeout, sc);
	simple_lock_init(&sc->out_lock);
	sc->dying = 0;
	sc->isopen = 0;

	midi_wait = MIDI_WAIT * hz / 1000000;
	if (midi_wait == 0)
		midi_wait = 1;

	sc->sc_dev = parent;
	sc->hw_if->getinfo(sc->hw_hdl, &mi);
	sc->props = mi.props;

	if ( sc->props & MIDI_PROP_CAN_INPUT ) {
		evcnt_attach_dynamic(&sc->rcvBytesDiscarded,
			EVCNT_TYPE_MISC, NULL,
			sc->dev.dv_xname, "rcv bytes discarded");
		evcnt_attach_dynamic(&sc->rcvIncompleteMessages,
			EVCNT_TYPE_MISC, NULL,
			sc->dev.dv_xname, "rcv incomplete msgs");
	}

	printf(": %s\n", mi.name);
}

int
midi_unit_count(void)
{
	int i;
	for ( i = 0; i < midi_cd.cd_ndevs; ++i )
	        if ( NULL == midi_cd.cd_devs[i] )
		        break;
        return i;
}

void
midi_initbuf(struct midi_buffer *mb)
{
	mb->used = 0;
	mb->usedhigh = MIDI_BUFSIZE;
	mb->end = mb->start + mb->usedhigh;
	mb->inp = mb->outp = mb->start;
}

int
midi_sleep_timo(int *chan, char *label, int timo)
{
	int st;

	if (!label)
		label = "midi";

	DPRINTFN(8, ("midi_sleep_timo: %p %s %d\n", chan, label, timo));
	*chan = 1;
	st = tsleep(chan, PWAIT | PCATCH, label, timo);
	*chan = 0;
#ifdef MIDI_DEBUG
	if (st != 0)
		printf("midi_sleep: %d\n", st);
#endif
	return st;
}

int
midi_sleep(int *chan, char *label)
{
	return midi_sleep_timo(chan, label, 0);
}

void
midi_wakeup(int *chan)
{
	if (*chan) {
		DPRINTFN(8, ("midi_wakeup: %p\n", chan));
		wakeup(chan);
		*chan = 0;
	}
}

/* in midivar.h:
#define MIDI_CAT_DATA 0
#define MIDI_CAT_STATUS1 1
#define MIDI_CAT_STATUS2 2
#define MIDI_CAT_COMMON 3
*/
static char const midi_cats[] = "\0\0\0\0\0\0\0\0\2\2\2\2\1\1\2\3";
#define MIDI_CAT(d) (midi_cats[((d)>>4)&15])

void
midi_in(void *addr, int data)
{
	struct midi_softc *sc = addr;
	struct midi_buffer *mb = &sc->inbuf;
	int i;
	u_char *what = sc->in_msg;
        u_char rtbuf;
	int count;

	if (!sc->isopen)
		return;

	if (!(sc->flags & FREAD))
		return;		/* discard data if not reading */

	if ( data >= 0xf8 ) { /* All realtime messages bypass state machine */
	        if ( data == 0xf9  ||  data == 0xfd ) {
			DPRINTF( ("midi_in: sc=%p data=0x%02x undefined\n",
				  sc, data));
			sc->rcvBytesDiscarded.ev_count++;
			return;
		}
		DPRINTFN(9, ("midi_in: sc=%p System Real-Time data=0x%02x\n",
			     sc, data));
		rtbuf = data;
		count = sizeof rtbuf;
		what = &rtbuf;
		goto deliver;
	}

	DPRINTFN(4, ("midi_in: sc=%p data=0x%02x state=%d\n",
		     sc, data, sc->in_state));

retry:
        switch ( sc->in_state | MIDI_CAT(data) ) {

	case MIDI_IN_START  | MIDI_CAT_COMMON:
	case MIDI_IN_RUN1_1 | MIDI_CAT_COMMON:
	case MIDI_IN_RUN2_2 | MIDI_CAT_COMMON:
	        sc->in_msg[0] = data;
		count = 1;
	        switch ( data ) {
		case 0xf0: sc->in_state = MIDI_IN_SYSEX;  goto deliver_raw;
		case 0xf1: sc->in_state = MIDI_IN_COM0_1; return;
		case 0xf2: sc->in_state = MIDI_IN_COM0_2; return;
		case 0xf3: sc->in_state = MIDI_IN_COM0_1; return;
		case 0xf6: sc->in_state = MIDI_IN_START;  break;
		default: goto protocol_violation;
		}
		break;

	case MIDI_IN_START  | MIDI_CAT_STATUS1:
	case MIDI_IN_RUN1_1 | MIDI_CAT_STATUS1:
	case MIDI_IN_RUN2_2 | MIDI_CAT_STATUS1:
	        sc->in_state = MIDI_IN_RUN0_1;
	        sc->in_msg[0] = data;
		return;

	case MIDI_IN_START  | MIDI_CAT_STATUS2:
	case MIDI_IN_RUN1_1 | MIDI_CAT_STATUS2:
	case MIDI_IN_RUN2_2 | MIDI_CAT_STATUS2:
	        sc->in_state = MIDI_IN_RUN0_2;
	        sc->in_msg[0] = data;
		return;

        case MIDI_IN_COM0_1 | MIDI_CAT_DATA:
		sc->in_state = MIDI_IN_START;
	        sc->in_msg[1] = data;
		count = 2;
		break;

        case MIDI_IN_COM0_2 | MIDI_CAT_DATA:
	        sc->in_state = MIDI_IN_COM1_2;
	        sc->in_msg[1] = data;
		return;

        case MIDI_IN_COM1_2 | MIDI_CAT_DATA:
		sc->in_state = MIDI_IN_START;
	        sc->in_msg[2] = data;
		count = 3;
		break;

        case MIDI_IN_RUN0_1 | MIDI_CAT_DATA:
        case MIDI_IN_RUN1_1 | MIDI_CAT_DATA:
		sc->in_state = MIDI_IN_RUN1_1;
	        sc->in_msg[1] = data;
		count = 2;
		break;

        case MIDI_IN_RUN0_2 | MIDI_CAT_DATA:
        case MIDI_IN_RUN2_2 | MIDI_CAT_DATA:
	        sc->in_state = MIDI_IN_RUN1_2;
	        sc->in_msg[1] = data;
		return;

        case MIDI_IN_RUN1_2 | MIDI_CAT_DATA:
		sc->in_state = MIDI_IN_RUN2_2;
	        sc->in_msg[2] = data;
		count = 3;
		break;

        case MIDI_IN_SYSEX | MIDI_CAT_DATA:
		sc->in_msg[0] = data;
		count = 1;
		goto deliver_raw;

        case MIDI_IN_SYSEX | MIDI_CAT_COMMON:
	        if ( data == 0xf7 ) {
		        sc->in_state = MIDI_IN_START;
			sc->in_msg[0] = data;
		        count = 1;
			goto deliver_raw;
		}
		/* FALLTHROUGH */

        default:
protocol_violation:
                DPRINTF(("midi_in: unexpected %#02x in state %u\n",
		        data, sc->in_state));
		switch ( sc->in_state ) {
		case MIDI_IN_RUN1_1: /* can only get here by seeing an */
		case MIDI_IN_RUN2_2: /* INVALID System Common message */
		        sc->in_state = MIDI_IN_START;
			/* FALLTHROUGH */
		case MIDI_IN_START:
			sc->rcvBytesDiscarded.ev_count++;
			return;
		case MIDI_IN_COM1_2:
		case MIDI_IN_RUN1_2:
			sc->rcvBytesDiscarded.ev_count++;
			/* FALLTHROUGH */
		case MIDI_IN_COM0_1:
		case MIDI_IN_RUN0_1:
		case MIDI_IN_COM0_2:
		case MIDI_IN_RUN0_2:
			sc->rcvBytesDiscarded.ev_count++;
			/* FALLTHROUGH */
		case MIDI_IN_SYSEX:
		        sc->rcvIncompleteMessages.ev_count++;
			break;
#if defined(AUDIO_DEBUG) || defined(DIAGNOSTIC)
		default:
		        printf("midi_in: mishandled %#02x(%u) in state %u?!\n",
			      data, MIDI_CAT(data), sc->in_state);
#endif
		}
		sc->in_state = MIDI_IN_START;
		goto retry;
	}

deliver:
#if NSEQUENCER > 0
	if (sc->seqopen) {
		extern void midiseq_in(struct midi_dev *,u_char *,int);
		midiseq_in(sc->seq_md, what, count);
		return;
	}
#endif
        if ( data == MIDI_ACK ) /* sequencer should see these to support API */
	        return; /* otherwise discard (could track time last seen) */
deliver_raw:
	if (mb->used + count > mb->usedhigh) {
		DPRINTF(("midi_in: buffer full, discard data=0x%02x\n",
			 what[0]));
		sc->rcvBytesDiscarded.ev_count += count;
		return;
	}
	for (i = 0; i < count; i++) {
		*mb->inp++ = what[i];
		if (mb->inp >= mb->end)
			mb->inp = mb->start;
		mb->used++;
	}
	midi_wakeup(&sc->rchan);
	selnotify(&sc->rsel, 0);
	if (sc->async)
		psignal(sc->async, SIGIO);
}

void
midi_out(void *addr)
{
	struct midi_softc *sc = addr;

	if (!sc->isopen)
		return;
	DPRINTFN(8, ("midi_out: %p\n", sc));
	midi_start_output(sc, 0, 1);
}

int
midiopen(dev_t dev, int flags, int ifmt, struct proc *p)
{
	struct midi_softc *sc;
	struct midi_hw_if *hw;
	int error;

	sc = device_lookup(&midi_cd, MIDIUNIT(dev));
	if (sc == NULL)
		return (ENXIO);
	if (sc->dying)
		return (EIO);

	DPRINTFN(3,("midiopen %p\n", sc));

	hw = sc->hw_if;
	if (!hw)
		return ENXIO;
	if (sc->isopen)
		return EBUSY;
	sc->in_state = MIDI_IN_START;
	error = hw->open(sc->hw_hdl, flags, midi_in, midi_out, sc);
	if (error)
		return error;
	sc->isopen++;
	midi_initbuf(&sc->outbuf);
	midi_initbuf(&sc->inbuf);
	sc->flags = flags;
	sc->rchan = 0;
	sc->wchan = 0;
	sc->pbus = 0;
	sc->async = 0;

#ifdef MIDI_SAVE
	if (midicnt != 0) {
		midisave.cnt = midicnt;
		midicnt = 0;
	}
#endif

	return 0;
}

int
midiclose(dev_t dev, int flags, int ifmt, struct proc *p)
{
	int unit = MIDIUNIT(dev);
	struct midi_softc *sc = midi_cd.cd_devs[unit];
	struct midi_hw_if *hw = sc->hw_if;
	int s, error;

	DPRINTFN(3,("midiclose %p\n", sc));

	midi_start_output(sc, 1, 0);
	error = 0;
	s = splaudio();
	while (sc->outbuf.used > 0 && !error) {
		DPRINTFN(8,("midiclose sleep used=%d\n", sc->outbuf.used));
		error = midi_sleep_timo(&sc->wchan, "mid_dr", 30*hz);
	}
	splx(s);
	callout_stop(&sc->sc_callout);
	sc->isopen = 0;
	hw->close(sc->hw_hdl);
#if NSEQUENCER > 0
	sc->seqopen = 0;
	sc->seq_md = 0;
#endif
	return 0;
}

int
midiread(dev_t dev, struct uio *uio, int ioflag)
{
	int unit = MIDIUNIT(dev);
	struct midi_softc *sc = midi_cd.cd_devs[unit];
	struct midi_buffer *mb = &sc->inbuf;
	int error;
	u_char *outp;
	int used, cc, n, resid;
	int s;

	DPRINTFN(6,("midiread: %p, count=%lu\n", sc,
		 (unsigned long)uio->uio_resid));

	if (sc->dying)
		return EIO;
        if ( !(sc->flags & FREAD) )
	        return EBADF;
        if ( !(sc->props & MIDI_PROP_CAN_INPUT) )
	        return ENXIO;

	error = 0;
	resid = uio->uio_resid;
	while (uio->uio_resid == resid && !error) {
		s = splaudio();
		while (mb->used <= 0) {
			if (ioflag & IO_NDELAY) {
				splx(s);
				return EWOULDBLOCK;
			}
			error = midi_sleep(&sc->rchan, "mid rd");
			if (error) {
				splx(s);
				return error;
			}
		}
		used = mb->used;
		outp = mb->outp;
		splx(s);
		if (sc->dying)
			return EIO;
		cc = used;	/* maximum to read */
		n = mb->end - outp;
		if (n < cc)
			cc = n;	/* don't read beyond end of buffer */
		if (uio->uio_resid < cc)
			cc = uio->uio_resid; /* and no more than we want */
		DPRINTFN(8, ("midiread: uiomove cc=%d\n", cc));
		error = uiomove(outp, cc, uio);
		if (error)
			break;
		used -= cc;
		outp += cc;
		if (outp >= mb->end)
			outp = mb->start;
		s = splaudio();
		mb->outp = outp;
		mb->used = used;
		splx(s);
	}
	return error;
}

void
midi_timeout(void *arg)
{
	struct midi_softc *sc = arg;

	DPRINTFN(8,("midi_timeout: %p\n", sc));
	midi_start_output(sc, 0, 0);
}

/*
 * Control can reach midi_start_output three ways:
 * 1. as a result of user writing (user == 1)
 * 2. by a ready interrupt from output hw (hw == 1)
 * 3. by a callout scheduled at the end of midi_start_output.
 *
 * The callout is not scheduled unless we are sure the hw will not
 * interrupt again (either because it just did and we supplied it
 * no data, or because it lacks interrupt capability). So we do not
 * expect a hw interrupt to occur with a callout pending.
 *
 * A user write may occur while the callout is pending, however, or before
 * an interrupt-capable device has interrupted. There are two cases:
 *
 * 1. A device interrupt is expected, or the pending callout is a MIDI_WAIT
 *    (the brief delay we put in if MIDI_MAX_WRITE characters have been
 *    written without yielding; interrupt-capable hardware can avoid this
 *    penalty by making sure not to use EINPROGRESS to consume MIDI_MAX_WRITE
 *    or more characters at once).  In these cases, the user invocation of
 *    start_output returns without action, leaving the output to be resumed
 *    by the device interrupt or by the callout after the proper delay. This
 *    case is identified by sc->pbus == 1.
 *
 * 2. The pending callout was scheduled to ensure an Active Sense gets
 *    written if there is no user write in time. In this case the user
 *    invocation (if there is something to write) cancels the pending
 *    callout. However, it may be possible the callout timer expired before
 *    we could cancel it, but the callout hasn't run yet. In this case
 *    (INVOKING status on the callout) the user invocation returns without
 *    further action so the callout can do the work. XXX handle the chance
 *    the callout got scheduled, saw our lock, and gave up.
 *
 * Is it possible that fast interrupt-driven hardware could interrupt while
 * the start_output that triggered it still holds the lock? In this case we'll
 * see on unlock that sc->hw_interrupted == 1 and loop around again if there
 * is more to write.
 */
int
midi_start_output(struct midi_softc *sc, int user, int hw)
{
	struct midi_buffer *mb = &sc->outbuf;
	u_char out;
	int error;
	int s;
	int written;
	int to_write;
	u_char *from;
	u_char *to;

again:
if ( mididebug > 9 ) return EIO;
	error = 0;

	if (sc->dying)
		return EIO;

	s = splaudio();

	if ( ! simple_lock_try(&sc->out_lock) ) {
	        if ( hw )
		        sc->hw_interrupted = 1;
		splx(s);
		DPRINTFN(8,("midi_start_output: locked out user=%d hw=%d\n",
                           user, hw));
		return 0;
	}

	to_write = mb->used;

	if ( user ) {
	        if ( sc->pbus ) {
			simple_unlock(&sc->out_lock);
			splx(s);
			DPRINTFN(8, ("midi_start_output: delaying\n"));
			return 0;
		}
		if ( to_write > 0 ) {
		        callout_stop(&sc->sc_callout);
			if (callout_invoking(&sc->sc_callout)) {
				simple_unlock(&sc->out_lock);
				splx(s);
				DPRINTFN(8,("midi_start_output: "
                                           "callout got away\n"));
				return 0;
			}
		}
	} else if ( hw )
		sc->hw_interrupted = 0;
	else
	        callout_ack(&sc->sc_callout);

	splx(s);
	/*
	 * As long as we hold the lock, we can rely on mb->outp not changing
	 * and mb->used not decreasing. We only need splaudio to update them.
	 */

	from = mb->outp;

	DPRINTFN(8,("midi_start_output: user=%d hw=%d to_write %u from %p\n",
		   user, hw, to_write, from));
	sc->pbus = 0;

	written = 0;
	if ( to_write == 0 && ! user && ! hw ) {
		error = sc->hw_if->output(sc->hw_hdl, MIDI_ACK);
		written = 1;
	}

	do {
	        if ( to_write > MIDI_MAX_WRITE - written )
		        to_write = MIDI_MAX_WRITE - written;
		if ( to_write == 0 )
			break;
		to = from + to_write;
		if ( to > mb->end )
		        to = mb->end;
		while ( from < to ) {
			out = *from++;
#ifdef MIDI_SAVE
			midisave.buf[midicnt] = out;
			midicnt = (midicnt + 1) % MIDI_SAVE_SIZE;
#endif
			DPRINTFN(8, ("midi_start_output: %p data=0x%02x\n",
				     sc, out));
			error = sc->hw_if->output(sc->hw_hdl, out);
			if ( error == 0 ) {
				if ( sc->props & MIDI_PROP_OUT_INTR )
					break;
			} else if ( ( sc->props & MIDI_PROP_OUT_INTR )
			            && error == EINPROGRESS )
				continue;
			else {  /* really an error */
				-- from;
				break;
			}
		}
		written += from - mb->outp;
		s = splaudio();
		mb->used -= from - mb->outp;
		if ( from == mb->end )
			from = mb->start;
		mb->outp = from;
		splx(s);
		to_write = mb->used;
	} while ( error == ( sc->props&MIDI_PROP_OUT_INTR ) ? EINPROGRESS : 0 );

	if ( written > 0 ) {
		midi_wakeup(&sc->wchan);
		selnotify(&sc->wsel, 0);
		if (sc->async)
			psignal(sc->async, SIGIO);
        }

	if ( sc->props & MIDI_PROP_OUT_INTR ) {
		if ( written > 0 && error == 0 ) {
			sc->pbus = 1;
			goto unlock_exit;
		}
		if ( error == EINPROGRESS )
			error = 0;
	}

	if ( error != 0 )
		goto handle_error;

	if ( to_write == 0 )
		callout_schedule(&sc->sc_callout, mstohz(285));
	else {
		sc->pbus = 1;
		callout_schedule(&sc->sc_callout, midi_wait);
	}
	goto unlock_exit;

handle_error:
#if defined(AUDIO_DEBUG) || defined(DIAGNOSTIC)
		printf("%s: midi_start_output error %d\n",
		      sc->dev.dv_xname, error);
#endif

unlock_exit:
	simple_unlock(&sc->out_lock);
	if ( sc->hw_interrupted ) {
		user = 0;
		hw = 1;
		goto again;
	}

	return error;
}

int
midiwrite(dev_t dev, struct uio *uio, int ioflag)
{
	int unit = MIDIUNIT(dev);
	struct midi_softc *sc = midi_cd.cd_devs[unit];
	struct midi_buffer *mb = &sc->outbuf;
	int error;
	u_char *inp;
	int used, cc, n;
	int s;

	DPRINTFN(6, ("midiwrite: %p, unit=%d, count=%lu\n", sc, unit,
		     (unsigned long)uio->uio_resid));

	if (sc->dying)
		return EIO;
        if ( !(sc->flags & FWRITE) )
	        return EBADF;

	error = 0;
	while (uio->uio_resid > 0 && !error) {
		s = splaudio();
		if (mb->used >= mb->usedhigh) {
			DPRINTFN(8,("midi_write: sleep used=%d hiwat=%d\n",
				 mb->used, mb->usedhigh));
			if (ioflag & IO_NDELAY) {
				splx(s);
				return EWOULDBLOCK;
			}
			error = midi_sleep(&sc->wchan, "mid wr");
			if (error) {
				splx(s);
				return error;
			}
		}
		used = mb->used;
		inp = mb->inp;
		splx(s);
		if (sc->dying)
			return EIO;
		cc = mb->usedhigh - used; 	/* maximum to write */
		n = mb->end - inp;
		if (n < cc)
			cc = n;		/* don't write beyond end of buffer */
		if (uio->uio_resid < cc)
			cc = uio->uio_resid; 	/* and no more than we have */
		error = uiomove(inp, cc, uio);
#ifdef MIDI_DEBUG
		if (error)
		        printf("midi_write:(1) uiomove failed %d; "
			       "cc=%d inp=%p\n",
			       error, cc, inp);
#endif
		if (error)
			break;
		inp = mb->inp + cc;
		if (inp >= mb->end)
			inp = mb->start;
		s = splaudio();
		mb->inp = inp;
		mb->used += cc;
		splx(s);
		error = midi_start_output(sc, 1, 0);
	}
	return error;
}

/*
 * This write routine is only called from sequencer code and expects
 * a write that is smaller than the MIDI buffer.
 */
int
midi_writebytes(int unit, u_char *buf, int cc)
{
	struct midi_softc *sc = midi_cd.cd_devs[unit];
	struct midi_buffer *mb = &sc->outbuf;
	int n, s;

	DPRINTFN(7, ("midi_writebytes: %p, unit=%d, cc=%d %#02x %#02x %#02x\n",
                    sc, unit, cc, buf[0], buf[1], buf[2]));

	if (sc->dying)
		return EIO;

	s = splaudio();
	if (mb->used + cc >= mb->usedhigh) {
		splx(s);
		return (EWOULDBLOCK);
	}
	n = mb->end - mb->inp;
	if (cc < n)
		n = cc;
	mb->used += cc;
	memcpy(mb->inp, buf, n);
	mb->inp += n;
	if (mb->inp >= mb->end) {
		mb->inp = mb->start;
		cc -= n;
		if (cc > 0) {
			memcpy(mb->inp, buf + n, cc);
			mb->inp += cc;
		}
	}
	splx(s);
	return (midi_start_output(sc, 1, 0));
}

int
midiioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
{
	int unit = MIDIUNIT(dev);
	struct midi_softc *sc = midi_cd.cd_devs[unit];
	struct midi_hw_if *hw = sc->hw_if;
	int error;

	DPRINTFN(5,("midiioctl: %p cmd=0x%08lx\n", sc, cmd));

	if (sc->dying)
		return EIO;

	error = 0;
	switch (cmd) {
	case FIONBIO:
		/* All handled in the upper FS layer. */
		break;

	case FIOASYNC:
		if (*(int *)addr) {
			if (sc->async)
				return EBUSY;
			sc->async = p;
			DPRINTFN(5,("midi_ioctl: FIOASYNC %p\n", p));
		} else
			sc->async = 0;
		break;

#if 0
	case MIDI_PRETIME:
		/* XXX OSS
		 * This should set up a read timeout, but that's
		 * why we have poll(), so there's nothing yet. */
		error = EINVAL;
		break;
#endif

#ifdef MIDI_SAVE
	case MIDI_GETSAVE:
		error = copyout(&midisave, *(void **)addr, sizeof midisave);
  		break;
#endif

	default:
		if (hw->ioctl)
			error = hw->ioctl(sc->hw_hdl, cmd, addr, flag, p);
		else
			error = EINVAL;
		break;
	}
	return error;
}

int
midipoll(dev_t dev, int events, struct proc *p)
{
	int unit = MIDIUNIT(dev);
	struct midi_softc *sc = midi_cd.cd_devs[unit];
	int revents = 0;
	int s;

	DPRINTFN(6,("midipoll: %p events=0x%x\n", sc, events));

	if (sc->dying)
		return EIO;

	s = splaudio();

	if ((sc->flags&FREAD) && (events & (POLLIN | POLLRDNORM)))
		if (sc->inbuf.used > 0)
			revents |= events & (POLLIN | POLLRDNORM);

	if ((sc->flags&FWRITE) && (events & (POLLOUT | POLLWRNORM)))
		if (sc->outbuf.used < sc->outbuf.usedhigh)
			revents |= events & (POLLOUT | POLLWRNORM);

	if (revents == 0) {
		if ((sc->flags&FREAD) && (events & (POLLIN | POLLRDNORM)))
			selrecord(p, &sc->rsel);

		if ((sc->flags&FWRITE) && (events & (POLLOUT | POLLWRNORM)))
			selrecord(p, &sc->wsel);
	}

	splx(s);
	return revents;
}

static void
filt_midirdetach(struct knote *kn)
{
	struct midi_softc *sc = kn->kn_hook;
	int s;

	s = splaudio();
	SLIST_REMOVE(&sc->rsel.sel_klist, kn, knote, kn_selnext);
	splx(s);
}

static int
filt_midiread(struct knote *kn, long hint)
{
	struct midi_softc *sc = kn->kn_hook;

	/* XXXLUKEM (thorpej): please make sure this is correct. */

	kn->kn_data = sc->inbuf.used;
	return (kn->kn_data > 0);
}

static const struct filterops midiread_filtops =
	{ 1, NULL, filt_midirdetach, filt_midiread };

static void
filt_midiwdetach(struct knote *kn)
{
	struct midi_softc *sc = kn->kn_hook;
	int s;

	s = splaudio();
	SLIST_REMOVE(&sc->wsel.sel_klist, kn, knote, kn_selnext);
	splx(s);
}

static int
filt_midiwrite(struct knote *kn, long hint)
{
	struct midi_softc *sc = kn->kn_hook;

	/* XXXLUKEM (thorpej): please make sure this is correct. */

	kn->kn_data = sc->outbuf.usedhigh - sc->outbuf.used;
	return (kn->kn_data > 0);
}

static const struct filterops midiwrite_filtops =
	{ 1, NULL, filt_midiwdetach, filt_midiwrite };

int
midikqfilter(dev_t dev, struct knote *kn)
{
	int unit = MIDIUNIT(dev);
	struct midi_softc *sc = midi_cd.cd_devs[unit];
	struct klist *klist;
	int s;

	switch (kn->kn_filter) {
	case EVFILT_READ:
		klist = &sc->rsel.sel_klist;
		kn->kn_fop = &midiread_filtops;
		break;

	case EVFILT_WRITE:
		klist = &sc->wsel.sel_klist;
		kn->kn_fop = &midiwrite_filtops;
		break;

	default:
		return (1);
	}

	kn->kn_hook = sc;

	s = splaudio();
	SLIST_INSERT_HEAD(klist, kn, kn_selnext);
	splx(s);

	return (0);
}

void
midi_getinfo(dev_t dev, struct midi_info *mi)
{
	struct midi_softc *sc;

	sc = device_lookup(&midi_cd, MIDIUNIT(dev));
	if (sc == NULL)
		return;
	if (sc->dying)
		return;

	sc->hw_if->getinfo(sc->hw_hdl, mi);
}

#endif /* NMIDI > 0 */

#if NMIDI > 0 || NMIDIBUS > 0

int	audioprint(void *, const char *);

struct device *
midi_attach_mi(struct midi_hw_if *mhwp, void *hdlp, struct device *dev)
{
	struct audio_attach_args arg;

#ifdef DIAGNOSTIC
	if (mhwp == NULL) {
		aprint_error("midi_attach_mi: NULL\n");
		return (0);
	}
#endif
	arg.type = AUDIODEV_TYPE_MIDI;
	arg.hwif = mhwp;
	arg.hdl = hdlp;
	return (config_found(dev, &arg, audioprint));
}

#endif /* NMIDI > 0 || NMIDIBUS > 0 */