w99200f.cpp

Vxworks 下的视频采集程序

#include <stdio.h>
#include <time.h>
//#include <dos.h>
#include"syslib.h"
#include "pci.h"
#include "xdefine.h" 
#include "w99200f.h"
extern unsigned long _IOBase;     // I/O base for video 
 
#define I2C_READY 0x0040 // 6-bit=1 I2C ready  
#define SA7114_W  0x0042 // SAA7114 Write Mode
#define SA7114_R  0x0043 // SAA7114 Read Mode 

#define SA7113_W  0x004A
#define SA7113_R  0x004B

extern DWORD _dMem_Data[64];
extern DWORD _dSDRAM_Data[2052];
extern DWORD _dAUDIO_Data[32]; 


 
DWORD  _ulAIR=0L;     // Address Index Register
DWORD  _ulDPR=4L ;    // Data Port Register 
DWORD  _ulODPR=8L ;   // the Output port of the Output-FIFO

  
BOOL W99200WriteReg(DWORD index, DWORD value);
DWORD W99200ReadReg (DWORD index);
void  W99200ReSet(); 

BOOL  W99200I2CWrite(DWORD Subadrs,DWORD *Value,UINT Count);
BOOL  W99200I2CRead(DWORD Subadrs,DWORD *Value); 

BOOL W99200SDRAM_Write(DWORD Mem); 
BOOL W99200SDRAM_Read(DWORD Mem);
BOOL W99200SDRAM_MARead(DWORD Mem);

BOOL W99200IMEM_Write(DWORD Mem); 
BOOL W99200IMEM_Read(DWORD Mem); 
BOOL W99200IMEM_MARead(DWORD Mem);

BOOL W99200AUDIO_End(void);
BOOL W99200AUDIO_Thr(void); 
BOOL W99200AUDIO_Read(void); 

BOOL W9920026QF_Write(DWORD index, DWORD data);  
DWORD W9920026QF_Read(DWORD index);

// AUDIO CODEC Test
DWORD AK4516ReadReg(DWORD index);  
BOOL AK4516WriteReg(DWORD index,DWORD dvalue);




void W99200OutIndexdw(DWORD Port, DWORD IndexData,DWORD DataAddress, DWORD Data); 
DWORD W99200InIndexdw(DWORD Port, DWORD IndexData, DWORD DataAddress);
void W99200Outpdw(DWORD port, DWORD data);
DWORD W99200Inpdw(DWORD port);

BOOL W99200I2CStatus(void);

BOOL W99200FIFO_Thr(void); 
BOOL W99200FIFO_End(void);
void W99200F_DELAY(void) ; 

extern int iSA;
//***********************************************************************
//    Function    :W99200F_DELAY
//    Description :
//    Return      :None
//***********************************************************************
void W99200F_DELAY(void)
{     
      
    clock_t start,end;
    return;
    start=clock();
    do
    {
       end=clock(); 
       //printf(" start->%ld, end->%ld\n", start,end );
    }while( (end-start) < 100 );  

}
//***********************************************************************
//    Function    :W99200WriteReg
//    Description :
//    Return      :BOOL
//***********************************************************************
BOOL W99200WriteReg(DWORD index, DWORD value)
{  
  
//  printf("WriteReg: Index=%x, value=%x\n", index, value);
  W99200OutIndexdw(_IOBase+_ulAIR,index,_IOBase+_ulDPR,value);
  return TRUE;  
} 

//***********************************************************************
//    Function    :W99200ReadReg
//    Description :
//    Return      :BOOL
//***********************************************************************
DWORD W99200ReadReg(DWORD index)
{  
  DWORD ulRet;
  ulRet=W99200InIndexdw(_IOBase+_ulAIR,index,_IOBase+_ulDPR);
  return ulRet;  
} 

//***********************************************************************
//    Function    :W99200ReSet
//    Description :
//    Return      :NONE
//***********************************************************************
void W99200ReSet()
{  
   DWORD value;
   value=0xFF;
   W99200WriteReg(Video_reset, value);   
} 
//***********************************************************************
//    Function    :W99200Outpdw
//    Description :
//    Return      :NONE
//***********************************************************************
void W99200Outpdw(DWORD port, DWORD data)
{
 // _outpdw((WORD) port,data);// direct outport a double word
 sysOutWord((int)port,(short)data);
}

//***********************************************************************
//    Function    :W99200OutIndexdw
//    Description :
//    Return      :NONE
//***********************************************************************
void W99200OutIndexdw(DWORD Port, DWORD IndexData, DWORD DataAddress, DWORD Data)
{
   W99200Outpdw(Port,IndexData); // outport register index
   W99200Outpdw(DataAddress,Data); // outport data                                                                    
} 


