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