Annotation of sys/dev/sequencer.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: sequencer.c,v 1.13 2007/06/06 19:42:28 mk Exp $ */
! 2: /* $NetBSD: sequencer.c,v 1.13 1998/11/25 22:17:07 augustss Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1998 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Lennart Augustsson (augustss@netbsd.org).
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by the NetBSD
! 22: * Foundation, Inc. and its contributors.
! 23: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 24: * contributors may be used to endorse or promote products derived
! 25: * from this software without specific prior written permission.
! 26: *
! 27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 37: * POSSIBILITY OF SUCH DAMAGE.
! 38: */
! 39:
! 40: #include "sequencer.h"
! 41: #if NSEQUENCER > 0
! 42:
! 43: #include <sys/param.h>
! 44: #include <sys/ioctl.h>
! 45: #include <sys/fcntl.h>
! 46: #include <sys/vnode.h>
! 47: #include <sys/selinfo.h>
! 48: #include <sys/poll.h>
! 49: #include <sys/malloc.h>
! 50: #include <sys/proc.h>
! 51: #include <sys/systm.h>
! 52: #include <sys/syslog.h>
! 53: #include <sys/kernel.h>
! 54: #include <sys/signalvar.h>
! 55: #include <sys/conf.h>
! 56: #include <sys/audioio.h>
! 57: #include <sys/midiio.h>
! 58: #include <sys/device.h>
! 59:
! 60: #include <dev/midi_if.h>
! 61: #include <dev/midivar.h>
! 62: #include <dev/sequencervar.h>
! 63:
! 64: #ifndef splaudio
! 65: #define splaudio() splbio() /* XXX found in audio_if.h normally */
! 66: #endif
! 67:
! 68: #define ADDTIMEVAL(a, b) ( \
! 69: (a)->tv_sec += (b)->tv_sec, \
! 70: (a)->tv_usec += (b)->tv_usec, \
! 71: (a)->tv_usec >= 1000000 ? ((a)->tv_sec++, (a)->tv_usec -= 1000000) : 0\
! 72: )
! 73:
! 74: #define SUBTIMEVAL(a, b) ( \
! 75: (a)->tv_sec -= (b)->tv_sec, \
! 76: (a)->tv_usec -= (b)->tv_usec, \
! 77: (a)->tv_usec < 0 ? ((a)->tv_sec--, (a)->tv_usec += 1000000) : 0\
! 78: )
! 79:
! 80: #ifdef AUDIO_DEBUG
! 81: #define DPRINTF(x) if (sequencerdebug) printf x
! 82: #define DPRINTFN(n,x) if (sequencerdebug >= (n)) printf x
! 83: int sequencerdebug = 0;
! 84: #else
! 85: #define DPRINTF(x)
! 86: #define DPRINTFN(n,x)
! 87: #endif
! 88:
! 89: #define SEQ_CMD(b) ((b)->arr[0])
! 90:
! 91: #define SEQ_EDEV(b) ((b)->arr[1])
! 92: #define SEQ_ECMD(b) ((b)->arr[2])
! 93: #define SEQ_ECHAN(b) ((b)->arr[3])
! 94: #define SEQ_ENOTE(b) ((b)->arr[4])
! 95: #define SEQ_EPARM(b) ((b)->arr[5])
! 96:
! 97: #define SEQ_EP1(b) ((b)->arr[4])
! 98: #define SEQ_EP2(b) ((b)->arr[5])
! 99:
! 100: #define SEQ_XCMD(b) ((b)->arr[1])
! 101: #define SEQ_XDEV(b) ((b)->arr[2])
! 102: #define SEQ_XCHAN(b) ((b)->arr[3])
! 103: #define SEQ_XNOTE(b) ((b)->arr[4])
! 104: #define SEQ_XVEL(b) ((b)->arr[5])
! 105:
! 106: #define SEQ_TCMD(b) ((b)->arr[1])
! 107: #define SEQ_TPARM(b) ((b)->arr[4])
! 108:
! 109: #define SEQ_NOTE_MAX 128
! 110: #define SEQ_NOTE_XXX 255
! 111: #define SEQ_VEL_OFF 0
! 112:
! 113: #define RECALC_TICK(t) ((t)->tick = 60 * 1000000L / ((t)->tempo * (t)->timebase))
! 114:
! 115: struct sequencer_softc seqdevs[NSEQUENCER];
! 116:
! 117: void sequencerattach(int);
! 118: void seq_reset(struct sequencer_softc *);
! 119: int seq_do_command(struct sequencer_softc *, seq_event_rec *);
! 120: int seq_do_extcommand(struct sequencer_softc *, seq_event_rec *);
! 121: int seq_do_chnvoice(struct sequencer_softc *, seq_event_rec *);
! 122: int seq_do_chncommon(struct sequencer_softc *, seq_event_rec *);
! 123: int seq_do_timing(struct sequencer_softc *, seq_event_rec *);
! 124: int seq_do_local(struct sequencer_softc *, seq_event_rec *);
! 125: int seq_do_sysex(struct sequencer_softc *, seq_event_rec *);
! 126: int seq_do_fullsize(struct sequencer_softc *, seq_event_rec *,
! 127: struct uio *);
! 128: int seq_timer(struct sequencer_softc *, int, int, seq_event_rec *);
! 129: static int seq_input_event(struct sequencer_softc *, seq_event_rec *);
! 130: int seq_drain(struct sequencer_softc *);
! 131: void seq_startoutput(struct sequencer_softc *);
! 132: void seq_timeout(void *);
! 133: int seq_to_new(seq_event_rec *, struct uio *);
! 134: static int seq_sleep_timo(int *, char *, int);
! 135: static int seq_sleep(int *, char *);
! 136: static void seq_wakeup(int *);
! 137:
! 138: struct midi_softc;
! 139: int midiseq_out(struct midi_dev *, u_char *, u_int, int);
! 140: struct midi_dev *midiseq_open(int, int);
! 141: void midiseq_close(struct midi_dev *);
! 142: void midiseq_reset(struct midi_dev *);
! 143: int midiseq_noteon(struct midi_dev *, int, int, int);
! 144: int midiseq_noteoff(struct midi_dev *, int, int, int);
! 145: int midiseq_keypressure(struct midi_dev *, int, int, int);
! 146: int midiseq_pgmchange(struct midi_dev *, int, int);
! 147: int midiseq_chnpressure(struct midi_dev *, int, int);
! 148: int midiseq_ctlchange(struct midi_dev *, int, int, int);
! 149: int midiseq_pitchbend(struct midi_dev *, int, int);
! 150: int midiseq_loadpatch(struct midi_dev *, struct sysex_info *,
! 151: struct uio *);
! 152: int midiseq_putc(struct midi_dev *, int);
! 153: void midiseq_in(struct midi_dev *, u_char *, int);
! 154:
! 155: void
! 156: sequencerattach(int n)
! 157: {
! 158: }
! 159:
! 160: int
! 161: sequenceropen(dev_t dev, int flags, int ifmt, struct proc *p)
! 162: {
! 163: int unit = SEQUENCERUNIT(dev);
! 164: struct sequencer_softc *sc;
! 165: struct midi_dev *md;
! 166: int nmidi;
! 167:
! 168: DPRINTF(("sequenceropen\n"));
! 169:
! 170: if (unit >= NSEQUENCER)
! 171: return (ENXIO);
! 172: sc = &seqdevs[unit];
! 173: if (sc->isopen)
! 174: return (EBUSY);
! 175: if (SEQ_IS_OLD(dev))
! 176: sc->mode = SEQ_OLD;
! 177: else
! 178: sc->mode = SEQ_NEW;
! 179: sc->isopen++;
! 180: sc->flags = flags & (FREAD|FWRITE);
! 181: sc->rchan = 0;
! 182: sc->wchan = 0;
! 183: sc->pbus = 0;
! 184: sc->async = 0;
! 185: sc->input_stamp = ~0;
! 186:
! 187: sc->nmidi = 0;
! 188: nmidi = midi_unit_count();
! 189:
! 190: sc->devs = malloc(nmidi * sizeof(struct midi_dev *),
! 191: M_DEVBUF, M_WAITOK);
! 192: for (unit = 0; unit < nmidi; unit++) {
! 193: md = midiseq_open(unit, flags);
! 194: if (md) {
! 195: sc->devs[sc->nmidi++] = md;
! 196: md->seq = sc;
! 197: }
! 198: }
! 199:
! 200: sc->timer.timebase = 100;
! 201: sc->timer.tempo = 60;
! 202: sc->doingsysex = 0;
! 203: RECALC_TICK(&sc->timer);
! 204: sc->timer.last = 0;
! 205: microtime(&sc->timer.start);
! 206:
! 207: SEQ_QINIT(&sc->inq);
! 208: SEQ_QINIT(&sc->outq);
! 209: sc->lowat = SEQ_MAXQ / 2;
! 210: timeout_set(&sc->timo, seq_timeout, sc);
! 211:
! 212: seq_reset(sc);
! 213:
! 214: DPRINTF(("sequenceropen: mode=%d, nmidi=%d\n", sc->mode, sc->nmidi));
! 215: return (0);
! 216: }
! 217:
! 218: static int
! 219: seq_sleep_timo(int *chan, char *label, int timo)
! 220: {
! 221: int st;
! 222:
! 223: if (!label)
! 224: label = "seq";
! 225:
! 226: DPRINTFN(5, ("seq_sleep_timo: %p %s %d\n", chan, label, timo));
! 227: *chan = 1;
! 228: st = tsleep(chan, PWAIT | PCATCH, label, timo);
! 229: *chan = 0;
! 230: #ifdef MIDI_DEBUG
! 231: if (st != 0)
! 232: printf("seq_sleep: %d\n", st);
! 233: #endif
! 234: return (st);
! 235: }
! 236:
! 237: static int
! 238: seq_sleep(int *chan, char *label)
! 239: {
! 240: return (seq_sleep_timo(chan, label, 0));
! 241: }
! 242:
! 243: static void
! 244: seq_wakeup(int *chan)
! 245: {
! 246: if (*chan) {
! 247: DPRINTFN(5, ("seq_wakeup: %p\n", chan));
! 248: wakeup(chan);
! 249: *chan = 0;
! 250: }
! 251: }
! 252:
! 253: int
! 254: seq_drain(struct sequencer_softc *sc)
! 255: {
! 256: int error;
! 257:
! 258: DPRINTFN(3, ("seq_drain: %p, len=%d\n", sc, SEQ_QLEN(&sc->outq)));
! 259: seq_startoutput(sc);
! 260: error = 0;
! 261: while(!SEQ_QEMPTY(&sc->outq) && !error)
! 262: error = seq_sleep_timo(&sc->wchan, "seq_dr", 60*hz);
! 263: return (error);
! 264: }
! 265:
! 266: void
! 267: seq_timeout(void *addr)
! 268: {
! 269: struct sequencer_softc *sc = addr;
! 270: DPRINTFN(4, ("seq_timeout: %p\n", sc));
! 271: sc->timeout = 0;
! 272: seq_startoutput(sc);
! 273: if (SEQ_QLEN(&sc->outq) < sc->lowat) {
! 274: seq_wakeup(&sc->wchan);
! 275: selwakeup(&sc->wsel);
! 276: if (sc->async)
! 277: psignal(sc->async, SIGIO);
! 278: }
! 279:
! 280: }
! 281:
! 282: void
! 283: seq_startoutput(struct sequencer_softc *sc)
! 284: {
! 285: struct sequencer_queue *q = &sc->outq;
! 286: seq_event_rec cmd;
! 287:
! 288: if (sc->timeout)
! 289: return;
! 290: DPRINTFN(4, ("seq_startoutput: %p, len=%d\n", sc, SEQ_QLEN(q)));
! 291: while(!SEQ_QEMPTY(q) && !sc->timeout) {
! 292: SEQ_QGET(q, cmd);
! 293: seq_do_command(sc, &cmd);
! 294: }
! 295: }
! 296:
! 297: int
! 298: sequencerclose(dev_t dev, int flags, int ifmt, struct proc *p)
! 299: {
! 300: struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
! 301: int n, s;
! 302:
! 303: DPRINTF(("sequencerclose: %p\n", sc));
! 304:
! 305: seq_drain(sc);
! 306: s = splaudio();
! 307: if (sc->timeout) {
! 308: timeout_del(&sc->timo);
! 309: sc->timeout = 0;
! 310: }
! 311: splx(s);
! 312:
! 313: for (n = 0; n < sc->nmidi; n++)
! 314: midiseq_close(sc->devs[n]);
! 315: free(sc->devs, M_DEVBUF);
! 316: sc->isopen = 0;
! 317: return (0);
! 318: }
! 319:
! 320: static int
! 321: seq_input_event(struct sequencer_softc *sc, seq_event_rec *cmd)
! 322: {
! 323: struct sequencer_queue *q = &sc->inq;
! 324:
! 325: DPRINTFN(2, ("seq_input_event: %02x %02x %02x %02x %02x %02x %02x %02x\n",
! 326: cmd->arr[0], cmd->arr[1], cmd->arr[2], cmd->arr[3],
! 327: cmd->arr[4], cmd->arr[5], cmd->arr[6], cmd->arr[7]));
! 328: if (SEQ_QFULL(q))
! 329: return (ENOMEM);
! 330: SEQ_QPUT(q, *cmd);
! 331: seq_wakeup(&sc->rchan);
! 332: selwakeup(&sc->rsel);
! 333: if (sc->async)
! 334: psignal(sc->async, SIGIO);
! 335: return (0);
! 336: }
! 337:
! 338: void
! 339: seq_event_intr(void *addr, seq_event_rec *iev)
! 340: {
! 341: struct sequencer_softc *sc = addr;
! 342: union {
! 343: u_int32_t l;
! 344: u_int8_t b[4];
! 345: } u;
! 346: u_long t;
! 347: struct timeval now;
! 348: seq_event_rec ev;
! 349:
! 350: microtime(&now);
! 351: SUBTIMEVAL(&now, &sc->timer.start);
! 352: t = now.tv_sec * 1000000 + now.tv_usec;
! 353: t /= sc->timer.tick;
! 354: if (t != sc->input_stamp) {
! 355: ev.arr[0] = SEQ_TIMING;
! 356: ev.arr[1] = TMR_WAIT_ABS;
! 357: ev.arr[2] = 0;
! 358: ev.arr[3] = 0;
! 359: u.l = t;
! 360: ev.arr[4] = u.b[0];
! 361: ev.arr[5] = u.b[1];
! 362: ev.arr[6] = u.b[2];
! 363: ev.arr[7] = u.b[3];
! 364: seq_input_event(sc, &ev);
! 365: sc->input_stamp = t;
! 366: }
! 367: seq_input_event(sc, iev);
! 368: }
! 369:
! 370: int
! 371: sequencerread(dev_t dev, struct uio *uio, int ioflag)
! 372: {
! 373: struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
! 374: struct sequencer_queue *q = &sc->inq;
! 375: seq_event_rec ev;
! 376: int error, s;
! 377:
! 378: DPRINTFN(20, ("sequencerread: %p, count=%d, ioflag=%x\n",
! 379: sc, uio->uio_resid, ioflag));
! 380:
! 381: if (sc->mode == SEQ_OLD) {
! 382: DPRINTFN(-1,("sequencerread: old read\n"));
! 383: return (EINVAL); /* XXX unimplemented */
! 384: }
! 385:
! 386: error = 0;
! 387: while (SEQ_QEMPTY(q)) {
! 388: if (ioflag & IO_NDELAY)
! 389: return (EWOULDBLOCK);
! 390: else {
! 391: error = seq_sleep(&sc->rchan, "seq rd");
! 392: if (error)
! 393: return (error);
! 394: }
! 395: }
! 396: s = splaudio();
! 397: while (uio->uio_resid >= sizeof ev && !error && !SEQ_QEMPTY(q)) {
! 398: SEQ_QGET(q, ev);
! 399: error = uiomove((caddr_t)&ev, sizeof ev, uio);
! 400: }
! 401: splx(s);
! 402: return (error);
! 403: }
! 404:
! 405: int
! 406: sequencerwrite(dev_t dev, struct uio *uio, int ioflag)
! 407: {
! 408: struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
! 409: struct sequencer_queue *q = &sc->outq;
! 410: int error;
! 411: seq_event_rec cmdbuf;
! 412: int size;
! 413:
! 414: DPRINTFN(2, ("sequencerwrite: %p, count=%d\n", sc, uio->uio_resid));
! 415:
! 416: error = 0;
! 417: size = sc->mode == SEQ_NEW ? sizeof cmdbuf : SEQOLD_CMDSIZE;
! 418: while (uio->uio_resid >= size) {
! 419: error = uiomove((caddr_t)&cmdbuf, size, uio);
! 420: if (error)
! 421: break;
! 422: if (sc->mode == SEQ_OLD)
! 423: if (seq_to_new(&cmdbuf, uio))
! 424: continue;
! 425: if (SEQ_CMD(&cmdbuf) == SEQ_FULLSIZE) {
! 426: /* We do it like OSS does, asynchronously */
! 427: error = seq_do_fullsize(sc, &cmdbuf, uio);
! 428: if (error)
! 429: break;
! 430: continue;
! 431: }
! 432: while (SEQ_QFULL(q)) {
! 433: seq_startoutput(sc);
! 434: if (SEQ_QFULL(q)) {
! 435: if (ioflag & IO_NDELAY)
! 436: return (EWOULDBLOCK);
! 437: error = seq_sleep(&sc->wchan, "seq_wr");
! 438: if (error)
! 439: return (error);
! 440: }
! 441: }
! 442: SEQ_QPUT(q, cmdbuf);
! 443: }
! 444: seq_startoutput(sc);
! 445:
! 446: #ifdef SEQUENCER_DEBUG
! 447: if (error)
! 448: DPRINTFN(2, ("sequencerwrite: error=%d\n", error));
! 449: #endif
! 450: return (error);
! 451: }
! 452:
! 453: int
! 454: sequencerioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
! 455: {
! 456: struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
! 457: struct synth_info *si;
! 458: struct midi_dev *md;
! 459: int devno;
! 460: int error;
! 461: int t;
! 462:
! 463: DPRINTFN(2, ("sequencerioctl: %p cmd=0x%08lx\n", sc, cmd));
! 464:
! 465: error = 0;
! 466: switch (cmd) {
! 467: case FIONBIO:
! 468: /* All handled in the upper FS layer. */
! 469: break;
! 470:
! 471: case FIOASYNC:
! 472: if (*(int *)addr) {
! 473: if (sc->async)
! 474: return (EBUSY);
! 475: sc->async = p;
! 476: DPRINTF(("sequencer_ioctl: FIOASYNC %p\n", p));
! 477: } else
! 478: sc->async = 0;
! 479: break;
! 480:
! 481: case SEQUENCER_RESET:
! 482: seq_reset(sc);
! 483: break;
! 484:
! 485: case SEQUENCER_PANIC:
! 486: seq_reset(sc);
! 487: /* Do more? OSS doesn't */
! 488: break;
! 489:
! 490: case SEQUENCER_SYNC:
! 491: if (sc->flags == FREAD)
! 492: return (0);
! 493: seq_drain(sc);
! 494: error = 0;
! 495: break;
! 496:
! 497: case SEQUENCER_INFO:
! 498: si = (struct synth_info*)addr;
! 499: devno = si->device;
! 500: if (devno < 0 || devno >= sc->nmidi)
! 501: return (EINVAL);
! 502: md = sc->devs[devno];
! 503: strncpy(si->name, md->name, sizeof si->name);
! 504: si->synth_type = SYNTH_TYPE_MIDI;
! 505: si->synth_subtype = md->subtype;
! 506: si->nr_voices = md->nr_voices;
! 507: si->instr_bank_size = md->instr_bank_size;
! 508: si->capabilities = md->capabilities;
! 509: break;
! 510:
! 511: case SEQUENCER_NRSYNTHS:
! 512: *(int *)addr = sc->nmidi;
! 513: break;
! 514:
! 515: case SEQUENCER_NRMIDIS:
! 516: *(int *)addr = sc->nmidi;
! 517: break;
! 518:
! 519: case SEQUENCER_OUTOFBAND:
! 520: DPRINTFN(3, ("sequencer_ioctl: OOB=%02x %02x %02x %02x %02x %02x %02x %02x\n",
! 521: *(u_char *)addr, *(u_char *)(addr+1),
! 522: *(u_char *)(addr+2), *(u_char *)(addr+3),
! 523: *(u_char *)(addr+4), *(u_char *)(addr+5),
! 524: *(u_char *)(addr+6), *(u_char *)(addr+7)));
! 525: error = seq_do_command(sc, (seq_event_rec *)addr);
! 526: break;
! 527:
! 528: case SEQUENCER_TMR_TIMEBASE:
! 529: t = *(int *)addr;
! 530: if (t < 1)
! 531: t = 1;
! 532: if (t > 1000)
! 533: t = 1000;
! 534: sc->timer.timebase = t;
! 535: *(int *)addr = t;
! 536: RECALC_TICK(&sc->timer);
! 537: break;
! 538:
! 539: case SEQUENCER_TMR_START:
! 540: error = seq_timer(sc, TMR_START, 0, 0);
! 541: break;
! 542:
! 543: case SEQUENCER_TMR_STOP:
! 544: error = seq_timer(sc, TMR_STOP, 0, 0);
! 545: break;
! 546:
! 547: case SEQUENCER_TMR_CONTINUE:
! 548: error = seq_timer(sc, TMR_CONTINUE, 0, 0);
! 549: break;
! 550:
! 551: case SEQUENCER_TMR_TEMPO:
! 552: t = *(int *)addr;
! 553: if (t < 8)
! 554: t = 8;
! 555: if (t > 250)
! 556: t = 250;
! 557: sc->timer.tempo = t;
! 558: *(int *)addr = t;
! 559: RECALC_TICK(&sc->timer);
! 560: break;
! 561:
! 562: case SEQUENCER_TMR_SOURCE:
! 563: *(int *)addr = SEQUENCER_TMR_INTERNAL;
! 564: break;
! 565:
! 566: case SEQUENCER_TMR_METRONOME:
! 567: /* noop */
! 568: break;
! 569:
! 570: case SEQUENCER_THRESHOLD:
! 571: t = SEQ_MAXQ - *(int *)addr / sizeof (seq_event_rec);
! 572: if (t < 1)
! 573: t = 1;
! 574: if (t > SEQ_MAXQ)
! 575: t = SEQ_MAXQ;
! 576: sc->lowat = t;
! 577: break;
! 578:
! 579: case SEQUENCER_CTRLRATE:
! 580: *(int *)addr = (sc->timer.tempo*sc->timer.timebase + 30) / 60;
! 581: break;
! 582:
! 583: case SEQUENCER_GETTIME:
! 584: {
! 585: struct timeval now;
! 586: u_long t;
! 587: microtime(&now);
! 588: SUBTIMEVAL(&now, &sc->timer.start);
! 589: t = now.tv_sec * 1000000 + now.tv_usec;
! 590: t /= sc->timer.tick;
! 591: *(int *)addr = t;
! 592: break;
! 593: }
! 594:
! 595: default:
! 596: DPRINTFN(-1,("sequencer_ioctl: unimpl %08lx\n", cmd));
! 597: error = ENOTTY;
! 598: break;
! 599: }
! 600: return (error);
! 601: }
! 602:
! 603: int
! 604: sequencerpoll(dev_t dev, int events, struct proc *p)
! 605: {
! 606: struct sequencer_softc *sc = &seqdevs[SEQUENCERUNIT(dev)];
! 607: int revents = 0;
! 608:
! 609: DPRINTF(("sequencerpoll: %p rw=0x%x\n", sc, events));
! 610:
! 611: if (events & (POLLIN | POLLRDNORM)) {
! 612: if (!SEQ_QEMPTY(&sc->inq))
! 613: revents |= events & (POLLIN | POLLRDNORM);
! 614: }
! 615: if (events & (POLLOUT | POLLWRNORM)) {
! 616: if (SEQ_QLEN(&sc->outq) < sc->lowat)
! 617: revents |= events & (POLLOUT | POLLWRNORM);
! 618: }
! 619: if (revents == 0) {
! 620: if (events & (POLLIN | POLLRDNORM))
! 621: selrecord(p, &sc->rsel);
! 622: if (events & (POLLOUT | POLLWRNORM))
! 623: selrecord(p, &sc->wsel);
! 624: }
! 625: return (revents);
! 626: }
! 627:
! 628: void
! 629: seq_reset(struct sequencer_softc *sc)
! 630: {
! 631: int i, chn;
! 632: struct midi_dev *md;
! 633:
! 634: for (i = 0; i < sc->nmidi; i++) {
! 635: md = sc->devs[i];
! 636: midiseq_reset(md);
! 637: for (chn = 0; chn < MAXCHAN; chn++) {
! 638: midiseq_ctlchange(md, chn, MIDI_CTRL_ALLOFF, 0);
! 639: midiseq_ctlchange(md, chn, MIDI_CTRL_RESET, 0);
! 640: midiseq_pitchbend(md, chn, MIDI_BEND_NEUTRAL);
! 641: }
! 642: }
! 643: }
! 644:
! 645: int
! 646: seq_do_command(struct sequencer_softc *sc, seq_event_rec *b)
! 647: {
! 648: int dev;
! 649:
! 650: DPRINTFN(4, ("seq_do_command: %p cmd=0x%02x\n", sc, SEQ_CMD(b)));
! 651:
! 652: switch(SEQ_CMD(b)) {
! 653: case SEQ_LOCAL:
! 654: return (seq_do_local(sc, b));
! 655: case SEQ_TIMING:
! 656: return (seq_do_timing(sc, b));
! 657: case SEQ_CHN_VOICE:
! 658: return (seq_do_chnvoice(sc, b));
! 659: case SEQ_CHN_COMMON:
! 660: return (seq_do_chncommon(sc, b));
! 661: case SEQ_SYSEX:
! 662: return (seq_do_sysex(sc, b));
! 663: /* COMPAT */
! 664: case SEQOLD_MIDIPUTC:
! 665: dev = b->arr[2];
! 666: if (dev < 0 || dev >= sc->nmidi)
! 667: return (ENXIO);
! 668: return (midiseq_putc(sc->devs[dev], b->arr[1]));
! 669: default:
! 670: DPRINTFN(-1,("seq_do_command: unimpl command %02x\n",
! 671: SEQ_CMD(b)));
! 672: return (EINVAL);
! 673: }
! 674: }
! 675:
! 676: int
! 677: seq_do_chnvoice(struct sequencer_softc *sc, seq_event_rec *b)
! 678: {
! 679: int cmd, dev, chan, note, parm, voice;
! 680: int error;
! 681: struct midi_dev *md;
! 682:
! 683: dev = SEQ_EDEV(b);
! 684: if (dev < 0 || dev >= sc->nmidi)
! 685: return (ENXIO);
! 686: md = sc->devs[dev];
! 687: cmd = SEQ_ECMD(b);
! 688: chan = SEQ_ECHAN(b);
! 689: note = SEQ_ENOTE(b);
! 690: parm = SEQ_EPARM(b);
! 691: DPRINTFN(2,("seq_do_chnvoice: cmd=%02x dev=%d chan=%d note=%d parm=%d\n",
! 692: cmd, dev, chan, note, parm));
! 693: voice = chan;
! 694: if (cmd == MIDI_NOTEON && parm == 0) {
! 695: cmd = MIDI_NOTEOFF;
! 696: parm = MIDI_HALF_VEL;
! 697: }
! 698: switch(cmd) {
! 699: case MIDI_NOTEON:
! 700: DPRINTFN(5, ("seq_do_chnvoice: noteon %p %d %d %d\n",
! 701: md, voice, note, parm));
! 702: error = midiseq_noteon(md, voice, note, parm);
! 703: break;
! 704: case MIDI_NOTEOFF:
! 705: error = midiseq_noteoff(md, voice, note, parm);
! 706: break;
! 707: case MIDI_KEY_PRESSURE:
! 708: error = midiseq_keypressure(md, voice, note, parm);
! 709: break;
! 710: default:
! 711: DPRINTFN(-1,("seq_do_chnvoice: unimpl command %02x\n", cmd));
! 712: error = EINVAL;
! 713: break;
! 714: }
! 715: return (error);
! 716: }
! 717:
! 718: int
! 719: seq_do_chncommon(struct sequencer_softc *sc, seq_event_rec *b)
! 720: {
! 721: int cmd, dev, chan, p1, w14;
! 722: int error;
! 723: struct midi_dev *md;
! 724: union {
! 725: int16_t s;
! 726: u_int8_t b[2];
! 727: } u;
! 728:
! 729: dev = SEQ_EDEV(b);
! 730: if (dev < 0 || dev >= sc->nmidi)
! 731: return (ENXIO);
! 732: md = sc->devs[dev];
! 733: cmd = SEQ_ECMD(b);
! 734: chan = SEQ_ECHAN(b);
! 735: p1 = SEQ_EP1(b);
! 736: u.b[0] = b->arr[6];
! 737: u.b[1] = b->arr[7];
! 738: w14 = u.s;
! 739: DPRINTFN(2,("seq_do_chncommon: %02x\n", cmd));
! 740:
! 741: error = 0;
! 742: switch(cmd) {
! 743: case MIDI_PGM_CHANGE:
! 744: error = midiseq_pgmchange(md, chan, p1);
! 745: break;
! 746: case MIDI_CTL_CHANGE:
! 747: if (chan > 15 || p1 > 127)
! 748: return (0); /* EINVAL */
! 749: error = midiseq_ctlchange(md, chan, p1, w14);
! 750: break;
! 751: case MIDI_PITCH_BEND:
! 752: error = midiseq_pitchbend(md, chan, w14);
! 753: break;
! 754: case MIDI_CHN_PRESSURE:
! 755: error = midiseq_chnpressure(md, chan, p1);
! 756: break;
! 757: default:
! 758: DPRINTFN(-1,("seq_do_chncommon: unimpl command %02x\n", cmd));
! 759: error = EINVAL;
! 760: break;
! 761: }
! 762: return (error);
! 763: }
! 764:
! 765: int
! 766: seq_do_timing(struct sequencer_softc *sc, seq_event_rec *b)
! 767: {
! 768: union {
! 769: int32_t i;
! 770: u_int8_t b[4];
! 771: } u;
! 772:
! 773: u.b[0] = b->arr[4];
! 774: u.b[1] = b->arr[5];
! 775: u.b[2] = b->arr[6];
! 776: u.b[3] = b->arr[7];
! 777: return (seq_timer(sc, SEQ_TCMD(b), u.i, b));
! 778: }
! 779:
! 780: int
! 781: seq_do_local(struct sequencer_softc *sc, seq_event_rec *b)
! 782: {
! 783: return (EINVAL);
! 784: }
! 785:
! 786: int
! 787: seq_do_sysex(struct sequencer_softc *sc, seq_event_rec *b)
! 788: {
! 789: int dev, i;
! 790: struct midi_dev *md;
! 791: u_int8_t c, *buf = &b->arr[2];
! 792:
! 793: dev = SEQ_EDEV(b);
! 794: if (dev < 0 || dev >= sc->nmidi)
! 795: return (ENXIO);
! 796: DPRINTF(("seq_do_sysex: dev=%d\n", dev));
! 797: md = sc->devs[dev];
! 798:
! 799: if (!sc->doingsysex) {
! 800: c = MIDI_SYSEX_START;
! 801: midiseq_out(md, &c, 1, 0);
! 802: sc->doingsysex = 1;
! 803: }
! 804:
! 805: for (i = 0; i < 6 && buf[i] != 0xff; i++)
! 806: ;
! 807: midiseq_out(md, buf, i, 0);
! 808: if (i < 6 || (i > 0 && buf[i-1] == MIDI_SYSEX_END))
! 809: sc->doingsysex = 0;
! 810: return (0);
! 811: }
! 812:
! 813: int
! 814: seq_timer(struct sequencer_softc *sc, int cmd, int parm, seq_event_rec *b)
! 815: {
! 816: struct syn_timer *t = &sc->timer;
! 817: struct timeval when;
! 818: int ticks;
! 819: int error;
! 820: long long usec;
! 821:
! 822: DPRINTFN(2,("seq_timer: %02x %d\n", cmd, parm));
! 823:
! 824: error = 0;
! 825: switch(cmd) {
! 826: case TMR_WAIT_REL:
! 827: parm += t->last;
! 828: /* FALLTHROUGH */
! 829: case TMR_WAIT_ABS:
! 830: t->last = parm;
! 831: usec = (long long)parm * (long long)t->tick; /* convert to usec */
! 832: when.tv_sec = usec / 1000000;
! 833: when.tv_usec = usec % 1000000;
! 834: DPRINTFN(4, ("seq_timer: parm=%d, sleep when=%ld.%06ld", parm,
! 835: when.tv_sec, when.tv_usec));
! 836: ADDTIMEVAL(&when, &t->start); /* abstime for end */
! 837: ticks = hzto(&when);
! 838: DPRINTFN(4, (" when+start=%ld.%06ld, ticks=%d\n",
! 839: when.tv_sec, when.tv_usec, ticks));
! 840: if (ticks > 0) {
! 841: #ifdef DIAGNOSTIC
! 842: if (ticks > 20 * hz) {
! 843: /* Waiting more than 20s */
! 844: printf("seq_timer: funny ticks=%d, usec=%lld, parm=%d, tick=%ld\n",
! 845: ticks, usec, parm, t->tick);
! 846: }
! 847: #endif
! 848: sc->timeout = 1;
! 849: timeout_add(&sc->timo, ticks);
! 850: }
! 851: #ifdef SEQUENCER_DEBUG
! 852: else if (ticks < 0)
! 853: DPRINTF(("seq_timer: ticks = %d\n", ticks));
! 854: #endif
! 855: break;
! 856: case TMR_START:
! 857: microtime(&t->start);
! 858: t->running = 1;
! 859: break;
! 860: case TMR_STOP:
! 861: microtime(&t->stop);
! 862: t->running = 0;
! 863: break;
! 864: case TMR_CONTINUE:
! 865: microtime(&when);
! 866: SUBTIMEVAL(&when, &t->stop);
! 867: ADDTIMEVAL(&t->start, &when);
! 868: t->running = 1;
! 869: break;
! 870: case TMR_TEMPO:
! 871: /* parm is ticks per minute / timebase */
! 872: if (parm < 8)
! 873: parm = 8;
! 874: if (parm > 360)
! 875: parm = 360;
! 876: t->tempo = parm;
! 877: RECALC_TICK(t);
! 878: break;
! 879: case TMR_ECHO:
! 880: error = seq_input_event(sc, b);
! 881: break;
! 882: case TMR_RESET:
! 883: t->last = 0;
! 884: microtime(&t->start);
! 885: break;
! 886: default:
! 887: DPRINTF(("seq_timer: unknown %02x\n", cmd));
! 888: error = EINVAL;
! 889: break;
! 890: }
! 891: return (error);
! 892: }
! 893:
! 894: int
! 895: seq_do_fullsize(struct sequencer_softc *sc, seq_event_rec *b, struct uio *uio)
! 896: {
! 897: struct sysex_info sysex;
! 898: u_int dev;
! 899:
! 900: #ifdef DIAGNOSTIC
! 901: if (sizeof(seq_event_rec) != SEQ_SYSEX_HDRSIZE) {
! 902: printf("seq_do_fullsize: sysex size ??\n");
! 903: return (EINVAL);
! 904: }
! 905: #endif
! 906: memcpy(&sysex, b, sizeof sysex);
! 907: dev = sysex.device_no;
! 908: DPRINTFN(2, ("seq_do_fullsize: fmt=%04x, dev=%d, len=%d\n",
! 909: sysex.key, dev, sysex.len));
! 910: return (midiseq_loadpatch(sc->devs[dev], &sysex, uio));
! 911: }
! 912:
! 913: /* Convert an old sequencer event to a new one. */
! 914: int
! 915: seq_to_new(seq_event_rec *ev, struct uio *uio)
! 916: {
! 917: int cmd, chan, note, parm;
! 918: u_int32_t delay;
! 919: int error;
! 920:
! 921: cmd = SEQ_CMD(ev);
! 922: chan = ev->arr[1];
! 923: note = ev->arr[2];
! 924: parm = ev->arr[3];
! 925: DPRINTFN(3, ("seq_to_new: 0x%02x %d %d %d\n", cmd, chan, note, parm));
! 926:
! 927: if (cmd >= 0x80) {
! 928: /* Fill the event record */
! 929: if (uio->uio_resid >= sizeof *ev - SEQOLD_CMDSIZE) {
! 930: error = uiomove(&ev->arr[SEQOLD_CMDSIZE],
! 931: sizeof *ev - SEQOLD_CMDSIZE, uio);
! 932: if (error)
! 933: return (error);
! 934: } else
! 935: return (EINVAL);
! 936: }
! 937:
! 938: switch(cmd) {
! 939: case SEQOLD_NOTEOFF:
! 940: note = 255;
! 941: SEQ_ECMD(ev) = MIDI_NOTEOFF;
! 942: goto onoff;
! 943: case SEQOLD_NOTEON:
! 944: SEQ_ECMD(ev) = MIDI_NOTEON;
! 945: onoff:
! 946: SEQ_CMD(ev) = SEQ_CHN_VOICE;
! 947: SEQ_EDEV(ev) = 0;
! 948: SEQ_ECHAN(ev) = chan;
! 949: SEQ_ENOTE(ev) = note;
! 950: SEQ_EPARM(ev) = parm;
! 951: break;
! 952: case SEQOLD_WAIT:
! 953: delay = *(u_int32_t *)ev->arr >> 8;
! 954: SEQ_CMD(ev) = SEQ_TIMING;
! 955: SEQ_TCMD(ev) = TMR_WAIT_REL;
! 956: *(u_int32_t *)&ev->arr[4] = delay;
! 957: break;
! 958: case SEQOLD_SYNCTIMER:
! 959: SEQ_CMD(ev) = SEQ_TIMING;
! 960: SEQ_TCMD(ev) = TMR_RESET;
! 961: break;
! 962: case SEQOLD_PGMCHANGE:
! 963: SEQ_ECMD(ev) = MIDI_PGM_CHANGE;
! 964: SEQ_CMD(ev) = SEQ_CHN_COMMON;
! 965: SEQ_EDEV(ev) = 0;
! 966: SEQ_ECHAN(ev) = chan;
! 967: SEQ_EP1(ev) = note;
! 968: break;
! 969: case SEQOLD_MIDIPUTC:
! 970: break; /* interpret in normal mode */
! 971: case SEQOLD_ECHO:
! 972: case SEQOLD_PRIVATE:
! 973: case SEQOLD_EXTENDED:
! 974: default:
! 975: DPRINTF(("seq_to_new: not impl 0x%02x\n", cmd));
! 976: return (EINVAL);
! 977: /* In case new events show up */
! 978: case SEQ_TIMING:
! 979: case SEQ_CHN_VOICE:
! 980: case SEQ_CHN_COMMON:
! 981: case SEQ_FULLSIZE:
! 982: break;
! 983: }
! 984: return (0);
! 985: }
! 986:
! 987: /**********************************************/
! 988:
! 989: void
! 990: midiseq_in(struct midi_dev *md, u_char *msg, int len)
! 991: {
! 992: int unit = md->unit;
! 993: seq_event_rec ev;
! 994: int status, chan;
! 995:
! 996: DPRINTFN(2, ("midiseq_in: %p %02x %02x %02x\n",
! 997: md, msg[0], msg[1], msg[2]));
! 998:
! 999: status = MIDI_GET_STATUS(msg[0]);
! 1000: chan = MIDI_GET_CHAN(msg[0]);
! 1001: switch (status) {
! 1002: case MIDI_NOTEON:
! 1003: if (msg[2] == 0) {
! 1004: status = MIDI_NOTEOFF;
! 1005: msg[2] = MIDI_HALF_VEL;
! 1006: }
! 1007: /* FALLTHROUGH */
! 1008: case MIDI_NOTEOFF:
! 1009: case MIDI_KEY_PRESSURE:
! 1010: SEQ_MK_CHN_VOICE(&ev, unit, status, chan, msg[1], msg[2]);
! 1011: break;
! 1012: case MIDI_CTL_CHANGE:
! 1013: SEQ_MK_CHN_COMMON(&ev, unit, status, chan, msg[1], 0, msg[2]);
! 1014: break;
! 1015: case MIDI_PGM_CHANGE:
! 1016: case MIDI_CHN_PRESSURE:
! 1017: SEQ_MK_CHN_COMMON(&ev, unit, status, chan, msg[1], 0, 0);
! 1018: break;
! 1019: case MIDI_PITCH_BEND:
! 1020: SEQ_MK_CHN_COMMON(&ev, unit, status, chan, 0, 0,
! 1021: (msg[1] & 0x7f) | ((msg[2] & 0x7f) << 7));
! 1022: break;
! 1023: default:
! 1024: return;
! 1025: }
! 1026: seq_event_intr(md->seq, &ev);
! 1027: }
! 1028:
! 1029: struct midi_dev *
! 1030: midiseq_open(int unit, int flags)
! 1031: {
! 1032: extern struct cfdriver midi_cd;
! 1033: int error;
! 1034: struct midi_dev *md;
! 1035: struct midi_softc *sc;
! 1036: struct midi_info mi;
! 1037:
! 1038: DPRINTFN(2, ("midiseq_open: %d %d\n", unit, flags));
! 1039: error = midiopen(makedev(0, unit), flags, 0, 0);
! 1040: if (error)
! 1041: return (0);
! 1042: sc = midi_cd.cd_devs[unit];
! 1043: sc->seqopen = 1;
! 1044: md = malloc(sizeof *md, M_DEVBUF, M_WAITOK);
! 1045: sc->seq_md = md;
! 1046: memset(md, 0, sizeof *md);
! 1047: md->msc = sc;
! 1048: midi_getinfo(makedev(0, unit), &mi);
! 1049: md->unit = unit;
! 1050: md->name = mi.name;
! 1051: md->subtype = 0;
! 1052: md->nr_voices = 128; /* XXX */
! 1053: md->instr_bank_size = 128; /* XXX */
! 1054: if (mi.props & MIDI_PROP_CAN_INPUT)
! 1055: md->capabilities |= SYNTH_CAP_INPUT;
! 1056: return (md);
! 1057: }
! 1058:
! 1059: void
! 1060: midiseq_close(struct midi_dev *md)
! 1061: {
! 1062: DPRINTFN(2, ("midiseq_close: %d\n", md->unit));
! 1063: midiclose(makedev(0, md->unit), 0, 0, 0);
! 1064: free(md, M_DEVBUF);
! 1065: }
! 1066:
! 1067: void
! 1068: midiseq_reset(struct midi_dev *md)
! 1069: {
! 1070: /* XXX send GM reset? */
! 1071: DPRINTFN(3, ("midiseq_reset: %d\n", md->unit));
! 1072: }
! 1073:
! 1074: int
! 1075: midiseq_out(struct midi_dev *md, u_char *buf, u_int cc, int chk)
! 1076: {
! 1077: DPRINTFN(5, ("midiseq_out: m=%p, unit=%d, buf[0]=0x%02x, cc=%d\n",
! 1078: md->msc, md->unit, buf[0], cc));
! 1079:
! 1080: /* The MIDI "status" byte does not have to be repeated. */
! 1081: if (chk && md->last_cmd == buf[0])
! 1082: buf++, cc--;
! 1083: else
! 1084: md->last_cmd = buf[0];
! 1085: return (midi_writebytes(md->unit, buf, cc));
! 1086: }
! 1087:
! 1088: int
! 1089: midiseq_noteon(struct midi_dev *md, int chan, int note, int vel)
! 1090: {
! 1091: u_char buf[3];
! 1092:
! 1093: DPRINTFN(6, ("midiseq_noteon 0x%02x %d %d\n",
! 1094: MIDI_NOTEON | chan, note, vel));
! 1095: if (chan < 0 || chan > 15 ||
! 1096: note < 0 || note > 127)
! 1097: return (EINVAL);
! 1098: if (vel < 0) vel = 0;
! 1099: if (vel > 127) vel = 127;
! 1100: buf[0] = MIDI_NOTEON | chan;
! 1101: buf[1] = note;
! 1102: buf[2] = vel;
! 1103: return (midiseq_out(md, buf, 3, 1));
! 1104: }
! 1105:
! 1106: int
! 1107: midiseq_noteoff(struct midi_dev *md, int chan, int note, int vel)
! 1108: {
! 1109: u_char buf[3];
! 1110:
! 1111: if (chan < 0 || chan > 15 ||
! 1112: note < 0 || note > 127)
! 1113: return (EINVAL);
! 1114: if (vel < 0) vel = 0;
! 1115: if (vel > 127) vel = 127;
! 1116: buf[0] = MIDI_NOTEOFF | chan;
! 1117: buf[1] = note;
! 1118: buf[2] = vel;
! 1119: return (midiseq_out(md, buf, 3, 1));
! 1120: }
! 1121:
! 1122: int
! 1123: midiseq_keypressure(struct midi_dev *md, int chan, int note, int vel)
! 1124: {
! 1125: u_char buf[3];
! 1126:
! 1127: if (chan < 0 || chan > 15 ||
! 1128: note < 0 || note > 127)
! 1129: return (EINVAL);
! 1130: if (vel < 0) vel = 0;
! 1131: if (vel > 127) vel = 127;
! 1132: buf[0] = MIDI_KEY_PRESSURE | chan;
! 1133: buf[1] = note;
! 1134: buf[2] = vel;
! 1135: return (midiseq_out(md, buf, 3, 1));
! 1136: }
! 1137:
! 1138: int
! 1139: midiseq_pgmchange(struct midi_dev *md, int chan, int parm)
! 1140: {
! 1141: u_char buf[2];
! 1142:
! 1143: if (chan < 0 || chan > 15 ||
! 1144: parm < 0 || parm > 127)
! 1145: return (EINVAL);
! 1146: buf[0] = MIDI_PGM_CHANGE | chan;
! 1147: buf[1] = parm;
! 1148: return (midiseq_out(md, buf, 2, 1));
! 1149: }
! 1150:
! 1151: int
! 1152: midiseq_chnpressure(struct midi_dev *md, int chan, int parm)
! 1153: {
! 1154: u_char buf[2];
! 1155:
! 1156: if (chan < 0 || chan > 15 ||
! 1157: parm < 0 || parm > 127)
! 1158: return (EINVAL);
! 1159: buf[0] = MIDI_CHN_PRESSURE | chan;
! 1160: buf[1] = parm;
! 1161: return (midiseq_out(md, buf, 2, 1));
! 1162: }
! 1163:
! 1164: int
! 1165: midiseq_ctlchange(struct midi_dev *md, int chan, int parm, int w14)
! 1166: {
! 1167: u_char buf[3];
! 1168:
! 1169: if (chan < 0 || chan > 15 ||
! 1170: parm < 0 || parm > 127)
! 1171: return (EINVAL);
! 1172: buf[0] = MIDI_CTL_CHANGE | chan;
! 1173: buf[1] = parm;
! 1174: buf[2] = w14 & 0x7f;
! 1175: return (midiseq_out(md, buf, 3, 1));
! 1176: }
! 1177:
! 1178: int
! 1179: midiseq_pitchbend(struct midi_dev *md, int chan, int parm)
! 1180: {
! 1181: u_char buf[3];
! 1182:
! 1183: if (chan < 0 || chan > 15)
! 1184: return (EINVAL);
! 1185: buf[0] = MIDI_PITCH_BEND | chan;
! 1186: buf[1] = parm & 0x7f;
! 1187: buf[2] = (parm >> 7) & 0x7f;
! 1188: return (midiseq_out(md, buf, 3, 1));
! 1189: }
! 1190:
! 1191: int
! 1192: midiseq_loadpatch(struct midi_dev *md, struct sysex_info *sysex, struct uio *uio)
! 1193: {
! 1194: u_char c, buf[128];
! 1195: int i, cc, error;
! 1196:
! 1197: if (sysex->key != SEQ_SYSEX_PATCH) {
! 1198: DPRINTFN(-1,("midiseq_loadpatch: bad patch key 0x%04x\n",
! 1199: sysex->key));
! 1200: return (EINVAL);
! 1201: }
! 1202: if (uio->uio_resid < sysex->len)
! 1203: /* adjust length, should be an error */
! 1204: sysex->len = uio->uio_resid;
! 1205:
! 1206: DPRINTFN(2, ("midiseq_loadpatch: len=%d\n", sysex->len));
! 1207: if (sysex->len == 0)
! 1208: return (EINVAL);
! 1209: error = uiomove(&c, 1, uio);
! 1210: if (error)
! 1211: return error;
! 1212: if (c != MIDI_SYSEX_START) /* must start like this */
! 1213: return (EINVAL);
! 1214: error = midiseq_out(md, &c, 1, 0);
! 1215: if (error)
! 1216: return (error);
! 1217: --sysex->len;
! 1218: while (sysex->len > 0) {
! 1219: cc = sysex->len;
! 1220: if (cc > sizeof buf)
! 1221: cc = sizeof buf;
! 1222: error = uiomove(buf, cc, uio);
! 1223: if (error)
! 1224: break;
! 1225: for(i = 0; i < cc && !MIDI_IS_STATUS(buf[i]); i++)
! 1226: ;
! 1227: error = midiseq_out(md, buf, i, 0);
! 1228: if (error)
! 1229: break;
! 1230: sysex->len -= i;
! 1231: if (i != cc)
! 1232: break;
! 1233: }
! 1234: /* Any leftover data in uio is rubbish;
! 1235: * the SYSEX should be one write ending in SYSEX_END.
! 1236: */
! 1237: uio->uio_resid = 0;
! 1238: c = MIDI_SYSEX_END;
! 1239: return (midiseq_out(md, &c, 1, 0));
! 1240: }
! 1241:
! 1242: int
! 1243: midiseq_putc(struct midi_dev *md, int data)
! 1244: {
! 1245: u_char c = data;
! 1246: DPRINTFN(4,("midiseq_putc: 0x%02x\n", data));
! 1247: return (midiseq_out(md, &c, 1, 0));
! 1248: }
! 1249:
! 1250: #include "midi.h"
! 1251: #if NMIDI == 0
! 1252: /*
! 1253: * If someone has a sequencer, but no midi devices there will
! 1254: * be unresolved references, so we provide little stubs.
! 1255: */
! 1256:
! 1257: int
! 1258: midi_unit_count()
! 1259: {
! 1260: return (0);
! 1261: }
! 1262:
! 1263: int
! 1264: midiopen(dev_t dev, int flags, int ifmt, struct proc *p)
! 1265: {
! 1266: return (ENXIO);
! 1267: }
! 1268:
! 1269: struct cfdriver midi_cd;
! 1270:
! 1271: void
! 1272: midi_getinfo(dev_t dev, struct midi_info *mi)
! 1273: {
! 1274: }
! 1275:
! 1276: int
! 1277: midiclose(dev_t dev, int flags, int ifmt, struct proc *p)
! 1278: {
! 1279: return (ENXIO);
! 1280: }
! 1281:
! 1282: int
! 1283: midi_writebytes(int unit, u_char *buf, int cc)
! 1284: {
! 1285: return (ENXIO);
! 1286: }
! 1287: #endif /* NMIDI == 0 */
! 1288:
! 1289: #endif /* NSEQUENCER > 0 */
! 1290:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sequencer.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev