w99200f.cpp

Vxworks 下的视频采集程序

    W99200WriteReg(BBSAR0, daddress);// Main Memory address (Buffer)
    W99200WriteReg(BBSR,2047);         // Buffer Size -1
    W99200WriteReg(PCICR,0x02);     // Open Master Enable     
    W99200WriteReg(BBSTR0,0x01);      // Buffer ready
    W99200WriteReg(Vwork_mode, 0x0007);
    W99200WriteReg(Vmem_select, dMem_Select);
    // Start Command  
    W99200WriteReg(Vstart, 0x00FF);
    // Reverse Data transfer
    do // Pooling the End of Data
    {
      //Moving data to Main Memory
    } while ( W99200FIFO_End()!=TRUE  );  
    for ( i=0 ; i< 2048 ; i++)
        _dSDRAM_Data[i]=*(pd+i);   
    return TRUE;
} 
// 3/17 end adding
//***********************************************************************
//    Function    :W99200IMEM_Write
//    Description :write 256 bytes to internal memory
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200IMEM_Write(DWORD Mem)
{     
    DWORD dMem_Select;
    int dSize; 
    int i; 
  
    dSize=64;  
    dMem_Select=Mem;
    // Set the internal memories size by index 
    if ( dMem_Select==0x09 || dMem_Select==0x0b )
       dSize=48;
    if ( dMem_Select==0x11 || dMem_Select==0x15 || dMem_Select==0x1d || dMem_Select==0x2b|| dMem_Select==0x0c)
       dSize=32;
    if ( dMem_Select==0x1a)
       dSize=16;          
    // Soft reset  
    W99200ReSet();
    // Configuration 
    W99200WriteReg(Vwork_mode, 0x0008);
    W99200WriteReg(Vmem_select,dMem_Select);
    // Start Command  
    W99200WriteReg(Vstart, 0x00FF);
    // Forward Data transfer
    for ( i=0 ; i < dSize ; i++)
      W99200WriteReg(Vdata_in, _dMem_Data[i]); 
    // Stop Command
    W99200WriteReg(Vstop, 0x00FF);
    return TRUE;
} 

