AhoLib: Fichero Fuente sb16dt.c

00001 /**********************************************************/
00002 /*/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\*/
00003 /*
00004 Copyright: 1993 - Grupo de Voz (DAET) ETSII/IT-Bilbao
00005 
00006 Nombre fuente................ SB16DT.C
00007 Nombre paquete............... -
00008 Lenguaje fuente.............. C (Borland C/C++ 3.1)
00009 Estado....................... Completado
00010 Dependencia Hard/OS.......... DT2801A
00011 Codigo condicional........... -
00012 
00013 Codificacion................. Borja Etxebarria
00014 
00015 Version  dd/mm/aa  Autor     Proposito de la edicion
00016 -------  --------  --------  -----------------------
00017 1.0.3    24/08/94  Borja     adaptacion a nuevo blaster_env() dec/hex.
00018 1.0.2    16/05/94  Borja     adaptacion a nueva interfaz LMEM.
00019 1.0.1    15/05/94  Borja     adaptacion a nueva interfaz DMA.
00020 1.0.0    19/02/94  Borja     Codificacion inicial.
00021 
00022 ======================== Contenido ========================
00023 Mapea la libreria de funciones de la tarjeta DT2801A de
00024 DataTranslation sobre la Sound Blaster 16.
00025 No se han implementado todas las funciones!!!!!
00026 ===========================================================
00027 */
00028 /*/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\*/
00029 /**********************************************************/
00030 
00031 #include <stdlib.h>
00032 
00033 #include "tdef.h"
00034 #include "lmem.h"
00035 #include "dma.h"
00036 #include "intrs.h"
00037 #include "sb.h"
00038 #include "blaster.h"
00039 
00040 /**********************************************************/
00041 
00042 PRIVATE BOOL  _sb16_initialized = FALSE;
00043 
00044 PRIVATE UINT16 _sb16_baseport;
00045 PRIVATE UINT16 _sb16_irq;
00046 PRIVATE UINT16 _sb16_dma16;
00047 
00048 PRIVATE UINT16 _rate = 8000;
00049 PRIVATE UINT32 _lmem;  /* buffer circular en formato lineal */
00050 PRIVATE UINT16 _nelem;  /* longitud del buffer circular (muestras 16 bits) */
00051 
00052 // PRIVATE VOID INTERRUPT (* _sb16_oldint) ( ) = NULL;
00053 PRIVATE IntrServiceFunc _sb16_oldint = NULL;
00054 
00055 /**********************************************************/
00056 
00057 void interrupt sb16_newint( void )
00058 {
00059     sb_IRQ_ack(_sb16_baseport);   /* ack a lo bruto para DSP */
00060     PIC_SEND_EOI(_sb16_irq);  /* ack para PIC */
00061 }
00062 
00063 /**********************************************************/
00064 
00065 short initialize( void )
00066 {
00067     if (!_sb16_initialized) {
00068         /* lee configuracion de entorno BLASTER */
00069         _sb16_baseport = blaster_env(BLASTER_BASEPORT,
00070                 BLASTER_DEFAULT_BASEPORT, BLASTER_DECHEX_BASEPORT);
00071         _sb16_irq = blaster_env(BLASTER_IRQ,
00072                 BLASTER_DEFAULT_IRQ, BLASTER_DECHEX_IRQ);
00073         _sb16_dma16 = blaster_env(BLASTER_DMA16,
00074                 BLASTER_DEFAULT_DMA16,BLASTER_DECHEX_DMA16);
00075     }
00076 
00077     /* resetea la tarjeta, -1 en caso de error ??????????? */
00078     if (sb_DSP_reset(_sb16_baseport))
00079         return -1;
00080 
00081     if (!_sb16_initialized) {
00082         _sb16_initialized = TRUE;
00083 
00084         /* programa rutina servicio interrupcion */
00085         _sb16_oldint = INT_GET_VEC(IRQ_INTN(_sb16_irq));
00086         INT_SET_VEC(IRQ_INTN(_sb16_irq),sb16_newint);
00087 
00088         /* conecta IRQ */
00089         PIC_ENABLE(_sb16_irq);
00090         PIC_SEND_EOI(_sb16_irq);
00091     }
00092 
00093     return 0;
00094 }
00095 
00096 /**********************************************************/
00097 
00098 short select_board( short )
00099 {
00100     if (!_sb16_initialized)
00101         return -1;
00102 
00103     return 0;
00104 }
00105 
00106 /**********************************************************/
00107 
00108 short find_dma_length( unsigned short * buff, short * maxlen )
00109 {
00110     if (!_sb16_initialized)
00111         return -1;
00112 
00113     if (DMA_IS_DMA16(_sb16_dma16))  /* DMA de 16 bits ? */
00114         *maxlen = (short)(fixlen((pfVOID)buff,0xFFFFL,128,2,2) >> 1);
00115     else
00116         *maxlen = (short)(fixlen((pfVOID)buff,0xFFFFL,64,1,2) >> 1);
00117     return 0;
00118 }
00119 
00120 /**********************************************************/
00121 
00122 short terminate( void )
00123 {
00124     if (!_sb16_initialized)
00125         return -1;
00126 
00127     sb_DSP_reset(_sb16_baseport);
00128 
00129     /* desconecta DMA */
00130     dma_disable(_sb16_dma16);
00131 
00132     PIC_DISABLE(_sb16_irq);
00133     INT_SET_VEC(IRQ_INTN(_sb16_irq),_sb16_oldint);
00134 
00135     _sb16_initialized = FALSE;
00136 
00137     return 0;
00138 }
00139 
00140 /**********************************************************/
00141 
00142 short setup_adc( short , short , short , short )
00143 {
00144     if (!_sb16_initialized)
00145         return -1;
00146 
00147     return 0;
00148 }
00149 
00150 /**********************************************************/
00151 
00152 short begin_adc_dma( short len, unsigned short * buff )
00153 {
00154     short tmp;
00155 
00156     if (!_sb16_initialized)
00157         return -1;
00158 
00159     /* comprueba longitud maxima posible */
00160     find_dma_length(buff, &tmp);
00161     _nelem = (len > tmp) ? tmp : len;   /* limita si es necesario */
00162     _lmem = PTR2LMEM(buff);
00163     if (!_nelem)  /* sal si no hay buffer */
00164         return -1;
00165 
00166     /* programa DMA */
00167     dma_set(_sb16_dma16, DMA_INCREMENT, DMA_SINGLE_CICLE, DMA_WRITE_TO_MEM,
00168             _lmem, DMA_IS_DMA16(_sb16_dma16) ? _nelem - 1 :
00169             ((UINT16)_nelem << 1) - 1, DMA_ENABLE);
00170 
00171     /* programa DSP */
00172     return sb_DSP_16(_sb16_baseport, SB_DSP_INPUT, SB_DSP_SINGLE_CICLE,
00173             SB_DSP_FIFO_ON, SB_DSP_MONO, SB_DSP_SIGNED,
00174             (UINT16)(_nelem - 1));
00175 
00176 }
00177 
00178 /**********************************************************/
00179 
00180 short continuous_adc_dma( short len, unsigned short * buff )
00181 {
00182     short tmp;
00183 
00184     if (!_sb16_initialized)
00185         return -1;
00186 
00187     /* comprueba longitud maxima posible */
00188     find_dma_length(buff, &tmp);
00189     _nelem = (len > tmp) ? tmp : len;   /* limita si es necesario */
00190     _lmem = PTR2LMEM(buff);
00191     if (!_nelem)  /* sal si no hay buffer */
00192         return -1;
00193 
00194     /* programa DMA */
00195     dma_set(_sb16_dma16, DMA_INCREMENT, DMA_AUTO_INIT, DMA_WRITE_TO_MEM,
00196             _lmem, DMA_IS_DMA16(_sb16_dma16) ? _nelem - 1 :
00197             ((UINT16)_nelem << 1) - 1, DMA_ENABLE);
00198 
00199     /* programa DSP */
00200     return sb_DSP_16(_sb16_baseport, SB_DSP_INPUT, SB_DSP_AUTO_INIT,
00201             SB_DSP_FIFO_ON, SB_DSP_MONO, SB_DSP_SIGNED,
00202             (UINT16)((_nelem >> 1) - 1));
00203 }
00204 
00205 /**********************************************************/
00206 
00207 short test_adc_dma( short * left )
00208 {
00209     if (!_sb16_initialized)
00210         return -1;
00211 
00212     /* lee DMA */
00213     *left = dma_get_count_l1(_sb16_dma16) + 1;
00214 
00215     if (! DMA_IS_DMA16(_sb16_dma16))
00216         *left >>= 1;
00217 
00218     return 0;
00219 }
00220 
00221 /**********************************************************/
00222 
00223 short wait_adc_dma( unsigned short *  ptr )
00224 {
00225     UINT16 left_l1, count_l1, ocount_l1;
00226 
00227     if (!_sb16_initialized)
00228         return -1;
00229 
00230     left_l1 = _nelem - (UINT16)((PTR2LMEM(ptr) - _lmem) >> 1);
00231     ocount_l1 = _nelem;
00232     if (! DMA_IS_DMA16(_sb16_dma16)) {
00233         left_l1 <<= 1;
00234         ocount_l1 <<= 1;
00235         }
00236     left_l1 -= 1;
00237 
00238     /* mientras estes por delante y no comienze ciclo nuevo */
00239     while (((count_l1 = dma_get_count_l1(_sb16_dma16)) >= left_l1) &&
00240             (ocount_l1 >= count_l1))
00241         ocount_l1 = count_l1;
00242 
00243     return 0;
00244 }
00245 
00246 /**********************************************************/
00247 
00248 short stop_adc_dma( void )
00249 {
00250     if (!_sb16_initialized)
00251         return -1;
00252 
00253     sb_DSP_16_pause(_sb16_baseport);
00254     sb_DSP_reset(_sb16_baseport);
00255     sb_DSP_out_rate(_sb16_baseport, _rate);
00256     sb_DSP_in_rate(_sb16_baseport, _rate);
00257 
00258     return 0;
00259 }
00260 
00261 /**********************************************************/
00262 
00263 short setup_dac( short , short )
00264 {
00265     if (!_sb16_initialized)
00266         return -1;
00267 
00268     return 0;
00269 }
00270 /**********************************************************/
00271 
00272 short begin_dac_dma( short len, unsigned short * buff )
00273 {
00274     short tmp;
00275 
00276     if (!_sb16_initialized)
00277         return -1;
00278 
00279     /* comprueba longitud maxima posible */
00280     find_dma_length(buff, &tmp);
00281     _nelem = (len > tmp) ? tmp : len;   /* limita si es necesario */
00282     _lmem = PTR2LMEM(buff);
00283     if (!_nelem)  /* sal si no hay buffer */
00284         return -1;
00285 
00286     /* programa DMA */
00287     dma_set(_sb16_dma16, DMA_INCREMENT, DMA_SINGLE_CICLE, DMA_READ_FROM_MEM,
00288             _lmem, DMA_IS_DMA16(_sb16_dma16) ? _nelem - 1 :
00289             ((UINT16)_nelem << 1) - 1, DMA_ENABLE);
00290 
00291     /* programa DSP */
00292     return sb_DSP_16(_sb16_baseport, SB_DSP_OUTPUT, SB_DSP_SINGLE_CICLE,
00293             SB_DSP_FIFO_ON, SB_DSP_MONO, SB_DSP_SIGNED,
00294             (UINT16)(_nelem - 1));
00295 }
00296 
00297 /**********************************************************/
00298 
00299 short continuous_dac_dma( short len, unsigned short * buff )
00300 {
00301     short tmp;
00302 
00303     if (!_sb16_initialized)
00304         return -1;
00305 
00306     /* comprueba longitud maxima posible */
00307     find_dma_length(buff, &tmp);
00308     _nelem = (len > tmp) ? tmp : len;   /* limita si es necesario */
00309     _lmem = PTR2LMEM(buff);
00310     if (!_nelem)  /* sal si no hay buffer */
00311         return -1;
00312 
00313     /* programa DMA */
00314     dma_set(_sb16_dma16, DMA_INCREMENT, DMA_AUTO_INIT, DMA_READ_FROM_MEM,
00315             _lmem, DMA_IS_DMA16(_sb16_dma16) ? _nelem - 1 :
00316             ((UINT16)_nelem << 1) - 1, DMA_ENABLE);
00317 
00318     /* programa DSP */
00319     return sb_DSP_16(_sb16_baseport, SB_DSP_OUTPUT, SB_DSP_AUTO_INIT,
00320             SB_DSP_FIFO_ON, SB_DSP_MONO, SB_DSP_SIGNED,
00321             (UINT16)((_nelem >> 1) - 1));
00322 }
00323 
00324 /**********************************************************/
00325 
00326 short test_dac_dma( short * left )
00327 {
00328     if (!_sb16_initialized)
00329         return -1;
00330 
00331     /* lee DMA */
00332     *left = dma_get_count_l1(_sb16_dma16) + 1;
00333 
00334     if (! DMA_IS_DMA16(_sb16_dma16))
00335         *left >>= 1;
00336 
00337     return 0;
00338 
00339 }
00340 
00341 /**********************************************************/
00342 
00343 short wait_dac_dma( unsigned short * ptr )
00344 {
00345     UINT16 left_l1, count_l1, ocount_l1;
00346 
00347     if (!_sb16_initialized)
00348         return -1;
00349 
00350     left_l1 = _nelem - (UINT16)((PTR2LMEM(ptr) - _lmem) >> 1);
00351     ocount_l1 = _nelem;
00352     if (! DMA_IS_DMA16(_sb16_dma16)) {
00353         left_l1 <<= 1;
00354         ocount_l1 <<= 1;
00355         }
00356     left_l1 -= 1;
00357 
00358     /* mientras estes por delante y no comienze ciclo nuevo */
00359     while (((count_l1 = dma_get_count_l1(_sb16_dma16)) >= left_l1) &&
00360             (ocount_l1 >= count_l1))
00361         ocount_l1 = count_l1;
00362 
00363     return 0;
00364 }
00365 
00366 /**********************************************************/
00367 
00368 short stop_dac_dma( void )
00369 {
00370     if (!_sb16_initialized)
00371         return -1;
00372 
00373     sb_DSP_16_pause(_sb16_baseport);
00374     sb_DSP_reset(_sb16_baseport);
00375     sb_DSP_out_rate(_sb16_baseport, _rate);
00376     sb_DSP_in_rate(_sb16_baseport, _rate);
00377 
00378     return 0;
00379 }
00380 
00381 /**********************************************************/
00382 
00383 short set_clock_frequency( float * frate )
00384 {
00385     if (!_sb16_initialized)
00386         return -1;
00387 
00388     _rate = (UINT16)(*frate + 0.5);
00389 
00390     sb_DSP_out_rate(_sb16_baseport, _rate);
00391     sb_DSP_in_rate(_sb16_baseport, _rate);
00392 
00393     return 0;
00394 }
00395 
00396 /**********************************************************/
00397 
00398 short set_error_control_word( unsigned short )
00399 {
00400     return 0;
00401 }
00402 
00403 /**********************************************************/
00404