program.cpp

里面有通过JTAG口对FLASH的烧写代码

#include	"StdAfx.h"
#include	"FluteD.h"

#include	"Pin.h"
#include	"Group.h"
#include	"JTAGDev.h"
#include	"JTAGPort.h"
#include	"FCDFile.h"
#include	"JTAGChain.h"
#include	"JTAGFlash.h"

#include	"Program.h"

int CProgram::Check(void)
{
	int result;
	result = Chain.CheckDev( Port );
	return result;
}


int CProgram::Setup(char *fcd_file)
{
	int result;
	result = FCD.Setup(fcd_file);
	if(result) return result;
	else
	{
		if(flag_verbose) 
		{
			FCD.Dump();
		}
	}

	result = Chain.Setup( &FCD );
	if(result) return result;
	else
	{
		if(flag_verbose)
		{
			Chain.Dump();
		}
	}

	result = Flash.Setup( &FCD, &Chain);
	if(result) return result;
	{
		if(flag_verbose)
		{
			Flash.Dump();
		}
	}

	result = Port.Setup( FCD.nResetCtrl & FCD_RSTINP );
	if(result) return result;
	else
	{
		if(flag_verbose)
		{
			Port.Dump();
		}
	}

	// reset before programming
	Port.SetRstpin( FCD.nResetCtrl & FCD_RSTBP1 );
	Sleep(100); // wait for 50 ms
	Port.SetRstpin( FCD.nResetCtrl & FCD_RSTBP2 );
	Sleep(100); // wait for 50 ms

	return ERR_FALSE;
}

int CProgram::Write(BYTE *buffer, long start_addr, long size)
{
	long nBegin, nEnd, nDataSize;
	long nBeginAddr, nEndAddr;
	BYTE *pData;
	BYTE aux[4];
	int i;

	AddLog("\n[Write]\n");

	nBegin = start_addr;
	nEnd = start_addr + size;
	nDataSize = size;
	pData = buffer;

	if(nBegin > nEnd)
	{
		AddLog("Wrong Address !\n");
		return ERR_TRUE;
	}

	if(nBegin >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("Begin Address TOO Large !\n");
		return ERR_TRUE;
	}

	if(nEnd >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("End Address TOO Large !\n");
		return ERR_TRUE;
	}

	nBeginAddr = nBegin / FCD.nDataWidth;
	nEndAddr = nEnd / FCD.nDataWidth;

	int op_length = Chain.Device.nInstLength;
	int bsr_length = Chain.Device.nBSRLength;
	
	Port.On();
	Port.Reset();

	Chain.SafeChain();

	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanIR(op_length, Chain.Device.nInstExtest);

	Flash.Standby();
//	Pulse();
//	Level();

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	// prepare to write data
	Flash.ToWrite(nBeginAddr);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	
	for(long addr=nBeginAddr; addr <= nEndAddr; addr++)
	{
		// erase command
		for(i=0; i < FCD.WriteCmd.length && i < MAX_FCMD; i++ )
		{
			if(FCD.WriteCmd.addr[i] == 0) Flash.SetAddr(addr);
			else Flash.SetAddr(FCD.WriteCmd.addr[i]);
			
			aux[0] = FCD.WriteCmd.cmd[i] & 0xff;
			aux[1] = ( FCD.WriteCmd.cmd[i] >> 8) & 0xff;
			aux[2] = ( FCD.WriteCmd.cmd[i] >> 16) & 0xff;
			aux[3] = ( FCD.WriteCmd.cmd[i] >> 24) & 0xff;

			Flash.SetData( aux );
			Flash.pWRPin -> Oe(1);
			Flash.pWRPin -> Write(0);
#ifdef _LOG
			fprintf(lp, "Write Command %lx @ %lx \n", FCD.WriteCmd.cmd[i], FCD.WriteCmd.addr[i]);
#endif
			Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
			Flash.pWRPin -> Write(1);
			Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
		}

		// write data
		Flash.SetAddr(addr);

		for(i=0; i< FCD.nDataWidth; i++)
		{
			aux[i] = *pData;
			pData++;
		}

		Flash.SetData( aux );

		Flash.pWRPin -> Oe(1);
		Flash.pWRPin -> Write(0);
		Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);
		Flash.pWRPin -> Oe(1);
		Flash.pWRPin -> Write(1);
		Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);
		
		if(!(addr % 64)) 
				Progress((addr - nBeginAddr)*100/(nEndAddr - nBeginAddr));
	}

	Chain.SafeChain();

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	Port.Off();
	
	AddLog("OK  \n");

	return ERR_FALSE;
}

