root/dev/ic/opl.c

DEFINITIONS

1. opl_attach
2. opl_probe_command
3. opl_command
4. opl_find
5. opl_set_op_reg
6. opl_set_ch_reg
7. opl_load_patch
8. opl_get_block_fnum
9. opl_reset
10. oplsyn_open
11. oplsyn_close
12. oplsyn_getinfo
13. oplsyn_reset
14. opl_calc_vol
15. oplsyn_noteon
16. oplsyn_noteoff
17. oplsyn_keypressure
18. oplsyn_ctlchange
19. oplsyn_pitchbend
20. oplsyn_loadpatch

    1 /*      $OpenBSD: opl.c,v 1.8 2006/07/27 05:55:00 miod Exp $    */
    2 /*      $NetBSD: opl.c,v 1.7 1998/12/08 14:26:56 augustss Exp $ */
    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  */
   40 /*
   41  * The OPL3 (YMF262) manual can be found at
   42  * ftp://ftp.yamahayst.com/pub/Fax_Back_Doc/Sound/YMF262.PDF
   43  */
   45 #include <sys/param.h>
   46 #include <sys/systm.h>
   47 #include <sys/errno.h>
   48 #include <sys/ioctl.h>
   49 #include <sys/syslog.h>
   50 #include <sys/device.h>
   51 #include <sys/selinfo.h>
   53 #include <machine/cpu.h>
   54 #include <machine/bus.h>
   56 #include <sys/audioio.h>
   57 #include <sys/midiio.h>
   58 #include <dev/audio_if.h>
   60 #include <dev/midi_if.h>
   61 #include <dev/midivar.h>
   62 #include <dev/midisynvar.h>
   64 #include <dev/ic/oplreg.h>
   65 #include <dev/ic/oplvar.h>
   67 #ifdef AUDIO_DEBUG
   68 #define DPRINTF(x)      if (opldebug) printf x
   69 #define DPRINTFN(n,x)   if (opldebug >= (n)) printf x
   70 int     opldebug = 0;
   71 #else
   72 #define DPRINTF(x)
   73 #define DPRINTFN(n,x)
   74 #endif
   76 struct real_voice {
u_int8_t voice_num;
u_int8_t voice_mode; /* 0=unavailable, 2=2 OP, 4=4 OP */
u_int8_t iooffs; /* I/O port (left or right side) */
u_int8_t op[4]; /* Operator offsets */
   81 };
   83 const struct opl_voice voicetab[] = {
   84 /*       No    I/O offs         OP1     OP2     OP3   OP4       */
   85 /*      ---------------------------------------------------     */
   86         { 0,   OPL_L,   {0x00,  0x03,   0x08, 0x0b}},
   87         { 1,   OPL_L,   {0x01,  0x04,   0x09, 0x0c}},
   88         { 2,   OPL_L,   {0x02,  0x05,   0x0a, 0x0d}},
   90         { 3,   OPL_L,   {0x08,  0x0b,   0x00, 0x00}},
   91         { 4,   OPL_L,   {0x09,  0x0c,   0x00, 0x00}},
   92         { 5,   OPL_L,   {0x0a,  0x0d,   0x00, 0x00}},
   94         { 6,   OPL_L,   {0x10,  0x13,   0x00, 0x00}},
   95         { 7,   OPL_L,   {0x11,  0x14,   0x00, 0x00}},
   96         { 8,   OPL_L,   {0x12,  0x15,   0x00, 0x00}},
   98         { 0,   OPL_R,   {0x00,  0x03,   0x08, 0x0b}},
   99         { 1,   OPL_R,   {0x01,  0x04,   0x09, 0x0c}},
  100         { 2,   OPL_R,   {0x02,  0x05,   0x0a, 0x0d}},
  101         { 3,   OPL_R,   {0x08,  0x0b,   0x00, 0x00}},
  102         { 4,   OPL_R,   {0x09,  0x0c,   0x00, 0x00}},
  103         { 5,   OPL_R,   {0x0a,  0x0d,   0x00, 0x00}},
  105         { 6,   OPL_R,   {0x10,  0x13,   0x00, 0x00}},
  106         { 7,   OPL_R,   {0x11,  0x14,   0x00, 0x00}},
  107         { 8,   OPL_R,   {0x12,  0x15,   0x00, 0x00}}
  108 };
  110 static void opl_probe_command(struct opl_attach_arg *, int, int);
  111 static void opl_command(struct opl_softc *, int, int, int);
  112 void opl_reset(struct opl_softc *);
  113 void opl_freq_to_fnum (int freq, int *block, int *fnum);
  115 int oplsyn_open(midisyn *ms, int);
  116 void oplsyn_close(midisyn *);
  117 void oplsyn_reset(void *);
  118 void oplsyn_noteon(midisyn *, u_int32_t, u_int32_t, u_int32_t);
  119 void oplsyn_noteoff(midisyn *, u_int32_t, u_int32_t, u_int32_t);
  120 void oplsyn_keypressure(midisyn *, u_int32_t, u_int32_t, u_int32_t);
  121 void oplsyn_ctlchange(midisyn *, u_int32_t, u_int32_t, u_int32_t);
  122 void oplsyn_pitchbend(midisyn *, u_int32_t, u_int32_t, u_int32_t);
  123 void oplsyn_loadpatch(midisyn *, struct sysex_info *, struct uio *);
  126 void opl_set_op_reg(struct opl_softc *, int, int, int, u_char);
  127 void opl_set_ch_reg(struct opl_softc *, int, int, u_char);
  128 void opl_load_patch(struct opl_softc *, int);
