hermes.bak

用于控制z1510芯片工作的程序代码

#include "hermes.h"
#include "z1510.h"
#include "dos.h"
#define VOID void
#define PVOID void*
#define U32 unsigned int
#define UCHAR unsigned char
#define PUCHAR unsigned char*
#define TRUE 1
#define FALSE 0
#define USHORT unsigned short
#define PUSHORT unsigned short*

#define CDSTRIP
#include "sticonf.h"
#include "i2c.h"

#define MAX_FRAME_RATE_CNT		5
#define MIN_OOS_DIFF			100
#define MAX_NUM_OF_SEQ_OOS		10

#define STATUS_SUCCESS TRUE
#define WATCH_DOG_TIMEOUT 10000000
extern FILE *fp2;

MEM_REGIONE DSPCodeArray[] = 
{
	{0x280,0x2BF},
	{0x10F,0x117},
	{0x139,0x13E},
	{0x140,0x149}
};

USHORT VidCoreBank[] = {0x0000,0x0001,0x0002,0x0003,0x0004,0x000C};

#define		LengthFirst 	23
#define		LengthSecond 	31
unsigned char v1[LengthFirst], v2[LengthSecond];
unsigned char FirstData[LengthFirst] = {0x08,0xc2,0x33,0x00,0xff,0xeb,0xe0,0x88,0x01,
					0x70,0x47,0x40,0x00,0x01,0x54,0x00,0x0c,0xb7,0x00,
					0x00,0x00,0x00,0x00};
                           
unsigned char SecondData[LengthSecond] = {0x02,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
					  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
					  0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x07,0x00,0x00,
					  0x00,0x00};
#define TIME_PORT  0x0ff50 

void HR_Wait(unsigned int ms)
{
	
	unsigned int   OldValue = 0;
	unsigned int   NextValue = 0;
	unsigned flag = 1;
	unsigned state = 0;
	flag = 1;
	state = 1;
	OldValue = inport(TIME_PORT);
	NextValue = OldValue + 312;
	if(NextValue >= 17210)
	{
   		NextValue = NextValue - 17210;
	}
	while(ms)
	{
		while(flag)
		{
		   	OldValue = inport(TIME_PORT);
		   	if(OldValue > NextValue || ((OldValue + 312) < NextValue))
		   	{
		   	        NextValue = OldValue + 312;
		   	        if(NextValue >= 17210)
		   	        {
		   	        	
		   	                NextValue = NextValue - 17210;
		   	                while(state)
		   	        	{
		   	        		OldValue = inport(TIME_PORT);
		   	        		if((OldValue < 312) && (OldValue > 0))
		   	        		state = 0;
		   	        	}
		   	        }
		   	        flag=0;
		   	}
		}
		ms--;
                flag=1;
                state = 1;
	}
}	


USHORT HR_ReadAddress(PUSHORT BaseAddress,USHORT Address)
{
	outportb(0x100,Address);
	return inportb(0x101);
}

void  HR_WriteAddress(unsigned short* BaseAddress,USHORT Address, unsigned char Value)
{
	outportb(0x100,Address);
  outportb(0x101,Value);
}
VOID  _HR_WriteAddress(PUSHORT BaseAddress,USHORT Address, FILE* fp)
{
	unsigned char ch;
	fread(&ch,1,1,fp);
	outportb(0x100,Address);
  outportb(0x101,ch);
}
USHORT HR_ResetDevice(PUSHORT pHermes)
{
	HR_WriteAddress(pHermes,Soft_rest,0x55);	
		
	HR_Wait(10);

	HR_WriteAddress(pHermes,Int_enable,Ready);	

	HR_Wait(10);

	if((HR_ReadAddress(pHermes,Int_source) & Ready) == Ready)
	{
		HR_WriteAddress(pHermes,Int_clear,0xff);
		return 1;
	}
	else
	{
		printf(" ResetDevice Ready Fail !\n");
		return 0;
	}
}

USHORT HR_OnPowerUP(PUSHORT pHermes)
{
	UCHAR Source = (UCHAR)HR_ReadAddress(pHermes,Int_source);

	HR_WriteAddress(pHermes,Int_clear,0xff);

	HR_WriteAddress(pHermes,DSPClock, 0x6E);
	
	Source = (UCHAR)HR_ReadAddress(pHermes,Int_enable);

	return HR_ResetDevice(pHermes);
}

