1 /* 2 * The sequencer personality manager. 3 * 4 * Copyright by Hannu Savolainen 1993 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 2. 10 * Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY 15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 17 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 18 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 20 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 21 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 * 28 */ 29 30 /* 31 * This is the newmidi sequencer driver. This driver handles io against 32 * /dev/sequencer, midi input and output event queues and event transmittion 33 * to and from a midi device or synthesizer. 34 */ 35 36 #include "opt_devfs.h" 37 38 #include <dev/sound/midi/midi.h> 39 #include <dev/sound/midi/sequencer.h> 40 41 #ifndef DDB 42 #define DDB(x) 43 #endif /* DDB */ 44 45 #define SND_DEV_SEQ 1 /* Sequencer output /dev/sequencer (FM 46 synthesizer and MIDI output) */ 47 #define SND_DEV_MIDIN 2 /* Raw midi access */ 48 #define SND_DEV_SEQ2 8 /* /dev/sequencer, level 2 interface */ 49 50 #define MIDIDEV_MODE 0x2000 51 52 /* Length of a sequencer event. */ 53 #define EV_SZ 8 54 #define IEV_SZ 8 55 56 /* Return value from seq_playevent and the helpers. */ 57 enum { 58 MORE, 59 TIMERARMED, 60 QUEUEFULL 61 }; 62 63 /* 64 * These functions goes into seq_op_desc to get called 65 * from sound.c. 66 */ 67 68 static midi_intr_t seq_intr; 69 static seq_callback_t seq_callback; 70 71 /* These are the entries to the sequencer driver. */ 72 static d_open_t seq_open; 73 static d_close_t seq_close; 74 static d_ioctl_t seq_ioctl; 75 static d_read_t seq_read; 76 static d_write_t seq_write; 77 static d_poll_t seq_poll; 78 79 /* 80 * This is the device descriptor for the midi sequencer. 81 */ 82 seqdev_info seq_op_desc = { 83 "midi sequencer", 84 85 0, 86 87 seq_open, 88 seq_close, 89 seq_read, 90 seq_write, 91 seq_ioctl, 92 seq_poll, 93 94 seq_callback, 95 96 SEQ_BUFFSIZE, /* Queue Length */ 97 98 0, /* XXX This is not an *audio* device! */ 99 }; 100 101 /* Here is the parameter structure per a device. */ 102 struct seq_softc { 103 seqdev_info *devinfo; /* sequencer device information */ 104 105 int fflags; /* Access mode */ 106 107 u_long seq_time; /* The beggining time of this sequence */ 108 u_long prev_event_time; /* The time of the previous event output */ 109 u_long prev_input_time; /* The time of the previous event input */ 110 u_long prev_wakeup_time; /* The time of the previous wakeup */ 111 struct callout_handle timeout_ch; /* Timer callout handler */ 112 long timer_current; /* Current timer value */ 113 int timer_running; /* State of timer */ 114 int midi_open[NMIDI_MAX]; /* State of midi devices. */ 115 int pending_timer; /* Timer change operation */ 116 int output_threshould; /* Sequence output threshould */ 117 int pre_event_timeout; /* Time to wait event input */ 118 int queueout_pending; /* Pending for the output queue */ 119 snd_sync_parm sync_parm; /* AIOSYNC parameter set */ 120 struct proc *sync_proc; /* AIOSYNCing process */ 121 }; 122 123 typedef struct seq_softc *sc_p; 124 125 static d_open_t seqopen; 126 static d_close_t seqclose; 127 static d_ioctl_t seqioctl; 128 static d_read_t seqread; 129 static d_write_t seqwrite; 130 static d_poll_t seqpoll; 131 132 #define CDEV_MAJOR SEQ_CDEV_MAJOR 133 static struct cdevsw seq_cdevsw = { 134 /* open */ seqopen, 135 /* close */ seqclose, 136 /* read */ seqread, 137 /* write */ seqwrite, 138 /* ioctl */ seqioctl, 139 /* poll */ seqpoll, 140 /* mmap */ nommap, 141 /* strategy */ nostrategy, 142 /* name */ "midi", /* XXX */ 143 /* maj */ CDEV_MAJOR, 144 /* dump */ nodump, 145 /* psize */ nopsize, 146 /* flags */ 0, 147 /* bmaj */ -1 148 }; 149 150 seqdev_info seq_info[NSEQ_MAX] ; 151 static int seq_info_inited; 152 u_long nseq = NSEQ_MAX; /* total number of sequencers */ 153 154 /* The followings are the local function. */ 155 static int seq_init(void); 156 static int seq_queue(sc_p scp, u_char *note); 157 static void seq_startplay(sc_p scp); 158 static int seq_playevent(sc_p scp, u_char *event); 159 static u_long seq_gettime(void); 160 static int seq_requesttimer(sc_p scp, int delay); 161 static void seq_stoptimer(sc_p scp); 162 static void seq_midiinput(sc_p scp, mididev_info *md); 163 static int seq_copytoinput(sc_p scp, u_char *event, int len); 164 static int seq_extended(sc_p scp, u_char *event); 165 static int seq_chnvoice(sc_p scp, u_char *event); 166 static int seq_findvoice(mididev_info *md, int chn, int note); 167 static int seq_allocvoice(mididev_info *md, int chn, int note); 168 static int seq_chncommon(sc_p scp, u_char *event); 169 static int seq_timing(sc_p scp, u_char *event); 170 static int seq_local(sc_p scp, u_char *event); 171 static int seq_sysex(sc_p scp, u_char *event); 172 static void seq_timer(void *arg); 173 static int seq_reset(sc_p scp); 174 static int seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p); 175 static int seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p); 176 static void seq_panic(sc_p scp); 177 static int seq_sync(sc_p scp); 178 179 static seqdev_info * get_seqdev_info(dev_t i_dev, int *unit); 180 181 /* 182 * Here are the main functions to interact to the user process. 183 * These are called from snd* functions in sys/i386/isa/snd/sound.c. 184 */ 185 186 static int 187 seq_init(void) 188 { 189 int unit; 190 sc_p scp; 191 seqdev_info *devinfo; 192 193 DEB(printf("seq: initing.\n")); 194 195 /* Have we already inited? */ 196 if (seq_info_inited) 197 return (1); 198 199 for (unit = 0 ; unit < nseq ; unit++) { 200 /* Allocate the softc. */ 201 scp = malloc(sizeof(*scp), M_DEVBUF, M_NOWAIT); 202 if (scp == (sc_p)NULL) { 203 printf("seq%d: softc allocation failed.\n", unit); 204 return (1); 205 } 206 bzero(scp, sizeof(*scp)); 207 208 /* Fill the softc and the seq_info for this unit. */ 209 scp->seq_time = seq_gettime(); 210 scp->prev_event_time = 0; 211 scp->prev_input_time = 0; 212 scp->prev_wakeup_time = scp->seq_time; 213 callout_handle_init(&scp->timeout_ch); 214 scp->timer_current = 0; 215 scp->timer_running = 0; 216 scp->queueout_pending = 0; 217 218 scp->devinfo = devinfo = &seq_info[unit]; 219 bcopy(&seq_op_desc, devinfo, sizeof(seq_op_desc)); 220 devinfo->unit = unit; 221 devinfo->softc = scp; 222 devinfo->flags = 0; 223 devinfo->midi_dbuf_in.unit_size = devinfo->midi_dbuf_out.unit_size = EV_SZ; 224 midibuf_init(&devinfo->midi_dbuf_in); 225 midibuf_init(&devinfo->midi_dbuf_out); 226 227 make_dev(&seq_cdevsw, MIDIMKMINOR(unit, SND_DEV_SEQ), 228 UID_ROOT, GID_WHEEL, 0666, "sequencer%d", unit); 229 } 230 231 /* We have inited. */ 232 seq_info_inited = 1; 233 234 if (nseq == 1) 235 printf("seq0: Midi sequencer.\n"); 236 else 237 printf("seq0-%lu: Midi sequencers.\n", nseq - 1); 238 239 DEB(printf("seq: inited.\n")); 240 241 return (0); 242 } 243 244 int 245 seq_open(dev_t i_dev, int flags, int mode, struct proc *p) 246 { 247 int unit, s, midiunit; 248 sc_p scp; 249 seqdev_info *sd; 250 mididev_info *md; 251 252 unit = MIDIUNIT(i_dev); 253 254 DEB(printf("seq%d: opening.\n", unit)); 255 256 if (unit >= NSEQ_MAX) { 257 DEB(printf("seq_open: unit %d does not exist.\n", unit)); 258 return (ENXIO); 259 } 260 261 sd = get_seqdev_info(i_dev, &unit); 262 if (sd == NULL) { 263 DEB(printf("seq_open: unit %d is not configured.\n", unit)); 264 return (ENXIO); 265 } 266 scp = sd->softc; 267 268 s = splmidi(); 269 /* Mark this device busy. */ 270 if ((sd->flags & SEQ_F_BUSY) != 0) { 271 splx(s); 272 DEB(printf("seq_open: unit %d is busy.\n", unit)); 273 return (EBUSY); 274 } 275 sd->flags |= SEQ_F_BUSY; 276 sd->flags &= ~(SEQ_F_READING | SEQ_F_WRITING); 277 scp->fflags = flags; 278 279 /* Init the queue. */ 280 midibuf_init(&sd->midi_dbuf_in); 281 midibuf_init(&sd->midi_dbuf_out); 282 283 /* Init timestamp. */ 284 scp->seq_time = seq_gettime(); 285 scp->prev_event_time = 0; 286 scp->prev_input_time = 0; 287 scp->prev_wakeup_time = scp->seq_time; 288 289 splx(s); 290 291 /* Open midi devices. */ 292 for (midiunit = 0 ; midiunit < nmidi + nsynth ; midiunit++) { 293 md = &midi_info[midiunit]; 294 if (MIDICONFED(md)) 295 seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, p); 296 } 297 298 DEB(printf("seq%d: opened.\n", unit)); 299 300 return (0); 301 } 302 303 int 304 seq_close(dev_t i_dev, int flags, int mode, struct proc *p) 305 { 306 int unit, s, i; 307 sc_p scp; 308 seqdev_info *sd; 309 mididev_info *md; 310 311 unit = MIDIUNIT(i_dev); 312 313 DEB(printf("seq%d: closing.\n", unit)); 314 315 if (unit >= NSEQ_MAX) { 316 DEB(printf("seq_close: unit %d does not exist.\n", unit)); 317 return (ENXIO); 318 } 319 320 sd = get_seqdev_info(i_dev, &unit); 321 if (sd == NULL) { 322 DEB(printf("seq_close: unit %d is not configured.\n", unit)); 323 return (ENXIO); 324 } 325 scp = sd->softc; 326 327 s = splmidi(); 328 329 if (!(sd->flags & MIDI_F_NBIO)) 330 seq_sync(scp); 331 332 /* Stop the timer. */ 333 seq_stoptimer(scp); 334 335 /* Reset the sequencer. */ 336 seq_reset(scp); 337 seq_sync(scp); 338 339 /* Clean up the midi device. */ 340 for (i = 0 ; i < nmidi + nsynth ; i++) { 341 md = &midi_info[i]; 342 if (MIDICONFED(md)) 343 seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, p); 344 } 345 346 /* Stop playing and unmark this device busy. */ 347 sd->flags &= ~(SEQ_F_BUSY | SEQ_F_READING | SEQ_F_WRITING); 348 349 splx(s); 350 351 DEB(printf("seq%d: closed.\n", unit)); 352 353 return (0); 354 } 355 356 int 357 seq_read(dev_t i_dev, struct uio *buf, int flag) 358 { 359 int unit, ret, s, len; 360 sc_p scp; 361 seqdev_info *sd; 362 363 unit = MIDIUNIT(i_dev); 364 365 /*DEB(printf("seq%d: reading.\n", unit));*/ 366 367 if (unit >= NSEQ_MAX) { 368 DEB(printf("seq_read: unit %d does not exist.\n", unit)); 369 return (ENXIO); 370 } 371 372 sd = get_seqdev_info(i_dev, &unit); 373 if (sd == NULL) { 374 DEB(printf("seq_read: unit %d is not configured.\n", unit)); 375 return (ENXIO); 376 } 377 scp = sd->softc; 378 if ((scp->fflags & FREAD) == 0) { 379 DEB(printf("seq_read: unit %d is not for reading.\n", unit)); 380 return (EIO); 381 } 382 383 s = splmidi(); 384 385 /* Begin recording. */ 386 sd->callback(sd, SEQ_CB_START | SEQ_CB_RD); 387 388 /* Have we got the data to read? */ 389 if ((sd->flags & SEQ_F_NBIO) != 0 && sd->midi_dbuf_in.rl == 0) 390 ret = EAGAIN; 391 else { 392 len = buf->uio_resid; 393 ret = midibuf_uioread(&sd->midi_dbuf_in, buf, len); 394 if (ret < 0) 395 ret = -ret; 396 else 397 ret = 0; 398 } 399 splx(s); 400 401 return (ret); 402 } 403 404 int 405 seq_write(dev_t i_dev, struct uio *buf, int flag) 406 { 407 u_char event[EV_SZ], ev_code; 408 int unit, count, countorg, midiunit, ev_size, p, ret, s; 409 sc_p scp; 410 seqdev_info *sd; 411 mididev_info *md; 412 413 unit = MIDIUNIT(i_dev); 414 415 /*DEB(printf("seq%d: writing.\n", unit));*/ 416 417 if (unit >= NSEQ_MAX) { 418 DEB(printf("seq_write: unit %d does not exist.\n", unit)); 419 return (ENXIO); 420 } 421 422 sd = get_seqdev_info(i_dev, &unit); 423 if (sd == NULL) { 424 DEB(printf("seq_write: unit %d is not configured.\n", unit)); 425 return (ENXIO); 426 } 427 scp = sd->softc; 428 if ((scp->fflags & FWRITE) == 0) { 429 DEB(printf("seq_write: unit %d is not for writing.\n", unit)); 430 return (EIO); 431 } 432 433 p = 0; 434 countorg = buf->uio_resid; 435 count = countorg; 436 437 s = splmidi(); 438 /* Begin playing. */ 439 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 440 splx(s); 441 442 /* Pick up an event. */ 443 while (count >= 4) { 444 if (uiomove((caddr_t)event, 4, buf)) 445 printf("seq_write: user memory mangled?\n"); 446 ev_code = event[0]; 447 448 /* Have a look at the event code. */ 449 if (ev_code == SEQ_FULLSIZE) { 450 451 /* A long event, these are the patches/samples for a synthesizer. */ 452 midiunit = *(u_short *)&event[2]; 453 if (midiunit < 0 || midiunit >= nmidi + nsynth) 454 return (ENXIO); 455 md = &midi_info[midiunit]; 456 if (!MIDICONFED(md)) 457 return (ENXIO); 458 s = splmidi(); 459 if ((md->flags & MIDI_F_BUSY) == 0 460 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0) { 461 splx(s); 462 return (ENXIO); 463 } 464 465 DEB(printf("seq_write: loading a patch to the unit %d.\n", midiunit)); 466 467 ret = md->synth.loadpatch(md, *(short *)&event[0], buf, p + 4, count, 0); 468 splx(s); 469 return (ret); 470 } 471 472 if (ev_code >= 128) { 473 474 /* Some sort of an extended event. The size is eight bytes. */ 475 #if notyet 476 if (scp->seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED) { 477 printf("seq%d: invalid level two event %x.\n", unit, ev_code); 478 return (EINVAL); 479 } 480 #endif /* notyet */ 481 ev_size = 8; 482 483 if (count < ev_size) { 484 /* No more data. Start playing now. */ 485 s = splmidi(); 486 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 487 splx(s); 488 489 return (0); 490 } 491 if (uiomove((caddr_t)&event[4], 4, buf)) 492 printf("seq_write: user memory mangled?\n"); 493 } else { 494 495 /* Not an extended event. The size is four bytes. */ 496 #if notyet 497 if (scp->seq_mode == SEQ_2) { 498 printf("seq%d: four byte event in level two mode.\n", unit); 499 return (EINVAL); 500 } 501 #endif /* notyet */ 502 ev_size = 4; 503 } 504 if (ev_code == SEQ_MIDIPUTC) { 505 /* An event passed to the midi device itself. */ 506 midiunit = event[2]; 507 if (midiunit < 0 || midiunit >= nmidi + nsynth) 508 return (ENXIO); 509 md = &midi_info[midiunit]; 510 if (!MIDICONFED(md)) 511 return (ENXIO); 512 if ((md->flags & MIDI_F_BUSY) == 0 513 && (ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc)) != 0) { 514 seq_reset(scp); 515 return (ret); 516 } 517 } 518 519 /*DEB(printf("seq_write: queueing event %d.\n", event[0]));*/ 520 /* Now we queue the event. */ 521 switch (seq_queue(scp, event)) { 522 case EAGAIN: 523 s = splmidi(); 524 /* The queue is full. Start playing now. */ 525 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 526 splx(s); 527 return (0); 528 case EINTR: 529 return (EINTR); 530 case ERESTART: 531 return (ERESTART); 532 } 533 p += ev_size; 534 count -= ev_size; 535 } 536 537 /* We have written every single data. Start playing now. */ 538 s = splmidi(); 539 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 540 splx(s); 541 542 return (0); 543 } 544 545 int 546 seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) 547 { 548 int unit, midiunit, ret, tmp, s, arg2; 549 sc_p scp; 550 seqdev_info *sd; 551 mididev_info *md; 552 struct synth_info *synthinfo; 553 struct midi_info *midiinfo; 554 struct patmgr_info *patinfo; 555 snd_sync_parm *syncparm; 556 struct seq_event_rec *event; 557 struct snd_size *sndsize; 558 559 unit = MIDIUNIT(i_dev); 560 561 DEB(printf("seq%d: ioctlling, cmd 0x%x.\n", unit, (int)cmd)); 562 563 if (unit >= NSEQ_MAX) { 564 DEB(printf("seq_ioctl: unit %d does not exist.\n", unit)); 565 return (ENXIO); 566 } 567 sd = get_seqdev_info(i_dev, &unit); 568 if (sd == NULL) { 569 DEB(printf("seq_ioctl: unit %d is not configured.\n", unit)); 570 return (ENXIO); 571 } 572 scp = sd->softc; 573 574 ret = 0; 575 576 switch (cmd) { 577 578 /* 579 * we start with the new ioctl interface. 580 */ 581 case AIONWRITE: /* how many bytes can be written ? */ 582 *(int *)arg = sd->midi_dbuf_out.fl; 583 break; 584 585 case AIOSSIZE: /* set the current blocksize */ 586 sndsize = (struct snd_size *)arg; 587 if (sndsize->play_size <= sd->midi_dbuf_out.unit_size && sndsize->rec_size <= sd->midi_dbuf_in.unit_size) { 588 sd->flags &= ~MIDI_F_HAS_SIZE; 589 sd->midi_dbuf_out.blocksize = sd->midi_dbuf_out.unit_size; 590 sd->midi_dbuf_in.blocksize = sd->midi_dbuf_in.unit_size; 591 } 592 else { 593 if (sndsize->play_size > sd->midi_dbuf_out.bufsize / 4) 594 sndsize->play_size = sd->midi_dbuf_out.bufsize / 4; 595 if (sndsize->rec_size > sd->midi_dbuf_in.bufsize / 4) 596 sndsize->rec_size = sd->midi_dbuf_in.bufsize / 4; 597 /* Round up the size to the multiple of EV_SZ. */ 598 sd->midi_dbuf_out.blocksize = 599 ((sndsize->play_size + sd->midi_dbuf_out.unit_size - 1) 600 / sd->midi_dbuf_out.unit_size) * sd->midi_dbuf_out.unit_size; 601 sd->midi_dbuf_in.blocksize = 602 ((sndsize->rec_size + sd->midi_dbuf_in.unit_size - 1) 603 / sd->midi_dbuf_in.unit_size) * sd->midi_dbuf_in.unit_size; 604 sd->flags |= MIDI_F_HAS_SIZE; 605 } 606 /* FALLTHROUGH */ 607 case AIOGSIZE: /* get the current blocksize */ 608 sndsize = (struct snd_size *)arg; 609 sndsize->play_size = sd->midi_dbuf_out.blocksize; 610 sndsize->rec_size = sd->midi_dbuf_in.blocksize; 611 612 ret = 0; 613 break; 614 615 case AIOSTOP: 616 if (*(int *)arg == AIOSYNC_PLAY) { 617 s = splmidi(); 618 619 /* Stop writing. */ 620 sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_WR); 621 622 /* Pass the ioctl to the midi devices. */ 623 for (midiunit = 0 ; midiunit < nmidi + nsynth ; midiunit++) { 624 md = &midi_info[midiunit]; 625 if (MIDICONFED(md) && scp->midi_open[midiunit] && (md->flags & MIDI_F_WRITING) != 0) { 626 arg2 = *(int *)arg; 627 midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, p); 628 } 629 } 630 631 *(int *)arg = sd->midi_dbuf_out.rl; 632 splx(s); 633 } 634 else if (*(int *)arg == AIOSYNC_CAPTURE) { 635 s = splmidi(); 636 637 /* Stop reading. */ 638 sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_RD); 639 640 /* Pass the ioctl to the midi devices. */ 641 for (midiunit = 0 ; midiunit < nmidi + nsynth ; midiunit++) { 642 md = &midi_info[midiunit]; 643 if (MIDICONFED(md) && scp->midi_open[midiunit] && (md->flags & MIDI_F_WRITING) != 0) { 644 arg2 = *(int *)arg; 645 midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, p); 646 } 647 } 648 649 *(int *)arg = sd->midi_dbuf_in.rl; 650 splx(s); 651 } 652 653 ret = 0; 654 break; 655 656 case AIOSYNC: 657 syncparm = (snd_sync_parm *)arg; 658 scp->sync_parm = *syncparm; 659 660 /* XXX Should select(2) against us watch the blocksize, or sync_parm? */ 661 662 ret = 0; 663 break; 664 665 case SNDCTL_TMR_TIMEBASE: 666 case SNDCTL_TMR_TEMPO: 667 case SNDCTL_TMR_START: 668 case SNDCTL_TMR_STOP: 669 case SNDCTL_TMR_CONTINUE: 670 case SNDCTL_TMR_METRONOME: 671 case SNDCTL_TMR_SOURCE: 672 #if notyet 673 if (scp->seq_mode != SEQ_2) { 674 ret = EINVAL; 675 break; 676 } 677 ret = tmr->ioctl(tmr_no, cmd, arg); 678 #endif /* notyet */ 679 break; 680 case SNDCTL_TMR_SELECT: 681 #if notyet 682 if (scp->seq_mode != SEQ_2) { 683 ret = EINVAL; 684 break; 685 } 686 #endif /* notyet */ 687 scp->pending_timer = *(int *)arg; 688 if (scp->pending_timer < 0 || scp->pending_timer >= /*NTIMER*/1) { 689 scp->pending_timer = -1; 690 ret = EINVAL; 691 break; 692 } 693 *(int *)arg = scp->pending_timer; 694 ret = 0; 695 break; 696 case SNDCTL_SEQ_PANIC: 697 seq_panic(scp); 698 ret = 0; 699 break; 700 case SNDCTL_SEQ_SYNC: 701 if (mode == O_RDONLY) { 702 ret = 0; 703 break; 704 } 705 ret = seq_sync(scp); 706 break; 707 case SNDCTL_SEQ_RESET: 708 seq_reset(scp); 709 ret = 0; 710 break; 711 case SNDCTL_SEQ_TESTMIDI: 712 midiunit = *(int *)arg; 713 if (midiunit >= nmidi + nsynth) { 714 ret = ENXIO; 715 break; 716 } 717 md = &midi_info[midiunit]; 718 if (MIDICONFED(md) && !scp->midi_open[midiunit]) { 719 ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); 720 break; 721 } 722 ret = 0; 723 break; 724 case SNDCTL_SEQ_GETINCOUNT: 725 if (mode == O_WRONLY) 726 *(int *)arg = 0; 727 else 728 *(int *)arg = sd->midi_dbuf_in.rl; 729 ret = 0; 730 break; 731 case SNDCTL_SEQ_GETOUTCOUNT: 732 if (mode == O_RDONLY) 733 *(int *)arg = 0; 734 else 735 *(int *)arg = sd->midi_dbuf_out.fl; 736 ret = 0; 737 break; 738 case SNDCTL_SEQ_CTRLRATE: 739 #if notyet 740 if (scp->seq_mode != SEQ_2) { 741 ret = tmr->ioctl(tmr_no, cmd, arg); 742 break; 743 } 744 #endif /* notyet */ 745 if (*(int *)arg != 0) { 746 ret = EINVAL; 747 break; 748 } 749 *(int *)arg = hz; 750 ret = 0; 751 break; 752 case SNDCTL_SEQ_RESETSAMPLES: 753 midiunit = *(int *)arg; 754 if (midiunit >= nmidi + nsynth) { 755 ret = ENXIO; 756 break; 757 } 758 if (!scp->midi_open[midiunit]) { 759 md = &midi_info[midiunit]; 760 if (MIDICONFED(md)) { 761 ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); 762 if (ret != 0) 763 break; 764 } else { 765 ret = EBUSY; 766 break; 767 } 768 } 769 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); 770 break; 771 case SNDCTL_SEQ_NRSYNTHS: 772 *(int *)arg = nmidi + nsynth; 773 ret = 0; 774 break; 775 case SNDCTL_SEQ_NRMIDIS: 776 *(int *)arg = nmidi + nsynth; 777 ret = 0; 778 break; 779 case SNDCTL_SYNTH_MEMAVL: 780 midiunit = *(int *)arg; 781 if (midiunit >= nmidi + nsynth) { 782 ret = ENXIO; 783 break; 784 } 785 if (!scp->midi_open[midiunit]) { 786 md = &midi_info[midiunit]; 787 if (MIDICONFED(md)) { 788 ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); 789 if (ret != 0) 790 break; 791 } else { 792 ret = EBUSY; 793 break; 794 } 795 } 796 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); 797 break; 798 case SNDCTL_FM_4OP_ENABLE: 799 midiunit = *(int *)arg; 800 if (midiunit >= nmidi + nsynth) { 801 ret = ENXIO; 802 break; 803 } 804 if (!scp->midi_open[midiunit]) { 805 md = &midi_info[midiunit]; 806 if (MIDICONFED(md)) { 807 ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); 808 if (ret != 0) 809 break; 810 } else { 811 ret = EBUSY; 812 break; 813 } 814 } 815 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); 816 break; 817 case SNDCTL_SYNTH_INFO: 818 synthinfo = (struct synth_info *)arg; 819 midiunit = synthinfo->device; 820 if (midiunit >= nmidi + nsynth) { 821 ret = ENXIO; 822 break; 823 } 824 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); 825 break; 826 case SNDCTL_SEQ_OUTOFBAND: 827 event = (struct seq_event_rec *)arg; 828 s = splmidi(); 829 ret = seq_playevent(scp, event->arr); 830 splx(s); 831 break; 832 case SNDCTL_MIDI_INFO: 833 midiinfo = (struct midi_info *)arg; 834 midiunit = midiinfo->device; 835 if (midiunit >= nmidi + nsynth) { 836 ret = ENXIO; 837 break; 838 } 839 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); 840 break; 841 case SNDCTL_PMGR_IFACE: 842 patinfo = (struct patmgr_info *)arg; 843 midiunit = patinfo->device; 844 if (midiunit >= nmidi + nsynth) { 845 ret = ENXIO; 846 break; 847 } 848 if (!scp->midi_open[midiunit]) { 849 ret = EBUSY; 850 break; 851 } 852 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); 853 break; 854 case SNDCTL_PMGR_ACCESS: 855 patinfo = (struct patmgr_info *)arg; 856 midiunit = patinfo->device; 857 if (midiunit >= nmidi + nsynth) { 858 ret = ENXIO; 859 break; 860 } 861 if (!scp->midi_open[midiunit]) { 862 md = &midi_info[midiunit]; 863 if (MIDICONFED(md)) { 864 ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); 865 if (ret != 0) 866 break; 867 } else { 868 ret = EBUSY; 869 break; 870 } 871 } 872 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); 873 break; 874 case SNDCTL_SEQ_THRESHOLD: 875 tmp = *(int *)arg; 876 RANGE(tmp, 1, sd->midi_dbuf_out.bufsize - 1); 877 scp->output_threshould = tmp; 878 ret = 0; 879 break; 880 case SNDCTL_MIDI_PRETIME: 881 tmp = *(int *)arg; 882 if (tmp < 0) 883 tmp = 0; 884 tmp = (hz * tmp) / 10; 885 scp->pre_event_timeout = tmp; 886 ret = 0; 887 break; 888 default: 889 if (scp->fflags == O_RDONLY) { 890 ret = EIO; 891 break; 892 } 893 if (!scp->midi_open[0]) { 894 md = &midi_info[0]; 895 if (MIDICONFED(md)) { 896 ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); 897 if (ret != 0) 898 break; 899 } else { 900 ret = EBUSY; 901 break; 902 } 903 } 904 ret = midi_ioctl(MIDIMKDEV(major(i_dev), 0, SND_DEV_MIDIN), cmd, arg, mode, p); 905 break; 906 } 907 908 return (ret); 909 } 910 911 int 912 seq_poll(dev_t i_dev, int events, struct proc *p) 913 { 914 int unit, ret, s, lim; 915 sc_p scp; 916 seqdev_info *sd; 917 918 unit = MIDIUNIT(i_dev); 919 920 DEB(printf("seq%d: polling.\n", unit)); 921 922 if (unit >= NSEQ_MAX) { 923 DEB(printf("seq_poll: unit %d does not exist.\n", unit)); 924 return (ENXIO); 925 } 926 sd = get_seqdev_info(i_dev, &unit); 927 if (sd == NULL) { 928 DEB(printf("seq_poll: unit %d is not configured.\n", unit)); 929 return (ENXIO); 930 } 931 scp = sd->softc; 932 933 ret = 0; 934 s = splmidi(); 935 936 /* Look up the apropriate queue and select it. */ 937 if ((events & (POLLOUT | POLLWRNORM)) != 0) { 938 /* Start playing. */ 939 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 940 941 /* Find out the boundary. */ 942 if ((sd->flags & SEQ_F_HAS_SIZE) != 0) 943 lim = sd->midi_dbuf_out.blocksize; 944 else 945 lim = sd->midi_dbuf_out.unit_size; 946 if (sd->midi_dbuf_out.fl < lim) 947 /* No enough space, record select. */ 948 selrecord(p, &sd->midi_dbuf_out.sel); 949 else 950 /* We can write now. */ 951 ret |= events & (POLLOUT | POLLWRNORM); 952 } 953 if ((events & (POLLIN | POLLRDNORM)) != 0) { 954 /* Start recording. */ 955 sd->callback(sd, SEQ_CB_START | SEQ_CB_RD); 956 957 /* Find out the boundary. */ 958 if ((sd->flags & SEQ_F_HAS_SIZE) != 0) 959 lim = sd->midi_dbuf_in.blocksize; 960 else 961 lim = sd->midi_dbuf_in.unit_size; 962 if (sd->midi_dbuf_in.rl < lim) 963 /* No data ready, record select. */ 964 selrecord(p, &sd->midi_dbuf_in.sel); 965 else 966 /* We can write now. */ 967 ret |= events & (POLLIN | POLLRDNORM); 968 } 969 splx(s); 970 971 return (ret); 972 } 973 974 static void 975 seq_intr(void *p, mididev_info *md) 976 { 977 sc_p scp; 978 seqdev_info *sd; 979 980 sd = (seqdev_info *)p; 981 scp = sd->softc; 982 983 /* Restart playing if we have the data to output. */ 984 if (scp->queueout_pending) 985 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 986 /* Check the midi device if we are reading. */ 987 if ((sd->flags & SEQ_F_READING) != 0) 988 seq_midiinput(scp, md); 989 } 990 991 static int 992 seq_callback(seqdev_info *sd, int reason) 993 { 994 int unit; 995 sc_p scp; 996 997 /*DEB(printf("seq_callback: reason 0x%x.\n", reason));*/ 998 999 if (sd == NULL) { 1000 DEB(printf("seq_callback: device not configured.\n")); 1001 return (ENXIO); 1002 } 1003 scp = sd->softc; 1004 unit = sd->unit; 1005 1006 switch (reason & SEQ_CB_REASON_MASK) { 1007 case SEQ_CB_START: 1008 if ((reason & SEQ_CB_RD) != 0 && (sd->flags & SEQ_F_READING) == 0) 1009 /* Begin recording. */ 1010 sd->flags |= SEQ_F_READING; 1011 if ((reason & SEQ_CB_WR) != 0 && (sd->flags & SEQ_F_WRITING) == 0) 1012 /* Start playing. */ 1013 seq_startplay(scp); 1014 break; 1015 case SEQ_CB_STOP: 1016 case SEQ_CB_ABORT: 1017 if ((reason & SEQ_CB_RD) != 0 && (sd->flags & SEQ_F_READING) != 0) { 1018 /* Stop the timer. */ 1019 scp->seq_time = seq_gettime(); 1020 scp->prev_input_time = 0; 1021 1022 /* Stop recording. */ 1023 sd->flags &= ~SEQ_F_READING; 1024 } 1025 if ((reason & SEQ_CB_WR) != 0 && (sd->flags & SEQ_F_WRITING) != 0) { 1026 /* Stop the timer. */ 1027 seq_stoptimer(scp); 1028 scp->seq_time = seq_gettime(); 1029 scp->prev_event_time = 0; 1030 1031 /* Stop Playing. */ 1032 sd->flags &= ~SEQ_F_WRITING; 1033 scp->queueout_pending = 0; 1034 } 1035 break; 1036 } 1037 1038 return (0); 1039 } 1040 1041 /* 1042 * The functions below here are the libraries for the above ones. 1043 */ 1044 1045 static int 1046 seq_queue(sc_p scp, u_char *note) 1047 { 1048 int unit, err, s; 1049 seqdev_info *sd; 1050 1051 sd = scp->devinfo; 1052 unit = sd->unit; 1053 1054 /*DEB(printf("seq%d: queueing.\n", unit));*/ 1055 1056 s = splmidi(); 1057 1058 /* Start playing if we have some data in the queue. */ 1059 if (sd->midi_dbuf_out.rl >= EV_SZ) 1060 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 1061 1062 if (sd->midi_dbuf_out.fl < EV_SZ) { 1063 /* We have no space. Start playing if not yet. */ 1064 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 1065 if ((sd->flags & SEQ_F_NBIO) != 0 && sd->midi_dbuf_out.fl < EV_SZ) { 1066 /* We would block. */ 1067 splx(s); 1068 return (EAGAIN); 1069 } else 1070 while (sd->midi_dbuf_out.fl < EV_SZ) { 1071 /* We have no space. Good night. */ 1072 err = tsleep(&sd->midi_dbuf_out.tsleep_out, PRIBIO | PCATCH, "seqque", 0); 1073 if (err == EINTR) 1074 sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR); 1075 if (err == EINTR || err == ERESTART) { 1076 splx(s); 1077 return (err); 1078 } 1079 } 1080 } 1081 1082 /* We now have enough space to write. */ 1083 err = midibuf_seqwrite(&sd->midi_dbuf_out, note, EV_SZ); 1084 1085 splx(s); 1086 1087 if (err < 0) 1088 err = -err; 1089 else 1090 err = 0; 1091 1092 return (err); 1093 } 1094 1095 static void 1096 seq_startplay(sc_p scp) 1097 { 1098 int unit; 1099 u_char event[EV_SZ]; 1100 seqdev_info *sd; 1101 1102 sd = scp->devinfo; 1103 unit = sd->unit; 1104 1105 /* Dequeue the events to play. */ 1106 while (sd->midi_dbuf_out.rl >= EV_SZ) { 1107 1108 /* We are playing now. */ 1109 sd->flags |= SEQ_F_WRITING; 1110 1111 /* We only copy the event, not dequeue. */ 1112 midibuf_seqcopy(&sd->midi_dbuf_out, event, EV_SZ); 1113 1114 switch (seq_playevent(scp, event)) { 1115 case TIMERARMED: 1116 /* Dequeue the event. */ 1117 midibuf_seqread(&sd->midi_dbuf_out, event, EV_SZ); 1118 /* FALLTHRU */ 1119 case QUEUEFULL: 1120 /* We cannot play further. */ 1121 return; 1122 case MORE: 1123 /* Dequeue the event. */ 1124 midibuf_seqread(&sd->midi_dbuf_out, event, EV_SZ); 1125 break; 1126 } 1127 } 1128 1129 /* Played every event in the queue. */ 1130 sd->flags &= ~SEQ_F_WRITING; 1131 } 1132 1133 static int 1134 seq_playevent(sc_p scp, u_char *event) 1135 { 1136 int unit, ret; 1137 long *delay; 1138 seqdev_info *sd; 1139 mididev_info *md; 1140 1141 sd = scp->devinfo; 1142 unit = sd->unit; 1143 1144 md = &midi_info[0]; 1145 if (!MIDICONFED(md)) 1146 return (MORE); 1147 1148 switch(event[0]) { 1149 case SEQ_NOTEOFF: 1150 if ((md->flags & MIDI_F_BUSY) != 0 || seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) == 0) 1151 if (md->synth.killnote(md, event[1], 255, event[3]) == EAGAIN) { 1152 ret = QUEUEFULL; 1153 break; 1154 } 1155 ret = MORE; 1156 break; 1157 case SEQ_NOTEON: 1158 if (((md->flags & MIDI_F_BUSY) != 0 || seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) == 0) 1159 && (event[4] < 128 || event[4] == 255)) 1160 if (md->synth.startnote(md, event[1], event[2], event[3]) == EAGAIN) { 1161 ret = QUEUEFULL; 1162 break; 1163 } 1164 ret = MORE; 1165 break; 1166 case SEQ_WAIT: 1167 1168 /* Extract the delay. */ 1169 delay = (long *)event; 1170 *delay = (*delay >> 8) & 0xffffff; 1171 if (*delay > 0) { 1172 /* Arm the timer. */ 1173 sd->flags |= SEQ_F_WRITING; 1174 scp->prev_event_time = *delay; 1175 if (seq_requesttimer(scp, *delay)) { 1176 ret = TIMERARMED; 1177 break; 1178 } 1179 } 1180 ret = MORE; 1181 break; 1182 case SEQ_PGMCHANGE: 1183 if ((md->flags & MIDI_F_BUSY) != 0 || seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) == 0) 1184 if (md->synth.setinstr(md, event[1], event[2]) == EAGAIN) { 1185 ret = QUEUEFULL; 1186 break; 1187 } 1188 ret = MORE; 1189 break; 1190 case SEQ_SYNCTIMER: 1191 /* Reset the timer. */ 1192 scp->seq_time = seq_gettime(); 1193 scp->prev_input_time = 0; 1194 scp->prev_event_time = 0; 1195 scp->prev_wakeup_time = scp->seq_time; 1196 ret = MORE; 1197 break; 1198 case SEQ_MIDIPUTC: 1199 /* Pass through to the midi device. */ 1200 if (event[2] < nmidi + nsynth) { 1201 md = &midi_info[event[2]]; 1202 if (MIDICONFED(md) && ((md->flags & MIDI_F_BUSY) != 0 || seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) == 0)) { 1203 if (md->synth.writeraw(md, &event[1], sizeof(event[1]), 1) == EAGAIN) { 1204 /* The queue was full. Try again later. */ 1205 ret = QUEUEFULL; 1206 break; 1207 } 1208 } 1209 } 1210 ret = MORE; 1211 break; 1212 case SEQ_ECHO: 1213 /* Echo this event back. */ 1214 if (seq_copytoinput(scp, event, 4) == EAGAIN) { 1215 ret = QUEUEFULL; 1216 break; 1217 } 1218 ret = MORE; 1219 break; 1220 case SEQ_PRIVATE: 1221 if (event[1] < nmidi + nsynth) { 1222 md = &midi_info[event[1]]; 1223 if (MIDICONFED(md) && md->synth.hwcontrol(md, event) == EAGAIN) { 1224 ret = QUEUEFULL; 1225 break; 1226 } 1227 } 1228 ret = MORE; 1229 break; 1230 case SEQ_EXTENDED: 1231 ret = seq_extended(scp, event); 1232 break; 1233 case EV_CHN_VOICE: 1234 ret = seq_chnvoice(scp, event); 1235 break; 1236 case EV_CHN_COMMON: 1237 ret = seq_chncommon(scp, event); 1238 break; 1239 case EV_TIMING: 1240 ret = seq_timing(scp, event); 1241 break; 1242 case EV_SEQ_LOCAL: 1243 ret = seq_local(scp, event); 1244 break; 1245 case EV_SYSEX: 1246 ret = seq_sysex(scp, event); 1247 break; 1248 default: 1249 ret = MORE; 1250 break; 1251 } 1252 1253 switch (ret) { 1254 case QUEUEFULL: 1255 /*DEB(printf("seq_playevent: the queue is full.\n"));*/ 1256 /* The queue was full. Try again on the interrupt by the midi device. */ 1257 sd->flags |= SEQ_F_WRITING; 1258 scp->queueout_pending = 1; 1259 break; 1260 case TIMERARMED: 1261 sd->flags |= SEQ_F_WRITING; 1262 /* FALLTHRU */ 1263 case MORE: 1264 scp->queueout_pending = 0; 1265 break; 1266 } 1267 1268 return (ret); 1269 } 1270 1271 static u_long 1272 seq_gettime(void) 1273 { 1274 struct timeval timecopy; 1275 1276 getmicrotime(&timecopy); 1277 return timecopy.tv_usec / (1000000 / hz) + (u_long) timecopy.tv_sec * hz; 1278 } 1279 1280 static int 1281 seq_requesttimer(sc_p scp, int delay) 1282 { 1283 u_long cur_time, rel_base; 1284 1285 /*DEB(printf("seq%d: requested timer at delay of %d.\n", unit, delay));*/ 1286 1287 cur_time = seq_gettime(); 1288 1289 if (delay < 0) 1290 /* Request a new timer. */ 1291 delay = -delay; 1292 else { 1293 rel_base = cur_time - scp->seq_time; 1294 if (delay <= rel_base) 1295 return 0; 1296 delay -= rel_base; 1297 } 1298 1299 #if notdef 1300 /* 1301 * Compensate the delay of midi message transmission. 1302 * XXX Do we have to consider the accumulation of errors 1303 * less than 1/hz second? 1304 */ 1305 delay -= (cur_time - scp->prev_wakeup_time); 1306 if (delay < 1) { 1307 printf("sequencer: prev = %lu, cur = %lu, delay = %d, skip sleeping.\n", 1308 scp->prev_wakeup_time, cur_time, delay); 1309 seq_stoptimer(scp); 1310 return 0; 1311 } 1312 #endif /* notdef */ 1313 1314 scp->timeout_ch = timeout(seq_timer, (void *)scp, delay); 1315 scp->timer_running = 1; 1316 return 1; 1317 } 1318 1319 static void 1320 seq_stoptimer(sc_p scp) 1321 { 1322 /*DEB(printf("seq%d: stopping timer.\n", unit));*/ 1323 1324 if (scp->timer_running) { 1325 untimeout(seq_timer, (void *)scp, scp->timeout_ch); 1326 scp->timer_running = 0; 1327 } 1328 } 1329 1330 static void 1331 seq_midiinput(sc_p scp, mididev_info *md) 1332 { 1333 int unit, midiunit; 1334 u_long tstamp; 1335 u_char event[4]; 1336 seqdev_info *sd; 1337 1338 sd = scp->devinfo; 1339 unit = sd->unit; 1340 1341 /* Can this midi device interrupt for input? */ 1342 midiunit = md->unit; 1343 if (scp->midi_open[midiunit] 1344 && (md->flags & MIDI_F_READING) != 0 1345 && md->intrarg == sd) 1346 /* Read the input data. */ 1347 while (md->synth.readraw(md, &event[1], sizeof(event[1]), 1) == 0) { 1348 tstamp = seq_gettime() - scp->seq_time; 1349 if (tstamp != scp->prev_input_time) { 1350 /* Insert a wait between events. */ 1351 tstamp = (tstamp << 8) | SEQ_WAIT; 1352 seq_copytoinput(scp, (u_char *)&tstamp, 4); 1353 scp->prev_input_time = tstamp; 1354 } 1355 event[0] = SEQ_MIDIPUTC; 1356 event[2] = midiunit; 1357 event[3] = 0; 1358 seq_copytoinput(scp, event, sizeof(event)); 1359 } 1360 } 1361 1362 static int 1363 seq_copytoinput(sc_p scp, u_char *event, int len) 1364 { 1365 seqdev_info *sd; 1366 1367 sd = scp->devinfo; 1368 1369 if (midibuf_input_intr(&sd->midi_dbuf_in, event, len) == -EAGAIN) 1370 return (EAGAIN); 1371 1372 return (0); 1373 } 1374 1375 static int 1376 seq_extended(sc_p scp, u_char *event) 1377 { 1378 int unit; 1379 seqdev_info *sd; 1380 mididev_info *md; 1381 1382 sd = scp->devinfo; 1383 unit = sd->unit; 1384 1385 if (event[2] >= nmidi + nsynth) 1386 return (MORE); 1387 md = &midi_info[event[2]]; 1388 if (!MIDICONFED(md) && (md->flags & MIDI_F_BUSY) == 0 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0) 1389 return (MORE); 1390 1391 switch (event[1]) { 1392 case SEQ_NOTEOFF: 1393 if (md->synth.killnote(md, event[3], event[4], event[5]) == EAGAIN) 1394 return (QUEUEFULL); 1395 break; 1396 case SEQ_NOTEON: 1397 if (event[4] < 128 || event[4] == 255) 1398 if (md->synth.startnote(md, event[3], event[4], event[5]) == EAGAIN) 1399 return (QUEUEFULL); 1400 break; 1401 case SEQ_PGMCHANGE: 1402 if (md->synth.setinstr(md, event[3], event[4]) == EAGAIN) 1403 return (QUEUEFULL); 1404 break; 1405 case SEQ_AFTERTOUCH: 1406 if (md->synth.aftertouch(md, event[3], event[4]) == EAGAIN) 1407 return (QUEUEFULL); 1408 break; 1409 case SEQ_BALANCE: 1410 if (md->synth.panning(md, event[3], (char)event[4]) == EAGAIN) 1411 return (QUEUEFULL); 1412 break; 1413 case SEQ_CONTROLLER: 1414 if (md->synth.controller(md, event[3], event[4], *(short *)&event[5]) == EAGAIN) 1415 return (QUEUEFULL); 1416 break; 1417 case SEQ_VOLMODE: 1418 if (md->synth.volumemethod != NULL) 1419 if (md->synth.volumemethod(md, event[3]) == EAGAIN) 1420 return (QUEUEFULL); 1421 break; 1422 } 1423 1424 return (MORE); 1425 } 1426 1427 static int 1428 seq_chnvoice(sc_p scp, u_char *event) 1429 { 1430 int voice; 1431 seqdev_info *sd; 1432 mididev_info *md; 1433 u_char dev, cmd, chn, note, parm; 1434 1435 voice = -1; 1436 dev = event[1]; 1437 cmd = event[2]; 1438 chn = event[3]; 1439 note = event[4]; 1440 parm = event[5]; 1441 1442 sd = scp->devinfo; 1443 1444 if (dev >= nmidi + nsynth) 1445 return (MORE); 1446 md = &midi_info[dev]; 1447 if (!MIDICONFED(md) && (md->flags & MIDI_F_BUSY) == 0 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0) 1448 return (MORE); 1449 1450 #if notyet 1451 if (scp->seq_mode == SEQ_2) { 1452 if (md->synth.allocvoice) 1453 voice = seq_allocvoice(md, chn, note); 1454 } 1455 #endif /* notyet */ 1456 switch (cmd) { 1457 case MIDI_NOTEON: 1458 if (note < 128 || note == 255) { 1459 #if notyet 1460 if (voice == -1 && scp->seq_mode == SEQ_2 && md->synth.allocvoice) 1461 /* This is an internal synthesizer. (FM, GUS, etc) */ 1462 if ((voice = seq_allocvoice(md, chn, note)) == -EAGAIN) 1463 return (QUEUEFULL); 1464 #endif /* notyet */ 1465 if (voice == -1) 1466 voice = chn; 1467 1468 #if notyet 1469 if (scp->seq_mode == SEQ_2 && dev < nmidi + nsynth && chn == 9) { 1470 /* This channel is a percussion. The note number is the patch number. */ 1471 if (md->synth.setinstr(md, voice, 128 + note) == EAGAIN) 1472 return (QUEUEFULL); 1473 note = 60; /* Middle C. */ 1474 } 1475 if (scp->seq_mode == SEQ_2) 1476 if (md->synth.setupvoice(md, voice, chn) == EAGAIN) 1477 return (QUEUEFULL); 1478 #endif /* notyet */ 1479 if (md->synth.startnote(md, voice, note, parm) == EAGAIN) 1480 return (QUEUEFULL); 1481 } 1482 break; 1483 case MIDI_NOTEOFF: 1484 if (voice == -1) 1485 voice = chn; 1486 if (md->synth.killnote(md, voice, note, parm) == EAGAIN) 1487 return (QUEUEFULL); 1488 break; 1489 case MIDI_KEY_PRESSURE: 1490 if (voice == -1) 1491 voice = chn; 1492 if (md->synth.aftertouch(md, voice, parm) == EAGAIN) 1493 return (QUEUEFULL); 1494 break; 1495 } 1496 1497 return (MORE); 1498 } 1499 1500 static int 1501 seq_findvoice(mididev_info *md, int chn, int note) 1502 { 1503 int i; 1504 u_short key; 1505 1506 key = (chn << 8) | (note + 1); 1507 1508 for (i = 0 ; i < md->synth.alloc.max_voice ; i++) 1509 if (md->synth.alloc.map[i] == key) 1510 return (i); 1511 1512 return (-1); 1513 } 1514 1515 static int 1516 seq_allocvoice(mididev_info *md, int chn, int note) 1517 { 1518 int voice; 1519 u_short key; 1520 1521 key = (chn << 8) | (note + 1); 1522 1523 if ((voice = md->synth.allocvoice(md, chn, note, &md->synth.alloc)) == -EAGAIN) 1524 return (-EAGAIN); 1525 md->synth.alloc.map[voice] = key; 1526 md->synth.alloc.alloc_times[voice] = md->synth.alloc.timestamp++; 1527 1528 return (voice); 1529 } 1530 1531 static int 1532 seq_chncommon(sc_p scp, u_char *event) 1533 { 1534 int unit/*, i, val, key*/; 1535 u_short w14; 1536 u_char dev, cmd, chn, p1; 1537 seqdev_info *sd; 1538 mididev_info *md; 1539 1540 dev = event[1]; 1541 cmd = event[2]; 1542 chn = event[3]; 1543 p1 = event[4]; 1544 w14 = *(u_short *)&event[6]; 1545 1546 sd = scp->devinfo; 1547 unit = sd->unit; 1548 1549 if (dev >= nmidi + nsynth) 1550 return (MORE); 1551 md = &midi_info[dev]; 1552 if (!MIDICONFED(md) && (md->flags & MIDI_F_BUSY) == 0 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0) 1553 return (MORE); 1554 1555 switch (cmd) { 1556 case MIDI_PGM_CHANGE: 1557 #if notyet 1558 if (scp->seq_mode == SEQ_2) { 1559 md->synth.chn_info[chn].pgm_num = p1; 1560 if (dev < nmidi + nsynth) 1561 if (md->synth.setinstr(md, chn, p1) == EAGAIN) 1562 return (QUEUEFULL); 1563 } else 1564 #endif /* notyet */ 1565 /* For Mode 1. */ 1566 if (md->synth.setinstr(md, chn, p1) == EAGAIN) 1567 return (QUEUEFULL); 1568 break; 1569 case MIDI_CTL_CHANGE: 1570 #if notyet 1571 if (scp->seq_mode == SEQ_2) { 1572 if (chn < 16 && p1 < 128) { 1573 md->synth.chn_info[chn].controllers[p1] = w14 & 0x7f; 1574 if (p1 < 32) 1575 /* We have set the MSB, clear the LSB. */ 1576 md->synth.chn_info[chn].controllers[p1 + 32] = 0; 1577 if (dev < nmidi + nsynth) { 1578 val = w14 & 0x7f; 1579 if (p1 < 64) { 1580 /* Combine the MSB and the LSB. */ 1581 val = ((md->synth.chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7) 1582 | (md->synth.chn_info[chn].controllers[p1 | 32] & 0x7f); 1583 p1 &= ~32; 1584 } 1585 /* Handle all of the notes playing on this channel. */ 1586 key = ((int)chn << 8); 1587 for (i = 0 ; i < md->synth.alloc.max_voice ; i++) 1588 if ((md->synth.alloc.map[i] & 0xff00) == key) 1589 if (md->synth.controller(md, i, p1, val) == EAGAIN) 1590 return (QUEUEFULL); 1591 } else 1592 if (md->synth.controller(md, chn, p1, w14) == EAGAIN) 1593 return (QUEUEFULL); 1594 } 1595 } else 1596 #endif /* notyet */ 1597 /* For Mode 1. */ 1598 if (md->synth.controller(md, chn, p1, w14) == EAGAIN) 1599 return (QUEUEFULL); 1600 break; 1601 case MIDI_PITCH_BEND: 1602 #if notyet 1603 if (scp->seq_mode == SEQ_2) { 1604 md->synth.chn_info[chn].bender_value = w14; 1605 if (dev < nmidi + nsynth) { 1606 /* Handle all of the notes playing on this channel. */ 1607 key = ((int)chn << 8); 1608 for (i = 0 ; i < md->synth.alloc.max_voice ; i++) 1609 if ((md->synth.alloc.map[i] & 0xff00) == key) 1610 if (md->synth.bender(md, i, w14) == EAGAIN) 1611 return (QUEUEFULL); 1612 } else 1613 if (md->synth.bender(md, chn, w14) == EAGAIN) 1614 return (QUEUEFULL); 1615 } else 1616 #endif /* notyet */ 1617 /* For Mode 1. */ 1618 if (md->synth.bender(md, chn, w14) == EAGAIN) 1619 return (QUEUEFULL); 1620 break; 1621 } 1622 1623 return (MORE); 1624 } 1625 1626 static int 1627 seq_timing(sc_p scp, u_char *event) 1628 { 1629 int unit/*, ret*/; 1630 long parm; 1631 seqdev_info *sd; 1632 1633 sd = scp->devinfo; 1634 unit = sd->unit; 1635 1636 parm = *(long *)&event[4]; 1637 1638 #if notyet 1639 if (scp->seq_mode == SEQ_2 && (ret = tmr->event(tmr_no, event)) == TIMERARMED) 1640 return (ret); 1641 #endif /* notyet */ 1642 switch (event[1]) { 1643 case TMR_WAIT_REL: 1644 parm += scp->prev_event_time; 1645 /* FALLTHRU */ 1646 case TMR_WAIT_ABS: 1647 if (parm > 0) { 1648 sd->flags |= SEQ_F_WRITING; 1649 scp->prev_event_time = parm; 1650 if (seq_requesttimer(scp, parm)) 1651 return (TIMERARMED); 1652 } 1653 break; 1654 case TMR_START: 1655 scp->seq_time = seq_gettime(); 1656 scp->prev_input_time = 0; 1657 scp->prev_event_time = 0; 1658 scp->prev_wakeup_time = scp->seq_time; 1659 break; 1660 case TMR_STOP: 1661 break; 1662 case TMR_CONTINUE: 1663 break; 1664 case TMR_TEMPO: 1665 break; 1666 case TMR_ECHO: 1667 #if notyet 1668 if (scp->seq_mode == SEQ_2) 1669 seq_copytoinput(scp, event, 8); 1670 else { 1671 #endif /* notyet */ 1672 parm = (parm << 8 | SEQ_ECHO); 1673 seq_copytoinput(scp, (u_char *)&parm, 4); 1674 #if notyet 1675 } 1676 #endif /* notyet */ 1677 break; 1678 } 1679 1680 return (MORE); 1681 } 1682 1683 static int 1684 seq_local(sc_p scp, u_char *event) 1685 { 1686 int unit; 1687 seqdev_info *sd; 1688 1689 sd = scp->devinfo; 1690 unit = sd->unit; 1691 1692 switch (event[1]) { 1693 case LOCL_STARTAUDIO: 1694 #if notyet 1695 DMAbuf_start_devices(*(u_int *)&event[4]); 1696 #endif /* notyet */ 1697 break; 1698 } 1699 1700 return (MORE); 1701 } 1702 1703 static int 1704 seq_sysex(sc_p scp, u_char *event) 1705 { 1706 int unit, i, l; 1707 seqdev_info *sd; 1708 mididev_info *md; 1709 1710 sd = scp->devinfo; 1711 unit = sd->unit; 1712 1713 if (event[1] >= nmidi + nsynth) 1714 return (MORE); 1715 md = &midi_info[event[1]]; 1716 if (!MIDICONFED(md) || md->synth.sendsysex == NULL 1717 || ((md->flags & MIDI_F_BUSY) == 0 && seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc) != 0)) 1718 return (MORE); 1719 1720 l = 0; 1721 for (i = 0 ; i < 6 && event[i + 2] != 0xff ; i++) 1722 l = i + 1; 1723 if (l > 0) 1724 if (md->synth.sendsysex(md, &event[2], l) == EAGAIN) 1725 return (QUEUEFULL); 1726 1727 return (MORE); 1728 } 1729 1730 static void 1731 seq_timer(void *arg) 1732 { 1733 sc_p scp; 1734 1735 scp = arg; 1736 1737 /*DEB(printf("seq_timer: timer fired.\n"));*/ 1738 1739 /* Record the current timestamp. */ 1740 scp->prev_wakeup_time = seq_gettime(); 1741 1742 seq_startplay(scp); 1743 } 1744 1745 static int 1746 seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p) 1747 { 1748 int midiunit, s, err; 1749 1750 if (md == NULL || !MIDICONFED(md)) { 1751 DEB(printf("seq_openmidi: midi device does not exist.\n")); 1752 return (ENXIO); 1753 } 1754 midiunit = md->unit; 1755 1756 DEB(printf("seq_openmidi: opening midi unit %d.\n", midiunit)); 1757 1758 if (!scp->midi_open[midiunit]) { 1759 err = midi_open(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, p); 1760 if (err != 0) { 1761 printf("seq_openmidi: failed to open midi device %d.\n", midiunit); 1762 return (err); 1763 } 1764 s = splmidi(); 1765 scp->midi_open[midiunit] = 1; 1766 md->intr = seq_intr; 1767 md->intrarg = scp->devinfo; 1768 md->synth.prev_out_status = 0; 1769 md->synth.sysex_state = 0; 1770 splx(s); 1771 } 1772 1773 return (0); 1774 } 1775 1776 static int 1777 seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p) 1778 { 1779 int midiunit, s; 1780 1781 if (md == NULL || !MIDICONFED(md)) { 1782 DEB(printf("seq_closemidi: midi device does not exist.\n")); 1783 return (ENXIO); 1784 } 1785 midiunit = md->unit; 1786 1787 DEB(printf("seq_closemidi: closing midi unit %d.\n", midiunit)); 1788 1789 if (scp->midi_open[midiunit]) { 1790 midi_close(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, p); 1791 s = splmidi(); 1792 scp->midi_open[midiunit] = 0; 1793 md->intr = NULL; 1794 md->intrarg = NULL; 1795 splx(s); 1796 } 1797 1798 return (0); 1799 } 1800 1801 static void 1802 seq_panic(sc_p scp) 1803 { 1804 seq_reset(scp); 1805 } 1806 1807 static int 1808 seq_reset(sc_p scp) 1809 { 1810 int unit, i, s, chn; 1811 seqdev_info *sd; 1812 mididev_info *md; 1813 u_char c[3]; 1814 1815 sd = scp->devinfo; 1816 unit = sd->unit; 1817 1818 s = splmidi(); 1819 1820 /* Stop reading and writing. */ 1821 sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_RD | SEQ_CB_WR); 1822 1823 /* Clear the queues. */ 1824 midibuf_init(&sd->midi_dbuf_in); 1825 midibuf_init(&sd->midi_dbuf_out); 1826 1827 #if notyet 1828 /* Reset the synthesizers. */ 1829 for (i = 0 ; i < nmidi + nsynth ; i++) { 1830 md = &midi_info[i]; 1831 if (MIDICONFED(md) && scp->midi_open[i]) 1832 md->synth.reset(md); 1833 } 1834 #endif /* notyet */ 1835 1836 #if notyet 1837 if (scp->seq_mode == SEQ_2) { 1838 for (chn = 0 ; chn < 16 ; chn++) 1839 for (i = 0 ; i < nmidi + nsynth ; i++) 1840 if (midi_open[i]) { 1841 md = &midi_info[i]; 1842 if (!MIDICONFED(md)) 1843 continue; 1844 if (md->synth.controller(md, chn, 123, 0) == EAGAIN /* All notes off. */ 1845 || md->synth.controller(md, chn, 121, 0) == EAGAIN /* Reset all controllers. */ 1846 || md->synth.bender(md, chn, 1 << 13) == EAGAIN) { /* Reset pitch bend. */ 1847 splx(s); 1848 return (EAGAIN); 1849 } 1850 } 1851 splx(s); 1852 } else { 1853 #endif /* notyet */ 1854 splx(s); 1855 for (i = 0 ; i < nmidi + nsynth ; i++) { 1856 md = &midi_info[i]; 1857 if (!MIDICONFED(md)) 1858 continue; 1859 1860 /* Send active sensing. */ 1861 c[0] = 0xfe; /* Active Sensing. */ 1862 if (md->synth.writeraw(md, c, 1, 0) == EAGAIN) 1863 return (EAGAIN); 1864 /* 1865 * We need a sleep to reset a midi device using an active sensing. 1866 * SC-88 resets after 420ms... 1867 */ 1868 tsleep(md, PRIBIO, "seqrst", 500 * hz / 1000); 1869 for (chn = 0 ; chn < 16 ; chn++) { 1870 c[0] = 0xb0 | (chn & 0x0f); 1871 c[1] = (u_char)0x78; /* All sound off */ 1872 c[2] = (u_char)0; 1873 if (md->synth.writeraw(md, c, 3, 0) == EAGAIN) 1874 return (EAGAIN); 1875 c[1] = (u_char)0x7b; /* All note off */ 1876 if (md->synth.writeraw(md, c, 3, 0) == EAGAIN) 1877 return (EAGAIN); 1878 c[1] = (u_char)0x79; /* Reset all controller */ 1879 if (md->synth.writeraw(md, c, 3, 0) == EAGAIN) 1880 return (EAGAIN); 1881 } 1882 } 1883 for (i = 0 ; i < nmidi + nsynth ; i++){ 1884 md = &midi_info[i]; 1885 if (MIDICONFED(md)) 1886 seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); 1887 } 1888 #if notyet 1889 } 1890 #endif /* notyet */ 1891 1892 return (0); 1893 } 1894 1895 static int 1896 seq_sync(sc_p scp) 1897 { 1898 int unit, s, i; 1899 seqdev_info *sd; 1900 1901 sd = scp->devinfo; 1902 unit = sd->unit; 1903 1904 s = splmidi(); 1905 1906 if (sd->midi_dbuf_out.rl >= EV_SZ) 1907 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR); 1908 1909 while ((sd->flags & SEQ_F_WRITING) != 0 && sd->midi_dbuf_out.rl >= EV_SZ) { 1910 i = tsleep(&sd->midi_dbuf_out.tsleep_out, PRIBIO | PCATCH, "seqsnc", 0); 1911 if (i == EINTR) 1912 sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR); 1913 if (i == EINTR || i == ERESTART) { 1914 splx(s); 1915 return (i); 1916 } 1917 } 1918 splx(s); 1919 1920 return (0); 1921 } 1922 1923 /* 1924 * a small utility function which, given a device number, returns 1925 * a pointer to the associated seqdev_info struct, and sets the unit 1926 * number. 1927 */ 1928 static seqdev_info * 1929 get_seqdev_info(dev_t i_dev, int *unit) 1930 { 1931 int u; 1932 seqdev_info *d = NULL ; 1933 1934 if (MIDIDEV(i_dev) != SND_DEV_SEQ && MIDIDEV(i_dev) != SND_DEV_SEQ2) 1935 return NULL; 1936 u = MIDIUNIT(i_dev); 1937 if (unit) 1938 *unit = u ; 1939 1940 if (u >= NSEQ_MAX) { 1941 DEB(printf("get_seqdev_info: unit %d is not configured.\n", u)); 1942 return NULL; 1943 } 1944 d = &seq_info[u]; 1945 1946 return d ; 1947 } 1948 1949 /* XXX These functions are actually redundant. */ 1950 static int 1951 seqopen(dev_t i_dev, int flags, int mode, struct proc * p) 1952 { 1953 switch (MIDIDEV(i_dev)) { 1954 case MIDI_DEV_SEQ: 1955 return seq_open(i_dev, flags, mode, p); 1956 } 1957 1958 return (ENXIO); 1959 } 1960 1961 static int 1962 seqclose(dev_t i_dev, int flags, int mode, struct proc * p) 1963 { 1964 switch (MIDIDEV(i_dev)) { 1965 case MIDI_DEV_SEQ: 1966 return seq_close(i_dev, flags, mode, p); 1967 } 1968 1969 return (ENXIO); 1970 } 1971 1972 static int 1973 seqread(dev_t i_dev, struct uio * buf, int flag) 1974 { 1975 switch (MIDIDEV(i_dev)) { 1976 case MIDI_DEV_SEQ: 1977 return seq_read(i_dev, buf, flag); 1978 } 1979 1980 return (ENXIO); 1981 } 1982 1983 static int 1984 seqwrite(dev_t i_dev, struct uio * buf, int flag) 1985 { 1986 switch (MIDIDEV(i_dev)) { 1987 case MIDI_DEV_SEQ: 1988 return seq_write(i_dev, buf, flag); 1989 } 1990 1991 return (ENXIO); 1992 } 1993 1994 static int 1995 seqioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p) 1996 { 1997 switch (MIDIDEV(i_dev)) { 1998 case MIDI_DEV_SEQ: 1999 return seq_ioctl(i_dev, cmd, arg, mode, p); 2000 } 2001 2002 return (ENXIO); 2003 } 2004 2005 static int 2006 seqpoll(dev_t i_dev, int events, struct proc * p) 2007 { 2008 switch (MIDIDEV(i_dev)) { 2009 case MIDI_DEV_SEQ: 2010 return seq_poll(i_dev, events, p); 2011 } 2012 2013 return (ENXIO); 2014 } 2015 2016 static int 2017 seq_modevent(module_t mod, int type, void *data) 2018 { 2019 int retval; 2020 2021 retval = 0; 2022 2023 switch (type) { 2024 case MOD_LOAD: 2025 seq_init(); 2026 break; 2027 2028 case MOD_UNLOAD: 2029 printf("sequencer: unload not supported yet.\n"); 2030 retval = EOPNOTSUPP; 2031 break; 2032 2033 default: 2034 break; 2035 } 2036 2037 return retval; 2038 } 2039 2040 DEV_MODULE(seq, seq_modevent, NULL); 2041