u_int32_t opl_get_block_fnum(int freq);
  130 int opl_calc_vol(int regbyte, int volume, int main_vol);
  132 struct cfdriver opl_cd = {
NULL, "opl", DV_DULL
  134 };
  136 struct midisyn_methods opl3_midi = {
oplsyn_open,
oplsyn_close,
  139         0,
  140         0,
oplsyn_noteon,
oplsyn_noteoff,
oplsyn_keypressure,
oplsyn_ctlchange,
  145         0,
  146         0,
oplsyn_pitchbend,
  148         0
  149 };
  151 void
opl_attach(sc)
  153         struct opl_softc *sc;
  154 {
  155         int i;
  156         struct opl_attach_arg oaa;
oaa.iot = sc->iot;
oaa.ioh = sc->ioh;
oaa.offs = sc->offs;
oaa.done = 0;
  163         if ((sc->model = opl_find(&oaa)) == 0) {
printf("\nopl: find failed\n");
  165                 return;
  166         }
sc->syn.mets = &opl3_midi;
snprintf(sc->syn.name, sizeof sc->syn.name, "%sYamaha OPL%d",
sc->syn.name, sc->model);
sc->syn.data = sc;
sc->syn.nvoice = sc->model == OPL_2 ? OPL2_NVOICE : OPL3_NVOICE;
sc->syn.flags =  MS_DOALLOC | MS_FREQXLATE;
midisyn_attach(&sc->mididev, &sc->syn);
  176         /* Set up voice table */
  177         for (i = 0; i < OPL3_NVOICE; i++)
sc->voices[i] = voicetab[i];
opl_reset(sc);
printf(": model OPL%d\n", sc->model);
midi_attach_mi(&midisyn_hw_if, &sc->syn, &sc->mididev.dev);
  185 }
  187 static void
opl_probe_command(oaa, addr, data)
  189         struct opl_attach_arg *oaa;
  190         int addr, data;
  191 {
DPRINTFN(4, ("opl_probe_command: addr=0x%02x data=0x%02x\n", 
addr, data));
bus_space_write_1(oaa->iot, oaa->ioh, OPL_ADDR + OPL_L + oaa->offs,
addr);
delay(10);
bus_space_write_1(oaa->iot, oaa->ioh, OPL_DATA + OPL_L + oaa->offs,
data);
delay(30);
  200 }
  202 static void
