Annotation of sys/dev/ic/opl.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 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: /*
! 41: * The OPL3 (YMF262) manual can be found at
! 42: * ftp://ftp.yamahayst.com/pub/Fax_Back_Doc/Sound/YMF262.PDF
! 43: */
! 44:
! 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>
! 52:
! 53: #include <machine/cpu.h>
! 54: #include <machine/bus.h>
! 55:
! 56: #include <sys/audioio.h>
! 57: #include <sys/midiio.h>
! 58: #include <dev/audio_if.h>
! 59:
! 60: #include <dev/midi_if.h>
! 61: #include <dev/midivar.h>
! 62: #include <dev/midisynvar.h>
! 63:
! 64: #include <dev/ic/oplreg.h>
! 65: #include <dev/ic/oplvar.h>
! 66:
! 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
! 75:
! 76: struct real_voice {
! 77: u_int8_t voice_num;
! 78: u_int8_t voice_mode; /* 0=unavailable, 2=2 OP, 4=4 OP */
! 79: u_int8_t iooffs; /* I/O port (left or right side) */
! 80: u_int8_t op[4]; /* Operator offsets */
! 81: };
! 82:
! 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}},
! 89:
! 90: { 3, OPL_L, {0x08, 0x0b, 0x00, 0x00}},
! 91: { 4, OPL_L, {0x09, 0x0c, 0x00, 0x00}},
! 92: { 5, OPL_L, {0x0a, 0x0d, 0x00, 0x00}},
! 93:
! 94: { 6, OPL_L, {0x10, 0x13, 0x00, 0x00}},
! 95: { 7, OPL_L, {0x11, 0x14, 0x00, 0x00}},
! 96: { 8, OPL_L, {0x12, 0x15, 0x00, 0x00}},
! 97:
! 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}},
! 104:
! 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: };
! 109:
! 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);
! 114:
! 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 *);
! 124:
! 125:
! 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);
! 129: u_int32_t opl_get_block_fnum(int freq);
! 130: int opl_calc_vol(int regbyte, int volume, int main_vol);
! 131:
! 132: struct cfdriver opl_cd = {
! 133: NULL, "opl", DV_DULL
! 134: };
! 135:
! 136: struct midisyn_methods opl3_midi = {
! 137: oplsyn_open,
! 138: oplsyn_close,
! 139: 0,
! 140: 0,
! 141: oplsyn_noteon,
! 142: oplsyn_noteoff,
! 143: oplsyn_keypressure,
! 144: oplsyn_ctlchange,
! 145: 0,
! 146: 0,
! 147: oplsyn_pitchbend,
! 148: 0
! 149: };
! 150:
! 151: void
! 152: opl_attach(sc)
! 153: struct opl_softc *sc;
! 154: {
! 155: int i;
! 156: struct opl_attach_arg oaa;
! 157:
! 158: oaa.iot = sc->iot;
! 159: oaa.ioh = sc->ioh;
! 160: oaa.offs = sc->offs;
! 161: oaa.done = 0;
! 162:
! 163: if ((sc->model = opl_find(&oaa)) == 0) {
! 164: printf("\nopl: find failed\n");
! 165: return;
! 166: }
! 167:
! 168: sc->syn.mets = &opl3_midi;
! 169: snprintf(sc->syn.name, sizeof sc->syn.name, "%sYamaha OPL%d",
! 170: sc->syn.name, sc->model);
! 171: sc->syn.data = sc;
! 172: sc->syn.nvoice = sc->model == OPL_2 ? OPL2_NVOICE : OPL3_NVOICE;
! 173: sc->syn.flags = MS_DOALLOC | MS_FREQXLATE;
! 174: midisyn_attach(&sc->mididev, &sc->syn);
! 175:
! 176: /* Set up voice table */
! 177: for (i = 0; i < OPL3_NVOICE; i++)
! 178: sc->voices[i] = voicetab[i];
! 179:
! 180: opl_reset(sc);
! 181:
! 182: printf(": model OPL%d\n", sc->model);
! 183:
! 184: midi_attach_mi(&midisyn_hw_if, &sc->syn, &sc->mididev.dev);
! 185: }
! 186:
! 187: static void
! 188: opl_probe_command(oaa, addr, data)
! 189: struct opl_attach_arg *oaa;
! 190: int addr, data;
! 191: {
! 192: DPRINTFN(4, ("opl_probe_command: addr=0x%02x data=0x%02x\n",
! 193: addr, data));
! 194: bus_space_write_1(oaa->iot, oaa->ioh, OPL_ADDR + OPL_L + oaa->offs,
! 195: addr);
! 196: delay(10);
! 197: bus_space_write_1(oaa->iot, oaa->ioh, OPL_DATA + OPL_L + oaa->offs,
! 198: data);
! 199: delay(30);
! 200: }
! 201:
! 202: static void
! 203: opl_command(sc, offs, addr, data)
! 204: struct opl_softc *sc;
! 205: int offs;
! 206: int addr, data;
! 207: {
! 208: DPRINTFN(4, ("opl_command: sc=%p, offs=%d addr=0x%02x data=0x%02x\n",
! 209: sc, offs, addr, data));
! 210: offs += sc->offs;
! 211: bus_space_write_1(sc->iot, sc->ioh, OPL_ADDR+offs, addr);
! 212: if (sc->model == OPL_2)
! 213: delay(10);
! 214: else
! 215: delay(6);
! 216: bus_space_write_1(sc->iot, sc->ioh, OPL_DATA+offs, data);
! 217: if (sc->model == OPL_2)
! 218: delay(30);
! 219: else
! 220: delay(6);
! 221: }
! 222:
! 223: int
! 224: opl_find(oaa)
! 225: struct opl_attach_arg *oaa;
! 226: {
! 227: u_int8_t status1, status2;
! 228: int model;
! 229:
! 230: DPRINTFN(2,("opl_find: ioh=0x%x\n", (int)oaa->ioh));
! 231: model = OPL_2; /* worst case assumption */
! 232:
! 233: /* Reset timers 1 and 2 */
! 234: opl_probe_command(oaa, OPL_TIMER_CONTROL,
! 235: OPL_TIMER1_MASK | OPL_TIMER2_MASK);
! 236: /* Reset the IRQ of the FM chip */
! 237: opl_probe_command(oaa, OPL_TIMER_CONTROL, OPL_IRQ_RESET);
! 238:
! 239: /* get status bits */
! 240: status1 = bus_space_read_1(oaa->iot, oaa->ioh,
! 241: OPL_STATUS + OPL_L + oaa->offs);
! 242:
! 243: opl_probe_command(oaa, OPL_TIMER1, -2); /* wait 2 ticks */
! 244: opl_probe_command(oaa, OPL_TIMER_CONTROL, /* start timer1 */
! 245: OPL_TIMER1_START | OPL_TIMER2_MASK);
! 246: delay(1000); /* wait for timer to expire */
! 247:
! 248: /* get status bits again */
! 249: status2 = bus_space_read_1(oaa->iot, oaa->ioh,
! 250: OPL_STATUS + OPL_L + oaa->offs);
! 251:
! 252: opl_probe_command(oaa, OPL_TIMER_CONTROL,
! 253: OPL_TIMER1_MASK | OPL_TIMER2_MASK);
! 254: opl_probe_command(oaa, OPL_TIMER_CONTROL, OPL_IRQ_RESET);
! 255:
! 256: DPRINTFN(2,("opl_find: %02x %02x\n", status1, status2));
! 257:
! 258: if ((status1 & OPL_STATUS_MASK) != 0 ||
! 259: (status2 & OPL_STATUS_MASK) != (OPL_STATUS_IRQ | OPL_STATUS_FT1))
! 260: return (0);
! 261:
! 262: switch(status1) {
! 263: case 0x00:
! 264: case 0x0f:
! 265: model = OPL_3;
! 266: break;
! 267: case 0x06:
! 268: model = OPL_2;
! 269: break;
! 270: default:
! 271: return 0;
! 272: }
! 273:
! 274: DPRINTFN(2,("opl_find: OPL%d at 0x%x detected\n",
! 275: model, (int)oaa->ioh));
! 276: return (model);
! 277: }
! 278:
! 279: void
! 280: opl_set_op_reg(sc, base, voice, op, value)
! 281: struct opl_softc *sc;
! 282: int base;
! 283: int voice;
! 284: int op;
! 285: u_char value;
! 286: {
! 287: struct opl_voice *v = &sc->voices[voice];
! 288: opl_command(sc, v->iooffs, base + v->op[op], value);
! 289: }
! 290:
! 291: void
! 292: opl_set_ch_reg(sc, base, voice, value)
! 293: struct opl_softc *sc;
! 294: int base;
! 295: int voice;
! 296: u_char value;
! 297: {
! 298: struct opl_voice *v = &sc->voices[voice];
! 299: opl_command(sc, v->iooffs, base + v->voiceno, value);
! 300: }
! 301:
! 302:
! 303: void
! 304: opl_load_patch(sc, v)
! 305: struct opl_softc *sc;
! 306: int v;
! 307: {
! 308: const struct opl_operators *p = sc->voices[v].patch;
! 309:
! 310: opl_set_op_reg(sc, OPL_AM_VIB, v, 0, p->ops[OO_CHARS+0]);
! 311: opl_set_op_reg(sc, OPL_AM_VIB, v, 1, p->ops[OO_CHARS+1]);
! 312: opl_set_op_reg(sc, OPL_KSL_LEVEL, v, 0, p->ops[OO_KSL_LEV+0]);
! 313: opl_set_op_reg(sc, OPL_KSL_LEVEL, v, 1, p->ops[OO_KSL_LEV+1]);
! 314: opl_set_op_reg(sc, OPL_ATTACK_DECAY, v, 0, p->ops[OO_ATT_DEC+0]);
! 315: opl_set_op_reg(sc, OPL_ATTACK_DECAY, v, 1, p->ops[OO_ATT_DEC+1]);
! 316: opl_set_op_reg(sc, OPL_SUSTAIN_RELEASE, v, 0, p->ops[OO_SUS_REL+0]);
! 317: opl_set_op_reg(sc, OPL_SUSTAIN_RELEASE, v, 1, p->ops[OO_SUS_REL+1]);
! 318: opl_set_op_reg(sc, OPL_WAVE_SELECT, v, 0, p->ops[OO_WAV_SEL+0]);
! 319: opl_set_op_reg(sc, OPL_WAVE_SELECT, v, 1, p->ops[OO_WAV_SEL+1]);
! 320: opl_set_ch_reg(sc, OPL_FEEDBACK_CONNECTION, v, p->ops[OO_FB_CONN]);
! 321: }
! 322:
! 323: #define OPL_FNUM_FAIL 0xffff
! 324: u_int32_t
! 325: opl_get_block_fnum(freq)
! 326: int freq;
! 327: {
! 328: u_int32_t f_num = freq / 3125;
! 329: u_int32_t block = 0;
! 330:
! 331: while (f_num > 0x3FF && block < 8) {
! 332: block++;
! 333: f_num >>= 1;
! 334: }
! 335:
! 336: if (block > 7)
! 337: return (OPL_FNUM_FAIL);
! 338: else
! 339: return ((block << 10) | f_num);
! 340: }
! 341:
! 342:
! 343: void
! 344: opl_reset(sc)
! 345: struct opl_softc *sc;
! 346: {
! 347: int i;
! 348:
! 349: for (i = 1; i <= OPL_MAXREG; i++)
! 350: opl_command(sc, OPL_L, OPL_KEYON_BLOCK + i, 0);
! 351:
! 352: opl_command(sc, OPL_L, OPL_TEST, OPL_ENABLE_WAVE_SELECT);
! 353: opl_command(sc, OPL_L, OPL_PERCUSSION, 0);
! 354: if (sc->model == OPL_3) {
! 355: opl_command(sc, OPL_R, OPL_MODE, OPL3_ENABLE);
! 356: opl_command(sc, OPL_R,OPL_CONNECTION_SELECT,OPL_NOCONNECTION);
! 357: }
! 358:
! 359: sc->volume = 64;
! 360: }
! 361:
! 362: int
! 363: oplsyn_open(ms, flags)
! 364: midisyn *ms;
! 365: int flags;
! 366: {
! 367: struct opl_softc *sc = ms->data;
! 368:
! 369: DPRINTFN(2, ("oplsyn_open: %d\n", flags));
! 370:
! 371: opl_reset(ms->data);
! 372: if (sc->spkrctl)
! 373: sc->spkrctl(sc->spkrarg, 1);
! 374: return (0);
! 375: }
! 376:
! 377: void
! 378: oplsyn_close(ms)
! 379: midisyn *ms;
! 380: {
! 381: struct opl_softc *sc = ms->data;
! 382:
! 383: DPRINTFN(2, ("oplsyn_close:\n"));
! 384:
! 385: /*opl_reset(ms->data);*/
! 386: if (sc->spkrctl)
! 387: sc->spkrctl(sc->spkrarg, 0);
! 388: }
! 389:
! 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;
! 397:
! 398: sd->name = sc->model == OPL_2 ? "Yamaha OPL2" : "Yamaha OPL3";
! 399: sd->type = SYNTH_TYPE_FM;
! 400: sd->subtype = sc->model == OPL_2 ? SYNTH_SUB_FM_TYPE_ADLIB
! 401: : SYNTH_SUB_FM_TYPE_OPL3;
! 402: sd->capabilities = 0;
! 403: }
! 404: #endif
! 405:
! 406: void
! 407: oplsyn_reset(addr)
! 408: void *addr;
! 409: {
! 410: struct opl_softc *sc = addr;
! 411: DPRINTFN(3, ("oplsyn_reset:\n"));
! 412: opl_reset(sc);
! 413: }
! 414:
! 415: 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};
! 432:
! 433: int
! 434: opl_calc_vol(regbyte, volume, mainvol)
! 435: int regbyte;
! 436: int volume;
! 437: int mainvol;
! 438: {
! 439: int level = ~regbyte & OPL_TOTAL_LEVEL_MASK;
! 440:
! 441: if (mainvol > 127)
! 442: mainvol = 127;
! 443:
! 444: volume = (volume * mainvol) / 127;
! 445:
! 446: if (level)
! 447: level += opl_volume_table[volume];
! 448:
! 449: if (level > OPL_TOTAL_LEVEL_MASK)
! 450: level = OPL_TOTAL_LEVEL_MASK;
! 451: if (level < 0)
! 452: level = 0;
! 453:
! 454: return (~level & OPL_TOTAL_LEVEL_MASK);
! 455: }
! 456:
! 457: void
! 458: oplsyn_noteon(ms, voice, freq, vel)
! 459: midisyn *ms;
! 460: 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;
! 465: u_int32_t block_fnum;
! 466: int mult;
! 467: int c_mult, m_mult;
! 468: u_int8_t chars0, chars1, ksl0, ksl1, fbc;
! 469: u_int8_t r20m, r20c, r40m, r40c, rA0, rB0;
! 470: u_int8_t vol0, vol1;
! 471:
! 472: DPRINTFN(3, ("oplsyn_noteon: %p %d %d\n", sc, voice,
! 473: MIDISYN_FREQ_TO_HZ(freq)));
! 474:
! 475: #ifdef DIAGNOSTIC
! 476: if (voice < 0 || voice >= sc->syn.nvoice) {
! 477: printf("oplsyn_noteon: bad voice %d\n", voice);
! 478: return;
! 479: }
! 480: #endif
! 481: /* Turn off old note */
! 482: opl_set_op_reg(sc, OPL_KSL_LEVEL, voice, 0, 0xff);
! 483: opl_set_op_reg(sc, OPL_KSL_LEVEL, voice, 1, 0xff);
! 484: opl_set_ch_reg(sc, OPL_KEYON_BLOCK, voice, 0);
! 485:
! 486: v = &sc->voices[voice];
! 487:
! 488: p = &opl2_instrs[MS_GETPGM(ms, voice)];
! 489: v->patch = p;
! 490: opl_load_patch(sc, voice);
! 491:
! 492: mult = 1;
! 493: for (;;) {
! 494: block_fnum = opl_get_block_fnum(freq / mult);
! 495: if (block_fnum != OPL_FNUM_FAIL)
! 496: break;
! 497: mult *= 2;
! 498: if (mult == 16)
! 499: mult = 15;
! 500: }
! 501:
! 502: chars0 = p->ops[OO_CHARS+0];
! 503: chars1 = p->ops[OO_CHARS+1];
! 504: m_mult = (chars0 & OPL_MULTIPLE_MASK) * mult;
! 505: c_mult = (chars1 & OPL_MULTIPLE_MASK) * mult;
! 506: if ((block_fnum == OPL_FNUM_FAIL) || (m_mult > 15) || (c_mult > 15)) {
! 507: printf("oplsyn_noteon: frequence out of range %d\n",
! 508: MIDISYN_FREQ_TO_HZ(freq));
! 509: return;
! 510: }
! 511: r20m = (chars0 &~ OPL_MULTIPLE_MASK) | m_mult;
! 512: r20c = (chars1 &~ OPL_MULTIPLE_MASK) | c_mult;
! 513:
! 514: /* 2 voice */
! 515: ksl0 = p->ops[OO_KSL_LEV+0];
! 516: ksl1 = p->ops[OO_KSL_LEV+1];
! 517: if (p->ops[OO_FB_CONN] & 0x01) {
! 518: vol0 = opl_calc_vol(ksl0, vel, sc->volume);
! 519: vol1 = opl_calc_vol(ksl1, vel, sc->volume);
! 520: } else {
! 521: vol0 = ksl0;
! 522: vol1 = opl_calc_vol(ksl1, vel, sc->volume);
! 523: }
! 524: r40m = (ksl0 & OPL_KSL_MASK) | vol0;
! 525: r40c = (ksl1 & OPL_KSL_MASK) | vol1;
! 526:
! 527: rA0 = block_fnum & 0xFF;
! 528: rB0 = (block_fnum >> 8) | OPL_KEYON_BIT;
! 529:
! 530: v->rB0 = rB0;
! 531:
! 532: fbc = p->ops[OO_FB_CONN];
! 533: if (sc->model == OPL_3) {
! 534: fbc &= ~OPL_STEREO_BITS;
! 535: /* XXX use pan */
! 536: fbc |= OPL_VOICE_TO_LEFT | OPL_VOICE_TO_RIGHT;
! 537: }
! 538: opl_set_ch_reg(sc, OPL_FEEDBACK_CONNECTION, voice, fbc);
! 539:
! 540: opl_set_op_reg(sc, OPL_AM_VIB, voice, 0, r20m);
! 541: opl_set_op_reg(sc, OPL_AM_VIB, voice, 1, r20c);
! 542: opl_set_op_reg(sc, OPL_KSL_LEVEL, voice, 0, r40m);
! 543: opl_set_op_reg(sc, OPL_KSL_LEVEL, voice, 1, r40c);
! 544: opl_set_ch_reg(sc, OPL_FNUM_LOW, voice, rA0);
! 545: opl_set_ch_reg(sc, OPL_KEYON_BLOCK, voice, rB0);
! 546: }
! 547:
! 548: void
! 549: oplsyn_noteoff(ms, voice, note, vel)
! 550: midisyn *ms;
! 551: u_int32_t voice, note, vel;
! 552: {
! 553: struct opl_softc *sc = ms->data;
! 554: struct opl_voice *v;
! 555:
! 556: DPRINTFN(3, ("oplsyn_noteoff: %p %d %d\n", sc, voice,
! 557: MIDISYN_FREQ_TO_HZ(note)));
! 558:
! 559: #ifdef DIAGNOSTIC
! 560: if (voice < 0 || voice >= sc->syn.nvoice) {
! 561: printf("oplsyn_noteoff: bad voice %d\n", voice);
! 562: return;
! 563: }
! 564: #endif
! 565: v = &sc->voices[voice];
! 566: opl_set_ch_reg(sc, 0xB0, voice, v->rB0 & ~OPL_KEYON_BIT);
! 567: }
! 568:
! 569: void
! 570: oplsyn_keypressure(ms, voice, note, vel)
! 571: midisyn *ms;
! 572: u_int32_t voice, note, vel;
! 573: {
! 574: #ifdef AUDIO_DEBUG
! 575: struct opl_softc *sc = ms->data;
! 576: DPRINTFN(1, ("oplsyn_keypressure: %p %d\n", sc, note));
! 577: #endif
! 578: }
! 579:
! 580: void
! 581: oplsyn_ctlchange(ms, voice, parm, w14)
! 582: midisyn *ms;
! 583: u_int32_t voice, parm, w14;
! 584: {
! 585: #ifdef AUDIO_DEBUG
! 586: struct opl_softc *sc = ms->data;
! 587: DPRINTFN(1, ("oplsyn_ctlchange: %p %d\n", sc, voice));
! 588: #endif
! 589: }
! 590:
! 591: void
! 592: oplsyn_pitchbend(ms, voice, parm, x)
! 593: midisyn *ms;
! 594: u_int32_t voice, parm, x;
! 595: {
! 596: #ifdef AUDIO_DEBUG
! 597: struct opl_softc *sc = ms->data;
! 598: DPRINTFN(1, ("oplsyn_pitchbend: %p %d\n", sc, voice));
! 599: #endif
! 600: }
! 601:
! 602: void
! 603: oplsyn_loadpatch(ms, sysex, uio)
! 604: 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;
! 611:
! 612: DPRINTFN(1, ("oplsyn_loadpatch: %p\n", sc));
! 613:
! 614: memcpy(&ins, sysex, sizeof *sysex);
! 615: if (uio->uio_resid >= sizeof ins - sizeof *sysex)
! 616: return EINVAL;
! 617: uiomove((char *)&ins + sizeof *sysex, sizeof ins - sizeof *sysex, uio);
! 618: /* XXX */
! 619: #endif
! 620: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to opl.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic