sys/dev/sound/midi/sequencer.c

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