opl_command(sc, offs, addr, data)
  204         struct opl_softc *sc;
  205         int offs;
  206         int addr, data;
  207 {
DPRINTFN(4, ("opl_command: sc=%p, offs=%d addr=0x%02x data=0x%02x\n", 
sc, offs, addr, data));
offs += sc->offs;
bus_space_write_1(sc->iot, sc->ioh, OPL_ADDR+offs, addr);
  212         if (sc->model == OPL_2)
delay(10);
  214         else
delay(6);
bus_space_write_1(sc->iot, sc->ioh, OPL_DATA+offs, data);
  217         if (sc->model == OPL_2)
delay(30);
  219         else
delay(6);
  221 }
  223 int
opl_find(oaa)
  225         struct opl_attach_arg *oaa;
  226 {
u_int8_t status1, status2;
  228         int model;
DPRINTFN(2,("opl_find: ioh=0x%x\n", (int)oaa->ioh));
model = OPL_2;  /* worst case assumption */
  233         /* Reset timers 1 and 2 */
opl_probe_command(oaa, OPL_TIMER_CONTROL, 
OPL_TIMER1_MASK | OPL_TIMER2_MASK);
  236         /* Reset the IRQ of the FM chip */
opl_probe_command(oaa, OPL_TIMER_CONTROL, OPL_IRQ_RESET);
  239         /* get status bits */
status1 = bus_space_read_1(oaa->iot, oaa->ioh,
OPL_STATUS + OPL_L + oaa->offs);
opl_probe_command(oaa, OPL_TIMER1, -2); /* wait 2 ticks */
opl_probe_command(oaa, OPL_TIMER_CONTROL, /* start timer1 */
OPL_TIMER1_START | OPL_TIMER2_MASK);
delay(1000);            /* wait for timer to expire */
  248         /* get status bits again */
status2 = bus_space_read_1(oaa->iot, oaa->ioh,
OPL_STATUS + OPL_L + oaa->offs);
opl_probe_command(oaa, OPL_TIMER_CONTROL, 
OPL_TIMER1_MASK | OPL_TIMER2_MASK);
opl_probe_command(oaa, OPL_TIMER_CONTROL, OPL_IRQ_RESET);
DPRINTFN(2,("opl_find: %02x %02x\n", status1, status2));
  258         if ((status1 & OPL_STATUS_MASK) != 0 ||
  259             (status2 & OPL_STATUS_MASK) != (OPL_STATUS_IRQ | OPL_STATUS_FT1))
  260                 return (0);
  262         switch(status1) {
  263         case 0x00:
  264         case 0x0f:
model = OPL_3;
  266                 break;
  267         case 0x06:
model = OPL_2;
  269                 break;
  270         default:
  271                 return 0;
  272         }
DPRINTFN(2,("opl_find: OPL%d at 0x%x detected\n", 
model, (int)oaa->ioh));
  276         return (model);
  277 }
  279 void 
opl_set_op_reg(sc, base, voice, op, value)
  281         struct opl_softc *sc;
  282         int base;
  283         int voice;
  284         int op;
u_char value;
  286 {
  287         struct opl_voice *v = &sc->voices[voice];
opl_command(sc, v->iooffs, base + v->op[op], value);
  289 }
  291 void 
opl_set_ch_reg(sc, base, voice, value)
  293         struct opl_softc *sc;
  294         int base;
  295         int voice;
u_char value;
  297 {
  298         struct opl_voice *v = &sc->voices[voice];
opl_command(sc, v->iooffs, base + v->voiceno, value);
  300 }
  303 void 
opl_load_patch(sc, v)
  305         struct opl_softc *sc;
  306         int v;
  307 {
  308         const struct opl_operators *p = sc->voices[v].patch;
opl_set_op_reg(sc, OPL_AM_VIB,          v, 0, p->ops[OO_CHARS+0]);
opl_set_op_reg(sc, OPL_AM_VIB,          v, 1, p->ops[OO_CHARS+1]);
opl_set_op_reg(sc, OPL_KSL_LEVEL,       v, 0, p->ops[OO_KSL_LEV+0]);
opl_set_op_reg(sc, OPL_KSL_LEVEL,       v, 1, p->ops[OO_KSL_LEV+1]);
opl_set_op_reg(sc, OPL_ATTACK_DECAY,    v, 0, p->ops[OO_ATT_DEC+0]);
opl_set_op_reg(sc, OPL_ATTACK_DECAY,    v, 1, p->ops[OO_ATT_DEC+1]);
opl_set_op_reg(sc, OPL_SUSTAIN_RELEASE, v, 0, p->ops[OO_SUS_REL+0]);
opl_set_op_reg(sc, OPL_SUSTAIN_RELEASE, v, 1, p->ops[OO_SUS_REL+1]);
opl_set_op_reg(sc, OPL_WAVE_SELECT,     v, 0, p->ops[OO_WAV_SEL+0]);
opl_set_op_reg(sc, OPL_WAVE_SELECT,     v, 1, p->ops[OO_WAV_SEL+1]);
opl_set_ch_reg(sc, OPL_FEEDBACK_CONNECTION, v, p->ops[OO_FB_CONN]);
  321 }
  323 #define OPL_FNUM_FAIL 0xffff
u_int32_t
opl_get_block_fnum(freq)
  326         int freq;
  327 {
u_int32_t f_num = freq / 3125;
u_int32_t  block = 0;
  331         while (f_num > 0x3FF && block < 8) {
block++;
f_num >>= 1;
  334         }
  336         if (block > 7)
  337                 return (OPL_FNUM_FAIL);
  338         else
  339                 return ((block << 10) | f_num);
  340   }
  343 void
opl_reset(sc)
  345         struct opl_softc *sc;
  346 {
  347         int i;
  349         for (i = 1; i <= OPL_MAXREG; i++)
opl_command(sc, OPL_L, OPL_KEYON_BLOCK + i, 0);
opl_command(sc, OPL_L, OPL_TEST, OPL_ENABLE_WAVE_SELECT);
opl_command(sc, OPL_L, OPL_PERCUSSION, 0);
  354         if (sc->model == OPL_3) {
opl_command(sc, OPL_R, OPL_MODE, OPL3_ENABLE);
opl_command(sc, OPL_R,OPL_CONNECTION_SELECT,OPL_NOCONNECTION);
  357         }
sc->volume = 64;
  360 }
  362 int
oplsyn_open(ms, flags)
midisyn *ms;
  365         int flags;
  366 {
  367         struct opl_softc *sc = ms->data;
DPRINTFN(2, ("oplsyn_open: %d\n", flags));
opl_reset(ms->data);
  372         if (sc->spkrctl)
sc->spkrctl(sc->spkrarg, 1);
  374         return (0);
  375 }
  377 void
oplsyn_close(ms)
midisyn *ms;
  380 {
  381         struct opl_softc *sc = ms->data;
DPRINTFN(2, ("oplsyn_close:\n"));
  385         /*opl_reset(ms->data);*/
  386         if (sc->spkrctl)
sc->spkrctl(sc->spkrarg, 0);
  388 }
  390 #if 0
  391 void
  392 oplsyn_getinfo(addr, sd)
  393         void *addr;
  394         struct synth_dev *sd;
  395 {
  396         struct opl_softc *sc = addr;
sd->name = sc->model == OPL_2 ? "Yamaha OPL2" : "Yamaha OPL3";
sd->type = SYNTH_TYPE_FM;
sd->subtype = sc->model == OPL_2 ? SYNTH_SUB_FM_TYPE_ADLIB 
  401                 : SYNTH_SUB_FM_TYPE_OPL3;
sd->capabilities = 0;
  403 }
  404 #endif
  406 void
oplsyn_reset(addr)
  408         void *addr;
  409 {
  410         struct opl_softc *sc = addr;
DPRINTFN(3, ("oplsyn_reset:\n"));
opl_reset(sc);
  413 }
int8_t opl_volume_table[128] =
  416     {-64, -48, -40, -35, -32, -29, -27, -26,
  417      -24, -23, -21, -20, -19, -18, -18, -17,
  418      -16, -15, -15, -14, -13, -13, -12, -12,
  419      -11, -11, -10, -10, -10, -9, -9, -8,
  420      -8, -8, -7, -7, -7, -6, -6, -6,
  421      -5, -5, -5, -5, -4, -4, -4, -4,
  422      -3, -3, -3, -3, -2, -2, -2, -2,
  423      -2, -1, -1, -1, -1, 0, 0, 0,
  424      0, 0, 0, 1, 1, 1, 1, 1,
  425      1, 2, 2, 2, 2, 2, 2, 2,
  426      3, 3, 3, 3, 3, 3, 3, 4,
  427      4, 4, 4, 4, 4, 4, 4, 5,
  428      5, 5, 5, 5, 5, 5, 5, 5,
  429      6, 6, 6, 6, 6, 6, 6, 6,
  430      6, 7, 7, 7, 7, 7, 7, 7,
  431      7, 7, 7, 8, 8, 8, 8, 8};
  433 int
opl_calc_vol(regbyte, volume, mainvol)
  435         int regbyte; 
  436         int volume;
  437         int mainvol;
  438 {
  439         int level = ~regbyte & OPL_TOTAL_LEVEL_MASK;
  441         if (mainvol > 127)
mainvol = 127;
volume = (volume * mainvol) / 127;
  446         if (level)
level += opl_volume_table[volume];
  449         if (level > OPL_TOTAL_LEVEL_MASK)
level = OPL_TOTAL_LEVEL_MASK;
  451         if (level < 0)
level = 0;
  454         return (~level & OPL_TOTAL_LEVEL_MASK);
  455 }
  457 void
oplsyn_noteon(ms, voice, freq, vel)
midisyn *ms;
u_int32_t voice, freq, vel;
  461 {
  462         struct opl_softc *sc = ms->data;
  463         struct opl_voice *v;
  464         const struct opl_operators *p;
u_int32_t block_fnum;
  466         int mult;
  467         int c_mult, m_mult;
u_int8_t chars0, chars1, ksl0, ksl1, fbc;
u_int8_t r20m, r20c, r40m, r40c, rA0, rB0;
u_int8_t vol0, vol1;
DPRINTFN(3, ("oplsyn_noteon: %p %d %d\n", sc, voice, 
MIDISYN_FREQ_TO_HZ(freq)));
  475 #ifdef DIAGNOSTIC
  476         if (voice < 0 || voice >= sc->syn.nvoice) {
printf("oplsyn_noteon: bad voice %d\n", voice);
  478                 return;
  479         }
  480 #endif
  481         /* Turn off old note */
opl_set_op_reg(sc, OPL_KSL_LEVEL,   voice, 0, 0xff);
opl_set_op_reg(sc, OPL_KSL_LEVEL,   voice, 1, 0xff);
opl_set_ch_reg(sc, OPL_KEYON_BLOCK, voice,    0);
v = &sc->voices[voice];
p = &opl2_instrs[MS_GETPGM(ms, voice)];
v->patch = p;
opl_load_patch(sc, voice);
mult = 1;
  493         for (;;) {
block_fnum = opl_get_block_fnum(freq / mult);
  495                 if (block_fnum != OPL_FNUM_FAIL)
  496                         break;
mult *= 2;
  498                 if (mult == 16)
mult = 15;
  500         }
chars0 = p->ops[OO_CHARS+0];
chars1 = p->ops[OO_CHARS+1];
m_mult = (chars0 & OPL_MULTIPLE_MASK) * mult;
c_mult = (chars1 & OPL_MULTIPLE_MASK) * mult;
  506         if ((block_fnum == OPL_FNUM_FAIL) || (m_mult > 15) || (c_mult > 15)) {
printf("oplsyn_noteon: frequence out of range %d\n",
MIDISYN_FREQ_TO_HZ(freq));
  509                 return;
  510         }
r20m = (chars0 &~ OPL_MULTIPLE_MASK) | m_mult;
r20c = (chars1 &~ OPL_MULTIPLE_MASK) | c_mult;
  514         /* 2 voice */
ksl0 = p->ops[OO_KSL_LEV+0];
ksl1 = p->ops[OO_KSL_LEV+1];
  517         if (p->ops[OO_FB_CONN] & 0x01) {
vol0 = opl_calc_vol(ksl0, vel, sc->volume);
vol1 = opl_calc_vol(ksl1, vel, sc->volume);
  520         } else {
vol0 = ksl0;
vol1 = opl_calc_vol(ksl1, vel, sc->volume);
  523         }
r40m = (ksl0 & OPL_KSL_MASK) | vol0;
r40c = (ksl1 & OPL_KSL_MASK) | vol1;
rA0  = block_fnum & 0xFF;
rB0  = (block_fnum >> 8) | OPL_KEYON_BIT;
v->rB0 = rB0;
fbc = p->ops[OO_FB_CONN];
  533         if (sc->model == OPL_3) {
fbc &= ~OPL_STEREO_BITS;
  535                 /* XXX use pan */
fbc |= OPL_VOICE_TO_LEFT | OPL_VOICE_TO_RIGHT;
  537         }
opl_set_ch_reg(sc, OPL_FEEDBACK_CONNECTION, voice, fbc);
opl_set_op_reg(sc, OPL_AM_VIB,      voice, 0, r20m);
opl_set_op_reg(sc, OPL_AM_VIB,      voice, 1, r20c);
opl_set_op_reg(sc, OPL_KSL_LEVEL,   voice, 0, r40m);
opl_set_op_reg(sc, OPL_KSL_LEVEL,   voice, 1, r40c);
opl_set_ch_reg(sc, OPL_FNUM_LOW,    voice,    rA0);
opl_set_ch_reg(sc, OPL_KEYON_BLOCK, voice,    rB0);
  546 }
  548 void
