sys/dev/sound/midi/sequencer.c

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