USHORT HR_LoadBank(PUSHORT pHermes,USHORT Bank,UCHAR const * Buffer)
{
	unsigned short status = STATUS_SUCCESS;
	PUCHAR puchar = (PUCHAR)Buffer;
	int	   i;
	
	HR_WriteAddress(pHermes,Int_enable,EendOfData | FIFOReady);

	HR_WriteAddress(pHermes,MemSelect_m_1_L,(USHORT)(0x00FF&Bank));
	HR_WriteAddress(pHermes,MemSelect_m_1_H,(USHORT)((0xFF00&Bank)>>8));
	HR_WriteAddress(pHermes,Command,HR_Start);
			
    HR_Wait(20);
	
	if((HR_ReadAddress(pHermes,Int_source) & FIFOReady) == FIFOReady)
	{
		HR_WriteAddress(pHermes,Int_clear,0xff);
		status = TRUE;
	}
	else
	{
		printf(" LoadBank FIFOReady Fail !\n");
		status = FALSE;
	}
	
	if(status == STATUS_SUCCESS)
	{
		for( i = 0;i < 256;i++)
		{
			HR_WriteAddress(pHermes,Data_in,*puchar);
			puchar++;
		}

	    HR_Wait(20);
		if((HR_ReadAddress(pHermes,Int_source) & EendOfData) == EendOfData)
		{
			HR_WriteAddress(pHermes,Int_clear,0xff);
			status = TRUE;
		}
		else
		{
			printf(" LoadBank EendOfReady Fail !\n");
			status = FALSE;
		}

		if(status != STATUS_SUCCESS)
			return status;
	}
	return status;
}
USHORT _HR_LoadBank(PUSHORT pHermes,USHORT Bank,FILE * Buffer)
{
	USHORT status = STATUS_SUCCESS;
	int	   i;
	
	HR_WriteAddress(pHermes,Int_enable,EendOfData | FIFOReady);

	HR_WriteAddress(pHermes,MemSelect_m_1_L,(USHORT)(0x00FF&Bank));
	HR_WriteAddress(pHermes,MemSelect_m_1_H,(USHORT)((0xFF00&Bank)>>8));
	HR_WriteAddress(pHermes,Command,HR_Start);
    HR_Wait(20);
	
	if((HR_ReadAddress(pHermes,Int_source) & FIFOReady) == FIFOReady)
	{
		HR_WriteAddress(pHermes,Int_clear,0xff);
		status = TRUE;
	}
	else
	{
		printf(" LoadBank FIFOReady Fail !\n");
		status = FALSE;
	}
	
	if(status == STATUS_SUCCESS)
	{
		for( i = 0;i < 256;i++)
		{
			_HR_WriteAddress(pHermes,Data_in,Buffer);
		}

	    HR_Wait(20);
		if((HR_ReadAddress(pHermes,Int_source) & EendOfData) == EendOfData)
		{
			HR_WriteAddress(pHermes,Int_clear,0xff);
			status = TRUE;
		}
		else
		{
			printf(" LoadBank EendOfReady Fail !\n");
			status = FALSE;
		}

		if(status != STATUS_SUCCESS)
			return status;
	}
	return status;
}
USHORT HR_LoadMemory(PUSHORT pHermes,USHORT FirstBank,USHORT LastBank ,UCHAR const * Buffer)
{
	USHORT status = STATUS_SUCCESS;
	USHORT BankNo;
	
	PUCHAR Code = (PUCHAR)Buffer;

	for(BankNo = FirstBank;BankNo <= LastBank;BankNo++)
	{
		status = HR_LoadBank(pHermes,BankNo,Code);
		Code += 256;
		if(status != STATUS_SUCCESS)
		{
			return status;
		}
	}

	return status;
}

USHORT _HR_LoadMemory(PUSHORT pHermes,USHORT FirstBank,USHORT LastBank ,FILE* Buffer)
{
	USHORT status = STATUS_SUCCESS;
	USHORT BankNo;
	int i;unsigned char ch;

	for(BankNo = FirstBank;BankNo <= LastBank;BankNo++)
	{
		status = _HR_LoadBank(pHermes,BankNo,Buffer);
		if(status != STATUS_SUCCESS)
		{
			return status;
		}
	}

	return status;
}

