1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2003 Mathew Kanner 5 * Copyright (c) 1993 Hannu Savolainen 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /* 31 * The sequencer personality manager. 32 */ 33 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/ioccom.h> 40 41 #include <sys/filio.h> 42 #include <sys/lock.h> 43 #include <sys/sockio.h> 44 #include <sys/fcntl.h> 45 #include <sys/proc.h> 46 #include <sys/sysctl.h> 47 48 #include <sys/kernel.h> /* for DATA_SET */ 49 50 #include <sys/module.h> 51 #include <sys/conf.h> 52 #include <sys/file.h> 53 #include <sys/uio.h> 54 #include <sys/syslog.h> 55 #include <sys/errno.h> 56 #include <sys/malloc.h> 57 #include <sys/bus.h> 58 #include <machine/resource.h> 59 #include <machine/bus.h> 60 #include <machine/clock.h> /* for DELAY */ 61 #include <sys/soundcard.h> 62 #include <sys/rman.h> 63 #include <sys/mman.h> 64 #include <sys/poll.h> 65 #include <sys/mutex.h> 66 #include <sys/condvar.h> 67 #include <sys/kthread.h> 68 #include <sys/unistd.h> 69 #include <sys/selinfo.h> 70 71 #ifdef HAVE_KERNEL_OPTION_HEADERS 72 #include "opt_snd.h" 73 #endif 74 75 #include <dev/sound/midi/midi.h> 76 #include <dev/sound/midi/midiq.h> 77 #include "synth_if.h" 78 79 #include <dev/sound/midi/sequencer.h> 80 81 #define TMR_TIMERBASE 13 82 83 #define SND_DEV_SEQ 1 /* Sequencer output /dev/sequencer (FM 84 * synthesizer and MIDI output) */ 85 #define SND_DEV_MUSIC 8 /* /dev/music, level 2 interface */ 86 87 /* Length of a sequencer event. */ 88 #define EV_SZ 8 89 #define IEV_SZ 8 90 91 /* Lookup modes */ 92 #define LOOKUP_EXIST (0) 93 #define LOOKUP_OPEN (1) 94 #define LOOKUP_CLOSE (2) 95 96 #define PCMMKMINOR(u, d, c) \ 97 ((((c) & 0xff) << 16) | (((u) & 0x0f) << 4) | ((d) & 0x0f)) 98 #define MIDIMKMINOR(u, d, c) PCMMKMINOR(u, d, c) 99 #define MIDIUNIT(y) ((dev2unit(y) >> 4) & 0x0f) 100 #define MIDIDEV(y) (dev2unit(y) & 0x0f) 101 102 /* These are the entries to the sequencer driver. */ 103 static d_open_t mseq_open; 104 static d_close_t mseq_close; 105 static d_ioctl_t mseq_ioctl; 106 static d_read_t mseq_read; 107 static d_write_t mseq_write; 108 static d_poll_t mseq_poll; 109 110 static struct cdevsw seq_cdevsw = { 111 .d_version = D_VERSION, 112 .d_open = mseq_open, 113 .d_close = mseq_close, 114 .d_read = mseq_read, 115 .d_write = mseq_write, 116 .d_ioctl = mseq_ioctl, 117 .d_poll = mseq_poll, 118 .d_name = "sequencer", 119 }; 120 121 struct seq_softc { 122 KOBJ_FIELDS; 123 124 struct mtx seq_lock, q_lock; 125 struct cv empty_cv, reset_cv, in_cv, out_cv, state_cv, th_cv; 126 127 MIDIQ_HEAD(, u_char) in_q, out_q; 128 129 u_long flags; 130 /* Flags (protected by flag_mtx of mididev_info) */ 131 int fflags; /* Access mode */ 132 int music; 133 134 int out_water; /* Sequence output threshould */ 135 snd_sync_parm sync_parm; /* AIOSYNC parameter set */ 136 struct thread *sync_thread; /* AIOSYNCing thread */ 137 struct selinfo in_sel, out_sel; 138 int midi_number; 139 struct cdev *seqdev, *musicdev; 140 int unit; 141 int maxunits; 142 kobj_t *midis; 143 int *midi_flags; 144 kobj_t mapper; 145 void *mapper_cookie; 146 struct timeval timerstop, timersub; 147 int timerbase, tempo; 148 int timerrun; 149 int done; 150 int playing; 151 int recording; 152 int busy; 153 int pre_event_timeout; 154 int waiting; 155 }; 156 157 /* 158 * Module specific stuff, including how many sequecers 159 * we currently own. 160 */ 161 162 SYSCTL_NODE(_hw_midi, OID_AUTO, seq, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 163 "Midi sequencer"); 164 165 int seq_debug; 166 /* XXX: should this be moved into debug.midi? */ 167 SYSCTL_INT(_hw_midi_seq, OID_AUTO, debug, CTLFLAG_RW, &seq_debug, 0, ""); 168 169 midi_cmdtab cmdtab_seqevent[] = { 170 {SEQ_NOTEOFF, "SEQ_NOTEOFF"}, 171 {SEQ_NOTEON, "SEQ_NOTEON"}, 172 {SEQ_WAIT, "SEQ_WAIT"}, 173 {SEQ_PGMCHANGE, "SEQ_PGMCHANGE"}, 174 {SEQ_SYNCTIMER, "SEQ_SYNCTIMER"}, 175 {SEQ_MIDIPUTC, "SEQ_MIDIPUTC"}, 176 {SEQ_DRUMON, "SEQ_DRUMON"}, 177 {SEQ_DRUMOFF, "SEQ_DRUMOFF"}, 178 {SEQ_ECHO, "SEQ_ECHO"}, 179 {SEQ_AFTERTOUCH, "SEQ_AFTERTOUCH"}, 180 {SEQ_CONTROLLER, "SEQ_CONTROLLER"}, 181 {SEQ_BALANCE, "SEQ_BALANCE"}, 182 {SEQ_VOLMODE, "SEQ_VOLMODE"}, 183 {SEQ_FULLSIZE, "SEQ_FULLSIZE"}, 184 {SEQ_PRIVATE, "SEQ_PRIVATE"}, 185 {SEQ_EXTENDED, "SEQ_EXTENDED"}, 186 {EV_SEQ_LOCAL, "EV_SEQ_LOCAL"}, 187 {EV_TIMING, "EV_TIMING"}, 188 {EV_CHN_COMMON, "EV_CHN_COMMON"}, 189 {EV_CHN_VOICE, "EV_CHN_VOICE"}, 190 {EV_SYSEX, "EV_SYSEX"}, 191 {-1, NULL}, 192 }; 193 194 midi_cmdtab cmdtab_seqioctl[] = { 195 {SNDCTL_SEQ_RESET, "SNDCTL_SEQ_RESET"}, 196 {SNDCTL_SEQ_SYNC, "SNDCTL_SEQ_SYNC"}, 197 {SNDCTL_SYNTH_INFO, "SNDCTL_SYNTH_INFO"}, 198 {SNDCTL_SEQ_CTRLRATE, "SNDCTL_SEQ_CTRLRATE"}, 199 {SNDCTL_SEQ_GETOUTCOUNT, "SNDCTL_SEQ_GETOUTCOUNT"}, 200 {SNDCTL_SEQ_GETINCOUNT, "SNDCTL_SEQ_GETINCOUNT"}, 201 {SNDCTL_SEQ_PERCMODE, "SNDCTL_SEQ_PERCMODE"}, 202 {SNDCTL_FM_LOAD_INSTR, "SNDCTL_FM_LOAD_INSTR"}, 203 {SNDCTL_SEQ_TESTMIDI, "SNDCTL_SEQ_TESTMIDI"}, 204 {SNDCTL_SEQ_RESETSAMPLES, "SNDCTL_SEQ_RESETSAMPLES"}, 205 {SNDCTL_SEQ_NRSYNTHS, "SNDCTL_SEQ_NRSYNTHS"}, 206 {SNDCTL_SEQ_NRMIDIS, "SNDCTL_SEQ_NRMIDIS"}, 207 {SNDCTL_SEQ_GETTIME, "SNDCTL_SEQ_GETTIME"}, 208 {SNDCTL_MIDI_INFO, "SNDCTL_MIDI_INFO"}, 209 {SNDCTL_SEQ_THRESHOLD, "SNDCTL_SEQ_THRESHOLD"}, 210 {SNDCTL_SYNTH_MEMAVL, "SNDCTL_SYNTH_MEMAVL"}, 211 {SNDCTL_FM_4OP_ENABLE, "SNDCTL_FM_4OP_ENABLE"}, 212 {SNDCTL_PMGR_ACCESS, "SNDCTL_PMGR_ACCESS"}, 213 {SNDCTL_SEQ_PANIC, "SNDCTL_SEQ_PANIC"}, 214 {SNDCTL_SEQ_OUTOFBAND, "SNDCTL_SEQ_OUTOFBAND"}, 215 {SNDCTL_TMR_TIMEBASE, "SNDCTL_TMR_TIMEBASE"}, 216 {SNDCTL_TMR_START, "SNDCTL_TMR_START"}, 217 {SNDCTL_TMR_STOP, "SNDCTL_TMR_STOP"}, 218 {SNDCTL_TMR_CONTINUE, "SNDCTL_TMR_CONTINUE"}, 219 {SNDCTL_TMR_TEMPO, "SNDCTL_TMR_TEMPO"}, 220 {SNDCTL_TMR_SOURCE, "SNDCTL_TMR_SOURCE"}, 221 {SNDCTL_TMR_METRONOME, "SNDCTL_TMR_METRONOME"}, 222 {SNDCTL_TMR_SELECT, "SNDCTL_TMR_SELECT"}, 223 {SNDCTL_MIDI_PRETIME, "SNDCTL_MIDI_PRETIME"}, 224 {AIONWRITE, "AIONWRITE"}, 225 {AIOGSIZE, "AIOGSIZE"}, 226 {AIOSSIZE, "AIOSSIZE"}, 227 {AIOGFMT, "AIOGFMT"}, 228 {AIOSFMT, "AIOSFMT"}, 229 {AIOGMIX, "AIOGMIX"}, 230 {AIOSMIX, "AIOSMIX"}, 231 {AIOSTOP, "AIOSTOP"}, 232 {AIOSYNC, "AIOSYNC"}, 233 {AIOGCAP, "AIOGCAP"}, 234 {-1, NULL}, 235 }; 236 237 midi_cmdtab cmdtab_timer[] = { 238 {TMR_WAIT_REL, "TMR_WAIT_REL"}, 239 {TMR_WAIT_ABS, "TMR_WAIT_ABS"}, 240 {TMR_STOP, "TMR_STOP"}, 241 {TMR_START, "TMR_START"}, 242 {TMR_CONTINUE, "TMR_CONTINUE"}, 243 {TMR_TEMPO, "TMR_TEMPO"}, 244 {TMR_ECHO, "TMR_ECHO"}, 245 {TMR_CLOCK, "TMR_CLOCK"}, 246 {TMR_SPP, "TMR_SPP"}, 247 {TMR_TIMESIG, "TMR_TIMESIG"}, 248 {-1, NULL}, 249 }; 250 251 midi_cmdtab cmdtab_seqcv[] = { 252 {MIDI_NOTEOFF, "MIDI_NOTEOFF"}, 253 {MIDI_NOTEON, "MIDI_NOTEON"}, 254 {MIDI_KEY_PRESSURE, "MIDI_KEY_PRESSURE"}, 255 {-1, NULL}, 256 }; 257 258 midi_cmdtab cmdtab_seqccmn[] = { 259 {MIDI_CTL_CHANGE, "MIDI_CTL_CHANGE"}, 260 {MIDI_PGM_CHANGE, "MIDI_PGM_CHANGE"}, 261 {MIDI_CHN_PRESSURE, "MIDI_CHN_PRESSURE"}, 262 {MIDI_PITCH_BEND, "MIDI_PITCH_BEND"}, 263 {MIDI_SYSTEM_PREFIX, "MIDI_SYSTEM_PREFIX"}, 264 {-1, NULL}, 265 }; 266 267 #ifndef KOBJMETHOD_END 268 #define KOBJMETHOD_END { NULL, NULL } 269 #endif 270 271 /* 272 * static const char *mpu401_mprovider(kobj_t obj, struct mpu401 *m); 273 */ 274 275 static kobj_method_t seq_methods[] = { 276 /* KOBJMETHOD(mpu_provider,mpu401_mprovider), */ 277 KOBJMETHOD_END 278 }; 279 280 DEFINE_CLASS(sequencer, seq_methods, 0); 281 282 /* The followings are the local function. */ 283 static int seq_convertold(u_char *event, u_char *out); 284 285 /* 286 * static void seq_midiinput(struct seq_softc * scp, void *md); 287 */ 288 static void seq_reset(struct seq_softc *scp); 289 static int seq_sync(struct seq_softc *scp); 290 291 static int seq_processevent(struct seq_softc *scp, u_char *event); 292 293 static int seq_timing(struct seq_softc *scp, u_char *event); 294 static int seq_local(struct seq_softc *scp, u_char *event); 295 296 static int seq_chnvoice(struct seq_softc *scp, kobj_t md, u_char *event); 297 static int seq_chncommon(struct seq_softc *scp, kobj_t md, u_char *event); 298 static int seq_sysex(struct seq_softc *scp, kobj_t md, u_char *event); 299 300 static int seq_fetch_mid(struct seq_softc *scp, int unit, kobj_t *md); 301 void seq_copytoinput(struct seq_softc *scp, u_char *event, int len); 302 int seq_modevent(module_t mod, int type, void *data); 303 struct seq_softc *seqs[10]; 304 static struct mtx seqinfo_mtx; 305 static u_long nseq = 0; 306 307 static void timer_start(struct seq_softc *t); 308 static void timer_stop(struct seq_softc *t); 309 static void timer_setvals(struct seq_softc *t, int tempo, int timerbase); 310 static void timer_wait(struct seq_softc *t, int ticks, int wait_abs); 311 static int timer_now(struct seq_softc *t); 312 313 314 static void 315 timer_start(struct seq_softc *t) 316 { 317 t->timerrun = 1; 318 getmicrotime(&t->timersub); 319 } 320 321 static void 322 timer_continue(struct seq_softc *t) 323 { 324 struct timeval now; 325 326 if (t->timerrun == 1) 327 return; 328 t->timerrun = 1; 329 getmicrotime(&now); 330 timevalsub(&now, &t->timerstop); 331 timevaladd(&t->timersub, &now); 332 } 333 334 static void 335 timer_stop(struct seq_softc *t) 336 { 337 t->timerrun = 0; 338 getmicrotime(&t->timerstop); 339 } 340 341 static void 342 timer_setvals(struct seq_softc *t, int tempo, int timerbase) 343 { 344 t->tempo = tempo; 345 t->timerbase = timerbase; 346 } 347 348 static void 349 timer_wait(struct seq_softc *t, int ticks, int wait_abs) 350 { 351 struct timeval now, when; 352 int ret; 353 unsigned long long i; 354 355 while (t->timerrun == 0) { 356 SEQ_DEBUG(2, printf("Timer wait when timer isn't running\n")); 357 /* 358 * The old sequencer used timeouts that only increased 359 * the timer when the timer was running. 360 * Hence the sequencer would stick (?) if the 361 * timer was disabled. 362 */ 363 cv_wait(&t->reset_cv, &t->seq_lock); 364 if (t->playing == 0) 365 return; 366 } 367 368 i = ticks * 60ull * 1000000ull / (t->tempo * t->timerbase); 369 370 when.tv_sec = i / 1000000; 371 when.tv_usec = i % 1000000; 372 373 #if 0 374 printf("timer_wait tempo %d timerbase %d ticks %d abs %d u_sec %llu\n", 375 t->tempo, t->timerbase, ticks, wait_abs, i); 376 #endif 377 378 if (wait_abs != 0) { 379 getmicrotime(&now); 380 timevalsub(&now, &t->timersub); 381 timevalsub(&when, &now); 382 } 383 if (when.tv_sec < 0 || when.tv_usec < 0) { 384 SEQ_DEBUG(3, 385 printf("seq_timer error negative time %lds.%06lds\n", 386 (long)when.tv_sec, (long)when.tv_usec)); 387 return; 388 } 389 i = when.tv_sec * 1000000ull; 390 i += when.tv_usec; 391 i *= hz; 392 i /= 1000000ull; 393 #if 0 394 printf("seq_timer usec %llu ticks %llu\n", 395 when.tv_sec * 1000000ull + when.tv_usec, i); 396 #endif 397 t->waiting = 1; 398 ret = cv_timedwait(&t->reset_cv, &t->seq_lock, i + 1); 399 t->waiting = 0; 400 401 if (ret != EWOULDBLOCK) 402 SEQ_DEBUG(3, printf("seq_timer didn't timeout\n")); 403 404 } 405 406 static int 407 timer_now(struct seq_softc *t) 408 { 409 struct timeval now; 410 unsigned long long i; 411 int ret; 412 413 if (t->timerrun == 0) 414 now = t->timerstop; 415 else 416 getmicrotime(&now); 417 418 timevalsub(&now, &t->timersub); 419 420 i = now.tv_sec * 1000000ull; 421 i += now.tv_usec; 422 i *= t->timerbase; 423 /* i /= t->tempo; */ 424 i /= 1000000ull; 425 426 ret = i; 427 /* 428 * printf("timer_now: %llu %d\n", i, ret); 429 */ 430 431 return ret; 432 } 433 434 static void 435 seq_eventthread(void *arg) 436 { 437 struct seq_softc *scp = arg; 438 u_char event[EV_SZ]; 439 440 mtx_lock(&scp->seq_lock); 441 SEQ_DEBUG(2, printf("seq_eventthread started\n")); 442 while (scp->done == 0) { 443 restart: 444 while (scp->playing == 0) { 445 cv_wait(&scp->state_cv, &scp->seq_lock); 446 if (scp->done) 447 goto done; 448 } 449 450 while (MIDIQ_EMPTY(scp->out_q)) { 451 cv_broadcast(&scp->empty_cv); 452 cv_wait(&scp->out_cv, &scp->seq_lock); 453 if (scp->playing == 0) 454 goto restart; 455 if (scp->done) 456 goto done; 457 } 458 459 MIDIQ_DEQ(scp->out_q, event, EV_SZ); 460 461 if (MIDIQ_AVAIL(scp->out_q) < scp->out_water) { 462 cv_broadcast(&scp->out_cv); 463 selwakeup(&scp->out_sel); 464 } 465 seq_processevent(scp, event); 466 } 467 468 done: 469 cv_broadcast(&scp->th_cv); 470 mtx_unlock(&scp->seq_lock); 471 SEQ_DEBUG(2, printf("seq_eventthread finished\n")); 472 kproc_exit(0); 473 } 474 475 /* 476 * seq_processevent: This maybe called by the event thread or the IOCTL 477 * handler for queued and out of band events respectively. 478 */ 479 static int 480 seq_processevent(struct seq_softc *scp, u_char *event) 481 { 482 int ret; 483 kobj_t m; 484 485 ret = 0; 486 487 if (event[0] == EV_SEQ_LOCAL) 488 ret = seq_local(scp, event); 489 else if (event[0] == EV_TIMING) 490 ret = seq_timing(scp, event); 491 else if (event[0] != EV_CHN_VOICE && 492 event[0] != EV_CHN_COMMON && 493 event[0] != EV_SYSEX && 494 event[0] != SEQ_MIDIPUTC) { 495 ret = 1; 496 SEQ_DEBUG(2, printf("seq_processevent not known %d\n", 497 event[0])); 498 } else if (seq_fetch_mid(scp, event[1], &m) != 0) { 499 ret = 1; 500 SEQ_DEBUG(2, printf("seq_processevent midi unit not found %d\n", 501 event[1])); 502 } else 503 switch (event[0]) { 504 case EV_CHN_VOICE: 505 ret = seq_chnvoice(scp, m, event); 506 break; 507 case EV_CHN_COMMON: 508 ret = seq_chncommon(scp, m, event); 509 break; 510 case EV_SYSEX: 511 ret = seq_sysex(scp, m, event); 512 break; 513 case SEQ_MIDIPUTC: 514 mtx_unlock(&scp->seq_lock); 515 ret = SYNTH_WRITERAW(m, &event[2], 1); 516 mtx_lock(&scp->seq_lock); 517 break; 518 } 519 return ret; 520 } 521 522 static int 523 seq_addunit(void) 524 { 525 struct seq_softc *scp; 526 int ret; 527 u_char *buf; 528 529 /* Allocate the softc. */ 530 ret = ENOMEM; 531 scp = malloc(sizeof(*scp), M_DEVBUF, M_NOWAIT | M_ZERO); 532 if (scp == NULL) { 533 SEQ_DEBUG(1, printf("seq_addunit: softc allocation failed.\n")); 534 goto err; 535 } 536 kobj_init((kobj_t)scp, &sequencer_class); 537 538 buf = malloc(sizeof(*buf) * EV_SZ * 1024, M_TEMP, M_NOWAIT | M_ZERO); 539 if (buf == NULL) 540 goto err; 541 MIDIQ_INIT(scp->in_q, buf, EV_SZ * 1024); 542 buf = malloc(sizeof(*buf) * EV_SZ * 1024, M_TEMP, M_NOWAIT | M_ZERO); 543 if (buf == NULL) 544 goto err; 545 MIDIQ_INIT(scp->out_q, buf, EV_SZ * 1024); 546 ret = EINVAL; 547 548 scp->midis = malloc(sizeof(kobj_t) * 32, M_TEMP, M_NOWAIT | M_ZERO); 549 scp->midi_flags = malloc(sizeof(*scp->midi_flags) * 32, M_TEMP, 550 M_NOWAIT | M_ZERO); 551 552 if (scp->midis == NULL || scp->midi_flags == NULL) 553 goto err; 554 555 scp->flags = 0; 556 557 mtx_init(&scp->seq_lock, "seqflq", NULL, 0); 558 cv_init(&scp->state_cv, "seqstate"); 559 cv_init(&scp->empty_cv, "seqempty"); 560 cv_init(&scp->reset_cv, "seqtimer"); 561 cv_init(&scp->out_cv, "seqqout"); 562 cv_init(&scp->in_cv, "seqqin"); 563 cv_init(&scp->th_cv, "seqstart"); 564 565 /* 566 * Init the damn timer 567 */ 568 569 scp->mapper = midimapper_addseq(scp, &scp->unit, &scp->mapper_cookie); 570 if (scp->mapper == NULL) 571 goto err; 572 573 scp->seqdev = make_dev(&seq_cdevsw, 574 MIDIMKMINOR(scp->unit, SND_DEV_SEQ, 0), UID_ROOT, 575 GID_WHEEL, 0666, "sequencer%d", scp->unit); 576 577 scp->musicdev = make_dev(&seq_cdevsw, 578 MIDIMKMINOR(scp->unit, SND_DEV_MUSIC, 0), UID_ROOT, 579 GID_WHEEL, 0666, "music%d", scp->unit); 580 581 if (scp->seqdev == NULL || scp->musicdev == NULL) 582 goto err; 583 /* 584 * TODO: Add to list of sequencers this module provides 585 */ 586 587 ret = 588 kproc_create 589 (seq_eventthread, scp, NULL, RFHIGHPID, 0, 590 "sequencer %02d", scp->unit); 591 592 if (ret) 593 goto err; 594 595 scp->seqdev->si_drv1 = scp->musicdev->si_drv1 = scp; 596 597 SEQ_DEBUG(2, printf("sequencer %d created scp %p\n", scp->unit, scp)); 598 599 ret = 0; 600 601 mtx_lock(&seqinfo_mtx); 602 seqs[nseq++] = scp; 603 mtx_unlock(&seqinfo_mtx); 604 605 goto ok; 606 607 err: 608 if (scp != NULL) { 609 if (scp->seqdev != NULL) 610 destroy_dev(scp->seqdev); 611 if (scp->musicdev != NULL) 612 destroy_dev(scp->musicdev); 613 /* 614 * TODO: Destroy mutex and cv 615 */ 616 if (scp->midis != NULL) 617 free(scp->midis, M_TEMP); 618 if (scp->midi_flags != NULL) 619 free(scp->midi_flags, M_TEMP); 620 if (scp->out_q.b) 621 free(scp->out_q.b, M_TEMP); 622 if (scp->in_q.b) 623 free(scp->in_q.b, M_TEMP); 624 free(scp, M_DEVBUF); 625 } 626 ok: 627 return ret; 628 } 629 630 static int 631 seq_delunit(int unit) 632 { 633 struct seq_softc *scp = seqs[unit]; 634 int i; 635 636 //SEQ_DEBUG(4, printf("seq_delunit: %d\n", unit)); 637 SEQ_DEBUG(1, printf("seq_delunit: 1 \n")); 638 mtx_lock(&scp->seq_lock); 639 640 scp->playing = 0; 641 scp->done = 1; 642 cv_broadcast(&scp->out_cv); 643 cv_broadcast(&scp->state_cv); 644 cv_broadcast(&scp->reset_cv); 645 SEQ_DEBUG(1, printf("seq_delunit: 2 \n")); 646 cv_wait(&scp->th_cv, &scp->seq_lock); 647 SEQ_DEBUG(1, printf("seq_delunit: 3.0 \n")); 648 mtx_unlock(&scp->seq_lock); 649 SEQ_DEBUG(1, printf("seq_delunit: 3.1 \n")); 650 651 cv_destroy(&scp->state_cv); 652 SEQ_DEBUG(1, printf("seq_delunit: 4 \n")); 653 cv_destroy(&scp->empty_cv); 654 SEQ_DEBUG(1, printf("seq_delunit: 5 \n")); 655 cv_destroy(&scp->reset_cv); 656 SEQ_DEBUG(1, printf("seq_delunit: 6 \n")); 657 cv_destroy(&scp->out_cv); 658 SEQ_DEBUG(1, printf("seq_delunit: 7 \n")); 659 cv_destroy(&scp->in_cv); 660 SEQ_DEBUG(1, printf("seq_delunit: 8 \n")); 661 cv_destroy(&scp->th_cv); 662 663 SEQ_DEBUG(1, printf("seq_delunit: 10 \n")); 664 if (scp->seqdev) 665 destroy_dev(scp->seqdev); 666 SEQ_DEBUG(1, printf("seq_delunit: 11 \n")); 667 if (scp->musicdev) 668 destroy_dev(scp->musicdev); 669 SEQ_DEBUG(1, printf("seq_delunit: 12 \n")); 670 scp->seqdev = scp->musicdev = NULL; 671 if (scp->midis != NULL) 672 free(scp->midis, M_TEMP); 673 SEQ_DEBUG(1, printf("seq_delunit: 13 \n")); 674 if (scp->midi_flags != NULL) 675 free(scp->midi_flags, M_TEMP); 676 SEQ_DEBUG(1, printf("seq_delunit: 14 \n")); 677 free(scp->out_q.b, M_TEMP); 678 SEQ_DEBUG(1, printf("seq_delunit: 15 \n")); 679 free(scp->in_q.b, M_TEMP); 680 681 SEQ_DEBUG(1, printf("seq_delunit: 16 \n")); 682 683 mtx_destroy(&scp->seq_lock); 684 SEQ_DEBUG(1, printf("seq_delunit: 17 \n")); 685 free(scp, M_DEVBUF); 686 687 mtx_lock(&seqinfo_mtx); 688 for (i = unit; i < (nseq - 1); i++) 689 seqs[i] = seqs[i + 1]; 690 nseq--; 691 mtx_unlock(&seqinfo_mtx); 692 693 return 0; 694 } 695 696 int 697 seq_modevent(module_t mod, int type, void *data) 698 { 699 int retval, r; 700 701 retval = 0; 702 703 switch (type) { 704 case MOD_LOAD: 705 mtx_init(&seqinfo_mtx, "seqmod", NULL, 0); 706 retval = seq_addunit(); 707 break; 708 709 case MOD_UNLOAD: 710 while (nseq) { 711 r = seq_delunit(nseq - 1); 712 if (r) { 713 retval = r; 714 break; 715 } 716 } 717 if (nseq == 0) { 718 retval = 0; 719 mtx_destroy(&seqinfo_mtx); 720 } 721 break; 722 723 default: 724 break; 725 } 726 727 return retval; 728 } 729 730 static int 731 seq_fetch_mid(struct seq_softc *scp, int unit, kobj_t *md) 732 { 733 734 if (unit >= scp->midi_number || unit < 0) 735 return EINVAL; 736 737 *md = scp->midis[unit]; 738 739 return 0; 740 } 741 742 int 743 mseq_open(struct cdev *i_dev, int flags, int mode, struct thread *td) 744 { 745 struct seq_softc *scp = i_dev->si_drv1; 746 int i; 747 748 if (scp == NULL) 749 return ENXIO; 750 751 SEQ_DEBUG(3, printf("seq_open: scp %p unit %d, flags 0x%x.\n", 752 scp, scp->unit, flags)); 753 754 /* 755 * Mark this device busy. 756 */ 757 758 mtx_lock(&scp->seq_lock); 759 if (scp->busy) { 760 mtx_unlock(&scp->seq_lock); 761 SEQ_DEBUG(2, printf("seq_open: unit %d is busy.\n", scp->unit)); 762 return EBUSY; 763 } 764 scp->fflags = flags; 765 /* 766 if ((scp->fflags & O_NONBLOCK) != 0) 767 scp->flags |= SEQ_F_NBIO; 768 */ 769 scp->music = MIDIDEV(i_dev) == SND_DEV_MUSIC; 770 771 /* 772 * Enumerate the available midi devices 773 */ 774 scp->midi_number = 0; 775 scp->maxunits = midimapper_open(scp->mapper, &scp->mapper_cookie); 776 777 if (scp->maxunits == 0) 778 SEQ_DEBUG(2, printf("seq_open: no midi devices\n")); 779 780 for (i = 0; i < scp->maxunits; i++) { 781 scp->midis[scp->midi_number] = 782 midimapper_fetch_synth(scp->mapper, scp->mapper_cookie, i); 783 if (scp->midis[scp->midi_number]) { 784 if (SYNTH_OPEN(scp->midis[scp->midi_number], scp, 785 scp->fflags) != 0) 786 scp->midis[scp->midi_number] = NULL; 787 else { 788 scp->midi_flags[scp->midi_number] = 789 SYNTH_QUERY(scp->midis[scp->midi_number]); 790 scp->midi_number++; 791 } 792 } 793 } 794 795 timer_setvals(scp, 60, 100); 796 797 timer_start(scp); 798 timer_stop(scp); 799 /* 800 * actually, if we're in rdonly mode, we should start the timer 801 */ 802 /* 803 * TODO: Handle recording now 804 */ 805 806 scp->out_water = MIDIQ_SIZE(scp->out_q) / 2; 807 808 scp->busy = 1; 809 mtx_unlock(&scp->seq_lock); 810 811 SEQ_DEBUG(2, printf("seq_open: opened, mode %s.\n", 812 scp->music ? "music" : "sequencer")); 813 SEQ_DEBUG(2, 814 printf("Sequencer %d %p opened maxunits %d midi_number %d:\n", 815 scp->unit, scp, scp->maxunits, scp->midi_number)); 816 for (i = 0; i < scp->midi_number; i++) 817 SEQ_DEBUG(3, printf(" midi %d %p\n", i, scp->midis[i])); 818 819 return 0; 820 } 821 822 /* 823 * mseq_close 824 */ 825 int 826 mseq_close(struct cdev *i_dev, int flags, int mode, struct thread *td) 827 { 828 int i; 829 struct seq_softc *scp = i_dev->si_drv1; 830 int ret; 831 832 if (scp == NULL) 833 return ENXIO; 834 835 SEQ_DEBUG(2, printf("seq_close: unit %d.\n", scp->unit)); 836 837 mtx_lock(&scp->seq_lock); 838 839 ret = ENXIO; 840 if (scp->busy == 0) 841 goto err; 842 843 seq_reset(scp); 844 seq_sync(scp); 845 846 for (i = 0; i < scp->midi_number; i++) 847 if (scp->midis[i]) 848 SYNTH_CLOSE(scp->midis[i]); 849 850 midimapper_close(scp->mapper, scp->mapper_cookie); 851 852 timer_stop(scp); 853 854 scp->busy = 0; 855 ret = 0; 856 857 err: 858 SEQ_DEBUG(3, printf("seq_close: closed ret = %d.\n", ret)); 859 mtx_unlock(&scp->seq_lock); 860 return ret; 861 } 862 863 int 864 mseq_read(struct cdev *i_dev, struct uio *uio, int ioflag) 865 { 866 int retval, used; 867 struct seq_softc *scp = i_dev->si_drv1; 868 869 #define SEQ_RSIZE 32 870 u_char buf[SEQ_RSIZE]; 871 872 if (scp == NULL) 873 return ENXIO; 874 875 SEQ_DEBUG(7, printf("mseq_read: unit %d, resid %zd.\n", 876 scp->unit, uio->uio_resid)); 877 878 mtx_lock(&scp->seq_lock); 879 if ((scp->fflags & FREAD) == 0) { 880 SEQ_DEBUG(2, printf("mseq_read: unit %d is not for reading.\n", 881 scp->unit)); 882 retval = EIO; 883 goto err1; 884 } 885 /* 886 * Begin recording. 887 */ 888 /* 889 * if ((scp->flags & SEQ_F_READING) == 0) 890 */ 891 /* 892 * TODO, start recording if not alread 893 */ 894 895 /* 896 * I think the semantics are to return as soon 897 * as possible. 898 * Second thought, it doens't seem like midimoutain 899 * expects that at all. 900 * TODO: Look up in some sort of spec 901 */ 902 903 while (uio->uio_resid > 0) { 904 while (MIDIQ_EMPTY(scp->in_q)) { 905 retval = EWOULDBLOCK; 906 /* 907 * I wish I knew which one to care about 908 */ 909 910 if (scp->fflags & O_NONBLOCK) 911 goto err1; 912 if (ioflag & O_NONBLOCK) 913 goto err1; 914 915 retval = cv_wait_sig(&scp->in_cv, &scp->seq_lock); 916 if (retval != 0) 917 goto err1; 918 } 919 920 used = MIN(MIDIQ_LEN(scp->in_q), uio->uio_resid); 921 used = MIN(used, SEQ_RSIZE); 922 923 SEQ_DEBUG(8, printf("midiread: uiomove cc=%d\n", used)); 924 MIDIQ_DEQ(scp->in_q, buf, used); 925 mtx_unlock(&scp->seq_lock); 926 retval = uiomove(buf, used, uio); 927 mtx_lock(&scp->seq_lock); 928 if (retval) 929 goto err1; 930 } 931 932 retval = 0; 933 err1: 934 mtx_unlock(&scp->seq_lock); 935 SEQ_DEBUG(6, printf("mseq_read: ret %d, resid %zd.\n", 936 retval, uio->uio_resid)); 937 938 return retval; 939 } 940 941 int 942 mseq_write(struct cdev *i_dev, struct uio *uio, int ioflag) 943 { 944 u_char event[EV_SZ], newevent[EV_SZ], ev_code; 945 struct seq_softc *scp = i_dev->si_drv1; 946 int retval; 947 int used; 948 949 SEQ_DEBUG(7, printf("seq_write: unit %d, resid %zd.\n", 950 scp->unit, uio->uio_resid)); 951 952 if (scp == NULL) 953 return ENXIO; 954 955 mtx_lock(&scp->seq_lock); 956 957 if ((scp->fflags & FWRITE) == 0) { 958 SEQ_DEBUG(2, printf("seq_write: unit %d is not for writing.\n", 959 scp->unit)); 960 retval = EIO; 961 goto err0; 962 } 963 while (uio->uio_resid > 0) { 964 while (MIDIQ_AVAIL(scp->out_q) == 0) { 965 retval = EWOULDBLOCK; 966 if (scp->fflags & O_NONBLOCK) 967 goto err0; 968 if (ioflag & O_NONBLOCK) 969 goto err0; 970 SEQ_DEBUG(8, printf("seq_write cvwait\n")); 971 972 scp->playing = 1; 973 cv_broadcast(&scp->out_cv); 974 cv_broadcast(&scp->state_cv); 975 976 retval = cv_wait_sig(&scp->out_cv, &scp->seq_lock); 977 /* 978 * We slept, maybe things have changed since last 979 * dying check 980 */ 981 if (retval != 0) 982 goto err0; 983 #if 0 984 /* 985 * Useless test 986 */ 987 if (scp != i_dev->si_drv1) 988 retval = ENXIO; 989 #endif 990 } 991 992 used = MIN(uio->uio_resid, 4); 993 994 SEQ_DEBUG(8, printf("seqout: resid %zd len %jd avail %jd\n", 995 uio->uio_resid, (intmax_t)MIDIQ_LEN(scp->out_q), 996 (intmax_t)MIDIQ_AVAIL(scp->out_q))); 997 998 if (used != 4) { 999 retval = ENXIO; 1000 goto err0; 1001 } 1002 mtx_unlock(&scp->seq_lock); 1003 retval = uiomove(event, used, uio); 1004 mtx_lock(&scp->seq_lock); 1005 if (retval) 1006 goto err0; 1007 1008 ev_code = event[0]; 1009 SEQ_DEBUG(8, printf("seq_write: unit %d, event %s.\n", 1010 scp->unit, midi_cmdname(ev_code, cmdtab_seqevent))); 1011 1012 /* Have a look at the event code. */ 1013 if (ev_code == SEQ_FULLSIZE) { 1014 1015 /* 1016 * TODO: restore code for SEQ_FULLSIZE 1017 */ 1018 #if 0 1019 /* 1020 * A long event, these are the patches/samples for a 1021 * synthesizer. 1022 */ 1023 midiunit = *(u_short *)&event[2]; 1024 mtx_lock(&sd->seq_lock); 1025 ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md); 1026 mtx_unlock(&sd->seq_lock); 1027 if (ret != 0) 1028 return (ret); 1029 1030 SEQ_DEBUG(printf("seq_write: loading a patch to the unit %d.\n", midiunit)); 1031 1032 ret = md->synth.loadpatch(md, *(short *)&event[0], buf, 1033 p + 4, count, 0); 1034 return (ret); 1035 #else 1036 /* 1037 * For now, just flush the darn buffer 1038 */ 1039 SEQ_DEBUG(2, 1040 printf("seq_write: SEQ_FULLSIZE flusing buffer.\n")); 1041 while (uio->uio_resid > 0) { 1042 mtx_unlock(&scp->seq_lock); 1043 retval = uiomove(event, MIN(EV_SZ, uio->uio_resid), uio); 1044 mtx_lock(&scp->seq_lock); 1045 if (retval) 1046 goto err0; 1047 1048 } 1049 retval = 0; 1050 goto err0; 1051 #endif 1052 } 1053 retval = EINVAL; 1054 if (ev_code >= 128) { 1055 int error; 1056 1057 /* 1058 * Some sort of an extended event. The size is eight 1059 * bytes. scoop extra info. 1060 */ 1061 if (scp->music && ev_code == SEQ_EXTENDED) { 1062 SEQ_DEBUG(2, printf("seq_write: invalid level two event %x.\n", ev_code)); 1063 goto err0; 1064 } 1065 mtx_unlock(&scp->seq_lock); 1066 if (uio->uio_resid < 4) 1067 error = EINVAL; 1068 else 1069 error = uiomove((caddr_t)&event[4], 4, uio); 1070 mtx_lock(&scp->seq_lock); 1071 if (error) { 1072 SEQ_DEBUG(2, 1073 printf("seq_write: user memory mangled?\n")); 1074 goto err0; 1075 } 1076 } else { 1077 /* 1078 * Size four event. 1079 */ 1080 if (scp->music) { 1081 SEQ_DEBUG(2, printf("seq_write: four byte event in music mode.\n")); 1082 goto err0; 1083 } 1084 } 1085 if (ev_code == SEQ_MIDIPUTC) { 1086 /* 1087 * TODO: event[2] is unit number to receive char. 1088 * Range check it. 1089 */ 1090 } 1091 if (scp->music) { 1092 #ifdef not_ever_ever 1093 if (event[0] == EV_TIMING && 1094 (event[1] == TMR_START || event[1] == TMR_STOP)) { 1095 /* 1096 * For now, try to make midimoutain work by 1097 * forcing these events to be processed 1098 * immediatly. 1099 */ 1100 seq_processevent(scp, event); 1101 } else 1102 MIDIQ_ENQ(scp->out_q, event, EV_SZ); 1103 #else 1104 MIDIQ_ENQ(scp->out_q, event, EV_SZ); 1105 #endif 1106 } else { 1107 if (seq_convertold(event, newevent) > 0) 1108 MIDIQ_ENQ(scp->out_q, newevent, EV_SZ); 1109 #if 0 1110 else 1111 goto err0; 1112 #endif 1113 } 1114 1115 } 1116 1117 scp->playing = 1; 1118 cv_broadcast(&scp->state_cv); 1119 cv_broadcast(&scp->out_cv); 1120 1121 retval = 0; 1122 1123 err0: 1124 SEQ_DEBUG(6, 1125 printf("seq_write done: leftover buffer length %zd retval %d\n", 1126 uio->uio_resid, retval)); 1127 mtx_unlock(&scp->seq_lock); 1128 return retval; 1129 } 1130 1131 int 1132 mseq_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode, 1133 struct thread *td) 1134 { 1135 int midiunit, ret, tmp; 1136 struct seq_softc *scp = i_dev->si_drv1; 1137 struct synth_info *synthinfo; 1138 struct midi_info *midiinfo; 1139 u_char event[EV_SZ]; 1140 u_char newevent[EV_SZ]; 1141 1142 kobj_t md; 1143 1144 /* 1145 * struct snd_size *sndsize; 1146 */ 1147 1148 if (scp == NULL) 1149 return ENXIO; 1150 1151 SEQ_DEBUG(6, printf("seq_ioctl: unit %d, cmd %s.\n", 1152 scp->unit, midi_cmdname(cmd, cmdtab_seqioctl))); 1153 1154 ret = 0; 1155 1156 switch (cmd) { 1157 case SNDCTL_SEQ_GETTIME: 1158 /* 1159 * ioctl needed by libtse 1160 */ 1161 mtx_lock(&scp->seq_lock); 1162 *(int *)arg = timer_now(scp); 1163 mtx_unlock(&scp->seq_lock); 1164 SEQ_DEBUG(6, printf("seq_ioctl: gettime %d.\n", *(int *)arg)); 1165 ret = 0; 1166 break; 1167 case SNDCTL_TMR_METRONOME: 1168 /* fallthrough */ 1169 case SNDCTL_TMR_SOURCE: 1170 /* 1171 * Not implemented 1172 */ 1173 ret = 0; 1174 break; 1175 case SNDCTL_TMR_TEMPO: 1176 event[1] = TMR_TEMPO; 1177 event[4] = *(int *)arg & 0xFF; 1178 event[5] = (*(int *)arg >> 8) & 0xFF; 1179 event[6] = (*(int *)arg >> 16) & 0xFF; 1180 event[7] = (*(int *)arg >> 24) & 0xFF; 1181 goto timerevent; 1182 case SNDCTL_TMR_TIMEBASE: 1183 event[1] = TMR_TIMERBASE; 1184 event[4] = *(int *)arg & 0xFF; 1185 event[5] = (*(int *)arg >> 8) & 0xFF; 1186 event[6] = (*(int *)arg >> 16) & 0xFF; 1187 event[7] = (*(int *)arg >> 24) & 0xFF; 1188 goto timerevent; 1189 case SNDCTL_TMR_START: 1190 event[1] = TMR_START; 1191 goto timerevent; 1192 case SNDCTL_TMR_STOP: 1193 event[1] = TMR_STOP; 1194 goto timerevent; 1195 case SNDCTL_TMR_CONTINUE: 1196 event[1] = TMR_CONTINUE; 1197 timerevent: 1198 event[0] = EV_TIMING; 1199 mtx_lock(&scp->seq_lock); 1200 if (!scp->music) { 1201 ret = EINVAL; 1202 mtx_unlock(&scp->seq_lock); 1203 break; 1204 } 1205 seq_processevent(scp, event); 1206 mtx_unlock(&scp->seq_lock); 1207 break; 1208 case SNDCTL_TMR_SELECT: 1209 SEQ_DEBUG(2, 1210 printf("seq_ioctl: SNDCTL_TMR_SELECT not supported\n")); 1211 ret = EINVAL; 1212 break; 1213 case SNDCTL_SEQ_SYNC: 1214 if (mode == O_RDONLY) { 1215 ret = 0; 1216 break; 1217 } 1218 mtx_lock(&scp->seq_lock); 1219 ret = seq_sync(scp); 1220 mtx_unlock(&scp->seq_lock); 1221 break; 1222 case SNDCTL_SEQ_PANIC: 1223 /* fallthrough */ 1224 case SNDCTL_SEQ_RESET: 1225 /* 1226 * SNDCTL_SEQ_PANIC == SNDCTL_SEQ_RESET 1227 */ 1228 mtx_lock(&scp->seq_lock); 1229 seq_reset(scp); 1230 mtx_unlock(&scp->seq_lock); 1231 ret = 0; 1232 break; 1233 case SNDCTL_SEQ_TESTMIDI: 1234 mtx_lock(&scp->seq_lock); 1235 /* 1236 * TODO: SNDCTL_SEQ_TESTMIDI now means "can I write to the 1237 * device?". 1238 */ 1239 mtx_unlock(&scp->seq_lock); 1240 break; 1241 #if 0 1242 case SNDCTL_SEQ_GETINCOUNT: 1243 if (mode == O_WRONLY) 1244 *(int *)arg = 0; 1245 else { 1246 mtx_lock(&scp->seq_lock); 1247 *(int *)arg = scp->in_q.rl; 1248 mtx_unlock(&scp->seq_lock); 1249 SEQ_DEBUG(printf("seq_ioctl: incount %d.\n", 1250 *(int *)arg)); 1251 } 1252 ret = 0; 1253 break; 1254 case SNDCTL_SEQ_GETOUTCOUNT: 1255 if (mode == O_RDONLY) 1256 *(int *)arg = 0; 1257 else { 1258 mtx_lock(&scp->seq_lock); 1259 *(int *)arg = scp->out_q.fl; 1260 mtx_unlock(&scp->seq_lock); 1261 SEQ_DEBUG(printf("seq_ioctl: outcount %d.\n", 1262 *(int *)arg)); 1263 } 1264 ret = 0; 1265 break; 1266 #endif 1267 case SNDCTL_SEQ_CTRLRATE: 1268 if (*(int *)arg != 0) { 1269 ret = EINVAL; 1270 break; 1271 } 1272 mtx_lock(&scp->seq_lock); 1273 *(int *)arg = scp->timerbase; 1274 mtx_unlock(&scp->seq_lock); 1275 SEQ_DEBUG(3, printf("seq_ioctl: ctrlrate %d.\n", *(int *)arg)); 1276 ret = 0; 1277 break; 1278 /* 1279 * TODO: ioctl SNDCTL_SEQ_RESETSAMPLES 1280 */ 1281 #if 0 1282 case SNDCTL_SEQ_RESETSAMPLES: 1283 mtx_lock(&scp->seq_lock); 1284 ret = lookup_mididev(scp, *(int *)arg, LOOKUP_OPEN, &md); 1285 mtx_unlock(&scp->seq_lock); 1286 if (ret != 0) 1287 break; 1288 ret = midi_ioctl(MIDIMKDEV(major(i_dev), *(int *)arg, 1289 SND_DEV_MIDIN), cmd, arg, mode, td); 1290 break; 1291 #endif 1292 case SNDCTL_SEQ_NRSYNTHS: 1293 mtx_lock(&scp->seq_lock); 1294 *(int *)arg = scp->midi_number; 1295 mtx_unlock(&scp->seq_lock); 1296 SEQ_DEBUG(3, printf("seq_ioctl: synths %d.\n", *(int *)arg)); 1297 ret = 0; 1298 break; 1299 case SNDCTL_SEQ_NRMIDIS: 1300 mtx_lock(&scp->seq_lock); 1301 if (scp->music) 1302 *(int *)arg = 0; 1303 else { 1304 /* 1305 * TODO: count the numbder of devices that can WRITERAW 1306 */ 1307 *(int *)arg = scp->midi_number; 1308 } 1309 mtx_unlock(&scp->seq_lock); 1310 SEQ_DEBUG(3, printf("seq_ioctl: midis %d.\n", *(int *)arg)); 1311 ret = 0; 1312 break; 1313 /* 1314 * TODO: ioctl SNDCTL_SYNTH_MEMAVL 1315 */ 1316 #if 0 1317 case SNDCTL_SYNTH_MEMAVL: 1318 mtx_lock(&scp->seq_lock); 1319 ret = lookup_mididev(scp, *(int *)arg, LOOKUP_OPEN, &md); 1320 mtx_unlock(&scp->seq_lock); 1321 if (ret != 0) 1322 break; 1323 ret = midi_ioctl(MIDIMKDEV(major(i_dev), *(int *)arg, 1324 SND_DEV_MIDIN), cmd, arg, mode, td); 1325 break; 1326 #endif 1327 case SNDCTL_SEQ_OUTOFBAND: 1328 for (ret = 0; ret < EV_SZ; ret++) 1329 event[ret] = (u_char)arg[0]; 1330 1331 mtx_lock(&scp->seq_lock); 1332 if (scp->music) 1333 ret = seq_processevent(scp, event); 1334 else { 1335 if (seq_convertold(event, newevent) > 0) 1336 ret = seq_processevent(scp, newevent); 1337 else 1338 ret = EINVAL; 1339 } 1340 mtx_unlock(&scp->seq_lock); 1341 break; 1342 case SNDCTL_SYNTH_INFO: 1343 synthinfo = (struct synth_info *)arg; 1344 midiunit = synthinfo->device; 1345 mtx_lock(&scp->seq_lock); 1346 if (seq_fetch_mid(scp, midiunit, &md) == 0) { 1347 bzero(synthinfo, sizeof(*synthinfo)); 1348 synthinfo->name[0] = 'f'; 1349 synthinfo->name[1] = 'a'; 1350 synthinfo->name[2] = 'k'; 1351 synthinfo->name[3] = 'e'; 1352 synthinfo->name[4] = 's'; 1353 synthinfo->name[5] = 'y'; 1354 synthinfo->name[6] = 'n'; 1355 synthinfo->name[7] = 't'; 1356 synthinfo->name[8] = 'h'; 1357 synthinfo->device = midiunit; 1358 synthinfo->synth_type = SYNTH_TYPE_MIDI; 1359 synthinfo->capabilities = scp->midi_flags[midiunit]; 1360 ret = 0; 1361 } else 1362 ret = EINVAL; 1363 mtx_unlock(&scp->seq_lock); 1364 break; 1365 case SNDCTL_MIDI_INFO: 1366 midiinfo = (struct midi_info *)arg; 1367 midiunit = midiinfo->device; 1368 mtx_lock(&scp->seq_lock); 1369 if (seq_fetch_mid(scp, midiunit, &md) == 0) { 1370 bzero(midiinfo, sizeof(*midiinfo)); 1371 midiinfo->name[0] = 'f'; 1372 midiinfo->name[1] = 'a'; 1373 midiinfo->name[2] = 'k'; 1374 midiinfo->name[3] = 'e'; 1375 midiinfo->name[4] = 'm'; 1376 midiinfo->name[5] = 'i'; 1377 midiinfo->name[6] = 'd'; 1378 midiinfo->name[7] = 'i'; 1379 midiinfo->device = midiunit; 1380 midiinfo->capabilities = scp->midi_flags[midiunit]; 1381 /* 1382 * TODO: What devtype? 1383 */ 1384 midiinfo->dev_type = 0x01; 1385 ret = 0; 1386 } else 1387 ret = EINVAL; 1388 mtx_unlock(&scp->seq_lock); 1389 break; 1390 case SNDCTL_SEQ_THRESHOLD: 1391 mtx_lock(&scp->seq_lock); 1392 RANGE(*(int *)arg, 1, MIDIQ_SIZE(scp->out_q) - 1); 1393 scp->out_water = *(int *)arg; 1394 mtx_unlock(&scp->seq_lock); 1395 SEQ_DEBUG(3, printf("seq_ioctl: water %d.\n", *(int *)arg)); 1396 ret = 0; 1397 break; 1398 case SNDCTL_MIDI_PRETIME: 1399 tmp = *(int *)arg; 1400 if (tmp < 0) 1401 tmp = 0; 1402 mtx_lock(&scp->seq_lock); 1403 scp->pre_event_timeout = (hz * tmp) / 10; 1404 *(int *)arg = scp->pre_event_timeout; 1405 mtx_unlock(&scp->seq_lock); 1406 SEQ_DEBUG(3, printf("seq_ioctl: pretime %d.\n", *(int *)arg)); 1407 ret = 0; 1408 break; 1409 case SNDCTL_FM_4OP_ENABLE: 1410 case SNDCTL_PMGR_IFACE: 1411 case SNDCTL_PMGR_ACCESS: 1412 /* 1413 * Patch manager and fm are ded, ded, ded. 1414 */ 1415 /* fallthrough */ 1416 default: 1417 /* 1418 * TODO: Consider ioctl default case. 1419 * Old code used to 1420 * if ((scp->fflags & O_ACCMODE) == FREAD) { 1421 * ret = EIO; 1422 * break; 1423 * } 1424 * Then pass on the ioctl to device 0 1425 */ 1426 SEQ_DEBUG(2, 1427 printf("seq_ioctl: unsupported IOCTL %ld.\n", cmd)); 1428 ret = EINVAL; 1429 break; 1430 } 1431 1432 return ret; 1433 } 1434 1435 int 1436 mseq_poll(struct cdev *i_dev, int events, struct thread *td) 1437 { 1438 int ret, lim; 1439 struct seq_softc *scp = i_dev->si_drv1; 1440 1441 SEQ_DEBUG(3, printf("seq_poll: unit %d.\n", scp->unit)); 1442 SEQ_DEBUG(1, printf("seq_poll: unit %d.\n", scp->unit)); 1443 1444 mtx_lock(&scp->seq_lock); 1445 1446 ret = 0; 1447 1448 /* Look up the apropriate queue and select it. */ 1449 if ((events & (POLLOUT | POLLWRNORM)) != 0) { 1450 /* Start playing. */ 1451 scp->playing = 1; 1452 cv_broadcast(&scp->state_cv); 1453 cv_broadcast(&scp->out_cv); 1454 1455 lim = scp->out_water; 1456 1457 if (MIDIQ_AVAIL(scp->out_q) < lim) 1458 /* No enough space, record select. */ 1459 selrecord(td, &scp->out_sel); 1460 else 1461 /* We can write now. */ 1462 ret |= events & (POLLOUT | POLLWRNORM); 1463 } 1464 if ((events & (POLLIN | POLLRDNORM)) != 0) { 1465 /* TODO: Start recording. */ 1466 1467 /* Find out the boundary. */ 1468 lim = 1; 1469 if (MIDIQ_LEN(scp->in_q) < lim) 1470 /* No data ready, record select. */ 1471 selrecord(td, &scp->in_sel); 1472 else 1473 /* We can read now. */ 1474 ret |= events & (POLLIN | POLLRDNORM); 1475 } 1476 mtx_unlock(&scp->seq_lock); 1477 1478 return (ret); 1479 } 1480 1481 #if 0 1482 static void 1483 sein_qtr(void *p, void /* mididev_info */ *md) 1484 { 1485 struct seq_softc *scp; 1486 1487 scp = (struct seq_softc *)p; 1488 1489 mtx_lock(&scp->seq_lock); 1490 1491 /* Restart playing if we have the data to output. */ 1492 if (scp->queueout_pending) 1493 seq_callback(scp, SEQ_CB_START | SEQ_CB_WR); 1494 /* Check the midi device if we are reading. */ 1495 if ((scp->flags & SEQ_F_READING) != 0) 1496 seq_midiinput(scp, md); 1497 1498 mtx_unlock(&scp->seq_lock); 1499 } 1500 1501 #endif 1502 /* 1503 * seq_convertold 1504 * Was the old playevent. Use this to convert and old 1505 * style /dev/sequencer event to a /dev/music event 1506 */ 1507 static int 1508 seq_convertold(u_char *event, u_char *out) 1509 { 1510 int used; 1511 u_char dev, chn, note, vel; 1512 1513 out[0] = out[1] = out[2] = out[3] = out[4] = out[5] = out[6] = 1514 out[7] = 0; 1515 1516 dev = 0; 1517 chn = event[1]; 1518 note = event[2]; 1519 vel = event[3]; 1520 1521 used = 0; 1522 1523 restart: 1524 /* 1525 * TODO: Debug statement 1526 */ 1527 switch (event[0]) { 1528 case EV_TIMING: 1529 case EV_CHN_VOICE: 1530 case EV_CHN_COMMON: 1531 case EV_SYSEX: 1532 case EV_SEQ_LOCAL: 1533 out[0] = event[0]; 1534 out[1] = event[1]; 1535 out[2] = event[2]; 1536 out[3] = event[3]; 1537 out[4] = event[4]; 1538 out[5] = event[5]; 1539 out[6] = event[6]; 1540 out[7] = event[7]; 1541 used += 8; 1542 break; 1543 case SEQ_NOTEOFF: 1544 out[0] = EV_CHN_VOICE; 1545 out[1] = dev; 1546 out[2] = MIDI_NOTEOFF; 1547 out[3] = chn; 1548 out[4] = note; 1549 out[5] = 255; 1550 used += 4; 1551 break; 1552 1553 case SEQ_NOTEON: 1554 out[0] = EV_CHN_VOICE; 1555 out[1] = dev; 1556 out[2] = MIDI_NOTEON; 1557 out[3] = chn; 1558 out[4] = note; 1559 out[5] = vel; 1560 used += 4; 1561 break; 1562 1563 /* 1564 * wait delay = (event[2] << 16) + (event[3] << 8) + event[4] 1565 */ 1566 1567 case SEQ_PGMCHANGE: 1568 out[0] = EV_CHN_COMMON; 1569 out[1] = dev; 1570 out[2] = MIDI_PGM_CHANGE; 1571 out[3] = chn; 1572 out[4] = note; 1573 out[5] = vel; 1574 used += 4; 1575 break; 1576 /* 1577 out[0] = EV_TIMING; 1578 out[1] = dev; 1579 out[2] = MIDI_PGM_CHANGE; 1580 out[3] = chn; 1581 out[4] = note; 1582 out[5] = vel; 1583 SEQ_DEBUG(4,printf("seq_playevent: synctimer\n")); 1584 break; 1585 */ 1586 1587 case SEQ_MIDIPUTC: 1588 SEQ_DEBUG(4, 1589 printf("seq_playevent: put data 0x%02x, unit %d.\n", 1590 event[1], event[2])); 1591 /* 1592 * Pass through to the midi device. 1593 * device = event[2] 1594 * data = event[1] 1595 */ 1596 out[0] = SEQ_MIDIPUTC; 1597 out[1] = dev; 1598 out[2] = chn; 1599 used += 4; 1600 break; 1601 #ifdef notyet 1602 case SEQ_ECHO: 1603 /* 1604 * This isn't handled here yet because I don't know if I can 1605 * just use four bytes events. There might be consequences 1606 * in the _read routing 1607 */ 1608 if (seq_copytoinput(scp, event, 4) == EAGAIN) { 1609 ret = QUEUEFULL; 1610 break; 1611 } 1612 ret = MORE; 1613 break; 1614 #endif 1615 case SEQ_EXTENDED: 1616 switch (event[1]) { 1617 case SEQ_NOTEOFF: 1618 case SEQ_NOTEON: 1619 case SEQ_PGMCHANGE: 1620 event++; 1621 used = 4; 1622 goto restart; 1623 break; 1624 case SEQ_AFTERTOUCH: 1625 /* 1626 * SYNTH_AFTERTOUCH(md, event[3], event[4]) 1627 */ 1628 case SEQ_BALANCE: 1629 /* 1630 * SYNTH_PANNING(md, event[3], (char)event[4]) 1631 */ 1632 case SEQ_CONTROLLER: 1633 /* 1634 * SYNTH_CONTROLLER(md, event[3], event[4], *(short *)&event[5]) 1635 */ 1636 case SEQ_VOLMODE: 1637 /* 1638 * SYNTH_VOLUMEMETHOD(md, event[3]) 1639 */ 1640 default: 1641 SEQ_DEBUG(2, 1642 printf("seq_convertold: SEQ_EXTENDED type %d" 1643 "not handled\n", event[1])); 1644 break; 1645 } 1646 break; 1647 case SEQ_WAIT: 1648 out[0] = EV_TIMING; 1649 out[1] = TMR_WAIT_REL; 1650 out[4] = event[2]; 1651 out[5] = event[3]; 1652 out[6] = event[4]; 1653 1654 SEQ_DEBUG(5, printf("SEQ_WAIT %d", 1655 event[2] + (event[3] << 8) + (event[4] << 24))); 1656 1657 used += 4; 1658 break; 1659 1660 case SEQ_ECHO: 1661 case SEQ_SYNCTIMER: 1662 case SEQ_PRIVATE: 1663 default: 1664 SEQ_DEBUG(2, 1665 printf("seq_convertold: event type %d not handled %d %d %d\n", 1666 event[0], event[1], event[2], event[3])); 1667 break; 1668 } 1669 return used; 1670 } 1671 1672 /* 1673 * Writting to the sequencer buffer never blocks and drops 1674 * input which cannot be queued 1675 */ 1676 void 1677 seq_copytoinput(struct seq_softc *scp, u_char *event, int len) 1678 { 1679 1680 mtx_assert(&scp->seq_lock, MA_OWNED); 1681 1682 if (MIDIQ_AVAIL(scp->in_q) < len) { 1683 /* 1684 * ENOROOM? EINPUTDROPPED? ETOUGHLUCK? 1685 */ 1686 SEQ_DEBUG(2, printf("seq_copytoinput: queue full\n")); 1687 } else { 1688 MIDIQ_ENQ(scp->in_q, event, len); 1689 selwakeup(&scp->in_sel); 1690 cv_broadcast(&scp->in_cv); 1691 } 1692 1693 } 1694 1695 static int 1696 seq_chnvoice(struct seq_softc *scp, kobj_t md, u_char *event) 1697 { 1698 int ret, voice; 1699 u_char cmd, chn, note, parm; 1700 1701 ret = 0; 1702 cmd = event[2]; 1703 chn = event[3]; 1704 note = event[4]; 1705 parm = event[5]; 1706 1707 mtx_assert(&scp->seq_lock, MA_OWNED); 1708 1709 SEQ_DEBUG(5, printf("seq_chnvoice: unit %d, dev %d, cmd %s," 1710 " chn %d, note %d, parm %d.\n", scp->unit, event[1], 1711 midi_cmdname(cmd, cmdtab_seqcv), chn, note, parm)); 1712 1713 voice = SYNTH_ALLOC(md, chn, note); 1714 1715 mtx_unlock(&scp->seq_lock); 1716 1717 switch (cmd) { 1718 case MIDI_NOTEON: 1719 if (note < 128 || note == 255) { 1720 #if 0 1721 if (scp->music && chn == 9) { 1722 /* 1723 * This channel is a percussion. The note 1724 * number is the patch number. 1725 */ 1726 /* 1727 mtx_unlock(&scp->seq_lock); 1728 if (SYNTH_SETINSTR(md, voice, 128 + note) 1729 == EAGAIN) { 1730 mtx_lock(&scp->seq_lock); 1731 return (QUEUEFULL); 1732 } 1733 mtx_lock(&scp->seq_lock); 1734 */ 1735 note = 60; /* Middle C. */ 1736 } 1737 #endif 1738 if (scp->music) { 1739 /* 1740 mtx_unlock(&scp->seq_lock); 1741 if (SYNTH_SETUPVOICE(md, voice, chn) 1742 == EAGAIN) { 1743 mtx_lock(&scp->seq_lock); 1744 return (QUEUEFULL); 1745 } 1746 mtx_lock(&scp->seq_lock); 1747 */ 1748 } 1749 SYNTH_STARTNOTE(md, voice, note, parm); 1750 } 1751 break; 1752 case MIDI_NOTEOFF: 1753 SYNTH_KILLNOTE(md, voice, note, parm); 1754 break; 1755 case MIDI_KEY_PRESSURE: 1756 SYNTH_AFTERTOUCH(md, voice, parm); 1757 break; 1758 default: 1759 ret = 1; 1760 SEQ_DEBUG(2, printf("seq_chnvoice event type %d not handled\n", 1761 event[1])); 1762 break; 1763 } 1764 1765 mtx_lock(&scp->seq_lock); 1766 return ret; 1767 } 1768 1769 static int 1770 seq_chncommon(struct seq_softc *scp, kobj_t md, u_char *event) 1771 { 1772 int ret; 1773 u_short w14; 1774 u_char cmd, chn, p1; 1775 1776 ret = 0; 1777 cmd = event[2]; 1778 chn = event[3]; 1779 p1 = event[4]; 1780 w14 = *(u_short *)&event[6]; 1781 1782 SEQ_DEBUG(5, printf("seq_chncommon: unit %d, dev %d, cmd %s, chn %d," 1783 " p1 %d, w14 %d.\n", scp->unit, event[1], 1784 midi_cmdname(cmd, cmdtab_seqccmn), chn, p1, w14)); 1785 mtx_unlock(&scp->seq_lock); 1786 switch (cmd) { 1787 case MIDI_PGM_CHANGE: 1788 SEQ_DEBUG(4, printf("seq_chncommon pgmchn chn %d pg %d\n", 1789 chn, p1)); 1790 SYNTH_SETINSTR(md, chn, p1); 1791 break; 1792 case MIDI_CTL_CHANGE: 1793 SEQ_DEBUG(4, printf("seq_chncommon ctlch chn %d pg %d %d\n", 1794 chn, p1, w14)); 1795 SYNTH_CONTROLLER(md, chn, p1, w14); 1796 break; 1797 case MIDI_PITCH_BEND: 1798 if (scp->music) { 1799 /* 1800 * TODO: MIDI_PITCH_BEND 1801 */ 1802 #if 0 1803 mtx_lock(&md->synth.vc_mtx); 1804 md->synth.chn_info[chn].bender_value = w14; 1805 if (md->midiunit >= 0) { 1806 /* 1807 * Handle all of the notes playing on this 1808 * channel. 1809 */ 1810 key = ((int)chn << 8); 1811 for (i = 0; i < md->synth.alloc.max_voice; i++) 1812 if ((md->synth.alloc.map[i] & 0xff00) == key) { 1813 mtx_unlock(&md->synth.vc_mtx); 1814 mtx_unlock(&scp->seq_lock); 1815 if (md->synth.bender(md, i, w14) == EAGAIN) { 1816 mtx_lock(&scp->seq_lock); 1817 return (QUEUEFULL); 1818 } 1819 mtx_lock(&scp->seq_lock); 1820 } 1821 } else { 1822 mtx_unlock(&md->synth.vc_mtx); 1823 mtx_unlock(&scp->seq_lock); 1824 if (md->synth.bender(md, chn, w14) == EAGAIN) { 1825 mtx_lock(&scp->seq_lock); 1826 return (QUEUEFULL); 1827 } 1828 mtx_lock(&scp->seq_lock); 1829 } 1830 #endif 1831 } else 1832 SYNTH_BENDER(md, chn, w14); 1833 break; 1834 default: 1835 ret = 1; 1836 SEQ_DEBUG(2, 1837 printf("seq_chncommon event type %d not handled.\n", 1838 event[1])); 1839 break; 1840 1841 } 1842 mtx_lock(&scp->seq_lock); 1843 return ret; 1844 } 1845 1846 static int 1847 seq_timing(struct seq_softc *scp, u_char *event) 1848 { 1849 int param; 1850 int ret; 1851 1852 ret = 0; 1853 param = event[4] + (event[5] << 8) + 1854 (event[6] << 16) + (event[7] << 24); 1855 1856 SEQ_DEBUG(5, printf("seq_timing: unit %d, cmd %d, param %d.\n", 1857 scp->unit, event[1], param)); 1858 switch (event[1]) { 1859 case TMR_WAIT_REL: 1860 timer_wait(scp, param, 0); 1861 break; 1862 case TMR_WAIT_ABS: 1863 timer_wait(scp, param, 1); 1864 break; 1865 case TMR_START: 1866 timer_start(scp); 1867 cv_broadcast(&scp->reset_cv); 1868 break; 1869 case TMR_STOP: 1870 timer_stop(scp); 1871 /* 1872 * The following cv_broadcast isn't needed since we only 1873 * wait for 0->1 transitions. It probably won't hurt 1874 */ 1875 cv_broadcast(&scp->reset_cv); 1876 break; 1877 case TMR_CONTINUE: 1878 timer_continue(scp); 1879 cv_broadcast(&scp->reset_cv); 1880 break; 1881 case TMR_TEMPO: 1882 if (param < 8) 1883 param = 8; 1884 if (param > 360) 1885 param = 360; 1886 SEQ_DEBUG(4, printf("Timer set tempo %d\n", param)); 1887 timer_setvals(scp, param, scp->timerbase); 1888 break; 1889 case TMR_TIMERBASE: 1890 if (param < 1) 1891 param = 1; 1892 if (param > 1000) 1893 param = 1000; 1894 SEQ_DEBUG(4, printf("Timer set timerbase %d\n", param)); 1895 timer_setvals(scp, scp->tempo, param); 1896 break; 1897 case TMR_ECHO: 1898 /* 1899 * TODO: Consider making 4-byte events for /dev/sequencer 1900 * PRO: Maybe needed by legacy apps 1901 * CON: soundcard.h has been warning for a while many years 1902 * to expect 8 byte events. 1903 */ 1904 #if 0 1905 if (scp->music) 1906 seq_copytoinput(scp, event, 8); 1907 else { 1908 param = (param << 8 | SEQ_ECHO); 1909 seq_copytoinput(scp, (u_char *)¶m, 4); 1910 } 1911 #else 1912 seq_copytoinput(scp, event, 8); 1913 #endif 1914 break; 1915 default: 1916 SEQ_DEBUG(2, printf("seq_timing event type %d not handled.\n", 1917 event[1])); 1918 ret = 1; 1919 break; 1920 } 1921 return ret; 1922 } 1923 1924 static int 1925 seq_local(struct seq_softc *scp, u_char *event) 1926 { 1927 int ret; 1928 1929 ret = 0; 1930 mtx_assert(&scp->seq_lock, MA_OWNED); 1931 1932 SEQ_DEBUG(5, printf("seq_local: unit %d, cmd %d\n", scp->unit, 1933 event[1])); 1934 switch (event[1]) { 1935 default: 1936 SEQ_DEBUG(1, printf("seq_local event type %d not handled\n", 1937 event[1])); 1938 ret = 1; 1939 break; 1940 } 1941 return ret; 1942 } 1943 1944 static int 1945 seq_sysex(struct seq_softc *scp, kobj_t md, u_char *event) 1946 { 1947 int i, l; 1948 1949 mtx_assert(&scp->seq_lock, MA_OWNED); 1950 SEQ_DEBUG(5, printf("seq_sysex: unit %d device %d\n", scp->unit, 1951 event[1])); 1952 l = 0; 1953 for (i = 0; i < 6 && event[i + 2] != 0xff; i++) 1954 l = i + 1; 1955 if (l > 0) { 1956 mtx_unlock(&scp->seq_lock); 1957 if (SYNTH_SENDSYSEX(md, &event[2], l) == EAGAIN) { 1958 mtx_lock(&scp->seq_lock); 1959 return 1; 1960 } 1961 mtx_lock(&scp->seq_lock); 1962 } 1963 return 0; 1964 } 1965 1966 /* 1967 * Reset no longer closes the raw devices nor seq_sync's 1968 * Callers are IOCTL and seq_close 1969 */ 1970 static void 1971 seq_reset(struct seq_softc *scp) 1972 { 1973 int chn, i; 1974 kobj_t m; 1975 1976 mtx_assert(&scp->seq_lock, MA_OWNED); 1977 1978 SEQ_DEBUG(5, printf("seq_reset: unit %d.\n", scp->unit)); 1979 1980 /* 1981 * Stop reading and writing. 1982 */ 1983 1984 /* scp->recording = 0; */ 1985 scp->playing = 0; 1986 cv_broadcast(&scp->state_cv); 1987 cv_broadcast(&scp->out_cv); 1988 cv_broadcast(&scp->reset_cv); 1989 1990 /* 1991 * For now, don't reset the timers. 1992 */ 1993 MIDIQ_CLEAR(scp->in_q); 1994 MIDIQ_CLEAR(scp->out_q); 1995 1996 for (i = 0; i < scp->midi_number; i++) { 1997 m = scp->midis[i]; 1998 mtx_unlock(&scp->seq_lock); 1999 SYNTH_RESET(m); 2000 for (chn = 0; chn < 16; chn++) { 2001 SYNTH_CONTROLLER(m, chn, 123, 0); 2002 SYNTH_CONTROLLER(m, chn, 121, 0); 2003 SYNTH_BENDER(m, chn, 1 << 13); 2004 } 2005 mtx_lock(&scp->seq_lock); 2006 } 2007 } 2008 2009 /* 2010 * seq_sync 2011 * *really* flush the output queue 2012 * flush the event queue, then flush the synthsisers. 2013 * Callers are IOCTL and close 2014 */ 2015 2016 #define SEQ_SYNC_TIMEOUT 8 2017 static int 2018 seq_sync(struct seq_softc *scp) 2019 { 2020 int i, rl, sync[16], done; 2021 2022 mtx_assert(&scp->seq_lock, MA_OWNED); 2023 2024 SEQ_DEBUG(4, printf("seq_sync: unit %d.\n", scp->unit)); 2025 2026 /* 2027 * Wait until output queue is empty. Check every so often to see if 2028 * the queue is moving along. If it isn't just abort. 2029 */ 2030 while (!MIDIQ_EMPTY(scp->out_q)) { 2031 2032 if (!scp->playing) { 2033 scp->playing = 1; 2034 cv_broadcast(&scp->state_cv); 2035 cv_broadcast(&scp->out_cv); 2036 } 2037 rl = MIDIQ_LEN(scp->out_q); 2038 2039 i = cv_timedwait_sig(&scp->out_cv, 2040 &scp->seq_lock, SEQ_SYNC_TIMEOUT * hz); 2041 2042 if (i == EINTR || i == ERESTART) { 2043 if (i == EINTR) { 2044 /* 2045 * XXX: I don't know why we stop playing 2046 */ 2047 scp->playing = 0; 2048 cv_broadcast(&scp->out_cv); 2049 } 2050 return i; 2051 } 2052 if (i == EWOULDBLOCK && rl == MIDIQ_LEN(scp->out_q) && 2053 scp->waiting == 0) { 2054 /* 2055 * A queue seems to be stuck up. Give up and clear 2056 * queues. 2057 */ 2058 MIDIQ_CLEAR(scp->out_q); 2059 scp->playing = 0; 2060 cv_broadcast(&scp->state_cv); 2061 cv_broadcast(&scp->out_cv); 2062 cv_broadcast(&scp->reset_cv); 2063 2064 /* 2065 * TODO: Consider if the raw devices need to be flushed 2066 */ 2067 2068 SEQ_DEBUG(1, printf("seq_sync queue stuck, aborting\n")); 2069 2070 return i; 2071 } 2072 } 2073 2074 scp->playing = 0; 2075 /* 2076 * Since syncing a midi device might block, unlock scp->seq_lock. 2077 */ 2078 2079 mtx_unlock(&scp->seq_lock); 2080 for (i = 0; i < scp->midi_number; i++) 2081 sync[i] = 1; 2082 2083 do { 2084 done = 1; 2085 for (i = 0; i < scp->midi_number; i++) 2086 if (sync[i]) { 2087 if (SYNTH_INSYNC(scp->midis[i]) == 0) 2088 sync[i] = 0; 2089 else 2090 done = 0; 2091 } 2092 if (!done) 2093 DELAY(5000); 2094 2095 } while (!done); 2096 2097 mtx_lock(&scp->seq_lock); 2098 return 0; 2099 } 2100 2101 char * 2102 midi_cmdname(int cmd, midi_cmdtab *tab) 2103 { 2104 while (tab->name != NULL) { 2105 if (cmd == tab->cmd) 2106 return (tab->name); 2107 tab++; 2108 } 2109 2110 return ("unknown"); 2111 } 2112