int CProgram::Read(BYTE *buffer, long start_addr, long size)
{
	long nBegin, nEnd, nDataSize;
	long nBeginAddr, nEndAddr;
	BYTE *pData;
	BYTE aux[4];
	int i;

	AddLog("\n[Read]\n");

	nBegin = start_addr;
	nEnd = start_addr + size;
	nDataSize = size;
	pData = buffer;

	if(nBegin > nEnd)
	{
		AddLog("Wrong Address !\n");
		return ERR_TRUE;
	}

	if(nBegin >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("Begin Address TOO Large !\n");
		return ERR_TRUE;
	}

	if(nEnd >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("End Address TOO Large !\n");
		return ERR_TRUE;
	}

	nBeginAddr = nBegin / FCD.nDataWidth;
	nEndAddr = nEnd / FCD.nDataWidth;

	int op_length = Chain.Device.nInstLength;
	int bsr_length = Chain.Device.nBSRLength;
	
	Port.On();
	Port.Reset();

	Chain.SafeChain();

	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanIR(op_length, Chain.Device.nInstExtest);

	Flash.Standby();
//	Pulse();
//	Level();

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	// prepare to read data
	Flash.ToRead(nBeginAddr);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	
	for(long addr=nBeginAddr + 1; addr < nEndAddr; addr++)
	{
		// read data
		Flash.SetAddr(addr);
		Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

		Flash.GetData( aux );

		for(i=0; i< FCD.nDataWidth; i++)
		{
			*pData = aux[i];
			pData++;
		}

		if(!(addr % 64)) 
			Progress((addr - nBeginAddr)*100/(nEndAddr - nBeginAddr));
	}
	
	Flash.SetAddr(addr);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

	Flash.GetData( aux );

	for(i=0; i< FCD.nDataWidth; i++)
	{
		*pData = aux[i];
		pData++;
	}

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

	Flash.GetData( aux );

	for(i=0; i< nEnd % FCD.nDataWidth; i++)
	{
		*pData = aux[i];
		pData++;
	}

	Chain.SafeChain();

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	Port.Off();
	
	AddLog("OK  \n");

	return ERR_FALSE;
}


void CProgram::Progress(int ptc)
{
	printf("%3d%%%c%c%c%c", ptc, 8, 8, 8, 8);
}