USHORT HR_ReadI2C(PUSHORT pHermes,UCHAR Device_ID,PUCHAR v,UCHAR address,PUCHAR c,UCHAR len)
{
	USHORT status = STATUS_SUCCESS;
	USHORT i;

	HR_WriteAddress(pHermes,Z15_REG_I2C_DEV_ID,Device_ID);
	HR_WriteAddress(pHermes,Z15_REG_I2C_ADDRESS,address);
	HR_WriteAddress(pHermes,Z15_REG_I2C_LENGTH,len);
	HR_WriteAddress(pHermes,Int_enable,DSP);	

	HR_WriteAddress(pHermes,Command,I2C_READ_CMD);
	HR_Wait(200);

	if((HR_ReadAddress(pHermes,Int_source) & DSP) == DSP)
	{
		HR_WriteAddress(pHermes,Int_clear,0xff);
		status = TRUE;
	}
	else
	{
			printf(" ReadI2C Fail !\n");
			status = FALSE;
	}

	if(status == STATUS_SUCCESS)
	{
		for(i=0;i<len;i++)
		{
			HR_Wait(10);
			v[i] = (UCHAR)HR_ReadAddress(pHermes,Z15_REG_I2C_DATA+i);
			if(v[i] != c[i])
				{
					fprintf(fp2,"HR_HR_ReadI2C Missmatch [%x] - Writter: %x Read: %x\n",i, c[i] , v[i]);
				fflush(fp2);close(dup(fileno(fp2)));
			}
		}
	}
	return status;
}

USHORT HR_WriteI2C(PUSHORT pHermes,UCHAR Device_ID,PUCHAR v,UCHAR address,UCHAR len)
{
	USHORT status = STATUS_SUCCESS;
	USHORT i;
		
	HR_WriteAddress(pHermes,Z15_REG_I2C_DEV_ID,Device_ID);
	HR_WriteAddress(pHermes,Z15_REG_I2C_ADDRESS,address);
	HR_WriteAddress(pHermes,Z15_REG_I2C_LENGTH,len);
	
   	for(i=0;i<len;i++)
		HR_WriteAddress(pHermes,(USHORT)(Z15_REG_I2C_DATA+i),v[i]);

	HR_WriteAddress(pHermes,Command,I2C_WRITE_CMD);
	
	HR_Wait(100);

	if((HR_ReadAddress(pHermes,Int_source) & DSP) == DSP)
	{
		HR_WriteAddress(pHermes,Int_clear,0xff);
		status = TRUE;
	}
	else
	{
			printf(" WriteI2C Fail !\n");
			status = FALSE;
	}

	return status;
}

USHORT HR_LoadI2C(PUSHORT pHermes)
{
	USHORT status = STATUS_SUCCESS;
	HR_WriteAddress(pHermes,Sys_config,0x01);
	HR_WriteAddress(pHermes,Int_enable,EendOfData | FIFOReady);
	HR_WriteAddress(pHermes,Work_mode,WorkMode_memory_write);
	HR_WriteAddress(pHermes,Threshold,0x20);
	
	status = HR_LoadMemory(pHermes,0x280,0x2BF,i2c);
	return status;
}

