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