jtagflash.cpp

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

// JTAGFlash.cpp: implementation of the CJTAGFlash class.
//
//////////////////////////////////////////////////////////////////////

#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"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


CJTAGFlash::CJTAGFlash()
{
	error = ERR_FALSE;
}

int CJTAGFlash::SetAddr(long ad)
{
	UINT32 addr = ad;
	for(int i = 0; i<nAddrWidth; i++)
	{
		pAddrPin[i] -> Oe(1);
		pAddrPin[i] -> Write((int)addr&0x01);
		addr >>= 1;
	}
	return 0;
}

int CJTAGFlash::GetData(BYTE *buf)
{
	int i,j;
	BYTE *pdt;
	BYTE data;
	pdt = buf;
	for(i = 0; i < nDataWidth; i++)	
	{
		for(j=0, data=0 ; j<8; j++)
		{
			data >>= 1;
			if(pDataPin[ i*8 + j ] -> Read())
			{
				data |= 0x80;
			}
		}
		*pdt = data;
		pdt++;
	}
	return ERR_FALSE;
}

int CJTAGFlash::SetData(BYTE * buf)
{
	int i,j;
	BYTE *pdt;
	BYTE data;
	pdt = buf;
	for(i = 0; i < nDataWidth; i++)	
	{
		data = *pdt;
		for(j=0; j<8; j++)
		{
			pDataPin[ i*8 + j ] -> Write((int)(data&0x01));
			data >>= 1;
		}
		pdt++;
	}
	return ERR_FALSE;
}

int CJTAGFlash::Standby(void)
{
	pWRPin -> Oe(1);
	pWRPin -> Write(1);
	pRDPin -> Oe(1);
	pRDPin -> Write(1);
	pCSPin -> Oe(1);
	pCSPin -> Write(1);
	return 0;
}

int CJTAGFlash::ToRead(long addr)
{
	SetAddr(addr);
	for(int i = 0; i < nDataWidth * 8; i++)	pDataPin[i] -> Oe(0);
	pRDPin -> Oe(1);
	pRDPin -> Write(0);
	pCSPin -> Oe(1);
	pCSPin -> Write(0);
	return 0;
}

int CJTAGFlash::ToWrite(long addr)
{
	for(int i = 0; i < nDataWidth * 8; i++)	pDataPin[i] -> Oe(1);
	// falling edge is used to latch address, so it shoul be high initial
	pWRPin -> Oe(1);    
	pWRPin -> Write(1);
	pCSPin -> Oe(1);
	pCSPin -> Write(0);
	
	return 0;
}


int CJTAGFlash::Dump()
{
	printf("Flash data width: %d Byte(s)\n", nDataWidth);
	printf("Flash address width: %d \n", nAddrWidth);
	if(flag_verbose)
	{
		printf("Address pins map:\n");
		for(int i=0; i<nAddrWidth; i++)
		{
			printf("ADDRESS%-2d  BSDL pin name:%-s\n", i, pAddrPin[i] -> strName);
		}
		printf("Data pins map:\n");
		for(i=0; i< nDataWidth * 8; i++)
		{
			printf("DATA%-2d  BSDL pin name:%-s\n", i, pDataPin[i] -> strName);
		}
	}
	return 0;
}