USHORT HR_ConfigI2C(PUSHORT pHermes)
{
	USHORT status = STATUS_SUCCESS;
	UCHAR  address1, address2, ReadDirection=0;

	UCHAR DevWriteID = 0x4A;

	if(((status = HR_LoadI2C(pHermes)) != STATUS_SUCCESS))
		return status;

	address1=0x01;
	address2=0x40;
	HR_WriteAddress(pHermes,Int_enable,DSP);

	HR_WriteAddress(pHermes,Work_mode,0x04);

	HR_WriteAddress(pHermes,Command,HR_Start);
	HR_Wait(20);

	HR_WriteAddress(pHermes,Command,I2C_INIT_CMD);
	if((status = HR_WriteI2C(pHermes, DevWriteID,&FirstData[0], address1, 10)) != STATUS_SUCCESS)
		return status;
	if((status = HR_WriteI2C(pHermes, DevWriteID,&FirstData[10],(address1+10), 10)) != STATUS_SUCCESS)
		return status;
	if((status = HR_WriteI2C(pHermes, DevWriteID,&FirstData[20], address1+20, 4)) != STATUS_SUCCESS)
		return status;
		
	if((status = HR_ReadI2C(pHermes, DevWriteID,&v1[0], address1,&FirstData[0], 10)) != STATUS_SUCCESS)
		return status;

	if((status = HR_ReadI2C(pHermes, DevWriteID,&v1[10], address1+10,&FirstData[10], 10)) != STATUS_SUCCESS)
		return status;

	if((status = HR_ReadI2C(pHermes, DevWriteID,&v1[20], address1+20,&FirstData[20], 3)) != STATUS_SUCCESS)
		return status;

	if((status = HR_WriteI2C(pHermes, DevWriteID,&SecondData[0], address2, 10)) != STATUS_SUCCESS)
		return status;          
	if((status = HR_WriteI2C(pHermes, DevWriteID,&SecondData[10], address2+10, 10)) != STATUS_SUCCESS)
		return status;
	if((status = HR_WriteI2C(pHermes, DevWriteID,&SecondData[20], address2+20, 10)) != STATUS_SUCCESS)
		return status;
	if((status = HR_WriteI2C(pHermes, DevWriteID,&SecondData[30], address2+30, 1)) != STATUS_SUCCESS)
		return status;

	if((status = HR_ReadI2C(pHermes, DevWriteID,&v2[0], address2,&SecondData[0], 10)) != STATUS_SUCCESS)
		return status;
	if((status = HR_ReadI2C(pHermes, DevWriteID,&v2[10], address2+10,&SecondData[10], 10)) != STATUS_SUCCESS)
		return status;
	if((status = HR_ReadI2C(pHermes, DevWriteID,&v2[20], address2+20,&SecondData[20], 10)) != STATUS_SUCCESS)
		return status;
	if((status = HR_ReadI2C(pHermes, DevWriteID,&v2[30], address2+30,&SecondData[30], 1)) != STATUS_SUCCESS)
		return status;
	
	return status;
}

USHORT HR_LoadVideoCore(PUSHORT pHermes)
{
	USHORT status;
	PUCHAR Code = (PUCHAR)sti;
	ULONG  i;	

	HR_WriteAddress(pHermes,Sys_config,Sys_config_VCDAV_indirect_mode);
	HR_WriteAddress(pHermes,Int_enable,EendOfData | FIFOReady);
	HR_WriteAddress(pHermes,Work_mode,WorkMode_memory_write);
	HR_WriteAddress(pHermes,Threshold,0x20);
	for(i = 0 ; i < 6 ; i++)
	{
		status = HR_LoadBank(pHermes,VidCoreBank[i],Code);
		Code += 256;
		if(status  != STATUS_SUCCESS)
			return status;
	}

	return status;
}

USHORT HR_LoadProgram(PUSHORT pHermes)
{
	FILE *fp1,*fp2,*fp3,*fp4;
	USHORT status = STATUS_SUCCESS;
    MEM_REGIONE *memreg = DSPCodeArray;
	ULONG mr;	
	fp1=fopen("dsp4","rb");
	fp2=fopen("dsp1","rb");
	fp3=fopen("dsp2","rb");
	fp4=fopen("dsp3","rb");
	DSPCodeArray[0].Code=fp1;
	DSPCodeArray[1].Code=fp2;
	DSPCodeArray[2].Code=fp3;
	DSPCodeArray[3].Code=fp4;
	HR_WriteAddress(pHermes,Sys_config,Sys_config_VCDAV_indirect_mode);
	HR_WriteAddress(pHermes,Work_mode,WorkMode_memory_write);
	HR_WriteAddress(pHermes,Threshold,0x20);

	for(mr = 0; mr < 4; mr++)
	{
		status = _HR_LoadMemory(pHermes,
						memreg[mr].FirstBank,
						memreg[mr].LastBank,memreg[mr].Code);
		
		if(status  != STATUS_SUCCESS)
			return status;
	}

	status = HR_LoadVideoCore(pHermes);
	fclose(fp1);fclose(fp2);fclose(fp3);fclose(fp4);
	return status;
}




USHORT HR_InitDevice(PUSHORT pHermes,Mode mode)
{
	USHORT status = TRUE;
	
	if(mode == ModeAV)
	{
		if((status = HR_ResetDevice(pHermes)) != STATUS_SUCCESS)
				return FALSE;

		if((status = HR_ConfigI2C(pHermes)) != STATUS_SUCCESS)
				return FALSE;
		
		if((status = HR_ResetDevice(pHermes)) != STATUS_SUCCESS)
				return FALSE;

		status = HR_LoadProgram(pHermes);
	}
	else
	{
		if((status = HR_ResetDevice(pHermes)) != STATUS_SUCCESS)
				return FALSE;

		if((status = HR_LoadProgram(pHermes)) != STATUS_SUCCESS)
				return FALSE;
		
		if((status = HR_ConfigI2C(pHermes)) != STATUS_SUCCESS)
				return FALSE;
	}
	
	return status;
}

