2 * Copyright (c) 2003 Mathew Kanner
3 * Copyright (c) 1998 The NetBSD Foundation, Inc.
6 * This code is derived from software contributed to The NetBSD Foundation
7 * by Lennart Augustsson (augustss@netbsd.org).
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
20 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
22 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
32 * Parts of this file started out as NetBSD: midi.c 1.31
33 * They are mostly gone. Still the most obvious will be the state
37 #include <sys/cdefs.h>
38 __FBSDID("$FreeBSD$");
40 #include <sys/param.h>
41 #include <sys/queue.h>
42 #include <sys/kernel.h>
44 #include <sys/mutex.h>
46 #include <sys/signalvar.h>
48 #include <sys/selinfo.h>
49 #include <sys/sysctl.h>
50 #include <sys/types.h>
51 #include <sys/malloc.h>
52 #include <sys/param.h>
53 #include <sys/systm.h>
55 #include <sys/fcntl.h>
56 #include <sys/types.h>
61 #include <sys/module.h>
63 #ifdef HAVE_KERNEL_OPTION_HEADERS
67 #include <dev/sound/midi/midi.h>
70 #include <dev/sound/midi/midiq.h>
72 MALLOC_DEFINE(M_MIDI, "midi buffers", "Midi data allocation area");
74 #ifndef KOBJMETHOD_END
75 #define KOBJMETHOD_END { NULL, NULL }
78 #define PCMMKMINOR(u, d, c) ((((c) & 0xff) << 16) | (((u) & 0x0f) << 4) | ((d) & 0x0f))
79 #define MIDIMKMINOR(u, d, c) PCMMKMINOR(u, d, c)
81 #define MIDI_DEV_RAW 2
82 #define MIDI_DEV_MIDICTL 12
85 MIDI_IN_START, MIDI_IN_SYSEX, MIDI_IN_DATA
89 * The MPU interface current has init() uninit() inqsize() outqsize()
90 * callback() : fiddle with the tx|rx status.
96 * /dev/rmidi Structure definitions
99 #define MIDI_NAMELEN 16
102 struct mtx lock; /* Protects all but queues */
105 int unit; /* Should only be used in midistat */
106 int channel; /* Should only be used in midistat */
109 int flags; /* File flags */
110 char name[MIDI_NAMELEN];
111 struct mtx qlock; /* Protects inq, outq and flags */
112 MIDIQ_HEAD(, char) inq, outq;
114 struct selinfo rsel, wsel;
115 int hiwat; /* QLEN(outq)>High-water -> disable
116 * writes from userland */
117 enum midi_states inq_state;
118 int inq_status, inq_left; /* Variables for the state machine in
119 * Midi_in, this is to provide that
120 * signals only get issued only
121 * complete command packets. */
124 struct synth_midi *synth;
126 TAILQ_ENTRY(snd_midi) link;
134 static synth_open_t midisynth_open;
135 static synth_close_t midisynth_close;
136 static synth_writeraw_t midisynth_writeraw;
137 static synth_killnote_t midisynth_killnote;
138 static synth_startnote_t midisynth_startnote;
139 static synth_setinstr_t midisynth_setinstr;
140 static synth_alloc_t midisynth_alloc;
141 static synth_controller_t midisynth_controller;
142 static synth_bender_t midisynth_bender;
145 static kobj_method_t midisynth_methods[] = {
146 KOBJMETHOD(synth_open, midisynth_open),
147 KOBJMETHOD(synth_close, midisynth_close),
148 KOBJMETHOD(synth_writeraw, midisynth_writeraw),
149 KOBJMETHOD(synth_setinstr, midisynth_setinstr),
150 KOBJMETHOD(synth_startnote, midisynth_startnote),
151 KOBJMETHOD(synth_killnote, midisynth_killnote),
152 KOBJMETHOD(synth_alloc, midisynth_alloc),
153 KOBJMETHOD(synth_controller, midisynth_controller),
154 KOBJMETHOD(synth_bender, midisynth_bender),
158 DEFINE_CLASS(midisynth, midisynth_methods, 0);
161 * Module Exports & Interface
163 * struct midi_chan *midi_init(MPU_CLASS cls, int unit, int chan,
165 * int midi_uninit(struct snd_midi *)
168 * EBUSY or other error
170 * int midi_in(struct snd_midi *, char *buf, int count)
171 * int midi_out(struct snd_midi *, char *buf, int count)
173 * midi_{in,out} return actual size transfered
179 * midi_devs tailq, holder of all rmidi instances protected by midistat_lock
182 TAILQ_HEAD(, snd_midi) midi_devs;
185 * /dev/midistat variables and declarations, protected by midistat_lock
188 static struct mtx midistat_lock;
189 static int midistat_isopen = 0;
190 static struct sbuf midistat_sbuf;
191 static int midistat_bufptr;
192 static struct cdev *midistat_dev;
195 * /dev/midistat dev_t declarations
198 static d_open_t midistat_open;
199 static d_close_t midistat_close;
200 static d_read_t midistat_read;
202 static struct cdevsw midistat_cdevsw = {
203 .d_version = D_VERSION,
204 .d_open = midistat_open,
205 .d_close = midistat_close,
206 .d_read = midistat_read,
207 .d_name = "midistat",
212 * /dev/rmidi dev_t declarations, struct variable access is protected by
213 * locks contained within the structure.
216 static d_open_t midi_open;
217 static d_close_t midi_close;
218 static d_ioctl_t midi_ioctl;
219 static d_read_t midi_read;
220 static d_write_t midi_write;
221 static d_poll_t midi_poll;
223 static struct cdevsw midi_cdevsw = {
224 .d_version = D_VERSION,
226 .d_close = midi_close,
228 .d_write = midi_write,
229 .d_ioctl = midi_ioctl,
235 * Prototypes of library functions
238 static int midi_destroy(struct snd_midi *, int);
239 static int midistat_prepare(struct sbuf * s);
240 static int midi_load(void);
241 static int midi_unload(void);
246 SYSCTL_NODE(_hw, OID_AUTO, midi, CTLFLAG_RD, 0, "Midi driver");
247 static SYSCTL_NODE(_hw_midi, OID_AUTO, stat, CTLFLAG_RD, 0, "Status device");
250 /* XXX: should this be moved into debug.midi? */
251 SYSCTL_INT(_hw_midi, OID_AUTO, debug, CTLFLAG_RW, &midi_debug, 0, "");
254 SYSCTL_INT(_hw_midi, OID_AUTO, dumpraw, CTLFLAG_RW, &midi_dumpraw, 0, "");
257 SYSCTL_INT(_hw_midi, OID_AUTO, instroff, CTLFLAG_RW, &midi_instroff, 0, "");
259 int midistat_verbose;
260 SYSCTL_INT(_hw_midi_stat, OID_AUTO, verbose, CTLFLAG_RW,
261 &midistat_verbose, 0, "");
263 #define MIDI_DEBUG(l,a) if(midi_debug>=l) a
269 * Register a new rmidi device. cls midi_if interface unit == 0 means
270 * auto-assign new unit number unit != 0 already assigned a unit number, eg.
271 * not the first channel provided by this device. channel, sub-unit
272 * cookie is passed back on MPU calls Typical device drivers will call with
273 * unit=0, channel=1..(number of channels) and cookie=soft_c and won't care
274 * what unit number is used.
276 * It is an error to call midi_init with an already used unit/channel combo.
278 * Returns NULL on error
282 midi_init(kobj_class_t cls, int unit, int channel, void *cookie)
286 int inqsize, outqsize;
289 MIDI_DEBUG(1, printf("midiinit: unit %d/%d.\n", unit, channel));
290 mtx_lock(&midistat_lock);
292 * Protect against call with existing unit/channel or auto-allocate a
296 TAILQ_FOREACH(m, &midi_devs, link) {
299 if (m->unit == unit && m->channel == channel) {
300 mtx_unlock(&m->lock);
305 * Find a better unit number
310 mtx_unlock(&m->lock);
316 MIDI_DEBUG(1, printf("midiinit #2: unit %d/%d.\n", unit, channel));
317 m = malloc(sizeof(*m), M_MIDI, M_NOWAIT | M_ZERO);
321 m->synth = malloc(sizeof(*m->synth), M_MIDI, M_NOWAIT | M_ZERO);
322 kobj_init((kobj_t)m->synth, &midisynth_class);
324 kobj_init((kobj_t)m, cls);
325 inqsize = MPU_INQSIZE(m, cookie);
326 outqsize = MPU_OUTQSIZE(m, cookie);
328 MIDI_DEBUG(1, printf("midiinit queues %d/%d.\n", inqsize, outqsize));
329 if (!inqsize && !outqsize)
332 mtx_init(&m->lock, "raw midi", NULL, 0);
333 mtx_init(&m->qlock, "q raw midi", NULL, 0);
339 buf = malloc(sizeof(MIDI_TYPE) * inqsize, M_MIDI, M_NOWAIT);
343 MIDIQ_INIT(m->inq, buf, inqsize);
346 buf = malloc(sizeof(MIDI_TYPE) * outqsize, M_MIDI, M_NOWAIT);
349 m->hiwat = outqsize / 2;
351 MIDIQ_INIT(m->outq, buf, outqsize);
353 if ((inqsize && !MIDIQ_BUF(m->inq)) ||
354 (outqsize && !MIDIQ_BUF(m->outq)))
361 m->channel = channel;
364 if (MPU_INIT(m, cookie))
367 mtx_unlock(&m->lock);
368 mtx_unlock(&m->qlock);
370 TAILQ_INSERT_TAIL(&midi_devs, m, link);
372 mtx_unlock(&midistat_lock);
374 m->dev = make_dev(&midi_cdevsw,
375 MIDIMKMINOR(unit, MIDI_DEV_RAW, channel),
376 UID_ROOT, GID_WHEEL, 0666, "midi%d.%d", unit, channel);
381 err2: mtx_destroy(&m->qlock);
382 mtx_destroy(&m->lock);
384 if (MIDIQ_BUF(m->inq))
385 free(MIDIQ_BUF(m->inq), M_MIDI);
386 if (MIDIQ_BUF(m->outq))
387 free(MIDIQ_BUF(m->outq), M_MIDI);
388 err1: free(m, M_MIDI);
389 err0: mtx_unlock(&midistat_lock);
390 MIDI_DEBUG(1, printf("midi_init ended in error\n"));
395 * midi_uninit does not call MIDI_UNINIT, as since this is the implementors
396 * entry point. midi_uninit if fact, does not send any methods. A call to
397 * midi_uninit is a defacto promise that you won't manipulate ch anymore
402 midi_uninit(struct snd_midi *m)
407 mtx_lock(&midistat_lock);
410 if (!(m->rchan || m->wchan))
422 err = midi_destroy(m, 0);
426 err: mtx_unlock(&m->lock);
427 exit: mtx_unlock(&midistat_lock);
432 * midi_in: process all data until the queue is full, then discards the rest.
433 * Since midi_in is a state machine, data discards can cause it to get out of
434 * whack. Process as much as possible. It calls, wakeup, selnotify and
435 * psignal at most once.
439 static int midi_lengths[] = {2, 2, 2, 2, 1, 1, 2, 0};
442 /* Number of bytes in a MIDI command */
443 #define MIDI_LENGTH(d) (midi_lengths[((d) >> 4) & 7])
444 #define MIDI_ACK 0xfe
445 #define MIDI_IS_STATUS(d) ((d) >= 0x80)
446 #define MIDI_IS_COMMON(d) ((d) >= 0xf0)
448 #define MIDI_SYSEX_START 0xF0
449 #define MIDI_SYSEX_END 0xF7
453 midi_in(struct snd_midi *m, MIDI_TYPE *buf, int size)
455 /* int i, sig, enq; */
458 /* MIDI_TYPE data; */
459 MIDI_DEBUG(5, printf("midi_in: m=%p size=%d\n", m, size));
464 if (!(m->flags & M_RX))
472 * Don't bother queuing if not in read mode. Discard everything and
473 * return size so the caller doesn't freak out.
476 if (!(m->flags & M_RX))
479 for (i = sig = 0; i < size; i++) {
483 if (data == MIDI_ACK)
486 switch (m->inq_state) {
488 if (MIDI_IS_STATUS(data)) {
490 case 0xf0: /* Sysex */
491 m->inq_state = MIDI_IN_SYSEX;
493 case 0xf1: /* MTC quarter frame */
494 case 0xf3: /* Song select */
495 m->inq_state = MIDI_IN_DATA;
499 case 0xf2: /* Song position pointer */
500 m->inq_state = MIDI_IN_DATA;
505 if (MIDI_IS_COMMON(data)) {
509 m->inq_state = MIDI_IN_DATA;
511 m->inq_status = data;
512 m->inq_left = MIDI_LENGTH(data);
516 } else if (MIDI_IS_STATUS(m->inq_status)) {
517 m->inq_state = MIDI_IN_DATA;
518 if (!MIDIQ_FULL(m->inq)) {
520 MIDIQ_ENQ(m->inq, &m->inq_status, 1);
523 m->inq_left = MIDI_LENGTH(m->inq_status) - 1;
527 * End of case MIDI_IN_START:
532 if (--m->inq_left <= 0)
533 sig = 1;/* deliver data */
536 if (data == MIDI_SYSEX_END)
537 m->inq_state = MIDI_IN_START;
542 if (!MIDIQ_FULL(m->inq)) {
543 MIDIQ_ENQ(m->inq, &data, 1);
547 * End of the state machines main "for loop"
552 MIDI_DEBUG(6, printf("midi_in: len %jd avail %jd\n",
553 (intmax_t)MIDIQ_LEN(m->inq),
554 (intmax_t)MIDIQ_AVAIL(m->inq)));
555 if (MIDIQ_AVAIL(m->inq) > size) {
557 MIDIQ_ENQ(m->inq, buf, size);
559 MIDI_DEBUG(4, printf("midi_in: Discarding data qu\n"));
560 mtx_unlock(&m->qlock);
570 kern_psignal(m->async, SIGIO);
571 PROC_UNLOCK(m->async);
576 mtx_unlock(&m->qlock);
581 * midi_out: The only clearer of the M_TXEN flag.
584 midi_out(struct snd_midi *m, MIDI_TYPE *buf, int size)
591 if (!(m->flags & M_TXEN))
594 MIDI_DEBUG(2, printf("midi_out: %p\n", m));
596 used = MIN(size, MIDIQ_LEN(m->outq));
597 MIDI_DEBUG(3, printf("midi_out: used %d\n", used));
599 MIDIQ_DEQ(m->outq, buf, used);
600 if (MIDIQ_EMPTY(m->outq)) {
602 MPU_CALLBACKP(m, m->cookie, m->flags);
604 if (used && MIDIQ_AVAIL(m->outq) > m->hiwat) {
612 kern_psignal(m->async, SIGIO);
613 PROC_UNLOCK(m->async);
616 mtx_unlock(&m->qlock);
622 * /dev/rmidi#.# device access functions
625 midi_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
627 struct snd_midi *m = i_dev->si_drv1;
630 MIDI_DEBUG(1, printf("midiopen %p %s %s\n", td,
631 flags & FREAD ? "M_RX" : "", flags & FWRITE ? "M_TX" : ""));
641 if (MIDIQ_SIZE(m->inq) == 0)
643 else if (m->flags & M_RX)
648 if (flags & FWRITE) {
649 if (MIDIQ_SIZE(m->outq) == 0)
651 else if (m->flags & M_TX)
663 m->flags |= M_RX | M_RXEN;
665 * Only clear the inq, the outq might still have data to drain
666 * from a previous session
674 MPU_CALLBACK(m, m->cookie, m->flags);
676 MIDI_DEBUG(2, printf("midi_open: opened.\n"));
678 err: mtx_unlock(&m->qlock);
679 mtx_unlock(&m->lock);
684 midi_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
686 struct snd_midi *m = i_dev->si_drv1;
690 MIDI_DEBUG(1, printf("midi_close %p %s %s\n", td,
691 flags & FREAD ? "M_RX" : "", flags & FWRITE ? "M_TX" : ""));
699 if ((flags & FREAD && !(m->flags & M_RX)) ||
700 (flags & FWRITE && !(m->flags & M_TX))) {
709 m->flags &= ~(M_RX | M_RXEN);
713 if ((m->flags & (M_TXEN | M_RXEN)) != (oldflags & (M_RXEN | M_TXEN)))
714 MPU_CALLBACK(m, m->cookie, m->flags);
716 MIDI_DEBUG(1, printf("midi_close: closed, busy = %d.\n", m->busy));
718 mtx_unlock(&m->qlock);
719 mtx_unlock(&m->lock);
725 * TODO: midi_read, per oss programmer's guide pg. 42 should return as soon
726 * as data is available.
729 midi_read(struct cdev *i_dev, struct uio *uio, int ioflag)
731 #define MIDI_RSIZE 32
732 struct snd_midi *m = i_dev->si_drv1;
735 char buf[MIDI_RSIZE];
737 MIDI_DEBUG(5, printf("midiread: count=%lu\n",
738 (unsigned long)uio->uio_resid));
748 if (!(m->flags & M_RX))
751 while (uio->uio_resid > 0) {
752 while (MIDIQ_EMPTY(m->inq)) {
753 retval = EWOULDBLOCK;
754 if (ioflag & O_NONBLOCK)
756 mtx_unlock(&m->lock);
758 retval = msleep(&m->rchan, &m->qlock,
759 PCATCH | PDROP, "midi RX", 0);
761 * We slept, maybe things have changed since last
766 if (m != i_dev->si_drv1)
768 /* if (retval && retval != ERESTART) */
777 MIDI_DEBUG(6, printf("midi_read start\n"));
779 * At this point, it is certain that m->inq has data
782 used = MIN(MIDIQ_LEN(m->inq), uio->uio_resid);
783 used = MIN(used, MIDI_RSIZE);
785 MIDI_DEBUG(6, printf("midiread: uiomove cc=%d\n", used));
786 MIDIQ_DEQ(m->inq, buf, used);
787 retval = uiomove(buf, used, uio);
793 * If we Made it here then transfer is good
796 err1: mtx_unlock(&m->qlock);
797 mtx_unlock(&m->lock);
798 err0: MIDI_DEBUG(4, printf("midi_read: ret %d\n", retval));
803 * midi_write: The only setter of M_TXEN
807 midi_write(struct cdev *i_dev, struct uio *uio, int ioflag)
809 #define MIDI_WSIZE 32
810 struct snd_midi *m = i_dev->si_drv1;
813 char buf[MIDI_WSIZE];
816 MIDI_DEBUG(4, printf("midi_write\n"));
824 if (!(m->flags & M_TX))
827 while (uio->uio_resid > 0) {
828 while (MIDIQ_AVAIL(m->outq) == 0) {
829 retval = EWOULDBLOCK;
830 if (ioflag & O_NONBLOCK)
832 mtx_unlock(&m->lock);
834 MIDI_DEBUG(3, printf("midi_write msleep\n"));
835 retval = msleep(&m->wchan, &m->qlock,
836 PCATCH | PDROP, "midi TX", 0);
838 * We slept, maybe things have changed since last
843 if (m != i_dev->si_drv1)
855 * We are certain than data can be placed on the queue
858 used = MIN(MIDIQ_AVAIL(m->outq), uio->uio_resid);
859 used = MIN(used, MIDI_WSIZE);
860 MIDI_DEBUG(5, printf("midiout: resid %zd len %jd avail %jd\n",
861 uio->uio_resid, (intmax_t)MIDIQ_LEN(m->outq),
862 (intmax_t)MIDIQ_AVAIL(m->outq)));
865 MIDI_DEBUG(5, printf("midi_write: uiomove cc=%d\n", used));
866 retval = uiomove(buf, used, uio);
869 MIDIQ_ENQ(m->outq, buf, used);
871 * Inform the bottom half that data can be written
873 if (!(m->flags & M_TXEN)) {
875 MPU_CALLBACK(m, m->cookie, m->flags);
879 * If we Made it here then transfer is good
882 err1: mtx_unlock(&m->qlock);
883 mtx_unlock(&m->lock);
888 midi_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
895 midi_poll(struct cdev *i_dev, int events, struct thread *td)
897 struct snd_midi *m = i_dev->si_drv1;
908 if (events & (POLLIN | POLLRDNORM))
909 if (!MIDIQ_EMPTY(m->inq))
910 events |= events & (POLLIN | POLLRDNORM);
912 if (events & (POLLOUT | POLLWRNORM))
913 if (MIDIQ_AVAIL(m->outq) < m->hiwat)
914 events |= events & (POLLOUT | POLLWRNORM);
917 if (events & (POLLIN | POLLRDNORM))
918 selrecord(td, &m->rsel);
920 if (events & (POLLOUT | POLLWRNORM))
921 selrecord(td, &m->wsel);
923 mtx_unlock(&m->lock);
924 mtx_unlock(&m->qlock);
930 * /dev/midistat device functions
934 midistat_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
938 MIDI_DEBUG(1, printf("midistat_open\n"));
939 mtx_lock(&midistat_lock);
941 if (midistat_isopen) {
942 mtx_unlock(&midistat_lock);
946 mtx_unlock(&midistat_lock);
948 if (sbuf_new(&midistat_sbuf, NULL, 4096, SBUF_AUTOEXTEND) == NULL) {
950 mtx_lock(&midistat_lock);
953 mtx_lock(&midistat_lock);
955 error = (midistat_prepare(&midistat_sbuf) > 0) ? 0 : ENOMEM;
959 mtx_unlock(&midistat_lock);
964 midistat_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
966 MIDI_DEBUG(1, printf("midistat_close\n"));
967 mtx_lock(&midistat_lock);
968 if (!midistat_isopen) {
969 mtx_unlock(&midistat_lock);
972 sbuf_delete(&midistat_sbuf);
975 mtx_unlock(&midistat_lock);
980 midistat_read(struct cdev *i_dev, struct uio *buf, int flag)
984 MIDI_DEBUG(4, printf("midistat_read\n"));
985 mtx_lock(&midistat_lock);
986 if (!midistat_isopen) {
987 mtx_unlock(&midistat_lock);
990 l = min(buf->uio_resid, sbuf_len(&midistat_sbuf) - midistat_bufptr);
993 mtx_unlock(&midistat_lock);
994 err = uiomove(sbuf_data(&midistat_sbuf) + midistat_bufptr, l,
996 mtx_lock(&midistat_lock);
999 midistat_bufptr += l;
1000 mtx_unlock(&midistat_lock);
1005 * Module library functions
1009 midistat_prepare(struct sbuf *s)
1013 mtx_assert(&midistat_lock, MA_OWNED);
1015 sbuf_printf(s, "FreeBSD Midi Driver (midi2)\n");
1016 if (TAILQ_EMPTY(&midi_devs)) {
1017 sbuf_printf(s, "No devices installed.\n");
1021 sbuf_printf(s, "Installed devices:\n");
1023 TAILQ_FOREACH(m, &midi_devs, link) {
1025 sbuf_printf(s, "%s [%d/%d:%s]", m->name, m->unit, m->channel,
1026 MPU_PROVIDER(m, m->cookie));
1027 sbuf_printf(s, "%s", MPU_DESCR(m, m->cookie, midistat_verbose));
1028 sbuf_printf(s, "\n");
1029 mtx_unlock(&m->lock);
1038 * Convert IOCTL command to string for debugging
1042 midi_cmdname(int cmd)
1047 } *tab, cmdtab_midiioctl[] = {
1048 #define A(x) {x, ## x}
1050 * Once we have some real IOCTLs define, the following will
1053 * A(SNDCTL_MIDI_PRETIME), A(SNDCTL_MIDI_MPUMODE),
1054 * A(SNDCTL_MIDI_MPUCMD), A(SNDCTL_SYNTH_INFO),
1055 * A(SNDCTL_MIDI_INFO), A(SNDCTL_SYNTH_MEMAVL),
1056 * A(SNDCTL_FM_LOAD_INSTR), A(SNDCTL_FM_4OP_ENABLE),
1057 * A(MIOSPASSTHRU), A(MIOGPASSTHRU), A(AIONWRITE),
1058 * A(AIOGSIZE), A(AIOSSIZE), A(AIOGFMT), A(AIOSFMT),
1059 * A(AIOGMIX), A(AIOSMIX), A(AIOSTOP), A(AIOSYNC),
1068 for (tab = cmdtab_midiioctl; tab->cmd != cmd && tab->cmd != -1; tab++);
1080 midisynth_open(void *n, void *arg, int flags)
1082 struct snd_midi *m = ((struct synth_midi *)n)->m;
1085 MIDI_DEBUG(1, printf("midisynth_open %s %s\n",
1086 flags & FREAD ? "M_RX" : "", flags & FWRITE ? "M_TX" : ""));
1092 mtx_lock(&m->qlock);
1096 if (flags & FREAD) {
1097 if (MIDIQ_SIZE(m->inq) == 0)
1099 else if (m->flags & M_RX)
1104 if (flags & FWRITE) {
1105 if (MIDIQ_SIZE(m->outq) == 0)
1107 else if (m->flags & M_TX)
1115 * TODO: Consider m->async = 0;
1118 if (flags & FREAD) {
1119 m->flags |= M_RX | M_RXEN;
1121 * Only clear the inq, the outq might still have data to drain
1122 * from a previous session
1124 MIDIQ_CLEAR(m->inq);
1128 if (flags & FWRITE) {
1132 m->synth_flags = flags & (FREAD | FWRITE);
1134 MPU_CALLBACK(m, m->cookie, m->flags);
1137 err: mtx_unlock(&m->qlock);
1138 mtx_unlock(&m->lock);
1139 MIDI_DEBUG(2, printf("midisynth_open: return %d.\n", retval));
1144 midisynth_close(void *n)
1146 struct snd_midi *m = ((struct synth_midi *)n)->m;
1150 MIDI_DEBUG(1, printf("midisynth_close %s %s\n",
1151 m->synth_flags & FREAD ? "M_RX" : "",
1152 m->synth_flags & FWRITE ? "M_TX" : ""));
1158 mtx_lock(&m->qlock);
1160 if ((m->synth_flags & FREAD && !(m->flags & M_RX)) ||
1161 (m->synth_flags & FWRITE && !(m->flags & M_TX))) {
1167 oldflags = m->flags;
1169 if (m->synth_flags & FREAD)
1170 m->flags &= ~(M_RX | M_RXEN);
1171 if (m->synth_flags & FWRITE)
1174 if ((m->flags & (M_TXEN | M_RXEN)) != (oldflags & (M_RXEN | M_TXEN)))
1175 MPU_CALLBACK(m, m->cookie, m->flags);
1177 MIDI_DEBUG(1, printf("midi_close: closed, busy = %d.\n", m->busy));
1179 mtx_unlock(&m->qlock);
1180 mtx_unlock(&m->lock);
1190 midisynth_writeraw(void *n, uint8_t *buf, size_t len)
1192 struct snd_midi *m = ((struct synth_midi *)n)->m;
1197 MIDI_DEBUG(4, printf("midisynth_writeraw\n"));
1205 mtx_lock(&m->qlock);
1207 if (!(m->flags & M_TX))
1211 printf("midi dump: ");
1214 while (MIDIQ_AVAIL(m->outq) == 0) {
1215 if (!(m->flags & M_TXEN)) {
1217 MPU_CALLBACK(m, m->cookie, m->flags);
1219 mtx_unlock(&m->lock);
1221 MIDI_DEBUG(3, printf("midisynth_writeraw msleep\n"));
1222 retval = msleep(&m->wchan, &m->qlock,
1223 PCATCH | PDROP, "midi TX", 0);
1225 * We slept, maybe things have changed since last
1228 if (retval == EINTR)
1234 mtx_lock(&m->qlock);
1241 * We are certain than data can be placed on the queue
1244 used = MIN(MIDIQ_AVAIL(m->outq), len);
1245 used = MIN(used, MIDI_WSIZE);
1247 printf("midi_synth: resid %zu len %jd avail %jd\n",
1248 len, (intmax_t)MIDIQ_LEN(m->outq),
1249 (intmax_t)MIDIQ_AVAIL(m->outq)));
1252 for (i = 0; i < used; i++)
1253 printf("%x ", buf[i]);
1255 MIDIQ_ENQ(m->outq, buf, used);
1259 * Inform the bottom half that data can be written
1261 if (!(m->flags & M_TXEN)) {
1263 MPU_CALLBACK(m, m->cookie, m->flags);
1267 * If we Made it here then transfer is good
1273 err1: mtx_unlock(&m->qlock);
1274 mtx_unlock(&m->lock);
1275 err0: return retval;
1279 midisynth_killnote(void *n, uint8_t chn, uint8_t note, uint8_t vel)
1284 if (note > 127 || chn > 15)
1291 c[0] = 0x90 | (chn & 0x0f); /* Note on. */
1292 c[1] = (u_char)note;
1295 c[0] = 0x80 | (chn & 0x0f); /* Note off. */
1296 c[1] = (u_char)note;
1300 return midisynth_writeraw(n, c, 3);
1304 midisynth_setinstr(void *n, uint8_t chn, uint16_t instr)
1308 if (instr > 127 || chn > 15)
1311 c[0] = 0xc0 | (chn & 0x0f); /* Progamme change. */
1312 c[1] = instr + midi_instroff;
1314 return midisynth_writeraw(n, c, 2);
1318 midisynth_startnote(void *n, uint8_t chn, uint8_t note, uint8_t vel)
1322 if (note > 127 || chn > 15)
1328 c[0] = 0x90 | (chn & 0x0f); /* Note on. */
1329 c[1] = (u_char)note;
1332 return midisynth_writeraw(n, c, 3);
1335 midisynth_alloc(void *n, uint8_t chan, uint8_t note)
1341 midisynth_controller(void *n, uint8_t chn, uint8_t ctrlnum, uint16_t val)
1345 if (ctrlnum > 127 || chn > 15)
1348 c[0] = 0xb0 | (chn & 0x0f); /* Control Message. */
1351 return midisynth_writeraw(n, c, 3);
1355 midisynth_bender(void *n, uint8_t chn, uint16_t val)
1360 if (val > 16383 || chn > 15)
1363 c[0] = 0xe0 | (chn & 0x0f); /* Pitch bend. */
1364 c[1] = (u_char)val & 0x7f;
1365 c[2] = (u_char)(val >> 7) & 0x7f;
1367 return midisynth_writeraw(n, c, 3);
1371 * Single point of midi destructions.
1374 midi_destroy(struct snd_midi *m, int midiuninit)
1377 mtx_assert(&midistat_lock, MA_OWNED);
1378 mtx_assert(&m->lock, MA_OWNED);
1380 MIDI_DEBUG(3, printf("midi_destroy\n"));
1381 m->dev->si_drv1 = NULL;
1382 mtx_unlock(&m->lock); /* XXX */
1383 destroy_dev(m->dev);
1384 TAILQ_REMOVE(&midi_devs, m, link);
1386 MPU_UNINIT(m, m->cookie);
1387 free(MIDIQ_BUF(m->inq), M_MIDI);
1388 free(MIDIQ_BUF(m->outq), M_MIDI);
1389 mtx_destroy(&m->qlock);
1390 mtx_destroy(&m->lock);
1396 * Load and unload functions, creates the /dev/midistat device
1402 mtx_init(&midistat_lock, "midistat lock", NULL, 0);
1403 TAILQ_INIT(&midi_devs); /* Initialize the queue. */
1405 midistat_dev = make_dev(&midistat_cdevsw,
1406 MIDIMKMINOR(0, MIDI_DEV_MIDICTL, 0),
1407 UID_ROOT, GID_WHEEL, 0666, "midistat");
1418 MIDI_DEBUG(1, printf("midi_unload()\n"));
1420 mtx_lock(&midistat_lock);
1421 if (midistat_isopen)
1424 TAILQ_FOREACH(m, &midi_devs, link) {
1429 retval = midi_destroy(m, 1);
1434 mtx_unlock(&midistat_lock); /* XXX */
1436 destroy_dev(midistat_dev);
1438 * Made it here then unload is complete
1440 mtx_destroy(&midistat_lock);
1444 mtx_unlock(&m->lock);
1446 mtx_unlock(&midistat_lock);
1448 MIDI_DEBUG(2, printf("midi_unload: failed\n"));
1452 extern int seq_modevent(module_t mod, int type, void *data);
1455 midi_modevent(module_t mod, int type, void *data)
1463 retval = midi_load();
1466 retval = seq_modevent(mod, type, data);
1471 retval = midi_unload();
1474 retval = seq_modevent(mod, type, data);
1486 midimapper_addseq(void *arg1, int *unit, void **cookie)
1490 return (kobj_t)arg1;
1494 midimapper_open(void *arg1, void **cookie)
1499 mtx_lock(&midistat_lock);
1501 TAILQ_FOREACH(m, &midi_devs, link) {
1505 mtx_unlock(&midistat_lock);
1510 midimapper_close(void *arg1, void *cookie)
1516 midimapper_fetch_synth(void *arg, void *cookie, int unit)
1521 mtx_lock(&midistat_lock);
1523 TAILQ_FOREACH(m, &midi_devs, link) {
1524 if (unit == retval) {
1525 mtx_unlock(&midistat_lock);
1526 return (kobj_t)m->synth;
1531 mtx_unlock(&midistat_lock);
1535 DEV_MODULE(midi, midi_modevent, NULL);
1536 MODULE_VERSION(midi, 1);