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