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