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