![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sb.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 sb.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 Sound Blaster interface. ! 5: * ! 6: * (c) 1996 Peter Remmers, Gustavo Goedert ! 7: * ! 8: * Bugfixes by Michael Sontheimer ! 9: */ ! 10: ! 11: #include "sysconfig.h" ! 12: #include "sysdeps.h" ! 13: ! 14: #include <stdlib.h> ! 15: #include <stdio.h> ! 16: #include <string.h> ! 17: #include <ctype.h> ! 18: #include <dos.h> ! 19: #include <pc.h> ! 20: #include <sys/farptr.h> ! 21: #include <dpmi.h> ! 22: #include <go32.h> ! 23: ! 24: #include "sound/sb.h" ! 25: #include "sound/dma.h" ! 26: ! 27: /* some useful macros */ ! 28: #define LOBYTE(x) ((UBYTE)(((UWORD)(x)) & 0xFF)) ! 29: #define HIBYTE(x) ((UBYTE)(((UWORD)(x)) >> 8)) ! 30: #define LOWORD(x) ((UWORD)(((ULONG)(x)) & 0xFFFF)) ! 31: #define HIWORD(x) ((UWORD)(((ULONG)(x)) >> 16)) ! 32: #define NUMPARAS(bytesize) (((bytesize)+15) >> 4) ! 33: ! 34: #ifndef TRUE ! 35: #define TRUE 1 ! 36: #endif ! 37: #ifndef FALSE ! 38: #define FALSE 0 ! 39: #endif ! 40: ! 41: /* Offsets relative to base I/O address. */ ! 42: #define SB_MIXER_ADDRESS 0x04 ! 43: #define SB_MIXER_DATA 0x05 ! 44: #define SB_DSP_RESET 0x06 ! 45: #define SB_DSP_READ_DATA 0x0A ! 46: #define SB_DSP_WRITE_DATA 0x0C ! 47: #define SB_DSP_WRITE_STATUS 0x0C ! 48: #define SB_DSP_DATA_AVAIL 0x0E ! 49: #define SB_DSP_INT_CLEAR 0x0F ! 50: ! 51: /* DSP Commands */ ! 52: #define CMD_PLAY_8BIT 0x14 ! 53: #define CMD_SET_TIME_CONSTANT 0x40 ! 54: #define CMD_DEFINE_SILENCE_BLOCK 0x80 ! 55: #define CMD_PAUSE_8BIT_DMA 0xD0 ! 56: #define CMD_CONTINUE_8BIT_DMA 0xD4 ! 57: #define CMD_SPEAKER_ON 0xD1 ! 58: #define CMD_SPEAKER_OFF 0xD3 ! 59: #define CMD_GET_SPEAKER_SETTING 0xD8 ! 60: #define CMD_DSP_VER 0xE1 ! 61: ! 62: /* SbPro-only commands */ ! 63: #define CMD_SET_BLOCK_SIZE 0x48 ! 64: #define CMD_PLAY_8BIT_HISPEED 0x91 ! 65: ! 66: /* SB16-only commands */ ! 67: #define CMD_SET_OUTPUT_RATE 0x41 ! 68: #define CMD_PLAY_16BIT_SINGLE 0xB0 ! 69: #define CMD_PLAY_16BIT_AUTOINIT 0xB6 ! 70: #define CMD_PLAY_8BIT_SINGLE 0xC0 ! 71: #define CMD_PLAY_8BIT_AUTOINIT 0xC6 ! 72: #define CMD_PAUSE_16BIT_DMA 0xD5 ! 73: #define CMD_CONTINUE_16BIT_DMA 0xD6 ! 74: ! 75: typedef void (*tPlayProc)(UWORD bytes); ! 76: ! 77: typedef struct ! 78: { ! 79: ULONG Data; ! 80: _go32_dpmi_seginfo dma_mem; /* info for DMA memory */ ! 81: } ! 82: tDMABuffer; ! 83: ! 84: tSBType SB_Type; ! 85: ! 86: UWORD SB_Base; /* the Base Address e.g. 220h */ ! 87: UWORD SB_IRQ; /* The IRQ e.g. 5 */ ! 88: UWORD SB_DMAlo; /* Low DMA channel e.g. 1 */ ! 89: UWORD SB_DMAhi; /* high DMA channel e.g. 5 */ ! 90: UWORD SB_INT; /* The Interrupt vector corresponding to IRQ e.g. 0Dh */ ! 91: UWORD SB_DMA; /* The current DMA channel */ ! 92: /* (depends on if we're playing 8Bit or 16Bit sound) */ ! 93: UBYTE SB_VersMaj; /* Major DSP Version byte */ ! 94: UBYTE SB_VersMin; /* Minor DSP Version byte */ ! 95: UBYTE SB_ModeByte; /* Mode Byte for SB16 (Mono/Stereo, Signed/Unsigned ) */ ! 96: UWORD SB_IntClearPort; /* SB Port to read from to acknoledge interrupt */ ! 97: ! 98: tPlayProc SB_Play_Proc; /* function */ ! 99: tDMABuffer dma_buf[2]; /* the two DMA buffers */ ! 100: ! 101: BOOL SB_16Bit; /* we're playing in 16 Bits */ ! 102: BOOL SB_Stereo; /* we're playing in stereo */ ! 103: UWORD SB_Active_Rate; /* the active sampling rate */ ! 104: ! 105: volatile UBYTE IRQ_Detected; /* the detected IRQ number */ ! 106: ! 107: _go32_dpmi_seginfo old_pmint; /* the old interrupt handler */ ! 108: _go32_dpmi_seginfo pm_wrapper; /* the new interrupt handler */ ! 109: ! 110: /* Reset SB at SB_Base, returns TRUE if it worked */ ! 111: BOOL SB_Reset (void) ! 112: { ! 113: outportb (SB_Base+SB_DSP_RESET, 1); ! 114: delay(100); ! 115: outportb (SB_Base+SB_DSP_RESET, 0); ! 116: delay(100); ! 117: return (inportb(SB_Base+SB_DSP_READ_DATA) == 0xAA); ! 118: } ! 119: ! 120: /* Write a command to DSP chip */ ! 121: inline void SB_WriteDSP (UBYTE value) ! 122: { ! 123: while (inportb(SB_Base + SB_DSP_WRITE_STATUS) & 0x80); ! 124: outportb (SB_Base + SB_DSP_WRITE_DATA, value); ! 125: } ! 126: ! 127: /* read a byte from DSP chip */ ! 128: inline UBYTE SB_ReadDSP (void) ! 129: { ! 130: while (!(inportb (SB_Base + SB_DSP_DATA_AVAIL) & 0x80)); ! 131: return (inportb (SB_Base + SB_DSP_READ_DATA)); ! 132: } ! 133: ! 134: /* write a value to the mixer chip */ ! 135: inline void SB_WriteMixer (UBYTE reg, UBYTE data) ! 136: { ! 137: outportb (SB_Base + SB_MIXER_ADDRESS, reg); ! 138: outportb (SB_Base + SB_MIXER_DATA, data); ! 139: } ! 140: ! 141: /* read a value from the mixer chip */ ! 142: inline UBYTE SB_ReadMixer (UBYTE reg) ! 143: { ! 144: outportb (SB_Base + SB_MIXER_ADDRESS, reg); ! 145: return (inportb (SB_Base + SB_MIXER_DATA)); ! 146: } ! 147: ! 148: /* try to detect, if SB has a mixer chip, returns TRUE if found */ ! 149: BOOL SB_DetectMixer (void) ! 150: { ! 151: UBYTE orgval; ! 152: ! 153: orgval = SB_ReadMixer (0x22); ! 154: ! 155: // Some SB-Pro-clones always set the bit 0 and 4, if reading ! 156: // the volume (the bit 0 and 4 aren't used for setting the volume) ! 157: ! 158: SB_WriteMixer (0x22, 0); ! 159: delay(200); ! 160: if ((SB_ReadMixer (0x22)&(0xEE)) != 0) ! 161: return (FALSE); ! 162: ! 163: SB_WriteMixer (0x22, 0xEE); ! 164: delay(200); ! 165: if ((SB_ReadMixer (0x22)&(0xEE)) != 0xEE) ! 166: return (FALSE); ! 167: ! 168: // SB_WriteMixer (0x22, orgval); // Why not setting the volume to maximum ? ! 169: ! 170: return (TRUE); ! 171: } ! 172: ! 173: /* play a block in 8 Bits on a Standard SB */ ! 174: void SB_Play_8Bit_Std (UWORD bytes) ! 175: { ! 176: SB_WriteDSP (CMD_PLAY_8BIT); ! 177: SB_WriteDSP (LOBYTE (bytes-1)); ! 178: SB_WriteDSP (HIBYTE (bytes-1)); ! 179: } ! 180: ! 181: /* Play a block in 8 Bits on an SB PRO */ ! 182: void SB_Play_8Bit_SbPro (UWORD bytes) ! 183: { ! 184: SB_WriteDSP (CMD_SET_BLOCK_SIZE); ! 185: SB_WriteDSP (LOBYTE (bytes-1)); ! 186: SB_WriteDSP (HIBYTE (bytes-1)); ! 187: SB_WriteDSP (CMD_PLAY_8BIT_HISPEED); ! 188: } ! 189: ! 190: /* play a block in 8 Bits on an SB 16 */ ! 191: void SB_Play_8Bit_SB16 (UWORD bytes) ! 192: { ! 193: SB_WriteDSP (CMD_PLAY_8BIT_SINGLE); ! 194: SB_WriteDSP (SB_ModeByte); ! 195: SB_WriteDSP (LOBYTE (bytes-1)); ! 196: SB_WriteDSP (HIBYTE (bytes-1)); ! 197: } ! 198: ! 199: /* play a block in 16 Bits on an SB 16 */ ! 200: void SB_Play_16Bit (UWORD bytes) ! 201: { ! 202: SB_WriteDSP (CMD_PLAY_16BIT_SINGLE); ! 203: SB_WriteDSP (SB_ModeByte); ! 204: SB_WriteDSP (LOBYTE ((bytes>>1) -1)); ! 205: SB_WriteDSP (HIBYTE ((bytes>>1) -1)); ! 206: } ! 207: ! 208: /* the main interrupt handler */ ! 209: void SB_IntHandler (void) ! 210: { ! 211: IsPlaying = FALSE; ! 212: ! 213: inportb (SB_IntClearPort); ! 214: if (SB_IRQ > 7) outportb (0xA0, 0x20); ! 215: ! 216: outportb (0x20, 0x20); ! 217: enable(); ! 218: } ! 219: ! 220: /* set sampling rate on a standard SB */ ! 221: void SB_SetRate_LoSpeed (UWORD rate) ! 222: { ! 223: SB_WriteDSP (CMD_SET_TIME_CONSTANT); ! 224: SB_WriteDSP (0x100 - 1000000 / rate); ! 225: } ! 226: ! 227: /* set sampling rate on a SB PRO */ ! 228: void SB_SetRate_HiSpeed (UWORD rate) ! 229: { ! 230: SB_WriteDSP (CMD_SET_TIME_CONSTANT); ! 231: SB_WriteDSP (HIBYTE (0x10000 - 256000000 / rate)); ! 232: } ! 233: ! 234: /* set sampling rate on an SB 16 */ ! 235: void SB_SetRate_SB16 (UWORD rate) ! 236: { ! 237: SB_WriteDSP (CMD_SET_OUTPUT_RATE); ! 238: SB_WriteDSP (HIBYTE (rate)); ! 239: SB_WriteDSP (LOBYTE (rate)); ! 240: } ! 241: ! 242: /* set the sampling rate */ ! 243: int SB_SetRate (unsigned short rate) ! 244: { ! 245: if (rate > 23000 && SB_Type < SB_Type_SbPro) return(FALSE); ! 246: ! 247: switch (SB_Type) ! 248: { ! 249: case SB_Type_StdSB: SB_SetRate_LoSpeed (rate); break; ! 250: case SB_Type_SbPro: SB_SetRate_HiSpeed (rate); break; ! 251: case SB_Type_SB16: SB_SetRate_SB16 (rate); break; ! 252: } ! 253: ! 254: SB_Active_Rate = rate; ! 255: ! 256: return (TRUE); ! 257: } ! 258: ! 259: /* set the number of bits, i.e. 8 Bit / 16 Bit mode */ ! 260: int SB_SetBits (unsigned char bits) ! 261: { ! 262: if (bits==16 && SB_Type < SB_Type_SB16) return (FALSE); ! 263: ! 264: if (SB_Type == SB_Type_SB16) ! 265: { ! 266: if (bits==16) ! 267: { ! 268: SB_Play_Proc = SB_Play_16Bit; ! 269: SB_IntClearPort = SB_Base + SB_DSP_INT_CLEAR; ! 270: SB_DMA = SB_DMAhi; ! 271: SB_16Bit = TRUE; ! 272: } ! 273: else ! 274: { ! 275: SB_Play_Proc = SB_Play_8Bit_SB16; ! 276: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL; ! 277: SB_DMA = SB_DMAlo; ! 278: SB_16Bit = FALSE; ! 279: } ! 280: } ! 281: ! 282: return (TRUE); ! 283: } ! 284: ! 285: /* set the number of channels, i.e. Mono / Stereo */ ! 286: int SB_SetChannels (unsigned char channels) ! 287: { ! 288: if (channels==2 && SB_Type < SB_Type_SbPro) return (FALSE); ! 289: ! 290: switch (SB_Type) ! 291: { ! 292: case SB_Type_StdSB: break; ! 293: ! 294: case SB_Type_SbPro: ! 295: if (channels==2) SB_WriteMixer (0x0E, SB_ReadMixer (0x0E) | 0x02); ! 296: else SB_WriteMixer (0x0E, SB_ReadMixer (0x0E) & 0xFD); ! 297: break; ! 298: ! 299: case SB_Type_SB16: ! 300: if (channels==2) SB_ModeByte |= 0x20; ! 301: else SB_ModeByte &= 0xDF; ! 302: break; ! 303: } ! 304: SB_Stereo = (channels==2); ! 305: ! 306: return (TRUE); ! 307: } ! 308: ! 309: /* set Signed / Unsigned mode (only on SB 16) */ ! 310: int SB_SetSigned (int sign) ! 311: { ! 312: if (sign && SB_Type < SB_Type_SB16) return (FALSE); ! 313: ! 314: if (SB_Type == SB_Type_SB16) ! 315: { ! 316: if (sign) SB_ModeByte |= 0x10; ! 317: else SB_ModeByte &= 0xEF; ! 318: } ! 319: return (TRUE); ! 320: } ! 321: ! 322: /* turn speaker off (doesn't seem to work on SB 16) */ ! 323: void SB_SpeakerOff(void) ! 324: { ! 325: SB_WriteDSP(CMD_SPEAKER_OFF); ! 326: } ! 327: ! 328: /* turn speaker on (doesn't seem to work on SB 16) */ ! 329: void SB_SpeakerOn(void) ! 330: { ! 331: SB_WriteDSP(CMD_SPEAKER_ON); ! 332: } ! 333: ! 334: /* set sound blaster master volume, range from 0 to 7 */ ! 335: void SB_SetVolume(UBYTE vol) ! 336: { ! 337: ! 338: /* no mixer on standard sb */ ! 339: if (SB_Type < SB_Type_SbPro) ! 340: return; ! 341: ! 342: if (vol>7) ! 343: vol = 7; ! 344: vol = (vol<<1); ! 345: if (SB_Type == SB_Type_SbPro) ! 346: vol = vol | 1; ! 347: vol = vol | (vol<<4); ! 348: ! 349: SB_WriteMixer (0x22, vol); ! 350: } ! 351: ! 352: /* interrupt handler functions used for IRQ/DMA detection */ ! 353: void irq2 (void) ! 354: { ! 355: IRQ_Detected = 2; ! 356: inportb (SB_IntClearPort); ! 357: outportb (0x20, 0x20); ! 358: } ! 359: void irq5 (void) ! 360: { ! 361: IRQ_Detected = 5; ! 362: inportb (SB_IntClearPort); ! 363: outportb (0x20, 0x20); ! 364: } ! 365: void irq7 (void) ! 366: { ! 367: IRQ_Detected = 7; ! 368: inportb (SB_IntClearPort); ! 369: outportb (0x20, 0x20); ! 370: } ! 371: void irq10 (void) ! 372: { ! 373: IRQ_Detected = 10; ! 374: inportb (SB_IntClearPort); ! 375: outportb (0xA0, 0x20); ! 376: outportb (0x20, 0x20); ! 377: } ! 378: ! 379: /* detect the sound blaster Base/IRQ/DMA settings (may hang computer) */ ! 380: int SB_Detect (unsigned short *base, unsigned short *irq, ! 381: unsigned short *dmalo, unsigned short *dmahi) ! 382: { ! 383: #define TESTBUFSIZE 0x80 ! 384: static const UBYTE lowdma[3] = { 1,3,0 }; ! 385: static const UBYTE highdma[3] = { 5,6,7 }; ! 386: ! 387: UBYTE old21,oldA1,old0F,oldDE; ! 388: _go32_dpmi_seginfo oldirq2,oldirq5,oldirq7,oldirq10; ! 389: _go32_dpmi_seginfo newirq2,newirq5,newirq7,newirq10; ! 390: _go32_dpmi_seginfo testbuf_info; ! 391: ULONG testbuf; ! 392: int ret1,ret2,ret3,ret4; ! 393: UBYTE i; ! 394: BOOL found; ! 395: ! 396: found = FALSE; ! 397: ! 398: *base = 0; ! 399: *irq = 0; ! 400: *dmalo = 0; ! 401: *dmahi = 0; ! 402: ! 403: SB_Base = 0x210; ! 404: while (SB_Base != 0x290) ! 405: { ! 406: if (SB_Reset()) break; ! 407: SB_Base += 0x10; ! 408: } ! 409: if (SB_Base == 0x290) return (FALSE); ! 410: *base = SB_Base; ! 411: ! 412: /* install detection interrupt handlers */ ! 413: newirq2.pm_offset = (int) irq2; ! 414: newirq5.pm_offset = (int) irq5; ! 415: newirq7.pm_offset = (int) irq7; ! 416: newirq10.pm_offset = (int) irq10; ! 417: ! 418: ret1 = _go32_dpmi_allocate_iret_wrapper (&newirq2); ! 419: ret2 = _go32_dpmi_allocate_iret_wrapper (&newirq5); ! 420: ret3 = _go32_dpmi_allocate_iret_wrapper (&newirq7); ! 421: ret4 = _go32_dpmi_allocate_iret_wrapper (&newirq10); ! 422: ! 423: if (ret1|ret2|ret3|ret4) ! 424: { ! 425: if (!ret1) _go32_dpmi_free_iret_wrapper (&newirq2); ! 426: if (!ret2) _go32_dpmi_free_iret_wrapper (&newirq5); ! 427: if (!ret3) _go32_dpmi_free_iret_wrapper (&newirq7); ! 428: if (!ret4) _go32_dpmi_free_iret_wrapper (&newirq10); ! 429: return (FALSE); ! 430: } ! 431: _go32_dpmi_lock_code (irq2, (int)SB_Detect - (int)irq2); ! 432: _go32_dpmi_lock_data ((void*)&IRQ_Detected, sizeof(IRQ_Detected)); ! 433: _go32_dpmi_lock_data (&SB_IntClearPort, sizeof(SB_IntClearPort)); ! 434: ! 435: _go32_dpmi_get_protected_mode_interrupt_vector (0x0A, &oldirq2); ! 436: _go32_dpmi_get_protected_mode_interrupt_vector (0x0D, &oldirq5); ! 437: _go32_dpmi_get_protected_mode_interrupt_vector (0x0F, &oldirq7); ! 438: _go32_dpmi_get_protected_mode_interrupt_vector (0x72, &oldirq10); ! 439: ! 440: _go32_dpmi_set_protected_mode_interrupt_vector (0x0A, &newirq2); ! 441: _go32_dpmi_set_protected_mode_interrupt_vector (0x0D, &newirq5); ! 442: _go32_dpmi_set_protected_mode_interrupt_vector (0x0F, &newirq7); ! 443: _go32_dpmi_set_protected_mode_interrupt_vector (0x72, &newirq10); ! 444: ! 445: testbuf_info.size = NUMPARAS(TESTBUFSIZE); ! 446: testbuf = DMA_AllocDMABuf (&testbuf_info); ! 447: ! 448: /* turn on interrupts 2,5,7 and 10 */ ! 449: old21 = inportb (0x21); ! 450: oldA1 = inportb (0xA1); ! 451: outportb (0x21, old21 & 0x5B); ! 452: outportb (0xA1, oldA1 & 0xFB); ! 453: ! 454: /* turn off DMA 0,1,3,5,6 and 7 */ ! 455: old0F = inportb (0x0F); ! 456: oldDE = inportb (0xDE); ! 457: outportb (0x0F, old0F | 0x0B); ! 458: outportb (0xDE, oldDE | 0x0E); ! 459: ! 460: /* fill testbuffer with silence */ ! 461: for (i=0; i<TESTBUFSIZE; i++) _farnspokeb (testbuf+i, 128); ! 462: ! 463: /* detect low DMA and IRQ */ ! 464: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL; ! 465: SB_SetRate_LoSpeed (22050); ! 466: /* program SB to play testbuffer, will start playing */ ! 467: /* when we hit the right DMA channel */ ! 468: SB_Play_8Bit_Std (TESTBUFSIZE); ! 469: ! 470: /* test all DMA channels */ ! 471: IRQ_Detected = 0; ! 472: for (i=0; i<3; i++) ! 473: { ! 474: DMA_InitTransfer (lowdma[i], DMA_READ, testbuf, TESTBUFSIZE); ! 475: delay (TESTBUFSIZE*2000 / 22050); ! 476: if (IRQ_Detected) ! 477: { ! 478: *dmalo = lowdma[i]; ! 479: *irq = IRQ_Detected; ! 480: break; ! 481: } ! 482: } ! 483: ! 484: if (IRQ_Detected) ! 485: { ! 486: found = TRUE; ! 487: ! 488: SB_WriteDSP (CMD_DSP_VER); ! 489: SB_VersMaj = SB_ReadDSP(); ! 490: SB_VersMin = SB_ReadDSP(); ! 491: ! 492: /* if SoundBlaster is an SB16 then test high DMA channel */ ! 493: if (SB_VersMaj >= 4) ! 494: { ! 495: outportb (0x0F, old0F | 0x0B); ! 496: outportb (0xDE, oldDE | 0x0E); ! 497: ! 498: for (i=0; i<TESTBUFSIZE; i+=2) _farnspokew (testbuf+i, 0x8000); ! 499: ! 500: SB_ModeByte = 0x00; ! 501: SB_IntClearPort = SB_Base + SB_DSP_INT_CLEAR; ! 502: SB_SetRate_SB16(44100); ! 503: SB_Play_16Bit(TESTBUFSIZE); ! 504: ! 505: IRQ_Detected = 0; ! 506: for (i=0; i<3; i++) ! 507: { ! 508: DMA_InitTransfer (highdma[i], DMA_READ, testbuf, TESTBUFSIZE); ! 509: delay (TESTBUFSIZE*1000 / 44100); ! 510: if (IRQ_Detected) ! 511: { ! 512: *dmahi = highdma[i]; ! 513: break; ! 514: } ! 515: } ! 516: if (!IRQ_Detected) *dmahi = *dmalo; ! 517: } ! 518: } ! 519: ! 520: /* clean up */ ! 521: _go32_dpmi_free_dos_memory (&testbuf_info); ! 522: ! 523: outportb (0x0F, old0F); ! 524: outportb (0xDE, oldDE); ! 525: outportb (0x21, old21); ! 526: outportb (0xA1, oldA1); ! 527: ! 528: _go32_dpmi_set_protected_mode_interrupt_vector (0x0A, &oldirq2); ! 529: _go32_dpmi_set_protected_mode_interrupt_vector (0x0D, &oldirq5); ! 530: _go32_dpmi_set_protected_mode_interrupt_vector (0x0F, &oldirq7); ! 531: _go32_dpmi_set_protected_mode_interrupt_vector (0x72, &oldirq10); ! 532: ! 533: _go32_dpmi_free_iret_wrapper (&newirq2); ! 534: _go32_dpmi_free_iret_wrapper (&newirq5); ! 535: _go32_dpmi_free_iret_wrapper (&newirq7); ! 536: _go32_dpmi_free_iret_wrapper (&newirq10); ! 537: ! 538: return (found); ! 539: } ! 540: ! 541: int SB_InitBuffers(int bufsize) ! 542: { ! 543: dma_buf[0].dma_mem.size = NUMPARAS(bufsize); ! 544: dma_buf[0].Data = DMA_AllocDMABuf (&dma_buf[0].dma_mem); ! 545: ! 546: dma_buf[1].dma_mem.size = NUMPARAS(bufsize); ! 547: dma_buf[1].Data = DMA_AllocDMABuf (&dma_buf[1].dma_mem); ! 548: ! 549: if ((dma_buf[0].Data == NULL) || (dma_buf[1].Data == NULL)) ! 550: return (FALSE); ! 551: ! 552: return (TRUE); ! 553: } ! 554: ! 555: ! 556: /* init Sound blaster using the given settings */ ! 557: int SB_Init (unsigned short base, unsigned short irq, ! 558: unsigned short dmalo, unsigned short dmahi) ! 559: { ! 560: SB_Base = base; ! 561: SB_IRQ = irq; ! 562: SB_DMAlo = dmalo; ! 563: SB_DMAhi = dmahi; ! 564: ! 565: if (SB_IRQ > 7) SB_INT = 0x68 + SB_IRQ; ! 566: else SB_INT = 0x08 + SB_IRQ; ! 567: ! 568: if (!SB_Reset()) return (FALSE); ! 569: ! 570: pm_wrapper.pm_offset = (int) SB_IntHandler; ! 571: if (_go32_dpmi_allocate_iret_wrapper (&pm_wrapper)) ! 572: { ! 573: printf ("Cannot allocate protected mode wrapper for SB interrupt!\n"); ! 574: _go32_dpmi_free_dos_memory (&dma_buf[0].dma_mem); ! 575: _go32_dpmi_free_dos_memory (&dma_buf[1].dma_mem); ! 576: return (FALSE); ! 577: } ! 578: ! 579: _go32_dpmi_lock_code (SB_WriteDSP, (ULONG)SB_WriteMixer - (ULONG)SB_WriteDSP); ! 580: _go32_dpmi_lock_data (&SB_Base, (ULONG)&old_pmint - (ULONG)&SB_Base); ! 581: ! 582: _go32_dpmi_get_protected_mode_interrupt_vector (SB_INT, &old_pmint); ! 583: _go32_dpmi_set_protected_mode_interrupt_vector (SB_INT, &pm_wrapper); ! 584: ! 585: if (SB_IRQ>7) ! 586: outportb(0xA1, inportb(0xA1) & ~(1 << (SB_IRQ-8))); ! 587: else ! 588: outportb(0x21, inportb(0x21) & ~(1 << SB_IRQ)); ! 589: ! 590: SB_Type = SB_Type_StdSB; ! 591: ! 592: if( SB_DetectMixer() != FALSE ) ! 593: SB_Type = SB_Type_SbPro; ! 594: ! 595: SB_WriteDSP (CMD_DSP_VER); ! 596: SB_VersMaj = SB_ReadDSP (); ! 597: SB_VersMin = SB_ReadDSP (); ! 598: ! 599: if (SB_VersMaj >= 4) SB_Type = SB_Type_SB16; ! 600: ! 601: // SB_Type = SB_Type_SbPro; /* for testing */ ! 602: ! 603: /* initialize SB to default 8Bit Mono 22050Hz */ ! 604: /* (available on all SoundBlaster Versions) */ ! 605: switch (SB_Type) ! 606: { ! 607: case SB_Type_StdSB: ! 608: SB_Play_Proc = SB_Play_8Bit_Std; ! 609: SB_SetRate_LoSpeed(22050); ! 610: break; ! 611: case SB_Type_SbPro: ! 612: SB_Play_Proc = SB_Play_8Bit_SbPro; ! 613: SB_SetRate_HiSpeed(22050); ! 614: break; ! 615: case SB_Type_SB16: ! 616: SB_Play_Proc = SB_Play_8Bit_SB16; ! 617: SB_SetRate_SB16(22050); ! 618: break; ! 619: } ! 620: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL; ! 621: SB_DMA = SB_DMAlo; ! 622: IsPlaying = FALSE; ! 623: SB_16Bit = FALSE; ! 624: SB_Stereo = FALSE; ! 625: SB_Active_Rate = 22050; ! 626: SB_ModeByte = 0x00; ! 627: ! 628: SB_SpeakerOn(); ! 629: SB_SetVolume(6); ! 630: ! 631: return (TRUE); ! 632: } ! 633: ! 634: /* clean up Sound Blaster */ ! 635: void SB_Done (void) ! 636: { ! 637: SB_Reset (); ! 638: if (SB_IRQ > 7) ! 639: outportb (0xA1, inportb(0xA1) | (1 << (SB_IRQ-8))); ! 640: else ! 641: outportb (0x21, inportb(0x21) | (1 << SB_IRQ)); ! 642: ! 643: _go32_dpmi_set_protected_mode_interrupt_vector (SB_INT, &old_pmint); ! 644: _go32_dpmi_free_iret_wrapper (&pm_wrapper); ! 645: _go32_dpmi_free_dos_memory (&dma_buf[0].dma_mem); ! 646: _go32_dpmi_free_dos_memory (&dma_buf[1].dma_mem); ! 647: } ! 648: ! 649: /* write sound data to be played to the fifo buffer */ ! 650: void SB_DirectWrite(unsigned int size, int freq) ! 651: { ! 652: DMA_InitTransfer (SB_DMA, DMA_READ, dma_buf[CurrentBuffer].Data, size); ! 653: (*SB_Play_Proc) (size); ! 654: IsPlaying = TRUE; ! 655: if (freq != SB_Active_Rate) ! 656: SB_SetRate(freq); ! 657: } ! 658: ! 659: /* return thee DSP chip version */ ! 660: void SB_GetVersion (unsigned char *Maj, unsigned char *Min) ! 661: { ! 662: *Maj = SB_VersMaj; ! 663: *Min = SB_VersMin; ! 664: } ! 665: ! 666: /* Detection Routine */ ! 667: int SB_DetectInitSound(int *dspbits, int *dsprate, int *sndbufsize, unsigned int *direct_buffers, int *stereo_sound) ! 668: { ! 669: UWORD base,irq,dmalo,dmahi; ! 670: char *blaster; ! 671: char *tok; ! 672: int have_sound; ! 673: extern void (*SND_DirectWrite)(unsigned int size, int freq); ! 674: ! 675: if ((*sndbufsize) > 65536) ! 676: *sndbufsize = 65536; ! 677: if ((*sndbufsize) < 4) ! 678: *sndbufsize = 4; ! 679: *sndbufsize = ((*sndbufsize)>>2)<<2; ! 680: ! 681: blaster = getenv ("BLASTER"); ! 682: if (blaster == NULL) ! 683: { ! 684: printf ("No BLASTER variable found!\n" ! 685: "Detecting SoundBlaster Settings...."); fflush (stdout); ! 686: have_sound = SB_Detect (&base, &irq, &dmalo, &dmahi); ! 687: if (!have_sound) ! 688: { ! 689: printf ("Not found!!\n"); ! 690: return (0); ! 691: } ! 692: printf ("Found! Base: %hx IRQ: %hd DMA: %hd,%hd\n", ! 693: base, irq, dmalo,dmahi); ! 694: } ! 695: else ! 696: { ! 697: base = 0; irq = 0; dmalo = 0; dmahi = 0; ! 698: ! 699: tok = strtok(blaster, " \t"); ! 700: while (tok != NULL) ! 701: { ! 702: switch (toupper(*tok)) ! 703: { ! 704: case 'A': sscanf(tok+1, "%hx", &base); break; ! 705: case 'I': sscanf(tok+1, "%hd", &irq); break; ! 706: case 'D': sscanf(tok+1, "%hd", &dmalo); break; ! 707: case 'H': sscanf(tok+1, "%hd", &dmahi); break; ! 708: default: break; ! 709: } ! 710: tok = strtok (NULL, " \t"); ! 711: } ! 712: printf ("SoundBlaster Settings taken from BLASTER variable:\n" ! 713: " Base: %hx IRQ: %hd DMA: %hd,%hd\n", base,irq,dmalo,dmahi); ! 714: } ! 715: ! 716: if (!SB_InitBuffers(*sndbufsize)) ! 717: { ! 718: fprintf(stderr, "Can't set sound buffers to %d!\n", *sndbufsize); ! 719: return(0); ! 720: } ! 721: ! 722: have_sound = SB_Init (base, irq, dmalo, dmahi); ! 723: if (!have_sound) ! 724: { ! 725: printf ("Cannot Initialize Soundblaster!\n"); ! 726: return (0); ! 727: } ! 728: ! 729: if (((*dspbits) == 16) && (SB_SetBits (16))) ! 730: SB_SetSigned (1); ! 731: else ! 732: *dspbits = 8; ! 733: ! 734: if (*stereo_sound) { ! 735: *stereo_sound = SB_SetChannels(2); ! 736: if (!(*stereo_sound)) ! 737: fprintf(stderr, "Warning, stereo not suporeted!\n"); ! 738: } ! 739: ! 740: if (!SB_SetRate(*dsprate)) ! 741: { ! 742: fprintf(stderr, "SoundBlaster%s can't use sample rate %d!\n", ! 743: SB_Type==SB_Type_StdSB ? "" : ! 744: (SB_Type==SB_Type_SbPro ? " PRO" : " 16"), ! 745: *dsprate); ! 746: return(0); ! 747: } ! 748: ! 749: printf ("SoundBlaster%s found.\n", ! 750: SB_Type==SB_Type_StdSB ? "" : ! 751: (SB_Type==SB_Type_SbPro ? " PRO" : " 16")); ! 752: ! 753: SND_DirectWrite = SB_DirectWrite; ! 754: direct_buffers[0] = dma_buf[0].Data; ! 755: direct_buffers[1] = dma_buf[1].Data; ! 756: ! 757: atexit (SB_Done); ! 758: ! 759: return 1; ! 760: } ! 761: ! 762: /* that's it... */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.