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

Cache object: 802a3afdfb3aef2be36dd5d4be9b593d


[ 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.