int CProgram::Erase(long start_addr, long size)
{
	long nBegin, nEnd, nDataSize;
	long nBeginAddr, nEndAddr;
	int i;
	BYTE aux[4];

	AddLog("\n[Erase]\n");

	nBegin = start_addr;
	nEnd = start_addr + size;
	nDataSize = size;

	if(nBegin > nEnd)
	{
		AddLog("Wrong Address !\n");
		return ERR_TRUE;
	}

	if(nBegin >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("Begin Address TOO Large !\n");
		return ERR_TRUE;
	}

	if(nEnd >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("End Address TOO Large !\n");
		return ERR_TRUE;
	}

	nBeginAddr = nBegin / FCD.nDataWidth;
	nEndAddr = nEnd / FCD.nDataWidth;
	if( nEnd % FCD.nDataWidth) nEndAddr++;

	int op_length = Chain.Device.nInstLength;
	int bsr_length = Chain.Device.nBSRLength;
		
	Port.On();
	Port.Reset();

	Chain.SafeChain();

#ifdef _LOG
		fprintf(lp, "SafeChain\n");
#endif
	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanIR(op_length, Chain.Device.nInstExtest);

	Flash.Standby();
//	Pulse();
//	Level();

#ifdef _LOG
		fprintf(lp, "Flash Standby\n");
#endif
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	// prepare to read data
	Flash.ToWrite(nBeginAddr);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	//	erase block
	long block_addr = 0;
	long block_size;
	int block_number = 0;
	int block_pt = 0;

	while(block_addr < nEnd)
	{
		if(block_number==0)
		{
			block_number = FCD.Block[block_pt].num;
			block_size = FCD.Block[block_pt].size;
			block_pt ++;
			if(block_number <= 0 || block_pt >= MAX_FBLK)
			{
				AddLog("Erase Block Out of Boundary !");
				return ERR_TRUE;
			}
		}
		if(block_addr >= nBegin)
		{
			// erase command
			for(i=0; i < FCD.EraseCmd.length && i < MAX_FCMD; i++ )
			{
				if(FCD.EraseCmd.addr[i] == 0) Flash.SetAddr(block_addr);
				else Flash.SetAddr(FCD.EraseCmd.addr[i]);
				
				aux[0] = FCD.EraseCmd.cmd[i] & 0xff;
				aux[1] = ( FCD.EraseCmd.cmd[i] >> 8) & 0xff;
				aux[2] = ( FCD.EraseCmd.cmd[i] >> 16) & 0xff;
				aux[3] = ( FCD.EraseCmd.cmd[i] >> 24) & 0xff;

				Flash.SetData( aux );
				Flash.pWRPin -> Oe(1);
				Flash.pWRPin -> Write(0);
#ifdef _LOG
	fprintf(lp, "Erase Command %lx @ %lx \n", FCD.EraseCmd.cmd[i], FCD.EraseCmd.addr[i]);
#endif
				Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
				Flash.pWRPin -> Write(1);
				Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

				sprintf(msg, "Erase Command %lx @ %lx \n", FCD.EraseCmd.cmd[i], FCD.EraseCmd.addr[i]);
				AddLog(msg, 2);
			}
			sprintf(msg, "Erase Block %ld (0x%lX)\n", block_addr, block_addr);
			AddLog(msg, 2);
			Sleep(FCD.nEraseDelay);
		}
		else
		{
			sprintf(msg, "Skip Block %ld (0x%lX)\n", block_addr, block_addr);
			AddLog(msg, 2);
		}
		block_addr += block_size;
		block_number --;
	}

	Port.Off();
	
	AddLog("OK\n");

	return ERR_FALSE;
}

int CProgram::Blank(long start_addr, long size)
{
	long nBegin, nEnd, nDataSize;
	long nBeginAddr, nEndAddr;
	BYTE aux[4];
	int i;

	AddLog("\n[Blank]\n");

	nBegin = start_addr;
	nEnd = start_addr + size;
	nDataSize = size;

	if(nBegin > nEnd)
	{
		AddLog("Wrong Address !\n");
		return ERR_TRUE;
	}

	if(nBegin >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("Begin Address TOO Large !\n");
		return ERR_TRUE;
	}

	if(nEnd >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("End Address TOO Large !\n");
		return ERR_TRUE;
	}

	nBeginAddr = nBegin / FCD.nDataWidth;
	nEndAddr = nEnd / FCD.nDataWidth;

	int op_length = Chain.Device.nInstLength;
	int bsr_length = Chain.Device.nBSRLength;
	
	Port.On();
	Port.Reset();

	Chain.SafeChain();

	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanIR(op_length, Chain.Device.nInstExtest);

	Flash.Standby();
//	Pulse();
//	Level();

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	// prepare to read data
	Flash.ToRead(nBeginAddr);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	
	for(long addr=nBeginAddr + 1; addr < nEndAddr; addr++)
	{
		// read data
		Flash.SetAddr(addr);
		Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

		Flash.GetData( aux );

		for(i=0; i< FCD.nDataWidth; i++)
		{
			if(aux[i] != 0xff) return ERR_TRUE;
		}

		if(!(addr % 64)) 
			Progress((addr - nBeginAddr)*100/(nEndAddr - nBeginAddr));
	}
	
	Flash.SetAddr(addr);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

	Flash.GetData( aux );

	for(i=0; i< FCD.nDataWidth; i++)
	{
		if(aux[i] != 0xff) return ERR_TRUE;
	}

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

	Flash.GetData( aux );

	for(i=0; i< nEnd % FCD.nDataWidth; i++)
	{
		if(aux[i] != 0xff) return ERR_TRUE;
	}

	Chain.SafeChain();

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	Port.Off();
	
	AddLog("OK  \n");

	return ERR_FALSE;

}

