Home | History | Annotate | Line # | Download | only in dev
midi.c revision 1.26 
      1 /*	$NetBSD: midi.c,v 1.26 2002/09/23 05:51:10 simonb Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1998 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Lennart Augustsson (augustss (at) netbsd.org).
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *        This product includes software developed by the NetBSD
     21  *        Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 
     39 #include <sys/cdefs.h>
     40 __KERNEL_RCSID(0, "$NetBSD: midi.c,v 1.26 2002/09/23 05:51:10 simonb Exp $");
     41 
     42 #include "midi.h"
     43 #include "sequencer.h"
     44 
     45 #include <sys/param.h>
     46 #include <sys/ioctl.h>
     47 #include <sys/fcntl.h>
     48 #include <sys/vnode.h>
     49 #include <sys/select.h>
     50 #include <sys/poll.h>
     51 #include <sys/malloc.h>
     52 #include <sys/proc.h>
     53 #include <sys/systm.h>
     54 #include <sys/callout.h>
     55 #include <sys/syslog.h>
     56 #include <sys/kernel.h>
     57 #include <sys/signalvar.h>
     58 #include <sys/conf.h>
     59 #include <sys/audioio.h>
     60 #include <sys/midiio.h>
     61 #include <sys/device.h>
     62 
     63 #include <dev/audio_if.h>
     64 #include <dev/midi_if.h>
     65 #include <dev/midivar.h>
     66 
     67 #if NMIDI > 0
     68 
     69 #ifdef AUDIO_DEBUG
     70 #define DPRINTF(x)	if (mididebug) printf x
     71 #define DPRINTFN(n,x)	if (mididebug >= (n)) printf x
     72 int	mididebug = 0;
     73 #else
     74 #define DPRINTF(x)
     75 #define DPRINTFN(n,x)
     76 #endif
     77 
     78 int midi_wait;
     79 
     80 void	midi_in(void *, int);
     81 void	midi_out(void *);
     82 int	midi_start_output(struct midi_softc *, int);
     83 int	midi_sleep_timo(int *, char *, int);
     84 int	midi_sleep(int *, char *);
     85 void	midi_wakeup(int *);
     86 void	midi_initbuf(struct midi_buffer *);
     87 void	midi_timeout(void *);
     88 
     89 int	midiprobe(struct device *, struct cfdata *, void *);
     90 void	midiattach(struct device *, struct device *, void *);
     91 int	mididetach(struct device *, int);
     92 int	midiactivate(struct device *, enum devact);
     93 
     94 dev_type_open(midiopen);
     95 dev_type_close(midiclose);
     96 dev_type_read(midiread);
     97 dev_type_write(midiwrite);
     98 dev_type_ioctl(midiioctl);
     99 dev_type_poll(midipoll);
    100 
    101 const struct cdevsw midi_cdevsw = {
    102 	midiopen, midiclose, midiread, midiwrite, midiioctl,
    103 	nostop, notty, midipoll, nommap,
    104 };
    105 
    106 struct cfattach midi_ca = {
    107 	sizeof(struct midi_softc), midiprobe, midiattach,
    108 	mididetach, midiactivate
    109 };
    110 
    111 #ifdef MIDI_SAVE
    112 #define MIDI_SAVE_SIZE 100000
    113 int midicnt;
    114 struct {
    115 	int cnt;
    116 	u_char buf[MIDI_SAVE_SIZE];
    117 } midisave;
    118 #define MIDI_GETSAVE		_IOWR('m', 100, int)
    119 
    120 #endif
    121 
    122 extern struct cfdriver midi_cd;
    123 
    124 int
    125 midiprobe(struct device *parent, struct cfdata *match, void *aux)
    126 {
    127 	struct audio_attach_args *sa = aux;
    128 
    129 	DPRINTFN(6,("midiprobe: type=%d sa=%p hw=%p\n",
    130 		 sa->type, sa, sa->hwif));
    131 	return (sa->type == AUDIODEV_TYPE_MIDI);
    132 }
    133 
    134 void
    135 midiattach(struct device *parent, struct device *self, void *aux)
    136 {
    137 	struct midi_softc *sc = (void *)self;
    138 	struct audio_attach_args *sa = aux;
    139 	struct midi_hw_if *hwp = sa->hwif;
    140 	void *hdlp = sa->hdl;
    141 
    142 	DPRINTFN(6, ("MIDI attach\n"));
    143 
    144 #ifdef DIAGNOSTIC
    145 	if (hwp == 0 ||
    146 	    hwp->open == 0 ||
    147 	    hwp->close == 0 ||
    148 	    hwp->output == 0 ||
    149 	    hwp->getinfo == 0) {
    150 		printf("midi: missing method\n");
    151 		return;
    152 	}
    153 #endif
    154 
    155 	callout_init(&sc->sc_callout);
    156 
    157 	sc->hw_if = hwp;
    158 	sc->hw_hdl = hdlp;
    159 	sc->dying = 0;
    160 	midi_attach(sc, parent);
    161 }
    162 
    163 int
    164 midiactivate(struct device *self, enum devact act)
    165 {
    166 	struct midi_softc *sc = (struct midi_softc *)self;
    167 
    168 	switch (act) {
    169 	case DVACT_ACTIVATE:
    170 		return (EOPNOTSUPP);
    171 
    172 	case DVACT_DEACTIVATE:
    173 		sc->dying = 1;
    174 		break;
    175 	}
    176 	return (0);
    177 }
    178 
    179 int
    180 mididetach(struct device *self, int flags)
    181 {
    182 	struct midi_softc *sc = (struct midi_softc *)self;
    183 	int maj, mn;
    184 
    185 	DPRINTF(("midi_detach: sc=%p flags=%d\n", sc, flags));
    186 
    187 	sc->dying = 1;
    188 
    189 	wakeup(&sc->wchan);
    190 	wakeup(&sc->rchan);
    191 
    192 	/* locate the major number */
    193 	maj = cdevsw_lookup_major(&midi_cdevsw);
    194 
    195 	/* Nuke the vnodes for any open instances (calls close). */
    196 	mn = self->dv_unit;
    197 	vdevgone(maj, mn, mn, VCHR);
    198 
    199 	return (0);
    200 }
    201 
    202 void
    203 midi_attach(struct midi_softc *sc, struct device *parent)
    204 {
    205 	struct midi_info mi;
    206 
    207 	sc->isopen = 0;
    208 
    209 	midi_wait = MIDI_WAIT * hz / 1000000;
    210 	if (midi_wait == 0)
    211 		midi_wait = 1;
    212 
    213 	sc->sc_dev = parent;
    214 	sc->hw_if->getinfo(sc->hw_hdl, &mi);
    215 	sc->props = mi.props;
    216 	printf(": %s\n", mi.name);
    217 }
    218 
    219 int
    220 midi_unit_count(void)
    221 {
    222 	return midi_cd.cd_ndevs;
    223 }
    224 
    225 void
    226 midi_initbuf(struct midi_buffer *mb)
    227 {
    228 	mb->used = 0;
    229 	mb->usedhigh = MIDI_BUFSIZE;
    230 	mb->end = mb->start + mb->usedhigh;
    231 	mb->inp = mb->outp = mb->start;
    232 }
    233 
    234 int
    235 midi_sleep_timo(int *chan, char *label, int timo)
    236 {
    237 	int st;
    238 
    239 	if (!label)
    240 		label = "midi";
    241 
    242 	DPRINTFN(5, ("midi_sleep_timo: %p %s %d\n", chan, label, timo));
    243 	*chan = 1;
    244 	st = tsleep(chan, PWAIT | PCATCH, label, timo);
    245 	*chan = 0;
    246 #ifdef MIDI_DEBUG
    247 	if (st != 0)
    248 		printf("midi_sleep: %d\n", st);
    249 #endif
    250 	return st;
    251 }
    252 
    253 int
    254 midi_sleep(int *chan, char *label)
    255 {
    256 	return midi_sleep_timo(chan, label, 0);
    257 }
    258 
    259 void
    260 midi_wakeup(int *chan)
    261 {
    262 	if (*chan) {
    263 		DPRINTFN(5, ("midi_wakeup: %p\n", chan));
    264 		wakeup(chan);
    265 		*chan = 0;
    266 	}
    267 }
    268 
    269 static int midi_lengths[] = { 2,2,2,2,1,1,2,0 };
    270 /* Number of bytes in a MIDI command */
    271 #define MIDI_LENGTH(d) (midi_lengths[((d) >> 4) & 7])
    272 
    273 void
    274 midi_in(void *addr, int data)
    275 {
    276 	struct midi_softc *sc = addr;
    277 	struct midi_buffer *mb = &sc->inbuf;
    278 	int i;
    279 
    280 	if (!sc->isopen)
    281 		return;
    282 	if (data == MIDI_ACK)
    283 		return;
    284 
    285 	DPRINTFN(3, ("midi_in: sc=%p data=0x%02x state=%d pos=%d\n",
    286 		     sc, data, sc->in_state, sc->in_pos));
    287 
    288 	if (!(sc->flags & FREAD))
    289 		return;		/* discard data if not reading */
    290 
    291 	switch(sc->in_state) {
    292 	case MIDI_IN_START:
    293 		if (MIDI_IS_STATUS(data)) {
    294 			switch(data) {
    295 			case 0xf0: /* Sysex */
    296 				sc->in_state = MIDI_IN_SYSEX;
    297 				break;
    298 			case 0xf1: /* MTC quarter frame */
    299 			case 0xf3: /* Song select */
    300 				sc->in_state = MIDI_IN_DATA;
    301 				sc->in_msg[0] = data;
    302 				sc->in_pos = 1;
    303 				sc->in_left = 1;
    304 				break;
    305 			case 0xf2: /* Song position pointer */
    306 				sc->in_state = MIDI_IN_DATA;
    307 				sc->in_msg[0] = data;
    308 				sc->in_pos = 1;
    309 				sc->in_left = 2;
    310 				break;
    311 			default:
    312 				if (MIDI_IS_COMMON(data)) {
    313 					sc->in_msg[0] = data;
    314 					sc->in_pos = 1;
    315 					goto deliver;
    316 				} else {
    317 					sc->in_state = MIDI_IN_DATA;
    318 					sc->in_msg[0] = sc->in_status = data;
    319 					sc->in_pos = 1;
    320 					sc->in_left = MIDI_LENGTH(data);
    321 				}
    322 				break;
    323 			}
    324 		} else {
    325 			if (MIDI_IS_STATUS(sc->in_status)) {
    326 				sc->in_state = MIDI_IN_DATA;
    327 				sc->in_msg[0] = sc->in_status;
    328 				sc->in_msg[1] = data;
    329 				sc->in_pos = 2;
    330 				sc->in_left = MIDI_LENGTH(sc->in_status) - 1;
    331 			}
    332 		}
    333 		return;
    334 	case MIDI_IN_DATA:
    335 		sc->in_msg[sc->in_pos++] = data;
    336 		if (--sc->in_left <= 0)
    337 			break;	/* deliver data */
    338 		return;
    339 	case MIDI_IN_SYSEX:
    340 		if (data == MIDI_SYSEX_END)
    341 			sc->in_state = MIDI_IN_START;
    342 		return;
    343 	}
    344 deliver:
    345 	sc->in_state = MIDI_IN_START;
    346 #if NSEQUENCER > 0
    347 	if (sc->seqopen) {
    348 		extern void midiseq_in(struct midi_dev *,u_char *,int);
    349 		midiseq_in(sc->seq_md, sc->in_msg, sc->in_pos);
    350 		return;
    351 	}
    352 #endif
    353 
    354 	if (mb->used + sc->in_pos > mb->usedhigh) {
    355 		DPRINTF(("midi_in: buffer full, discard data=0x%02x\n",
    356 			 sc->in_msg[0]));
    357 		return;
    358 	}
    359 	for (i = 0; i < sc->in_pos; i++) {
    360 		*mb->inp++ = sc->in_msg[i];
    361 		if (mb->inp >= mb->end)
    362 			mb->inp = mb->start;
    363 		mb->used++;
    364 	}
    365 	midi_wakeup(&sc->rchan);
    366 	selwakeup(&sc->rsel);
    367 	if (sc->async)
    368 		psignal(sc->async, SIGIO);
    369 }
    370 
    371 void
    372 midi_out(void *addr)
    373 {
    374 	struct midi_softc *sc = addr;
    375 
    376 	if (!sc->isopen)
    377 		return;
    378 	DPRINTFN(3, ("midi_out: %p\n", sc));
    379 	midi_start_output(sc, 1);
    380 }
    381 
    382 int
    383 midiopen(dev_t dev, int flags, int ifmt, struct proc *p)
    384 {
    385 	struct midi_softc *sc;
    386 	struct midi_hw_if *hw;
    387 	int error;
    388 
    389 	sc = device_lookup(&midi_cd, MIDIUNIT(dev));
    390 	if (sc == NULL)
    391 		return (ENXIO);
    392 	if (sc->dying)
    393 		return (EIO);
    394 
    395 	DPRINTF(("midiopen %p\n", sc));
    396 
    397 	hw = sc->hw_if;
    398 	if (!hw)
    399 		return ENXIO;
    400 	if (sc->isopen)
    401 		return EBUSY;
    402 	sc->in_state = MIDI_IN_START;
    403 	sc->in_status = 0;
    404 	error = hw->open(sc->hw_hdl, flags, midi_in, midi_out, sc);
    405 	if (error)
    406 		return error;
    407 	sc->isopen++;
    408 	midi_initbuf(&sc->outbuf);
    409 	midi_initbuf(&sc->inbuf);
    410 	sc->flags = flags;
    411 	sc->rchan = 0;
    412 	sc->wchan = 0;
    413 	sc->pbus = 0;
    414 	sc->async = 0;
    415 
    416 #ifdef MIDI_SAVE
    417 	if (midicnt != 0) {
    418 		midisave.cnt = midicnt;
    419 		midicnt = 0;
    420 	}
    421 #endif
    422 
    423 	return 0;
    424 }
    425 
    426 int
    427 midiclose(dev_t dev, int flags, int ifmt, struct proc *p)
    428 {
    429 	int unit = MIDIUNIT(dev);
    430 	struct midi_softc *sc = midi_cd.cd_devs[unit];
    431 	struct midi_hw_if *hw = sc->hw_if;
    432 	int s, error;
    433 
    434 	DPRINTF(("midiclose %p\n", sc));
    435 
    436 	midi_start_output(sc, 0);
    437 	error = 0;
    438 	s = splaudio();
    439 	while (sc->outbuf.used > 0 && !error) {
    440 		DPRINTFN(2,("midiclose sleep used=%d\n", sc->outbuf.used));
    441 		error = midi_sleep_timo(&sc->wchan, "mid_dr", 30*hz);
    442 	}
    443 	splx(s);
    444 	sc->isopen = 0;
    445 	hw->close(sc->hw_hdl);
    446 #if NSEQUENCER > 0
    447 	sc->seqopen = 0;
    448 	sc->seq_md = 0;
    449 #endif
    450 	return 0;
    451 }
    452 
    453 int
    454 midiread(dev_t dev, struct uio *uio, int ioflag)
    455 {
    456 	int unit = MIDIUNIT(dev);
    457 	struct midi_softc *sc = midi_cd.cd_devs[unit];
    458 	struct midi_buffer *mb = &sc->inbuf;
    459 	int error;
    460 	u_char *outp;
    461 	int used, cc, n, resid;
    462 	int s;
    463 
    464 	DPRINTF(("midiread: %p, count=%lu\n", sc,
    465 		 (unsigned long)uio->uio_resid));
    466 
    467 	if (sc->dying)
    468 		return EIO;
    469 
    470 	error = 0;
    471 	resid = uio->uio_resid;
    472 	while (uio->uio_resid == resid && !error) {
    473 		s = splaudio();
    474 		while (mb->used <= 0) {
    475 			if (ioflag & IO_NDELAY) {
    476 				splx(s);
    477 				return EWOULDBLOCK;
    478 			}
    479 			error = midi_sleep(&sc->rchan, "mid rd");
    480 			if (error) {
    481 				splx(s);
    482 				return error;
    483 			}
    484 		}
    485 		used = mb->used;
    486 		outp = mb->outp;
    487 		splx(s);
    488 		if (sc->dying)
    489 			return EIO;
    490 		cc = used;	/* maximum to read */
    491 		n = mb->end - outp;
    492 		if (n < cc)
    493 			cc = n;	/* don't read beyond end of buffer */
    494 		if (uio->uio_resid < cc)
    495 			cc = uio->uio_resid; /* and no more than we want */
    496 		DPRINTFN(3, ("midiread: uiomove cc=%d\n", cc));
    497 		error = uiomove(outp, cc, uio);
    498 		if (error)
    499 			break;
    500 		used -= cc;
    501 		outp += cc;
    502 		if (outp >= mb->end)
    503 			outp = mb->start;
    504 		s = splaudio();
    505 		mb->outp = outp;
    506 		mb->used = used;
    507 		splx(s);
    508 	}
    509 	return error;
    510 }
    511 
    512 void
    513 midi_timeout(void *arg)
    514 {
    515 	struct midi_softc *sc = arg;
    516 
    517 	DPRINTFN(3,("midi_timeout: %p\n", sc));
    518 	midi_start_output(sc, 1);
    519 }
    520 
    521 int
    522 midi_start_output(struct midi_softc *sc, int intr)
    523 {
    524 	struct midi_buffer *mb = &sc->outbuf;
    525 	u_char out;
    526 	int error;
    527 	int s;
    528 	int i;
    529 
    530 	error = 0;
    531 
    532 	if (sc->dying)
    533 		return EIO;
    534 
    535 	if (sc->pbus && !intr) {
    536 		DPRINTFN(4, ("midi_start_output: busy\n"));
    537 		return 0;
    538 	}
    539 	sc->pbus = (mb->used > 0)?1:0;
    540 	for (i = 0; i < MIDI_MAX_WRITE && mb->used > 0 &&
    541 		   (!error || error==EINPROGRESS); i++) {
    542 		s = splaudio();
    543 		out = *mb->outp;
    544 		mb->outp++;
    545 		if (mb->outp >= mb->end)
    546 			mb->outp = mb->start;
    547 		mb->used--;
    548 		splx(s);
    549 #ifdef MIDI_SAVE
    550 		midisave.buf[midicnt] = out;
    551 		midicnt = (midicnt + 1) % MIDI_SAVE_SIZE;
    552 #endif
    553 		DPRINTFN(4, ("midi_start_output: %p i=%d, data=0x%02x\n",
    554 			     sc, i, out));
    555 		error = sc->hw_if->output(sc->hw_hdl, out);
    556 		if ((sc->props & MIDI_PROP_OUT_INTR) && error!=EINPROGRESS)
    557 			/* If ointr is enabled, midi_start_output()
    558 			 * normally writes only one byte,
    559 			 * except hw_if->output() returns EINPROGRESS.
    560 			 */
    561 			break;
    562 	}
    563 	midi_wakeup(&sc->wchan);
    564 	selwakeup(&sc->wsel);
    565 	if (sc->async)
    566 		psignal(sc->async, SIGIO);
    567 	if (!(sc->props & MIDI_PROP_OUT_INTR) || error==EINPROGRESS) {
    568 		if (mb->used > 0)
    569 			callout_reset(&sc->sc_callout, midi_wait,
    570 				      midi_timeout, sc);
    571 		else
    572 			sc->pbus = 0;
    573 	}
    574 	if ((sc->props & MIDI_PROP_OUT_INTR) && error==EINPROGRESS)
    575 		error = 0;
    576 
    577 	return error;
    578 }
    579 
    580 int
    581 midiwrite(dev_t dev, struct uio *uio, int ioflag)
    582 {
    583 	int unit = MIDIUNIT(dev);
    584 	struct midi_softc *sc = midi_cd.cd_devs[unit];
    585 	struct midi_buffer *mb = &sc->outbuf;
    586 	int error;
    587 	u_char *inp;
    588 	int used, cc, n;
    589 	int s;
    590 
    591 	DPRINTFN(2, ("midiwrite: %p, unit=%d, count=%lu\n", sc, unit,
    592 		     (unsigned long)uio->uio_resid));
    593 
    594 	if (sc->dying)
    595 		return EIO;
    596 
    597 	error = 0;
    598 	while (uio->uio_resid > 0 && !error) {
    599 		s = splaudio();
    600 		if (mb->used >= mb->usedhigh) {
    601 			DPRINTFN(3,("midi_write: sleep used=%d hiwat=%d\n",
    602 				 mb->used, mb->usedhigh));
    603 			if (ioflag & IO_NDELAY) {
    604 				splx(s);
    605 				return EWOULDBLOCK;
    606 			}
    607 			error = midi_sleep(&sc->wchan, "mid wr");
    608 			if (error) {
    609 				splx(s);
    610 				return error;
    611 			}
    612 		}
    613 		used = mb->used;
    614 		inp = mb->inp;
    615 		splx(s);
    616 		if (sc->dying)
    617 			return EIO;
    618 		cc = mb->usedhigh - used; 	/* maximum to write */
    619 		n = mb->end - inp;
    620 		if (n < cc)
    621 			cc = n;		/* don't write beyond end of buffer */
    622 		if (uio->uio_resid < cc)
    623 			cc = uio->uio_resid; 	/* and no more than we have */
    624 		error = uiomove(inp, cc, uio);
    625 #ifdef MIDI_DEBUG
    626 		if (error)
    627 		        printf("midi_write:(1) uiomove failed %d; "
    628 			       "cc=%d inp=%p\n",
    629 			       error, cc, inp);
    630 #endif
    631 		if (error)
    632 			break;
    633 		inp = mb->inp + cc;
    634 		if (inp >= mb->end)
    635 			inp = mb->start;
    636 		s = splaudio();
    637 		mb->inp = inp;
    638 		mb->used += cc;
    639 		splx(s);
    640 		error = midi_start_output(sc, 0);
    641 	}
    642 	return error;
    643 }
    644 
    645 /*
    646  * This write routine is only called from sequencer code and expects
    647  * a write that is smaller than the MIDI buffer.
    648  */
    649 int
    650 midi_writebytes(int unit, u_char *buf, int cc)
    651 {
    652 	struct midi_softc *sc = midi_cd.cd_devs[unit];
    653 	struct midi_buffer *mb = &sc->outbuf;
    654 	int n, s;
    655 
    656 	DPRINTFN(2, ("midi_writebytes: %p, unit=%d, cc=%d\n", sc, unit, cc));
    657 	DPRINTFN(3, ("midi_writebytes: %x %x %x\n",buf[0],buf[1],buf[2]));
    658 
    659 	if (sc->dying)
    660 		return EIO;
    661 
    662 	s = splaudio();
    663 	if (mb->used + cc >= mb->usedhigh) {
    664 		splx(s);
    665 		return (EWOULDBLOCK);
    666 	}
    667 	n = mb->end - mb->inp;
    668 	if (cc < n)
    669 		n = cc;
    670 	mb->used += cc;
    671 	memcpy(mb->inp, buf, n);
    672 	mb->inp += n;
    673 	if (mb->inp >= mb->end) {
    674 		mb->inp = mb->start;
    675 		cc -= n;
    676 		if (cc > 0) {
    677 			memcpy(mb->inp, buf + n, cc);
    678 			mb->inp += cc;
    679 		}
    680 	}
    681 	splx(s);
    682 	return (midi_start_output(sc, 0));
    683 }
    684 
    685 int
    686 midiioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
    687 {
    688 	int unit = MIDIUNIT(dev);
    689 	struct midi_softc *sc = midi_cd.cd_devs[unit];
    690 	struct midi_hw_if *hw = sc->hw_if;
    691 	int error;
    692 
    693 	DPRINTF(("midiioctl: %p cmd=0x%08lx\n", sc, cmd));
    694 
    695 	if (sc->dying)
    696 		return EIO;
    697 
    698 	error = 0;
    699 	switch (cmd) {
    700 	case FIONBIO:
    701 		/* All handled in the upper FS layer. */
    702 		break;
    703 
    704 	case FIOASYNC:
    705 		if (*(int *)addr) {
    706 			if (sc->async)
    707 				return EBUSY;
    708 			sc->async = p;
    709 			DPRINTF(("midi_ioctl: FIOASYNC %p\n", p));
    710 		} else
    711 			sc->async = 0;
    712 		break;
    713 
    714 #if 0
    715 	case MIDI_PRETIME:
    716 		/* XXX OSS
    717 		 * This should set up a read timeout, but that's
    718 		 * why we have poll(), so there's nothing yet. */
    719 		error = EINVAL;
    720 		break;
    721 #endif
    722 
    723 #ifdef MIDI_SAVE
    724 	case MIDI_GETSAVE:
    725 		error = copyout(&midisave, *(void **)addr, sizeof midisave);
    726   		break;
    727 #endif
    728 
    729 	default:
    730 		if (hw->ioctl)
    731 			error = hw->ioctl(sc->hw_hdl, cmd, addr, flag, p);
    732 		else
    733 			error = EINVAL;
    734 		break;
    735 	}
    736 	return error;
    737 }
    738 
    739 int
    740 midipoll(dev_t dev, int events, struct proc *p)
    741 {
    742 	int unit = MIDIUNIT(dev);
    743 	struct midi_softc *sc = midi_cd.cd_devs[unit];
    744 	int revents = 0;
    745 	int s;
    746 
    747 	DPRINTF(("midipoll: %p events=0x%x\n", sc, events));
    748 
    749 	if (sc->dying)
    750 		return EIO;
    751 
    752 	s = splaudio();
    753 
    754 	if (events & (POLLIN | POLLRDNORM))
    755 		if (sc->inbuf.used > 0)
    756 			revents |= events & (POLLIN | POLLRDNORM);
    757 
    758 	if (events & (POLLOUT | POLLWRNORM))
    759 		if (sc->outbuf.used < sc->outbuf.usedhigh)
    760 			revents |= events & (POLLOUT | POLLWRNORM);
    761 
    762 	if (revents == 0) {
    763 		if (events & (POLLIN | POLLRDNORM))
    764 			selrecord(p, &sc->rsel);
    765 
    766 		if (events & (POLLOUT | POLLWRNORM))
    767 			selrecord(p, &sc->wsel);
    768 	}
    769 
    770 	splx(s);
    771 	return revents;
    772 }
    773 
    774 void
    775 midi_getinfo(dev_t dev, struct midi_info *mi)
    776 {
    777 	struct midi_softc *sc;
    778 
    779 	sc = device_lookup(&midi_cd, MIDIUNIT(dev));
    780 	if (sc == NULL)
    781 		return;
    782 	if (sc->dying)
    783 		return;
    784 
    785 	sc->hw_if->getinfo(sc->hw_hdl, mi);
    786 }
    787 
    788 #endif /* NMIDI > 0 */
    789 
    790 #if NMIDI > 0 || NMIDIBUS > 0
    791 
    792 int	audioprint(void *, const char *);
    793 
    794 struct device *
    795 midi_attach_mi(struct midi_hw_if *mhwp, void *hdlp, struct device *dev)
    796 {
    797 	struct audio_attach_args arg;
    798 
    799 #ifdef DIAGNOSTIC
    800 	if (mhwp == NULL) {
    801 		printf("midi_attach_mi: NULL\n");
    802 		return (0);
    803 	}
    804 #endif
    805 	arg.type = AUDIODEV_TYPE_MIDI;
    806 	arg.hwif = mhwp;
    807 	arg.hdl = hdlp;
    808 	return (config_found(dev, &arg, audioprint));
    809 }
    810 
    811 #endif /* NMIDI > 0 || NMIDIBUS > 0 */
    812