![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gus.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src / od-dos / sound|
Return to gus.c CVS log | Up to [UNIX Amiga Emulator] / uae / src / od-dos / sound |
1.1 ! root 1: /* ! 2: * UAE - The Un*x Amiga Emulator ! 3: * ! 4: * DOS Gravis Ultrasound interface. ! 5: * ! 6: * Version 0.3 ! 7: * ! 8: * (c) 1996,1997 Michael Sontheimer ! 9: * ! 10: * Please, do not change the code ! Write me an email with the bugfix, ! 11: * the improvement or the suggestion. ! 12: * My email address: [email protected] ! 13: * ! 14: */ ! 15: ! 16: ! 17: //#define DEBUG ! 18: ! 19: #include <stdlib.h> ! 20: #include <stdio.h> ! 21: #include <string.h> ! 22: #include <ctype.h> ! 23: #include <dos.h> ! 24: #include <pc.h> ! 25: #include <sys/farptr.h> ! 26: #include <dpmi.h> ! 27: #include <go32.h> ! 28: ! 29: ! 30: #include "sysconfig.h" ! 31: #include "sysdeps.h" ! 32: #include "sound/gus.h" ! 33: #include "sound/dma.h" ! 34: ! 35: ! 36: ! 37: #ifndef TRUE ! 38: #define TRUE 1 ! 39: #endif ! 40: #ifndef FALSE ! 41: #define FALSE 0 ! 42: #endif ! 43: ! 44: ! 45: // GUS Ports ! 46: ! 47: #define GUS_COMMAND 0x103 ! 48: #define GUS_DATAHI 0x105 ! 49: #define GUS_DATALO 0x104 ! 50: #define GUS_IRQSTATE 0x006 ! 51: #define GUS_TIMERCTRL 0x008 ! 52: #define GUS_TIMERDATA 0x009 ! 53: #define GUS_VOICE 0x102 ! 54: #define GUS_DRAM 0x107 ! 55: #define GUS_MIXER 0x000 ! 56: #define GUS_DMACTRL 0x00b // Beide Adressen sind identisch !!! ! 57: #define GUS_IRQCTRL 0x00b ! 58: #define GUS_REGISTERCTRL 0x00f ! 59: ! 60: // GUS Kommandos ! 61: ! 62: #define GUS_CMD_RESET 0x4c ! 63: #define GUS_CMD_DRAMDMACTRL 0x41 ! 64: #define GUS_CMD_DMASTARTADR 0x42 ! 65: #define GUS_CMD_DRAMIOADRLO 0x43 ! 66: #define GUS_CMD_DRAMIOADRHI 0x44 ! 67: #define GUS_CMD_TIMERCTRL 0x45 ! 68: #define GUS_CMD_COUNTER1 0x46 ! 69: #define GUS_CMD_COUNTER2 0x47 ! 70: #define GUS_CMD_SAMPLEFREQ 0x48 ! 71: #define GUS_CMD_SAMPLECTRL 0x49 ! 72: ! 73: #define GUS_CMD_VOICECTRLW 0x00 ! 74: #define GUS_CMD_FREQUCTRLW 0x01 ! 75: #define GUS_CMD_STARTHIW 0x02 ! 76: #define GUS_CMD_STARTLOW 0x03 ! 77: #define GUS_CMD_ENDHIW 0x04 ! 78: #define GUS_CMD_ENDLOW 0x05 ! 79: #define GUS_CMD_RAMPRATEW 0x06 ! 80: #define GUS_CMD_VOLUMEW 0x09 ! 81: #define GUS_CMD_CURRENTHIW 0x0a ! 82: #define GUS_CMD_CURRENTLOW 0x0b ! 83: #define GUS_CMD_PANPOSW 0x0c ! 84: #define GUS_CMD_VOLUMECTRLW 0x0d ! 85: #define GUS_CMD_ACTIVEVOICESW 0x0e ! 86: ! 87: #define GUS_CMD_VOICECTRLR 0x80 ! 88: #define GUS_CMD_FREQUCTRLR 0x81 ! 89: #define GUS_CMD_STARTHIR 0x82 ! 90: #define GUS_CMD_STARTLOR 0x83 ! 91: #define GUS_CMD_ENDHIR 0x84 ! 92: #define GUS_CMD_ENDLOR 0x85 ! 93: #define GUS_CMD_VOLUMER 0x89 ! 94: #define GUS_CMD_CURRENTHIR 0x8a ! 95: #define GUS_CMD_CURRENTLOR 0x8b ! 96: #define GUS_CMD_PANPOSR 0x8c ! 97: #define GUS_CMD_VOLUMECTRLR 0x8d ! 98: #define GUS_CMD_ACTIVEVOICESR 0x8e ! 99: #define GUS_CMD_IRQSOURCER 0x8f ! 100: ! 101: #define ADDR_HI(x) ((UWORD)((((ULONG)(x))>>7L)&0x1fffL)) ! 102: #define ADDR_LO(x) ((UWORD)((((ULONG)(x))&0x7fL)<<9L)) ! 103: ! 104: ! 105: #define LSW( x ) ((UWORD)(((ULONG)(x))&0xffffL)) ! 106: #define MSW( x ) ((UWORD)(((ULONG)(x))>>16L)) ! 107: #define LSB( x ) ((UBYTE)(((UWORD)(x))&0xffL)) ! 108: #define MSB( x ) ((UBYTE)(((UWORD)(x))>>8)) ! 109: #define CONVTO16B( x ) ((((x)>>1L)&0x0001ffffL)|((x)&0x000c0000L)) ! 110: #define NUMPARAS(bytesize) (((bytesize)+15) >> 4) ! 111: ! 112: ! 113: ! 114: // Variablen ! 115: ! 116: ! 117: UWORD uwGUSPort; ! 118: UBYTE ubGUSGF1Int; ! 119: UBYTE ubGUSMIDIInt; ! 120: UBYTE ubGUSDMA1; ! 121: UBYTE ubGUSDMA2; ! 122: UBYTE ubGUSUsedBits; // 0 if 8 bit or 4 if 16 bit ! 123: UWORD uwGUSUsedFreq; ! 124: UBYTE ubGUSGF1IRQVector; // Physikalischer Vektor des GF1 IRQ's ! 125: UBYTE *pGUSBuffer; // Zwischenpuffer ! 126: ULONG nGUSBufferWriteIndex; ! 127: ULONG nGUSBufferReadIndex; ! 128: ULONG ulBytesInBuffer; // Anzahl der Bytes im Puffer ! 129: ULONG ulGUSSndBufSize; ! 130: ULONG ulDMABufMaxSize; ! 131: ! 132: ! 133: int bIgnoreGF1IRQ=TRUE; ! 134: int bDMAInProgress=FALSE; ! 135: int bWarnFlag=TRUE; // Flag, ob Warnungen ausgeben werden sollen ! 136: int nWarnCnt=0; ! 137: #define MAXWARNS 5 // Anzahl der maximalen Warnungen ! 138: ! 139: _go32_dpmi_seginfo old_pmintGF1; /* the old interrupt handler */ ! 140: _go32_dpmi_seginfo pm_wrapperGF1; /* the new interrupt handler */ ! 141: ! 142: UBYTE ubDummy; ! 143: ! 144: ! 145: ! 146: ! 147: static __inline__ void WriteGUSb( UWORD uwReg, UBYTE ubByte ) ! 148: { ! 149: outportb( uwGUSPort+uwReg, ubByte ); ! 150: } ! 151: ! 152: static __inline__ UBYTE ReadGUSb( UWORD uwReg ) ! 153: { ! 154: return inportb( uwGUSPort+uwReg ); ! 155: } ! 156: ! 157: static __inline__ void WriteGUSw( UWORD uwReg, UWORD uwWord ) ! 158: { ! 159: outportw( uwGUSPort+uwReg, uwWord ); ! 160: } ! 161: ! 162: static __inline__ UWORD ReadGUSw( UWORD uwReg ) ! 163: { ! 164: return inportw( uwGUSPort+uwReg ); ! 165: } ! 166: ! 167: ! 168: ! 169: _go32_dpmi_seginfo dma_mem; // Zeiger auf DMA-Speicher ! 170: ULONG dmabufadr; ! 171: ! 172: void GUS_GF1Delay( void ) ! 173: { ! 174: ! 175: int i; ! 176: ! 177: for( i=0; i<6; i++ ) ! 178: inportb( uwGUSPort+GUS_DATAHI ); ! 179: ! 180: ! 181: } ! 182: ! 183: /******************************* ! 184: ! 185: void GUS_Reset( UBYTE ubGUSDMA1, UBYTE ubGUSDMA2, ubGUSGF1Int ) ! 186: ! 187: *******************************/ ! 188: ! 189: void GUS_Reset( UBYTE ubGUSDMA1, UBYTE ubGUSDMA2, UBYTE ubGUSGF1Int ) ! 190: { ! 191: int i, j; ! 192: UBYTE nDMA, nInt; ! 193: ! 194: WriteGUSb( GUS_MIXER, 1|2 ); // Latches aus, Alle Aus/Eingaben aus ! 195: ! 196: // Reset ! 197: WriteGUSb( GUS_COMMAND, GUS_CMD_RESET ); ! 198: WriteGUSb( GUS_DATAHI, 0 ); ! 199: delay( 100 ); ! 200: WriteGUSb( GUS_COMMAND, GUS_CMD_RESET ); ! 201: WriteGUSb( GUS_DATAHI, 1 ); ! 202: delay( 100 ); ! 203: ! 204: // DMA Control Register reset ! 205: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 206: WriteGUSb( GUS_DATAHI, 0 ); ! 207: delay( 10 ); ! 208: ! 209: // Timer Control Register ! 210: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 211: WriteGUSb( GUS_DATAHI, 0 ); ! 212: delay( 10 ); ! 213: ! 214: // Sampling Control Register ! 215: WriteGUSb( GUS_COMMAND, GUS_CMD_SAMPLECTRL ); ! 216: WriteGUSb( GUS_DATAHI, 0 ); ! 217: delay( 10 ); ! 218: ! 219: // Number of Voices ! 220: WriteGUSb( GUS_COMMAND, GUS_CMD_ACTIVEVOICESW ); ! 221: WriteGUSb( GUS_DATAHI, 0xc0 | (15-1) ); // 15 Voices (left/right) ! 222: ! 223: // Evtl. anstehende DMA-IRQ's holen ! 224: ReadGUSb( GUS_IRQSTATE ); ! 225: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 226: ReadGUSb( GUS_DATAHI ); ! 227: ! 228: // Evtl. Sampleinterrupts lesen ! 229: WriteGUSb( GUS_COMMAND, GUS_CMD_SAMPLECTRL ); ! 230: ReadGUSb( GUS_DATAHI ); ! 231: ! 232: // IRQ-Status lesen ! 233: WriteGUSb( GUS_COMMAND, GUS_CMD_IRQSOURCER ); ! 234: ReadGUSb( GUS_DATAHI ); ! 235: ! 236: // Alle Stimmen abschalten ! 237: ! 238: for( i=0; i<32; i++ ) ! 239: { ! 240: WriteGUSb( GUS_VOICE, (UBYTE)i ); ! 241: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 242: WriteGUSb( GUS_DATAHI, 3 ); // Stimme stoppen ! 243: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 244: WriteGUSb( GUS_DATAHI, 3 ); // Lautstaerke 0 ! 245: WriteGUSb( GUS_COMMAND, GUS_CMD_RAMPRATEW ); ! 246: WriteGUSb( GUS_DATAHI, 0 ); // Ramp 0 ! 247: ! 248: } ! 249: ! 250: // Evtl. anstehende DMA-IRQ's holen ! 251: ReadGUSb( GUS_IRQSTATE ); ! 252: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 253: ReadGUSb( GUS_DATAHI ); ! 254: ! 255: // Evtl. Sampleinterrupts lesen ! 256: WriteGUSb( GUS_COMMAND, GUS_CMD_SAMPLECTRL ); ! 257: ReadGUSb( GUS_DATAHI ); ! 258: ! 259: // IRQ-Status lesen ! 260: WriteGUSb( GUS_COMMAND, GUS_CMD_IRQSOURCER ); ! 261: ReadGUSb( GUS_DATAHI ); ! 262: ! 263: ! 264: // Reset beenden und GF1 Master IRQ einschalten ! 265: WriteGUSb( GUS_COMMAND, GUS_CMD_RESET ); ! 266: WriteGUSb( GUS_DATAHI, 7 ); ! 267: ! 268: ! 269: if( ubGUSDMA1 == 0 ) // IRQ's und DMA einstellen ? ! 270: return; // Nein, dann Ende ! 271: ! 272: ! 273: // Digital ASIC einstellen ! 274: ! 275: WriteGUSb( GUS_REGISTERCTRL, 5 ); // IRQ's-Register waehlen ! 276: WriteGUSb( GUS_MIXER, 1|2 ); // Alles Abschalten ! 277: WriteGUSb( GUS_IRQCTRL, 0 ); // IRQ's loeschen ! 278: WriteGUSb( GUS_REGISTERCTRL, 0 ); // Alte Registerkonfig wieder einschalten ! 279: ! 280: // DMA selektieren ! 281: ! 282: nDMA=0; ! 283: for( j=0; j<2; j++ ) ! 284: { ! 285: switch( ((j!=0)?(ubGUSDMA1):(ubGUSDMA2)) ) ! 286: { ! 287: case 1: ! 288: nDMA |= 1; ! 289: break; ! 290: case 3: ! 291: nDMA |= 2; ! 292: break; ! 293: case 5: ! 294: nDMA |= 3; ! 295: break; ! 296: case 6: ! 297: nDMA |= 4; ! 298: break; ! 299: case 7: ! 300: nDMA |= 5; ! 301: break; ! 302: } ! 303: if( j==0 ) ! 304: nDMA=nDMA<<3; ! 305: } ! 306: ! 307: if( ubGUSDMA1 == ubGUSDMA2 ) // Gleichen DMA fuer beides ? ! 308: nDMA = (nDMA&0x3)|(1<<6); ! 309: ! 310: ! 311: // Interrupt der GUS setzen ! 312: ! 313: nInt=0; ! 314: for( j=0; j<2; j++ ) ! 315: { ! 316: switch( (j!=0)?(ubGUSGF1Int):(ubGUSMIDIInt) ) ! 317: { ! 318: case 2: ! 319: nInt |= 1; ! 320: break; ! 321: case 5: ! 322: nInt |= 2; ! 323: break; ! 324: case 3: ! 325: nInt |= 3; ! 326: break; ! 327: case 7: ! 328: nInt |= 4; ! 329: break; ! 330: case 11: ! 331: nInt |= 5; ! 332: break; ! 333: case 12: ! 334: nInt |= 6; ! 335: break; ! 336: case 15: ! 337: nInt |= 7; ! 338: break; ! 339: } ! 340: if( j==0 ) ! 341: nInt=nInt<<3; ! 342: } ! 343: ! 344: if( ubGUSGF1Int == ubGUSMIDIInt ) ! 345: nInt = (nInt&0x3)|(1<<6); ! 346: ! 347: ! 348: ! 349: disable(); ! 350: ! 351: WriteGUSb( GUS_MIXER, 1|2 ); // DMA-Einstellung aktivieren ! 352: WriteGUSb( GUS_DMACTRL, nDMA | 0x80 ); // DMA-Kanal selektieren, welcher im SET angegebe wurde ! 353: ! 354: ! 355: WriteGUSb( GUS_MIXER, 1|2|64 ); // IRQ's selektieren ! 356: WriteGUSb( GUS_IRQCTRL, nInt ); ! 357: ! 358: WriteGUSb( GUS_MIXER, 1|2 ); // DMA-Einstellung aktivieren ! 359: WriteGUSb( GUS_DMACTRL, nDMA ); // DMA-Kanal selektieren, welcher im SET angegebe wurde ! 360: ! 361: WriteGUSb( GUS_MIXER, 1|2|64 ); // IRQ's selektieren ! 362: WriteGUSb( GUS_IRQCTRL, nInt ); ! 363: ! 364: enable(); ! 365: ! 366: // IRQ/DMA locken ! 367: ! 368: WriteGUSb( GUS_VOICE, 0 ); ! 369: ! 370: WriteGUSb( GUS_MIXER, 8 | ((ubGUSGF1Int==ubGUSMIDIInt)?16:0 ) ); ! 371: ! 372: WriteGUSb( GUS_VOICE, 0 ); ! 373: ! 374: ! 375: ! 376: } ! 377: ! 378: ! 379: ! 380: /******************************* ! 381: ! 382: int GUS_Init( void ) ! 383: ! 384: *******************************/ ! 385: ! 386: int GUS_Init( int *dspbits, int *rate, int *sndbufsize, unsigned int *direct_buffers, int *stereo_sound ) ! 387: { ! 388: ! 389: char *szGUSENVStr, *pz; ! 390: int i, j; ! 391: extern void (*SND_Write)(void *buf, unsigned long size); ! 392: ! 393: ! 394: ! 395: szGUSENVStr = getenv( "ULTRASND" ); ! 396: if( szGUSENVStr == 0 ) ! 397: return 0; ! 398: ! 399: ! 400: if( (*dspbits != 8 ) && (*dspbits != 16 ) ) ! 401: { ! 402: printf( "%d bits are not supported on the GUS !\n", dspbits ); ! 403: return 0; ! 404: } ! 405: ! 406: ! 407: ubGUSUsedBits = (*dspbits==8)?0:4; ! 408: ! 409: if( (*rate < 1000) || (*rate > 44100 )) ! 410: { ! 411: fprintf( stderr, "%dHz are not supported on the GUS !\n", *rate ); ! 412: return 0; ! 413: } ! 414: ! 415: uwGUSUsedFreq = *rate; ! 416: ! 417: ! 418: ! 419: ulDMABufMaxSize = 8192; ! 420: ulGUSSndBufSize = ((ULONG)*sndbufsize)*32; ! 421: ! 422: ! 423: ! 424: fprintf( stderr, "GUS configured for %d bits, %d Hz\n", *dspbits, *rate ); ! 425: fprintf( stderr, "Soundbuffersize: %d bytes\n", ulGUSSndBufSize ); ! 426: fprintf( stderr, "DMA-buffersize: %d bytes\n", ulDMABufMaxSize ); ! 427: fprintf( stderr, "Fragmentsize: %d bytes\n", *sndbufsize ); ! 428: ! 429: ! 430: uwGUSPort = (UWORD)strtol( szGUSENVStr, (char **)NULL, 16 ); ! 431: pz = strchr( szGUSENVStr, ',' ); ! 432: if( (pz == 0) || (uwGUSPort ==0) ) ! 433: return 0; ! 434: ! 435: ubGUSDMA1 = (UBYTE)atol( pz+1 ); ! 436: pz = strchr( pz+1, ',' ); ! 437: if( pz == 0 ) ! 438: return 0; ! 439: ! 440: ubGUSDMA2 = (UBYTE)atol( pz+1 ); ! 441: ! 442: pz = strchr( pz+1, ',' ); ! 443: if( pz == 0 ) ! 444: return 0; ! 445: ! 446: ubGUSGF1Int = (UBYTE)atol( pz+1 ); ! 447: if( ubGUSGF1Int == 0 ) ! 448: return 0; ! 449: ! 450: pz = strchr( pz+1, ',' ); ! 451: if( pz == 0 ) ! 452: return 0; ! 453: ! 454: ubGUSMIDIInt = (UBYTE)atol( pz+1 ); ! 455: if( ubGUSMIDIInt == 0 ) ! 456: return 0; ! 457: ! 458: // Speicher fuer DMA holen ! 459: ! 460: ! 461: memset( &dma_mem, 0, sizeof( _go32_dpmi_seginfo ) ); ! 462: dma_mem.size = NUMPARAS( ulDMABufMaxSize+1000 ); ! 463: dmabufadr = DMA_AllocDMABuf( &dma_mem ); ! 464: ! 465: ! 466: _go32_dpmi_lock_code( GUS_PlayBuffer, (ULONG)GUS_DummyFunc - (ULONG)GUS_PlayBuffer); ! 467: _go32_dpmi_lock_data( &uwGUSPort, (ULONG)&ubDummy - (ULONG)&uwGUSPort); ! 468: ! 469: ! 470: if( dmabufadr == NULL) ! 471: { ! 472: fprintf( stderr, "Cannot allocate DOS memory for DMA buffers!\n" ); ! 473: return 0; ! 474: } ! 475: ! 476: ! 477: // Zwischenpuffer allokieren ! 478: ! 479: pGUSBuffer = (UBYTE *)malloc( ulGUSSndBufSize+1000 ); ! 480: if( pGUSBuffer == 0 ) ! 481: { ! 482: fprintf( stderr, "Cannot allocate soundbuffer !\n" ); ! 483: return 0; ! 484: } ! 485: ! 486: nGUSBufferWriteIndex = nGUSBufferReadIndex = 0; ! 487: ulBytesInBuffer = 0; ! 488: ! 489: // GUS-Reset ! 490: ! 491: GUS_Reset( ubGUSDMA1, ubGUSDMA2, ubGUSGF1Int ); ! 492: ! 493: ! 494: // Test, ob wir in das GUS-RAM etwas schreiben koennen ! 495: ! 496: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 497: WriteGUSw( GUS_DATALO, 0 ); ! 498: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 499: WriteGUSw( GUS_DATAHI, 0 ); ! 500: ! 501: WriteGUSb( GUS_DRAM, 0x15 ); ! 502: delay( 100 ); ! 503: if( ReadGUSb( GUS_DRAM ) != 0x15 ) // Bytes unterschiedlich ? ! 504: return 0; ! 505: ! 506: // GUS-RAM loeschen ! 507: ! 508: j=-1; ! 509: for( i=0; i<(int)(ulDMABufMaxSize*2+1000); i++ ) ! 510: { ! 511: if( j != MSW(i) ) // Muss das Highword veraendert werden ? ! 512: { ! 513: j = MSW(i); ! 514: ! 515: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 516: WriteGUSw( GUS_DATALO, MSW( i ) ); ! 517: } ! 518: ! 519: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 520: WriteGUSw( GUS_DATALO, LSW( i ) ); ! 521: ! 522: WriteGUSb( GUS_DRAM, 0 ); ! 523: ! 524: } ! 525: ! 526: ! 527: // Interrupthandler installieren ! 528: ! 529: memset( &pm_wrapperGF1, 0, sizeof( _go32_dpmi_seginfo ) ); ! 530: pm_wrapperGF1.pm_offset = (int) GUS_GF1InterruptHandler; ! 531: if(_go32_dpmi_allocate_iret_wrapper( &pm_wrapperGF1 ) ) ! 532: { ! 533: fprintf( stderr, "Cannot allocate protected mode wrapper for GUS interrupt!\n"); ! 534: if( dmabufadr != 0 ) ! 535: _go32_dpmi_free_dos_memory( &dma_mem ); ! 536: ! 537: return 0; ! 538: } ! 539: ! 540: ! 541: ubGUSGF1IRQVector = (ubGUSGF1Int>7)?(ubGUSGF1Int+0x68):(ubGUSGF1Int+0x08); // Physik. Vektor berechnen ! 542: ! 543: _go32_dpmi_get_protected_mode_interrupt_vector( ubGUSGF1IRQVector, &old_pmintGF1 ); // Alten Interrupt merken ! 544: _go32_dpmi_set_protected_mode_interrupt_vector( ubGUSGF1IRQVector, &pm_wrapperGF1 ); // Neuen Interrupt merken ! 545: ! 546: ! 547: // Interrupt erlauben ! 548: ! 549: if( ubGUSGF1Int > 7 ) ! 550: { ! 551: outportb( 0xA1, inportb( 0xA1 ) & ~(1 << ( ubGUSGF1Int-8 ) ) ); ! 552: outportb( 0xA0, 0x20 ); ! 553: } ! 554: else ! 555: { ! 556: outportb( 0x21, inportb( 0x21 ) & ~(1 << ubGUSGF1Int)); ! 557: outportb( 0x20, 0x20 ); ! 558: } ! 559: ! 560: ! 561: // Hier wird die Stimme zum erstenmal gestertet ! 562: ! 563: ! 564: WriteGUSb( GUS_VOICE, 0 ); // Stimme0 ! 565: ! 566: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMEW ); // Lautstaerke auf Maximum ! 567: WriteGUSw( GUS_DATALO, 61247 ); ! 568: ! 569: WriteGUSb( GUS_COMMAND, GUS_CMD_FREQUCTRLW ); // 15 Stimmen = x / 40! ! 570: ! 571: // WriteGUSw( GUS_DATALO, (UWORD)((((((((ULONG)uwGUSUsedFreq)/1000L)<<9L)+(44100L>>1L))/44100L)<<1L)) ); ! 572: WriteGUSw( GUS_DATALO, uwGUSUsedFreq/40 ); ! 573: ! 574: ! 575: WriteGUSb( GUS_COMMAND, GUS_CMD_CURRENTLOW ); // Current ! 576: WriteGUSw( GUS_DATALO, 32 ); ! 577: WriteGUSb( GUS_COMMAND, GUS_CMD_CURRENTHIW ); ! 578: WriteGUSw( GUS_DATALO, 0 ); ! 579: ! 580: WriteGUSb( GUS_COMMAND, GUS_CMD_STARTHIW ); // Start ! 581: WriteGUSw( GUS_DATALO, 0 ); ! 582: WriteGUSb( GUS_COMMAND, GUS_CMD_STARTLOW ); ! 583: WriteGUSw( GUS_DATALO, 32 ); ! 584: ! 585: if( ubGUSUsedBits == 0 ) // 8 oder 16 Bit ? ! 586: { ! 587: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 588: WriteGUSw( GUS_DATALO, ADDR_HI( ulDMABufMaxSize+32 ) ); ! 589: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 590: WriteGUSw( GUS_DATALO, ADDR_LO( ulDMABufMaxSize+32 ) ); ! 591: } ! 592: else ! 593: { ! 594: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende ! 595: WriteGUSw( GUS_DATALO, ADDR_HI( CONVTO16B( ulDMABufMaxSize+32 ) ) ); ! 596: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 597: WriteGUSw( GUS_DATALO, ADDR_LO( CONVTO16B( ulDMABufMaxSize+32 ) ) ); ! 598: } ! 599: ! 600: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 601: WriteGUSb( GUS_DATAHI, 3|4 ); ! 602: GUS_GF1Delay(); ! 603: WriteGUSb( GUS_DATAHI, 3|4 ); // Rollover an ! 604: ! 605: ! 606: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 607: WriteGUSb( GUS_DATAHI, 32|ubGUSUsedBits ); ! 608: GUS_GF1Delay(); ! 609: WriteGUSb( GUS_DATAHI, 32|ubGUSUsedBits ); // Stimme starten, Loop aus ! 610: ! 611: ! 612: bIgnoreGF1IRQ = FALSE; ! 613: ! 614: ! 615: // GUS-Initialisierung beendet, puhhh ! 616: ! 617: fprintf( stderr, "GUS found at port: %Xh, dma1: %d, dma2: %d, GF1-int: %d, MIDI-int: %d\n", uwGUSPort, ubGUSDMA1, ubGUSDMA2, ubGUSGF1Int, ubGUSMIDIInt ); ! 618: ! 619: ! 620: atexit( GUS_Cleanup ); ! 621: ! 622: ! 623: SND_Write = GUS_PlayBuffer; // Zeiger auf meine Abspielroutine eintragen ! 624: direct_buffers[0] = 0; // Direct access not supported ! 625: direct_buffers[1] = 0; ! 626: *stereo_sound = 0; ! 627: ! 628: ! 629: printf( "First ....(%ld,%X)\n", ulBytesInBuffer, &ulBytesInBuffer ); ! 630: ! 631: ! 632: return 1; ! 633: ! 634: } ! 635: ! 636: ! 637: /******************************* ! 638: ! 639: int GUS_Cleanup( void ) ! 640: ! 641: *******************************/ ! 642: ! 643: ! 644: void GUS_Cleanup( void ) ! 645: { ! 646: ! 647: ! 648: fprintf( stderr, "Freeing up all GUS-stuff\n" ); ! 649: ! 650: // Warten, bis DMA beendet ist ! 651: ! 652: if( bDMAInProgress == TRUE ) ! 653: { ! 654: do ! 655: { ! 656: delay( 10 ); ! 657: } ! 658: while( bDMAInProgress == TRUE ); ! 659: } ! 660: ! 661: ! 662: // Stimmen anhalten ! 663: ! 664: WriteGUSb( GUS_VOICE, 0 ); ! 665: ! 666: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 667: WriteGUSb( GUS_DATAHI, 3 ); ! 668: GUS_GF1Delay(); ! 669: WriteGUSb( GUS_DATAHI, 3 ); ! 670: ! 671: ! 672: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 673: WriteGUSb( GUS_DATAHI, 3 ); ! 674: GUS_GF1Delay(); ! 675: WriteGUSb( GUS_DATAHI, 3 ); ! 676: ! 677: // GUS resetten ! 678: ! 679: GUS_Reset( 0, 0, 0 ); ! 680: ! 681: // Interrupts wieder sperren ! 682: ! 683: if( ubGUSGF1Int > 7 ) ! 684: outportb (0xA1, inportb(0xA1) | (1 << (ubGUSGF1Int-8))); ! 685: else ! 686: outportb (0x21, inportb(0x21) | (1 << ubGUSGF1Int)); ! 687: ! 688: _go32_dpmi_set_protected_mode_interrupt_vector( ubGUSGF1IRQVector, &old_pmintGF1 ); ! 689: _go32_dpmi_free_iret_wrapper( &pm_wrapperGF1 ); ! 690: ! 691: ! 692: // Speicher freigeben ! 693: ! 694: if( pGUSBuffer != 0 ) ! 695: free( pGUSBuffer ); ! 696: ! 697: if( dmabufadr != 0 ) ! 698: _go32_dpmi_free_dos_memory( &dma_mem ); // Speicher fuer DMA freigeben ! 699: ! 700: GUS_Reset( 0, 0, 0 ); ! 701: ! 702: } ! 703: ! 704: /******************************* ! 705: ! 706: void GUS_PlayBuffer( void *buf, unsigned long size ) ! 707: ! 708: *******************************/ ! 709: ! 710: ! 711: // Diese Routine wird vom UAE aufgerufen, wenn der Soundbuffer ! 712: // zu leeren ist ! 713: ! 714: ! 715: void GUS_PlayBuffer( void *buf, unsigned long size ) ! 716: { ! 717: ULONG i, j; ! 718: ! 719: ! 720: j=0; ! 721: while( ulBytesInBuffer>ulDMABufMaxSize*2 ); ! 722: /* ! 723: { ! 724: fprintf( stderr, "Waiting ....(%ld,%X)\n", ulBytesInBuffer, &ulBytesInBuffer ); ! 725: fflush( stderr ); ! 726: j++; ! 727: if( j>50 ) ! 728: { ! 729: fprintf( stderr, "Breche ab ...\n" ); ! 730: fflush( stderr ); ! 731: break; ! 732: } ! 733: ! 734: } */ ! 735: ! 736: disable(); ! 737: ! 738: // Daten in den GUS-Buffer kopieren ! 739: ! 740: if( size+ulBytesInBuffer>ulGUSSndBufSize ) ! 741: { ! 742: if( bWarnFlag == TRUE ) ! 743: { ! 744: fprintf( stderr, "Error: GUS-soundbuffer overflow !\n" ); ! 745: nWarnCnt++; ! 746: if( nWarnCnt>MAXWARNS ) ! 747: { ! 748: bWarnFlag = FALSE; ! 749: fprintf( stderr, "GUS: No further messages !\n" ); ! 750: } ! 751: } ! 752: ! 753: } ! 754: else ! 755: { ! 756: // GUS-Buffer fuellen ! 757: ! 758: // Koennen wir auf einmal kopieren ? ! 759: ! 760: i = ulGUSSndBufSize-nGUSBufferWriteIndex; ! 761: if( i < size ) ! 762: { ! 763: memcpy( pGUSBuffer+nGUSBufferWriteIndex, buf, i ); ! 764: ! 765: memcpy( pGUSBuffer, ((UBYTE*)buf)+i, size-i ); ! 766: ! 767: } ! 768: else ! 769: { ! 770: memcpy( pGUSBuffer+nGUSBufferWriteIndex, buf, size ); ! 771: } ! 772: ! 773: nGUSBufferWriteIndex = (nGUSBufferWriteIndex+size)&(ulGUSSndBufSize-1); ! 774: ! 775: ulBytesInBuffer += size; ! 776: ! 777: } ! 778: ! 779: enable(); ! 780: ! 781: } ! 782: ! 783: ! 784: /******************************* ! 785: ! 786: void GUS_StartDMA( ULONG ulPosInGUSRAM ) ! 787: ! 788: *******************************/ ! 789: ! 790: ! 791: ! 792: void GUS_StartDMA( ULONG ulPosInGUSRAM, int bLoop ) ! 793: { ! 794: ! 795: ULONG i, pDMABuf, j; ! 796: ULONG ulTemp; ! 797: ! 798: ! 799: // I hope, everything is aligned to 4 byte (32bit), otherwise ! 800: // the machine my crash :( ! 801: ! 802: ! 803: if( bDMAInProgress == TRUE ) ! 804: { ! 805: fprintf( stderr, "Error in StartDMA, DMA already im progress !\n" ); ! 806: return; ! 807: } ! 808: ! 809: bDMAInProgress=TRUE; ! 810: ! 811: // Kopiert die Daten aus dem Soundbuffer in den DMA-Puffer ! 812: ! 813: ! 814: _farsetsel( _dos_ds ); ! 815: ! 816: if( ulBytesInBuffer == 0 ) // Sind ueberhaupt Daten im Puffer ? ! 817: { // Nein, dann DMA-Buffer loeschen ! 818: pDMABuf = dmabufadr; ! 819: ! 820: if( ubGUSUsedBits == 0 ) // 8 Bit ? ! 821: ulTemp = 0x80808080UL; ! 822: else ! 823: ulTemp = 0; ! 824: ! 825: for( i=ulDMABufMaxSize/4; i>0; i-- ) ! 826: { ! 827: _farnspokel( pDMABuf, ulTemp ); ! 828: pDMABuf+=4; ! 829: } ! 830: ! 831: } ! 832: else ! 833: { ! 834: if( ulBytesInBuffer >= ulDMABufMaxSize ) // Sind mehr Daten da, als ! 835: { // der Puffer gross ist ? ! 836: ! 837: pDMABuf = dmabufadr; // Ja, DMA-Puffer vollmachen ! 838: ! 839: j = nGUSBufferReadIndex; ! 840: for( i=ulDMABufMaxSize/4; i>0; i-- ) ! 841: { ! 842: _farnspokel( pDMABuf, *((ULONG*)(pGUSBuffer+j)) ); // 32 bit-copy ! 843: pDMABuf+=4; ! 844: j = (j+4)&(ulGUSSndBufSize-1); ! 845: } ! 846: ! 847: nGUSBufferReadIndex = (nGUSBufferReadIndex+ulDMABufMaxSize)&(ulGUSSndBufSize-1); ! 848: ! 849: ulBytesInBuffer -= ulDMABufMaxSize; ! 850: } ! 851: else ! 852: { ! 853: pDMABuf = dmabufadr; // Nein, nur den vorhanden Teil ! 854: // kopieren ! 855: ! 856: j = nGUSBufferReadIndex; ! 857: for( i=ulBytesInBuffer/4; i>0; i-- ) ! 858: { ! 859: _farnspokel( pDMABuf, *((ULONG*)(pGUSBuffer+j)) ); ! 860: pDMABuf+=4; ! 861: j = (j+4)&(ulGUSSndBufSize-1); ! 862: } ! 863: nGUSBufferReadIndex = (nGUSBufferReadIndex+ulBytesInBuffer)&(ulGUSSndBufSize-1); ! 864: ! 865: ! 866: if( ubGUSUsedBits == 0 ) // 8 Bit ? ! 867: ulTemp = 0x80808080UL; ! 868: else ! 869: ulTemp = 0; ! 870: ! 871: ! 872: for( i=(ulDMABufMaxSize-ulBytesInBuffer)/4; i>0; i-- ) ! 873: { ! 874: _farnspokel( pDMABuf, ulTemp ); ! 875: pDMABuf+=4; ! 876: } ! 877: ! 878: ! 879: ulBytesInBuffer = 0; ! 880: } ! 881: ! 882: } ! 883: ! 884: ! 885: if( bLoop == TRUE ) // Byte/Word kopieren, um das Geklicke zu verhindern ! 886: { ! 887: ! 888: if( ubGUSUsedBits == 0 ) // 8 Bit ? ! 889: { ! 890: ! 891: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 892: WriteGUSw( GUS_DATALO, MSW( ulPosInGUSRAM-ulDMABufMaxSize-1 ) ); ! 893: ! 894: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 895: WriteGUSw( GUS_DATALO, LSW( ulPosInGUSRAM-ulDMABufMaxSize-1 ) ); ! 896: ! 897: WriteGUSb( GUS_DRAM, _farnspeekb( dmabufadr+ulDMABufMaxSize-1 )+0x80 ); ! 898: ! 899: } ! 900: else ! 901: { ! 902: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 903: WriteGUSw( GUS_DATALO, MSW( ulPosInGUSRAM-ulDMABufMaxSize-2 ) ); ! 904: ! 905: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 906: WriteGUSw( GUS_DATALO, LSW( ulPosInGUSRAM-ulDMABufMaxSize-2 ) ); ! 907: ! 908: WriteGUSb( GUS_DRAM, _farnspeekb( dmabufadr+ulDMABufMaxSize-2 ) ); ! 909: ! 910: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 911: WriteGUSw( GUS_DATALO, MSW( ulPosInGUSRAM-ulDMABufMaxSize-1 ) ); ! 912: ! 913: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 914: WriteGUSw( GUS_DATALO, LSW( ulPosInGUSRAM-ulDMABufMaxSize-1 ) ); ! 915: ! 916: WriteGUSb( GUS_DRAM, _farnspeekb( dmabufadr+ulDMABufMaxSize-1 ) ); ! 917: ! 918: } ! 919: ! 920: } ! 921: ! 922: ! 923: // DMA-Controller initialisieren ! 924: DMA_InitTransfer( ubGUSDMA1, DMA_READ, dmabufadr, ulDMABufMaxSize ); ! 925: ! 926: // GUS-Register initialisieren ! 927: WriteGUSb( GUS_COMMAND, GUS_CMD_DMASTARTADR ); ! 928: if( ubGUSDMA1>3 ) ! 929: WriteGUSw( GUS_DATALO, CONVTO16B(ulPosInGUSRAM>>4) ); // Adresse>>4 !!!! ! 930: else ! 931: WriteGUSw( GUS_DATALO, (UWORD)(ulPosInGUSRAM>>4) ); // Adresse>>4 !!!! ! 932: ! 933: if( ubGUSUsedBits == 0 ) ! 934: { // 8 Bit ! 935: if( ubGUSDMA1>3 ) ! 936: { ! 937: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 938: WriteGUSb( GUS_DATAHI, 0x85 | 0x20 ); // Mit signed->unsigned kopieren ! 939: ! 940: } ! 941: else ! 942: { ! 943: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 944: WriteGUSb( GUS_DATAHI, 0x81 | 0x20 ); ! 945: } ! 946: } ! 947: else ! 948: { // 16 Bit ! 949: if( ubGUSDMA1>3 ) ! 950: { ! 951: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 952: WriteGUSb( GUS_DATAHI, 0x05 | 0x20 ); // Ohne signed->unsigned kopieren ! 953: ! 954: } ! 955: else ! 956: { ! 957: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 958: WriteGUSb( GUS_DATAHI, 0x01 | 0x20 ); ! 959: } ! 960: ! 961: ! 962: } ! 963: ! 964: } ! 965: ! 966: ! 967: ! 968: /******************************* ! 969: ! 970: void GUS_WorkOnVoices( void ) ! 971: ! 972: *******************************/ ! 973: ! 974: ! 975: // Hier werden die Interrupts der einzelnen Stimmen bearbeitet ! 976: ! 977: void GUS_WorkOnVoices( void ) ! 978: { ! 979: ! 980: UBYTE ubIntArt, ubTemp1, ubTemp2; ! 981: int i, nVoice, nVoiceBit, nWaveIgnore=0, nVolumeIgnore=0; ! 982: int nIntCounts=0; ! 983: ! 984: // Alle anstehenden Interrupts bearbeiten ! 985: ! 986: for(;;) ! 987: { ! 988: ! 989: ! 990: WriteGUSb( GUS_COMMAND, GUS_CMD_IRQSOURCER ); // IRQ-Art holen ! 991: ubIntArt = ReadGUSb( GUS_DATAHI ); ! 992: ! 993: nVoice = ubIntArt & 0x1f; ! 994: nVoiceBit = ((ULONG)1)<<((ULONG)nVoice); ! 995: ! 996: // Alle Interrupts abgearbeitet ? ! 997: if( ( ubIntArt & 192) == 192 ) // Negative Logik !!!! ! 998: { ! 999: break; ! 1000: } ! 1001: ! 1002: nIntCounts++; ! 1003: ! 1004: if( nIntCounts>3 ) ! 1005: { ! 1006: #ifdef DEBUG ! 1007: fprintf( stderr, "!!!! Breche Int. ab, da mehr als 3 Anfragen !!!\n" ); ! 1008: #endif ! 1009: ! 1010: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1011: WriteGUSb( GUS_DATAHI, 3 ); ! 1012: GUS_GF1Delay(); ! 1013: WriteGUSb( GUS_DATAHI, 3 ); ! 1014: ! 1015: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 1016: WriteGUSb( GUS_DATAHI, 3 ); ! 1017: GUS_GF1Delay(); ! 1018: WriteGUSb( GUS_DATAHI, 3 ); ! 1019: ! 1020: return; ! 1021: } ! 1022: ! 1023: if( bIgnoreGF1IRQ == TRUE ) ! 1024: { ! 1025: #ifdef DEBUG ! 1026: fprintf( stderr, "\t\tIgnoriere IRQ !\n" ); ! 1027: #endif ! 1028: ! 1029: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 1030: WriteGUSb( GUS_DATAHI, 3 ); // Loop aus, IRQ aus ! 1031: ! 1032: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1033: WriteGUSb( GUS_DATAHI, 3 ); // Rollover an, IRQ an ! 1034: } ! 1035: ! 1036: #ifdef DEBUG ! 1037: fprintf( stderr, "\tBearbeite Stimme %d, IntArt: $%X\n", nVoice, ubIntArt ); ! 1038: #endif ! 1039: ! 1040: if( ! (ubIntArt & 128 ) ) // WAVE-Table-IRQ ? ! 1041: { ! 1042: if( !(nWaveIgnore & nVoiceBit )) ! 1043: { ! 1044: nWaveIgnore |= nVoiceBit; ! 1045: ! 1046: #ifdef DEBUG ! 1047: fprintf( stderr,"\t\tBearbeite WAVE-IRQ\n" ); ! 1048: #endif ! 1049: ! 1050: WriteGUSb( GUS_VOICE, nVoice ); ! 1051: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLR ); ! 1052: ubTemp1 = ReadGUSb( GUS_DATAHI ); ! 1053: ! 1054: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLR ); ! 1055: ubTemp2 = ReadGUSb( GUS_DATAHI ); ! 1056: ! 1057: ! 1058: if( ubTemp2&4 ) // Ist das Rollover an ? ! 1059: { // Ja ! 1060: ! 1061: // Das Ende neu setzen ! 1062: ! 1063: if( ubGUSUsedBits == 0 ) // 8 Bit ? ! 1064: { ! 1065: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 1066: WriteGUSw( GUS_DATALO, ADDR_HI( ulDMABufMaxSize*2+32 ) ); ! 1067: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 1068: WriteGUSw( GUS_DATALO, ADDR_LO( ulDMABufMaxSize*2+32 ) ); ! 1069: } ! 1070: else ! 1071: { ! 1072: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 1073: WriteGUSw( GUS_DATALO, ADDR_HI( CONVTO16B( ulDMABufMaxSize*2+32 ) ) ); ! 1074: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 1075: WriteGUSw( GUS_DATALO, ADDR_LO( CONVTO16B( ulDMABufMaxSize*2+32 ) ) ); ! 1076: } ! 1077: ! 1078: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1079: WriteGUSb( GUS_DATAHI, 3 ); ! 1080: GUS_GF1Delay(); ! 1081: WriteGUSb( GUS_DATAHI, 3 ); // Rollover aus ! 1082: ! 1083: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 1084: WriteGUSb( GUS_DATAHI, 32|8|ubGUSUsedBits ); ! 1085: GUS_GF1Delay(); ! 1086: WriteGUSb( GUS_DATAHI, 32|8|ubGUSUsedBits ); // Loop an ! 1087: ! 1088: GUS_StartDMA( 32, FALSE ); ! 1089: ! 1090: } ! 1091: else ! 1092: { ! 1093: ! 1094: // Das Ende neu setzen ! 1095: ! 1096: if( ubGUSUsedBits == 0 ) ! 1097: { ! 1098: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 1099: WriteGUSw( GUS_DATALO, ADDR_HI( ulDMABufMaxSize+32 ) ); ! 1100: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 1101: WriteGUSw( GUS_DATALO, ADDR_LO( ulDMABufMaxSize+32 ) ); ! 1102: } ! 1103: else ! 1104: { ! 1105: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 1106: WriteGUSw( GUS_DATALO, ADDR_HI( CONVTO16B( ulDMABufMaxSize+32 ) ) ); ! 1107: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 1108: WriteGUSw( GUS_DATALO, ADDR_LO( CONVTO16B( ulDMABufMaxSize+32 ) ) ); ! 1109: } ! 1110: ! 1111: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1112: WriteGUSb( GUS_DATAHI, 3|4 ); ! 1113: GUS_GF1Delay(); ! 1114: WriteGUSb( GUS_DATAHI, 3|4 ); // Rollover an ! 1115: ! 1116: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 1117: WriteGUSb( GUS_DATAHI, 32|ubGUSUsedBits ); ! 1118: GUS_GF1Delay(); ! 1119: WriteGUSb( GUS_DATAHI, 32|ubGUSUsedBits ); // Loop aus ! 1120: ! 1121: GUS_StartDMA( ulDMABufMaxSize+32, TRUE ); ! 1122: ! 1123: } ! 1124: ! 1125: } ! 1126: } ! 1127: ! 1128: if( ! (ubIntArt & 64 ) ) // Volume-IRQ ! 1129: { ! 1130: ! 1131: if( !(nVolumeIgnore & nVoiceBit )) ! 1132: { ! 1133: nVolumeIgnore |= nVoiceBit; ! 1134: #ifdef DEBUG ! 1135: fprintf( stderr, "\t\tBearbeite Volume-IRQ\n" ); ! 1136: #endif ! 1137: ! 1138: WriteGUSb( GUS_VOICE, nVoice ); ! 1139: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLR ); ! 1140: ubTemp2 = ReadGUSb( GUS_DATAHI ); ! 1141: ! 1142: WriteGUSb(GUS_COMMAND, GUS_CMD_VOICECTRLR ); ! 1143: ubTemp1 = ReadGUSb( GUS_DATAHI ); ! 1144: ! 1145: ! 1146: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1147: WriteGUSb( GUS_DATAHI, (ubTemp2 & (~32)) | 3 ); ! 1148: ! 1149: } ! 1150: ! 1151: } ! 1152: ! 1153: } ! 1154: } ! 1155: ! 1156: ! 1157: ! 1158: /******************************* ! 1159: ! 1160: void GUS_GF1InterruptHandler( void ) ! 1161: ! 1162: *******************************/ ! 1163: ! 1164: ! 1165: // Hier werden alle Interrupts verarbeitet ! 1166: ! 1167: void GUS_GF1InterruptHandler( void ) ! 1168: { ! 1169: ! 1170: UBYTE ubIntArt, ubTemp; ! 1171: ! 1172: ! 1173: ! 1174: ! 1175: if( uwGUSPort == 0 ) ! 1176: return; ! 1177: ! 1178: #ifdef DEBUG ! 1179: fprintf( stderr, "- Interrupt aufgetreten. Zeit: %lf\n", ((double)clock())/((double)CLOCKS_PER_SEC) ); ! 1180: #endif ! 1181: ! 1182: for(;;) ! 1183: { ! 1184: ! 1185: ubIntArt = ReadGUSb( GUS_IRQSTATE ); ! 1186: ! 1187: #ifdef DEBUG ! 1188: fprintf( stderr, " IRQ-Status (2x6): $%X\n", ubIntArt ); ! 1189: #endif ! 1190: ! 1191: ! 1192: if( ubIntArt == 0 ) // Fertig ? ! 1193: break; ! 1194: ! 1195: if( ubIntArt & 128 ) // TC-IRQ ? ! 1196: { ! 1197: ! 1198: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 1199: if( ReadGUSb( GUS_DATAHI ) & 0x40 ) ! 1200: { ! 1201: #ifdef DEBUG ! 1202: fprintf( stderr, " - Bearbeite DMA-Interrupt\n" ); ! 1203: #endif ! 1204: ! 1205: bDMAInProgress = FALSE; ! 1206: ! 1207: } ! 1208: ! 1209: WriteGUSb( GUS_COMMAND, GUS_CMD_SAMPLECTRL ); ! 1210: if( ReadGUSb( GUS_DATAHI ) & 0x40 ) ! 1211: { ! 1212: #ifdef DEBUG ! 1213: fprintf( stderr, " - Bearbeite Sample-Interrupt\n" ); ! 1214: #endif ! 1215: ! 1216: } ! 1217: ! 1218: } ! 1219: ! 1220: if( ubIntArt & 3 ) ! 1221: { ! 1222: #ifdef DEBUG ! 1223: fprintf( stderr, " - Bearbeite MIDI-IRQ\n" ); ! 1224: #endif ! 1225: ! 1226: } ! 1227: ! 1228: if( ubIntArt & 64 ) ! 1229: { ! 1230: #ifdef DEBUG ! 1231: fprintf( stderr, " - Bearbeite VOLUME-IRQ\n" ); ! 1232: #endif ! 1233: GUS_WorkOnVoices(); ! 1234: ! 1235: ! 1236: } ! 1237: ! 1238: if( ubIntArt & 32 ) ! 1239: { ! 1240: #ifdef DEBUG ! 1241: fprintf( stderr, " - Bearbeite WAVETABLE-IRQ\n" ); ! 1242: #endif ! 1243: GUS_WorkOnVoices(); ! 1244: ! 1245: } ! 1246: ! 1247: ! 1248: if( ubIntArt & 4 ) // Timer 1? ! 1249: { ! 1250: #ifdef DEBUG ! 1251: fprintf( stderr, " - Bearbeite Timer 1-IRQ\n" ); ! 1252: #endif ! 1253: ! 1254: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 1255: ubTemp = ReadGUSb( GUS_DATAHI ); ! 1256: ! 1257: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 1258: WriteGUSb( GUS_DATAHI, ubTemp & (~4) ); // Timer 1 aus ! 1259: } ! 1260: ! 1261: if( ubIntArt & 8 ) // Timer 2? ! 1262: { ! 1263: #ifdef DEBUG ! 1264: fprintf( stderr, " - Bearbeite Timer 2-IRQ\n" ); ! 1265: #endif ! 1266: ! 1267: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 1268: ubTemp = ReadGUSb( GUS_DATAHI ); ! 1269: ! 1270: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 1271: WriteGUSb( GUS_DATAHI, ubTemp & (~8) ); // Timer 2 aus ! 1272: } ! 1273: } ! 1274: ! 1275: #ifdef DEBUG ! 1276: fprintf( stderr, "- Interruptende\n\n" ); ! 1277: #endif ! 1278: ! 1279: if( ubGUSGF1Int > 7 ) ! 1280: outportb( 0xA0, 0x20 ); ! 1281: ! 1282: outportb( 0x20, 0x20 ); ! 1283: ! 1284: } ! 1285: ! 1286: ! 1287: // Dummy-Routine zum erkennen des Programmendes ! 1288: ! 1289: void GUS_DummyFunc( void ) ! 1290: { ! 1291: ; ! 1292: } ! 1293: ! 1294:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.