int CProgram::Verify(BYTE *buffer, long start_addr, long size)
{
	long nBegin, nEnd, nDataSize;
	long nBeginAddr, nEndAddr;
	BYTE *pData;
	BYTE aux[4];
	int i;

	AddLog("\n[Verify]\n");

	nBegin = start_addr;
	nEnd = start_addr + size;
	nDataSize = size;
	pData = buffer;

	if(nBegin > nEnd)
	{
		AddLog("Wrong Address !\n");
		return ERR_TRUE;
	}

	if(nBegin >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("Begin Address TOO Large !\n");
		return ERR_TRUE;
	}

	if(nEnd >= (1 << FCD.nAddrWidth) * FCD.nDataWidth)
	{
		AddLog("End Address TOO Large !\n");
		return ERR_TRUE;
	}

	nBeginAddr = nBegin / FCD.nDataWidth;
	nEndAddr = nEnd / FCD.nDataWidth;

	int op_length = Chain.Device.nInstLength;
	int bsr_length = Chain.Device.nBSRLength;
	
	Port.On();
	Port.Reset();

	Chain.SafeChain();

	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	Port.ScanIR(op_length, Chain.Device.nInstSample);
	Port.ScanIR(op_length, Chain.Device.nInstExtest);

	Flash.Standby();
//	Pulse();
//	Level();

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	// prepare to read data
	Flash.ToRead(nBeginAddr);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);
	
	for(long addr=nBeginAddr + 1; addr < nEndAddr; addr++)
	{
		// read data
		Flash.SetAddr(addr);
		Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

		Flash.GetData( aux );

		for(i=0; i< FCD.nDataWidth; i++)
		{
			if( *pData != aux[i] )
			{
				sprintf(msg, "Verify missed at %ld (0x%lX) + %d Original:0x%X JTAG:0x%X\n", addr, addr, i, (int)*pData, aux[i]);
				AddLog(msg);
			}
			pData++;
		}

		if(!(addr % 64)) 
			Progress((addr - nBeginAddr)*100/(nEndAddr - nBeginAddr));
	}
	
	Flash.SetAddr(addr++);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

	Flash.GetData( aux );

	for(i=0; i< FCD.nDataWidth; i++)
	{
		if( *pData != aux[i] )
		{
			sprintf(msg, "Verify missed at %ld (0x%lX) + %d Original:0x%X JTAG:0x%X\n", addr, addr, i, (int)*pData, aux[i]);
			AddLog(msg);
		}
		pData++;
	}

	Flash.SetAddr(addr);
	Port.ScanDR(Chain.nChainLength, Chain.nOutChain, Chain.nInChain);

	Flash.GetData( aux );

	for(i=0; i< nEnd % FCD.nDataWidth; i++)
	{
		if( *pData != aux[i] )
		{
			sprintf(msg, "Verify missed at %ld (0x%lX) + %d Original:0x%X JTAG:0x%X\n", addr, addr, i, (int)*pData, aux[i]);
			AddLog(msg);
		}
		pData++;
	}

	Chain.SafeChain();

	Port.ScanDR(Chain.nChainLength, Chain.nOutChain);

	Port.Off();
	
	AddLog("OK  \n");

	return ERR_FALSE;
}

CProgram::~CProgram()
{
	// reset after programming
	Sleep(100); // wait for 50 ms
	Port.SetRstpin( FCD.nResetCtrl & FCD_RSTAP1 );
	Sleep(100); // wait for 50 ms
	Port.SetRstpin( FCD.nResetCtrl & FCD_RSTAP2 );
}