oplsyn_noteoff(ms, voice, note, vel)
midisyn *ms;
u_int32_t voice, note, vel;
  552 {
  553         struct opl_softc *sc = ms->data;
  554         struct opl_voice *v;
DPRINTFN(3, ("oplsyn_noteoff: %p %d %d\n", sc, voice, 
MIDISYN_FREQ_TO_HZ(note)));
  559 #ifdef DIAGNOSTIC
  560         if (voice < 0 || voice >= sc->syn.nvoice) {
printf("oplsyn_noteoff: bad voice %d\n", voice);
  562                 return;
  563         }
  564 #endif
v = &sc->voices[voice];
opl_set_ch_reg(sc, 0xB0, voice, v->rB0 & ~OPL_KEYON_BIT);
  567 }
  569 void
oplsyn_keypressure(ms, voice, note, vel)
midisyn *ms;
u_int32_t voice, note, vel;
  573 {
  574 #ifdef AUDIO_DEBUG
  575         struct opl_softc *sc = ms->data;
DPRINTFN(1, ("oplsyn_keypressure: %p %d\n", sc, note));
  577 #endif
  578 }
  580 void
oplsyn_ctlchange(ms, voice, parm, w14)
midisyn *ms;
u_int32_t voice, parm, w14;
  584 {
  585 #ifdef AUDIO_DEBUG
  586         struct opl_softc *sc = ms->data;
DPRINTFN(1, ("oplsyn_ctlchange: %p %d\n", sc, voice));
  588 #endif
  589 }
  591 void
oplsyn_pitchbend(ms, voice, parm, x)
midisyn *ms;
u_int32_t voice, parm, x;
  595 {
  596 #ifdef AUDIO_DEBUG
  597         struct opl_softc *sc = ms->data;
DPRINTFN(1, ("oplsyn_pitchbend: %p %d\n", sc, voice));
  599 #endif
  600 }
  602 void
oplsyn_loadpatch(ms, sysex, uio)
midisyn *ms;
  605         struct sysex_info *sysex;
  606         struct uio *uio;
  607 {
  608 #if 0
  609         struct opl_softc *sc = ms->data;
  610         struct sbi_instrument ins;
DPRINTFN(1, ("oplsyn_loadpatch: %p\n", sc));
memcpy(&ins, sysex, sizeof *sysex);
  615         if (uio->uio_resid >= sizeof ins - sizeof *sysex)
  616                 return EINVAL;
uiomove((char *)&ins + sizeof *sysex, sizeof ins - sizeof *sysex, uio);
  618         /* XXX */
  619 #endif
  620 }