![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dos-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|
Return to dos-sb.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * DOS Sound Blaster interface.
5: *
6: * (c) 1996 Peter Remmers
7: */
8:
9: #include "sysconfig.h"
10: #include "sysdeps.h"
11:
12: #include <stdlib.h>
13: #include <stdio.h>
14: #include <string.h>
15: #include <ctype.h>
16: #include <dos.h>
17: #include <pc.h>
18: #include <sys/farptr.h>
19: #include <dpmi.h>
20: #include <go32.h>
21:
22: #include "dos-sb.h"
23: #include "dos-dma.h"
24:
25: /* some useful macros */
26: #define LOBYTE(x) ((UBYTE)(((UWORD)(x)) & 0xFF))
27: #define HIBYTE(x) ((UBYTE)(((UWORD)(x)) >> 8))
28: #define LOWORD(x) ((UWORD)(((ULONG)(x)) & 0xFFFF))
29: #define HIWORD(x) ((UWORD)(((ULONG)(x)) >> 16))
30: #define NUMPARAS(bytesize) (((bytesize)+15) >> 4)
31:
32: #ifndef TRUE
33: #define TRUE 1
34: #endif
35: #ifndef FALSE
36: #define FALSE 0
37: #endif
38:
39: /* Offsets relative to base I/O address. */
40: #define SB_MIXER_ADDRESS 0x04
41: #define SB_MIXER_DATA 0x05
42: #define SB_DSP_RESET 0x06
43: #define SB_DSP_READ_DATA 0x0A
44: #define SB_DSP_WRITE_DATA 0x0C
45: #define SB_DSP_WRITE_STATUS 0x0C
46: #define SB_DSP_DATA_AVAIL 0x0E
47: #define SB_DSP_INT_CLEAR 0x0F
48:
49: /* DSP Commands */
50: #define CMD_PLAY_8BIT 0x14
51: #define CMD_SET_TIME_CONSTANT 0x40
52: #define CMD_DEFINE_SILENCE_BLOCK 0x80
53: #define CMD_PAUSE_8BIT_DMA 0xD0
54: #define CMD_CONTINUE_8BIT_DMA 0xD4
55: #define CMD_SPEAKER_ON 0xD1
56: #define CMD_SPEAKER_OFF 0xD3
57: #define CMD_GET_SPEAKER_SETTING 0xD8
58: #define CMD_DSP_VER 0xE1
59:
60: /* SbPro-only commands */
61: #define CMD_SET_BLOCK_SIZE 0x48
62: #define CMD_PLAY_8BIT_HISPEED 0x91
63:
64: /* SB16-only commands */
65: #define CMD_SET_OUTPUT_RATE 0x41
66: #define CMD_PLAY_16BIT_SINGLE 0xB0
67: #define CMD_PLAY_16BIT_AUTOINIT 0xB6
68: #define CMD_PLAY_8BIT_SINGLE 0xC0
69: #define CMD_PLAY_8BIT_AUTOINIT 0xC6
70: #define CMD_PAUSE_16BIT_DMA 0xD5
71: #define CMD_CONTINUE_16BIT_DMA 0xD6
72:
73: #define DMA_BUF_SIZE 14700 /* absolute maximum (FIFO_BUF_SIZE / 3) */
74: #define FIFO_BUF_SIZE 58800 /* max size for 1/4th second sound at */
75: /* 44100Hz 16Bits Stereo */
76: #define DESIRED_INT_RATE 70 /* The interrupt rate in Hz. The block size is */
77: /* calculated from sampling rate and this value */
78:
79: typedef void (*tPlayProc)(UWORD bytes);
80: typedef struct
81: {
82: ULONG Data;
83: UWORD Size;
84: }
85: tDMABuffer;
86:
87: tSBType SB_Type;
88:
89: UWORD SB_Base; /* the Base Address e.g. 220h */
90: UWORD SB_IRQ; /* The IRQ e.g. 5 */
91: UWORD SB_DMAlo; /* Low DMA channel e.g. 1 */
92: UWORD SB_DMAhi; /* high DMA channel e.g. 5 */
93: UWORD SB_INT; /* The Interrupt vector corresponding to IRQ e.g. 0Dh */
94: UWORD SB_DMA; /* The current DMA channel */
95: /* (depends on if we're playing 8Bit or 16Bit sound) */
96: UBYTE SB_VersMaj; /* Major DSP Version byte */
97: UBYTE SB_VersMin; /* Minor DSP Version byte */
98: UBYTE SB_ModeByte; /* Mode Byte for SB16 (Mono/Stereo, Signed/Unsigned ) */
99: UBYTE SB_StopByte; /* DSP command to stop DMA */
100: UBYTE SB_ContByte; /* DSP command to continue DMA */
101: UWORD SB_IntClearPort; /* SB Port to read from to acknoledge interrupt */
102:
103: tPlayProc SB_Single_Play_Proc; /* single-cycle play function */
104: tPlayProc SB_Play_Proc; /* autoinitialized DMA play function */
105:
106: volatile int SB_Playing; /* Sound is currently playing */
107: volatile unsigned long SB_Bytes_Played; /* number of bytes played so far */
108:
109: volatile tDMABuffer dma_buf[2]; /* the two DMA buffers */
110: volatile UBYTE active_buf; /* the currently playing buffer */
111: volatile UBYTE last_buf; /* last buffer to play */
112: volatile UWORD last_block_size; /* size of the previously played block */
113: UWORD dma_block_size; /* size of one DMA block */
114:
115: UBYTE fifobuf[FIFO_BUF_SIZE]; /* a ring buffer for sound buffering */
116: UWORD fifo_max; /* max fill size of fifo buffer */
117: UWORD fifo_write_index; /* the index to write to the fifo buffer */
118: UWORD fifo_read_index; /* the index to read from the fifo buffer */
119: volatile UWORD fifo_size; /* the current fill size */
120:
121: BOOL SB_Autoinit; /* we're currently using autoinitialized DMA mode */
122: BOOL SB_Stopped; /* Sound is stopped */
123: BOOL SB_16Bit; /* we're playing in 16 Bits */
124: BOOL SB_Stereo; /* we're playing in stereo */
125: UWORD SB_Active_Rate; /* the active sampling rate */
126:
127: volatile UBYTE IRQ_Detected; /* the detected IRQ number */
128:
129: _go32_dpmi_registers cb_regs; /* the registers for the int handler */
130: _go32_dpmi_seginfo old_pmint; /* the old interrupt handler */
131: _go32_dpmi_seginfo pm_wrapper; /* the new interrupt handler */
132: _go32_dpmi_seginfo dma_mem; /* info for DMA memory */
133:
134: /* Reset SB at SB_Base, returns TRUE if it worked */
135: BOOL SB_Reset(void)
136: {
137: outportb (SB_Base+SB_DSP_RESET, 1);
138: delay(10);
139: outportb (SB_Base+SB_DSP_RESET, 0);
140: delay(100);
141: return (inportb(SB_Base+SB_DSP_READ_DATA) == 0xAA);
142: }
143:
144: /* Write a command to DSP chip */
145: void SB_WriteDSP (UBYTE value)
146: {
147: while (inportb(SB_Base + SB_DSP_WRITE_STATUS) & 0x80);
148: outportb (SB_Base + SB_DSP_WRITE_DATA, value);
149: }
150:
151: /* read a byte from DSP chip */
152: UBYTE SB_ReadDSP (void)
153: {
154: while (!(inportb (SB_Base + SB_DSP_DATA_AVAIL) & 0x80));
155: return (inportb (SB_Base + SB_DSP_READ_DATA));
156: }
157:
158: /* write a value to the mixer chip */
159: void SB_WriteMixer (UBYTE reg, UBYTE data)
160: {
161: outportb (SB_Base + SB_MIXER_ADDRESS, reg);
162: outportb (SB_Base + SB_MIXER_DATA, data);
163: }
164:
165: /* read a value from the mixer chip */
166: UBYTE SB_ReadMixer (UBYTE reg)
167: {
168: outportb (SB_Base + SB_MIXER_ADDRESS, reg);
169: return (inportb (SB_Base + SB_MIXER_DATA));
170: }
171:
172: /* try to detect, if SB has a mixer chip, returns TRUE if found */
173: BOOL SB_DetectMixer (void)
174: {
175: UBYTE orgval;
176:
177: orgval = SB_ReadMixer (0x22);
178:
179: SB_WriteMixer (0x22, 0);
180: if (SB_ReadMixer (0x22) != 0) return (FALSE);
181:
182: SB_WriteMixer (0x22, 0xEE);
183: if (SB_ReadMixer (0x22) != 0xEE) return (FALSE);
184:
185: SB_WriteMixer (0x22, orgval);
186:
187: return (TRUE);
188: }
189:
190: /* read a byte from the fifo buffer */
191: UBYTE fifo_read (void)
192: {
193: UBYTE ret;
194:
195: if (fifo_size == 0) return(0);
196: ret = fifobuf[fifo_read_index++];
197: if (fifo_read_index == fifo_max) fifo_read_index = 0;
198: fifo_size--;
199:
200: return (ret);
201: }
202:
203: /* write a byte to the fifo buffer */
204: void fifo_write (UBYTE val)
205: {
206: if (fifo_size == fifo_max) return;
207: fifobuf[fifo_write_index++] = val;
208: if (fifo_write_index == fifo_max) fifo_write_index = 0;
209: fifo_size++;
210: }
211:
212: /* fill a DMA buffer with data from the fifo buffer */
213: /* if fifo buffer is empty after this, the DMA buffer */
214: /* is marked to be the last one to be played */
215: void fill_buffer (UBYTE buf)
216: {
217: register int i;
218: register UWORD size;
219: register ULONG p;
220:
221: if (fifo_size == 0) return;
222:
223: disable();
224:
225: if (fifo_size < dma_block_size) size = fifo_size;
226: else size = dma_block_size;
227: dma_buf[buf].Size = size;
228:
229: p = dma_buf[buf].Data;
230:
231: _farsetsel (_dos_ds);
232: for (i=0; i < size; i++) _farnspokeb (p++, fifo_read());
233:
234: if (fifo_size == 0) last_buf = buf;
235:
236: enable ();
237: }
238:
239: /* play a block in 8 Bits on a Standard SB */
240: void SB_Play_8Bit_Std (UWORD bytes)
241: {
242: SB_WriteDSP (CMD_PLAY_8BIT);
243: SB_WriteDSP (LOBYTE (bytes-1));
244: SB_WriteDSP (HIBYTE (bytes-1));
245: }
246:
247: /* Play a block in 8 Bits on an SB PRO */
248: void SB_Play_8Bit_SbPro (UWORD bytes)
249: {
250: if (bytes != last_block_size)
251: {
252: SB_WriteDSP (CMD_SET_BLOCK_SIZE);
253: SB_WriteDSP (LOBYTE (bytes-1));
254: SB_WriteDSP (HIBYTE (bytes-1));
255: last_block_size = bytes;
256: }
257: SB_WriteDSP (CMD_PLAY_8BIT_HISPEED);
258: }
259:
260: /* play a block in 8 Bits on an SB 16 */
261: void SB_Play_8Bit_SB16 (UWORD bytes)
262: {
263: SB_WriteDSP (CMD_PLAY_8BIT_SINGLE);
264: SB_WriteDSP (SB_ModeByte);
265: SB_WriteDSP (LOBYTE (bytes-1));
266: SB_WriteDSP (HIBYTE (bytes-1));
267: }
268:
269: /* play a block in 8 Bits on an SB 16 using autoinitialized DMA */
270: void SB_Play_8Bit_SB16_Autoinit (UWORD bytes)
271: {
272: SB_WriteDSP (CMD_PLAY_8BIT_AUTOINIT);
273: SB_WriteDSP (SB_ModeByte);
274: SB_WriteDSP (LOBYTE (bytes-1));
275: SB_WriteDSP (HIBYTE (bytes-1));
276: }
277:
278: /* play a block in 16 Bits on an SB 16 */
279: void SB_Play_16Bit (UWORD bytes)
280: {
281: SB_WriteDSP (CMD_PLAY_16BIT_SINGLE);
282: SB_WriteDSP (SB_ModeByte);
283: SB_WriteDSP (LOBYTE ((bytes>>1) -1));
284: SB_WriteDSP (HIBYTE ((bytes>>1) -1));
285: }
286:
287: /* play a block in 16 Bits on an SB 16 using autoinitialized DMA */
288: void SB_Play_16Bit_Autoinit (UWORD bytes)
289: {
290: SB_WriteDSP (CMD_PLAY_16BIT_AUTOINIT);
291: SB_WriteDSP (SB_ModeByte);
292: SB_WriteDSP (LOBYTE ((bytes>>1) -1));
293: SB_WriteDSP (HIBYTE ((bytes>>1) -1));
294: }
295:
296: /* the interrupt handler for playing in single-cycle mode */
297: void SB_IntHandler_Single (void)
298: {
299: UBYTE h = 1-active_buf;
300:
301: if (last_buf != 0xFF && fifo_size > 0)
302: {
303: last_buf = 0xFF;
304: last_block_size = 0;
305:
306: /* if we just played the last block and there's already new data */
307: /* in the fifo buffer, then continue playing with the new data */
308: if (active_buf == last_buf)
309: {
310: fill_buffer (0);
311: DMA_InitTransfer (SB_DMA, DMA_READ_AUTOINIT,
312: dma_buf[0].Data, dma_block_size*2);
313: h = 0;
314: }
315: }
316:
317: (*SB_Single_Play_Proc) (dma_buf[h].Size);
318: fill_buffer (active_buf);
319: active_buf = h;
320: }
321:
322: /* interrupt handler for playing in autoinitialized DMA mode */
323: void SB_IntHandler_Autoinit (void)
324: {
325: if (last_buf != 0xFF)
326: {
327: if (active_buf == last_buf && fifo_size > 0)
328: {
329: last_buf = 0xFF;
330: active_buf = 0;
331:
332: DMA_InitTransfer (SB_DMA, DMA_READ_AUTOINIT,
333: dma_buf[0].Data, dma_block_size*2);
334:
335: fill_buffer (0);
336: if (fifo_size == 0)
337: (*SB_Single_Play_Proc) (dma_buf[0].Size);
338: else
339: {
340: (*SB_Play_Proc) (dma_block_size);
341: fill_buffer(1);
342: if (fifo_size == 0)
343: (*SB_Single_Play_Proc) (dma_buf[1].Size);
344: }
345: }
346: else active_buf = 1 - active_buf;
347: }
348: else
349: {
350: fill_buffer (active_buf);
351:
352: if (active_buf == last_buf)
353: (*SB_Single_Play_Proc) (dma_buf[active_buf].Size);
354:
355: active_buf = 1 - active_buf;
356: }
357: }
358:
359: /* the main interrupt handler */
360: void SB_IntHandler (void)
361: {
362: SB_Bytes_Played += dma_buf[active_buf].Size;
363:
364: if (active_buf == last_buf && fifo_size == 0) SB_Playing = FALSE;
365: else if (SB_Autoinit) SB_IntHandler_Autoinit();
366: else SB_IntHandler_Single();
367:
368: inportb (SB_IntClearPort);
369: if (SB_IRQ > 7) outportb (0xA0, 0x20);
370:
371: outportb (0x20, 0x20);
372: enable();
373: }
374:
375: /* set sampling rate on a standard SB */
376: void SB_SetRate_LoSpeed (UWORD rate)
377: {
378: SB_WriteDSP (CMD_SET_TIME_CONSTANT);
379: SB_WriteDSP (0x100 - 1000000 / rate);
380: }
381:
382: /* set sampling rate on a SB PRO */
383: void SB_SetRate_HiSpeed (UWORD rate)
384: {
385: SB_WriteDSP (CMD_SET_TIME_CONSTANT);
386: SB_WriteDSP (HIBYTE (0x10000 - 256000000 / rate));
387: }
388:
389: /* set sampling rate on an SB 16 */
390: void SB_SetRate_SB16 (UWORD rate)
391: {
392: SB_WriteDSP (CMD_SET_OUTPUT_RATE);
393: SB_WriteDSP (HIBYTE (rate));
394: SB_WriteDSP (LOBYTE (rate));
395: }
396:
397: /* calculates the DMA block size and the fifo size */
398: /* from sampling rate and the desired interrupt rate */
399: void calculate_buf_sizes(void)
400: {
401: ULONG rate;
402:
403: rate = SB_Active_Rate;
404: if (SB_16Bit) rate <<= 1;
405: if (SB_Stereo) rate <<= 1;
406: /* rate is now bytes per second */
407: dma_block_size = (rate / DESIRED_INT_RATE) & ~3; /* make multiples of 4 */
408: dma_buf[1].Data = dma_buf[0].Data + dma_block_size;
409: fifo_max = rate / 4; /* make fifo size 1/4th second of sound */
410: }
411:
412: /* set the sampling rate */
413: int SB_SetRate (unsigned short rate)
414: {
415: if (rate > 23000 && SB_Type < SB_Type_SbPro) return(FALSE);
416:
417: switch (SB_Type)
418: {
419: case SB_Type_StdSB: SB_SetRate_LoSpeed (rate); break;
420: case SB_Type_SbPro: SB_SetRate_HiSpeed (rate); break;
421: case SB_Type_SB16: SB_SetRate_SB16 (rate); break;
422: }
423:
424: SB_Active_Rate = rate;
425:
426: calculate_buf_sizes();
427:
428: return (TRUE);
429: }
430:
431: /* set the number of bits, i.e. 8 Bit / 16 Bit mode */
432: int SB_SetBits (unsigned char bits)
433: {
434: if (bits==16 && SB_Type < SB_Type_SB16) return (FALSE);
435:
436: if (SB_Type == SB_Type_SB16)
437: {
438: if (bits==16)
439: {
440: SB_Play_Proc = SB_Play_16Bit_Autoinit;
441: SB_Single_Play_Proc = SB_Play_16Bit;
442: SB_IntClearPort = SB_Base + SB_DSP_INT_CLEAR;
443: SB_DMA = SB_DMAhi;
444: SB_StopByte = CMD_PAUSE_16BIT_DMA;
445: SB_ContByte = CMD_CONTINUE_16BIT_DMA;
446: SB_16Bit = TRUE;
447: }
448: else
449: {
450: SB_Play_Proc = SB_Play_8Bit_SB16_Autoinit;
451: SB_Single_Play_Proc = SB_Play_8Bit_SB16;
452: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL;
453: SB_DMA = SB_DMAlo;
454: SB_StopByte = CMD_PAUSE_8BIT_DMA;
455: SB_ContByte = CMD_CONTINUE_8BIT_DMA;
456: SB_16Bit = FALSE;
457: }
458: }
459:
460: calculate_buf_sizes();
461:
462: return (TRUE);
463: }
464:
465: /* set the number of channels, i.e. Mono / Stereo */
466: int SB_SetChannels (unsigned char channels)
467: {
468: if (channels==2 && SB_Type < SB_Type_SbPro) return (FALSE);
469:
470: switch (SB_Type)
471: {
472: case SB_Type_StdSB: break;
473:
474: case SB_Type_SbPro:
475: if (channels==2) SB_WriteMixer (0x0E, SB_ReadMixer (0x0E) | 0x02);
476: else SB_WriteMixer (0x0E, SB_ReadMixer (0x0E) & 0xFD);
477: break;
478:
479: case SB_Type_SB16:
480: if (channels==2) SB_ModeByte |= 0x20;
481: else SB_ModeByte &= 0xDF;
482: break;
483: }
484: SB_Stereo = (channels==2);
485:
486: calculate_buf_sizes();
487:
488: return (TRUE);
489: }
490:
491: /* set Signed / Unsigned mode (only on SB 16) */
492: int SB_SetSigned (int sign)
493: {
494: if (sign && SB_Type < SB_Type_SB16) return (FALSE);
495:
496: if (SB_Type == SB_Type_SB16)
497: {
498: if (sign) SB_ModeByte |= 0x10;
499: else SB_ModeByte &= 0xEF;
500: }
501: return (TRUE);
502: }
503:
504: /* turn speaker off (doesn't seem to work on SB 16) */
505: void SB_SpeakerOff(void)
506: {
507: SB_WriteDSP(CMD_SPEAKER_OFF);
508: }
509:
510: /* turn speaker on (doesn't seem to work on SB 16) */
511: void SB_SpeakerOn(void)
512: {
513: SB_WriteDSP(CMD_SPEAKER_ON);
514: }
515:
516: /* start playing the sound data in the fifo buffer */
517: void SB_Play (void)
518: {
519: if (fifo_size == 0) return;
520:
521: active_buf = 0;
522: last_buf = 0xFF;
523: last_block_size = 0;
524:
525: DMA_InitTransfer (SB_DMA, DMA_READ_AUTOINIT,
526: dma_buf[0].Data, dma_block_size*2);
527: if (SB_Autoinit)
528: {
529: fill_buffer (0);
530: if (fifo_size == 0)
531: (*SB_Single_Play_Proc) (dma_buf[0].Size);
532: else
533: {
534: (*SB_Play_Proc) (dma_block_size);
535: fill_buffer(1);
536: if (fifo_size == 0) (*SB_Single_Play_Proc) (dma_buf[1].Size);
537: }
538: }
539: else
540: {
541: fill_buffer(0);
542: (*SB_Single_Play_Proc) (dma_buf[0].Size);
543: fill_buffer(1);
544: }
545:
546: SB_Playing = TRUE;
547: }
548:
549: /* interrupt handler functions used for IRQ/DMA detection */
550: void irq2 (void)
551: {
552: IRQ_Detected = 2;
553: inportb (SB_IntClearPort);
554: outportb (0x20, 0x20);
555: }
556: void irq5 (void)
557: {
558: IRQ_Detected = 5;
559: inportb (SB_IntClearPort);
560: outportb (0x20, 0x20);
561: }
562: void irq7 (void)
563: {
564: IRQ_Detected = 7;
565: inportb (SB_IntClearPort);
566: outportb (0x20, 0x20);
567: }
568: void irq10 (void)
569: {
570: IRQ_Detected = 10;
571: inportb (SB_IntClearPort);
572: outportb (0xA0, 0x20);
573: outportb (0x20, 0x20);
574: }
575:
576: /* detect the sound blaster Base/IRQ/DMA settings (may hang computer) */
577: int SB_Detect (unsigned short *base, unsigned short *irq,
578: unsigned short *dmalo, unsigned short *dmahi)
579: {
580: #define TESTBUFSIZE 0x80
581: static const UBYTE lowdma[3] = { 1,3,0 };
582: static const UBYTE highdma[3] = { 5,6,7 };
583:
584: UBYTE old21,oldA1,old0F,oldDE;
585: _go32_dpmi_seginfo oldirq2,oldirq5,oldirq7,oldirq10;
586: _go32_dpmi_seginfo newirq2,newirq5,newirq7,newirq10;
587: _go32_dpmi_seginfo testbuf_info;
588: ULONG testbuf;
589: int ret1,ret2,ret3,ret4;
590: UBYTE i;
591: BOOL found;
592:
593: found = FALSE;
594:
595: *base = 0;
596: *irq = 0;
597: *dmalo = 0;
598: *dmahi = 0;
599:
600: SB_Base = 0x210;
601: while (SB_Base != 0x290)
602: {
603: if (SB_Reset()) break;
604: SB_Base += 0x10;
605: }
606: if (SB_Base == 0x290) return (FALSE);
607: *base = SB_Base;
608:
609: /* install detection interrupt handlers */
610: newirq2.pm_offset = (int) irq2;
611: newirq5.pm_offset = (int) irq5;
612: newirq7.pm_offset = (int) irq7;
613: newirq10.pm_offset = (int) irq10;
614:
615: ret1 = _go32_dpmi_allocate_iret_wrapper (&newirq2);
616: ret2 = _go32_dpmi_allocate_iret_wrapper (&newirq5);
617: ret3 = _go32_dpmi_allocate_iret_wrapper (&newirq7);
618: ret4 = _go32_dpmi_allocate_iret_wrapper (&newirq10);
619:
620: if (ret1|ret2|ret3|ret4)
621: {
622: if (!ret1) _go32_dpmi_free_iret_wrapper (&newirq2);
623: if (!ret2) _go32_dpmi_free_iret_wrapper (&newirq5);
624: if (!ret3) _go32_dpmi_free_iret_wrapper (&newirq7);
625: if (!ret4) _go32_dpmi_free_iret_wrapper (&newirq10);
626: return (FALSE);
627: }
628: _go32_dpmi_lock_code (irq2, (int)SB_Detect - (int)irq2);
629: _go32_dpmi_lock_data ((void*)&IRQ_Detected, sizeof(IRQ_Detected));
630: _go32_dpmi_lock_data (&SB_IntClearPort, sizeof(SB_IntClearPort));
631:
632: _go32_dpmi_get_protected_mode_interrupt_vector (0x0A, &oldirq2);
633: _go32_dpmi_get_protected_mode_interrupt_vector (0x0D, &oldirq5);
634: _go32_dpmi_get_protected_mode_interrupt_vector (0x0F, &oldirq7);
635: _go32_dpmi_get_protected_mode_interrupt_vector (0x72, &oldirq10);
636:
637: _go32_dpmi_set_protected_mode_interrupt_vector (0x0A, &newirq2);
638: _go32_dpmi_set_protected_mode_interrupt_vector (0x0D, &newirq5);
639: _go32_dpmi_set_protected_mode_interrupt_vector (0x0F, &newirq7);
640: _go32_dpmi_set_protected_mode_interrupt_vector (0x72, &newirq10);
641:
642: testbuf_info.size = NUMPARAS(TESTBUFSIZE);
643: testbuf = DMA_AllocDMABuf (&testbuf_info);
644:
645: /* turn on interrupts 2,5,7 and 10 */
646: old21 = inportb (0x21);
647: oldA1 = inportb (0xA1);
648: outportb (0x21, old21 & 0x5B);
649: outportb (0xA1, oldA1 & 0xFB);
650:
651: /* turn off DMA 0,1,3,5,6 and 7 */
652: old0F = inportb (0x0F);
653: oldDE = inportb (0xDE);
654: outportb (0x0F, old0F | 0x0B);
655: outportb (0xDE, oldDE | 0x0E);
656:
657: /* fill testbuffer with silence */
658: _farsetsel (_dos_ds);
659: for (i=0; i<TESTBUFSIZE; i++) _farnspokeb (testbuf+i, 128);
660:
661: /* detect low DMA and IRQ */
662: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL;
663: SB_SetRate_LoSpeed (22050);
664: /* program SB to play testbuffer, will start playing */
665: /* when we hit the right DMA channel */
666: SB_Play_8Bit_Std (TESTBUFSIZE);
667:
668: /* test all DMA channels */
669: IRQ_Detected = 0;
670: for (i=0; i<3; i++)
671: {
672: DMA_InitTransfer (lowdma[i], DMA_READ, testbuf, TESTBUFSIZE);
673: delay (TESTBUFSIZE*2000 / 22050);
674: if (IRQ_Detected)
675: {
676: *dmalo = lowdma[i];
677: *irq = IRQ_Detected;
678: break;
679: }
680: }
681:
682: if (IRQ_Detected)
683: {
684: found = TRUE;
685:
686: SB_WriteDSP (CMD_DSP_VER);
687: SB_VersMaj = SB_ReadDSP();
688: SB_VersMin = SB_ReadDSP();
689:
690: /* if SoundBlaster is an SB16 then test high DMA channel */
691: if (SB_VersMaj >= 4)
692: {
693: outportb (0x0F, old0F | 0x0B);
694: outportb (0xDE, oldDE | 0x0E);
695:
696: _farsetsel (_dos_ds);
697: for (i=0; i<TESTBUFSIZE; i+=2) _farnspokew (testbuf+i, 0x8000);
698:
699: SB_ModeByte = 0x00;
700: SB_IntClearPort = SB_Base + SB_DSP_INT_CLEAR;
701: SB_SetRate_SB16(44100);
702: SB_Play_16Bit(TESTBUFSIZE);
703:
704: IRQ_Detected = 0;
705: for (i=0; i<3; i++)
706: {
707: DMA_InitTransfer (highdma[i], DMA_READ, testbuf, TESTBUFSIZE);
708: delay (TESTBUFSIZE*1000 / 44100);
709: if (IRQ_Detected)
710: {
711: *dmahi = highdma[i];
712: break;
713: }
714: }
715: if (!IRQ_Detected) *dmahi = *dmalo;
716: }
717: }
718:
719: /* clean up */
720: _go32_dpmi_free_dos_memory (&testbuf_info);
721:
722: outportb (0x0F, old0F);
723: outportb (0xDE, oldDE);
724: outportb (0x21, old21);
725: outportb (0xA1, oldA1);
726:
727: _go32_dpmi_set_protected_mode_interrupt_vector (0x0A, &oldirq2);
728: _go32_dpmi_set_protected_mode_interrupt_vector (0x0D, &oldirq5);
729: _go32_dpmi_set_protected_mode_interrupt_vector (0x0F, &oldirq7);
730: _go32_dpmi_set_protected_mode_interrupt_vector (0x72, &oldirq10);
731:
732: _go32_dpmi_free_iret_wrapper (&newirq2);
733: _go32_dpmi_free_iret_wrapper (&newirq5);
734: _go32_dpmi_free_iret_wrapper (&newirq7);
735: _go32_dpmi_free_iret_wrapper (&newirq10);
736:
737: return (found);
738: }
739:
740: /* init Sound blaster using the given settings */
741: int SB_Init (unsigned short base, unsigned short irq,
742: unsigned short dmalo, unsigned short dmahi)
743: {
744: SB_Base = base;
745: SB_IRQ = irq;
746: SB_DMAlo = dmalo;
747: SB_DMAhi = dmahi;
748:
749: if (SB_IRQ > 7) SB_INT = 0x68 + SB_IRQ;
750: else SB_INT = 0x08 + SB_IRQ;
751:
752:
753: if (!SB_Reset()) return (FALSE);
754:
755: dma_mem.size = NUMPARAS(DMA_BUF_SIZE);
756: dma_buf[0].Data = DMA_AllocDMABuf (&dma_mem);
757:
758: if (dma_buf[0].Data == NULL)
759: {
760: printf ("Cannot allocate DOS Memory for DMA buffers!\n");
761: return (FALSE);
762: }
763:
764: fifo_write_index = 0;
765: fifo_read_index = 0;
766: fifo_size = 0;
767:
768: pm_wrapper.pm_offset = (int) SB_IntHandler;
769: if (_go32_dpmi_allocate_iret_wrapper (&pm_wrapper))
770: {
771: printf ("Cannot allocate protected mode wrapper for SB interrupt!\n");
772: _go32_dpmi_free_dos_memory (&dma_mem);
773: return (FALSE);
774: }
775:
776: _go32_dpmi_lock_code (SB_WriteDSP, (ULONG)SB_WriteMixer - (ULONG)SB_WriteDSP);
777: _go32_dpmi_lock_code (fifo_read, (ULONG)SB_SetRate_LoSpeed - (ULONG)fifo_read);
778: _go32_dpmi_lock_data (&SB_Base, (ULONG)&old_pmint - (ULONG)&SB_Base);
779:
780: _go32_dpmi_get_protected_mode_interrupt_vector (SB_INT, &old_pmint);
781: _go32_dpmi_set_protected_mode_interrupt_vector (SB_INT, &pm_wrapper);
782:
783: if (SB_IRQ>7)
784: outportb(0xA1, inportb(0xA1) & ~(1 << (SB_IRQ-8)));
785: else
786: outportb(0x21, inportb(0x21) & ~(1 << SB_IRQ));
787:
788: SB_Type = SB_Type_StdSB;
789:
790: if (SB_DetectMixer()) SB_Type = SB_Type_SbPro;
791:
792: SB_WriteDSP (CMD_DSP_VER);
793: SB_VersMaj = SB_ReadDSP ();
794: SB_VersMin = SB_ReadDSP ();
795:
796: if (SB_VersMaj >= 4) SB_Type = SB_Type_SB16;
797:
798: // SB_Type = SB_Type_SbPro; /* for testing */
799:
800: /* initialize SB to default 8Bit Mono 22050Hz */
801: /* (available on all SoundBlaster Versions) */
802: switch (SB_Type)
803: {
804: case SB_Type_StdSB:
805: SB_Single_Play_Proc = SB_Play_8Bit_Std;
806: SB_Autoinit = FALSE;
807: SB_SetRate_LoSpeed(22050);
808: break;
809: case SB_Type_SbPro:
810: SB_Single_Play_Proc = SB_Play_8Bit_SbPro;
811: SB_Autoinit = FALSE;
812: SB_SetRate_HiSpeed(22050);
813: break;
814: case SB_Type_SB16:
815: SB_Single_Play_Proc = SB_Play_8Bit_SB16;
816: SB_Play_Proc = SB_Play_8Bit_SB16_Autoinit;
817: SB_Autoinit = TRUE;
818: SB_SetRate_SB16(22050);
819: break;
820: }
821: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL;
822: SB_DMA = SB_DMAlo;
823: SB_Playing = FALSE;
824: SB_Stopped = FALSE;
825: SB_16Bit = FALSE;
826: SB_Stereo = FALSE;
827: SB_Active_Rate = 22050;
828: SB_ModeByte = 0x00;
829: SB_StopByte = CMD_PAUSE_8BIT_DMA;
830: SB_ContByte = CMD_CONTINUE_8BIT_DMA;
831: SB_Bytes_Played = 0;
832:
833: calculate_buf_sizes();
834:
835: return (TRUE);
836: }
837:
838: /* clean up Sound Blaster */
839: void SB_Done (void)
840: {
841: SB_Reset ();
842: if (SB_IRQ > 7)
843: outportb (0xA1, inportb(0xA1) | (1 << (SB_IRQ-8)));
844: else
845: outportb (0x21, inportb(0x21) | (1 << SB_IRQ));
846:
847: _go32_dpmi_set_protected_mode_interrupt_vector (SB_INT, &old_pmint);
848: _go32_dpmi_free_iret_wrapper (&pm_wrapper);
849: _go32_dpmi_free_dos_memory (&dma_mem);
850: }
851:
852: /* write sound data to be played to the fifo buffer */
853: void SB_Write (void *buf, unsigned long size)
854: {
855: #define MIN(a,b) ((a)<(b) ? (a) : (b))
856:
857: UWORD s;
858: int i;
859:
860: if (SB_Stopped) SB_Continue();
861: while (size > 0)
862: {
863: s = MIN (size, (UWORD) (fifo_max - dma_block_size));
864:
865: while (fifo_size+s > fifo_max);
866:
867: disable ();
868: for (i=0; i<s; i++) fifo_write (*((UBYTE*)buf)++);
869: enable ();
870:
871: if (!SB_Playing && fifo_size > dma_block_size*2) SB_Play();
872:
873: size -= s;
874: }
875: }
876:
877: /* start any unplayed sound */
878: void SB_Flush (void)
879: {
880: if (SB_Stopped) SB_Continue();
881: if (fifo_size>0 && !SB_Playing) SB_Play();
882: }
883:
884: /* stop/pause sound output */
885: void SB_Stop (void)
886: {
887: if (SB_Stopped) return;
888: SB_WriteDSP (SB_StopByte);
889: SB_Stopped = TRUE;
890: }
891:
892: /* continue sound output */
893: void SB_Continue (void)
894: {
895: if (!SB_Stopped) return;
896: SB_WriteDSP (SB_ContByte);
897: SB_Stopped = FALSE;
898: }
899:
900: /* return thee DSP chip version */
901: void SB_GetVersion (unsigned char *Maj, unsigned char *Min)
902: {
903: *Maj = SB_VersMaj;
904: *Min = SB_VersMin;
905: }
906:
907: /* return the current DMA block size */
908: unsigned short SB_GetFragmentSize (void)
909: {
910: return (dma_block_size);
911: }
912:
913: /* return the current fifo buffer size (not the fifo fill size) */
914: UWORD SB_GetBufferSize (void)
915: {
916: return (fifo_max);
917: }
918:
919: /* Detection Routine */
920: int SB_DetectInitSound(int *dspbits, int *dsprate, int *sndbufsize)
921: {
922: UWORD base,irq,dmalo,dmahi;
923: char *blaster;
924: char *tok;
925: int have_sound;
926: extern void (*SND_Write)(void *buf, unsigned long size);
927:
928: blaster = getenv ("BLASTER");
929: if (blaster == NULL)
930: {
931: printf ("No BLASTER variable found!\n"
932: "Detecting SoundBlaster Settings...."); fflush (stdout);
933: have_sound = SB_Detect (&base, &irq, &dmalo, &dmahi);
934: if (!have_sound)
935: {
936: printf ("Not found!!\n");
937: return (0);
938: }
939: printf ("Found! Base: %hx IRQ: %hd DMA: %hd,%hd\n",
940: base, irq, dmalo,dmahi);
941: }
942: else
943: {
944: base = 0; irq = 0; dmalo = 0; dmahi = 0;
945:
946: tok = strtok(blaster, " \t");
947: while (tok != NULL)
948: {
949: switch (toupper(*tok))
950: {
951: case 'A': sscanf(tok+1, "%hx", &base); break;
952: case 'I': sscanf(tok+1, "%hd", &irq); break;
953: case 'D': sscanf(tok+1, "%hd", &dmalo); break;
954: case 'H': sscanf(tok+1, "%hd", &dmahi); break;
955: default: break;
956: }
957: tok = strtok (NULL, " \t");
958: }
959: printf ("SoundBlaster Settings taken from BLASTER variable:\n"
960: " Base: %hx IRQ: %hd DMA: %hd,%hd\n", base,irq,dmalo,dmahi);
961: }
962:
963: have_sound = SB_Init (base, irq, dmalo, dmahi);
964: if (!have_sound)
965: {
966: printf ("Cannot Initialize Soundblaster!\n");
967: return (0);
968: }
969:
970: if ((*dspbits) == 16 && SB_SetBits (16))
971: SB_SetSigned (1);
972: else
973: *dspbits = 8;
974:
975: SB_SetRate(22050);
976:
977: if ((*dsprate) == 0 && !SB_SetRate(44100))
978: {
979: printf ("SoundCard does not support playing at 44100 Hz, using 22050 Hz\n");
980: SB_SetRate(22050);
981: *dsprate = 1;
982: }
983:
984: *sndbufsize = SB_GetFragmentSize();
985:
986: printf ("SoundBlaster%s found and configured for %d bits at %d Hz,\n"
987: " Fragment size is %d Bytes, Buffer size is %d bytes.\n",
988: SB_Type==SB_Type_StdSB ? "" :
989: (SB_Type==SB_Type_SbPro ? " PRO" : " 16"),
990: *dspbits, (*dsprate) ? 22050 : 44100, *sndbufsize, SB_GetBufferSize());
991:
992: SND_Write = SB_Write;
993:
994: atexit (SB_Done);
995:
996: return 1;
997: }
998:
999: /* that's it... */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.