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