//---
//***********************************************************************
//    Function    :W99200IMEM_Read
//    Description :write 256 bytes to internal memory
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200IMEM_Read(DWORD Mem)
{     
    DWORD dMem_Select;
    DWORD i; 
    
    
    dMem_Select=Mem;     
    // Soft reset  
    W99200ReSet();
    // Configuration  
    //W99200WriteReg(Vint_enable,0x0003);// enable interrupt FIFO ready and end of data 3/16
    W99200WriteReg(Vthreshold, 0x0002);// 8 double-word(32 bytes) 
    W99200WriteReg(Vwork_mode, 0x0009);
    W99200WriteReg(Vmem_select, dMem_Select);
    // Start Command  
    W99200WriteReg(Vstart, 0x00FF);
    // Reverse Data transfer 
    i=0;
    printf( "\n" );
    do // Pooling the End of Data
    { 
      if ( W99200FIFO_Thr()== TRUE )
      {
        _dMem_Data[i]=W99200Inpdw(_IOBase+_ulODPR);
        _dMem_Data[i+1]=W99200Inpdw(_IOBase+_ulODPR); 
        _dMem_Data[i+2]=W99200Inpdw(_IOBase+_ulODPR);
        _dMem_Data[i+3]=W99200Inpdw(_IOBase+_ulODPR);
        _dMem_Data[i+4]=W99200Inpdw(_IOBase+_ulODPR);
        _dMem_Data[i+5]=W99200Inpdw(_IOBase+_ulODPR);
        _dMem_Data[i+6]=W99200Inpdw(_IOBase+_ulODPR);
        _dMem_Data[i+7]=W99200Inpdw(_IOBase+_ulODPR);  
        i=i+8;
        if ( (i%50)==0 )
           printf( "." );
      }
    } while ( W99200FIFO_End()!=TRUE  );
    printf( "\n" );
    return TRUE;
}
// 3/16 adding
//***********************************************************************
//    Function    :W99200IMEM_MARead
//    Description :write 256 bytes to internal memory
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200IMEM_MARead(DWORD Mem)
{     
    DWORD dMem_Select;
    DWORD i;  
    DWORD daddress;  
    BYTE  *bOffset;
    DWORD *pd;
    DWORD seg_val=0,off_val=0;
    void  *pp = _dMem_Data;
    
//    bOffset=(BYTE *)pp;
//    seg_val=_FP_SEG(pp);
//    off_val=_FP_OFF(pp);
//    daddress=(DWORD)seg_val;
//    daddress <<= 4;
//    daddress += off_val;
      daddress=pp;
    for( i = 0; i < 4; i ++ )
    {
        if((daddress & 0x0003) == 0)
            break;
        daddress ++;
    } 
    bOffset=bOffset+i;   
    pd=(DWORD *)bOffset;
    dMem_Select=Mem;     
    // Soft reset  
    W99200ReSet();
    // Configuration  
    //W99200WriteReg(Vint_enable,0x0003);// enable interrupt FIFO ready and end of data 3/16
    W99200WriteReg(Vthreshold, 0x0002);// 8 double-word(32 bytes) 
    W99200WriteReg(BBSAR0, daddress);// Main Memory address (Buffer)
    W99200WriteReg(BBSR,63);         // Buffer Size -1
    W99200WriteReg(PCICR,0x02);     // Open Master Enable    
    W99200WriteReg(BBSTR0,0x01);      // Buffer ready
    W99200WriteReg(Vwork_mode, 0x0009);
    W99200WriteReg(Vmem_select, dMem_Select);
    // Start Command  
    W99200WriteReg(Vstart, 0x00FF);
    // Reverse Data transfer
    printf( "\n" );
    do // Pooling the End of Data
    {
      //Moving data to Main Memory
    } while ( W99200FIFO_End()!=TRUE  );
    for ( i=0 ; i< 64 ; i++)
        _dMem_Data[i]=*(pd+i);
    printf( "\n" );
    return TRUE;
}
//------------
// Audio_Read
//***********************************************************************
//    Function    :W99200SDRA_Read
//    Description :Read One Blok Data
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200AUDIO_Read(void)
{
    DWORD i; 
    
    FILE *fp1;
   // open write file
    if( (fp1 = fopen( "AUDIO.OUT", "w+b" )) == NULL ) 
    {
     printf( "The file 'AUDIO.OUT' was not opened\n" );
     return 0;
    }  
    // Soft reset  
    W99200ReSet();
    // Configuration  
    //W99200WriteReg(Vint_enable,0x0003);// enable interrupt FIFO ready and end of data
    W99200WriteReg(AFCR0,0x000C);// 0000 1100 : threshold=128 bytes
    // Start Command  
    W99200WriteReg(AFCR1, 0x0010); // Audio Strat
    // Reverse Data transfer 
    i=0;
    do // Pooling the End of Data
    { 
      if ( W99200AUDIO_Thr()== TRUE )
      {            
        for ( i =0 ; i< 32 ; i++ )
          _dAUDIO_Data[i]=W99200ReadReg(Audio_out);
      }    
      fwrite( _dAUDIO_Data, sizeof(_dAUDIO_Data), 32, fp1 );    
    } while ( W99200AUDIO_End()!=TRUE  ); 
    // Stop Command
    W99200WriteReg(AFCR1, 0x0008); // Audio Stop
    fclose(fp1);
    return TRUE;
}  

//***********************************************************************
//    Function    :W99200AUDIO_THR
//    Description :Polling the  AUDIO passes the threshold level
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200AUDIO_Thr(void)
{
    DWORD ulRet; 
    clock_t start, end; 

    // Polling FIFO passes the threshold  
    start=clock();
    do
    {  
       ulRet=W99200ReadReg(AFISR); // 1-bit=1: FIFO passed the threshold 
       if ( (ulRet & 0x0001) == 0x0001 )
         return TRUE; 
       end=clock();    
    }while( (end-start) < 500 );
    return FALSE;
} 

