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