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