sequencer.c revision 1.30.14.16
1 /* $NetBSD: sequencer.c,v 1.30.14.16 2006/05/20 04:31:59 chap 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: sequencer.c,v 1.30.14.16 2006/05/20 04:31:59 chap 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(int); 115 void seq_reset(struct sequencer_softc *); 116 int seq_do_command(struct sequencer_softc *, seq_event_rec *); 117 int seq_do_extcommand(struct sequencer_softc *, seq_event_rec *); 118 int seq_do_chnvoice(struct sequencer_softc *, seq_event_rec *); 119 int seq_do_chncommon(struct sequencer_softc *, seq_event_rec *); 120 int seq_do_timing(struct sequencer_softc *, seq_event_rec *); 121 int seq_do_local(struct sequencer_softc *, seq_event_rec *); 122 int seq_do_sysex(struct sequencer_softc *, seq_event_rec *); 123 int seq_do_fullsize(struct sequencer_softc *, seq_event_rec *, struct uio *); 124 int seq_timer(struct sequencer_softc *, int, int, seq_event_rec *); 125 static int seq_input_event(struct sequencer_softc *, seq_event_rec *); 126 int seq_drain(struct sequencer_softc *); 127 void seq_startoutput(struct sequencer_softc *); 128 void seq_timeout(void *); 129 int seq_to_new(seq_event_rec *, struct uio *); 130 static int seq_sleep_timo(int *, const char *, int); 131 static int seq_sleep(int *, const char *); 132 static void seq_wakeup(int *); 133 134 struct midi_softc; 135 int midiseq_out(struct midi_dev *, u_char *, u_int, int); 136 struct midi_dev *midiseq_open(int, int); 137 void midiseq_close(struct midi_dev *); 138 void midiseq_reset(struct midi_dev *); 139 int midiseq_noteon(struct midi_dev *, int, int, int); 140 int midiseq_noteoff(struct midi_dev *, int, int, int); 141 int midiseq_keypressure(struct midi_dev *, int, int, int); 142 int midiseq_pgmchange(struct midi_dev *, int, int); 143 int midiseq_chnpressure(struct midi_dev *, int, int); 144 int midiseq_ctlchange(struct midi_dev *, int, int, int); 145 int midiseq_pitchbend(struct midi_dev *, int, int); 146 int midiseq_loadpatch(struct midi_dev *, struct sysex_info *, struct uio *); 147 int midiseq_putc(struct midi_dev *, int); 148 void midiseq_in(struct midi_dev *, u_char *, int); 149 150 dev_type_open(sequenceropen); 151 dev_type_close(sequencerclose); 152 dev_type_read(sequencerread); 153 dev_type_write(sequencerwrite); 154 dev_type_ioctl(sequencerioctl); 155 dev_type_poll(sequencerpoll); 156 dev_type_kqfilter(sequencerkqfilter); 157 158 const struct cdevsw sequencer_cdevsw = { 159 sequenceropen, sequencerclose, sequencerread, sequencerwrite, 160 sequencerioctl, nostop, notty, sequencerpoll, nommap, 161 sequencerkqfilter, 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, l) 175 dev_t dev; 176 int flags, ifmt; 177 struct lwp *l; 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 const 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 const 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 selnotify(&sc->wsel, 0); 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, l) 323 dev_t dev; 324 int flags, ifmt; 325 struct lwp *l; 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 selnotify(&sc->rsel, 0); 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, l) 492 dev_t dev; 493 u_long cmd; 494 caddr_t addr; 495 int flag; 496 struct lwp *l; 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 = l->l_proc; 518 DPRINTF(("sequencer_ioctl: FIOASYNC %p\n", l)); 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 if ( !(sc->flags & FWRITE ) ) 568 return EBADF; 569 error = seq_do_command(sc, (seq_event_rec *)addr); 570 break; 571 572 case SEQUENCER_TMR_TIMEBASE: 573 t = *(int *)addr; 574 if (t < 1) 575 t = 1; 576 if (t > 10000) 577 t = 10000; 578 sc->timer.timebase = t; 579 *(int *)addr = t; 580 RECALC_TICK(&sc->timer); 581 break; 582 583 case SEQUENCER_TMR_START: 584 error = seq_timer(sc, TMR_START, 0, 0); 585 break; 586 587 case SEQUENCER_TMR_STOP: 588 error = seq_timer(sc, TMR_STOP, 0, 0); 589 break; 590 591 case SEQUENCER_TMR_CONTINUE: 592 error = seq_timer(sc, TMR_CONTINUE, 0, 0); 593 break; 594 595 case SEQUENCER_TMR_TEMPO: 596 t = *(int *)addr; 597 if (t < 8) 598 t = 8; 599 if (t > 250) 600 t = 250; 601 sc->timer.tempo = t; 602 *(int *)addr = t; 603 RECALC_TICK(&sc->timer); 604 break; 605 606 case SEQUENCER_TMR_SOURCE: 607 *(int *)addr = SEQUENCER_TMR_INTERNAL; 608 break; 609 610 case SEQUENCER_TMR_METRONOME: 611 /* noop */ 612 break; 613 614 case SEQUENCER_THRESHOLD: 615 t = SEQ_MAXQ - *(int *)addr / sizeof (seq_event_rec); 616 if (t < 1) 617 t = 1; 618 if (t > SEQ_MAXQ) 619 t = SEQ_MAXQ; 620 sc->lowat = t; 621 break; 622 623 case SEQUENCER_CTRLRATE: 624 *(int *)addr = (sc->timer.tempo*sc->timer.timebase + 30) / 60; 625 break; 626 627 case SEQUENCER_GETTIME: 628 { 629 struct timeval now; 630 u_long tx; 631 microtime(&now); 632 SUBTIMEVAL(&now, &sc->timer.start); 633 tx = now.tv_sec * 1000000 + now.tv_usec; 634 tx /= sc->timer.tick; 635 *(int *)addr = tx; 636 break; 637 } 638 639 default: 640 DPRINTFN(-1,("sequencer_ioctl: unimpl %08lx\n", cmd)); 641 error = EINVAL; 642 break; 643 } 644 return error; 645 } 646 647 int 648 sequencerpoll(dev, events, l) 649 dev_t dev; 650 int events; 651 struct lwp *l; 652 { 653 struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)]; 654 int revents = 0; 655 656 DPRINTF(("sequencerpoll: %p events=0x%x\n", sc, events)); 657 658 if (events & (POLLIN | POLLRDNORM)) 659 if ((sc->flags&FREAD) && !SEQ_QEMPTY(&sc->inq)) 660 revents |= events & (POLLIN | POLLRDNORM); 661 662 if (events & (POLLOUT | POLLWRNORM)) 663 if ((sc->flags&FWRITE) && SEQ_QLEN(&sc->outq) < sc->lowat) 664 revents |= events & (POLLOUT | POLLWRNORM); 665 666 if (revents == 0) { 667 if ((sc->flags&FREAD) && (events & (POLLIN | POLLRDNORM))) 668 selrecord(l, &sc->rsel); 669 670 if ((sc->flags&FWRITE) && (events & (POLLOUT | POLLWRNORM))) 671 selrecord(l, &sc->wsel); 672 } 673 674 return revents; 675 } 676 677 static void 678 filt_sequencerrdetach(struct knote *kn) 679 { 680 struct sequencer_softc *sc = kn->kn_hook; 681 int s; 682 683 s = splaudio(); 684 SLIST_REMOVE(&sc->rsel.sel_klist, kn, knote, kn_selnext); 685 splx(s); 686 } 687 688 static int 689 filt_sequencerread(struct knote *kn, long hint) 690 { 691 struct sequencer_softc *sc = kn->kn_hook; 692 693 /* XXXLUKEM (thorpej): make sure this is correct */ 694 695 if (SEQ_QEMPTY(&sc->inq)) 696 return (0); 697 kn->kn_data = sizeof(seq_event_rec); 698 return (1); 699 } 700 701 static const struct filterops sequencerread_filtops = 702 { 1, NULL, filt_sequencerrdetach, filt_sequencerread }; 703 704 static void 705 filt_sequencerwdetach(struct knote *kn) 706 { 707 struct sequencer_softc *sc = kn->kn_hook; 708 int s; 709 710 s = splaudio(); 711 SLIST_REMOVE(&sc->wsel.sel_klist, kn, knote, kn_selnext); 712 splx(s); 713 } 714 715 static int 716 filt_sequencerwrite(struct knote *kn, long hint) 717 { 718 struct sequencer_softc *sc = kn->kn_hook; 719 720 /* XXXLUKEM (thorpej): make sure this is correct */ 721 722 if (SEQ_QLEN(&sc->outq) >= sc->lowat) 723 return (0); 724 kn->kn_data = sizeof(seq_event_rec); 725 return (1); 726 } 727 728 static const struct filterops sequencerwrite_filtops = 729 { 1, NULL, filt_sequencerwdetach, filt_sequencerwrite }; 730 731 int 732 sequencerkqfilter(dev_t dev, struct knote *kn) 733 { 734 struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)]; 735 struct klist *klist; 736 int s; 737 738 switch (kn->kn_filter) { 739 case EVFILT_READ: 740 klist = &sc->rsel.sel_klist; 741 kn->kn_fop = &sequencerread_filtops; 742 break; 743 744 case EVFILT_WRITE: 745 klist = &sc->wsel.sel_klist; 746 kn->kn_fop = &sequencerwrite_filtops; 747 break; 748 749 default: 750 return (1); 751 } 752 753 kn->kn_hook = sc; 754 755 s = splaudio(); 756 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 757 splx(s); 758 759 return (0); 760 } 761 762 void 763 seq_reset(sc) 764 struct sequencer_softc *sc; 765 { 766 int i, chn; 767 struct midi_dev *md; 768 769 if ( !(sc->flags & FWRITE) ) 770 return; 771 for (i = 0; i < sc->nmidi; i++) { 772 md = sc->devs[i]; 773 midiseq_reset(md); 774 for (chn = 0; chn < MAXCHAN; chn++) { 775 midiseq_ctlchange(md, chn, MIDI_CTRL_ALLOFF, 0); 776 midiseq_ctlchange(md, chn, MIDI_CTRL_RESET, 0); 777 midiseq_pitchbend(md, chn, MIDI_BEND_NEUTRAL); 778 } 779 } 780 } 781 782 int 783 seq_do_command(sc, b) 784 struct sequencer_softc *sc; 785 seq_event_rec *b; 786 { 787 int dev; 788 789 DPRINTFN(4, ("seq_do_command: %p cmd=0x%02x\n", sc, SEQ_CMD(b))); 790 791 switch(SEQ_CMD(b)) { 792 case SEQ_LOCAL: 793 return seq_do_local(sc, b); 794 case SEQ_TIMING: 795 return seq_do_timing(sc, b); 796 case SEQ_CHN_VOICE: 797 return seq_do_chnvoice(sc, b); 798 case SEQ_CHN_COMMON: 799 return seq_do_chncommon(sc, b); 800 case SEQ_SYSEX: 801 return seq_do_sysex(sc, b); 802 /* COMPAT */ 803 case SEQOLD_MIDIPUTC: 804 dev = b->arr[2]; 805 if (dev < 0 || dev >= sc->nmidi) 806 return (ENXIO); 807 return midiseq_putc(sc->devs[dev], b->arr[1]); 808 default: 809 DPRINTFN(-1,("seq_do_command: unimpl command %02x\n", 810 SEQ_CMD(b))); 811 return (EINVAL); 812 } 813 } 814 815 int 816 seq_do_chnvoice(sc, b) 817 struct sequencer_softc *sc; 818 seq_event_rec *b; 819 { 820 int cmd, dev, chan, note, parm, voice; 821 int error; 822 struct midi_dev *md; 823 824 dev = SEQ_EDEV(b); 825 if (dev < 0 || dev >= sc->nmidi) 826 return ENXIO; 827 md = sc->devs[dev]; 828 cmd = SEQ_ECMD(b); 829 chan = SEQ_ECHAN(b); 830 note = SEQ_ENOTE(b); 831 parm = SEQ_EPARM(b); 832 DPRINTFN(2,("seq_do_chnvoice: cmd=%02x dev=%d chan=%d note=%d parm=%d\n", 833 cmd, dev, chan, note, parm)); 834 voice = chan; 835 if (cmd == MIDI_NOTEON && parm == 0) { 836 cmd = MIDI_NOTEOFF; 837 parm = MIDI_HALF_VEL; 838 } 839 switch(cmd) { 840 case MIDI_NOTEON: 841 DPRINTFN(5, ("seq_do_chnvoice: noteon %p %d %d %d\n", 842 md, voice, note, parm)); 843 error = midiseq_noteon(md, voice, note, parm); 844 break; 845 case MIDI_NOTEOFF: 846 error = midiseq_noteoff(md, voice, note, parm); 847 break; 848 case MIDI_KEY_PRESSURE: 849 error = midiseq_keypressure(md, voice, note, parm); 850 break; 851 default: 852 DPRINTFN(-1,("seq_do_chnvoice: unimpl command %02x\n", cmd)); 853 error = EINVAL; 854 break; 855 } 856 return error; 857 } 858 859 int 860 seq_do_chncommon(sc, b) 861 struct sequencer_softc *sc; 862 seq_event_rec *b; 863 { 864 int cmd, dev, chan, p1, w14; 865 int error; 866 struct midi_dev *md; 867 union { 868 int16_t s; 869 u_int8_t b[2]; 870 } u; 871 872 dev = SEQ_EDEV(b); 873 if (dev < 0 || dev >= sc->nmidi) 874 return ENXIO; 875 md = sc->devs[dev]; 876 cmd = SEQ_ECMD(b); 877 chan = SEQ_ECHAN(b); 878 p1 = SEQ_EP1(b); 879 u.b[0] = b->arr[6]; 880 u.b[1] = b->arr[7]; 881 w14 = u.s; 882 DPRINTFN(2,("seq_do_chncommon: %02x\n", cmd)); 883 884 error = 0; 885 switch(cmd) { 886 case MIDI_PGM_CHANGE: 887 error = midiseq_pgmchange(md, chan, p1); 888 break; 889 case MIDI_CTL_CHANGE: 890 if (chan > 15 || p1 > 127) 891 return 0; /* EINVAL */ 892 error = midiseq_ctlchange(md, chan, p1, w14); 893 break; 894 case MIDI_PITCH_BEND: 895 error = midiseq_pitchbend(md, chan, w14); 896 break; 897 case MIDI_CHN_PRESSURE: 898 error = midiseq_chnpressure(md, chan, p1); 899 break; 900 default: 901 DPRINTFN(-1,("seq_do_chncommon: unimpl command %02x\n", cmd)); 902 error = EINVAL; 903 break; 904 } 905 return (error); 906 } 907 908 int 909 seq_do_timing(sc, b) 910 struct sequencer_softc *sc; 911 seq_event_rec *b; 912 { 913 union { 914 int32_t i; 915 u_int8_t b[4]; 916 } u; 917 u.b[0] = b->arr[4]; 918 u.b[1] = b->arr[5]; 919 u.b[2] = b->arr[6]; 920 u.b[3] = b->arr[7]; 921 return seq_timer(sc, SEQ_TCMD(b), u.i, b); 922 } 923 924 int 925 seq_do_local(sc, b) 926 struct sequencer_softc *sc; 927 seq_event_rec *b; 928 { 929 return (EINVAL); 930 } 931 932 int 933 seq_do_sysex(sc, b) 934 struct sequencer_softc *sc; 935 seq_event_rec *b; 936 { 937 int dev, i; 938 struct midi_dev *md; 939 u_int8_t c, *bf = &b->arr[2]; 940 941 dev = SEQ_EDEV(b); 942 if (dev < 0 || dev >= sc->nmidi) 943 return (ENXIO); 944 DPRINTF(("seq_do_sysex: dev=%d\n", dev)); 945 md = sc->devs[dev]; 946 947 if (!sc->doingsysex) { 948 c = MIDI_SYSEX_START; 949 midiseq_out(md, &c, 1, 0); 950 sc->doingsysex = 1; 951 } 952 953 for (i = 0; i < 6 && bf[i] != 0xff; i++) 954 ; 955 midiseq_out(md, bf, i, 0); 956 if (i < 6 || (i > 0 && bf[i-1] == MIDI_SYSEX_END)) 957 sc->doingsysex = 0; 958 return (0); 959 } 960 961 int 962 seq_timer(sc, cmd, parm, b) 963 struct sequencer_softc *sc; 964 int cmd, parm; 965 seq_event_rec *b; 966 { 967 struct syn_timer *t = &sc->timer; 968 struct timeval when; 969 int ticks; 970 int error; 971 long long usec; 972 973 DPRINTFN(2,("seq_timer: %02x %d\n", cmd, parm)); 974 975 error = 0; 976 switch(cmd) { 977 case TMR_WAIT_REL: 978 parm += t->last; 979 /* fall into */ 980 case TMR_WAIT_ABS: 981 t->last = parm; 982 usec = (long long)parm * (long long)t->tick; /* convert to usec */ 983 when.tv_sec = usec / 1000000; 984 when.tv_usec = usec % 1000000; 985 DPRINTFN(4, ("seq_timer: parm=%d, sleep when=%ld.%06ld", parm, 986 when.tv_sec, when.tv_usec)); 987 ADDTIMEVAL(&when, &t->start); /* abstime for end */ 988 ticks = hzto(&when); 989 DPRINTFN(4, (" when+start=%ld.%06ld, tick=%d\n", 990 when.tv_sec, when.tv_usec, ticks)); 991 if (ticks > 0) { 992 #ifdef DIAGNOSTIC 993 if (ticks > 20 * hz) { 994 /* Waiting more than 20s */ 995 printf("seq_timer: funny ticks=%d, usec=%lld, parm=%d, tick=%ld\n", 996 ticks, usec, parm, t->tick); 997 } 998 #endif 999 sc->timeout = 1; 1000 callout_reset(&sc->sc_callout, ticks, 1001 seq_timeout, sc); 1002 } 1003 #ifdef SEQUENCER_DEBUG 1004 else if (tick < 0) 1005 DPRINTF(("seq_timer: ticks = %d\n", ticks)); 1006 #endif 1007 break; 1008 case TMR_START: 1009 microtime(&t->start); 1010 t->running = 1; 1011 break; 1012 case TMR_STOP: 1013 microtime(&t->stop); 1014 t->running = 0; 1015 break; 1016 case TMR_CONTINUE: 1017 microtime(&when); 1018 SUBTIMEVAL(&when, &t->stop); 1019 ADDTIMEVAL(&t->start, &when); 1020 t->running = 1; 1021 break; 1022 case TMR_TEMPO: 1023 /* parm is ticks per minute / timebase */ 1024 if (parm < 8) 1025 parm = 8; 1026 if (parm > 360) 1027 parm = 360; 1028 t->tempo = parm; 1029 RECALC_TICK(t); 1030 break; 1031 case TMR_ECHO: 1032 error = seq_input_event(sc, b); 1033 break; 1034 case TMR_RESET: 1035 t->last = 0; 1036 microtime(&t->start); 1037 break; 1038 default: 1039 DPRINTF(("seq_timer: unknown %02x\n", cmd)); 1040 error = EINVAL; 1041 break; 1042 } 1043 return (error); 1044 } 1045 1046 int 1047 seq_do_fullsize(sc, b, uio) 1048 struct sequencer_softc *sc; 1049 seq_event_rec *b; 1050 struct uio *uio; 1051 { 1052 struct sysex_info sysex; 1053 u_int dev; 1054 1055 #ifdef DIAGNOSTIC 1056 if (sizeof(seq_event_rec) != SEQ_SYSEX_HDRSIZE) { 1057 printf("seq_do_fullsize: sysex size ??\n"); 1058 return EINVAL; 1059 } 1060 #endif 1061 memcpy(&sysex, b, sizeof sysex); 1062 dev = sysex.device_no; 1063 DPRINTFN(2, ("seq_do_fullsize: fmt=%04x, dev=%d, len=%d\n", 1064 sysex.key, dev, sysex.len)); 1065 return (midiseq_loadpatch(sc->devs[dev], &sysex, uio)); 1066 } 1067 1068 /* Convert an old sequencer event to a new one. */ 1069 int 1070 seq_to_new(ev, uio) 1071 seq_event_rec *ev; 1072 struct uio *uio; 1073 { 1074 int cmd, chan, note, parm; 1075 u_int32_t tmp_delay; 1076 int error; 1077 1078 cmd = SEQ_CMD(ev); 1079 chan = ev->arr[1]; 1080 note = ev->arr[2]; 1081 parm = ev->arr[3]; 1082 DPRINTFN(3, ("seq_to_new: 0x%02x %d %d %d\n", cmd, chan, note, parm)); 1083 1084 if (cmd >= 0x80) { 1085 /* Fill the event record */ 1086 if (uio->uio_resid >= sizeof *ev - SEQOLD_CMDSIZE) { 1087 error = uiomove(&ev->arr[SEQOLD_CMDSIZE], 1088 sizeof *ev - SEQOLD_CMDSIZE, uio); 1089 if (error) 1090 return error; 1091 } else 1092 return EINVAL; 1093 } 1094 1095 switch(cmd) { 1096 case SEQOLD_NOTEOFF: 1097 note = 255; 1098 SEQ_ECMD(ev) = MIDI_NOTEOFF; 1099 goto onoff; 1100 case SEQOLD_NOTEON: 1101 SEQ_ECMD(ev) = MIDI_NOTEON; 1102 onoff: 1103 SEQ_CMD(ev) = SEQ_CHN_VOICE; 1104 SEQ_EDEV(ev) = 0; 1105 SEQ_ECHAN(ev) = chan; 1106 SEQ_ENOTE(ev) = note; 1107 SEQ_EPARM(ev) = parm; 1108 break; 1109 case SEQOLD_WAIT: 1110 tmp_delay = *(u_int32_t *)ev->arr >> 8; 1111 SEQ_CMD(ev) = SEQ_TIMING; 1112 SEQ_TCMD(ev) = TMR_WAIT_REL; 1113 *(u_int32_t *)&ev->arr[4] = tmp_delay; 1114 break; 1115 case SEQOLD_SYNCTIMER: 1116 SEQ_CMD(ev) = SEQ_TIMING; 1117 SEQ_TCMD(ev) = TMR_RESET; 1118 break; 1119 case SEQOLD_PGMCHANGE: 1120 SEQ_ECMD(ev) = MIDI_PGM_CHANGE; 1121 SEQ_CMD(ev) = SEQ_CHN_COMMON; 1122 SEQ_EDEV(ev) = 0; 1123 SEQ_ECHAN(ev) = chan; 1124 SEQ_EP1(ev) = note; 1125 break; 1126 case SEQOLD_MIDIPUTC: 1127 break; /* interpret in normal mode */ 1128 case SEQOLD_ECHO: 1129 case SEQOLD_PRIVATE: 1130 case SEQOLD_EXTENDED: 1131 default: 1132 DPRINTF(("seq_to_new: not impl 0x%02x\n", cmd)); 1133 return EINVAL; 1134 /* In case new events show up */ 1135 case SEQ_TIMING: 1136 case SEQ_CHN_VOICE: 1137 case SEQ_CHN_COMMON: 1138 case SEQ_FULLSIZE: 1139 break; 1140 } 1141 return 0; 1142 } 1143 1144 /**********************************************/ 1145 1146 void 1147 midiseq_in(md, msg, len) 1148 struct midi_dev *md; 1149 u_char *msg; 1150 int len; 1151 { 1152 int unit = md->unit; 1153 seq_event_rec ev; 1154 int status, chan; 1155 1156 DPRINTFN(2, ("midiseq_in: %p %02x %02x %02x\n", 1157 md, msg[0], msg[1], msg[2])); 1158 1159 status = MIDI_GET_STATUS(msg[0]); 1160 chan = MIDI_GET_CHAN(msg[0]); 1161 switch (status) { 1162 case MIDI_NOTEON: /* midi(4) always canonicalizes NoteOn velocity 0 */ 1163 case MIDI_NOTEOFF: /* to NoteOff velocity 64. */ 1164 case MIDI_KEY_PRESSURE: 1165 SEQ_MK_CHN_VOICE(&ev, unit, status, chan, msg[1], msg[2]); 1166 break; 1167 case MIDI_CTL_CHANGE: /* XXX not correct for MSB */ 1168 SEQ_MK_CHN_COMMON(&ev, unit, status, chan, msg[1], 0, msg[2]); 1169 break; 1170 case MIDI_PGM_CHANGE: 1171 case MIDI_CHN_PRESSURE: 1172 SEQ_MK_CHN_COMMON(&ev, unit, status, chan, msg[1], 0, 0); 1173 break; 1174 case MIDI_PITCH_BEND: 1175 SEQ_MK_CHN_COMMON(&ev, unit, status, chan, 0, 0, 1176 (msg[1] & 0x7f) | ((msg[2] & 0x7f) << 7)); 1177 break; 1178 default: /* this is now the point where MIDI_ACKs disappear */ 1179 return; 1180 } 1181 seq_event_intr(md->seq, &ev); 1182 } 1183 1184 struct midi_dev * 1185 midiseq_open(unit, flags) 1186 int unit; 1187 int flags; 1188 { 1189 extern struct cfdriver midi_cd; 1190 extern const struct cdevsw midi_cdevsw; 1191 int error; 1192 struct midi_dev *md; 1193 struct midi_softc *sc; 1194 struct midi_info mi; 1195 1196 midi_getinfo(makedev(0, unit), &mi); 1197 if ( !(mi.props & MIDI_PROP_CAN_INPUT) ) 1198 flags &= ~FREAD; 1199 if ( 0 == ( flags & ( FREAD | FWRITE ) ) ) 1200 return 0; 1201 DPRINTFN(2, ("midiseq_open: %d %d\n", unit, flags)); 1202 error = (*midi_cdevsw.d_open)(makedev(0, unit), flags, 0, 0); 1203 if (error) 1204 return (0); 1205 sc = midi_cd.cd_devs[unit]; 1206 sc->seqopen = 1; 1207 md = malloc(sizeof *md, M_DEVBUF, M_WAITOK|M_ZERO); 1208 sc->seq_md = md; 1209 md->msc = sc; 1210 md->unit = unit; 1211 md->name = mi.name; 1212 md->subtype = 0; 1213 md->nr_voices = 128; /* XXX */ 1214 md->instr_bank_size = 128; /* XXX */ 1215 if (mi.props & MIDI_PROP_CAN_INPUT) 1216 md->capabilities |= SYNTH_CAP_INPUT; 1217 return (md); 1218 } 1219 1220 void 1221 midiseq_close(md) 1222 struct midi_dev *md; 1223 { 1224 extern const struct cdevsw midi_cdevsw; 1225 1226 DPRINTFN(2, ("midiseq_close: %d\n", md->unit)); 1227 (*midi_cdevsw.d_close)(makedev(0, md->unit), 0, 0, 0); 1228 free(md, M_DEVBUF); 1229 } 1230 1231 void 1232 midiseq_reset(md) 1233 struct midi_dev *md; 1234 { 1235 /* XXX send GM reset? */ 1236 DPRINTFN(3, ("midiseq_reset: %d\n", md->unit)); 1237 } 1238 1239 int 1240 midiseq_out(md, bf, cc, chk) 1241 struct midi_dev *md; 1242 u_char *bf; 1243 u_int cc; 1244 int chk; 1245 { 1246 DPRINTFN(5, ("midiseq_out: m=%p, unit=%d, bf[0]=0x%02x, cc=%d\n", 1247 md->msc, md->unit, bf[0], cc)); 1248 1249 /* midi(4) does running status compression where appropriate. */ 1250 return midi_writebytes(md->unit, bf, cc); 1251 } 1252 1253 int 1254 midiseq_noteon(md, chan, note, vel) 1255 struct midi_dev *md; 1256 int chan, note, vel; 1257 { 1258 u_char bf[3]; 1259 1260 DPRINTFN(6, ("midiseq_noteon 0x%02x %d %d\n", 1261 MIDI_NOTEON | chan, note, vel)); 1262 if (chan < 0 || chan > 15 || 1263 note < 0 || note > 127) 1264 return EINVAL; 1265 if (vel < 0) vel = 0; 1266 if (vel > 127) vel = 127; 1267 bf[0] = MIDI_NOTEON | chan; 1268 bf[1] = note; 1269 bf[2] = vel; 1270 return midiseq_out(md, bf, 3, 1); 1271 } 1272 1273 int 1274 midiseq_noteoff(md, chan, note, vel) 1275 struct midi_dev *md; 1276 int chan, note, vel; 1277 { 1278 u_char bf[3]; 1279 1280 if (chan < 0 || chan > 15 || 1281 note < 0 || note > 127) 1282 return EINVAL; 1283 if (vel < 0) vel = 0; 1284 if (vel > 127) vel = 127; 1285 bf[0] = MIDI_NOTEOFF | chan; 1286 bf[1] = note; 1287 bf[2] = vel; 1288 return midiseq_out(md, bf, 3, 1); 1289 } 1290 1291 int 1292 midiseq_keypressure(md, chan, note, vel) 1293 struct midi_dev *md; 1294 int chan, note, vel; 1295 { 1296 u_char bf[3]; 1297 1298 if (chan < 0 || chan > 15 || 1299 note < 0 || note > 127) 1300 return EINVAL; 1301 if (vel < 0) vel = 0; 1302 if (vel > 127) vel = 127; 1303 bf[0] = MIDI_KEY_PRESSURE | chan; 1304 bf[1] = note; 1305 bf[2] = vel; 1306 return midiseq_out(md, bf, 3, 1); 1307 } 1308 1309 int 1310 midiseq_pgmchange(md, chan, parm) 1311 struct midi_dev *md; 1312 int chan, parm; 1313 { 1314 u_char bf[2]; 1315 1316 if (chan < 0 || chan > 15 || 1317 parm < 0 || parm > 127) 1318 return EINVAL; 1319 bf[0] = MIDI_PGM_CHANGE | chan; 1320 bf[1] = parm; 1321 return midiseq_out(md, bf, 2, 1); 1322 } 1323 1324 int 1325 midiseq_chnpressure(md, chan, parm) 1326 struct midi_dev *md; 1327 int chan, parm; 1328 { 1329 u_char bf[2]; 1330 1331 if (chan < 0 || chan > 15 || 1332 parm < 0 || parm > 127) 1333 return EINVAL; 1334 bf[0] = MIDI_CHN_PRESSURE | chan; 1335 bf[1] = parm; 1336 return midiseq_out(md, bf, 2, 1); 1337 } 1338 1339 int 1340 midiseq_ctlchange(md, chan, parm, w14) 1341 struct midi_dev *md; 1342 int chan, parm, w14; 1343 { 1344 u_char bf[3]; 1345 1346 if (chan < 0 || chan > 15 || 1347 parm < 0 || parm > 127) 1348 return EINVAL; 1349 bf[0] = MIDI_CTL_CHANGE | chan; 1350 bf[1] = parm; 1351 bf[2] = w14 & 0x7f; /* XXX */ 1352 return midiseq_out(md, bf, 3, 1); 1353 } 1354 1355 int 1356 midiseq_pitchbend(md, chan, parm) 1357 struct midi_dev *md; 1358 int chan, parm; 1359 { 1360 u_char bf[3]; 1361 1362 if (chan < 0 || chan > 15) 1363 return EINVAL; 1364 bf[0] = MIDI_PITCH_BEND | chan; 1365 bf[1] = parm & 0x7f; 1366 bf[2] = (parm >> 7) & 0x7f; 1367 return midiseq_out(md, bf, 3, 1); 1368 } 1369 1370 int 1371 midiseq_loadpatch(md, sysex, uio) 1372 struct midi_dev *md; 1373 struct sysex_info *sysex; 1374 struct uio *uio; 1375 { 1376 u_char c, bf[128]; 1377 int i, cc, error; 1378 1379 if (sysex->key != SEQ_SYSEX_PATCH) { 1380 DPRINTFN(-1,("midiseq_loadpatch: bad patch key 0x%04x\n", 1381 sysex->key)); 1382 return (EINVAL); 1383 } 1384 if (uio->uio_resid < sysex->len) 1385 /* adjust length, should be an error */ 1386 sysex->len = uio->uio_resid; 1387 1388 DPRINTFN(2, ("midiseq_loadpatch: len=%d\n", sysex->len)); 1389 if (sysex->len == 0) 1390 return EINVAL; 1391 error = uiomove(&c, 1, uio); 1392 if (error) 1393 return error; 1394 if (c != MIDI_SYSEX_START) /* must start like this */ 1395 return EINVAL; 1396 error = midiseq_out(md, &c, 1, 0); 1397 if (error) 1398 return error; 1399 --sysex->len; 1400 while (sysex->len > 0) { 1401 cc = sysex->len; 1402 if (cc > sizeof bf) 1403 cc = sizeof bf; 1404 error = uiomove(bf, cc, uio); 1405 if (error) 1406 break; 1407 for(i = 0; i < cc && !MIDI_IS_STATUS(bf[i]); i++) 1408 ; 1409 error = midiseq_out(md, bf, i, 0); 1410 if (error) 1411 break; 1412 sysex->len -= i; 1413 if (i != cc) 1414 break; 1415 } 1416 /* Any leftover data in uio is rubbish; 1417 * the SYSEX should be one write ending in SYSEX_END. 1418 */ 1419 uio->uio_resid = 0; 1420 c = MIDI_SYSEX_END; 1421 return midiseq_out(md, &c, 1, 0); 1422 } 1423 1424 int 1425 midiseq_putc(md, data) 1426 struct midi_dev *md; 1427 int data; 1428 { 1429 u_char c = data; 1430 DPRINTFN(4,("midiseq_putc: 0x%02x\n", data)); 1431 return midiseq_out(md, &c, 1, 0); 1432 } 1433 1434 #include "midi.h" 1435 #if NMIDI == 0 1436 dev_type_open(midiopen); 1437 dev_type_close(midiclose); 1438 1439 const struct cdevsw midi_cdevsw = { 1440 midiopen, midiclose, noread, nowrite, noioctl, 1441 nostop, notty, nopoll, nommap, 1442 }; 1443 1444 /* 1445 * If someone has a sequencer, but no midi devices there will 1446 * be unresolved references, so we provide little stubs. 1447 */ 1448 1449 int 1450 midi_unit_count() 1451 { 1452 return (0); 1453 } 1454 1455 int 1456 midiopen(dev, flags, ifmt, l) 1457 dev_t dev; 1458 int flags, ifmt; 1459 struct lwp *l; 1460 { 1461 return (ENXIO); 1462 } 1463 1464 struct cfdriver midi_cd; 1465 1466 void 1467 midi_getinfo(dev, mi) 1468 dev_t dev; 1469 struct midi_info *mi; 1470 { 1471 } 1472 1473 int 1474 midiclose(dev, flags, ifmt, l) 1475 dev_t dev; 1476 int flags, ifmt; 1477 struct lwp *l; 1478 { 1479 return (ENXIO); 1480 } 1481 1482 int 1483 midi_writebytes(unit, bf, cc) 1484 int unit; 1485 u_char *bf; 1486 int cc; 1487 { 1488 return (ENXIO); 1489 } 1490 #endif /* NMIDI == 0 */ 1491
Indexes created Tue Sep 30 20:09:53 GMT 2025