/* $NetBSD: sequencer.c,v 1.84 2023/10/17 09:59:46 riastradh Exp $ */
/*
* Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Lennart Augustsson (
[email protected]) and by Andrew Doran.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Locking:
*
* o sc_lock: provides atomic access to all data structures. Taken from
* both process and soft interrupt context.
*
* o sc_dvlock: serializes operations on /dev/sequencer. Taken from
* process context. Dropped while waiting for data in sequencerread()
* to allow concurrent reads/writes while no data available.
*
* o sc_isopen: we allow only one concurrent open, only to prevent user
* and/or application error.
*
* o MIDI softc locks. These can be spinlocks and there can be many of
* them, because we can open many MIDI devices. We take these only in two
* places: when enabling redirection from the MIDI device and when
* disabling it (open/close). midiseq_in() is called by the MIDI driver
* with its own lock held when passing data into this module. To avoid
* lock order and context problems, we package the received message as a
* sequencer_pcqitem_t and put onto a producer-consumer queue. A soft
* interrupt is scheduled to dequeue and decode the message later where we
* can safely acquire the sequencer device's sc_lock. PCQ is lockless for
* multiple producer, single consumer settings like this one.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sequencer.c,v 1.84 2023/10/17 09:59:46 riastradh Exp $");
#ifdef _KERNEL_OPT
#include "midi.h"
#endif
#include <sys/param.h>
#include <sys/types.h>
#include <sys/atomic.h>
#include <sys/audioio.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/intr.h>
#include <sys/ioctl.h>
#include <sys/kauth.h>
#include <sys/kernel.h>
#include <sys/kmem.h>
#include <sys/midiio.h>
#include <sys/pcq.h>
#include <sys/poll.h>
#include <sys/proc.h>
#include <sys/select.h>
#include <sys/signalvar.h>
#include <sys/syslog.h>
#include <sys/systm.h>
#include <sys/vnode.h>
#include <sys/vnode.h>
#include <dev/midi_if.h>
#include <dev/midivar.h>
#include <dev/sequencervar.h>
#include "ioconf.h"
/*
* XXX Kludge. This module uses midi_cd, and depends on the `midi'
* module, but there's no obvious way to get midi_cd declared in
* ioconf.h without actually pulling MIDI into the module in
* sys/modules/sequencer/sequencer.ioconf. Please fix me!
*
* XXX XXX XXX Apparently sequencer.ioconf doesn't actually make the
* sequencer cdev! Did this ever work?
*
* XXX XXX XXX Apparently there are even some kernels that include a
* sequencer pseudo-device but exclude any midi device. How do they
* even link??
*/
extern struct cfdriver midi_cd;
#ifdef _MODULE
extern struct cfdriver sequencer_cd;
#endif
#define ADDTIMEVAL(a, b) ( \
(a)->tv_sec += (b)->tv_sec, \
(a)->tv_usec += (b)->tv_usec, \
(a)->tv_usec > 1000000 ? ((a)->tv_sec++, (a)->tv_usec -= 1000000) : 0\
)
#define SUBTIMEVAL(a, b) ( \
(a)->tv_sec -= (b)->tv_sec, \
(a)->tv_usec -= (b)->tv_usec, \
(a)->tv_usec < 0 ? ((a)->tv_sec--, (a)->tv_usec += 1000000) : 0\
)
#ifdef AUDIO_DEBUG
#define DPRINTF(x) do { if (sequencerdebug) printf x; } while (0)
#define DPRINTFN(n,x) do { if (sequencerdebug >= (n)) printf x; } while (0)
int sequencerdebug = 0;
#else
#define DPRINTF(x) do { } while (0)
#define DPRINTFN(n,x) do { } while (0)
#endif
#define SEQ_NOTE_MAX 128
#define SEQ_NOTE_XXX 255
#define RECALC_USPERDIV(t) \
((t)->usperdiv = 60*1000000L/((t)->tempo_beatpermin*(t)->timebase_divperbeat))
typedef union sequencer_pcqitem {
void *qi_ptr;
char qi_msg[4];
} sequencer_pcqitem_t;
static void seq_reset(struct sequencer_softc *);
static int seq_do_command(struct sequencer_softc *, seq_event_t *);
static int seq_do_chnvoice(struct sequencer_softc *, seq_event_t *);
static int seq_do_chncommon(struct sequencer_softc *, seq_event_t *);
static void seq_timer_waitabs(struct sequencer_softc *, uint32_t);
static int seq_do_timing(struct sequencer_softc *, seq_event_t *);
static int seq_do_local(struct sequencer_softc *, seq_event_t *);
static int seq_do_sysex(struct sequencer_softc *, seq_event_t *);
static int seq_do_fullsize(struct sequencer_softc *, seq_event_t *,
struct uio *);
static int seq_input_event(struct sequencer_softc *, seq_event_t *);
static int seq_drain(struct sequencer_softc *);
static void seq_startoutput(struct sequencer_softc *);
static void seq_timeout(void *);
static int seq_to_new(seq_event_t *, struct uio *);
static void seq_softintr(void *);
static int midiseq_out(struct midi_dev *, u_char *, u_int, int);
static struct midi_dev *midiseq_open(int, int);
static void midiseq_close(struct midi_dev *);
static void midiseq_reset(struct midi_dev *);
static int midiseq_noteon(struct midi_dev *, int, int, seq_event_t *);
static int midiseq_noteoff(struct midi_dev *, int, int, seq_event_t *);
static int midiseq_keypressure(struct midi_dev *, int, int, seq_event_t *);
static int midiseq_pgmchange(struct midi_dev *, int, seq_event_t *);
static int midiseq_chnpressure(struct midi_dev *, int, seq_event_t *);
static int midiseq_ctlchange(struct midi_dev *, int, seq_event_t *);
static int midiseq_pitchbend(struct midi_dev *, int, seq_event_t *);
static int midiseq_loadpatch(struct midi_dev *, struct sysex_info *,
struct uio *);
void midiseq_in(struct midi_dev *, u_char *, int);
static dev_type_open(sequenceropen);
static dev_type_close(sequencerclose);
static dev_type_read(sequencerread);
static dev_type_write(sequencerwrite);
static dev_type_ioctl(sequencerioctl);
static dev_type_poll(sequencerpoll);
static dev_type_kqfilter(sequencerkqfilter);
const struct cdevsw sequencer_cdevsw = {
.d_open = sequenceropen,
.d_close = sequencerclose,
.d_read = sequencerread,
.d_write = sequencerwrite,
.d_ioctl = sequencerioctl,
.d_stop = nostop,
.d_tty = notty,
.d_poll = sequencerpoll,
.d_mmap = nommap,
.d_kqfilter = sequencerkqfilter,
.d_discard = nodiscard,
.d_flag = D_OTHER | D_MPSAFE
};
static LIST_HEAD(, sequencer_softc) sequencers =
LIST_HEAD_INITIALIZER(sequencers);
static kmutex_t sequencer_lock;
static void
sequencerdestroy(struct sequencer_softc *sc)
{
callout_halt(&sc->sc_callout, &sc->lock);
callout_destroy(&sc->sc_callout);
softint_disestablish(sc->sih);
cv_destroy(&sc->rchan);
cv_destroy(&sc->wchan);
cv_destroy(&sc->lchan);
if (sc->pcq)
pcq_destroy(sc->pcq);
kmem_free(sc, sizeof(*sc));
}
static struct sequencer_softc *
sequencercreate(int unit)
{
struct sequencer_softc *sc = kmem_zalloc(sizeof(*sc), KM_SLEEP);
sc->sc_unit = unit;
callout_init(&sc->sc_callout, CALLOUT_MPSAFE);
sc->sih = softint_establish(SOFTINT_NET | SOFTINT_MPSAFE,
seq_softintr, sc);
mutex_init(&sc->lock, MUTEX_DEFAULT, IPL_NONE);
cv_init(&sc->rchan, "midiseqr");
cv_init(&sc->wchan, "midiseqw");
cv_init(&sc->lchan, "midiseql");
sc->pcq = pcq_create(SEQ_MAXQ, KM_SLEEP);
if (sc->pcq == NULL) {
sequencerdestroy(sc);
return NULL;
}
return sc;
}
static struct sequencer_softc *
sequencerget(int unit)
{
struct sequencer_softc *sc;
KASSERTMSG(unit >= 0, "unit=%d", unit);
if (unit < 0)
return NULL;
mutex_enter(&sequencer_lock);
LIST_FOREACH(sc, &sequencers, sc_link) {
if (sc->sc_unit == unit) {
mutex_exit(&sequencer_lock);
return sc;
}
}
mutex_exit(&sequencer_lock);
/*
* XXXSMP -- nothing excludes another thread from creating the
* same unit here
*/
if ((sc = sequencercreate(unit)) == NULL)
return NULL;
mutex_enter(&sequencer_lock);
LIST_INSERT_HEAD(&sequencers, sc, sc_link);
mutex_exit(&sequencer_lock);
return sc;
}
#ifdef notyet
static void
sequencerput(struct sequencer_softc *sc)
{
mutex_enter(&sequencer_lock);
LIST_REMOVE(sc, sc_link);
mutex_exit(&sequencer_lock);
sequencerdestroy(sc);
}
#endif
void
sequencerattach(int n)
{
mutex_init(&sequencer_lock, MUTEX_DEFAULT, IPL_NONE);
}
/*
* Release reference to device acquired with sequencer_enter().
*/
static void
sequencer_exit(struct sequencer_softc *sc)
{
sc->dvlock--;
cv_broadcast(&sc->lchan);
mutex_exit(&sc->lock);
}
/*
* Look up sequencer device and acquire locks for device access.
*/
static int
sequencer_enter(dev_t dev, struct sequencer_softc **scp)
{
struct sequencer_softc *sc;
/* First, find the device and take sc_lock. */
if ((sc = sequencerget(SEQUENCERUNIT(dev))) == NULL)
return ENXIO;
mutex_enter(&sc->lock);
while (sc->dvlock) {
cv_wait(&sc->lchan, &sc->lock);
}
sc->dvlock++;
if (sc->dying) {
sequencer_exit(sc);
return EIO;
}
*scp = sc;
return 0;
}
static int
sequenceropen(dev_t dev, int flags, int ifmt, struct lwp *l)
{
struct sequencer_softc *sc;
struct midi_dev *md;
struct midi_softc *msc;
int error, unit, mdno;
DPRINTF(("sequenceropen\n"));
if ((error = sequencer_enter(dev, &sc)) != 0)
return error;
if (sc->isopen != 0) {
sequencer_exit(sc);
return EBUSY;
}
if (SEQ_IS_OLD(SEQUENCERUNIT(dev)))
sc->mode = SEQ_OLD;
else
sc->mode = SEQ_NEW;
sc->isopen++;
sc->flags = flags & (FREAD|FWRITE);
sc->pbus = 0;
sc->async = 0;
sc->input_stamp = ~0;
sc->nmidi = 0;
sc->ndevs = midi_unit_count();
sc->timer.timebase_divperbeat = 100;
sc->timer.tempo_beatpermin = 60;
RECALC_USPERDIV(&sc->timer);
sc->timer.divs_lastevent = sc->timer.divs_lastchange = 0;
microtime(&sc->timer.reftime);
SEQ_QINIT(&sc->inq);
SEQ_QINIT(&sc->outq);
sc->lowat = SEQ_MAXQ / 2;
if (sc->ndevs > 0) {
mutex_exit(&sc->lock);
sc->devs = kmem_alloc(sc->ndevs * sizeof(struct midi_dev *),
KM_SLEEP);
for (unit = 0; unit < sc->ndevs; unit++) {
md = midiseq_open(unit, flags);
if (md) {
sc->devs[sc->nmidi++] = md;
md->seq = sc;
md->doingsysex = 0;
DPRINTF(("%s: midi unit %d opened as seq %p\n",
__func__, unit, md));
} else {
DPRINTF(("%s: midi unit %d not opened as seq\n",
__func__, unit));
}
}
mutex_enter(&sc->lock);
} else {
sc->devs = NULL;
}
/* Only now redirect input from MIDI devices. */
for (mdno = 0; mdno < sc->nmidi; mdno++) {
msc = device_lookup_private(&midi_cd, sc->devs[mdno]->unit);
if (msc) {
mutex_enter(msc->lock);
msc->seqopen = 1;
mutex_exit(msc->lock);
}
}
seq_reset(sc);
sequencer_exit(sc);
DPRINTF(("%s: mode=%d, nmidi=%d\n", __func__, sc->mode, sc->nmidi));
return 0;
}
static int
seq_drain(struct sequencer_softc *sc)
{
int error;
KASSERT(mutex_owned(&sc->lock));
DPRINTFN(3, ("seq_drain: %p, len=%d\n", sc, SEQ_QLEN(&sc->outq)));
seq_startoutput(sc);
error = 0;
while (!SEQ_QEMPTY(&sc->outq) && !error)
error = cv_timedwait_sig(&sc->wchan, &sc->lock, 60*hz);
return error;
}
static void
seq_timeout(void *addr)
{
struct sequencer_softc *sc = addr;
proc_t *p;
pid_t pid;
DPRINTFN(4, ("seq_timeout: %p\n", sc));
mutex_enter(&sc->lock);
if (sc->timeout == 0) {
mutex_exit(&sc->lock);
return;
}
sc->timeout = 0;
seq_startoutput(sc);
if (SEQ_QLEN(&sc->outq) >= sc->lowat) {
mutex_exit(&sc->lock);
return;
}
cv_broadcast(&sc->wchan);
selnotify(&sc->wsel, 0, NOTE_SUBMIT);
if ((pid = sc->async) != 0) {
mutex_enter(&proc_lock);
if ((p = proc_find(pid)) != NULL)
psignal(p, SIGIO);
mutex_exit(&proc_lock);
}
mutex_exit(&sc->lock);
}
static void
seq_startoutput(struct sequencer_softc *sc)
{
struct sequencer_queue *q = &sc->outq;
seq_event_t cmd;
KASSERT(mutex_owned(&sc->lock));
if (sc->timeout)
return;
DPRINTFN(4, ("seq_startoutput: %p, len=%d\n", sc, SEQ_QLEN(q)));
while (!SEQ_QEMPTY(q) && !sc->timeout) {
SEQ_QGET(q, cmd);
seq_do_command(sc, &cmd);
}
}
static int
sequencerclose(dev_t dev, int flags, int ifmt, struct lwp *l)
{
struct sequencer_softc *sc;
struct midi_softc *msc;
int unit, error;
DPRINTF(("%s: %"PRIx64"\n", __func__, dev));
if ((error = sequencer_enter(dev, &sc)) != 0)
return error;
seq_drain(sc);
if (sc->timeout) {
callout_halt(&sc->sc_callout, &sc->lock);
sc->timeout = 0;
}
/* Bin input from MIDI devices. */
for (unit = 0; unit < sc->nmidi; unit++) {
msc = device_lookup_private(&midi_cd, unit);
if (msc) {
mutex_enter(msc->lock);
msc->seqopen = 0;
mutex_exit(msc->lock);
}
}
mutex_exit(&sc->lock);
for (unit = 0; unit < sc->nmidi; unit++)
if (sc->devs[unit] != NULL)
midiseq_close(sc->devs[unit]);
if (sc->devs != NULL) {
KASSERT(sc->ndevs > 0);
kmem_free(sc->devs, sc->ndevs * sizeof(struct midi_dev *));
sc->devs = NULL;
}
mutex_enter(&sc->lock);
sc->isopen = 0;
sequencer_exit(sc);
DPRINTF(("%s: %"PRIx64" done\n", __func__, dev));
return 0;
}
static int
seq_input_event(struct sequencer_softc *sc, seq_event_t *cmd)
{
struct sequencer_queue *q;
KASSERT(mutex_owned(&sc->lock));
DPRINTFN(2, ("seq_input_event: %02x %02x %02x %02x %02x "
"%02x %02x %02x\n", cmd->tag,
cmd->unknown.byte[0], cmd->unknown.byte[1],
cmd->unknown.byte[2], cmd->unknown.byte[3],
cmd->unknown.byte[4], cmd->unknown.byte[5],
cmd->unknown.byte[6]));
q = &sc->inq;
if (SEQ_QFULL(q))
return ENOMEM;
SEQ_QPUT(q, *cmd);
cv_broadcast(&sc->rchan);
selnotify(&sc->rsel, 0, NOTE_SUBMIT);
if (sc->async != 0) {
proc_t *p;
mutex_enter(&proc_lock);
if ((p = proc_find(sc->async)) != NULL)
psignal(p, SIGIO);
mutex_exit(&proc_lock);
}
return 0;
}
static void
seq_softintr(void *addr)
{
struct sequencer_softc *sc;
struct timeval now;
seq_event_t ev;
int status, chan, unit;
sequencer_pcqitem_t qi;
u_long t;
sc = addr;
mutex_enter(&sc->lock);
qi.qi_ptr = pcq_get(sc->pcq);
if (qi.qi_ptr == NULL) {
mutex_exit(&sc->lock);
return;
}
KASSERT((qi.qi_msg[3] & 0x80) != 0);
unit = qi.qi_msg[3] & ~0x80;
status = MIDI_GET_STATUS(qi.qi_msg[0]);
chan = MIDI_GET_CHAN(qi.qi_msg[0]);
switch (status) {
case MIDI_NOTEON: /* midi(4) always canonicalizes hidden note-off */
ev = SEQ_MK_CHN(NOTEON, .device=unit, .channel=chan,
.key=qi.qi_msg[1], .velocity=qi.qi_msg[2]);
break;
case MIDI_NOTEOFF:
ev = SEQ_MK_CHN(NOTEOFF, .device=unit, .channel=chan,
.key=qi.qi_msg[1], .velocity=qi.qi_msg[2]);
break;
case MIDI_KEY_PRESSURE:
ev = SEQ_MK_CHN(KEY_PRESSURE, .device=unit, .channel=chan,
.key=qi.qi_msg[1], .pressure=qi.qi_msg[2]);
break;
case MIDI_CTL_CHANGE: /* XXX not correct for MSB */
ev = SEQ_MK_CHN(CTL_CHANGE, .device=unit, .channel=chan,
.controller=qi.qi_msg[1], .value=qi.qi_msg[2]);
break;
case MIDI_PGM_CHANGE:
ev = SEQ_MK_CHN(PGM_CHANGE, .device=unit, .channel=chan,
.program=qi.qi_msg[1]);
break;
case MIDI_CHN_PRESSURE:
ev = SEQ_MK_CHN(CHN_PRESSURE, .device=unit, .channel=chan,
.pressure=qi.qi_msg[1]);
break;
case MIDI_PITCH_BEND:
ev = SEQ_MK_CHN(PITCH_BEND, .device=unit, .channel=chan,
.value=(qi.qi_msg[1] & 0x7f) | ((qi.qi_msg[2] & 0x7f) << 7));
break;
default: /* this is now the point where MIDI_ACKs disappear */
mutex_exit(&sc->lock);
return;
}
microtime(&now);
if (!sc->timer.running)
now = sc->timer.stoptime;
SUBTIMEVAL(&now, &sc->timer.reftime);
t = now.tv_sec * 1000000 + now.tv_usec;
t /= sc->timer.usperdiv;
t += sc->timer.divs_lastchange;
if (t != sc->input_stamp) {
seq_input_event(sc, &SEQ_MK_TIMING(WAIT_ABS, .divisions=t));
sc->input_stamp = t; /* XXX what happens if timer is reset? */
}
seq_input_event(sc, &ev);
mutex_exit(&sc->lock);
}
static int
sequencerread(dev_t dev, struct uio *uio, int ioflag)
{
struct sequencer_softc *sc;
struct sequencer_queue *q;
seq_event_t ev;
int error;
DPRINTFN(2, ("sequencerread: %"PRIx64", count=%d, ioflag=%x\n",
dev, (int)uio->uio_resid, ioflag));
if ((error = sequencer_enter(dev, &sc)) != 0)
return error;
q = &sc->inq;
if (sc->mode == SEQ_OLD) {
sequencer_exit(sc);
DPRINTFN(-1,("sequencerread: old read\n"));
return EINVAL; /* XXX unimplemented */
}
while (SEQ_QEMPTY(q)) {
if (ioflag & IO_NDELAY) {
error = EWOULDBLOCK;
break;
}
/* Drop lock to allow concurrent read/write. */
KASSERT(sc->dvlock != 0);
sc->dvlock--;
error = cv_wait_sig(&sc->rchan, &sc->lock);
while (sc->dvlock != 0) {
cv_wait(&sc->lchan, &sc->lock);
}
sc->dvlock++;
if (error) {
break;
}
}
while (uio->uio_resid >= sizeof(ev) && !error && !SEQ_QEMPTY(q)) {
SEQ_QGET(q, ev);
mutex_exit(&sc->lock);
error = uiomove(&ev, sizeof(ev), uio);
mutex_enter(&sc->lock);
}
sequencer_exit(sc);
return error;
}
static int
sequencerwrite(dev_t dev, struct uio *uio, int ioflag)
{
struct sequencer_softc *sc;
struct sequencer_queue *q;
int error;
seq_event_t cmdbuf;
int size;
DPRINTFN(2, ("sequencerwrite: %"PRIx64", count=%d\n", dev,
(int)uio->uio_resid));
if ((error = sequencer_enter(dev, &sc)) != 0)
return error;
q = &sc->outq;
size = sc->mode == SEQ_NEW ? sizeof cmdbuf : SEQOLD_CMDSIZE;
while (uio->uio_resid >= size && error == 0) {
mutex_exit(&sc->lock);
error = uiomove(&cmdbuf, size, uio);
if (error == 0) {
if (sc->mode == SEQ_OLD && seq_to_new(&cmdbuf, uio)) {
mutex_enter(&sc->lock);
continue;
}
if (cmdbuf.tag == SEQ_FULLSIZE) {
/* We do it like OSS does, asynchronously */
error = seq_do_fullsize(sc, &cmdbuf, uio);
if (error == 0) {
mutex_enter(&sc->lock);
continue;
}
}
}
mutex_enter(&sc->lock);
if (error != 0) {
break;
}
while (SEQ_QFULL(q)) {
seq_startoutput(sc);
if (SEQ_QFULL(q)) {
if (ioflag & IO_NDELAY) {
error = EWOULDBLOCK;
break;
}
error = cv_wait_sig(&sc->wchan, &sc->lock);
if (error) {
break;
}
}
}
if (error == 0) {
SEQ_QPUT(q, cmdbuf);
}
}
if (error == 0) {
seq_startoutput(sc);
} else {
DPRINTFN(2, ("sequencerwrite: error=%d\n", error));
}
sequencer_exit(sc);
return error;
}
static int
sequencerioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
{
struct sequencer_softc *sc;
struct synth_info *si;
struct midi_dev *md;
int devno, error, t;
struct timeval now;
u_long tx;
DPRINTFN(2, ("sequencerioctl: %"PRIx64" cmd=0x%08lx\n", dev, cmd));
if ((error = sequencer_enter(dev, &sc)) != 0)
return error;
switch (cmd) {
case FIONBIO:
/* All handled in the upper FS layer. */
break;
case FIOASYNC:
if (*(int *)addr) {
if (sc->async != 0) {
error = EBUSY;
break;
}
sc->async = curproc->p_pid;
DPRINTF(("%s: FIOASYNC %d\n", __func__,
sc->async));
} else {
sc->async = 0;
}
break;
case SEQUENCER_RESET:
seq_reset(sc);
break;
case SEQUENCER_PANIC:
seq_reset(sc);
/* Do more? OSS doesn't */
break;
case SEQUENCER_SYNC:
if (sc->flags != FREAD)
seq_drain(sc);
break;
case SEQUENCER_INFO:
si = (struct synth_info*)addr;
devno = si->device;
if (devno < 0 || devno >= sc->nmidi) {
error = EINVAL;
break;
}
md = sc->devs[devno];
strncpy(si->name, md->name, sizeof si->name);
si->synth_type = SYNTH_TYPE_MIDI;
si->synth_subtype = md->subtype;
si->nr_voices = md->nr_voices;
si->instr_bank_size = md->instr_bank_size;
si->capabilities = md->capabilities;
break;
case SEQUENCER_NRSYNTHS:
*(int *)addr = sc->nmidi;
break;
case SEQUENCER_NRMIDIS:
*(int *)addr = sc->nmidi;
break;
case SEQUENCER_OUTOFBAND:
DPRINTFN(3, ("sequencer_ioctl: OOB=%02x %02x %02x %02x %02x %02x %02x %02x\n",
*(u_char *)addr, *((u_char *)addr+1),
*((u_char *)addr+2), *((u_char *)addr+3),
*((u_char *)addr+4), *((u_char *)addr+5),
*((u_char *)addr+6), *((u_char *)addr+7)));
if ((sc->flags & FWRITE) == 0) {
error = EBADF;
} else {
error = seq_do_command(sc, (seq_event_t *)addr);
}
break;
case SEQUENCER_TMR_TIMEBASE:
t = *(int *)addr;
if (t < 1)
t = 1;
if (t > 10000)
t = 10000;
*(int *)addr = t;
sc->timer.timebase_divperbeat = t;
sc->timer.divs_lastchange = sc->timer.divs_lastevent;
microtime(&sc->timer.reftime);
RECALC_USPERDIV(&sc->timer);
break;
case SEQUENCER_TMR_START:
error = seq_do_timing(sc, &SEQ_MK_TIMING(START));
break;
case SEQUENCER_TMR_STOP:
error = seq_do_timing(sc, &SEQ_MK_TIMING(STOP));
break;
case SEQUENCER_TMR_CONTINUE:
error = seq_do_timing(sc, &SEQ_MK_TIMING(CONTINUE));
break;
case SEQUENCER_TMR_TEMPO:
error = seq_do_timing(sc,
&SEQ_MK_TIMING(TEMPO, .bpm=*(int *)addr));
RECALC_USPERDIV(&sc->timer);
if (error == 0)
*(int *)addr = sc->timer.tempo_beatpermin;
break;
case SEQUENCER_TMR_SOURCE:
*(int *)addr = SEQUENCER_TMR_INTERNAL;
break;
case SEQUENCER_TMR_METRONOME:
/* noop */
break;
case SEQUENCER_THRESHOLD:
t = SEQ_MAXQ - *(int *)addr / sizeof (seq_event_rec);
if (t < 1)
t = 1;
if (t > SEQ_MAXQ)
t = SEQ_MAXQ;
sc->lowat = t;
break;
case SEQUENCER_CTRLRATE:
*(int *)addr = (sc->timer.tempo_beatpermin
*sc->timer.timebase_divperbeat + 30) / 60;
break;
case SEQUENCER_GETTIME:
microtime(&now);
SUBTIMEVAL(&now, &sc->timer.reftime);
tx = now.tv_sec * 1000000 + now.tv_usec;
tx /= sc->timer.usperdiv;
tx += sc->timer.divs_lastchange;
*(int *)addr = tx;
break;
default:
DPRINTFN(-1,("sequencer_ioctl: unimpl %08lx\n", cmd));
error = EINVAL;
break;
}
sequencer_exit(sc);
return error;
}
static int
sequencerpoll(dev_t dev, int events, struct lwp *l)
{
struct sequencer_softc *sc;
int revents = 0;
if ((sc = sequencerget(SEQUENCERUNIT(dev))) == NULL)
return ENXIO;
DPRINTF(("%s: %p events=0x%x\n", __func__, sc, events));
mutex_enter(&sc->lock);
if (events & (POLLIN | POLLRDNORM))
if ((sc->flags&FREAD) && !SEQ_QEMPTY(&sc->inq))
revents |= events & (POLLIN | POLLRDNORM);
if (events & (POLLOUT | POLLWRNORM))
if ((sc->flags&FWRITE) && SEQ_QLEN(&sc->outq) < sc->lowat)
revents |= events & (POLLOUT | POLLWRNORM);
if (revents == 0) {
if ((sc->flags&FREAD) && (events & (POLLIN | POLLRDNORM)))
selrecord(l, &sc->rsel);
if ((sc->flags&FWRITE) && (events & (POLLOUT | POLLWRNORM)))
selrecord(l, &sc->wsel);
}
mutex_exit(&sc->lock);
return revents;
}
static void
filt_sequencerrdetach(struct knote *kn)
{
struct sequencer_softc *sc = kn->kn_hook;
mutex_enter(&sc->lock);
selremove_knote(&sc->rsel, kn);
mutex_exit(&sc->lock);
}
static int
filt_sequencerread(struct knote *kn, long hint)
{
struct sequencer_softc *sc = kn->kn_hook;
int rv;
if (hint != NOTE_SUBMIT) {
mutex_enter(&sc->lock);
}
if (SEQ_QEMPTY(&sc->inq)) {
rv = 0;
} else {
kn->kn_data = sizeof(seq_event_rec);
rv = 1;
}
if (hint != NOTE_SUBMIT) {
mutex_exit(&sc->lock);
}
return rv;
}
static const struct filterops sequencerread_filtops = {
.f_flags = FILTEROP_ISFD,
.f_attach = NULL,
.f_detach = filt_sequencerrdetach,
.f_event = filt_sequencerread,
};
static void
filt_sequencerwdetach(struct knote *kn)
{
struct sequencer_softc *sc = kn->kn_hook;
mutex_enter(&sc->lock);
selremove_knote(&sc->wsel, kn);
mutex_exit(&sc->lock);
}
static int
filt_sequencerwrite(struct knote *kn, long hint)
{
struct sequencer_softc *sc = kn->kn_hook;
int rv;
if (hint != NOTE_SUBMIT) {
mutex_enter(&sc->lock);
}
if (SEQ_QLEN(&sc->outq) >= sc->lowat) {
rv = 0;
} else {
kn->kn_data = sizeof(seq_event_rec);
rv = 1;
}
if (hint != NOTE_SUBMIT) {
mutex_exit(&sc->lock);
}
return rv;
}
static const struct filterops sequencerwrite_filtops = {
.f_flags = FILTEROP_ISFD,
.f_attach = NULL,
.f_detach = filt_sequencerwdetach,
.f_event = filt_sequencerwrite,
};
static int
sequencerkqfilter(dev_t dev, struct knote *kn)
{
struct sequencer_softc *sc;
struct selinfo *sip;
if ((sc = sequencerget(SEQUENCERUNIT(dev))) == NULL)
return ENXIO;
switch (kn->kn_filter) {
case EVFILT_READ:
sip = &sc->rsel;
kn->kn_fop = &sequencerread_filtops;
break;
case EVFILT_WRITE:
sip = &sc->wsel;
kn->kn_fop = &sequencerwrite_filtops;
break;
default:
return EINVAL;
}
kn->kn_hook = sc;
mutex_enter(&sc->lock);
selrecord_knote(sip, kn);
mutex_exit(&sc->lock);
return 0;
}
static void
seq_reset(struct sequencer_softc *sc)
{
int i, chn;
struct midi_dev *md;
KASSERT(mutex_owned(&sc->lock));
if (!(sc->flags & FWRITE))
return;
for (i = 0; i < sc->nmidi; i++) {
md = sc->devs[i];
midiseq_reset(md);
for (chn = 0; chn < MAXCHAN; chn++) {
midiseq_ctlchange(md, chn, &SEQ_MK_CHN(CTL_CHANGE,
.controller=MIDI_CTRL_NOTES_OFF));
midiseq_ctlchange(md, chn, &SEQ_MK_CHN(CTL_CHANGE,
.controller=MIDI_CTRL_RESET));
midiseq_pitchbend(md, chn, &SEQ_MK_CHN(PITCH_BEND,
.value=MIDI_BEND_NEUTRAL));
}
}
}
static int
seq_do_command(struct sequencer_softc *sc, seq_event_t *b)
{
int dev;
KASSERT(mutex_owned(&sc->lock));
DPRINTFN(4, ("seq_do_command: %p cmd=0x%02x\n", sc, b->timing.op));
switch(b->tag) {
case SEQ_LOCAL:
return seq_do_local(sc, b);
case SEQ_TIMING:
return seq_do_timing(sc, b);
case SEQ_CHN_VOICE:
return seq_do_chnvoice(sc, b);
case SEQ_CHN_COMMON:
return seq_do_chncommon(sc, b);
case SEQ_SYSEX:
return seq_do_sysex(sc, b);
/* COMPAT */
case SEQOLD_MIDIPUTC:
dev = b->putc.device;
if (dev < 0 || dev >= sc->nmidi)
return ENXIO;
return midiseq_out(sc->devs[dev], &b->putc.byte, 1, 0);
default:
DPRINTFN(-1,("seq_do_command: unimpl command %02x\n", b->tag));
return EINVAL;
}
}
static int
seq_do_chnvoice(struct sequencer_softc *sc, seq_event_t *b)
{
int dev;
int error;
struct midi_dev *md;
KASSERT(mutex_owned(&sc->lock));
dev = b->voice.device;
if (dev < 0 || dev >= sc->nmidi ||
b->voice.channel > 15 ||
b->voice.key >= SEQ_NOTE_MAX)
return ENXIO;
md = sc->devs[dev];
switch(b->voice.op) {
case MIDI_NOTEON: /* no need to special-case hidden noteoff here */
error = midiseq_noteon(md, b->voice.channel, b->voice.key, b);
break;
case MIDI_NOTEOFF:
error = midiseq_noteoff(md, b->voice.channel, b->voice.key, b);
break;
case MIDI_KEY_PRESSURE:
error = midiseq_keypressure(md,
b->voice.channel, b->voice.key, b);
break;
default:
DPRINTFN(-1,("seq_do_chnvoice: unimpl command %02x\n",
b->voice.op));
error = EINVAL;
break;
}
return error;
}
static int
seq_do_chncommon(struct sequencer_softc *sc, seq_event_t *b)
{
int dev;
int error;
struct midi_dev *md;
KASSERT(mutex_owned(&sc->lock));
dev = b->common.device;
if (dev < 0 || dev >= sc->nmidi ||
b->common.channel > 15)
return ENXIO;
md = sc->devs[dev];
DPRINTFN(2,("seq_do_chncommon: %02x\n", b->common.op));
error = 0;
switch(b->common.op) {
case MIDI_PGM_CHANGE:
error = midiseq_pgmchange(md, b->common.channel, b);
break;
case MIDI_CTL_CHANGE:
error = midiseq_ctlchange(md, b->common.channel, b);
break;
case MIDI_PITCH_BEND:
error = midiseq_pitchbend(md, b->common.channel, b);
break;
case MIDI_CHN_PRESSURE:
error = midiseq_chnpressure(md, b->common.channel, b);
break;
default:
DPRINTFN(-1,("seq_do_chncommon: unimpl command %02x\n",
b->common.op));
error = EINVAL;
break;
}
return error;
}
static int
seq_do_local(struct sequencer_softc *sc, seq_event_t *b)
{
KASSERT(mutex_owned(&sc->lock));
return EINVAL;
}
static int
seq_do_sysex(struct sequencer_softc *sc, seq_event_t *b)
{
int dev, i;
struct midi_dev *md;
uint8_t *bf = b->sysex.buffer;
KASSERT(mutex_owned(&sc->lock));
dev = b->sysex.device;
if (dev < 0 || dev >= sc->nmidi)
return ENXIO;
DPRINTF(("%s: dev=%d\n", __func__, dev));
md = sc->devs[dev];
if (!md->doingsysex) {
midiseq_out(md, (uint8_t[]){MIDI_SYSEX_START}, 1, 0);
md->doingsysex = 1;
}
for (i = 0; i < 6 && bf[i] != 0xff; i++)
;
midiseq_out(md, bf, i, 0);
if (i < 6 || (i > 0 && bf[i-1] == MIDI_SYSEX_END))
md->doingsysex = 0;
return 0;
}
static void
seq_timer_waitabs(struct sequencer_softc *sc, uint32_t divs)
{
struct timeval when;
long long usec;
struct syn_timer *t;
int ticks;
KASSERT(mutex_owned(&sc->lock));
t = &sc->timer;
t->divs_lastevent = divs;
divs -= t->divs_lastchange;
usec = (long long)divs * (long long)t->usperdiv; /* convert to usec */
when.tv_sec = usec / 1000000;
when.tv_usec = usec % 1000000;
DPRINTFN(4, ("seq_timer_waitabs: adjdivs=%d, sleep when=%"PRId64".%06"PRId64,
divs, when.tv_sec, (uint64_t)when.tv_usec));
ADDTIMEVAL(&when, &t->reftime); /* abstime for end */
ticks = tvhzto(&when);
DPRINTFN(4, (" when+start=%"PRId64".%06"PRId64", tick=%d\n",
when.tv_sec, (uint64_t)when.tv_usec, ticks));
if (ticks > 0) {
#ifdef DIAGNOSTIC
if (ticks > 20 * hz) {
/* Waiting more than 20s */
printf("seq_timer_waitabs: funny ticks=%d, "
"usec=%lld\n", ticks, usec);
}
#endif
sc->timeout = 1;
callout_reset(&sc->sc_callout, ticks,
seq_timeout, sc);
}
#ifdef SEQUENCER_DEBUG
else if (tick < 0)
DPRINTF(("%s: ticks = %d\n", __func__, ticks));
#endif
}
static int
seq_do_timing(struct sequencer_softc *sc, seq_event_t *b)
{
struct syn_timer *t = &sc->timer;
struct timeval when;
int error;
KASSERT(mutex_owned(&sc->lock));
error = 0;
switch(b->timing.op) {
case TMR_WAIT_REL:
seq_timer_waitabs(sc,
b->t_WAIT_REL.divisions + t->divs_lastevent);
break;
case TMR_WAIT_ABS:
seq_timer_waitabs(sc, b->t_WAIT_ABS.divisions);
break;
case TMR_START:
microtime(&t->reftime);
t->divs_lastevent = t->divs_lastchange = 0;
t->running = 1;
break;
case TMR_STOP:
microtime(&t->stoptime);
t->running = 0;
break;
case TMR_CONTINUE:
if (t->running)
break;
microtime(&when);
SUBTIMEVAL(&when, &t->stoptime);
ADDTIMEVAL(&t->reftime, &when);
t->running = 1;
break;
case TMR_TEMPO:
/* bpm is unambiguously MIDI clocks per minute / 24 */
/* (24 MIDI clocks are usually but not always a quarter note) */
if (b->t_TEMPO.bpm < 8) /* where are these limits specified? */
t->tempo_beatpermin = 8;
else if (b->t_TEMPO.bpm > 360) /* ? */
t->tempo_beatpermin = 360;
else
t->tempo_beatpermin = b->t_TEMPO.bpm;
t->divs_lastchange = t->divs_lastevent;
microtime(&t->reftime);
RECALC_USPERDIV(t);
break;
case TMR_ECHO:
error = seq_input_event(sc, b);
break;
case TMR_RESET:
t->divs_lastevent = t->divs_lastchange = 0;
microtime(&t->reftime);
break;
case TMR_SPP:
case TMR_TIMESIG:
DPRINTF(("%s: unimplemented %02x\n", __func__, b->timing.op));
error = EINVAL; /* not quite accurate... */
break;
default:
DPRINTF(("%s: unknown %02x\n", __func__, b->timing.op));
error = EINVAL;
break;
}
return error;
}
static int
seq_do_fullsize(struct sequencer_softc *sc, seq_event_t *b, struct uio *uio)
{
struct sysex_info sysex;
u_int dev;
CTASSERT(sizeof(seq_event_rec) == SEQ_SYSEX_HDRSIZE);
memcpy(&sysex, b, sizeof(*b));
dev = sysex.device_no;
if (/* dev < 0 || */ dev >= sc->nmidi)
return ENXIO;
DPRINTFN(2, ("seq_do_fullsize: fmt=%04x, dev=%d, len=%d\n",
sysex.key, dev, sysex.len));
return midiseq_loadpatch(sc->devs[dev], &sysex, uio);
}
/*
* Convert an old sequencer event to a new one.
* NOTE: on entry, *ev may contain valid data only in the first 4 bytes.
* That may be true even on exit (!) in the case of SEQOLD_MIDIPUTC; the
* caller will only look at the first bytes in that case anyway. Ugly? Sure.
*/
static int
seq_to_new(seq_event_t *ev, struct uio *uio)
{
int cmd, chan, note, parm;
uint32_t tmp_delay;
int error;
uint8_t *bfp;
cmd = ev->tag;
bfp = ev->unknown.byte;
chan = *bfp++;
note = *bfp++;
parm = *bfp++;
DPRINTFN(3, ("seq_to_new: 0x%02x %d %d %d\n", cmd, chan, note, parm));
if (cmd >= 0x80) {
/* Fill the event record */
if (uio->uio_resid >= sizeof *ev - SEQOLD_CMDSIZE) {
error = uiomove(bfp, sizeof *ev - SEQOLD_CMDSIZE, uio);
if (error)
return error;
} else
return EINVAL;
}
switch(cmd) {
case SEQOLD_NOTEOFF:
/*
* What's with the SEQ_NOTE_XXX? In OSS this seems to have
* been undocumented magic for messing with the overall volume
* of a 'voice', equated precariously with 'channel' and
* pretty much unimplementable except by directly frobbing a
* synth chip. For us, who treat everything as interfaced over
* MIDI, this will just be unceremoniously discarded as
* invalid in midiseq_noteoff, making the whole event an
* elaborate no-op, and that doesn't seem to be any different
* from what happens on linux with a MIDI-interfaced device,
* by the way. The moral is ... use the new /dev/music API, ok?
*/
*ev = SEQ_MK_CHN(NOTEOFF, .device=0, .channel=chan,
.key=SEQ_NOTE_XXX, .velocity=parm);
break;
case SEQOLD_NOTEON:
*ev = SEQ_MK_CHN(NOTEON,
.device=0, .channel=chan, .key=note, .velocity=parm);
break;
case SEQOLD_WAIT:
/*
* This event cannot even /exist/ on non-littleendian machines,
* and so help me, that's exactly the way OSS defined it.
* Also, the OSS programmer's guide states (p. 74, v1.11)
* that seqold time units are system clock ticks, unlike
* the new 'divisions' which are determined by timebase. In
* that case we would need to do scaling here - but no such
* behavior is visible in linux either--which also treats this
* value, surprisingly, as an absolute, not relative, time.
* My guess is that this event has gone unused so long that
* nobody could agree we got it wrong no matter what we do.
*/
tmp_delay = *(uint32_t *)ev >> 8;
*ev = SEQ_MK_TIMING(WAIT_ABS, .divisions=tmp_delay);
break;
case SEQOLD_SYNCTIMER:
/*
* The TMR_RESET event is not defined in any OSS materials
* I can find; it may have been invented here just to provide
* an accurate _to_new translation of this event.
*/
*ev = SEQ_MK_TIMING(RESET);
break;
case SEQOLD_PGMCHANGE:
*ev = SEQ_MK_CHN(PGM_CHANGE,
.device=0, .channel=chan, .program=note);
break;
case SEQOLD_MIDIPUTC:
break; /* interpret in normal mode */
case SEQOLD_ECHO:
case SEQOLD_PRIVATE:
case SEQOLD_EXTENDED:
default:
DPRINTF(("%s: not impl 0x%02x\n", __func__, cmd));
return EINVAL;
/* In case new-style events show up */
case SEQ_TIMING:
case SEQ_CHN_VOICE:
case SEQ_CHN_COMMON:
case SEQ_FULLSIZE:
break;
}
return 0;
}
/**********************************************/
void
midiseq_in(struct midi_dev *md, u_char *msg, int len)
{
struct sequencer_softc *sc;
sequencer_pcqitem_t qi;
DPRINTFN(2, ("midiseq_in: %p %02x %02x %02x\n",
md, msg[0], msg[1], msg[2]));
sc = md->seq;
qi.qi_msg[0] = msg[0];
qi.qi_msg[1] = msg[1];
qi.qi_msg[2] = msg[2];
qi.qi_msg[3] = md->unit | 0x80; /* ensure non-zero value of qi_ptr */
pcq_put(sc->pcq, qi.qi_ptr);
softint_schedule(sc->sih);
}
static struct midi_dev *
midiseq_open(int unit, int flags)
{
int error;
struct midi_dev *md;
struct midi_softc *sc;
struct midi_info mi;
int major;
dev_t dev;
vnode_t *vp;
int oflags;
major = devsw_name2chr("midi", NULL, 0);
dev = makedev(major, unit);
DPRINTFN(2, ("midiseq_open: %d %d\n", unit, flags));
error = cdevvp(dev, &vp);
if (error)
return NULL;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
error = VOP_OPEN(vp, flags, kauth_cred_get());
VOP_UNLOCK(vp);
if (error) {
vrele(vp);
return NULL;
}
/* Only after we have acquired reference via VOP_OPEN(). */
midi_getinfo(dev, &mi);
oflags = flags;
if ((mi.props & MIDI_PROP_CAN_INPUT) == 0)
flags &= ~FREAD;
if ((flags & (FREAD|FWRITE)) == 0) {
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
VOP_CLOSE(vp, oflags, kauth_cred_get());
VOP_UNLOCK(vp);
vrele(vp);
return NULL;
}
sc = device_lookup_private(&midi_cd, unit);
md = kmem_zalloc(sizeof(*md), KM_SLEEP);
md->unit = unit;
md->name = mi.name;
md->subtype = 0;
md->nr_voices = 128; /* XXX */
md->instr_bank_size = 128; /* XXX */
md->vp = vp;
if (mi.props & MIDI_PROP_CAN_INPUT)
md->capabilities |= SYNTH_CAP_INPUT;
sc->seq_md = md;
return md;
}
static void
midiseq_close(struct midi_dev *md)
{
DPRINTFN(2, ("midiseq_close: %d\n", md->unit));
(void)vn_close(md->vp, 0, kauth_cred_get());
kmem_free(md, sizeof(*md));
}
static void
midiseq_reset(struct midi_dev *md)
{
/* XXX send GM reset? */
DPRINTFN(3, ("midiseq_reset: %d\n", md->unit));
}
static int
midiseq_out(struct midi_dev *md, u_char *bf, u_int cc, int chk)
{
DPRINTFN(5, ("midiseq_out: md=%p, unit=%d, bf[0]=0x%02x, cc=%d\n",
md, md->unit, bf[0], cc));
/* midi(4) does running status compression where appropriate. */
return midi_writebytes(md->unit, bf, cc);
}
/*
* If the writing process hands us a hidden note-off in a note-on event,
* we will simply write it that way; no need to special case it here,
* as midi(4) will always canonicalize or compress as appropriate anyway.
*/
static int
midiseq_noteon(struct midi_dev *md, int chan, int key, seq_event_t *ev)
{
return midiseq_out(md, (uint8_t[]){
MIDI_NOTEON | chan, key, ev->c_NOTEON.velocity & 0x7f}, 3, 1);
}
static int
midiseq_noteoff(struct midi_dev *md, int chan, int key, seq_event_t *ev)
{
return midiseq_out(md, (uint8_t[]){
MIDI_NOTEOFF | chan, key, ev->c_NOTEOFF.velocity & 0x7f}, 3, 1);
}
static int
midiseq_keypressure(struct midi_dev *md, int chan, int key, seq_event_t *ev)
{
return midiseq_out(md, (uint8_t[]){
MIDI_KEY_PRESSURE | chan, key,
ev->c_KEY_PRESSURE.pressure & 0x7f}, 3, 1);
}
static int
midiseq_pgmchange(struct midi_dev *md, int chan, seq_event_t *ev)
{
if (ev->c_PGM_CHANGE.program > 127)
return EINVAL;
return midiseq_out(md, (uint8_t[]){
MIDI_PGM_CHANGE | chan, ev->c_PGM_CHANGE.program}, 2, 1);
}
static int
midiseq_chnpressure(struct midi_dev *md, int chan, seq_event_t *ev)
{
if (ev->c_CHN_PRESSURE.pressure > 127)
return EINVAL;
return midiseq_out(md, (uint8_t[]){
MIDI_CHN_PRESSURE | chan, ev->c_CHN_PRESSURE.pressure}, 2, 1);
}
static int
midiseq_ctlchange(struct midi_dev *md, int chan, seq_event_t *ev)
{
if (ev->c_CTL_CHANGE.controller > 127)
return EINVAL;
return midiseq_out( md, (uint8_t[]){
MIDI_CTL_CHANGE | chan, ev->c_CTL_CHANGE.controller,
ev->c_CTL_CHANGE.value & 0x7f /* XXX this is SO wrong */
}, 3, 1);
}
static int
midiseq_pitchbend(struct midi_dev *md, int chan, seq_event_t *ev)
{
return midiseq_out(md, (uint8_t[]){
MIDI_PITCH_BEND | chan,
ev->c_PITCH_BEND.value & 0x7f,
(ev->c_PITCH_BEND.value >> 7) & 0x7f}, 3, 1);
}
static int
midiseq_loadpatch(struct midi_dev *md,
struct sysex_info *sysex, struct uio *uio)
{
struct sequencer_softc *sc;
u_char c, bf[128];
int i, cc, error;
if (sysex->key != SEQ_SYSEX_PATCH) {
DPRINTFN(-1,("midiseq_loadpatch: bad patch key 0x%04x\n",
sysex->key));
return EINVAL;
}
if (uio->uio_resid < sysex->len)
/* adjust length, should be an error */
sysex->len = uio->uio_resid;
DPRINTFN(2, ("midiseq_loadpatch: len=%d\n", sysex->len));
if (sysex->len == 0)
return EINVAL;
error = uiomove(&c, 1, uio);
if (error)
return error;
if (c != MIDI_SYSEX_START) /* must start like this */
return EINVAL;
sc = md->seq;
mutex_enter(&sc->lock);
error = midiseq_out(md, &c, 1, 0);
mutex_exit(&sc->lock);
if (error)
return error;
--sysex->len;
while (sysex->len > 0) {
cc = sysex->len;
if (cc > sizeof bf)
cc = sizeof bf;
error = uiomove(bf, cc, uio);
if (error)
break;
for(i = 0; i < cc && !MIDI_IS_STATUS(bf[i]); i++)
;
/*
* XXX midi(4)'s buffer might not accommodate this, and the
* function will not block us (though in this case we have
* a process and could in principle block).
*/
mutex_enter(&sc->lock);
error = midiseq_out(md, bf, i, 0);
mutex_exit(&sc->lock);
if (error)
break;
sysex->len -= i;
if (i != cc)
break;
}
/*
* Any leftover data in uio is rubbish;
* the SYSEX should be one write ending in SYSEX_END.
*/
uio->uio_resid = 0;
c = MIDI_SYSEX_END;
mutex_enter(&sc->lock);
error = midiseq_out(md, &c, 1, 0);
mutex_exit(&sc->lock);
return error;
}
#if NMIDI == 0
static dev_type_open(midiopen);
static dev_type_close(midiclose);
/*
* If someone has a sequencer, but no midi devices there will
* be unresolved references, so we provide little stubs.
*/
int
midi_unit_count(void)
{
return 0;
}
static int
midiopen(dev_t dev, int flags, int ifmt, struct lwp *l)
{
return ENXIO;
}
void
midi_getinfo(dev_t dev, struct midi_info *mi)
{
mi->name = "Dummy MIDI device";
mi->props = 0;
}
static int
midiclose(dev_t dev, int flags, int ifmt, struct lwp *l)
{
return ENXIO;
}
int
midi_writebytes(int unit, u_char *bf, int cc)
{
return ENXIO;
}
#endif /* NMIDI == 0 */
