home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / atari / atari800-0.8.6 / sbdrv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-10  |  33.2 KB  |  1,388 lines
  1. /*****************************************************************************/  
  2. /*                                                                           */ 
  3. /* Module:    SBDRV                                                          */ 
  4. /* Purpose:   Sound Blaster DAC DMA Driver V1.2                              */ 
  5. /* Author(s): Ron Fries, Neil Bradley and Bradford Mott                      */ 
  6. /*                                                                           */ 
  7. /* 02/20/97 - Initial Release                                                */ 
  8. /*                                                                           */ 
  9. /* 08/19/97 - V1.1 - Corrected problem with the auto-detect of older SB      */ 
  10. /*            cards and problem with DSP shutdown which left the auto-init   */ 
  11. /*            mode active.  Required creating a function to reset the DSP.   */ 
  12. /*            Also, added checks on the BLASTER settings to verify they      */ 
  13. /*            are possible values for either SB or SB compatibles.           */ 
  14. /*            Added several helpful information/error messages.  These can   */ 
  15. /*            be disabled by removing the SBDRV_SHOW_ERR definition.         */ 
  16. /*                                                                                                                                                       */ 
  17. /* 12/24/97 - V1.2 - Added support for DJGPP (by Bradford Mott).             */ 
  18. /*                                                                           */ 
  19. /*                                                                           */ 
  20. /*****************************************************************************/ 
  21. /*                                                                           */ 
  22. /*                 License Information and Copyright Notice                  */ 
  23. /*                 ========================================                  */ 
  24. /*                                                                           */ 
  25. /* SBDrv is Copyright(c) 1997-1998 by Ron Fries, Neil Bradley and            */ 
  26. /*       Bradford Mott                                                       */ 
  27. /*                                                                           */ 
  28. /* This library is free software; you can redistribute it and/or modify it   */ 
  29. /* under the terms of version 2 of the GNU Library General Public License    */ 
  30. /* as published by the Free Software Foundation.                             */ 
  31. /*                                                                           */ 
  32. /* This library is distributed in the hope that it will be useful, but       */ 
  33. /* WITHOUT ANY WARRANTY; without even the implied warranty of                */ 
  34. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library */ 
  35. /* General Public License for more details.                                  */ 
  36. /* To obtain a copy of the GNU Library General Public License, write to the  */ 
  37. /* Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   */ 
  38. /*                                                                           */ 
  39. /* Any permitted reproduction of these routines, in whole or in part, must   */ 
  40. /* bear this legend.                                                         */ 
  41. /*                                                                           */ 
  42. /*****************************************************************************/ 
  43.  
  44. #ifdef DJGPP
  45. #include <go32.h>
  46. #include <dpmi.h>
  47. #include <sys/movedata.h>
  48. #endif                            /* 
  49.  */
  50.  
  51. #include <dos.h>
  52. #include <stdlib.h>
  53. #include <ctype.h>
  54. #include <string.h>
  55. #include <conio.h>
  56. #include <time.h>
  57. #include <stdio.h>
  58. #include "sbdrv.h"
  59.  
  60. #define DSP_RESET         0x06
  61. #define DSP_READ          0x0a
  62. #define DSP_WRITE         0x0c
  63. #define DSP_ACK           0x0e
  64.  
  65. #define DMA_BASE          0x00
  66. #define DMA_COUNT         0x01
  67. #define DMA_MASK          0x0a
  68. #define DMA_MODE          0x0b
  69. #define DMA_FF            0x0c
  70.  
  71. #define MASTER_VOLUME     0x22
  72. #define LINE_VOLUME       0x2e
  73. #define FM_VOLUME         0x26
  74.  
  75. /* declare local global variables */ 
  76. #ifdef DJGPP
  77. static int theDOSBufferSegment;
  78.  
  79. static int theDOSBufferSelector;
  80.  
  81. #endif                            /* 
  82.  */
  83. static uint8 *Sb_buffer;
  84.  
  85. static uint16 Sb_buf_size = 200;
  86.  
  87. static uint16 Sb_offset;
  88.  
  89. static uint16 Playback_freq;
  90.  
  91. static uint8 Sb_init = 0;
  92.  
  93. static uint8 Count_low;
  94.  
  95. static uint8 Count_high;
  96.  
  97.  
  98. static uint16 IOaddr = 0x220;
  99.  
  100. static uint16 Irq = 7;
  101.  
  102. static uint16 Dma = 1;
  103.  
  104. static uint8 DMAmode = AUTO_DMA;
  105.  
  106. /*static */ uint8 DMAcount;
  107.  
  108. static void (*FillBuffer) (uint8 * buf, uint16 buf_size);
  109.  
  110.  
  111. #ifdef DJGPP
  112. static _go32_dpmi_seginfo OldIntVectInfo;
  113.  
  114. static _go32_dpmi_seginfo NewIntVectInfo;
  115.  
  116. #else                            /* 
  117.  */
  118. static void (__interrupt * OldIntVect) (void);
  119.  
  120. #endif                            /* 
  121.  */
  122.  
  123. /* function prototypes */ 
  124. #ifdef DJGPP
  125. static void newIntVect(void);
  126.  
  127. #else                            /* 
  128.  */
  129. static void interrupt newIntVect(void);
  130.  
  131. #endif                            /* 
  132.  */
  133.  
  134. static void setNewIntVect(uint16 irq);
  135.  
  136. static void setOldIntVect(uint16 irq);
  137.  
  138. static void dsp_out(uint16 port, uint8 val);
  139.  
  140. static uint8 hextodec(char c);
  141.  
  142. static void logErr(char *st);
  143.  
  144. static uint8 getBlasterEnv(void);
  145.  
  146. static uint8 dsp_in(uint16 port);
  147.  
  148.  
  149. /*****************************************************************************/ 
  150. /*                                                                           */ 
  151. /* Module:  setNewIntVect                                                    */ 
  152. /* Purpose: To set the specified interrupt vector to the sound output        */ 
  153. /*          processing interrupt.                                            */ 
  154. /* Author:  Ron Fries                                                        */ 
  155. /* Date:    January 1, 1997                                                  */ 
  156. /*                                                                           */ 
  157. /*****************************************************************************/ 
  158.  
  159. static void setNewIntVect(uint16 irq) 
  160. {
  161.     
  162.         if (irq > 7)
  163.         
  164.     {
  165.         
  166. #ifdef DJGPP
  167.             _go32_dpmi_get_protected_mode_interrupt_vector(irq + 0x68, 
  168.                                                         &OldIntVectInfo);
  169.         
  170.             NewIntVectInfo.pm_selector = _my_cs();
  171.         
  172.             NewIntVectInfo.pm_offset = (int) newIntVect;
  173.         
  174.             _go32_dpmi_allocate_iret_wrapper(&NewIntVectInfo);
  175.         
  176.             _go32_dpmi_set_protected_mode_interrupt_vector(irq + 0x68, 
  177.                                                         &NewIntVectInfo);
  178.         
  179. #else                            /* 
  180.  */
  181.             OldIntVect = _dos_getvect(irq + 0x68);
  182.         
  183.             _dos_setvect(irq + 0x68, newIntVect);
  184.         
  185. #endif                            /* 
  186.  */
  187.     }
  188.     
  189.         else
  190.         
  191.     {
  192.         
  193. #ifdef DJGPP
  194.             _go32_dpmi_get_protected_mode_interrupt_vector(irq + 0x08, 
  195.                                                         &OldIntVectInfo);
  196.         
  197.             NewIntVectInfo.pm_selector = _my_cs();
  198.         
  199.             NewIntVectInfo.pm_offset = (int) newIntVect;
  200.         
  201.             _go32_dpmi_allocate_iret_wrapper(&NewIntVectInfo);
  202.         
  203.             _go32_dpmi_set_protected_mode_interrupt_vector(irq + 0x08, 
  204.                                                         &NewIntVectInfo);
  205.         
  206. #else                            /* 
  207.  */
  208.             OldIntVect = _dos_getvect(irq + 0x08);
  209.         
  210.             _dos_setvect(irq + 0x08, newIntVect);
  211.         
  212. #endif                            /* 
  213.  */
  214.     }
  215.     
  216. }
  217.  
  218.  
  219.  
  220. /*****************************************************************************/ 
  221. /*                                                                           */ 
  222. /* Module:  setOldIntVect                                                    */ 
  223. /* Purpose: To restore the original vector                                   */ 
  224. /* Author:  Ron Fries                                                        */ 
  225. /* Date:    January 1, 1997                                                  */ 
  226. /*                                                                           */ 
  227. /*****************************************************************************/ 
  228.  
  229. static void setOldIntVect(uint16 irq) 
  230. {
  231.     
  232.         if (irq > 7)
  233.         
  234.     {
  235.         
  236. #ifdef DJGPP
  237.             _go32_dpmi_set_protected_mode_interrupt_vector(irq + 0x68, 
  238.                                                         &OldIntVectInfo);
  239.         
  240.             _go32_dpmi_free_iret_wrapper(&NewIntVectInfo);
  241.         
  242. #else                            /* 
  243.  */
  244.             _dos_setvect(irq + 0x68, OldIntVect);
  245.         
  246. #endif                            /* 
  247.  */
  248.     }
  249.     
  250.         else
  251.         
  252.     {
  253.         
  254. #ifdef DJGPP
  255.             _go32_dpmi_set_protected_mode_interrupt_vector(irq + 0x08, 
  256.                                                         &OldIntVectInfo);
  257.         
  258.             _go32_dpmi_free_iret_wrapper(&NewIntVectInfo);
  259.         
  260. #else                            /* 
  261.  */
  262.             _dos_setvect(irq + 0x08, OldIntVect);
  263.         
  264. #endif                            /* 
  265.  */
  266.     }
  267.     
  268. }
  269.  
  270.  
  271.  
  272. /*****************************************************************************/ 
  273. /*                                                                           */ 
  274. /* Module:  dsp_out                                                          */ 
  275. /* Purpose: To send a byte to the SB's DSP                                   */ 
  276. /* Author:  Ron Fries                                                        */ 
  277. /* Date:    September 10, 1996                                               */ 
  278. /*                                                                           */ 
  279. /*****************************************************************************/ 
  280.  
  281. static void dsp_out(uint16 port, uint8 val) 
  282. {
  283.     
  284.     /* wait for buffer to be free */ 
  285.         while (inp(IOaddr + DSP_WRITE) & 0x80)
  286.         
  287.     {
  288.         
  289.         /* do nothing */ 
  290.     }
  291.     
  292.         
  293.     /* transmit the next byte */ 
  294.         outp(port, val);
  295.     
  296. }
  297.  
  298.  
  299.  
  300. /*****************************************************************************/ 
  301. /*                                                                           */ 
  302. /* Module:  dsp_in                                                           */ 
  303. /* Purpose: To read a byte from the SB's DSP                                 */ 
  304. /* Author:  Ron Fries                                                        */ 
  305. /* Date:    January 26, 1997                                                 */ 
  306. /*                                                                           */ 
  307. /*****************************************************************************/ 
  308.  
  309. static uint8 dsp_in(uint16 port) 
  310. {
  311.     
  312.         uint16 x = 10000;        /* set timeout */
  313.     
  314.         
  315.     /* wait for buffer to be free */ 
  316.         while (((inp(IOaddr + 0x0E) & 0x80) == 0) && (x > 0))
  317.         
  318.     {
  319.         
  320.         /* decrement the timeout */ 
  321.             x--;
  322.         
  323.     }
  324.     
  325.         
  326.         if (x > 0)
  327.         
  328.     {
  329.         
  330.         /* read the data byte */ 
  331.             return (inp(port));
  332.         
  333.     }
  334.     
  335.         else
  336.         
  337.     {
  338.         
  339.             return (0);
  340.         
  341.     }
  342.     
  343. }
  344.  
  345.  
  346.  
  347. /*****************************************************************************/ 
  348. /*                                                                           */ 
  349. /* Module:  hextodec                                                         */ 
  350. /* Purpose: Convert the input character to hex                               */ 
  351. /* Author:  Ron Fries                                                        */ 
  352. /* Date:    September 10, 1996                                               */ 
  353. /*                                                                           */ 
  354. /*****************************************************************************/ 
  355.  
  356. uint8 hextodec(char c) 
  357. {
  358.     
  359.         uint8 retval = 0;
  360.     
  361.         
  362.         c = toupper(c);
  363.     
  364.         
  365.         if ((c >= '0') && (c <= '9'))
  366.         
  367.     {
  368.         
  369.             retval = c - '0';
  370.         
  371.     }
  372.     
  373.         else if ((c >= 'A') && (c <= 'F'))
  374.         
  375.     {
  376.         
  377.             retval = c - 'A' + 10;
  378.         
  379.     }
  380.     
  381.         
  382.         return (retval);
  383.     
  384. }
  385.  
  386.  
  387.  
  388. /*****************************************************************************/ 
  389. /*                                                                           */ 
  390. /* Module:  logErr                                                           */ 
  391. /* Purpose: Displays an error message.                                       */ 
  392. /* Author:  Ron Fries                                                        */ 
  393. /* Date:    September 24, 1996                                               */ 
  394. /*                                                                           */ 
  395. /*****************************************************************************/ 
  396.  
  397. static void logErr(char *st) 
  398. {
  399.     
  400. #ifdef SBDRV_SHOW_ERR
  401.         printf("%s", st);
  402.     
  403. #endif                            /* 
  404.  */
  405. } 
  406.  
  407.  
  408. /*****************************************************************************/ 
  409. /*                                                                           */ 
  410. /* Module:  getBlasterEnv                                                    */ 
  411. /* Purpose: Read the BLASTER environment variable and set the local globals  */ 
  412. /* Author:  Ron Fries                                                        */ 
  413. /* Date:    September 10, 1996                                               */ 
  414. /*                                                                           */ 
  415. /*****************************************************************************/ 
  416.  
  417. static uint8 getBlasterEnv(void) 
  418. {
  419.     
  420.         char *env;
  421.     
  422.         char *ptr;
  423.     
  424.         uint16 count = 0;
  425.     
  426.         
  427.         env = strupr(getenv("BLASTER"));
  428.     
  429.         
  430.     /* if the environment variable exists */ 
  431.         if (env)
  432.         
  433.     {
  434.         
  435.         /* search for the address setting */ 
  436.             ptr = strchr(env, 'A');
  437.         
  438.             if (ptr)
  439.             
  440.         {
  441.             
  442.             /* if valid, read and convert the IO address */ 
  443.                 IOaddr = (hextodec(ptr[1]) << 8) + 
  444.                 (hextodec(ptr[2]) << 4) + 
  445.                 (hextodec(ptr[3]));
  446.             
  447.                 
  448.             /* verify the IO address is one of the possible SB settings */ 
  449.                 switch (IOaddr)
  450.                 
  451.             {
  452.                 
  453.             case 0x210:
  454.                 
  455.             case 0x220:
  456.                 
  457.             case 0x230:
  458.                 
  459.             case 0x240:
  460.                 
  461.             case 0x250:
  462.                 
  463.             case 0x260:
  464.                 
  465.             case 0x280:
  466.                 
  467.             case 0x2A0:
  468.                 
  469.             case 0x2C0:
  470.                 
  471.             case 0x2E0:
  472.                 
  473.                 /* IO address OK so indicate one more valid item found */ 
  474.                     count++;
  475.                 
  476.                     break;
  477.                 
  478.                     
  479.             default:
  480.                 
  481.                     logErr("Invalid Sound Blaster I/O address specified.\n");
  482.                 
  483.                     logErr("Possible values are:  ");
  484.                 
  485.                     logErr("210, 220, 230, 240, 250, 260, 280, 2A0, 2C0, 2E0.\n");
  486.                 
  487.             }
  488.             
  489.         }
  490.         
  491.             else
  492.             
  493.         {
  494.             
  495.                 logErr("Unable to read Sound Blaster I/O address.\n");
  496.             
  497.         }
  498.         
  499.             
  500.         /* search for the IRQ setting */ 
  501.             ptr = strchr(env, 'I');
  502.         
  503.             if (ptr)
  504.             
  505.         {
  506.             
  507.             /* if valid, read and convert the IRQ */ 
  508.             /* if the IRQ has two digits */ 
  509.                 if ((ptr[1] == '1') && ((ptr[2] >= '0') && (ptr[2] <= '5')))
  510.                 
  511.             {
  512.                 
  513.                 /* then convert accordingly (using decimal) */ 
  514.                     Irq = hextodec(ptr[1]) * 10 + hextodec(ptr[2]);
  515.                 
  516.             }
  517.             
  518.                 else
  519.                 
  520.             {
  521.                 
  522.                 /* else convert as a single hex digit */ 
  523.                     Irq = hextodec(ptr[1]);
  524.                 
  525.             }
  526.             
  527.                 
  528.             /* verify the IRQ setting is one of the possible SB settings */ 
  529.                 switch (Irq)
  530.                 
  531.             {
  532.                 
  533.             case 2:            /* two is actually the interrupt cascade for IRQs > 7 */
  534.                 
  535.                 /* IRQ nine is the cascase for 2 */ 
  536.                     Irq = 9;
  537.                 
  538.                     
  539.                 /* IRQ OK so indicate one more valid item found */ 
  540.                     count++;
  541.                 
  542.                     break;
  543.                 
  544.                     
  545.             case 3:
  546.                 
  547.             case 4:
  548.                 
  549.             case 5:
  550.                 
  551.             case 7:
  552.                 
  553.             case 9:
  554.                 
  555.             case 10:
  556.                 
  557.             case 11:
  558.                 
  559.             case 12:
  560.                 
  561.             case 15:
  562.                 
  563.                     
  564.                 /* IRQ OK so indicate one more valid item found */ 
  565.                     count++;
  566.                 
  567.                     break;
  568.                 
  569.                     
  570.             default:
  571.                 
  572.                     logErr("Invalid Sound Blaster IRQ specified.\n");
  573.                 
  574.                     logErr("Possible values are:  ");
  575.                 
  576.                     logErr("2, 3, 4, 5, 7, 9, 10, 11, 12, 15.\n");
  577.                 
  578.             }
  579.             
  580.         }
  581.         
  582.             else
  583.             
  584.         {
  585.             
  586.                 logErr("Unable to read Sound Blaster IRQ.\n");
  587.             
  588.         }
  589.         
  590.             
  591.         /* search for the DMA setting */ 
  592.             ptr = strchr(env, 'D');
  593.         
  594.             if (ptr)
  595.             
  596.         {
  597.             
  598.             /* if valid, read and convert the DMA */ 
  599.                 Dma = hextodec(ptr[1]);
  600.             
  601.                 
  602.             /* verify the DMA setting is one of the possible 8-bit SB settings */ 
  603.                 switch (Dma)
  604.                 
  605.             {
  606.                 
  607.             case 0:
  608.                 
  609.             case 1:
  610.                 
  611.             case 3:
  612.                 
  613.                 /* DMA OK so indicate one more valid item found */ 
  614.                     count++;
  615.                 
  616.                     break;
  617.                 
  618.                     
  619.             default:
  620.                 
  621.                     logErr("Invalid Sound Blaster 8-bit DMA specified.\n");
  622.                 
  623.                     logErr("Possible values are:  ");
  624.                 
  625.                     logErr("0, 1, 3.\n");
  626.                 
  627.             }
  628.             
  629.         }
  630.         
  631.             else
  632.             
  633.         {
  634.             
  635.                 logErr("Unable to read Sound Blaster DMA setting.\n");
  636.             
  637.         }
  638.         
  639.     }
  640.     
  641.         else
  642.         
  643.     {
  644.         
  645.             logErr("BLASTER enviroment variable not configured.");
  646.         
  647.     }
  648.     
  649.         
  650.         return (count != 3);
  651.     
  652. }
  653.  
  654.  
  655.  
  656. /*****************************************************************************/ 
  657. /*                                                                           */ 
  658. /* Module:  low_malloc                                                       */ 
  659. /* Purpose: To allocate memory in the first 640K of memory                   */ 
  660. /* Author:  Neil Bradley                                                     */ 
  661. /* Date:    December 16, 1996                                                */ 
  662. /*                                                                           */ 
  663. /*****************************************************************************/ 
  664.  
  665. #ifdef __WATCOMC__
  666. void dos_memalloc(unsigned short int para, unsigned short int *seg, unsigned short int *sel);
  667.  
  668. #pragma  aux dos_memalloc = \
  669. "push  ecx" \ 
  670. "push  edx" \ 
  671. "mov   ax, 0100h" \ 
  672. "int   31h" \ 
  673. "pop   ebx" \ 
  674. "mov   [ebx], dx" \ 
  675. "pop   ebx" \ 
  676. "mov   [ebx], ax" \ 
  677. parm[bx][ecx][edx] \ 
  678. modify[ax ebx ecx edx];
  679.  
  680.  
  681. void dos_memfree(short int sel);
  682.  
  683. #pragma  aux dos_memfree =  \
  684. "mov   ax, 0101h" \ 
  685. "int   31h" \ 
  686. parm[dx] \ 
  687. modify[ax dx];
  688.  
  689.  
  690. void *low_malloc(int size) 
  691. {
  692.     
  693.         unsigned short int seg;
  694.     
  695.         unsigned short int i = 0;
  696.     
  697.         
  698.         dos_memalloc((size >> 4) + 1, &seg, &i);
  699.     
  700.         return ((char *) (seg << 4));
  701.     
  702. } 
  703.  
  704. #endif                            /* 
  705.  */
  706.  
  707.  
  708. /*****************************************************************************/ 
  709. /*                                                                           */ 
  710. /* Module:  Set_master_volume                                                */ 
  711. /* Purpose: To set the Sound Blaster's master volume                         */ 
  712. /* Author:  Neil Bradley                                                     */ 
  713. /* Date:    January 1, 1997                                                  */ 
  714. /*                                                                           */ 
  715. /*****************************************************************************/ 
  716.  
  717. void Set_master_volume(uint8 left, uint8 right) 
  718.  
  719. {
  720.     
  721.     /* if the SB was initialized */ 
  722.         if (Sb_init)
  723.         
  724.     {
  725.         
  726.             outp(IOaddr + 0x04, MASTER_VOLUME);
  727.         
  728.             outp(IOaddr + 0x05, ((left & 0xf) << 4) + (right & 0x0f));
  729.         
  730.     }
  731.     
  732. }
  733.  
  734.  
  735.  
  736. /*****************************************************************************/ 
  737. /*                                                                           */ 
  738. /* Module:  Set_line_volume                                                  */ 
  739. /* Purpose: To set the Sound Blaster's line level volume                     */ 
  740. /* Author:  Neil Bradley                                                     */ 
  741. /* Date:    January 1, 1997                                                  */ 
  742. /*                                                                           */ 
  743. /*****************************************************************************/ 
  744.  
  745. void Set_line_volume(uint8 left, uint8 right) 
  746. {
  747.     
  748.     /* if the SB was initialized */ 
  749.         if (Sb_init)
  750.         
  751.     {
  752.         
  753.             outp(IOaddr + 0x04, LINE_VOLUME);
  754.         
  755.             outp(IOaddr + 0x05, ((left & 0xf) << 4) + (right & 0x0f));
  756.         
  757.     }
  758.     
  759. }
  760.  
  761.  
  762.  
  763. /*****************************************************************************/ 
  764. /*                                                                           */ 
  765. /* Module:  Set_FM_volume                                                    */ 
  766. /* Purpose: To set the Sound Blaster's FM volume                             */ 
  767. /* Author:  Neil Bradley                                                     */ 
  768. /* Date:    January 1, 1997                                                  */ 
  769. /*                                                                           */ 
  770. /*****************************************************************************/ 
  771.  
  772. void Set_FM_volume(uint8 left, uint8 right) 
  773.  
  774. {
  775.     
  776.     /* if the SB was initialized */ 
  777.         if (Sb_init)
  778.         
  779.     {
  780.         
  781.             outp(IOaddr + 0x04, FM_VOLUME);
  782.         
  783.             outp(IOaddr + 0x05, ((left & 0xf) << 4) + (right & 0x0f));
  784.         
  785.     }
  786.     
  787. }
  788.  
  789.  
  790.  
  791. /*****************************************************************************/ 
  792. /*                                                                           */ 
  793. /* Module:  ResetDSP                                                         */ 
  794. /* Purpose: To reset the SB DSP.  Returns a value of zero if unsuccessful.   */ 
  795. /*          This function requires as input the SB base port address.        */ 
  796. /* Author:  Ron Fries                                                        */ 
  797. /* Date:    August 5, 1997                                                   */ 
  798. /*                                                                           */ 
  799. /*****************************************************************************/ 
  800.  
  801. uint8 ResetDSP(uint16 ioaddr) 
  802. {
  803.     
  804.         uint8 x;
  805.     
  806.         uint16 y;
  807.     
  808.         
  809.     /* assume the init was not successful */ 
  810.         Sb_init = 0;
  811.     
  812.         
  813.     /* send a DSP reset to the SB */ 
  814.         outp(ioaddr + DSP_RESET, 1);
  815.     
  816.         
  817.     /* wait a few microsec */ 
  818.         x = inp(ioaddr + DSP_RESET);
  819.     
  820.         x = inp(ioaddr + DSP_RESET);
  821.     
  822.         x = inp(ioaddr + DSP_RESET);
  823.     
  824.         x = inp(ioaddr + DSP_RESET);
  825.     
  826.         
  827.     /* clear the DSP reset */ 
  828.         outp(ioaddr + DSP_RESET, 0);
  829.     
  830.         
  831.     /* wait a bit until the SB indicates good status */ 
  832.         y = 0;
  833.     
  834.         
  835.         do
  836.         
  837.     {
  838.         
  839.             x = inp(ioaddr + DSP_READ);
  840.         
  841.             y++;
  842.         
  843.     } while ((y < 1000) && (x != 0xaa));
  844.     
  845.         
  846.     /* if we were able to successfully reset the SB */ 
  847.         if (x == 0xaa)
  848.         
  849.     {
  850.         
  851.         /* turn on speaker */ 
  852.             dsp_out(ioaddr + DSP_WRITE, 0xd1);
  853.         
  854.             
  855.         /* read to make sure DSP register is clear */ 
  856.             dsp_in(ioaddr + DSP_READ);
  857.         
  858.             
  859.         /* set time constant */ 
  860.             dsp_out(ioaddr + DSP_WRITE, 0x40);
  861.         
  862.             dsp_out(ioaddr + DSP_WRITE, 
  863.                     (unsigned char) (256 - 1000000L / Playback_freq));
  864.         
  865.             
  866.         /* indicate successful initialization */ 
  867.             Sb_init = 1;
  868.         
  869.     }
  870.     
  871.         
  872.         return (Sb_init);
  873.     
  874. }
  875.  
  876.  
  877.  
  878. /*****************************************************************************/ 
  879. /*                                                                           */ 
  880. /* Module:  OpenSB                                                           */ 
  881. /* Purpose: To reset the SB and prepare all buffers and other global         */ 
  882. /*          global variables for sound output.  Allows the user to select    */ 
  883. /*          the playback frequency, number of buffers, and size of each      */ 
  884. /*          buffer.  Returns a value of zero if unsuccessful.                */ 
  885. /* Author:  Ron Fries                                                        */ 
  886. /* Date:    January 1, 1997                                                  */ 
  887. /*                                                                           */ 
  888. /*****************************************************************************/ 
  889.  
  890. uint8 OpenSB(uint16 playback_freq, uint16 buffer_size) 
  891. {
  892.     
  893.     /* initialize local globals */ 
  894.         if (buffer_size > 0)
  895.         
  896.     {
  897.         
  898.             Sb_buf_size = buffer_size;
  899.         
  900.     }
  901.     
  902.         
  903.         Playback_freq = playback_freq;
  904.     
  905.         
  906.     /* assume the init was not successful */ 
  907.         Sb_init = 0;
  908.     
  909.         
  910.     /* attempt to read the Blaster Environment Variable */ 
  911.         if (getBlasterEnv() == 0)
  912.         
  913.     {
  914.         
  915.         /* if the DSP could be successfully reset */ 
  916.             if (ResetDSP(IOaddr) != 0)
  917.             
  918.         {
  919.             
  920.             /* setup the DSP interrupt service routine */ 
  921.                 setNewIntVect(Irq);
  922.             
  923.                 
  924.             /* Enable the interrupt used */ 
  925.                 if (Irq > 7)
  926.                 
  927.             {
  928.                 
  929.                     outp(0xa1, inp(0xa1) & (~(1 << (Irq - 8))));
  930.                 
  931.             }
  932.             
  933.                 else
  934.                 
  935.             {
  936.                 
  937.                     outp(0x21, inp(0x21) & (~(1 << Irq)));
  938.                 
  939.             }
  940.             
  941.                 
  942.             /* make sure interrupts are enabled */ 
  943.                 _enable();
  944.             
  945.                 
  946.             /* create a buffer to hold the data */ 
  947. #ifdef __WATCOMC__
  948.                 Sb_buffer = low_malloc(Sb_buf_size * 2);
  949.             
  950. #elif defined(DJGPP)
  951.                 Sb_buffer = (uint8 *) malloc(Sb_buf_size * 2);
  952.             
  953.                 theDOSBufferSegment = __dpmi_allocate_dos_memory((Sb_buf_size * 2 + 15) >> 4, 
  954.                                                   &theDOSBufferSelector);
  955.             
  956. #else                            /* 
  957.  */
  958.                 Sb_buffer = malloc(Sb_buf_size * 2);
  959.             
  960. #endif                            /* 
  961.  */
  962.                 
  963.             /* if we were unable to successfully allocate the buffer */ 
  964. #ifdef DJGPP
  965.                 if ((Sb_buffer == 0) || (theDOSBufferSegment == -1))
  966.                 
  967. #else                            /* 
  968.  */
  969.                 if (Sb_buffer == 0)
  970.                 
  971. #endif                            /* 
  972.  */
  973.             {
  974.                 
  975.                     logErr("Unable to allocate buffer for audio output.\n");
  976.                 
  977.                     
  978.                 /* close the SB */ 
  979.                     CloseSB();
  980.                 
  981.             }
  982.             
  983.         }
  984.         
  985.             else
  986.             
  987.         {
  988.             
  989.                 logErr("Unable to initialize the Sound Card.\n");
  990.             
  991.         }
  992.         
  993.             
  994.     }
  995.     
  996.         
  997.         return (Sb_init);
  998.     
  999. }
  1000.  
  1001.  
  1002.  
  1003. /*****************************************************************************/ 
  1004. /*                                                                           */ 
  1005. /* Module:  CloseSB                                                          */ 
  1006. /* Purpose: Closes the SB and disables the interrupts.                       */ 
  1007. /* Author:  Ron Fries                                                        */ 
  1008. /* Date:    January 1, 1997                                                  */ 
  1009. /*                                                                           */ 
  1010. /*****************************************************************************/ 
  1011.  
  1012. void CloseSB(void) 
  1013. {
  1014.     
  1015. #ifdef __WATCOMC__
  1016.         uint32 addr;
  1017.     
  1018. #endif                            /* 
  1019.  */
  1020.         
  1021.     /* if the SB was initialized */ 
  1022.         if (Sb_init)
  1023.         
  1024.     {
  1025.         
  1026.         /* turn the speaker off */ 
  1027.             dsp_out(IOaddr + DSP_WRITE, 0xd3);
  1028.         
  1029.             
  1030.         /* stop all DMA transfer */ 
  1031.             Stop_audio_output();
  1032.         
  1033.             
  1034.         /* indicate SB no longer active */ 
  1035.             Sb_init = 0;
  1036.         
  1037.             
  1038.         /* Disable the interrupt used */ 
  1039.             if (Irq > 7)
  1040.             
  1041.         {
  1042.             
  1043.                 outp(0xa1, inp(0xa1) | (1 << (Irq - 8)));
  1044.             
  1045.         }
  1046.         
  1047.             else
  1048.             
  1049.         {
  1050.             
  1051.                 outp(0x21, inp(0x21) | (1 << Irq));
  1052.             
  1053.         }
  1054.         
  1055.             
  1056.         /* restore the original interrupt routine */ 
  1057.             setOldIntVect(Irq);
  1058.         
  1059.             
  1060.         /* free any memory that had been allocated */ 
  1061.             if (Sb_buffer != 0)
  1062.             
  1063.         {
  1064.             
  1065. #ifdef __WATCOMC__
  1066.                 addr = (uint32) Sb_buffer;
  1067.             
  1068.                 dos_memfree((uint16) (addr >> 4));
  1069.             
  1070. #elif defined(DJGPP)
  1071.                 free(Sb_buffer);
  1072.             
  1073.                 __dpmi_free_dos_memory(theDOSBufferSelector);
  1074.             
  1075. #else                            /* 
  1076.  */
  1077.                 free(Sb_buffer);
  1078.             
  1079. #endif                            /* 
  1080.  */
  1081.         }
  1082.         
  1083.     }
  1084.     
  1085. }
  1086.  
  1087.  
  1088.  
  1089. /*****************************************************************************/ 
  1090. /*                                                                           */ 
  1091. /* Module:  Stop_audio_output                                                */ 
  1092. /* Purpose: Stops the SB's DMA transfer.                                     */ 
  1093. /* Author:  Ron Fries                                                        */ 
  1094. /* Date:    January 17, 1997                                                 */ 
  1095. /*                                                                           */ 
  1096. /*****************************************************************************/ 
  1097.  
  1098. void Stop_audio_output(void) 
  1099. {
  1100.     
  1101.     /* stop any transfer that may be in progress */ 
  1102.         
  1103.     /* if the SB was initialized */ 
  1104.         if (Sb_init)
  1105.         
  1106.     {
  1107.         
  1108.         /* halt DMA */ 
  1109.             dsp_out(IOaddr + DSP_WRITE, 0xd0);
  1110.         
  1111.             
  1112.         /* exit DMA operation */ 
  1113.             dsp_out(IOaddr + DSP_WRITE, 0xda);
  1114.         
  1115.             
  1116.         /* halt DMA */ 
  1117.             dsp_out(IOaddr + DSP_WRITE, 0xd0);
  1118.         
  1119.     }
  1120.     
  1121. }
  1122.  
  1123.  
  1124.  
  1125. /*****************************************************************************/ 
  1126. /*                                                                           */ 
  1127. /* Module:  Start_audio_output                                               */ 
  1128. /* Purpose: Fills all configured buffers and outputs the first.              */ 
  1129. /* Author:  Ron Fries                                                        */ 
  1130. /* Date:    February 20, 1997                                                */ 
  1131. /*                                                                           */ 
  1132. /*****************************************************************************/ 
  1133.  
  1134. uint8 Start_audio_output(uint8 dma_mode, 
  1135.                          void (*fillBuffer) (uint8 * buf, uint16 n)) 
  1136. {
  1137.     
  1138.         uint8 ret_val = 1;
  1139.     
  1140.         static uint8 pagePort[8] =
  1141.     {0x87, 0x83, 0x81, 0x82};
  1142.     
  1143.         uint8 offset_low;
  1144.     
  1145.         uint8 offset_high;
  1146.     
  1147.         uint8 page_no;
  1148.     
  1149.         uint8 count_low;
  1150.     
  1151.         uint8 count_high;
  1152.     
  1153.         uint32 addr;
  1154.     
  1155.         clock_t start_time;
  1156.     
  1157.         
  1158.     /* if the SB initialized properly */ 
  1159.         if (Sb_init)
  1160.         
  1161.     {
  1162.         
  1163.         /* set the fill buffer routine */ 
  1164.             FillBuffer = fillBuffer;
  1165.         
  1166.             
  1167.         /* keep track of the DMA selection */ 
  1168.             DMAmode = dma_mode;
  1169.         
  1170.             
  1171.         /* stop any transfer that may be in progress */ 
  1172.             Stop_audio_output();
  1173.         
  1174.             
  1175.         /* fill the buffer */ 
  1176.             FillBuffer(Sb_buffer, Sb_buf_size * 2);
  1177.         
  1178.             
  1179. #ifdef DJGPP
  1180.         /* Copy data to DOS memory buffer */ 
  1181.             dosmemput(Sb_buffer, Sb_buf_size * 2, theDOSBufferSegment << 4);
  1182.         
  1183. #endif                            /* 
  1184.  */
  1185.             
  1186.         /* calculate high, low and page addresses of buffer */ 
  1187. #ifdef __WATCOMC__
  1188.             addr = (uint32) Sb_buffer;
  1189.         
  1190. #elif defined(DJGPP)
  1191.             addr = ((uint32) theDOSBufferSegment) << 4;
  1192.         
  1193. #else                            /* 
  1194.  */
  1195.             addr = ((uint32) FP_SEG(Sb_buffer) << 4) + 
  1196.             (uint32) FP_OFF(Sb_buffer);
  1197.         
  1198. #endif                            /* 
  1199.  */
  1200.             Sb_offset = (uint16) (addr & 0x0ffff);
  1201.         
  1202.             offset_low = (uint8) (addr & 0x0ff);
  1203.         
  1204.             offset_high = (uint8) ((addr >> 8) & 0x0ff);
  1205.         
  1206.             page_no = (uint8) (addr >> 16);
  1207.         
  1208.             
  1209.             count_low = (uint8) ((Sb_buf_size * 2) - 1) & 0x0ff;
  1210.         
  1211.             count_high = (uint8) (((Sb_buf_size * 2) - 1) >> 8) & 0x0ff;
  1212.         
  1213.             
  1214.         /* program the DMAC for output transfer */ 
  1215.             outp(DMA_MASK, 0x04 | Dma);
  1216.         
  1217.             outp(DMA_FF, 0);
  1218.         
  1219.             
  1220.         /* select auto-initialize DMA mode */ 
  1221.             outp(DMA_MODE, 0x58 | Dma);
  1222.         
  1223.             outp(DMA_BASE + (Dma << 1), offset_low);
  1224.         
  1225.             outp(DMA_BASE + (Dma << 1), offset_high);
  1226.         
  1227.             outp(pagePort[Dma], page_no);
  1228.         
  1229.             outp(DMA_COUNT + (Dma << 1), count_low);
  1230.         
  1231.             outp(DMA_COUNT + (Dma << 1), count_high);
  1232.         
  1233.             outp(DMA_MASK, Dma);
  1234.         
  1235.             
  1236.         /* calculate the high/low buffer size counts */ 
  1237.             Count_low = (uint8) (Sb_buf_size - 1) & 0x0ff;
  1238.         
  1239.             Count_high = (uint8) ((Sb_buf_size - 1) >> 8) & 0x0ff;
  1240.         
  1241.             
  1242.             if (DMAmode == STANDARD_DMA)
  1243.             
  1244.         {
  1245.             
  1246.             /* start the standard DMA transfer */ 
  1247.                 dsp_out(IOaddr + DSP_WRITE, 0x14);
  1248.             
  1249.                 dsp_out(IOaddr + DSP_WRITE, Count_low);
  1250.             
  1251.                 dsp_out(IOaddr + DSP_WRITE, Count_high);
  1252.             
  1253.         }
  1254.         
  1255.             else
  1256.             
  1257.         {
  1258.             
  1259.             /* reset the DMA counter */ 
  1260.                 DMAcount = 0;
  1261.             
  1262.                 
  1263.             /* set the auto-initialize buffer size */ 
  1264.                 dsp_out(IOaddr + DSP_WRITE, 0x48);
  1265.             
  1266.                 dsp_out(IOaddr + DSP_WRITE, Count_low);
  1267.             
  1268.                 dsp_out(IOaddr + DSP_WRITE, Count_high);
  1269.             
  1270.                 
  1271.             /* and start the auto-initialize DMA transfer */ 
  1272.                 dsp_out(IOaddr + DSP_WRITE, 0x1c);
  1273.             
  1274.                 
  1275.                 start_time = clock();
  1276.             
  1277.                 
  1278.             /* Delay for a bit and wait for DMAcount to change. */ 
  1279.             /* Wait for the DMA to be called twice to make sure */ 
  1280.             /* auto-init mode is working properly. */ 
  1281.                 while ((clock() - start_time < (int) (CLK_TCK / 2)) && (DMAcount < 2))
  1282.                 
  1283.             {
  1284.                 
  1285.                 /* This routine will wait for up to 1/2 second for DMAcount */ 
  1286.                 /* to change.  The value in CLK_TCK is the number of times */ 
  1287.                 /* the clock will tick in one second. */ 
  1288.             } 
  1289.                 
  1290.             /* if the auto-init DMA is not active */ 
  1291.                 if (DMAcount < 2)
  1292.                 
  1293.             {
  1294.                 
  1295.                 /* Reset the SB DSP */ 
  1296.                     ResetDSP(IOaddr);
  1297.                 
  1298.                     
  1299.                 /* then try again with STANDARD_DMA */ 
  1300.                     Start_audio_output(STANDARD_DMA, fillBuffer);
  1301.                 
  1302.             }
  1303.             
  1304.         }
  1305.         
  1306.             
  1307.             ret_val = 0;
  1308.         
  1309.     }
  1310.     
  1311.         
  1312.         return (ret_val);
  1313.     
  1314. }
  1315.  
  1316.  
  1317.  
  1318. /*****************************************************************************/ 
  1319. /*                                                                           */ 
  1320. /* Module:  newIntVect                                                       */ 
  1321. /* Purpose: The interrupt vector to handle the DAC DMAC completed interrupt  */ 
  1322. /*          Sends the next buffer to the SB and re-fills the current buffer. */ 
  1323. /* Author:  Ron Fries                                                        */ 
  1324. /* Date:    January 1, 1997                                                  */ 
  1325. /*                                                                           */ 
  1326. /*****************************************************************************/ 
  1327. #ifdef DJGPP
  1328. static void newIntVect(void) 
  1329. #else                            /* 
  1330.  */
  1331. static void interrupt newIntVect(void) 
  1332. #endif                            /* 
  1333.  */
  1334. {
  1335.     
  1336.         uint16 addr;
  1337.     
  1338.         
  1339.         if (DMAmode == STANDARD_DMA)
  1340.         
  1341.     {
  1342.         
  1343.         /* restart standard DMA transfer */ 
  1344.             dsp_out(IOaddr + DSP_WRITE, 0x14);
  1345.         
  1346.             dsp_out(IOaddr + DSP_WRITE, Count_low);
  1347.         
  1348.             dsp_out(IOaddr + DSP_WRITE, Count_high);
  1349.         
  1350.     }
  1351.     
  1352.         
  1353.         DMAcount++;
  1354.     
  1355.         
  1356.     /* acknowledge the DSP interrupt */ 
  1357.         inp(IOaddr + DSP_ACK);
  1358.     
  1359.         
  1360.     /* determine the current playback position */ 
  1361.         addr = inp(DMA_BASE + (Dma << 1));    /* get low byte ptr */
  1362.     
  1363.         addr |= inp(DMA_BASE + (Dma << 1)) << 8;    /* and high byte ptr */
  1364.     
  1365.         
  1366.         addr -= Sb_offset;        /* subtract the offset */
  1367.     
  1368.         
  1369.     /* if we're currently playing the first half of the buffer */ 
  1370.         if (addr < Sb_buf_size)
  1371.         
  1372.     {
  1373.         
  1374.         /* reload the second half of the buffer */ 
  1375.             FillBuffer(Sb_buffer + Sb_buf_size, Sb_buf_size);
  1376.         
  1377.             
  1378. #ifdef DJGPP
  1379.         /* Copy data to DOS memory buffer */ 
  1380.             dosmemput(Sb_buffer + Sb_buf_size, Sb_buf_size, 
  1381.                       (theDOSBufferSegment << 4) + Sb_buf_size);
  1382.         
  1383. #endif                            /* 
  1384.  */
  1385.     }
  1386.     
  1387.         else
  1388.         
  1389.     {
  1390.         
  1391.         /* else reload the first half of the buffer */ 
  1392.             FillBuffer(Sb_buffer, Sb_buf_size);
  1393.         
  1394.             
  1395. #ifdef DJGPP
  1396.         /* Copy data to DOS memory buffer */ 
  1397.             dosmemput(Sb_buffer, Sb_buf_size, theDOSBufferSegment << 4);
  1398.         
  1399. #endif                            /* 
  1400.  */
  1401.     }
  1402.     
  1403.         
  1404.     /* indicate end of interrupt  */ 
  1405.         outp(0x20, 0x20);
  1406.     
  1407.         
  1408.         if (Irq > 7)
  1409.         
  1410.     {
  1411.         
  1412.             outp(0xa0, 0x20);
  1413.         
  1414.     }
  1415.     
  1416. }
  1417.  
  1418.