The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/sound/midi/sequencer.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: 39c9f7d458628520dfca6c161d8d1a2f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.