//***********************************************************************
//    Function    :W99200InIndexdw
//    Description :
//    Return      :DWORD
//***********************************************************************
DWORD W99200InIndexdw (DWORD Port, DWORD IndexData, DWORD DataAddress)
{
   DWORD data=0; 
   W99200Outpdw(Port,IndexData); // outport register index
   data=W99200Inpdw(DataAddress);
   return data;
}

//***********************************************************************
//    Function    :W99200Inpdw
//    Description :
//    Return      :
//***********************************************************************
DWORD W99200Inpdw(DWORD Port)
{
  DWORD data=0;
//  data=_inpdw((WORD) Port); // direct inport a double word
  data=sysInWord((int)Port);
  return data;                                                                  
}

//***********************************************************************
//    Function    :W99200I2CWrite
//    Description :Write data to IC2
//    Parameters  :Subaddress, Data, Count  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200I2CWrite(DWORD Subadrs, DWORD *Value,UINT Count)
{       
  
  DWORD dValue[256];
  int iResult=0;
  UINT uCount,i;

//  printf("Subadrs=%x Value=%x\n", Subadrs, *Value);
  
  uCount=Count; 
  // Read the written data
  for ( i=0 ; i < uCount ; i++ )
  {
      dValue[i]=*Value;
      Value++;
  } 
  // enable interrupt I2C ready   
  //W99200WriteReg(Vint_enable, I2C_READY); 
 
  // *** I2C Start 
  W99200WriteReg(I2c_start, 0x00FF); // I2c_start: any data
  // *** Write Device ID, SAA7114 Write Mode=42, Read Mode=43 
  if ( iSA==2 )
     W99200WriteReg(I2c_data, SA7114_W); 
  else
     W99200WriteReg(I2c_data, SA7113_W); 
     
  //W99200F_DELAY(); // otis adding 4/1
  // Check I2C Acknowledge
  if ( W99200I2CStatus()== TRUE ) 
  {
    // Write Subaddress
    W99200WriteReg(I2c_data, Subadrs);
    //W99200F_DELAY(); // otis adding 4/1
    if ( W99200I2CStatus()!= TRUE ) // Check I2C Acknowledge
         return FALSE; 
    // Write data     
    for ( i=0 ; i < uCount ; i++ )
    {
       W99200WriteReg(I2c_data, dValue[i]);
      // W99200F_DELAY(); // otis adding 4/1
       if ( W99200I2CStatus()!= TRUE ) // Check I2C Acknowledge
         return FALSE;
    }
    // I2C Stop
    W99200WriteReg(I2c_stop, 0x00FF); // I2c_stop = any data
    //W99200F_DELAY(); // otis adding 4/1
    if ( W99200I2CStatus() == TRUE )
         return TRUE;
    else
         return FALSE;   
  }
  else
    return FALSE;  
    } 


//***********************************************************************
//    Function    :W99200I2CRead
//    Description :Read data from I2C
//    Parameters  :Subaddress  
//    Return      :Data
//***********************************************************************
BOOL W99200I2CRead(DWORD Subadrs,DWORD *Value)
{  
  // === Write SAA7114 Subadress ===
  //W99200WriteReg(Vint_enable, I2C_READY);// enable interrupt I2C ready
  // I2C Start 
  W99200WriteReg(I2c_start, 0x00FF); // I2c_start: any data
  // Write Device ID, SAA7114 Write Mode=40, Read Mode=41 
  if ( iSA==2 )
     W99200WriteReg(I2c_data, SA7114_W);   
  else
     W99200WriteReg(I2c_data, SA7113_W);      
  // Check I2C Acknowledge
  //W99200F_DELAY(); // otis adding 4/1
  if ( W99200I2CStatus()!= TRUE )
     return FALSE;
  // Write Subaddress   
  W99200WriteReg(I2c_data, Subadrs);
  // Check I2C Acknowledge
  //W99200F_DELAY(); // otis adding 4/1
  if ( W99200I2CStatus()!= TRUE )
     return FALSE;
     
  // === Read Date === 
  // enable interrupt I2C ready   
  //W99200WriteReg(Vint_enable, I2C_READY);
  // I2C Start 
  W99200WriteReg(I2c_start, 0x00FF); // I2c_start: any data 
  // Write Device ID, SAA7114 Write Mode=40, Read Mode=41 
  if ( iSA==2)
     W99200WriteReg(I2c_data, SA7114_R);
  else
     W99200WriteReg(I2c_data, SA7113_R);
  //W99200F_DELAY(); // otis adding 4/1
  if ( W99200I2CStatus()!= TRUE ) // Check I2C Acknowledge
     return FALSE;
  *Value=W99200ReadReg(I2c_data);
  // I2C Stop
  W99200WriteReg(I2c_stop, 0x00FF); // I2c_stop = any data
  if ( W99200I2CStatus()!= TRUE )
     return FALSE; 
  else
     return TRUE;   
  
}

