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