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