xref: /netbsd-src/sys/dev/sequencer.c (revision 08c81a9c2dc8c7300e893321eb65c0925d60871c)
1 /*	$NetBSD: sequencer.c,v 1.20 2002/09/06 13:18:43 gehenna 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@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: sequencer.c,v 1.20 2002/09/06 13:18:43 gehenna Exp $");
41 
42 #include "sequencer.h"
43 
44 #include <sys/param.h>
45 #include <sys/ioctl.h>
46 #include <sys/fcntl.h>
47 #include <sys/vnode.h>
48 #include <sys/select.h>
49 #include <sys/poll.h>
50 #include <sys/malloc.h>
51 #include <sys/proc.h>
52 #include <sys/systm.h>
53 #include <sys/syslog.h>
54 #include <sys/kernel.h>
55 #include <sys/signalvar.h>
56 #include <sys/conf.h>
57 #include <sys/audioio.h>
58 #include <sys/midiio.h>
59 #include <sys/device.h>
60 
61 #include <dev/midi_if.h>
62 #include <dev/midivar.h>
63 #include <dev/sequencervar.h>
64 
65 #define ADDTIMEVAL(a, b) ( \
66 	(a)->tv_sec += (b)->tv_sec, \
67 	(a)->tv_usec += (b)->tv_usec, \
68 	(a)->tv_usec > 1000000 ? ((a)->tv_sec++, (a)->tv_usec -= 1000000) : 0\
69 	)
70 
71 #define SUBTIMEVAL(a, b) ( \
72 	(a)->tv_sec -= (b)->tv_sec, \
73 	(a)->tv_usec -= (b)->tv_usec, \
74 	(a)->tv_usec < 0 ? ((a)->tv_sec--, (a)->tv_usec += 1000000) : 0\
75 	)
76 
77 #ifdef AUDIO_DEBUG
78 #define DPRINTF(x)	if (sequencerdebug) printf x
79 #define DPRINTFN(n,x)	if (sequencerdebug >= (n)) printf x
80 int	sequencerdebug = 0;
81 #else
82 #define DPRINTF(x)
83 #define DPRINTFN(n,x)
84 #endif
85 
86 #define SEQ_CMD(b)  ((b)->arr[0])
87 
88 #define SEQ_EDEV(b)  ((b)->arr[1])
89 #define SEQ_ECMD(b)  ((b)->arr[2])
90 #define SEQ_ECHAN(b) ((b)->arr[3])
91 #define SEQ_ENOTE(b) ((b)->arr[4])
92 #define SEQ_EPARM(b) ((b)->arr[5])
93 
94 #define SEQ_EP1(b)   ((b)->arr[4])
95 #define SEQ_EP2(b)   ((b)->arr[5])
96 
97 #define SEQ_XCMD(b)  ((b)->arr[1])
98 #define SEQ_XDEV(b)  ((b)->arr[2])
99 #define SEQ_XCHAN(b) ((b)->arr[3])
100 #define SEQ_XNOTE(b) ((b)->arr[4])
101 #define SEQ_XVEL(b)  ((b)->arr[5])
102 
103 #define SEQ_TCMD(b)  ((b)->arr[1])
104 #define SEQ_TPARM(b) ((b)->arr[4])
105 
106 #define SEQ_NOTE_MAX 128
107 #define SEQ_NOTE_XXX 255
108 #define SEQ_VEL_OFF 0
109 
110 #define RECALC_TICK(t) ((t)->tick = 60 * 1000000L / ((t)->tempo * (t)->timebase))
111 
112 struct sequencer_softc seqdevs[NSEQUENCER];
113 
114 void sequencerattach __P((int));
115 void seq_reset __P((struct sequencer_softc *));
116 int seq_do_command __P((struct sequencer_softc *, seq_event_rec *));
117 int seq_do_extcommand __P((struct sequencer_softc *, seq_event_rec *));
118 int seq_do_chnvoice __P((struct sequencer_softc *, seq_event_rec *));
119 int seq_do_chncommon __P((struct sequencer_softc *, seq_event_rec *));
120 int seq_do_timing __P((struct sequencer_softc *, seq_event_rec *));
121 int seq_do_local __P((struct sequencer_softc *, seq_event_rec *));
122 int seq_do_sysex __P((struct sequencer_softc *, seq_event_rec *));
123 int seq_do_fullsize __P((struct sequencer_softc *, seq_event_rec *,
124 			 struct uio *));
125 int seq_timer __P((struct sequencer_softc *, int, int, seq_event_rec *));
126 static int seq_input_event __P((struct sequencer_softc *, seq_event_rec *));
127 int seq_drain __P((struct sequencer_softc *));
128 void seq_startoutput __P((struct sequencer_softc *));
129 void seq_timeout __P((void *));
130 int seq_to_new __P((seq_event_rec *, struct uio *));
131 static int seq_sleep_timo(int *, char *, int);
132 static int seq_sleep(int *, char *);
133 static void seq_wakeup(int *);
134 
135 struct midi_softc;
136 int midiseq_out __P((struct midi_dev *, u_char *, u_int, int));
137 struct midi_dev *midiseq_open __P((int, int));
138 void midiseq_close __P((struct midi_dev *));
139 void midiseq_reset __P((struct midi_dev *));
140 int midiseq_noteon __P((struct midi_dev *, int, int, int));
141 int midiseq_noteoff __P((struct midi_dev *, int, int, int));
142 int midiseq_keypressure __P((struct midi_dev *, int, int, int));
143 int midiseq_pgmchange __P((struct midi_dev *, int, int));
144 int midiseq_chnpressure __P((struct midi_dev *, int, int));
145 int midiseq_ctlchange __P((struct midi_dev *, int, int, int));
146 int midiseq_pitchbend __P((struct midi_dev *, int, int));
147 int midiseq_loadpatch __P((struct midi_dev *, struct sysex_info *,
148 			   struct uio *));
149 int midiseq_putc __P((struct midi_dev *, int));
150 void midiseq_in __P((struct midi_dev *, u_char *, int));
151 
152 dev_type_open(sequenceropen);
153 dev_type_close(sequencerclose);
154 dev_type_read(sequencerread);
155 dev_type_write(sequencerwrite);
156 dev_type_ioctl(sequencerioctl);
157 dev_type_poll(sequencerpoll);
158 
159 const struct cdevsw sequencer_cdevsw = {
160 	sequenceropen, sequencerclose, sequencerread, sequencerwrite,
161 	sequencerioctl, nostop, notty, sequencerpoll, nommap,
162 };
163 
164 void
165 sequencerattach(n)
166 	int n;
167 {
168 
169 	for (n = 0; n < NSEQUENCER; n++)
170 		callout_init(&seqdevs[n].sc_callout);
171 }
172 
173 int
174 sequenceropen(dev, flags, ifmt, p)
175 	dev_t dev;
176 	int flags, ifmt;
177 	struct proc *p;
178 {
179 	int unit = SEQUENCERUNIT(dev);
180 	struct sequencer_softc *sc;
181 	struct midi_dev *md;
182 	int nmidi;
183 
184 	DPRINTF(("sequenceropen\n"));
185 
186 	if (unit >= NSEQUENCER)
187 		return (ENXIO);
188 	sc = &seqdevs[unit];
189 	if (sc->isopen)
190 		return EBUSY;
191 	if (SEQ_IS_OLD(unit))
192 		sc->mode = SEQ_OLD;
193 	else
194 		sc->mode = SEQ_NEW;
195 	sc->isopen++;
196 	sc->flags = flags & (FREAD|FWRITE);
197 	sc->rchan = 0;
198 	sc->wchan = 0;
199 	sc->pbus = 0;
200 	sc->async = 0;
201 	sc->input_stamp = ~0;
202 
203 	sc->nmidi = 0;
204 	nmidi = midi_unit_count();
205 
206 	sc->devs = malloc(nmidi * sizeof(struct midi_dev *),
207 			  M_DEVBUF, M_WAITOK);
208 	for (unit = 0; unit < nmidi; unit++) {
209 		md = midiseq_open(unit, flags);
210 		if (md) {
211 			sc->devs[sc->nmidi++] = md;
212 			md->seq = sc;
213 		}
214 	}
215 
216 	sc->timer.timebase = 100;
217 	sc->timer.tempo = 60;
218 	sc->doingsysex = 0;
219 	RECALC_TICK(&sc->timer);
220 	sc->timer.last = 0;
221 	microtime(&sc->timer.start);
222 
223 	SEQ_QINIT(&sc->inq);
224 	SEQ_QINIT(&sc->outq);
225 	sc->lowat = SEQ_MAXQ / 2;
226 
227 	seq_reset(sc);
228 
229 	DPRINTF(("sequenceropen: mode=%d, nmidi=%d\n", sc->mode, sc->nmidi));
230 	return 0;
231 }
232 
233 static int
234 seq_sleep_timo(chan, label, timo)
235 	int *chan;
236 	char *label;
237 	int timo;
238 {
239 	int st;
240 
241 	if (!label)
242 		label = "seq";
243 
244 	DPRINTFN(5, ("seq_sleep_timo: %p %s %d\n", chan, label, timo));
245 	*chan = 1;
246 	st = tsleep(chan, PWAIT | PCATCH, label, timo);
247 	*chan = 0;
248 #ifdef MIDI_DEBUG
249 	if (st != 0)
250 	    printf("seq_sleep: %d\n", st);
251 #endif
252 	return st;
253 }
254 
255 static int
256 seq_sleep(chan, label)
257 	int *chan;
258 	char *label;
259 {
260 	return seq_sleep_timo(chan, label, 0);
261 }
262 
263 static void
264 seq_wakeup(chan)
265 	int *chan;
266 {
267 	if (*chan) {
268 		DPRINTFN(5, ("seq_wakeup: %p\n", chan));
269 		wakeup(chan);
270 		*chan = 0;
271 	}
272 }
273 
274 int
275 seq_drain(sc)
276 	struct sequencer_softc *sc;
277 {
278 	int error;
279 
280 	DPRINTFN(3, ("seq_drain: %p, len=%d\n", sc, SEQ_QLEN(&sc->outq)));
281 	seq_startoutput(sc);
282 	error = 0;
283 	while(!SEQ_QEMPTY(&sc->outq) && !error)
284 		error = seq_sleep_timo(&sc->wchan, "seq_dr", 60*hz);
285 	return (error);
286 }
287 
288 void
289 seq_timeout(addr)
290 	void *addr;
291 {
292 	struct sequencer_softc *sc = addr;
293 	DPRINTFN(4, ("seq_timeout: %p\n", sc));
294 	sc->timeout = 0;
295 	seq_startoutput(sc);
296 	if (SEQ_QLEN(&sc->outq) < sc->lowat) {
297 		seq_wakeup(&sc->wchan);
298 		selwakeup(&sc->wsel);
299 		if (sc->async)
300 			psignal(sc->async, SIGIO);
301 	}
302 
303 }
304 
305 void
306 seq_startoutput(sc)
307 	struct sequencer_softc *sc;
308 {
309 	struct sequencer_queue *q = &sc->outq;
310 	seq_event_rec cmd;
311 
312 	if (sc->timeout)
313 		return;
314 	DPRINTFN(4, ("seq_startoutput: %p, len=%d\n", sc, SEQ_QLEN(q)));
315 	while(!SEQ_QEMPTY(q) && !sc->timeout) {
316 		SEQ_QGET(q, cmd);
317 		seq_do_command(sc, &cmd);
318 	}
319 }
320 
321 int
322 sequencerclose(dev, flags, ifmt, p)
323 	dev_t dev;
324 	int flags, ifmt;
325 	struct proc *p;
326 {
327 	struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
328 	int n, s;
329 
330 	DPRINTF(("sequencerclose: %p\n", sc));
331 
332 	seq_drain(sc);
333 	s = splaudio();
334 	if (sc->timeout) {
335 		callout_stop(&sc->sc_callout);
336 		sc->timeout = 0;
337 	}
338 	splx(s);
339 
340 	for (n = 0; n < sc->nmidi; n++)
341 		midiseq_close(sc->devs[n]);
342 	free(sc->devs, M_DEVBUF);
343 	sc->isopen = 0;
344 	return (0);
345 }
346 
347 static int
348 seq_input_event(sc, cmd)
349 	struct sequencer_softc *sc;
350 	seq_event_rec *cmd;
351 {
352 	struct sequencer_queue *q = &sc->inq;
353 
354 	DPRINTFN(2, ("seq_input_event: %02x %02x %02x %02x %02x %02x %02x %02x\n",
355 		     cmd->arr[0], cmd->arr[1], cmd->arr[2], cmd->arr[3],
356 		     cmd->arr[4], cmd->arr[5], cmd->arr[6], cmd->arr[7]));
357 	if (SEQ_QFULL(q))
358 		return (ENOMEM);
359 	SEQ_QPUT(q, *cmd);
360 	seq_wakeup(&sc->rchan);
361 	selwakeup(&sc->rsel);
362 	if (sc->async)
363 		psignal(sc->async, SIGIO);
364 	return 0;
365 }
366 
367 void
368 seq_event_intr(addr, iev)
369 	void *addr;
370 	seq_event_rec *iev;
371 {
372 	struct sequencer_softc *sc = addr;
373 	union {
374 		u_int32_t l;
375 		u_int8_t b[4];
376 	} u;
377 	u_long t;
378 	struct timeval now;
379 	seq_event_rec ev;
380 
381 	microtime(&now);
382 	SUBTIMEVAL(&now, &sc->timer.start);
383 	t = now.tv_sec * 1000000 + now.tv_usec;
384 	t /= sc->timer.tick;
385 	if (t != sc->input_stamp) {
386 		ev.arr[0] = SEQ_TIMING;
387 		ev.arr[1] = TMR_WAIT_ABS;
388 		ev.arr[2] = 0;
389 		ev.arr[3] = 0;
390 		u.l = t;
391 		ev.arr[4] = u.b[0];
392 		ev.arr[5] = u.b[1];
393 		ev.arr[6] = u.b[2];
394 		ev.arr[7] = u.b[3];
395 		seq_input_event(sc, &ev);
396 		sc->input_stamp = t;
397 	}
398 	seq_input_event(sc, iev);
399 }
400 
401 int
402 sequencerread(dev, uio, ioflag)
403 	dev_t dev;
404 	struct uio *uio;
405 	int ioflag;
406 {
407 	struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
408 	struct sequencer_queue *q = &sc->inq;
409 	seq_event_rec ev;
410 	int error, s;
411 
412 	DPRINTFN(20, ("sequencerread: %p, count=%d, ioflag=%x\n",
413 		     sc, (int) uio->uio_resid, ioflag));
414 
415 	if (sc->mode == SEQ_OLD) {
416 		DPRINTFN(-1,("sequencerread: old read\n"));
417 		return (EINVAL); /* XXX unimplemented */
418 	}
419 
420 	error = 0;
421 	while (SEQ_QEMPTY(q)) {
422 		if (ioflag & IO_NDELAY)
423 			return EWOULDBLOCK;
424 		else {
425 			error = seq_sleep(&sc->rchan, "seq rd");
426 			if (error)
427 				return error;
428 		}
429 	}
430 	s = splaudio();
431 	while (uio->uio_resid >= sizeof ev && !error && !SEQ_QEMPTY(q)) {
432 		SEQ_QGET(q, ev);
433 		error = uiomove(&ev, sizeof ev, uio);
434 	}
435 	splx(s);
436 	return error;
437 }
438 
439 int
440 sequencerwrite(dev, uio, ioflag)
441 	dev_t dev;
442 	struct uio *uio;
443 	int ioflag;
444 {
445 	struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
446 	struct sequencer_queue *q = &sc->outq;
447 	int error;
448 	seq_event_rec cmdbuf;
449 	int size;
450 
451 	DPRINTFN(2, ("sequencerwrite: %p, count=%d\n", sc, (int) uio->uio_resid));
452 
453 	error = 0;
454 	size = sc->mode == SEQ_NEW ? sizeof cmdbuf : SEQOLD_CMDSIZE;
455 	while (uio->uio_resid >= size) {
456 		error = uiomove(&cmdbuf, size, uio);
457 		if (error)
458 			break;
459 		if (sc->mode == SEQ_OLD)
460 			if (seq_to_new(&cmdbuf, uio))
461 				continue;
462 		if (SEQ_CMD(&cmdbuf) == SEQ_FULLSIZE) {
463 			/* We do it like OSS does, asynchronously */
464 			error = seq_do_fullsize(sc, &cmdbuf, uio);
465 			if (error)
466 				break;
467 			continue;
468 		}
469 		while (SEQ_QFULL(q)) {
470 			seq_startoutput(sc);
471 			if (SEQ_QFULL(q)) {
472 				if (ioflag & IO_NDELAY)
473 					return EWOULDBLOCK;
474 				error = seq_sleep(&sc->wchan, "seq_wr");
475 				if (error)
476 					return error;
477 			}
478 		}
479 		SEQ_QPUT(q, cmdbuf);
480 	}
481 	seq_startoutput(sc);
482 
483 #ifdef SEQUENCER_DEBUG
484 	if (error)
485 		DPRINTFN(2, ("sequencerwrite: error=%d\n", error));
486 #endif
487 	return error;
488 }
489 
490 int
491 sequencerioctl(dev, cmd, addr, flag, p)
492 	dev_t dev;
493 	u_long cmd;
494 	caddr_t addr;
495 	int flag;
496 	struct proc *p;
497 {
498 	struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
499 	struct synth_info *si;
500 	struct midi_dev *md;
501 	int devno;
502 	int error;
503 	int t;
504 
505 	DPRINTFN(2, ("sequencerioctl: %p cmd=0x%08lx\n", sc, cmd));
506 
507 	error = 0;
508 	switch (cmd) {
509 	case FIONBIO:
510 		/* All handled in the upper FS layer. */
511 		break;
512 
513 	case FIOASYNC:
514 		if (*(int *)addr) {
515 			if (sc->async)
516 				return EBUSY;
517 			sc->async = p;
518 			DPRINTF(("sequencer_ioctl: FIOASYNC %p\n", p));
519 		} else
520 			sc->async = 0;
521 		break;
522 
523 	case SEQUENCER_RESET:
524 		seq_reset(sc);
525 		break;
526 
527 	case SEQUENCER_PANIC:
528 		seq_reset(sc);
529 		/* Do more?  OSS doesn't */
530 		break;
531 
532 	case SEQUENCER_SYNC:
533 		if (sc->flags == FREAD)
534 			return 0;
535 		seq_drain(sc);
536 		error = 0;
537 		break;
538 
539 	case SEQUENCER_INFO:
540 		si = (struct synth_info*)addr;
541 		devno = si->device;
542 		if (devno < 0 || devno >= sc->nmidi)
543 			return EINVAL;
544 		md = sc->devs[devno];
545 		strncpy(si->name, md->name, sizeof si->name);
546 		si->synth_type = SYNTH_TYPE_MIDI;
547 		si->synth_subtype = md->subtype;
548 		si->nr_voices = md->nr_voices;
549 		si->instr_bank_size = md->instr_bank_size;
550 		si->capabilities = md->capabilities;
551 		break;
552 
553 	case SEQUENCER_NRSYNTHS:
554 		*(int *)addr = sc->nmidi;
555 		break;
556 
557 	case SEQUENCER_NRMIDIS:
558 		*(int *)addr = sc->nmidi;
559 		break;
560 
561 	case SEQUENCER_OUTOFBAND:
562 		DPRINTFN(3, ("sequencer_ioctl: OOB=%02x %02x %02x %02x %02x %02x %02x %02x\n",
563 			     *(u_char *)addr, *(u_char *)(addr+1),
564 			     *(u_char *)(addr+2), *(u_char *)(addr+3),
565 			     *(u_char *)(addr+4), *(u_char *)(addr+5),
566 			     *(u_char *)(addr+6), *(u_char *)(addr+7)));
567 		error = seq_do_command(sc, (seq_event_rec *)addr);
568 		break;
569 
570 	case SEQUENCER_TMR_TIMEBASE:
571 		t = *(int *)addr;
572 		if (t < 1)
573 			t = 1;
574 		if (t > 10000)
575 			t = 10000;
576 		sc->timer.timebase = t;
577 		*(int *)addr = t;
578 		RECALC_TICK(&sc->timer);
579 		break;
580 
581 	case SEQUENCER_TMR_START:
582 		error = seq_timer(sc, TMR_START, 0, 0);
583 		break;
584 
585 	case SEQUENCER_TMR_STOP:
586 		error = seq_timer(sc, TMR_STOP, 0, 0);
587 		break;
588 
589 	case SEQUENCER_TMR_CONTINUE:
590 		error = seq_timer(sc, TMR_CONTINUE, 0, 0);
591 		break;
592 
593 	case SEQUENCER_TMR_TEMPO:
594 		t = *(int *)addr;
595 		if (t < 8)
596 			t = 8;
597 		if (t > 250)
598 			t = 250;
599 		sc->timer.tempo = t;
600 		*(int *)addr = t;
601 		RECALC_TICK(&sc->timer);
602 		break;
603 
604 	case SEQUENCER_TMR_SOURCE:
605 		*(int *)addr = SEQUENCER_TMR_INTERNAL;
606 		break;
607 
608 	case SEQUENCER_TMR_METRONOME:
609 		/* noop */
610 		break;
611 
612 	case SEQUENCER_THRESHOLD:
613 		t = SEQ_MAXQ - *(int *)addr / sizeof (seq_event_rec);
614 		if (t < 1)
615 			t = 1;
616 		if (t > SEQ_MAXQ)
617 			t = SEQ_MAXQ;
618 		sc->lowat = t;
619 		break;
620 
621 	case SEQUENCER_CTRLRATE:
622 		*(int *)addr = (sc->timer.tempo*sc->timer.timebase + 30) / 60;
623 		break;
624 
625 	case SEQUENCER_GETTIME:
626 	{
627 		struct timeval now;
628 		u_long t;
629 		microtime(&now);
630 		SUBTIMEVAL(&now, &sc->timer.start);
631 		t = now.tv_sec * 1000000 + now.tv_usec;
632 		t /= sc->timer.tick;
633 		*(int *)addr = t;
634 		break;
635 	}
636 
637 	default:
638 		DPRINTFN(-1,("sequencer_ioctl: unimpl %08lx\n", cmd));
639 		error = EINVAL;
640 		break;
641 	}
642 	return error;
643 }
644 
645 int
646 sequencerpoll(dev, events, p)
647 	dev_t dev;
648 	int events;
649 	struct proc *p;
650 {
651 	struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
652 	int revents = 0;
653 
654 	DPRINTF(("sequencerpoll: %p events=0x%x\n", sc, events));
655 
656 	if (events & (POLLIN | POLLRDNORM))
657 		if (!SEQ_QEMPTY(&sc->inq))
658 			revents |= events & (POLLIN | POLLRDNORM);
659 
660 	if (events & (POLLOUT | POLLWRNORM))
661 		if (SEQ_QLEN(&sc->outq) < sc->lowat)
662 			revents |= events & (POLLOUT | POLLWRNORM);
663 
664 	if (revents == 0) {
665 		if (events & (POLLIN | POLLRDNORM))
666 			selrecord(p, &sc->rsel);
667 
668 		if (events & (POLLOUT | POLLWRNORM))
669 			selrecord(p, &sc->wsel);
670 	}
671 
672 	return revents;
673 }
674 
675 void
676 seq_reset(sc)
677 	struct sequencer_softc *sc;
678 {
679 	int i, chn;
680 	struct midi_dev *md;
681 
682 	for (i = 0; i < sc->nmidi; i++) {
683 		md = sc->devs[i];
684 		midiseq_reset(md);
685 		for (chn = 0; chn < MAXCHAN; chn++) {
686 			midiseq_ctlchange(md, chn, MIDI_CTRL_ALLOFF, 0);
687 			midiseq_ctlchange(md, chn, MIDI_CTRL_RESET, 0);
688 			midiseq_pitchbend(md, chn, MIDI_BEND_NEUTRAL);
689 		}
690 	}
691 }
692 
693 int
694 seq_do_command(sc, b)
695 	struct sequencer_softc *sc;
696 	seq_event_rec *b;
697 {
698 	int dev;
699 
700 	DPRINTFN(4, ("seq_do_command: %p cmd=0x%02x\n", sc, SEQ_CMD(b)));
701 
702 	switch(SEQ_CMD(b)) {
703 	case SEQ_LOCAL:
704 		return seq_do_local(sc, b);
705 	case SEQ_TIMING:
706 		return seq_do_timing(sc, b);
707 	case SEQ_CHN_VOICE:
708 		return seq_do_chnvoice(sc, b);
709 	case SEQ_CHN_COMMON:
710 		return seq_do_chncommon(sc, b);
711 	case SEQ_SYSEX:
712 		return seq_do_sysex(sc, b);
713 	/* COMPAT */
714 	case SEQOLD_MIDIPUTC:
715 		dev = b->arr[2];
716 		if (dev < 0 || dev >= sc->nmidi)
717 			return (ENXIO);
718 		return midiseq_putc(sc->devs[dev], b->arr[1]);
719 	default:
720 		DPRINTFN(-1,("seq_do_command: unimpl command %02x\n",
721 			     SEQ_CMD(b)));
722 		return (EINVAL);
723 	}
724 }
725 
726 int
727 seq_do_chnvoice(sc, b)
728 	struct sequencer_softc *sc;
729 	seq_event_rec *b;
730 {
731 	int cmd, dev, chan, note, parm, voice;
732 	int error;
733 	struct midi_dev *md;
734 
735 	dev = SEQ_EDEV(b);
736 	if (dev < 0 || dev >= sc->nmidi)
737 		return ENXIO;
738 	md = sc->devs[dev];
739 	cmd = SEQ_ECMD(b);
740 	chan = SEQ_ECHAN(b);
741 	note = SEQ_ENOTE(b);
742 	parm = SEQ_EPARM(b);
743 	DPRINTFN(2,("seq_do_chnvoice: cmd=%02x dev=%d chan=%d note=%d parm=%d\n",
744 		    cmd, dev, chan, note, parm));
745 	voice = chan;
746 	if (cmd == MIDI_NOTEON && parm == 0) {
747 		cmd = MIDI_NOTEOFF;
748 		parm = MIDI_HALF_VEL;
749 	}
750 	switch(cmd) {
751 	case MIDI_NOTEON:
752 		DPRINTFN(5, ("seq_do_chnvoice: noteon %p %d %d %d\n",
753 			     md, voice, note, parm));
754 		error = midiseq_noteon(md, voice, note, parm);
755 		break;
756 	case MIDI_NOTEOFF:
757 		error = midiseq_noteoff(md, voice, note, parm);
758 		break;
759 	case MIDI_KEY_PRESSURE:
760 		error = midiseq_keypressure(md, voice, note, parm);
761 		break;
762 	default:
763 		DPRINTFN(-1,("seq_do_chnvoice: unimpl command %02x\n", cmd));
764 		error = EINVAL;
765 		break;
766 	}
767 	return error;
768 }
769 
770 int
771 seq_do_chncommon(sc, b)
772 	struct sequencer_softc *sc;
773 	seq_event_rec *b;
774 {
775 	int cmd, dev, chan, p1, w14;
776 	int error;
777 	struct midi_dev *md;
778 	union {
779 		int16_t s;
780 		u_int8_t b[2];
781 	} u;
782 
783 	dev = SEQ_EDEV(b);
784 	if (dev < 0 || dev >= sc->nmidi)
785 		return ENXIO;
786 	md = sc->devs[dev];
787 	cmd = SEQ_ECMD(b);
788 	chan = SEQ_ECHAN(b);
789 	p1 = SEQ_EP1(b);
790 	u.b[0] = b->arr[6];
791 	u.b[1] = b->arr[7];
792 	w14 = u.s;
793 	DPRINTFN(2,("seq_do_chncommon: %02x\n", cmd));
794 
795 	error = 0;
796 	switch(cmd) {
797 	case MIDI_PGM_CHANGE:
798 		error = midiseq_pgmchange(md, chan, p1);
799 		break;
800 	case MIDI_CTL_CHANGE:
801 		if (chan > 15 || p1 > 127)
802 			return 0; /* EINVAL */
803 		error = midiseq_ctlchange(md, chan, p1, w14);
804 		break;
805 	case MIDI_PITCH_BEND:
806 		error = midiseq_pitchbend(md, chan, w14);
807 		break;
808 	case MIDI_CHN_PRESSURE:
809 		error = midiseq_chnpressure(md, chan, p1);
810 		break;
811 	default:
812 		DPRINTFN(-1,("seq_do_chncommon: unimpl command %02x\n", cmd));
813 		error = EINVAL;
814 		break;
815 	}
816 	return (error);
817 }
818 
819 int
820 seq_do_timing(sc, b)
821 	struct sequencer_softc *sc;
822 	seq_event_rec *b;
823 {
824 	union {
825 		int32_t i;
826 		u_int8_t b[4];
827 	} u;
828 	u.b[0] = b->arr[4];
829 	u.b[1] = b->arr[5];
830 	u.b[2] = b->arr[6];
831 	u.b[3] = b->arr[7];
832 	return seq_timer(sc, SEQ_TCMD(b), u.i, b);
833 }
834 
835 int
836 seq_do_local(sc, b)
837 	struct sequencer_softc *sc;
838 	seq_event_rec *b;
839 {
840 	return (EINVAL);
841 }
842 
843 int
844 seq_do_sysex(sc, b)
845 	struct sequencer_softc *sc;
846 	seq_event_rec *b;
847 {
848 	int dev, i;
849 	struct midi_dev *md;
850 	u_int8_t c, *buf = &b->arr[2];
851 
852 	dev = SEQ_EDEV(b);
853 	if (dev < 0 || dev >= sc->nmidi)
854 		return (ENXIO);
855 	DPRINTF(("seq_do_sysex: dev=%d\n", dev));
856 	md = sc->devs[dev];
857 
858 	if (!sc->doingsysex) {
859 		c = MIDI_SYSEX_START;
860 		midiseq_out(md, &c, 1, 0);
861 		sc->doingsysex = 1;
862 	}
863 
864 	for (i = 0; i < 6 && buf[i] != 0xff; i++)
865 		;
866 	midiseq_out(md, buf, i, 0);
867 	if (i < 6 || (i > 0 && buf[i-1] == MIDI_SYSEX_END))
868 		sc->doingsysex = 0;
869 	return (0);
870 }
871 
872 int
873 seq_timer(sc, cmd, parm, b)
874 	struct sequencer_softc *sc;
875 	int cmd, parm;
876 	seq_event_rec *b;
877 {
878 	struct syn_timer *t = &sc->timer;
879 	struct timeval when;
880 	int ticks;
881 	int error;
882 	long long usec;
883 
884 	DPRINTFN(2,("seq_timer: %02x %d\n", cmd, parm));
885 
886 	error = 0;
887 	switch(cmd) {
888 	case TMR_WAIT_REL:
889 		parm += t->last;
890 		/* fall into */
891 	case TMR_WAIT_ABS:
892 		t->last = parm;
893 		usec = (long long)parm * (long long)t->tick; /* convert to usec */
894 		when.tv_sec = usec / 1000000;
895 		when.tv_usec = usec % 1000000;
896 		DPRINTFN(4, ("seq_timer: parm=%d, sleep when=%ld.%06ld", parm,
897 			     when.tv_sec, when.tv_usec));
898 		ADDTIMEVAL(&when, &t->start); /* abstime for end */
899 		ticks = hzto(&when);
900 		DPRINTFN(4, (" when+start=%ld.%06ld, tick=%d\n",
901 			     when.tv_sec, when.tv_usec, ticks));
902 		if (ticks > 0) {
903 #ifdef DIAGNOSTIC
904 			if (ticks > 20 * hz) {
905 				/* Waiting more than 20s */
906 				printf("seq_timer: funny ticks=%d, usec=%lld, parm=%d, tick=%ld\n",
907 				       ticks, usec, parm, t->tick);
908 			}
909 #endif
910 			sc->timeout = 1;
911 			callout_reset(&sc->sc_callout, ticks,
912 			    seq_timeout, sc);
913 		}
914 #ifdef SEQUENCER_DEBUG
915 		else if (tick < 0)
916 			DPRINTF(("seq_timer: ticks = %d\n", ticks));
917 #endif
918 		break;
919 	case TMR_START:
920 		microtime(&t->start);
921 		t->running = 1;
922 		break;
923 	case TMR_STOP:
924 		microtime(&t->stop);
925 		t->running = 0;
926 		break;
927 	case TMR_CONTINUE:
928 		microtime(&when);
929 		SUBTIMEVAL(&when, &t->stop);
930 		ADDTIMEVAL(&t->start, &when);
931 		t->running = 1;
932 		break;
933 	case TMR_TEMPO:
934 		/* parm is ticks per minute / timebase */
935 		if (parm < 8)
936 			parm = 8;
937 		if (parm > 360)
938 			parm = 360;
939 		t->tempo = parm;
940 		RECALC_TICK(t);
941 		break;
942 	case TMR_ECHO:
943 		error = seq_input_event(sc, b);
944 		break;
945 	case TMR_RESET:
946 		t->last = 0;
947 		microtime(&t->start);
948 		break;
949 	default:
950 		DPRINTF(("seq_timer: unknown %02x\n", cmd));
951 		error = EINVAL;
952 		break;
953 	}
954 	return (error);
955 }
956 
957 int
958 seq_do_fullsize(sc, b, uio)
959 	struct sequencer_softc *sc;
960 	seq_event_rec *b;
961 	struct uio *uio;
962 {
963 	struct sysex_info sysex;
964 	u_int dev;
965 
966 #ifdef DIAGNOSTIC
967 	if (sizeof(seq_event_rec) != SEQ_SYSEX_HDRSIZE) {
968 		printf("seq_do_fullsize: sysex size ??\n");
969 		return EINVAL;
970 	}
971 #endif
972 	memcpy(&sysex, b, sizeof sysex);
973 	dev = sysex.device_no;
974 	DPRINTFN(2, ("seq_do_fullsize: fmt=%04x, dev=%d, len=%d\n",
975 		     sysex.key, dev, sysex.len));
976 	return (midiseq_loadpatch(sc->devs[dev], &sysex, uio));
977 }
978 
979 /* Convert an old sequencer event to a new one. */
980 int
981 seq_to_new(ev, uio)
982 	seq_event_rec *ev;
983 	struct uio *uio;
984 {
985 	int cmd, chan, note, parm;
986 	u_int32_t delay;
987 	int error;
988 
989 	cmd = SEQ_CMD(ev);
990 	chan = ev->arr[1];
991 	note = ev->arr[2];
992 	parm = ev->arr[3];
993 	DPRINTFN(3, ("seq_to_new: 0x%02x %d %d %d\n", cmd, chan, note, parm));
994 
995 	if (cmd >= 0x80) {
996 		/* Fill the event record */
997 		if (uio->uio_resid >= sizeof *ev - SEQOLD_CMDSIZE) {
998 			error = uiomove(&ev->arr[SEQOLD_CMDSIZE],
999 					sizeof *ev - SEQOLD_CMDSIZE, uio);
1000 			if (error)
1001 				return error;
1002 		} else
1003 			return EINVAL;
1004 	}
1005 
1006 	switch(cmd) {
1007 	case SEQOLD_NOTEOFF:
1008 		note = 255;
1009 		SEQ_ECMD(ev) = MIDI_NOTEOFF;
1010 		goto onoff;
1011 	case SEQOLD_NOTEON:
1012 		SEQ_ECMD(ev) = MIDI_NOTEON;
1013 	onoff:
1014 		SEQ_CMD(ev) = SEQ_CHN_VOICE;
1015 		SEQ_EDEV(ev) = 0;
1016 		SEQ_ECHAN(ev) = chan;
1017 		SEQ_ENOTE(ev) = note;
1018 		SEQ_EPARM(ev) = parm;
1019 		break;
1020 	case SEQOLD_WAIT:
1021 		delay = *(u_int32_t *)ev->arr >> 8;
1022 		SEQ_CMD(ev) = SEQ_TIMING;
1023 		SEQ_TCMD(ev) = TMR_WAIT_REL;
1024 		*(u_int32_t *)&ev->arr[4] = delay;
1025 		break;
1026 	case SEQOLD_SYNCTIMER:
1027 		SEQ_CMD(ev) = SEQ_TIMING;
1028 		SEQ_TCMD(ev) = TMR_RESET;
1029 		break;
1030 	case SEQOLD_PGMCHANGE:
1031 		SEQ_ECMD(ev) = MIDI_PGM_CHANGE;
1032 		SEQ_CMD(ev) = SEQ_CHN_COMMON;
1033 		SEQ_EDEV(ev) = 0;
1034 		SEQ_ECHAN(ev) = chan;
1035 		SEQ_EP1(ev) = note;
1036 		break;
1037 	case SEQOLD_MIDIPUTC:
1038 		break;		/* interpret in normal mode */
1039 	case SEQOLD_ECHO:
1040 	case SEQOLD_PRIVATE:
1041 	case SEQOLD_EXTENDED:
1042 	default:
1043 		DPRINTF(("seq_to_new: not impl 0x%02x\n", cmd));
1044 		return EINVAL;
1045 	/* In case new events show up */
1046 	case SEQ_TIMING:
1047 	case SEQ_CHN_VOICE:
1048 	case SEQ_CHN_COMMON:
1049 	case SEQ_FULLSIZE:
1050 		break;
1051 	}
1052 	return 0;
1053 }
1054 
1055 /**********************************************/
1056 
1057 void
1058 midiseq_in(md, msg, len)
1059 	struct midi_dev *md;
1060 	u_char *msg;
1061 	int len;
1062 {
1063 	int unit = md->unit;
1064 	seq_event_rec ev;
1065 	int status, chan;
1066 
1067 	DPRINTFN(2, ("midiseq_in: %p %02x %02x %02x\n",
1068 		     md, msg[0], msg[1], msg[2]));
1069 
1070 	status = MIDI_GET_STATUS(msg[0]);
1071 	chan = MIDI_GET_CHAN(msg[0]);
1072 	switch (status) {
1073 	case MIDI_NOTEON:
1074 		if (msg[2] == 0) {
1075 			status = MIDI_NOTEOFF;
1076 			msg[2] = MIDI_HALF_VEL;
1077 		}
1078 		/* fall into */
1079 	case MIDI_NOTEOFF:
1080 	case MIDI_KEY_PRESSURE:
1081 		SEQ_MK_CHN_VOICE(&ev, unit, status, chan, msg[1], msg[2]);
1082 		break;
1083 	case MIDI_CTL_CHANGE:
1084 		SEQ_MK_CHN_COMMON(&ev, unit, status, chan, msg[1], 0, msg[2]);
1085 		break;
1086 	case MIDI_PGM_CHANGE:
1087 	case MIDI_CHN_PRESSURE:
1088 		SEQ_MK_CHN_COMMON(&ev, unit, status, chan, msg[1], 0, 0);
1089 		break;
1090 	case MIDI_PITCH_BEND:
1091 		SEQ_MK_CHN_COMMON(&ev, unit, status, chan, 0, 0,
1092 				  (msg[1] & 0x7f) | ((msg[2] & 0x7f) << 7));
1093 		break;
1094 	default:
1095 		return;
1096 	}
1097 	seq_event_intr(md->seq, &ev);
1098 }
1099 
1100 struct midi_dev *
1101 midiseq_open(unit, flags)
1102 	int unit;
1103 	int flags;
1104 {
1105 	extern struct cfdriver midi_cd;
1106 	extern const struct cdevsw midi_cdevsw;
1107 	int error;
1108 	struct midi_dev *md;
1109 	struct midi_softc *sc;
1110 	struct midi_info mi;
1111 
1112 	DPRINTFN(2, ("midiseq_open: %d %d\n", unit, flags));
1113 	error = (*midi_cdevsw.d_open)(makedev(0, unit), flags, 0, 0);
1114 	if (error)
1115 		return (0);
1116 	sc = midi_cd.cd_devs[unit];
1117 	sc->seqopen = 1;
1118 	md = malloc(sizeof *md, M_DEVBUF, M_WAITOK|M_ZERO);
1119 	sc->seq_md = md;
1120 	md->msc = sc;
1121 	midi_getinfo(makedev(0, unit), &mi);
1122 	md->unit = unit;
1123 	md->name = mi.name;
1124 	md->subtype = 0;
1125 	md->nr_voices = 128;	/* XXX */
1126 	md->instr_bank_size = 128; /* XXX */
1127 	if (mi.props & MIDI_PROP_CAN_INPUT)
1128 		md->capabilities |= SYNTH_CAP_INPUT;
1129 	return (md);
1130 }
1131 
1132 void
1133 midiseq_close(md)
1134 	struct midi_dev *md;
1135 {
1136 	extern const struct cdevsw midi_cdevsw;
1137 
1138 	DPRINTFN(2, ("midiseq_close: %d\n", md->unit));
1139 	(*midi_cdevsw.d_close)(makedev(0, md->unit), 0, 0, 0);
1140 	free(md, M_DEVBUF);
1141 }
1142 
1143 void
1144 midiseq_reset(md)
1145 	struct midi_dev *md;
1146 {
1147 	/* XXX send GM reset? */
1148 	DPRINTFN(3, ("midiseq_reset: %d\n", md->unit));
1149 }
1150 
1151 int
1152 midiseq_out(md, buf, cc, chk)
1153 	struct midi_dev *md;
1154 	u_char *buf;
1155 	u_int cc;
1156 	int chk;
1157 {
1158 	DPRINTFN(5, ("midiseq_out: m=%p, unit=%d, buf[0]=0x%02x, cc=%d\n",
1159 		     md->msc, md->unit, buf[0], cc));
1160 
1161 	/* The MIDI "status" byte does not have to be repeated. */
1162 	if (chk && md->last_cmd == buf[0])
1163 		buf++, cc--;
1164 	else
1165 		md->last_cmd = buf[0];
1166 	return midi_writebytes(md->unit, buf, cc);
1167 }
1168 
1169 int
1170 midiseq_noteon(md, chan, note, vel)
1171 	struct midi_dev *md;
1172 	int chan, note, vel;
1173 {
1174 	u_char buf[3];
1175 
1176 	DPRINTFN(6, ("midiseq_noteon 0x%02x %d %d\n",
1177 		     MIDI_NOTEON | chan, note, vel));
1178 	if (chan < 0 || chan > 15 ||
1179 	    note < 0 || note > 127)
1180 		return EINVAL;
1181 	if (vel < 0) vel = 0;
1182 	if (vel > 127) vel = 127;
1183 	buf[0] = MIDI_NOTEON | chan;
1184 	buf[1] = note;
1185 	buf[2] = vel;
1186 	return midiseq_out(md, buf, 3, 1);
1187 }
1188 
1189 int
1190 midiseq_noteoff(md, chan, note, vel)
1191 	struct midi_dev *md;
1192 	int chan, note, vel;
1193 {
1194 	u_char buf[3];
1195 
1196 	if (chan < 0 || chan > 15 ||
1197 	    note < 0 || note > 127)
1198 		return EINVAL;
1199 	if (vel < 0) vel = 0;
1200 	if (vel > 127) vel = 127;
1201 	buf[0] = MIDI_NOTEOFF | chan;
1202 	buf[1] = note;
1203 	buf[2] = vel;
1204 	return midiseq_out(md, buf, 3, 1);
1205 }
1206 
1207 int
1208 midiseq_keypressure(md, chan, note, vel)
1209 	struct midi_dev *md;
1210 	int chan, note, vel;
1211 {
1212 	u_char buf[3];
1213 
1214 	if (chan < 0 || chan > 15 ||
1215 	    note < 0 || note > 127)
1216 		return EINVAL;
1217 	if (vel < 0) vel = 0;
1218 	if (vel > 127) vel = 127;
1219 	buf[0] = MIDI_KEY_PRESSURE | chan;
1220 	buf[1] = note;
1221 	buf[2] = vel;
1222 	return midiseq_out(md, buf, 3, 1);
1223 }
1224 
1225 int
1226 midiseq_pgmchange(md, chan, parm)
1227 	struct midi_dev *md;
1228 	int chan, parm;
1229 {
1230 	u_char buf[2];
1231 
1232 	if (chan < 0 || chan > 15 ||
1233 	    parm < 0 || parm > 127)
1234 		return EINVAL;
1235 	buf[0] = MIDI_PGM_CHANGE | chan;
1236 	buf[1] = parm;
1237 	return midiseq_out(md, buf, 2, 1);
1238 }
1239 
1240 int
1241 midiseq_chnpressure(md, chan, parm)
1242 	struct midi_dev *md;
1243 	int chan, parm;
1244 {
1245 	u_char buf[2];
1246 
1247 	if (chan < 0 || chan > 15 ||
1248 	    parm < 0 || parm > 127)
1249 		return EINVAL;
1250 	buf[0] = MIDI_CHN_PRESSURE | chan;
1251 	buf[1] = parm;
1252 	return midiseq_out(md, buf, 2, 1);
1253 }
1254 
1255 int
1256 midiseq_ctlchange(md, chan, parm, w14)
1257 	struct midi_dev *md;
1258 	int chan, parm, w14;
1259 {
1260 	u_char buf[3];
1261 
1262 	if (chan < 0 || chan > 15 ||
1263 	    parm < 0 || parm > 127)
1264 		return EINVAL;
1265 	buf[0] = MIDI_CTL_CHANGE | chan;
1266 	buf[1] = parm;
1267 	buf[2] = w14 & 0x7f;
1268 	return midiseq_out(md, buf, 3, 1);
1269 }
1270 
1271 int
1272 midiseq_pitchbend(md, chan, parm)
1273 	struct midi_dev *md;
1274 	int chan, parm;
1275 {
1276 	u_char buf[3];
1277 
1278 	if (chan < 0 || chan > 15)
1279 		return EINVAL;
1280 	buf[0] = MIDI_PITCH_BEND | chan;
1281 	buf[1] = parm & 0x7f;
1282 	buf[2] = (parm >> 7) & 0x7f;
1283 	return midiseq_out(md, buf, 3, 1);
1284 }
1285 
1286 int
1287 midiseq_loadpatch(md, sysex, uio)
1288 	struct midi_dev *md;
1289 	struct sysex_info *sysex;
1290 	struct uio *uio;
1291 {
1292 	u_char c, buf[128];
1293 	int i, cc, error;
1294 
1295 	if (sysex->key != SEQ_SYSEX_PATCH) {
1296 		DPRINTFN(-1,("midiseq_loadpatch: bad patch key 0x%04x\n",
1297 			     sysex->key));
1298 		return (EINVAL);
1299 	}
1300 	if (uio->uio_resid < sysex->len)
1301 		/* adjust length, should be an error */
1302 		sysex->len = uio->uio_resid;
1303 
1304 	DPRINTFN(2, ("midiseq_loadpatch: len=%d\n", sysex->len));
1305 	if (sysex->len == 0)
1306 		return EINVAL;
1307 	error = uiomove(&c, 1, uio);
1308 	if (error)
1309 		return error;
1310 	if (c != MIDI_SYSEX_START)		/* must start like this */
1311 		return EINVAL;
1312 	error = midiseq_out(md, &c, 1, 0);
1313 	if (error)
1314 		return error;
1315 	--sysex->len;
1316 	while (sysex->len > 0) {
1317 		cc = sysex->len;
1318 		if (cc > sizeof buf)
1319 			cc = sizeof buf;
1320 		error = uiomove(buf, cc, uio);
1321 		if (error)
1322 			break;
1323 		for(i = 0; i < cc && !MIDI_IS_STATUS(buf[i]); i++)
1324 			;
1325 		error = midiseq_out(md, buf, i, 0);
1326 		if (error)
1327 			break;
1328 		sysex->len -= i;
1329 		if (i != cc)
1330 			break;
1331 	}
1332 	/* Any leftover data in uio is rubbish;
1333 	 * the SYSEX should be one write ending in SYSEX_END.
1334 	 */
1335 	uio->uio_resid = 0;
1336 	c = MIDI_SYSEX_END;
1337 	return midiseq_out(md, &c, 1, 0);
1338 }
1339 
1340 int
1341 midiseq_putc(md, data)
1342 	struct midi_dev *md;
1343 	int data;
1344 {
1345 	u_char c = data;
1346 	DPRINTFN(4,("midiseq_putc: 0x%02x\n", data));
1347 	return midiseq_out(md, &c, 1, 0);
1348 }
1349 
1350 #include "midi.h"
1351 #if NMIDI == 0
1352 dev_type_open(midiopen);
1353 dev_type_close(midiclose);
1354 
1355 const struct cdevsw midi_cdevsw = {
1356 	midiopen, midiclose, noread, nowrite, noioctl,
1357 	nostop, notty, nopoll, nommap,
1358 };
1359 
1360 /*
1361  * If someone has a sequencer, but no midi devices there will
1362  * be unresolved references, so we provide little stubs.
1363  */
1364 
1365 int
1366 midi_unit_count()
1367 {
1368 	return (0);
1369 }
1370 
1371 int
1372 midiopen(dev, flags, ifmt, p)
1373 	dev_t dev;
1374 	int flags, ifmt;
1375 	struct proc *p;
1376 {
1377 	return (ENXIO);
1378 }
1379 
1380 struct cfdriver midi_cd;
1381 
1382 void
1383 midi_getinfo(dev, mi)
1384 	dev_t dev;
1385 	struct midi_info *mi;
1386 {
1387 }
1388 
1389 int
1390 midiclose(dev, flags, ifmt, p)
1391 	dev_t dev;
1392 	int flags, ifmt;
1393 	struct proc *p;
1394 {
1395 	return (ENXIO);
1396 }
1397 
1398 int
1399 midi_writebytes(unit, buf, cc)
1400 	int unit;
1401 	u_char *buf;
1402 	int cc;
1403 {
1404 	return (ENXIO);
1405 }
1406 #endif /* NMIDI == 0 */
1407