//***********************************************************************
//    Function    :W99200AUDIO_End
//    Description :Polling the  AUDIO passes the threshold level
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200AUDIO_End(void)
{
    DWORD ulRet; 
    clock_t start, end; 

    // Polling FIFO passes the threshold  
    start=clock();
    do
    {  
       ulRet=W99200ReadReg(AFISR); // 1-bit=1: FIFO passed the threshold 
       if ( (ulRet & 0x0002) == 0x0002 )
         return TRUE; 
       end=clock();    
    }while( (end-start) < 500 );
    return FALSE;
} 

//***********************************************************************
//    Function    :W9920026QF_Read
//    Description :Read W9926QF One Register
//    Parameters  :DWORD index  
//    Return      :TRUE or FALSE
//***********************************************************************
DWORD W9920026QF_Read(DWORD index)
{ 
  DWORD dValue;
  DWORD dData,dData0,dData1,dData2,dData3;
  DWORD dAddr0,dAddr1,dAddr2,dAddr3; 
  int i;
  dAddr3= index & 0xF000;
  dAddr2= index & 0x0F00;
  dAddr1= index & 0x00F0;
  dAddr0= index & 0x000F;
  
  W99200WriteReg(PCR,0x0080);
  W99200WriteReg(PCR,0x0020);
  W99200WriteReg(PCR,0x0040);
  dValue=(DWORD)('!'& 0x00FF);
  W99200WriteReg(0x0070,dValue); 
  for ( i=0 ; i< 4 ; i++)
  {
     dValue=(DWORD)('N'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
     dValue=(DWORD)('A'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
     dValue=(DWORD)('5'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
     dValue=(DWORD)('1'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
     dValue=(DWORD)('7'& 0x00FF);
     W99200WriteReg(0x0070,dValue);
     dValue=(DWORD)('9'& 0x00FF);
     W99200WriteReg(0x0070,dValue);  
     dValue=(DWORD)('!'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
  } 

  W99200WriteReg(0x73,dAddr3); // AIR3 ( 26QF) 
  W99200WriteReg(0x72,dAddr2); // AIR2 ( 26QF)
  W99200WriteReg(0x71,dAddr1); // AIR1 ( 26QF)
  W99200WriteReg(0x70,dAddr0); // AIR0 ( 26QF)
 
  dData3=W99200ReadReg(0x77);  // DPR3
  dData2=W99200ReadReg(0x76);  // DPR2
  dData1=W99200ReadReg(0x75);  // DPR1
  dData0=W99200ReadReg(0x74);  // DPR0
  dData3 >>=12;
  dData3= dData3 & 0xF000;
  dData2 >>=8;
  dData2= dData2 & 0x0F00;
  dData1 >>=4;
  dData1= dData1 & 0x00F0;
  dData0= dData0 & 0x000F; 
  dData=dData3 | dData2 | dData1| dData0; 
  return dData;
 
}

//
//***********************************************************************
//    Function    :W9920026QF_Write
//    Description :Write W9926QF One Register
//    Parameters  :DWORD index  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W9920026QF_Write(DWORD index, DWORD data)
{ 
  DWORD dValue;
  DWORD dData0,dData1,dData2,dData3;
  DWORD dAddr0,dAddr1,dAddr2,dAddr3; 
  int i;
  dAddr3= index & 0xF000;
  dAddr2= index & 0x0F00;
  dAddr1= index & 0x00F0;
  dAddr0= index & 0x000F;
  
  dData3= data & 0xF000;
  dData2= data & 0x0F00;
  dData1= data & 0x00F0;
  dData0= data & 0x000F;
  
  W99200WriteReg(PCR,0x0080);
  W99200WriteReg(PCR,0x0020);
  W99200WriteReg(PCR,0x0040);
  dValue=(DWORD)('!'& 0x00FF);
  W99200WriteReg(0x0070,dValue); 
  for ( i=0 ; i< 4 ; i++)
  {
     dValue=(DWORD)('N'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
     dValue=(DWORD)('A'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
     dValue=(DWORD)('5'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
     dValue=(DWORD)('1'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
     dValue=(DWORD)('7'& 0x00FF);
     W99200WriteReg(0x0070,dValue);
     dValue=(DWORD)('9'& 0x00FF);
     W99200WriteReg(0x0070,dValue);  
     dValue=(DWORD)('!'& 0x00FF);
     W99200WriteReg(0x0070,dValue); 
  } 

  W99200WriteReg(0x73,dAddr3); // AIR3 ( 26QF) 
  W99200WriteReg(0x72,dAddr2); // AIR2 ( 26QF)
  W99200WriteReg(0x71,dAddr1); // AIR1 ( 26QF)
  W99200WriteReg(0x70,dAddr0); // AIR0 ( 26QF)
 
  W99200WriteReg(0x77,dData3); // DPR3 ( 26QF) 
  W99200WriteReg(0x76,dData2); // DPR2 ( 26QF)
  W99200WriteReg(0x75,dData1); // DPR1 ( 26QF)
  W99200WriteReg(0x74,dData0); // DPR0 ( 26QF)
  return 1;
 
} 


//-------------------------- 5/4 modify for AUDIOCDEC New ----------------------      
//***********************************************************************
//    Function    :AK4516ReadReg
//    Description :Read AK4516 One Register
//    Parameters  :DWORD index
//    Return      :  Value
//***********************************************************************
DWORD AK4516ReadReg(DWORD index)
{
   DWORD dOperation_code;
   DWORD dResult;
   DWORD value;
   DWORD data;
   int i;

   W99200WriteReg(GPCR,0);// Set GPCR=0;
   W99200WriteReg(GPOR,0);// Set GPOR=0;
   dOperation_code=0x03; // operation_code=0000011;( bits)
   index <<= 3 ;            
   dResult=dOperation_code|index;
   /* dResult<<= 24; */
   for ( i=0 ; i < 8 ; i++)
   {
     if ( (dResult & 0x01)== 0x01 ) // check bit0=1
     {
        W99200WriteReg(GPCR,0x05);
        W99200WriteReg(GPCR,0x04);
     }
     else
     {
        W99200WriteReg(GPCR,0x07);
        W99200WriteReg(GPCR,0x06);
     }
     dResult >>= 1;
   }
   value=0;
   for ( i=0 ; i < 8 ; i++ )
   {
       W99200WriteReg(GPCR,0x05);
       data=W99200ReadReg(GPIR);
       data = data & 0x02 ;
       if( data == 0x02)
          value = value | 0x100 ;
       value >>=1;
       W99200WriteReg(GPCR,0x04);
   }
   W99200WriteReg(GPCR,0x00) ;     /* Set to the initial state */
   return value;
}


//***********************************************************************
//    Function    :AK4516WriteReg
//    Description :Write AK4516 One Register
//    Parameters  :DWORD index  DWORD dValue
//    Return      :  TRUE ot FALSE
//***********************************************************************
BOOL AK4516WriteReg(DWORD index,DWORD dvalue)
{
   DWORD dOperation_code;
   DWORD dResult;
   DWORD value;
   int i;

   W99200WriteReg(GPCR,0);// Set GPCR=0;
   W99200WriteReg(GPOR,0);// Set GPOR=0;
   dOperation_code=0x07; // operation_code=00000111;( bits)
   index <<= 3 ;
   dResult=dOperation_code|index;
   /* dResult<<= 24; */
   for ( i=0 ; i < 8 ; i++)
   {
     if ( (dResult & 0x01)== 0x01 ) // check bit0=1
     {
        W99200WriteReg(GPCR,0x05);
        W99200WriteReg(GPCR,0x04);
     }
     else
     {
        W99200WriteReg(GPCR,0x07);
        W99200WriteReg(GPCR,0x06);
     }
     dResult >>= 1;
   }
   value=dvalue;
   for ( i=0 ; i < 8 ; i++ )
   {
       if ( (value & 0x01)==0x01 )   // check bit0 = 1
       {
          W99200WriteReg(GPCR,0x05);
          W99200WriteReg(GPCR,0x04);
       }
       else
       {
          W99200WriteReg(GPCR,0x07);
          W99200WriteReg(GPCR,0x06);
       }
       value >>=1;
   }
   W99200WriteReg(GPCR,0x00) ;    /* Set to the initial state */
   return TRUE;
}



//---------------------------5/4 end------------------------