int CJTAGFlash::Setup(CFCDFile *fcd, CJTAGChain *chain)
{
	int i;
	AddLog("\n[Setup Flash Pin Map]\n");	

	nAddrWidth = fcd -> nAddrWidth;
	nDataWidth = fcd -> nDataWidth;

	// Setup Address Map
	
	for(i=0; i<nAddrWidth; i++)
	{
		pAddrPin[i] = chain -> Device.GetPin(fcd -> AddrPin[i]);
		if(pAddrPin[i] == NULL)
		{
			AddLog("Miss Pin of Flash Address !\n");
			return ERR_TRUE;
		}
		if(pAddrPin[i] -> nAssigned) 
		{
			AddLog("Address Pin Re-assigned !\n");
			return ERR_TRUE;
		}
		else
			pAddrPin[i] -> nAssigned++;
		if(pAddrPin[i] -> nType != PIN_OUT && pAddrPin[i] -> nType != PIN_INOUT)
		{
			AddLog("Address Pin Type ERROR !\n");
			return ERR_TRUE;
		}
	}
	
	// Setup Data Map
	
	for(i=0; i< (nDataWidth * 8); i++)
	{
		pDataPin[i] = chain -> Device.GetPin( fcd -> DataPin[i] );
		if(pDataPin[i] == NULL)
		{
			AddLog("Miss Pin of Flash Data !\n");
			return ERR_TRUE;
		}
		if(pDataPin[i] -> nAssigned) 
		{
			AddLog("Data Pin Re-assigned !\n");
			return ERR_TRUE;
		}
		else
			pDataPin[i] -> nAssigned++;
		if(pDataPin[i] -> nType != PIN_INOUT)
		{
			AddLog("Data Pin Type ERROR !\n");
			return ERR_TRUE;
		}
	}
	
	// Setup RD Map
	
	pRDPin = chain -> Device.GetPin(fcd -> RDPin);
	if(pRDPin == NULL)
	{
		AddLog("NO Pin of Flash RD !\n");
		return ERR_TRUE;
	}
	if(pRDPin -> nAssigned)
	{
		AddLog("RD Pin Re-assigned !\n");
		return ERR_TRUE;
	}
	else
		pRDPin -> nAssigned++; 
	if(pRDPin -> nType != PIN_OUT && pRDPin -> nType != PIN_INOUT)
	{
		AddLog("RD Pin Type ERROR !\n");
		return ERR_TRUE;
	}
	
	// Setup WR Map
	
	pWRPin = chain -> Device.GetPin( fcd -> WRPin);
	if(pWRPin == NULL)
	{
		AddLog("NO Pin of Flash WR !\n");
		return ERR_TRUE;
	}
	if(pWRPin -> nAssigned)
	{
		AddLog("WR Pin Re-assigned !\n");
		return ERR_TRUE;
	}
	else
		pWRPin -> nAssigned++; 
	if(pWRPin -> nType != PIN_OUT && pWRPin -> nType != PIN_INOUT)
	{
		AddLog("WR Pin Type ERROR !\n");
		return ERR_TRUE;
	}
	
	// Setup CS Map

	pCSPin = chain -> Device.GetPin( fcd -> CSPin);
	if(pCSPin == NULL)
	{
		AddLog("NO Flash CS Map Pin !\n");
		return ERR_TRUE;
	}
	if(pCSPin -> nAssigned)
	{
		AddLog("CS Pin Re-assigned !\n");
		return ERR_TRUE;
	}
	else
		pCSPin -> nAssigned++; 
	if(pCSPin -> nType != PIN_OUT && pCSPin -> nType != PIN_INOUT)
	{
		AddLog("CS Pin Type ERROR !\n");
		return ERR_TRUE;
	}

	return ERR_FALSE;

}


int CJTAGFlash::GetDataPinNum(const char* strDataPin)
{
	int i,j;
	const char *pt;
	j=strlen(strDataPin);
	pt=strDataPin+j-1;
	for(i=0;i<(j-1);i++)
	  if(isdigit(*pt)) pt--;
	  else	{  pt++; break;}
	return(atoi(pt));	
}


int CJTAGFlash::DataConv(BYTE * pData, long length)
{
	long i;
	int j;
	int pin[MAX_FPIN];
	char DataWordIn[MAX_FPIN/8];
	char DataWordOut[MAX_FPIN/8];
	BYTE * pts;
	BYTE * ptd;
	
	const int mask[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
	
	pts=pData;
	ptd=pData;
	
	for(i=0; i< (nDataWidth * 8); i++)
	   pin[i]=GetDataPinNum(LPCTSTR(pDataPin[i]->strName));

	for(i=0;i<(length/nDataWidth);i++)
	{
		for(j=0;j<nDataWidth;j++)
		{
			DataWordIn[j]=*pts++;
			DataWordOut[j]=0;
		}
		for(j=0;j<(nDataWidth*8);j++)
		{
			if(DataWordIn[pin[j]/8]&mask[pin[j]%8])
			  DataWordOut[j/8]|=mask[j%8];			
		}	
		for(j=0;j<nDataWidth;j++) *ptd++=DataWordOut[j];
	}
	return(0);	  
}

int CJTAGFlash::DatanConv(BYTE * pData, long length)
{
	long i;
	int j;
	int pin[MAX_FPIN];
	char DataWordIn[MAX_FPIN/8];
	char DataWordOut[MAX_FPIN/8];
	BYTE * pts;
	BYTE * ptd;
	
	const int mask[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
	
	pts=pData;
	ptd=pData;
	
	for(i=0; i< (nDataWidth * 8); i++)
	   pin[i]=GetDataPinNum(LPCTSTR(pDataPin[i]->strName));

	for(i=0;i<(length/nDataWidth);i++)
	{
		for(j=0;j<nDataWidth;j++)
		{
			DataWordIn[j]=*pts++;
			DataWordOut[j]=0;
		}
		for(j=0;j<(nDataWidth*8);j++)
		{
			if(DataWordIn[j/8]&mask[j%8])
			  DataWordOut[pin[j]/8]|=mask[pin[j]%8];			
		}	
		for(j=0;j<nDataWidth;j++) *ptd++=DataWordOut[j];
	}
	return(0);	  
}