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  * The sequencer personality manager.
    3  * 
    4  * Copyright by Hannu Savolainen 1993
    5  * 
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions are
    8  * met: 1. Redistributions of source code must retain the above copyright
    9  * notice, this list of conditions and the following disclaimer. 2.
   10  * Redistributions in binary form must reproduce the above copyright notice,
   11  * this list of conditions and the following disclaimer in the documentation
   12  * and/or other materials provided with the distribution.
   13  * 
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
   15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   17  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
   18  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   20  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   21  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  * $FreeBSD: releng/5.0/sys/dev/sound/midi/sequencer.c 93818 2002-04-04 21:03:38Z jhb $
   27  *
   28  */
   29 
   30 /*
   31  * This is the newmidi sequencer driver. This driver handles io against
   32  * /dev/sequencer, midi input and output event queues and event transmittion
   33  * to and from a midi device or synthesizer.
   34  */
   35 
   36 #include <dev/sound/midi/midi.h>
   37 #include <dev/sound/midi/sequencer.h>
   38 
   39 #define SND_DEV_SEQ     1       /* Sequencer output /dev/sequencer (FM
   40                                    synthesizer and MIDI output) */
   41 #define SND_DEV_MIDIN   2       /* Raw midi access */
   42 #define SND_DEV_MUSIC   8       /* /dev/music, level 2 interface */
   43 
   44 #define MIDIDEV_MODE 0x2000
   45 
   46 /* Length of a sequencer event. */
   47 #define EV_SZ 8
   48 #define IEV_SZ 8
   49 
   50 /* Lookup modes */
   51 #define LOOKUP_EXIST    (0)
   52 #define LOOKUP_OPEN     (1)
   53 #define LOOKUP_CLOSE    (2)
   54 
   55 /*
   56  * These functions goes into seq_op_desc to get called
   57  * from sound.c.
   58  */
   59 
   60 static midi_intr_t seq_intr;
   61 static midi_callback_t seq_callback;
   62 
   63 /* These are the entries to the sequencer driver. */
   64 static d_open_t seq_open;
   65 static d_close_t seq_close;
   66 static d_ioctl_t seq_ioctl;
   67 static d_read_t seq_read;
   68 static d_write_t seq_write;
   69 static d_poll_t seq_poll;
   70 
   71 /*
   72  * This is the device descriptor for the midi sequencer.
   73  */
   74 seqdev_info seq_op_desc = {
   75         "midi sequencer",
   76 
   77         0,
   78 
   79         seq_open,
   80         seq_close,
   81         seq_read,
   82         seq_write,
   83         seq_ioctl,
   84         seq_poll,
   85 
   86         seq_callback,
   87 
   88         SEQ_BUFFSIZE, /* Queue Length */
   89 
   90         0, /* XXX This is not an *audio* device! */
   91 };
   92 
   93 
   94 /* Here is the parameter structure per a device. */
   95 struct seq_softc {
   96         seqdev_info     *devinfo;               /* sequencer device information */
   97 
   98         /* Flags (protected by flag_mtx of mididev_info) */
   99         int             fflags;                 /* Access mode */
  100         int             queueout_pending;       /* Pending for the output queue */
  101         int             seq_mode;               /* Sequencer mode */
  102 
  103         /* Timer counters */
  104         u_long          seq_time;               /* The beggining time of this sequence */
  105         u_long          prev_event_time;        /* The time of the previous event output */
  106         u_long          prev_input_time;        /* The time of the previous event input */
  107         u_long          prev_wakeup_time;       /* The time of the previous wakeup */
  108         struct callout  timeout_ch;             /* Timer callout handler */
  109         long            timer_current;          /* Current timer value */
  110         int             timer_running;          /* State of timer */
  111         int             pending_timer;          /* Timer change operation */
  112         int             pre_event_timeout;      /* Time to wait event input */
  113 
  114         /* Devices */
  115         TAILQ_HEAD(,_mididev_info)      midi_open;      /* Midi devices opened by this sequencer. */
  116         timerdev_info   *timer;                 /* A timer device for /dev/music */
  117 
  118         /*
  119          * XXX not sure to which category these belong.
  120          * (and some might be no-op)
  121          */
  122         int             output_threshould;      /* Sequence output threshould */
  123         snd_sync_parm   sync_parm;              /* AIOSYNC parameter set */
  124         struct thread   *sync_thread;           /* AIOSYNCing thread */
  125 };
  126 
  127 typedef struct seq_softc *sc_p;
  128 
  129 static d_open_t seqopen;
  130 static d_close_t seqclose;
  131 static d_ioctl_t seqioctl;
  132 static d_read_t seqread;
  133 static d_write_t seqwrite;
  134 static d_poll_t seqpoll;
  135 
  136 #define CDEV_MAJOR SEQ_CDEV_MAJOR
  137 static struct cdevsw seq_cdevsw = {
  138         /* open */      seqopen,
  139         /* close */     seqclose,
  140         /* read */      seqread,
  141         /* write */     seqwrite,
  142         /* ioctl */     seqioctl,
  143         /* poll */      seqpoll,
  144         /* mmap */      nommap,
  145         /* strategy */  nostrategy,
  146         /* name */      "midi", /* XXX */
  147         /* maj */       CDEV_MAJOR,
  148         /* dump */      nodump,
  149         /* psize */     nopsize,
  150         /* flags */     0,
  151 };
  152 
  153 
  154 static TAILQ_HEAD(,_seqdev_info)        seq_info;
  155 /* Mutex to protect seq_info and nseq. */
  156 static struct mtx                       seqinfo_mtx;
  157 /* total number of sequencers */
  158 static u_long                           nseq;
  159 static dev_t                            seq_alias = NODEV;
  160 static dev_t                            music_alias = NODEV;
  161 
  162 SYSCTL_NODE(_hw_midi, OID_AUTO, seq, CTLFLAG_RD, 0, "Midi sequencer");
  163 
  164 int                                     seq_debug;
  165 SYSCTL_INT(_hw_midi_seq, OID_AUTO, debug, CTLFLAG_RW, &seq_debug, 0, "");
  166 
  167 static midi_cmdtab      cmdtab_seqevent[] = {
  168         {SEQ_NOTEOFF,           "SEQ_NOTEOFF"},
  169         {SEQ_NOTEON,            "SEQ_NOTEON"},
  170         {SEQ_WAIT,              "SEQ_WAIT"},
  171         {SEQ_PGMCHANGE,         "SEQ_PGMCHANGE"},
  172         {SEQ_SYNCTIMER,         "SEQ_SYNCTIMER"},
  173         {SEQ_MIDIPUTC,          "SEQ_MIDIPUTC"},
  174         {SEQ_DRUMON,            "SEQ_DRUMON"},
  175         {SEQ_DRUMOFF,           "SEQ_DRUMOFF"},
  176         {SEQ_ECHO,              "SEQ_ECHO"},
  177         {SEQ_AFTERTOUCH,        "SEQ_AFTERTOUCH"},
  178         {SEQ_CONTROLLER,        "SEQ_CONTROLLER"},
  179         {SEQ_BALANCE,           "SEQ_BALANCE"},
  180         {SEQ_VOLMODE,           "SEQ_VOLMODE"},
  181         {SEQ_FULLSIZE,          "SEQ_FULLSIZE"},
  182         {SEQ_PRIVATE,           "SEQ_PRIVATE"},
  183         {SEQ_EXTENDED,          "SEQ_EXTENDED"},
  184         {EV_SEQ_LOCAL,          "EV_SEQ_LOCAL"},
  185         {EV_TIMING,             "EV_TIMING"},
  186         {EV_CHN_COMMON,         "EV_CHN_COMMON"},
  187         {EV_CHN_VOICE,          "EV_CHN_VOICE"},
  188         {EV_SYSEX,              "EV_SYSEX"},
  189         {-1,                    NULL},
  190 };
  191 
  192 midi_cmdtab     cmdtab_seqioctl[] = {
  193         {SNDCTL_SEQ_RESET,      "SNDCTL_SEQ_RESET"},
  194         {SNDCTL_SEQ_SYNC,       "SNDCTL_SEQ_SYNC"},
  195         {SNDCTL_SYNTH_INFO,     "SNDCTL_SYNTH_INFO"},
  196         {SNDCTL_SEQ_CTRLRATE,   "SNDCTL_SEQ_CTRLRATE"},
  197         {SNDCTL_SEQ_GETOUTCOUNT,        "SNDCTL_SEQ_GETOUTCOUNT"},
  198         {SNDCTL_SEQ_GETINCOUNT, "SNDCTL_SEQ_GETINCOUNT"},
  199         {SNDCTL_SEQ_PERCMODE,   "SNDCTL_SEQ_PERCMODE"},
  200         {SNDCTL_FM_LOAD_INSTR,  "SNDCTL_FM_LOAD_INSTR"},
  201         {SNDCTL_SEQ_TESTMIDI,   "SNDCTL_SEQ_TESTMIDI"},
  202         {SNDCTL_SEQ_RESETSAMPLES,       "SNDCTL_SEQ_RESETSAMPLES"},
  203         {SNDCTL_SEQ_NRSYNTHS,   "SNDCTL_SEQ_NRSYNTHS"},
  204         {SNDCTL_SEQ_NRMIDIS,    "SNDCTL_SEQ_NRMIDIS"},
  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 static 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 static 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 
  265 /* The followings are the local function. */
  266 static int seq_init(void);
  267 static int seq_initunit(int unit);
  268 static int seq_queue(sc_p scp, u_char *note);
  269 static void seq_startplay(sc_p scp);
  270 static int seq_playevent(sc_p scp, u_char *event);
  271 static u_long seq_gettime(void);
  272 static int seq_requesttimer(sc_p scp, int delay);
  273 static void seq_stoptimer(sc_p scp);
  274 static void seq_midiinput(sc_p scp, mididev_info *md);
  275 static int seq_extended(sc_p scp, u_char *event);
  276 static int seq_chnvoice(sc_p scp, u_char *event);
  277 static int seq_findvoice(mididev_info *md, int chn, int note) __unused;
  278 static int seq_allocvoice(sc_p scp, mididev_info *md, int chn, int note) __unused;
  279 static int seq_chncommon(sc_p scp, u_char *event);
  280 static int seq_timing(sc_p scp, u_char *event);
  281 static int seq_local(sc_p scp, u_char *event);
  282 static int seq_sysex(sc_p scp, u_char *event);
  283 static int seq_reset(sc_p scp);
  284 static int seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct thread *p);
  285 static int seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct thread *p);
  286 static void seq_panic(sc_p scp);
  287 static int seq_sync(sc_p scp);
  288 
  289 static seqdev_info *get_seqdev_info(dev_t i_dev, int *unit);
  290 static seqdev_info *get_seqdev_info_unit(int unit);
  291 static seqdev_info *create_seqdev_info_unit(int unit, seqdev_info *seq);
  292 static int lookup_mididev(sc_p scp, int unit, int mode, mididev_info **mdp);
  293 static int lookup_mididev_midi(sc_p scp, int unit, int mode, mididev_info **mdp);
  294 static void seq_clone(void *arg, char *name, int namelen, dev_t *dev);
  295 
  296 /*
  297  * Here are the main functions to interact to the user process.
  298  * These are called from snd* functions in sys/i386/isa/snd/sound.c.
  299  */
  300 
  301 static int
  302 seq_init(void)
  303 {
  304         SEQ_DEBUG(printf("seq: initing.\n"));
  305 
  306         mtx_init(&seqinfo_mtx, "seqinf", NULL, MTX_DEF);
  307         TAILQ_INIT(&seq_info);
  308 
  309         seq_initunit(0);
  310         EVENTHANDLER_REGISTER(dev_clone, seq_clone, 0, 1000);
  311 
  312         SEQ_DEBUG(printf("seq: inited.\n"));
  313 
  314         return (0);
  315 }
  316 
  317 static int
  318 seq_initunit(int unit)
  319 {
  320         sc_p scp;
  321         seqdev_info *devinfo;
  322         dev_t seqdev, musicdev;
  323 
  324         /* Allocate the softc. */
  325         scp = malloc(sizeof(*scp), M_DEVBUF, M_WAITOK | M_ZERO);
  326         if (scp == (sc_p)NULL) {
  327                 printf("seq_initunit: unit %d, softc allocation failed.\n", unit);
  328                 return (1);
  329         }
  330 
  331         /* Fill the softc and the seq_info for this unit. */
  332         scp->seq_time = seq_gettime();
  333         scp->prev_event_time = 0;
  334         scp->prev_input_time = 0;
  335         scp->prev_wakeup_time = scp->seq_time;
  336 #if defined(MIDI_OUTOFGIANT)
  337         callout_init(&scp->timeout_ch, 1);
  338 #else
  339         callout_init(&scp->timeout_ch, 0);
  340 #endif /* MIDI_OUTOFGIANT */
  341         scp->timer_current = 0;
  342         scp->timer_running = 0;
  343         scp->queueout_pending = 0;
  344         TAILQ_INIT(&scp->midi_open);
  345         scp->pending_timer = -1;
  346 
  347         scp->devinfo = devinfo = create_seqdev_info_unit(unit, &seq_op_desc);
  348         devinfo->midi_dbuf_in.unit_size = devinfo->midi_dbuf_out.unit_size = EV_SZ;
  349         devinfo->softc = scp;
  350         devinfo->flags = 0;
  351         mtx_unlock(&devinfo->flagqueue_mtx);
  352 
  353         seqdev = make_dev(&seq_cdevsw, MIDIMKMINOR(unit, SND_DEV_SEQ),
  354                           UID_ROOT, GID_WHEEL, 0666, "sequencer%d", unit);
  355         musicdev = make_dev(&seq_cdevsw, MIDIMKMINOR(unit, SND_DEV_MUSIC),
  356                             UID_ROOT, GID_WHEEL, 0666, "music%d", unit);
  357 
  358         mtx_lock(&seqinfo_mtx);
  359         if (seq_alias != NODEV) {
  360                 destroy_dev(seq_alias);
  361                 seq_alias = NODEV;
  362         }
  363         seq_alias = make_dev_alias(seqdev, "sequencer");
  364         if (music_alias != NODEV) {
  365                 destroy_dev(music_alias);
  366                 music_alias = NODEV;
  367         }
  368         music_alias = make_dev_alias(musicdev, "music");
  369         mtx_unlock(&seqinfo_mtx);
  370 
  371         if (timerdev_install() != 0)
  372                 printf("seq_initunit: timerdev_install failed.\n");
  373 
  374         return (0);
  375 }
  376 
  377 int
  378 seq_open(dev_t i_dev, int flags, int mode, struct thread *td)
  379 {
  380         int unit;
  381         sc_p scp;
  382         seqdev_info *sd;
  383 
  384         unit = MIDIUNIT(i_dev);
  385 
  386         SEQ_DEBUG(printf("seq_open: unit %d, flags 0x%x.\n", unit, flags));
  387 
  388         if (unit >= NSEQ_MAX) {
  389                 SEQ_DEBUG(printf("seq_open: unit %d does not exist.\n", unit));
  390                 return (ENXIO);
  391         }
  392 
  393         sd = get_seqdev_info(i_dev, &unit);
  394         if (sd == NULL) {
  395                 SEQ_DEBUG(printf("seq_open: unit %d is not configured.\n", unit));
  396                 return (ENXIO);
  397         }
  398         scp = sd->softc;
  399 
  400         /* Mark this device busy. */
  401         mtx_lock(&sd->flagqueue_mtx);
  402         if ((sd->flags & SEQ_F_BUSY) != 0) {
  403                 mtx_unlock(&sd->flagqueue_mtx);
  404                 SEQ_DEBUG(printf("seq_open: unit %d is busy.\n", unit));
  405                 return (EBUSY);
  406         }
  407         scp->fflags = flags;
  408         sd->flags |= SEQ_F_BUSY;
  409         sd->flags &= ~(SEQ_F_READING | SEQ_F_WRITING);
  410         if ((scp->fflags & O_NONBLOCK) != 0)
  411                 sd->flags |= SEQ_F_NBIO;
  412         scp->seq_mode = MIDIDEV(i_dev);
  413 
  414         /* Init the queue. */
  415         midibuf_clear(&sd->midi_dbuf_in);
  416         midibuf_clear(&sd->midi_dbuf_out);
  417 
  418         /* Init timestamp. */
  419         scp->seq_time = seq_gettime();
  420         scp->prev_event_time = 0;
  421         scp->prev_input_time = 0;
  422         scp->prev_wakeup_time = scp->seq_time;
  423 
  424         if (scp->pending_timer != -1) {
  425                 scp->timer = get_timerdev_info_unit(scp->pending_timer);
  426                 scp->pending_timer = -1;
  427         }
  428         if (scp->timer == NULL)
  429                 scp->timer = get_timerdev_info();
  430         if (scp->timer != NULL) {
  431                 scp->timer->seq = scp;
  432                 mtx_unlock(&scp->timer->mtx);
  433         } else if (scp->seq_mode == SND_DEV_MUSIC) {
  434                 mtx_unlock(&sd->flagqueue_mtx);
  435                 printf("seq_open: no timer available.\n");
  436                 sd->flags &= ~SEQ_F_BUSY;
  437                 return (ENXIO);
  438         }
  439 
  440         if (scp->seq_mode == SND_DEV_MUSIC)
  441                 scp->timer->open(scp->timer, flags, mode, td);
  442 
  443         /* Begin recording if nonblocking. */
  444         if ((sd->flags & (SEQ_F_READING | SEQ_F_NBIO)) == SEQ_F_NBIO && (scp->fflags & FREAD) != 0)
  445                 sd->callback(sd, SEQ_CB_START | SEQ_CB_RD);
  446 
  447         mtx_unlock(&sd->flagqueue_mtx);
  448 
  449         SEQ_DEBUG(printf("seq_open: opened, mode %d.\n", scp->seq_mode == SND_DEV_MUSIC ? 2 : 1));
  450 
  451         return (0);
  452 }
  453 
  454 int
  455 seq_close(dev_t i_dev, int flags, int mode, struct thread *td)
  456 {
  457         int unit;
  458         sc_p scp;
  459         seqdev_info *sd;
  460         mididev_info *md;
  461         timerdev_info *tmd;
  462 
  463         unit = MIDIUNIT(i_dev);
  464 
  465         SEQ_DEBUG(printf("seq_close: unit %d.\n", unit));
  466 
  467         if (unit >= NSEQ_MAX) {
  468                 SEQ_DEBUG(printf("seq_close: unit %d does not exist.\n", unit));
  469                 return (ENXIO);
  470         }
  471 
  472         sd = get_seqdev_info(i_dev, &unit);
  473         if (sd == NULL) {
  474                 SEQ_DEBUG(printf("seq_close: unit %d is not configured.\n", unit));
  475                 return (ENXIO);
  476         }
  477         scp = sd->softc;
  478 
  479         mtx_lock(&sd->flagqueue_mtx);
  480 
  481         if (!(sd->flags & MIDI_F_NBIO))
  482                 seq_sync(scp);
  483 
  484         /* Stop the timer. */
  485         seq_stoptimer(scp);
  486 
  487         /* Reset the sequencer. */
  488         seq_reset(scp);
  489         seq_sync(scp);
  490 
  491         /* Clean up the midi device. */
  492         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq)
  493                 lookup_mididev(scp, md->unit, LOOKUP_CLOSE, NULL);
  494 
  495         /* Stop playing and unmark this device busy. */
  496         sd->flags &= ~(SEQ_F_BUSY | SEQ_F_READING | SEQ_F_WRITING | SEQ_F_INSYNC);
  497 
  498         if (scp->seq_mode == SND_DEV_MUSIC)
  499                 scp->timer->close(scp->timer, flags, mode, td);
  500 
  501         if (scp->timer != NULL) {
  502                 tmd = scp->timer;
  503                 mtx_lock(&tmd->mtx);
  504                 scp->timer = NULL;
  505                 tmd->seq = NULL;
  506                 mtx_unlock(&tmd->mtx);
  507         }
  508 
  509         mtx_unlock(&sd->flagqueue_mtx);
  510 
  511         SEQ_DEBUG(printf("seq_close: closed.\n"));
  512 
  513         return (0);
  514 }
  515 
  516 int
  517 seq_read(dev_t i_dev, struct uio *buf, int flag)
  518 {
  519         int unit, ret, len, lenr;
  520         sc_p scp;
  521         seqdev_info *sd;
  522         u_char *uiobuf;
  523 
  524         unit = MIDIUNIT(i_dev);
  525 
  526         SEQ_DEBUG(printf("seq_read: unit %d, resid %d.\n", unit, buf->uio_resid));
  527 
  528         if (unit >= NSEQ_MAX) {
  529                 SEQ_DEBUG(printf("seq_read: unit %d does not exist.\n", unit));
  530                 return (ENXIO);
  531         }
  532 
  533         sd = get_seqdev_info(i_dev, &unit);
  534         if (sd == NULL) {
  535                 SEQ_DEBUG(printf("seq_read: unit %d is not configured.\n", unit));
  536                 return (ENXIO);
  537         }
  538         scp = sd->softc;
  539         if ((scp->fflags & FREAD) == 0) {
  540                 SEQ_DEBUG(printf("seq_read: unit %d is not for reading.\n", unit));
  541                 return (EIO);
  542         }
  543 
  544         len = buf->uio_resid;
  545         lenr = 0;
  546 
  547         uiobuf = (u_char *)malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
  548         if (uiobuf == NULL)
  549                 return (ENOMEM);
  550 
  551         mtx_lock(&sd->flagqueue_mtx);
  552 
  553         /* Begin recording. */
  554         if ((sd->flags & SEQ_F_READING) == 0)
  555                 sd->callback(sd, SEQ_CB_START | SEQ_CB_RD);
  556 
  557         /* Have we got the data to read? */
  558         if ((sd->flags & SEQ_F_NBIO) != 0 && sd->midi_dbuf_in.rl == 0)
  559                 ret = EAGAIN;
  560         else {
  561                 if ((sd->flags & SEQ_F_NBIO) != 0 && len > sd->midi_dbuf_in.rl)
  562                         len = sd->midi_dbuf_in.rl;
  563                 ret = midibuf_seqread(&sd->midi_dbuf_in, uiobuf, len, &lenr,
  564                                       sd->callback, sd, SEQ_CB_START | SEQ_CB_RD,
  565                                       &sd->flagqueue_mtx);
  566         }
  567 
  568         mtx_unlock(&sd->flagqueue_mtx);
  569 
  570         if (ret == 0 && lenr > 0)
  571                 ret = uiomove(uiobuf, lenr, buf);
  572 
  573         free(uiobuf, M_DEVBUF);
  574 
  575         SEQ_DEBUG(printf("seq_read: ret %d, resid %d.\n", ret, buf->uio_resid));
  576 
  577         return (ret);
  578 }
  579 
  580 int
  581 seq_write(dev_t i_dev, struct uio *buf, int flag)
  582 {
  583         u_char event[EV_SZ], ev_code;
  584         int unit, count, countorg, midiunit, ev_size, p, ret;
  585         sc_p scp;
  586         seqdev_info *sd;
  587         mididev_info *md;
  588 
  589         unit = MIDIUNIT(i_dev);
  590 
  591         SEQ_DEBUG(printf("seq_write: unit %d, resid %d.\n", unit, buf->uio_resid));
  592 
  593         if (unit >= NSEQ_MAX) {
  594                 SEQ_DEBUG(printf("seq_write: unit %d does not exist.\n", unit));
  595                 return (ENXIO);
  596         }
  597 
  598         sd = get_seqdev_info(i_dev, &unit);
  599         if (sd == NULL) {
  600                 SEQ_DEBUG(printf("seq_write: unit %d is not configured.\n", unit));
  601                 return (ENXIO);
  602         }
  603         scp = sd->softc;
  604         if ((scp->fflags & FWRITE) == 0) {
  605                 SEQ_DEBUG(printf("seq_write: unit %d is not for writing.\n", unit));
  606                 return (EIO);
  607         }
  608 
  609         p = 0;
  610         countorg = buf->uio_resid;
  611         count = countorg;
  612 
  613         /* Pick up an event. */
  614         while (count >= 4) {
  615                 if (uiomove((caddr_t)event, 4, buf))
  616                         printf("seq_write: user memory mangled?\n");
  617                 ev_code = event[0];
  618                 SEQ_DEBUG(printf("seq_write: unit %d, event %s.\n", unit, midi_cmdname(ev_code, cmdtab_seqevent)));
  619 
  620                 /* Have a look at the event code. */
  621                 if (ev_code == SEQ_FULLSIZE) {
  622 
  623                         /* A long event, these are the patches/samples for a synthesizer. */
  624                         midiunit = *(u_short *)&event[2];
  625                         mtx_lock(&sd->flagqueue_mtx);
  626                         ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
  627                         mtx_unlock(&sd->flagqueue_mtx);
  628                         if (ret != 0)
  629                                 return (ret);
  630 
  631                         SEQ_DEBUG(printf("seq_write: loading a patch to the unit %d.\n", midiunit));
  632 
  633                         ret = md->synth.loadpatch(md, *(short *)&event[0], buf, p + 4, count, 0);
  634                         return (ret);
  635                 }
  636 
  637                 if (ev_code >= 128) {
  638 
  639                         /* Some sort of an extended event. The size is eight bytes. */
  640                         if (scp->seq_mode == SND_DEV_MUSIC && ev_code == SEQ_EXTENDED) {
  641                                 printf("seq_write: invalid level two event %x.\n", ev_code);
  642                                 return (EINVAL);
  643                         }
  644                         ev_size = 8;
  645 
  646                         if (count < ev_size) {
  647                                 /* No more data. Start playing now. */
  648                                 mtx_lock(&sd->flagqueue_mtx);
  649                                 if ((sd->flags & SEQ_F_WRITING) == 0)
  650                                         sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
  651                                 mtx_unlock(&sd->flagqueue_mtx);
  652                                 buf->uio_resid += 4;
  653 
  654                                 return (0);
  655                         }
  656                         if (uiomove((caddr_t)&event[4], 4, buf))
  657                                 printf("seq_write: user memory mangled?\n");
  658                 } else {
  659 
  660                         /* Not an extended event. The size is four bytes. */
  661                         if (scp->seq_mode == SND_DEV_MUSIC) {
  662                                 printf("seq_write: four byte event in level two mode.\n");
  663                                 return (EINVAL);
  664                         }
  665                         ev_size = 4;
  666                 }
  667                 if (ev_code == SEQ_MIDIPUTC) {
  668                         /* An event passed to the midi device itself. */
  669                         midiunit = event[2];
  670                         mtx_lock(&sd->flagqueue_mtx);
  671                         ret = lookup_mididev_midi(scp, midiunit, LOOKUP_OPEN, &md);
  672                         mtx_unlock(&sd->flagqueue_mtx);
  673                         if (ret != 0)
  674                                 return (ret);
  675                 }
  676 
  677                 SEQ_DEBUG(printf("seq_write: queueing event %s.\n", midi_cmdname(event[0], cmdtab_seqevent)));
  678                 /* Now we queue the event. */
  679                 mtx_lock(&sd->flagqueue_mtx);
  680                 switch (seq_queue(scp, event)) {
  681                 case EAGAIN:
  682                         /* The queue is full. Start playing now. */
  683                         if ((sd->flags & SEQ_F_WRITING) == 0)
  684                                 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
  685                         mtx_unlock(&sd->flagqueue_mtx);
  686                         buf->uio_resid = count;
  687                         SEQ_DEBUG(printf("seq_write: resid %d.\n", buf->uio_resid));
  688                         if (count < countorg)
  689                                 return (0);
  690                         return (EAGAIN);
  691                 case EINTR:
  692                         mtx_unlock(&sd->flagqueue_mtx);
  693                         SEQ_DEBUG(printf("seq_write: resid %d.\n", buf->uio_resid));
  694                         return (EINTR);
  695                 case ERESTART:
  696                         mtx_unlock(&sd->flagqueue_mtx);
  697                         SEQ_DEBUG(printf("seq_write: resid %d.\n", buf->uio_resid));
  698                         return (ERESTART);
  699                 }
  700                 mtx_unlock(&sd->flagqueue_mtx);
  701                 p += ev_size;
  702                 count -= ev_size;
  703         }
  704 
  705         /* We have written every single data. Start playing now. */
  706         mtx_lock(&sd->flagqueue_mtx);
  707         if ((sd->flags & SEQ_F_WRITING) == 0)
  708                 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
  709         mtx_unlock(&sd->flagqueue_mtx);
  710 
  711         SEQ_DEBUG(printf("seq_write: resid %d.\n", buf->uio_resid));
  712 
  713         return (0);
  714 }
  715 
  716 int
  717 seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td)
  718 {
  719         int unit, midiunit, ret, tmp;
  720         sc_p scp;
  721         seqdev_info *sd;
  722         mididev_info *md;
  723         struct synth_info *synthinfo;
  724         struct midi_info *midiinfo;
  725         struct patmgr_info *patinfo;
  726         struct seq_event_rec *event;
  727         struct snd_size *sndsize;
  728 
  729         unit = MIDIUNIT(i_dev);
  730 
  731         SEQ_DEBUG(printf("seq_ioctl: unit %d, cmd %s.\n", unit, midi_cmdname(cmd, cmdtab_seqioctl)));
  732 
  733         if (unit >= NSEQ_MAX) {
  734                 SEQ_DEBUG(printf("seq_ioctl: unit %d does not exist.\n", unit));
  735                 return (ENXIO);
  736         }
  737         sd = get_seqdev_info(i_dev, &unit);
  738         if (sd == NULL) {
  739                 SEQ_DEBUG(printf("seq_ioctl: unit %d is not configured.\n", unit));
  740                 return (ENXIO);
  741         }
  742         scp = sd->softc;
  743 
  744         ret = 0;
  745 
  746         switch (cmd) {
  747 
  748                 /*
  749                  * we start with the new ioctl interface.
  750                  */
  751         case AIONWRITE: /* how many bytes can be written ? */
  752                 mtx_lock(&sd->flagqueue_mtx);
  753                 *(int *)arg = sd->midi_dbuf_out.fl;
  754                 mtx_unlock(&sd->flagqueue_mtx);
  755                 SEQ_DEBUG(printf("seq_ioctl: fl %d.\n", *(int *)arg));
  756                 break;
  757 
  758         case AIOSSIZE:     /* set the current blocksize */
  759                 sndsize = (struct snd_size *)arg;
  760                 SEQ_DEBUG(printf("seq_ioctl: play %d, rec %d.\n", sndsize->play_size, sndsize->rec_size));
  761                 mtx_lock(&sd->flagqueue_mtx);
  762                 if (sndsize->play_size <= sd->midi_dbuf_out.unit_size && sndsize->rec_size <= sd->midi_dbuf_in.unit_size) {
  763                         sd->midi_dbuf_out.blocksize = sd->midi_dbuf_out.unit_size;
  764                         sd->midi_dbuf_in.blocksize = sd->midi_dbuf_in.unit_size;
  765                         sndsize->play_size = sd->midi_dbuf_out.blocksize;
  766                         sndsize->rec_size = sd->midi_dbuf_in.blocksize;
  767                         sd->flags &= ~MIDI_F_HAS_SIZE;
  768                         mtx_unlock(&sd->flagqueue_mtx);
  769                 }
  770                 else {
  771                         if (sndsize->play_size > sd->midi_dbuf_out.bufsize / 4)
  772                                 sndsize->play_size = sd->midi_dbuf_out.bufsize / 4;
  773                         if (sndsize->rec_size > sd->midi_dbuf_in.bufsize / 4)
  774                                 sndsize->rec_size = sd->midi_dbuf_in.bufsize / 4;
  775                         /* Round up the size to the multiple of EV_SZ. */
  776                         sd->midi_dbuf_out.blocksize =
  777                             ((sndsize->play_size + sd->midi_dbuf_out.unit_size - 1)
  778                              / sd->midi_dbuf_out.unit_size) * sd->midi_dbuf_out.unit_size;
  779                         sd->midi_dbuf_in.blocksize =
  780                             ((sndsize->rec_size + sd->midi_dbuf_in.unit_size - 1)
  781                              / sd->midi_dbuf_in.unit_size) * sd->midi_dbuf_in.unit_size;
  782                         sndsize->play_size = sd->midi_dbuf_out.blocksize;
  783                         sndsize->rec_size = sd->midi_dbuf_in.blocksize;
  784                         sd->flags |= MIDI_F_HAS_SIZE;
  785                         mtx_unlock(&sd->flagqueue_mtx);
  786                 }       
  787 
  788                 ret = 0;
  789                 break;
  790 
  791         case AIOGSIZE:  /* get the current blocksize */
  792                 sndsize = (struct snd_size *)arg;
  793                 mtx_lock(&sd->flagqueue_mtx);
  794                 sndsize->play_size = sd->midi_dbuf_out.blocksize;
  795                 sndsize->rec_size = sd->midi_dbuf_in.blocksize;
  796                 mtx_unlock(&sd->flagqueue_mtx);
  797                 SEQ_DEBUG(printf("seq_ioctl: play %d, rec %d.\n", sndsize->play_size, sndsize->rec_size));
  798 
  799                 ret = 0;
  800                 break;
  801 
  802         case AIOSTOP:
  803                 if (*(int *)arg == AIOSYNC_PLAY) {
  804 
  805                         /* Stop writing. */
  806                         mtx_lock(&sd->flagqueue_mtx);
  807                         sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_WR);
  808                         mtx_unlock(&sd->flagqueue_mtx);
  809 
  810                         /* Pass the ioctl to the midi devices. */
  811                         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
  812                                 if ((md->flags & MIDI_F_WRITING) != 0)
  813                                         midi_ioctl(MIDIMKDEV(major(i_dev), md->unit, SND_DEV_MIDIN), cmd, (caddr_t)arg, mode, td);
  814                         }
  815 
  816                         mtx_lock(&sd->flagqueue_mtx);
  817                         *(int *)arg = sd->midi_dbuf_out.rl;
  818                         mtx_unlock(&sd->flagqueue_mtx);
  819                 }
  820                 else if (*(int *)arg == AIOSYNC_CAPTURE) {
  821 
  822                         /* Stop reading. */
  823                         mtx_lock(&sd->flagqueue_mtx);
  824                         sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_RD);
  825                         mtx_unlock(&sd->flagqueue_mtx);
  826 
  827                         /* Pass the ioctl to the midi devices. */
  828                         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
  829                                 if ((md->flags & MIDI_F_WRITING) != 0)
  830                                         midi_ioctl(MIDIMKDEV(major(i_dev), md->unit, SND_DEV_MIDIN), cmd, (caddr_t)arg, mode, td);
  831                         }
  832 
  833                         mtx_lock(&sd->flagqueue_mtx);
  834                         *(int *)arg = sd->midi_dbuf_in.rl;
  835                         mtx_unlock(&sd->flagqueue_mtx);
  836                 }
  837 
  838                 ret = 0;
  839                 break;
  840 
  841         case AIOSYNC:
  842                 mtx_lock(&sd->flagqueue_mtx);
  843                 scp->sync_parm = *(snd_sync_parm *)arg;
  844                 mtx_unlock(&sd->flagqueue_mtx);
  845 
  846                 /* XXX Should select(2) against us watch the blocksize, or sync_parm? */
  847 
  848                 ret = 0;
  849                 break;
  850 
  851         case FIONBIO: /* set/clear non-blocking i/o */
  852                 mtx_lock(&sd->flagqueue_mtx);
  853                 if (*(int *)arg == 0)
  854                         sd->flags &= ~SEQ_F_NBIO ;
  855                 else
  856                         sd->flags |= SEQ_F_NBIO ;
  857                 mtx_unlock(&sd->flagqueue_mtx);
  858                 MIDI_DEBUG(printf("seq_ioctl: arg %d.\n", *(int *)arg));
  859                 break ;
  860 
  861         case SNDCTL_TMR_TIMEBASE:
  862         case SNDCTL_TMR_TEMPO:
  863         case SNDCTL_TMR_START:
  864         case SNDCTL_TMR_STOP:
  865         case SNDCTL_TMR_CONTINUE:
  866         case SNDCTL_TMR_METRONOME:
  867         case SNDCTL_TMR_SOURCE:
  868                 mtx_lock(&sd->flagqueue_mtx);
  869                 if (scp->seq_mode != SND_DEV_MUSIC) {
  870                         ret = EINVAL;
  871                         mtx_unlock(&sd->flagqueue_mtx);
  872                         break;
  873                 }
  874                 mtx_unlock(&sd->flagqueue_mtx);
  875                 /* XXX We should adopt am sx to protect scp->timer */
  876                 ret = scp->timer->ioctl(scp->timer, cmd, arg, mode, td);
  877                 break;
  878         case SNDCTL_TMR_SELECT:
  879                 mtx_lock(&sd->flagqueue_mtx);
  880                 if (scp->seq_mode != SND_DEV_MUSIC) {
  881                         ret = EINVAL;
  882                         mtx_unlock(&sd->flagqueue_mtx);
  883                         break;
  884                 }
  885                 mtx_unlock(&sd->flagqueue_mtx);
  886                 scp->pending_timer = *(int *)arg;
  887                 mtx_lock(&sd->flagqueue_mtx);
  888                 if (scp->pending_timer < 0) {
  889                         scp->pending_timer = -1;
  890                         ret = EINVAL;
  891                         mtx_unlock(&sd->flagqueue_mtx);
  892                         break;
  893                 }
  894                 mtx_unlock(&sd->flagqueue_mtx);
  895                 SEQ_DEBUG(printf("seq_ioctl: new timer %d.\n", *(int *)arg));
  896                 ret = 0;
  897                 break;
  898         case SNDCTL_SEQ_PANIC:
  899                 mtx_lock(&sd->flagqueue_mtx);
  900                 seq_panic(scp);
  901                 mtx_unlock(&sd->flagqueue_mtx);
  902                 ret = 0;
  903                 break;
  904         case SNDCTL_SEQ_SYNC:
  905                 if (mode == O_RDONLY) {
  906                         ret = 0;
  907                         break;
  908                 }
  909                 mtx_lock(&scp->devinfo->flagqueue_mtx);
  910                 ret = seq_sync(scp);
  911                 mtx_unlock(&scp->devinfo->flagqueue_mtx);
  912                 break;
  913         case SNDCTL_SEQ_RESET:
  914                 mtx_lock(&scp->devinfo->flagqueue_mtx);
  915                 seq_reset(scp);
  916                 mtx_unlock(&scp->devinfo->flagqueue_mtx);
  917                 ret = 0;
  918                 break;
  919         case SNDCTL_SEQ_TESTMIDI:
  920                 mtx_lock(&sd->flagqueue_mtx);
  921                 ret = lookup_mididev_midi(scp, *(int *)arg, LOOKUP_OPEN, &md);
  922                 mtx_unlock(&sd->flagqueue_mtx);
  923                 break;
  924         case SNDCTL_SEQ_GETINCOUNT:
  925                 if (mode == O_WRONLY)
  926                         *(int *)arg = 0;
  927                 else {
  928                         mtx_lock(&sd->flagqueue_mtx);
  929                         *(int *)arg = sd->midi_dbuf_in.rl;
  930                         mtx_unlock(&sd->flagqueue_mtx);
  931                         SEQ_DEBUG(printf("seq_ioctl: incount %d.\n", *(int *)arg));
  932                 }
  933                 ret = 0;
  934                 break;
  935         case SNDCTL_SEQ_GETOUTCOUNT:
  936                 if (mode == O_RDONLY)
  937                         *(int *)arg = 0;
  938                 else {
  939                         mtx_lock(&sd->flagqueue_mtx);
  940                         *(int *)arg = sd->midi_dbuf_out.fl;
  941                         mtx_unlock(&sd->flagqueue_mtx);
  942                         SEQ_DEBUG(printf("seq_ioctl: outcount %d.\n", *(int *)arg));
  943                 }
  944                 ret = 0;
  945                 break;
  946         case SNDCTL_SEQ_CTRLRATE:
  947                 mtx_lock(&sd->flagqueue_mtx);
  948                 if (scp->seq_mode == SND_DEV_MUSIC) {
  949                         mtx_unlock(&sd->flagqueue_mtx);
  950                         ret = scp->timer->ioctl(scp->timer, cmd, arg, mode, td);
  951                         break;
  952                 }
  953                 mtx_unlock(&sd->flagqueue_mtx);
  954                 if (*(int *)arg != 0) {
  955                         ret = EINVAL;
  956                         break;
  957                 }
  958                 *(int *)arg = hz;
  959                 SEQ_DEBUG(printf("seq_ioctl: ctrlrate %d.\n", *(int *)arg));
  960                 ret = 0;
  961                 break;
  962         case SNDCTL_SEQ_RESETSAMPLES:
  963                 mtx_lock(&sd->flagqueue_mtx);
  964                 ret = lookup_mididev(scp, *(int *)arg, LOOKUP_OPEN, &md);
  965                 mtx_unlock(&sd->flagqueue_mtx);
  966                 if (ret != 0)
  967                         break;
  968                 ret = midi_ioctl(MIDIMKDEV(major(i_dev), *(int *)arg, SND_DEV_MIDIN), cmd, arg, mode, td);
  969                 break;
  970         case SNDCTL_SEQ_NRSYNTHS:
  971                 mtx_lock(&sd->flagqueue_mtx);
  972                 if (scp->seq_mode == SND_DEV_MUSIC)
  973                         *(int *)arg = mididev_synth_number() + mididev_midi_number();
  974                 else
  975                         *(int *)arg = mididev_synth_number();
  976                 mtx_unlock(&sd->flagqueue_mtx);
  977                 SEQ_DEBUG(printf("seq_ioctl: synths %d.\n", *(int *)arg));
  978                 ret = 0;
  979                 break;
  980         case SNDCTL_SEQ_NRMIDIS:
  981                 mtx_lock(&sd->flagqueue_mtx);
  982                 if (scp->seq_mode == SND_DEV_MUSIC)
  983                         *(int *)arg = 0;
  984                 else
  985                         *(int *)arg = mididev_midi_number();
  986                 mtx_unlock(&sd->flagqueue_mtx);
  987                 SEQ_DEBUG(printf("seq_ioctl: midis %d.\n", *(int *)arg));
  988                 ret = 0;
  989                 break;
  990         case SNDCTL_SYNTH_MEMAVL:
  991                 mtx_lock(&sd->flagqueue_mtx);
  992                 ret = lookup_mididev(scp, *(int *)arg, LOOKUP_OPEN, &md);
  993                 mtx_unlock(&sd->flagqueue_mtx);
  994                 if (ret != 0)
  995                         break;
  996                 ret = midi_ioctl(MIDIMKDEV(major(i_dev), *(int *)arg, SND_DEV_MIDIN), cmd, arg, mode, td);
  997                 break;
  998         case SNDCTL_FM_4OP_ENABLE:
  999                 mtx_lock(&sd->flagqueue_mtx);
 1000                 ret = lookup_mididev(scp, *(int *)arg, LOOKUP_OPEN, &md);
 1001                 mtx_unlock(&sd->flagqueue_mtx);
 1002                 if (ret != 0)
 1003                         break;
 1004                 ret = midi_ioctl(MIDIMKDEV(major(i_dev), *(int *)arg, SND_DEV_MIDIN), cmd, arg, mode, td);
 1005                 break;
 1006         case SNDCTL_SYNTH_INFO:
 1007                 synthinfo = (struct synth_info *)arg;
 1008                 midiunit = synthinfo->device;
 1009                 mtx_lock(&sd->flagqueue_mtx);
 1010                 ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
 1011                 mtx_unlock(&sd->flagqueue_mtx);
 1012                 if (ret != 0)
 1013                         break;
 1014                 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td);
 1015                 break;
 1016         case SNDCTL_SEQ_OUTOFBAND:
 1017                 event = (struct seq_event_rec *)arg;
 1018                 mtx_lock(&sd->flagqueue_mtx);
 1019                 ret = seq_playevent(scp, event->arr);
 1020                 mtx_unlock(&sd->flagqueue_mtx);
 1021                 break;
 1022         case SNDCTL_MIDI_INFO:
 1023                 midiinfo = (struct midi_info *)arg;
 1024                 midiunit = midiinfo->device;
 1025                 mtx_lock(&sd->flagqueue_mtx);
 1026                 ret = lookup_mididev_midi(scp, midiunit, LOOKUP_OPEN, &md);
 1027                 mtx_unlock(&sd->flagqueue_mtx);
 1028                 if (ret != 0)
 1029                         break;
 1030                 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td);
 1031                 break;
 1032         case SNDCTL_PMGR_IFACE:
 1033                 patinfo = (struct patmgr_info *)arg;
 1034                 midiunit = patinfo->device;
 1035                 mtx_lock(&sd->flagqueue_mtx);
 1036                 ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
 1037                 mtx_unlock(&sd->flagqueue_mtx);
 1038                 if (ret != 0)
 1039                         break;
 1040                 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td);
 1041                 break;
 1042         case SNDCTL_PMGR_ACCESS:
 1043                 patinfo = (struct patmgr_info *)arg;
 1044                 midiunit = patinfo->device;
 1045                 mtx_lock(&sd->flagqueue_mtx);
 1046                 ret = lookup_mididev(scp, midiunit, LOOKUP_OPEN, &md);
 1047                 mtx_unlock(&sd->flagqueue_mtx);
 1048                 if (ret != 0)
 1049                         break;
 1050                 ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td);
 1051                 break;
 1052         case SNDCTL_SEQ_THRESHOLD:
 1053                 mtx_lock(&sd->flagqueue_mtx);
 1054                 RANGE(*(int *)arg, 1, sd->midi_dbuf_out.bufsize - 1);
 1055                 scp->output_threshould = *(int *)arg;
 1056                 mtx_unlock(&sd->flagqueue_mtx);
 1057                 SEQ_DEBUG(printf("seq_ioctl: threshold %d.\n", *(int *)arg));
 1058                 ret = 0;
 1059                 break;
 1060         case SNDCTL_MIDI_PRETIME:
 1061                 tmp = *(int *)arg;
 1062                 if (tmp < 0)
 1063                         tmp = 0;
 1064                 mtx_lock(&sd->flagqueue_mtx);
 1065                 scp->pre_event_timeout = (hz * tmp) / 10;
 1066                 *(int *)arg = scp->pre_event_timeout;
 1067                 mtx_unlock(&sd->flagqueue_mtx);
 1068                 SEQ_DEBUG(printf("seq_ioctl: pretime %d.\n", *(int *)arg));
 1069                 ret = 0;
 1070                 break;
 1071         default:
 1072                 if ((scp->fflags & O_ACCMODE) == FREAD) {
 1073                         ret = EIO;
 1074                         break;
 1075                 }
 1076                 mtx_lock(&sd->flagqueue_mtx);
 1077                 ret = lookup_mididev(scp, 0, LOOKUP_OPEN, &md);
 1078                 mtx_unlock(&sd->flagqueue_mtx);
 1079                 if (ret != 0)
 1080                         break;
 1081                 ret = midi_ioctl(MIDIMKDEV(major(i_dev), 0, SND_DEV_MIDIN), cmd, arg, mode, td);
 1082                 break;
 1083         }
 1084 
 1085         return (ret);
 1086 }
 1087 
 1088 int
 1089 seq_poll(dev_t i_dev, int events, struct thread *td)
 1090 {
 1091         int unit, ret, lim;
 1092         sc_p scp;
 1093         seqdev_info *sd;
 1094 
 1095         unit = MIDIUNIT(i_dev);
 1096 
 1097         SEQ_DEBUG(printf("seq_poll: unit %d.\n", unit));
 1098 
 1099         if (unit >= NSEQ_MAX) {
 1100                 SEQ_DEBUG(printf("seq_poll: unit %d does not exist.\n", unit));
 1101                 return (ENXIO);
 1102         }
 1103         sd = get_seqdev_info(i_dev, &unit);
 1104         if (sd == NULL) {
 1105                 SEQ_DEBUG(printf("seq_poll: unit %d is not configured.\n", unit));
 1106                 return (ENXIO);
 1107         }
 1108         scp = sd->softc;
 1109 
 1110         mtx_lock(&sd->flagqueue_mtx);
 1111 
 1112         ret = 0;
 1113 
 1114         /* Look up the apropriate queue and select it. */
 1115         if ((events & (POLLOUT | POLLWRNORM)) != 0) {
 1116                 /* Start playing. */
 1117                 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
 1118 
 1119                 /* Find out the boundary. */
 1120                 if ((sd->flags & SEQ_F_HAS_SIZE) != 0)
 1121                         lim = sd->midi_dbuf_out.blocksize;
 1122                 else
 1123                         lim = sd->midi_dbuf_out.unit_size;
 1124                 if (sd->midi_dbuf_out.fl < lim)
 1125                         /* No enough space, record select. */
 1126                         selrecord(td, &sd->midi_dbuf_out.sel);
 1127                 else
 1128                         /* We can write now. */
 1129                         ret |= events & (POLLOUT | POLLWRNORM);
 1130         }
 1131         if ((events & (POLLIN | POLLRDNORM)) != 0) {
 1132                 /* Start recording. */
 1133                 sd->callback(sd, SEQ_CB_START | SEQ_CB_RD);
 1134 
 1135                 /* Find out the boundary. */
 1136                 if ((sd->flags & SEQ_F_HAS_SIZE) != 0)
 1137                         lim = sd->midi_dbuf_in.blocksize;
 1138                 else
 1139                         lim = sd->midi_dbuf_in.unit_size;
 1140                 if (sd->midi_dbuf_in.rl < lim)
 1141                         /* No data ready, record select. */
 1142                         selrecord(td, &sd->midi_dbuf_in.sel);
 1143                 else
 1144                         /* We can write now. */
 1145                         ret |= events & (POLLIN | POLLRDNORM);
 1146         }
 1147 
 1148         mtx_unlock(&sd->flagqueue_mtx);
 1149 
 1150         return (ret);
 1151 }
 1152 
 1153 static void
 1154 seq_intr(void *p, mididev_info *md)
 1155 {
 1156         sc_p scp;
 1157         seqdev_info *sd;
 1158 
 1159         sd = (seqdev_info *)p;
 1160         scp = sd->softc;
 1161 
 1162         mtx_lock(&sd->flagqueue_mtx);
 1163 
 1164         /* Restart playing if we have the data to output. */
 1165         if (scp->queueout_pending)
 1166                 sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
 1167         /* Check the midi device if we are reading. */
 1168         if ((sd->flags & SEQ_F_READING) != 0)
 1169                 seq_midiinput(scp, md);
 1170 
 1171         mtx_unlock(&sd->flagqueue_mtx);
 1172 }
 1173 
 1174 static int
 1175 seq_callback(void *d, int reason)
 1176 {
 1177         int unit;
 1178         sc_p scp;
 1179         seqdev_info *sd;
 1180 
 1181         sd = (seqdev_info *)d;
 1182 
 1183         SEQ_DEBUG(printf("seq_callback: reason 0x%x.\n", reason));
 1184 
 1185         if (sd == NULL) {
 1186                 SEQ_DEBUG(printf("seq_callback: device not configured.\n"));
 1187                 return (ENXIO);
 1188         }
 1189         scp = sd->softc;
 1190         unit = sd->unit;
 1191 
 1192         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1193 
 1194         switch (reason & SEQ_CB_REASON_MASK) {
 1195         case SEQ_CB_START:
 1196                 if ((reason & SEQ_CB_RD) != 0 && (sd->flags & SEQ_F_READING) == 0)
 1197                         /* Begin recording. */
 1198                         sd->flags |= SEQ_F_READING;
 1199                 if ((reason & SEQ_CB_WR) != 0 && (sd->flags & SEQ_F_WRITING) == 0)
 1200                         /* Start playing. */
 1201                         seq_startplay(scp);
 1202                 break;
 1203         case SEQ_CB_STOP:
 1204         case SEQ_CB_ABORT:
 1205                 if ((reason & SEQ_CB_RD) != 0 && (sd->flags & SEQ_F_READING) != 0) {
 1206                         /* Stop recording. */
 1207                         sd->flags &= ~SEQ_F_READING;
 1208                         scp->seq_time = seq_gettime();
 1209                         scp->prev_input_time = 0;
 1210                 }
 1211                 if ((reason & SEQ_CB_WR) != 0 && (sd->flags & SEQ_F_WRITING) != 0) {
 1212                         /* Stop Playing. */
 1213                         sd->flags &= ~SEQ_F_WRITING;
 1214                         scp->queueout_pending = 0;
 1215                         scp->seq_time = seq_gettime();
 1216                         scp->prev_input_time = 0;
 1217 
 1218                         /* Stop the timer. */
 1219                         seq_stoptimer(scp);
 1220                 }
 1221         }
 1222 
 1223         return (0);
 1224 }
 1225 
 1226 /*
 1227  * The functions below here are the libraries for the above ones.
 1228  */
 1229 
 1230 static int
 1231 seq_queue(sc_p scp, u_char *note)
 1232 {
 1233         int unit, err, lenw;
 1234         seqdev_info *sd;
 1235 
 1236         sd = scp->devinfo;
 1237         unit = sd->unit;
 1238 
 1239         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1240 
 1241         SEQ_DEBUG(printf("seq_queue: unit %d.\n", unit));
 1242 
 1243         if ((sd->flags & SEQ_F_INSYNC) != 0)
 1244                 cv_wait(&sd->insync_cv, &sd->flagqueue_mtx);
 1245 
 1246         if (sd->midi_dbuf_out.fl < EV_SZ) {
 1247                 /* We have no space. Start playing if not yet. */
 1248                 if ((sd->flags & SEQ_F_WRITING) == 0)
 1249                         sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
 1250                 if ((sd->flags & SEQ_F_NBIO) != 0 && sd->midi_dbuf_out.fl < EV_SZ)
 1251                         /* We would block. */
 1252                         return (EAGAIN);
 1253         }
 1254 
 1255         /* Write to the queue. */
 1256         err = midibuf_seqwrite(&sd->midi_dbuf_out, note, EV_SZ, &lenw,
 1257                                sd->callback, sd, SEQ_CB_START | SEQ_CB_WR,
 1258                                &sd->flagqueue_mtx);
 1259 
 1260         if (err == 0) {
 1261                 /* Start playing if we have some data in the queue. */
 1262                 if (sd->midi_dbuf_out.rl >= EV_SZ && ((sd->flags & SEQ_F_WRITING) == 0))
 1263                         sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
 1264         }
 1265 
 1266         return (err);
 1267 }
 1268 
 1269 static void
 1270 seq_startplay(sc_p scp)
 1271 {
 1272         int unit, lenr;
 1273         u_char event[EV_SZ];
 1274         seqdev_info *sd;
 1275 
 1276         sd = scp->devinfo;
 1277         unit = sd->unit;
 1278 
 1279         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1280 
 1281         sd->flags |= SEQ_F_WRITING;
 1282 
 1283         /* Dequeue the events to play. */
 1284         while (sd->midi_dbuf_out.rl >= EV_SZ) {
 1285 
 1286                 midibuf_seqcopy(&sd->midi_dbuf_out, event, EV_SZ, &lenr,
 1287                                 NULL, NULL, 0,
 1288                                 &sd->flagqueue_mtx);
 1289 
 1290                 switch (seq_playevent(scp, event)) {
 1291                 case TIMERARMED:
 1292                         midibuf_seqdelete(&sd->midi_dbuf_out, EV_SZ, &lenr,
 1293                                           NULL, NULL, 0,
 1294                                           &sd->flagqueue_mtx);
 1295                         return;
 1296                 case QUEUEFULL:
 1297                         /* We cannot play any further. */
 1298                         return;
 1299                 case MORE:
 1300                         midibuf_seqdelete(&sd->midi_dbuf_out, EV_SZ, &lenr,
 1301                                           NULL, NULL, 0,
 1302                                           &sd->flagqueue_mtx);
 1303                         break;
 1304                 }
 1305         }
 1306 
 1307         /* Played every event in the queue. */
 1308         sd->flags &= ~SEQ_F_WRITING;
 1309 }
 1310 
 1311 static int
 1312 seq_playevent(sc_p scp, u_char *event)
 1313 {
 1314         int unit, ret, lenw;
 1315         long *delay;
 1316         seqdev_info *sd;
 1317         mididev_info *md;
 1318 
 1319         sd = scp->devinfo;
 1320         unit = sd->unit;
 1321 
 1322         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1323 
 1324         ret = lookup_mididev(scp, 0, LOOKUP_OPEN, &md);
 1325         if (ret != 0)
 1326                 return (MORE);
 1327 
 1328         SEQ_DEBUG(printf("seq_playevent: unit %d, event %s.\n", sd->unit, midi_cmdname(event[0], cmdtab_seqevent)));
 1329 
 1330         switch(event[0]) {
 1331         case SEQ_NOTEOFF:
 1332                 mtx_unlock(&sd->flagqueue_mtx);
 1333                 SEQ_DEBUG(printf("seq_playevent: chn %d, note %d, vel %d.\n", event[1], event[2], event[3]));
 1334                 if (md->synth.killnote(md, event[1], 255, event[3]) == EAGAIN) {
 1335                         mtx_lock(&sd->flagqueue_mtx);
 1336                         ret = QUEUEFULL;
 1337                         break;
 1338                 }
 1339                 mtx_lock(&sd->flagqueue_mtx);
 1340                 ret = MORE;
 1341                 break;
 1342         case SEQ_NOTEON:
 1343                 mtx_unlock(&sd->flagqueue_mtx);
 1344                 SEQ_DEBUG(printf("seq_playevent: chn %d, note %d, vel %d, aux %d.\n", event[1], event[2], event[3], event[4]));
 1345                 if ((event[4] < 128 || event[4] == 255) && md->synth.startnote(md, event[1], event[2], event[3]) == EAGAIN) {
 1346                         mtx_lock(&sd->flagqueue_mtx);
 1347                         ret = QUEUEFULL;
 1348                         break;
 1349                 }
 1350                 mtx_lock(&sd->flagqueue_mtx);
 1351                 ret = MORE;
 1352                 break;
 1353         case SEQ_WAIT:
 1354 
 1355                 /* Extract the delay. */
 1356                 delay = (long *)event;
 1357                 *delay = (*delay >> 8) & 0xffffff;
 1358                 SEQ_DEBUG(printf("seq_playevent: delay %ld.\n", *delay));
 1359                 if (*delay > 0) {
 1360                         /* Arm the timer. */
 1361                         sd->flags |= SEQ_F_WRITING;
 1362                         if (seq_requesttimer(scp, *delay)) {
 1363                                 ret = TIMERARMED;
 1364                                 break;
 1365                         }
 1366                 }
 1367                 ret = MORE;
 1368                 break;
 1369         case SEQ_PGMCHANGE:
 1370                 SEQ_DEBUG(printf("seq_playevent: chn %d, instr %d.\n", event[1], event[2]));
 1371                 mtx_unlock(&sd->flagqueue_mtx);
 1372                 if (md->synth.setinstr(md, event[1], event[2]) == EAGAIN) {
 1373                         mtx_lock(&sd->flagqueue_mtx);
 1374                         ret = QUEUEFULL;
 1375                         break;
 1376                 }
 1377                 mtx_lock(&sd->flagqueue_mtx);
 1378                 ret = MORE;
 1379                 break;
 1380         case SEQ_SYNCTIMER:
 1381                 /* Reset the timer. */
 1382                 scp->seq_time = seq_gettime();
 1383                 scp->prev_input_time = 0;
 1384                 scp->prev_event_time = 0;
 1385                 scp->prev_wakeup_time = scp->seq_time;
 1386                 ret = MORE;
 1387                 break;
 1388         case SEQ_MIDIPUTC:
 1389                 SEQ_DEBUG(printf("seq_playevent: data 0x%02x, unit %d.\n", event[1], event[2]));
 1390                 /* Pass through to the midi device. */
 1391                 ret = lookup_mididev_midi(scp, event[2], LOOKUP_OPEN, &md);
 1392                 if (ret != 0) {
 1393                         ret = MORE;
 1394                         break;
 1395                 }
 1396                 mtx_unlock(&sd->flagqueue_mtx);
 1397                 if (md->synth.writeraw(md, &event[1], sizeof(event[1]), &lenw, 1) == EAGAIN)
 1398                         /* The queue was full. Try again later. */
 1399                         ret = QUEUEFULL;
 1400                 else
 1401                         ret = MORE;
 1402                 mtx_lock(&sd->flagqueue_mtx);
 1403                 break;
 1404         case SEQ_ECHO:
 1405                 /* Echo this event back. */
 1406                 if (seq_copytoinput(scp, event, 4) == EAGAIN) {
 1407                         ret = QUEUEFULL;
 1408                         break;
 1409                 }
 1410                 ret = MORE;
 1411                 break;
 1412         case SEQ_PRIVATE:
 1413                 ret = lookup_mididev(scp, event[1], LOOKUP_OPEN, &md);
 1414                 if (ret != 0) {
 1415                         ret = MORE;
 1416                         break;
 1417                 }
 1418                 mtx_unlock(&sd->flagqueue_mtx);
 1419                 if (md->synth.hwcontrol(md, event) == EAGAIN) {
 1420                         mtx_lock(&sd->flagqueue_mtx);
 1421                         ret = QUEUEFULL;
 1422                         break;
 1423                 }
 1424                 mtx_lock(&sd->flagqueue_mtx);
 1425                 ret = MORE;
 1426                 break;
 1427         case SEQ_EXTENDED:
 1428                 ret = seq_extended(scp, event);
 1429                 break;
 1430         case EV_CHN_VOICE:
 1431                 ret = seq_chnvoice(scp, event);
 1432                 break;
 1433         case EV_CHN_COMMON:
 1434                 ret = seq_chncommon(scp, event);
 1435                 break;
 1436         case EV_TIMING:
 1437                 ret = seq_timing(scp, event);
 1438                 break;
 1439         case EV_SEQ_LOCAL:
 1440                 ret = seq_local(scp, event);
 1441                 break;
 1442         case EV_SYSEX:
 1443                 ret = seq_sysex(scp, event);
 1444                 break;
 1445         default:
 1446                 ret = MORE;
 1447                 break;
 1448         }
 1449 
 1450         switch (ret) {
 1451         case QUEUEFULL:
 1452                 SEQ_DEBUG(printf("seq_playevent: the queue is full.\n"));
 1453                 /* The queue was full. Try again on the interrupt by the midi device. */
 1454                 sd->flags |= SEQ_F_WRITING;
 1455                 scp->queueout_pending = 1;
 1456                 break;
 1457         case TIMERARMED:
 1458                 SEQ_DEBUG(printf("seq_playevent: armed timer.\n"));
 1459                 sd->flags |= SEQ_F_WRITING;
 1460                 /* FALLTHRU */
 1461         case MORE:
 1462                 scp->queueout_pending = 0;
 1463                 break;
 1464         }
 1465 
 1466         return (ret);
 1467 }
 1468 
 1469 static u_long
 1470 seq_gettime(void)
 1471 {
 1472         struct timeval  timecopy;
 1473 
 1474         getmicrotime(&timecopy);
 1475         return timecopy.tv_usec / (1000000 / hz) + (u_long) timecopy.tv_sec * hz;
 1476 }
 1477 
 1478 static int
 1479 seq_requesttimer(sc_p scp, int delay)
 1480 {
 1481         u_long cur_time, rel_base;
 1482 
 1483         SEQ_DEBUG(printf("seq_requesttimer: unit %d, delay %d.\n", scp->devinfo->unit, delay));
 1484 
 1485         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 1486 
 1487         cur_time = seq_gettime();
 1488 
 1489         scp->prev_event_time = delay;
 1490         if (delay < 0)
 1491                 /* Request a new timer. */
 1492                 delay = -delay;
 1493         else {
 1494                 rel_base = cur_time - scp->seq_time;
 1495                 if (delay <= rel_base) {
 1496                         seq_stoptimer(scp);
 1497                         return 0;
 1498                 }
 1499                 delay -= rel_base;
 1500         }
 1501 
 1502 #if notdef
 1503         /*
 1504          * Compensate the delay of midi message transmission.
 1505          * XXX Do we have to consider the accumulation of errors
 1506          * less than 1/hz second?
 1507          */
 1508         delay -= (cur_time - scp->prev_wakeup_time);
 1509         if (delay < 1) {
 1510                 printf("sequencer: prev = %lu, cur = %lu, delay = %d, skip sleeping.\n",
 1511                         scp->prev_wakeup_time, cur_time, delay);
 1512                 seq_stoptimer(scp);
 1513                 return 0;
 1514         }
 1515 #endif /* notdef */
 1516 
 1517         callout_reset(&scp->timeout_ch, delay, seq_timer, (void *)scp);
 1518         scp->timer_running = 1;
 1519 
 1520         return 1;
 1521 }
 1522 
 1523 static void
 1524 seq_stoptimer(sc_p scp)
 1525 {
 1526         SEQ_DEBUG(printf("seq_stoptimer: unit %d.\n", scp->devinfo->unit));
 1527 
 1528         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 1529 
 1530         if (scp->timer_running) {
 1531                 callout_stop(&scp->timeout_ch);
 1532                 scp->timer_running = 0;
 1533         }
 1534 }
 1535 
 1536 static void
 1537 seq_midiinput(sc_p scp, mididev_info *md)
 1538 {
 1539         int unit, midiunit, lenr;
 1540         u_long tstamp;
 1541         u_char event[4];
 1542         seqdev_info *sd;
 1543 
 1544         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 1545 
 1546         sd = scp->devinfo;
 1547         unit = sd->unit;
 1548 
 1549         /* Can this midi device interrupt for input? */
 1550         midiunit = md->midiunit;
 1551         if (lookup_mididev_midi(scp, midiunit, LOOKUP_EXIST, NULL) != 0)
 1552                 return;
 1553 
 1554         if ((md->flags & MIDI_F_READING) != 0 && md->intrarg == sd) {
 1555                 /* Read the input data. */
 1556                 mtx_unlock(&scp->devinfo->flagqueue_mtx);
 1557                 while (md->synth.readraw(md, &event[1], sizeof(event[1]), &lenr, 1) == 0) {
 1558                         mtx_lock(&scp->devinfo->flagqueue_mtx);
 1559                         tstamp = seq_gettime() - scp->seq_time;
 1560                         if (tstamp != scp->prev_input_time) {
 1561                                 /* Insert a wait between events. */
 1562                                 tstamp = (tstamp << 8) | SEQ_WAIT;
 1563                                 seq_copytoinput(scp, (u_char *)&tstamp, 4);
 1564                                 scp->prev_input_time = tstamp;
 1565                         }
 1566                         bzero(event, sizeof(event));
 1567                         event[0] = SEQ_MIDIPUTC;
 1568                         event[2] = midiunit;
 1569                         event[3] = 0;
 1570                         seq_copytoinput(scp, event, sizeof(event));
 1571                         mtx_unlock(&scp->devinfo->flagqueue_mtx);
 1572                 }
 1573                 mtx_lock(&scp->devinfo->flagqueue_mtx);
 1574         }
 1575 }
 1576 
 1577 int
 1578 seq_copytoinput(void *arg, u_char *event, int len)
 1579 {
 1580         int ret, leni;
 1581         sc_p scp;
 1582         seqdev_info *sd;
 1583 
 1584         scp = arg;
 1585         sd = scp->devinfo;
 1586 
 1587         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1588 
 1589         if (len != 4 && len != 8)
 1590                 return (EINVAL);
 1591         if (scp->seq_mode == SND_DEV_MUSIC && len != 8)
 1592                 return (EINVAL);
 1593 
 1594         ret = midibuf_input_intr(&sd->midi_dbuf_in, event, len, &leni);
 1595         if (ret == EAGAIN)
 1596                 ret = 0;
 1597 
 1598         return (ret);
 1599 }
 1600 
 1601 static int
 1602 seq_extended(sc_p scp, u_char *event)
 1603 {
 1604         int unit;
 1605         seqdev_info *sd;
 1606         mididev_info *md;
 1607 
 1608         sd = scp->devinfo;
 1609         unit = sd->unit;
 1610 
 1611         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1612 
 1613         if (lookup_mididev(scp, event[2], LOOKUP_OPEN, &md) != 0)
 1614                 return (MORE);
 1615 
 1616         SEQ_DEBUG(printf("seq_extended: unit %d, event %s, midiunit %d.\n", unit, midi_cmdname(event[1], cmdtab_seqevent), event[2]));
 1617 
 1618         switch (event[1]) {
 1619         case SEQ_NOTEOFF:
 1620                 mtx_unlock(&sd->flagqueue_mtx);
 1621                 SEQ_DEBUG(printf("seq_extended: chn %d, note %d, vel %d.\n", event[3], event[4], event[5]));
 1622                 if (md->synth.killnote(md, event[3], event[4], event[5]) == EAGAIN) {
 1623                         mtx_lock(&sd->flagqueue_mtx);
 1624                         return (QUEUEFULL);
 1625                 }
 1626                 mtx_lock(&sd->flagqueue_mtx);
 1627                 break;
 1628         case SEQ_NOTEON:
 1629                 mtx_unlock(&sd->flagqueue_mtx);
 1630                 SEQ_DEBUG(printf("seq_extended: chn %d, note %d, vel %d.\n", event[3], event[4], event[5]));
 1631                 if ((event[4] < 128 || event[4] == 255) && md->synth.startnote(md, event[3], event[4], event[5]) == EAGAIN) {
 1632                         mtx_lock(&sd->flagqueue_mtx);
 1633                         return (QUEUEFULL);
 1634                 }
 1635                 mtx_lock(&sd->flagqueue_mtx);
 1636                 break;
 1637         case SEQ_PGMCHANGE:
 1638                 mtx_unlock(&sd->flagqueue_mtx);
 1639                 SEQ_DEBUG(printf("seq_extended: chn %d, instr %d.\n", event[3], event[4]));
 1640                 if (md->synth.setinstr(md, event[3], event[4]) == EAGAIN) {
 1641                         mtx_lock(&sd->flagqueue_mtx);
 1642                         return (QUEUEFULL);
 1643                 }
 1644                 mtx_lock(&sd->flagqueue_mtx);
 1645                 break;
 1646         case SEQ_AFTERTOUCH:
 1647                 mtx_unlock(&sd->flagqueue_mtx);
 1648                 SEQ_DEBUG(printf("seq_extended: chn %d, press %d.\n", event[3], event[4]));
 1649                 if (md->synth.aftertouch(md, event[3], event[4]) == EAGAIN) {
 1650                         mtx_lock(&sd->flagqueue_mtx);
 1651                         return (QUEUEFULL);
 1652                 }
 1653                 mtx_lock(&sd->flagqueue_mtx);
 1654                 break;
 1655         case SEQ_BALANCE:
 1656                 mtx_unlock(&sd->flagqueue_mtx);
 1657                 SEQ_DEBUG(printf("seq_extended: chn %d, pan %d.\n", event[3], event[4]));
 1658                 if (md->synth.panning(md, event[3], (char)event[4]) == EAGAIN) {
 1659                         mtx_lock(&sd->flagqueue_mtx);
 1660                         return (QUEUEFULL);
 1661                 }
 1662                 mtx_lock(&sd->flagqueue_mtx);
 1663                 break;
 1664         case SEQ_CONTROLLER:
 1665                 mtx_unlock(&sd->flagqueue_mtx);
 1666                 SEQ_DEBUG(printf("seq_extended: chn %d, ctrlnum %d, val %d.\n", event[3], event[4], *(short *)&event[5]));
 1667                 if (md->synth.controller(md, event[3], event[4], *(short *)&event[5]) == EAGAIN) {
 1668                         mtx_lock(&sd->flagqueue_mtx);
 1669                         return (QUEUEFULL);
 1670                 }
 1671                 mtx_lock(&sd->flagqueue_mtx);
 1672                 break;
 1673         case SEQ_VOLMODE:
 1674                 mtx_unlock(&sd->flagqueue_mtx);
 1675                 SEQ_DEBUG(printf("seq_extended: mode %d.\n", event[3]));
 1676                 if (md->synth.volumemethod != NULL && md->synth.volumemethod(md, event[3]) == EAGAIN) {
 1677                         mtx_lock(&sd->flagqueue_mtx);
 1678                         return (QUEUEFULL);
 1679                 }
 1680                 mtx_lock(&sd->flagqueue_mtx);
 1681                 break;
 1682         }
 1683 
 1684         return (MORE);
 1685 }
 1686 
 1687 static int
 1688 seq_chnvoice(sc_p scp, u_char *event)
 1689 {
 1690         int voice;
 1691         seqdev_info *sd;
 1692         mididev_info *md;
 1693         u_char dev, cmd, chn, note, parm;
 1694 
 1695         voice = -1;
 1696         dev = event[1];
 1697         cmd = event[2];
 1698         chn = event[3];
 1699         note = event[4];
 1700         parm = event[5];
 1701 
 1702         sd = scp->devinfo;
 1703 
 1704         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1705 
 1706         if (lookup_mididev(scp, dev, LOOKUP_OPEN, &md) != 0)
 1707                 return (MORE);
 1708 
 1709         SEQ_DEBUG(printf("seq_chnvoice: unit %d, dev %d, cmd %s, chn %d, note %d, parm %d.\n",
 1710                          sd->unit,
 1711                          dev,
 1712                          midi_cmdname(cmd, cmdtab_seqcv),
 1713                          chn,
 1714                          note,
 1715                          parm));
 1716 
 1717         if (scp->seq_mode == SND_DEV_MUSIC && md->synth.allocvoice != NULL)
 1718                 voice = seq_allocvoice(scp, md, chn, note);
 1719         switch (cmd) {
 1720         case MIDI_NOTEON:
 1721                 if (note < 128 || note == 255) {
 1722                         if (voice == -1 && scp->seq_mode == SND_DEV_MUSIC && md->synth.allocvoice)
 1723                                 /* This is an internal synthesizer. (FM, GUS, etc) */
 1724                                 if ((voice = seq_allocvoice(scp, md, chn, note)) == EAGAIN)
 1725                                         return (QUEUEFULL);
 1726                         if (voice == -1)
 1727                                 voice = chn;
 1728 
 1729                         if (scp->seq_mode == SND_DEV_MUSIC && chn == 9) {
 1730                                 /* This channel is a percussion. The note number is the patch number. */
 1731                                 mtx_unlock(&sd->flagqueue_mtx);
 1732                                 if (md->synth.setinstr(md, voice, 128 + note) == EAGAIN) {
 1733                                         mtx_lock(&sd->flagqueue_mtx);
 1734                                         return (QUEUEFULL);
 1735                                 }
 1736                                 mtx_lock(&sd->flagqueue_mtx);
 1737 
 1738                                 note = 60; /* Middle C. */
 1739                         }
 1740                         if (scp->seq_mode == SND_DEV_MUSIC) {
 1741                                 mtx_unlock(&sd->flagqueue_mtx);
 1742                                 if (md->synth.setupvoice(md, voice, chn) == EAGAIN) {
 1743                                         mtx_lock(&sd->flagqueue_mtx);
 1744                                         return (QUEUEFULL);
 1745                                 }
 1746                                 mtx_lock(&sd->flagqueue_mtx);
 1747                         }
 1748                         mtx_unlock(&sd->flagqueue_mtx);
 1749                         if (md->synth.startnote(md, voice, note, parm) == EAGAIN) {
 1750                                 mtx_lock(&sd->flagqueue_mtx);
 1751                                 return (QUEUEFULL);
 1752                         }
 1753                         mtx_lock(&sd->flagqueue_mtx);
 1754                 }
 1755                 break;
 1756         case MIDI_NOTEOFF:
 1757                 if (voice == -1)
 1758                         voice = chn;
 1759                 mtx_unlock(&sd->flagqueue_mtx);
 1760                 if (md->synth.killnote(md, voice, note, parm) == EAGAIN) {
 1761                         mtx_lock(&sd->flagqueue_mtx);
 1762                         return (QUEUEFULL);
 1763                 }
 1764                 mtx_lock(&sd->flagqueue_mtx);
 1765                 break;
 1766         case MIDI_KEY_PRESSURE:
 1767                 if (voice == -1)
 1768                         voice = chn;
 1769                 mtx_unlock(&sd->flagqueue_mtx);
 1770                 if (md->synth.aftertouch(md, voice, parm) == EAGAIN) {
 1771                         mtx_lock(&sd->flagqueue_mtx);
 1772                         return (QUEUEFULL);
 1773                 }
 1774                 mtx_lock(&sd->flagqueue_mtx);
 1775                 break;
 1776         }
 1777 
 1778         return (MORE);
 1779 }
 1780 
 1781 static int
 1782 seq_findvoice(mididev_info *md, int chn, int note)
 1783 {
 1784         int i;
 1785         u_short key;
 1786 
 1787         key = (chn << 8) | (note + 1);
 1788 
 1789         mtx_lock(&md->synth.vc_mtx);
 1790         for (i = 0 ; i < md->synth.alloc.max_voice ; i++)
 1791                 if (md->synth.alloc.map[i] == key) {
 1792                         mtx_unlock(&md->synth.vc_mtx);
 1793                         return (i);
 1794                 }
 1795         mtx_unlock(&md->synth.vc_mtx);
 1796 
 1797         return (-1);
 1798 }
 1799 
 1800 static int
 1801 seq_allocvoice(sc_p scp, mididev_info *md, int chn, int note)
 1802 {
 1803         int voice;
 1804         u_short key;
 1805 
 1806         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 1807 
 1808         key = (chn << 8) | (note + 1);
 1809 
 1810         mtx_unlock(&scp->devinfo->flagqueue_mtx);
 1811         if ((voice = md->synth.allocvoice(md, chn, note, &md->synth.alloc)) == EAGAIN) {
 1812                 mtx_lock(&scp->devinfo->flagqueue_mtx);
 1813                 return (EAGAIN);
 1814         }
 1815         mtx_lock(&scp->devinfo->flagqueue_mtx);
 1816 
 1817         mtx_lock(&md->synth.vc_mtx);
 1818         md->synth.alloc.map[voice] = key;
 1819         md->synth.alloc.alloc_times[voice] = md->synth.alloc.timestamp++;
 1820         mtx_unlock(&md->synth.vc_mtx);
 1821 
 1822         return (voice);
 1823 }
 1824 
 1825 static int
 1826 seq_chncommon(sc_p scp, u_char *event)
 1827 {
 1828         int unit, i, val, key;
 1829         u_short w14;
 1830         u_char dev, cmd, chn, p1;
 1831         seqdev_info *sd;
 1832         mididev_info *md;
 1833 
 1834         dev = event[1];
 1835         cmd = event[2];
 1836         chn = event[3];
 1837         p1 = event[4];
 1838         w14 = *(u_short *)&event[6];
 1839 
 1840         sd = scp->devinfo;
 1841         unit = sd->unit;
 1842 
 1843         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1844 
 1845         if (lookup_mididev(scp, dev, LOOKUP_OPEN, &md) != 0)
 1846                 return (MORE);
 1847 
 1848         SEQ_DEBUG(printf("seq_chnvoice: unit %d, dev %d, cmd %s, chn %d, p1 %d, w14 %d.\n",
 1849                          sd->unit,
 1850                          dev,
 1851                          midi_cmdname(cmd, cmdtab_seqccmn),
 1852                          chn,
 1853                          p1,
 1854                          w14));
 1855 
 1856         switch (cmd) {
 1857         case MIDI_PGM_CHANGE:
 1858                 if (scp->seq_mode == SND_DEV_MUSIC) {
 1859                         mtx_lock(&md->synth.vc_mtx);
 1860                         md->synth.chn_info[chn].pgm_num = p1;
 1861                         mtx_unlock(&md->synth.vc_mtx);
 1862                         mtx_unlock(&sd->flagqueue_mtx);
 1863                         if (md->midiunit >= 0) {
 1864                                 if (md->synth.setinstr(md, chn, p1) == EAGAIN) {
 1865                                         mtx_lock(&sd->flagqueue_mtx);
 1866                                         return (QUEUEFULL);
 1867                                 }
 1868                         }
 1869                         mtx_lock(&sd->flagqueue_mtx);
 1870                 } else {
 1871                         /* For Mode 1. */
 1872                         mtx_unlock(&sd->flagqueue_mtx);
 1873                         if (md->synth.setinstr(md, chn, p1) == EAGAIN) {        
 1874                                 mtx_lock(&sd->flagqueue_mtx);
 1875                                 return (QUEUEFULL);
 1876                         }
 1877                         mtx_lock(&sd->flagqueue_mtx);
 1878                 }
 1879                 break;
 1880         case MIDI_CTL_CHANGE:
 1881                 /* mtx_lock(&md->giant); */
 1882                 if (scp->seq_mode == SND_DEV_MUSIC) {
 1883                         if (chn < 16 && p1 < 128) {
 1884                                 mtx_lock(&md->synth.vc_mtx);
 1885                                 md->synth.chn_info[chn].controllers[p1] = w14 & 0x7f;
 1886                                 if (p1 < 32)
 1887                                         /* We have set the MSB, clear the LSB. */
 1888                                         md->synth.chn_info[chn].controllers[p1 + 32] = 0;
 1889                                 if (md->midiunit >= 0) {
 1890                                         val = w14 & 0x7f;
 1891                                         if (p1 < 64) {
 1892                                                 /* Combine the MSB and the LSB. */
 1893                                                 val = ((md->synth.chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
 1894                                                     | (md->synth.chn_info[chn].controllers[p1 | 32] & 0x7f);
 1895                                                 p1 &= ~32;
 1896                                         }
 1897                                         /* Handle all of the notes playing on this channel. */
 1898                                         key = ((int)chn << 8);
 1899                                         for (i = 0 ; i < md->synth.alloc.max_voice ; i++)
 1900                                                 if ((md->synth.alloc.map[i] & 0xff00) == key) {
 1901                                                         mtx_unlock(&md->synth.vc_mtx);
 1902                                                         mtx_unlock(&sd->flagqueue_mtx);
 1903                                                         if (md->synth.controller(md, i, p1, val) == EAGAIN) {
 1904                                                                 mtx_lock(&sd->flagqueue_mtx);
 1905                                                                 return (QUEUEFULL);
 1906                                                         }
 1907                                                         mtx_lock(&sd->flagqueue_mtx);
 1908                                                         mtx_lock(&md->synth.vc_mtx);
 1909                                                 }
 1910                                         mtx_unlock(&md->synth.vc_mtx);
 1911                                 } else {
 1912                                         mtx_unlock(&md->synth.vc_mtx);
 1913                                         mtx_unlock(&sd->flagqueue_mtx);
 1914                                         if (md->synth.controller(md, chn, p1, w14) == EAGAIN) {
 1915                                                 mtx_lock(&sd->flagqueue_mtx);
 1916                                                 return (QUEUEFULL);
 1917                                         }
 1918                                         mtx_lock(&sd->flagqueue_mtx);
 1919                                 }
 1920                         }
 1921                 } else {
 1922                         /* For Mode 1. */
 1923                         mtx_unlock(&sd->flagqueue_mtx);
 1924                         if (md->synth.controller(md, chn, p1, w14) == EAGAIN) {
 1925                                 mtx_lock(&sd->flagqueue_mtx);
 1926                                 return (QUEUEFULL);
 1927                         }
 1928                         mtx_lock(&sd->flagqueue_mtx);
 1929                 }
 1930                 break;
 1931         case MIDI_PITCH_BEND:
 1932                 if (scp->seq_mode == SND_DEV_MUSIC) {
 1933                         mtx_lock(&md->synth.vc_mtx);
 1934                         md->synth.chn_info[chn].bender_value = w14;
 1935                         if (md->midiunit >= 0) {
 1936                                 /* Handle all of the notes playing on this channel. */
 1937                                 key = ((int)chn << 8);
 1938                                 for (i = 0 ; i < md->synth.alloc.max_voice ; i++)
 1939                                         if ((md->synth.alloc.map[i] & 0xff00) == key) {
 1940                                                 mtx_unlock(&md->synth.vc_mtx);
 1941                                                 mtx_unlock(&sd->flagqueue_mtx);
 1942                                                 if (md->synth.bender(md, i, w14) == EAGAIN) {
 1943                                                         mtx_lock(&sd->flagqueue_mtx);
 1944                                                         return (QUEUEFULL);
 1945                                                 }
 1946                                                 mtx_lock(&sd->flagqueue_mtx);
 1947                                         }
 1948                         } else {
 1949                                 mtx_unlock(&md->synth.vc_mtx);
 1950                                 mtx_unlock(&sd->flagqueue_mtx);
 1951                                 if (md->synth.bender(md, chn, w14) == EAGAIN) {
 1952                                         mtx_lock(&sd->flagqueue_mtx);
 1953                                         return (QUEUEFULL);
 1954                                 }
 1955                                 mtx_lock(&sd->flagqueue_mtx);
 1956                         }
 1957                 } else {
 1958                         /* For Mode 1. */
 1959                         mtx_unlock(&sd->flagqueue_mtx);
 1960                         if (md->synth.bender(md, chn, w14) == EAGAIN) {
 1961                                 mtx_lock(&sd->flagqueue_mtx);
 1962                                 return (QUEUEFULL);
 1963                         }
 1964                         mtx_lock(&sd->flagqueue_mtx);
 1965                 }
 1966                 break;
 1967         }
 1968 
 1969         return (MORE);
 1970 }
 1971 
 1972 static int
 1973 seq_timing(sc_p scp, u_char *event)
 1974 {
 1975         int unit, ret;
 1976         long parm;
 1977         seqdev_info *sd;
 1978 
 1979         sd = scp->devinfo;
 1980         unit = sd->unit;
 1981 
 1982         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 1983 
 1984         parm = *(long *)&event[4];
 1985 
 1986         if (scp->seq_mode == SND_DEV_MUSIC) {
 1987                 ret = scp->timer->event(scp->timer, event);
 1988                 if (ret == TIMERARMED)
 1989                         sd->flags |= SEQ_F_WRITING;
 1990                 return (ret);
 1991         }
 1992 
 1993         SEQ_DEBUG(printf("seq_timing: unit %d, cmd %s, parm %lu.\n",
 1994                          unit, midi_cmdname(event[1], cmdtab_timer), parm));
 1995 
 1996         ret = MORE;
 1997         switch (event[1]) {
 1998         case TMR_WAIT_REL:
 1999                 parm += scp->prev_event_time;
 2000                 /* FALLTHRU */
 2001         case TMR_WAIT_ABS:
 2002                 if (parm > 0) {
 2003                         sd->flags |= SEQ_F_WRITING;
 2004                         if (seq_requesttimer(scp, parm))
 2005                                 ret = TIMERARMED;
 2006                 }
 2007                 break;
 2008         case TMR_START:
 2009                 scp->seq_time = seq_gettime();
 2010                 scp->prev_input_time = 0;
 2011                 scp->prev_event_time = 0;
 2012                 scp->prev_wakeup_time = scp->seq_time;
 2013                 break;
 2014         case TMR_STOP:
 2015                 break;
 2016         case TMR_CONTINUE:
 2017                 break;
 2018         case TMR_TEMPO:
 2019                 break;
 2020         case TMR_ECHO:
 2021                 if (scp->seq_mode == SND_DEV_MUSIC)
 2022                         seq_copytoinput(scp, event, 8);
 2023                 else {
 2024                         parm = (parm << 8 | SEQ_ECHO);
 2025                         seq_copytoinput(scp, (u_char *)&parm, 4);
 2026                 }
 2027                 break;
 2028         }
 2029 
 2030         SEQ_DEBUG(printf("seq_timing: timer %s.\n",
 2031                          ret == TIMERARMED ? "armed" : "not armed"));
 2032 
 2033         return (ret);
 2034 }
 2035 
 2036 static int
 2037 seq_local(sc_p scp, u_char *event)
 2038 {
 2039         int unit;
 2040         seqdev_info *sd;
 2041 
 2042         sd = scp->devinfo;
 2043         unit = sd->unit;
 2044 
 2045         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 2046 
 2047         switch (event[1]) {
 2048         case LOCL_STARTAUDIO:
 2049 #if notyet
 2050                 DMAbuf_start_devices(*(u_int *)&event[4]);
 2051 #endif /* notyet */
 2052                 break;
 2053         }
 2054 
 2055         return (MORE);
 2056 }
 2057 
 2058 static int
 2059 seq_sysex(sc_p scp, u_char *event)
 2060 {
 2061         int unit, i, l;
 2062         seqdev_info *sd;
 2063         mididev_info *md;
 2064 
 2065         sd = scp->devinfo;
 2066         unit = sd->unit;
 2067 
 2068         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 2069 
 2070         if (lookup_mididev(scp, event[1], LOOKUP_OPEN, &md) != 0)
 2071                 return (MORE);
 2072 
 2073         l = 0;
 2074         for (i = 0 ; i < 6 && event[i + 2] != 0xff ; i++)
 2075                 l = i + 1;
 2076         if (l > 0) {
 2077                 mtx_unlock(&sd->flagqueue_mtx);
 2078                 if (md->synth.sendsysex(md, &event[2], l) == EAGAIN) {
 2079                         mtx_lock(&sd->flagqueue_mtx);
 2080                         return (QUEUEFULL);
 2081                 }
 2082                 mtx_lock(&sd->flagqueue_mtx);
 2083         }
 2084 
 2085         return (MORE);
 2086 }
 2087 
 2088 void
 2089 seq_timer(void *arg)
 2090 {
 2091         sc_p scp;
 2092         seqdev_info *sd;
 2093 
 2094         scp = arg;
 2095         sd = scp->devinfo;
 2096 
 2097         SEQ_DEBUG(printf("seq_timer: unit %d, timer fired.\n", sd->unit));
 2098 
 2099         /* Record the current timestamp. */
 2100         mtx_lock(&sd->flagqueue_mtx);
 2101 
 2102         scp->timer_running = 0;
 2103         scp->prev_wakeup_time = seq_gettime();
 2104         seq_startplay(scp);
 2105 
 2106         mtx_unlock(&sd->flagqueue_mtx);
 2107 }
 2108 
 2109 static int
 2110 seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct thread *td)
 2111 {
 2112         int midiunit, err, insync, chn;
 2113 
 2114         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 2115 
 2116         midiunit = md->unit;
 2117 
 2118         SEQ_DEBUG(printf("seq_openmidi: opening midi unit %d.\n", midiunit));
 2119 
 2120         err = midi_open(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, td);
 2121         if (err != 0) {
 2122                 printf("seq_openmidi: failed to open midi device %d.\n", midiunit);
 2123                 return (err);
 2124         }
 2125         mtx_lock(&md->synth.status_mtx);
 2126         mtx_lock(&md->flagqueue_mtx);
 2127         md->intr = seq_intr;
 2128         md->intrarg = scp->devinfo;
 2129         mtx_unlock(&md->flagqueue_mtx);
 2130         md->synth.sysex_state = 0;
 2131         if (scp->seq_mode == SND_DEV_MUSIC) {
 2132                 for (chn = 0 ; chn < 16 ; chn++) {
 2133                         md->synth.chn_info[chn].pgm_num = 0;
 2134                         md->synth.reset(md);
 2135                         md->synth.chn_info[chn].bender_value = (1 << 7);
 2136                 }
 2137         }
 2138         mtx_unlock(&md->synth.status_mtx);
 2139 
 2140         insync = 0;
 2141         if ((scp->devinfo->flags & SEQ_F_INSYNC) != 0) {
 2142                 insync = 1;
 2143                 cv_wait(&scp->devinfo->insync_cv, &scp->devinfo->flagqueue_mtx);
 2144         }
 2145 
 2146         TAILQ_INSERT_TAIL(&scp->midi_open, md, md_linkseq);
 2147 
 2148         if (insync)
 2149                 cv_broadcast(&scp->devinfo->insync_cv);
 2150 
 2151         return (0);
 2152 }
 2153 
 2154 static int
 2155 seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct thread *td)
 2156 {
 2157         int midiunit, insync;
 2158 
 2159         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 2160 
 2161         if (md == NULL || !MIDICONFED(md)) {
 2162                 SEQ_DEBUG(printf("seq_closemidi: midi device does not exist.\n"));
 2163                 return (ENXIO);
 2164         }
 2165         midiunit = md->unit;
 2166 
 2167         SEQ_DEBUG(printf("seq_closemidi: closing midi unit %d.\n", midiunit));
 2168 
 2169         midi_close(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, td);
 2170         mtx_lock(&md->flagqueue_mtx);
 2171         md->intr = NULL;
 2172         md->intrarg = NULL;
 2173         mtx_unlock(&md->flagqueue_mtx);
 2174 
 2175         insync = 0;
 2176         if ((scp->devinfo->flags & SEQ_F_INSYNC) != 0) {
 2177                 insync = 1;
 2178                 cv_wait(&scp->devinfo->insync_cv, &scp->devinfo->flagqueue_mtx);
 2179         }
 2180 
 2181         TAILQ_REMOVE(&scp->midi_open, md, md_linkseq);
 2182 
 2183         if (insync)
 2184                 cv_broadcast(&scp->devinfo->insync_cv);
 2185 
 2186         return (0);
 2187 }
 2188 
 2189 static void
 2190 seq_panic(sc_p scp)
 2191 {
 2192         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 2193 
 2194         seq_reset(scp);
 2195 }
 2196 
 2197 static int
 2198 seq_reset(sc_p scp)
 2199 {
 2200         int unit, chn, lenw, ret;
 2201         seqdev_info *sd;
 2202         mididev_info *md;
 2203         u_char c[3];
 2204 
 2205         sd = scp->devinfo;
 2206         unit = sd->unit;
 2207 
 2208         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 2209 
 2210         SEQ_DEBUG(printf("seq_reset: unit %d.\n", unit));
 2211 
 2212         if ((sd->flags & SEQ_F_INSYNC) != 0)
 2213                 cv_wait(&sd->insync_cv, &sd->flagqueue_mtx);
 2214 
 2215         /* Stop reading and writing. */
 2216         sd->callback(sd, SEQ_CB_ABORT | SEQ_CB_RD | SEQ_CB_WR);
 2217 
 2218         /* Clear the queues. */
 2219         midibuf_clear(&sd->midi_dbuf_in);
 2220         midibuf_clear(&sd->midi_dbuf_out);
 2221 
 2222         /* Reset the synthesizers. */
 2223         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq)
 2224                 md->synth.reset(md);
 2225 
 2226         if (scp->seq_mode == SND_DEV_MUSIC) {
 2227                 for (chn = 0 ; chn < 16 ; chn++) {
 2228                         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
 2229                                 mtx_unlock(&sd->flagqueue_mtx);
 2230                                 ret = 0;
 2231                                 if (md->synth.controller(md, chn, 123, 0) == EAGAIN /* All notes off. */
 2232                                     || md->synth.controller(md, chn, 121, 0) == EAGAIN /* Reset all controllers. */
 2233                                     || md->synth.bender(md, chn, 1 << 13) == EAGAIN) /* Reset pitch bend. */
 2234                                         ret = EAGAIN;
 2235                                 mtx_lock(&sd->flagqueue_mtx);
 2236                                 return (ret);
 2237                         }
 2238                 }
 2239         } else {
 2240                 TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
 2241                         for (chn = 0 ; chn < 16 ; chn++) {
 2242                                 mtx_unlock(&sd->flagqueue_mtx);
 2243                                 c[0] = 0xb0 | (chn & 0x0f);
 2244                                 c[1] = (u_char)0x78; /* All sound off */
 2245                                 c[2] = (u_char)0;
 2246                                 md->synth.writeraw(md, c, 3, &lenw, 0);
 2247                                 c[1] = (u_char)0x7b; /* All note off */
 2248                                 md->synth.writeraw(md, c, 3, &lenw, 0);
 2249                                 c[1] = (u_char)0x79; /* Reset all controller */
 2250                                 md->synth.writeraw(md, c, 3, &lenw, 0);
 2251                                 mtx_lock(&sd->flagqueue_mtx);
 2252                         }
 2253                 }
 2254                 seq_sync(scp);
 2255                 TAILQ_FOREACH(md, &scp->midi_open, md_linkseq)
 2256                         lookup_mididev(scp, md->unit, LOOKUP_CLOSE, NULL);
 2257         }
 2258 
 2259         return (0);
 2260 }
 2261 
 2262 #define SEQ_SYNC_TIMEOUT 8
 2263 static int
 2264 seq_sync(sc_p scp)
 2265 {
 2266         int i, rl;
 2267         seqdev_info *sd;
 2268         mididev_info *md;
 2269 
 2270         sd = scp->devinfo;
 2271 
 2272         mtx_assert(&sd->flagqueue_mtx, MA_OWNED);
 2273 
 2274         SEQ_DEBUG(printf("seq_sync: unit %d.\n", sd->unit));
 2275         sd->flags |= SEQ_F_INSYNC;
 2276 
 2277         while (sd->midi_dbuf_out.rl >= EV_SZ) {
 2278                 if ((sd->flags & SEQ_F_WRITING) == 0)
 2279                         sd->callback(sd, SEQ_CB_START | SEQ_CB_WR);
 2280                 rl = sd->midi_dbuf_out.rl;
 2281                 i = cv_timedwait_sig(&sd->midi_dbuf_out.cv_out, &sd->flagqueue_mtx, SEQ_SYNC_TIMEOUT * hz);
 2282                 if (i == EINTR || i == ERESTART) {
 2283                         if (i == EINTR)
 2284                                 sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR);
 2285                         sd->flags &= ~SEQ_F_INSYNC;
 2286                         return (i);
 2287                 }
 2288                 if (i == EWOULDBLOCK && rl == sd->midi_dbuf_out.rl && !scp->timer_running) {
 2289                         /* A queue seems to be stuck up. Give up and clear queues. */
 2290                         sd->callback(sd, SEQ_CB_STOP | SEQ_CB_WR);
 2291                         midibuf_clear(&sd->midi_dbuf_out);
 2292                         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
 2293                                 mtx_lock(&md->flagqueue_mtx);
 2294                                 md->callback(md, MIDI_CB_ABORT | MIDI_CB_WR);
 2295                                 midibuf_clear(&md->midi_dbuf_out);
 2296                                 mtx_unlock(&md->flagqueue_mtx);
 2297                         }
 2298                         break;
 2299                 }
 2300         }
 2301 
 2302         /*
 2303          * Since syncing a midi device might block, unlock sd->flagqueue_mtx.
 2304          * Keep sd->midi_dbuf_out from writing by setting SEQ_F_INSYNC.
 2305          * sd->insync_cv is signalled when sync is finished.
 2306          */
 2307         mtx_unlock(&sd->flagqueue_mtx);
 2308 
 2309         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
 2310                 mtx_lock(&md->flagqueue_mtx);
 2311                 midi_sync(md);
 2312                 mtx_unlock(&md->flagqueue_mtx);
 2313         }
 2314 
 2315         mtx_lock(&sd->flagqueue_mtx);
 2316         sd->flags &= ~SEQ_F_INSYNC;
 2317         cv_broadcast(&sd->insync_cv);
 2318 
 2319         return (0);
 2320 }
 2321 
 2322 /*
 2323  * a small utility function which, given a device number, returns
 2324  * a pointer to the associated seqdev_info struct, and sets the unit
 2325  * number.
 2326  */
 2327 static seqdev_info *
 2328 get_seqdev_info(dev_t i_dev, int *unit)
 2329 {
 2330         int u;
 2331 
 2332         if (MIDIDEV(i_dev) != SND_DEV_SEQ && MIDIDEV(i_dev) != SND_DEV_MUSIC)
 2333                 return NULL;
 2334         u = MIDIUNIT(i_dev);
 2335         if (unit)
 2336                 *unit = u ;
 2337 
 2338         return get_seqdev_info_unit(u);
 2339 }
 2340 
 2341 /*
 2342  * a small utility function which, given a unit number, returns
 2343  * a pointer to the associated mididev_info struct.
 2344  */
 2345 seqdev_info *
 2346 get_seqdev_info_unit(int unit)
 2347 {
 2348         seqdev_info *sd;
 2349 
 2350         mtx_lock(&seqinfo_mtx);
 2351         TAILQ_FOREACH(sd, &seq_info, sd_link) {
 2352                 if (sd->unit == unit)
 2353                         break;
 2354         }
 2355         mtx_unlock(&seqinfo_mtx);
 2356 
 2357         return sd;
 2358 }
 2359 
 2360 /* Create a new sequencer device info structure. */
 2361 seqdev_info *
 2362 create_seqdev_info_unit(int unit, seqdev_info *seq)
 2363 {
 2364         seqdev_info *sd, *sdnew;
 2365 
 2366         /* As malloc(9) might block, allocate seqdev_info now. */
 2367         sdnew = malloc(sizeof(seqdev_info), M_DEVBUF, M_WAITOK | M_ZERO);
 2368         if (sdnew == NULL)
 2369                 return NULL;
 2370         bcopy(seq, sdnew, sizeof(seqdev_info));
 2371         sdnew->unit = unit;
 2372         midibuf_init(&sdnew->midi_dbuf_in);
 2373         midibuf_init(&sdnew->midi_dbuf_out);
 2374         mtx_init(&sdnew->flagqueue_mtx, "seqflq", NULL, MTX_DEF);
 2375         cv_init(&sdnew->insync_cv, "seqins");
 2376 
 2377         mtx_lock(&seqinfo_mtx);
 2378 
 2379         TAILQ_FOREACH(sd, &seq_info, sd_link) {
 2380                 if (sd->unit == unit) {
 2381                         mtx_unlock(&seqinfo_mtx);
 2382                         midibuf_destroy(&sdnew->midi_dbuf_in);
 2383                         midibuf_destroy(&sdnew->midi_dbuf_out);
 2384                         mtx_destroy(&sdnew->flagqueue_mtx);
 2385                         cv_destroy(&sdnew->insync_cv);
 2386                         free(sdnew, M_DEVBUF);
 2387                         return sd;
 2388                 }
 2389         }
 2390 
 2391         mtx_lock(&sdnew->flagqueue_mtx);
 2392         TAILQ_INSERT_TAIL(&seq_info, sdnew, sd_link);
 2393         nseq++;
 2394 
 2395         mtx_unlock(&seqinfo_mtx);
 2396 
 2397         return sdnew;
 2398 }
 2399 
 2400 /*
 2401  * Look up a midi device by its unit number opened by this sequencer.
 2402  * If the device is not opened and mode is LOOKUP_OPEN, open the device.
 2403  */
 2404 static int
 2405 lookup_mididev(sc_p scp, int unit, int mode, mididev_info **mdp)
 2406 {
 2407         int ret;
 2408         mididev_info *md;
 2409 
 2410         if (mdp == NULL)
 2411                 mdp = &md;
 2412 
 2413         *mdp = NULL;
 2414 
 2415         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 2416 
 2417         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
 2418                 if (scp->seq_mode == SND_DEV_MUSIC ? md->unit == unit : md->synthunit == unit) {
 2419                         *mdp = md;
 2420                         if (mode == LOOKUP_CLOSE)
 2421                                 return seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, curthread);
 2422 
 2423                         return (md != NULL && MIDICONFED(md)) ? 0 : ENXIO;
 2424                 }
 2425         }
 2426 
 2427         if (mode == LOOKUP_OPEN) {
 2428                 if (scp->seq_mode == SND_DEV_MUSIC)
 2429                         md = get_mididev_info_unit(unit);
 2430                 else
 2431                         md = get_mididev_synth_unit(unit);
 2432                 if (md != NULL) {
 2433                         *mdp = md;
 2434                         ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curthread);
 2435                         return ret;
 2436                 }
 2437         }
 2438 
 2439         return ENXIO;
 2440 }
 2441 
 2442 /*
 2443  * Look up a midi device by its midi unit number opened by this sequencer.
 2444  * If the device is not opened and mode is LOOKUP_OPEN, open the device.
 2445  */
 2446 static int
 2447 lookup_mididev_midi(sc_p scp, int unit, int mode, mididev_info **mdp)
 2448 {
 2449         int ret;
 2450         mididev_info *md;
 2451 
 2452         if (mdp == NULL)
 2453                 mdp = &md;
 2454 
 2455         *mdp = NULL;
 2456 
 2457         if (scp->seq_mode == SND_DEV_MUSIC)
 2458                 return (ENXIO);
 2459 
 2460         mtx_assert(&scp->devinfo->flagqueue_mtx, MA_OWNED);
 2461 
 2462         TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) {
 2463                 if (md->midiunit == unit) {
 2464                         *mdp = md;
 2465                         if (mode == LOOKUP_CLOSE)
 2466                                 return seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, curthread);
 2467 
 2468                         return (md != NULL && MIDICONFED(md)) ? 0 : ENXIO;
 2469                 }
 2470         }
 2471 
 2472         if (mode == LOOKUP_OPEN) {
 2473                 md = get_mididev_midi_unit(unit);
 2474                 if (md != NULL) {
 2475                         *mdp = md;
 2476                         ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curthread);
 2477                         return ret;
 2478                 }
 2479         }
 2480 
 2481         return ENXIO;
 2482 }
 2483 
 2484 /* XXX These functions are actually redundant. */
 2485 static int
 2486 seqopen(dev_t i_dev, int flags, int mode, struct thread *td)
 2487 {
 2488         switch (MIDIDEV(i_dev)) {
 2489         case MIDI_DEV_SEQ:
 2490         case MIDI_DEV_MUSIC:
 2491                 return seq_open(i_dev, flags, mode, td);
 2492         }
 2493 
 2494         return (ENXIO);
 2495 }
 2496 
 2497 static int
 2498 seqclose(dev_t i_dev, int flags, int mode, struct thread *td)
 2499 {
 2500         switch (MIDIDEV(i_dev)) {
 2501         case MIDI_DEV_SEQ:
 2502         case MIDI_DEV_MUSIC:
 2503                 return seq_close(i_dev, flags, mode, td);
 2504         }
 2505 
 2506         return (ENXIO);
 2507 }
 2508 
 2509 static int
 2510 seqread(dev_t i_dev, struct uio * buf, int flag)
 2511 {
 2512         switch (MIDIDEV(i_dev)) {
 2513         case MIDI_DEV_SEQ:
 2514         case MIDI_DEV_MUSIC:
 2515                 return seq_read(i_dev, buf, flag);
 2516         }
 2517 
 2518         return (ENXIO);
 2519 }
 2520 
 2521 static int
 2522 seqwrite(dev_t i_dev, struct uio * buf, int flag)
 2523 {
 2524         switch (MIDIDEV(i_dev)) {
 2525         case MIDI_DEV_SEQ:
 2526         case MIDI_DEV_MUSIC:
 2527                 return seq_write(i_dev, buf, flag);
 2528         }
 2529 
 2530         return (ENXIO);
 2531 }
 2532 
 2533 static int
 2534 seqioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td)
 2535 {
 2536         switch (MIDIDEV(i_dev)) {
 2537         case MIDI_DEV_SEQ:
 2538         case MIDI_DEV_MUSIC:
 2539                 return seq_ioctl(i_dev, cmd, arg, mode, td);
 2540         }
 2541 
 2542         return (ENXIO);
 2543 }
 2544 
 2545 static int
 2546 seqpoll(dev_t i_dev, int events, struct thread *td)
 2547 {
 2548         switch (MIDIDEV(i_dev)) {
 2549         case MIDI_DEV_SEQ:
 2550         case MIDI_DEV_MUSIC:
 2551                 return seq_poll(i_dev, events, td);
 2552         }
 2553 
 2554         return (ENXIO);
 2555 }
 2556 
 2557 static int
 2558 seq_modevent(module_t mod, int type, void *data)
 2559 {
 2560         int retval;
 2561 
 2562         retval = 0;
 2563 
 2564         switch (type) {
 2565         case MOD_LOAD:
 2566                 seq_init();
 2567                 break;
 2568 
 2569         case MOD_UNLOAD:
 2570                 printf("sequencer: unload not supported yet.\n");
 2571                 retval = EOPNOTSUPP;
 2572                 break;
 2573 
 2574         default:
 2575                 break;
 2576         }
 2577 
 2578         return retval;
 2579 }
 2580 
 2581 DEV_MODULE(seq, seq_modevent, NULL);
 2582 
 2583 static void
 2584 seq_clone(arg, name, namelen, dev)
 2585         void *arg;
 2586         char *name;
 2587         int namelen;
 2588         dev_t *dev;
 2589 {
 2590         int u;
 2591 
 2592         if (*dev != NODEV)
 2593                 return;
 2594         if (bcmp(name, "sequencer", 9) != 0)
 2595                 return;
 2596         if (name[10] != '\0' && name[11] != '\0')
 2597                 return;
 2598         u = name[9] - '';
 2599         if (name[10] != '\0') {
 2600                 u *= 10;
 2601                 u += name[10] - '';
 2602         }
 2603         seq_initunit(u);
 2604         *dev = MIDIMKDEV(SEQ_CDEV_MAJOR, u, MIDI_DEV_SEQ);
 2605         return;
 2606 }

Cache object: 59c9b2f1df30dd04171607ae75420686


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