//***********************************************************************
//    Function    :W99200I2CStatus
//    Description :Get the Acknowledge
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200I2CStatus(void)
{   
    DWORD dValue;
    DWORD ulRet; 
    clock_t start, end; 
    
    //W99200WriteReg(Vint_enable,I2C_READY);// enable interrupt I2C ready  
    // Polling I2C Status  
    start=clock(); 
    ulRet=0;
    do
    {  
       //ulRet=W99200ReadReg(I2c_status); // 0-bit=0 false;1 success 
       ulRet=W99200ReadReg(Vint_source); // 0-bit=0 false;1 success 
       if ( (ulRet & 0x0040) == 0x0040 ) 
       {
         W99200WriteReg(Vint_clear,I2C_READY);//4/21..................
         /*
         if ( W99200ReadReg(I2c_status)== 0x01 )
           return TRUE;
         else */
           return TRUE;   
       }   
       end=clock();    
    }while( (end-start) < 500);   
    dValue=0x00FF; // I2c_stop = any data
    //W99200WriteReg(I2c_stop, dValue);// I2C Stop
    return FALSE;
}

//***********************************************************************
//    Function    :W99200CKFIFO_THR
//    Description :Polling the  FIFO passes the threshold level
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200FIFO_Thr(void)
{
   DWORD ulRet;
     
    ulRet=0x00; 
    
    ulRet=W99200ReadReg(0x0f); // otis 4/20 adding 
    //if( ulRet & 0x3c )
    //if ( (ulRet & 0x0020) == 0x0020 ) 
    //   printf( " \n int_source ->%lx",ulRet);
    if ( (ulRet & 0x0002) == 0x0002 )
    {
         //W99200WriteReg(Vint_clear,0x02);
         return TRUE;
    }
    
    return FALSE;
}

//***********************************************************************
//    Function    :W99200I2CFIFO
//    Description :Polling the  FIFO End of data
//    Parameters  :None
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200FIFO_End(void)
{
    DWORD ulRet;
    clock_t start, end;

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

//***********************************************************************
//    Function    :W99200SDRAM_Write
//    Description :Get the Acknowledge
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200SDRAM_Write(DWORD Mem)
{     
    DWORD dMem_Select;
    DWORD i;
    
    dMem_Select=Mem; 
    // Soft reset
    W99200ReSet();
    // Configuration 
    W99200WriteReg(Vwork_mode, 0x0006);
    W99200WriteReg(Vmem_select,dMem_Select);
    // Start Command  
    W99200WriteReg(Vstart, 0x00FF);
    // Forward Data transfer
    for ( i=0 ; i < 2048 ; i++)
      W99200WriteReg(Vdata_in,_dSDRAM_Data[i]); 
    // Stop Command
    W99200WriteReg(Vstop, 0x00FF);
    return TRUE;
}

//***********************************************************************
//    Function    :W99200SDRA_Read
//    Description :Read One Blok Data
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200SDRAM_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
    W99200WriteReg(Vthreshold, 0x0002);// 8 double-word(32 bytes) 
    W99200WriteReg(Vwork_mode, 0x0007);
    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 )
      {
        _dSDRAM_Data[i]=W99200Inpdw(_IOBase+_ulODPR);
        _dSDRAM_Data[i+1]=W99200Inpdw(_IOBase+_ulODPR);
        _dSDRAM_Data[i+2]=W99200Inpdw(_IOBase+_ulODPR);
        _dSDRAM_Data[i+3]=W99200Inpdw(_IOBase+_ulODPR);
        _dSDRAM_Data[i+4]=W99200Inpdw(_IOBase+_ulODPR);
        _dSDRAM_Data[i+5]=W99200Inpdw(_IOBase+_ulODPR);
        _dSDRAM_Data[i+6]=W99200Inpdw(_IOBase+_ulODPR);
        _dSDRAM_Data[i+7]=W99200Inpdw(_IOBase+_ulODPR);
        i=i+8;
        if ( (i%50)==0 )
          printf( "." );
      }
    } while ( W99200FIFO_End()!=TRUE  );
    printf( "\n" );
    return TRUE;
} 
// 3/17 adding    
//***********************************************************************
//    Function    :W99200SDRA_MARead
//    Description :Read One Blok Data use Master Mode
//    Parameters  :None  
//    Return      :TRUE or FALSE
//***********************************************************************
BOOL W99200SDRAM_MARead(DWORD Mem)
{     
    DWORD dMem_Select;
    DWORD i;
    DWORD daddress; 
    BYTE  *bOffset;
    DWORD *pd;
    DWORD seg_val=0,off_val=0;
    void  *pp = _dSDRAM_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 ++ )    // Find the 4 address
    {
        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)