VOID  HR_InitVCDVA(PUSHORT pHermes)
{
	USHORT VCDAV_Sbit_rate_m;
  USHORT VCDAV_Sbit_rate_l;
  double srate;
  srate = (double)(((VCDAV_Vbit_rate_l+VCDAV_Vbit_rate_m<<8)/50+28)*51);
  VCDAV_Sbit_rate_m = ((USHORT)(srate/256)) & 0xff;
  VCDAV_Sbit_rate_l = (USHORT)(srate) & 0xff;
  
	HR_WriteAddress(pHermes,DSPClock, 0x6E);
	HR_WriteAddress(pHermes,0x0c, 0x03);
	HR_WriteAddress(pHermes,0x10, 0x20);

	HR_WriteAddress(pHermes,Work_mode,0x04);HR_Wait(2);
	HR_WriteAddress(pHermes,Video_format,0x09);HR_Wait(2);
	HR_WriteAddress(pHermes,Venc_cntl,VCDAV_Venc_cntl);HR_Wait(2);
	HR_WriteAddress(pHermes,Vframe_pattern,VCDAV_Vframe_pattern);HR_Wait(2);
	HR_WriteAddress(pHermes,Vbit_rate_l,VCDAV_Vbit_rate_l);HR_Wait(2);
	HR_WriteAddress(pHermes,Vbit_rate_m,VCDAV_Vbit_rate_m);HR_Wait(2);
	HR_WriteAddress(pHermes,Vbv_size,VCDAV_Vbv_size);HR_Wait(2);
	HR_WriteAddress(pHermes,VCDAV_Vbv_initial,VCDAV_Vbv_initial);HR_Wait(2);
	HR_WriteAddress(pHermes,Vslice_header, VCDAV_Vslice_header);HR_Wait(2);
	HR_WriteAddress(pHermes,Vin_cntl, VCDAV_Vin_cntl);HR_Wait(2);		

	HR_WriteAddress(pHermes,Vin_offset, 0xFA);HR_Wait(2);
	HR_WriteAddress(pHermes,0x28, 0x0b);HR_Wait(2);			//set Arate
	
	HR_WriteAddress(pHermes,Srate_l, VCDAV_Sbit_rate_l);HR_Wait(2);
	HR_WriteAddress(pHermes,Srate_m, VCDAV_Sbit_rate_m);HR_Wait(2);

	HR_WriteAddress(pHermes,I2sin_confa, VCDAV_I2sin_confa);HR_Wait(2);
	HR_WriteAddress(pHermes,I2sin_confb,VCDAV_I2sin_confb);HR_Wait(2);
	HR_WriteAddress(pHermes,CD_Formatting,VCDAV_CD_Formatting);HR_Wait(2);
	HR_WriteAddress(pHermes,Sys_config,0x01);HR_Wait(2);
	HR_WriteAddress(pHermes,Active_ports,VCDAV_Active_ports);HR_Wait(2);
	HR_WriteAddress(pHermes,Initial_second,VCDAV_Initial_second);HR_Wait(2);
	HR_WriteAddress(pHermes,Threshold, VCDAV_Threshold);HR_Wait(2);
	HR_WriteAddress(pHermes,0x19,0x07);HR_Wait(2);		//set vquality 0x01->highest, 0x1f->lowerst
	HR_WriteAddress(pHermes,Venc_cntl,VCDAV_Venc_cntl);
	printf("sratel=%x,srate_m=%x\n",VCDAV_Sbit_rate_l,VCDAV_Sbit_rate_m);

}

VOID HR_StopCapture(PUSHORT pHermes)
{
	{
		HR_WriteAddress(pHermes,Command,HR_Stop);
	}
}

USHORT HR_StartDevice(PUSHORT pHermes)
{
	USHORT status;
			
	HR_WriteAddress(pHermes,Int_clear,0xff);
	
	HR_WriteAddress(pHermes,Int_enable,0xFF);
	HR_WriteAddress(pHermes,Command,HR_Start);
		
	return status;
}
USHORT HR_StartCapture(PUSHORT pHermes)
{
	{
		return HR_StartDevice(pHermes);
	}
}