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