usbjtag.cpp

usb-jtag转换,sparc芯片反汇编,sparc芯片调试的工具,可以对芯片内的gpio,sdram,flash进行读写,还可以一次下载64K大小的数据,反汇编,在线调试.

		return 0xffffffff;
		
	return nReturn;        
}

/****************************************/
// function: get vendor id
// input: 
//			unsigned int x
// output:
//			unsigned int type
/****************************************/
unsigned int Cusbjtag::amba_vendor(unsigned int x)
{
	return (((x) >> 24) & 0xff);
}

/****************************************/
// function: get device id
// input: 
//			int addr x
// output:
//			unsigned int type
/****************************************/
unsigned int Cusbjtag::amba_device(unsigned int x)
{
	return (((x) >> 12) & 0xfff);
}

/****************************************/
// function: collect AHB slave device
// input: 
//			int DeviceId[]
//			int VenderId[]
// output:
//			none
/****************************************/
void Cusbjtag::ReadAhbDevice(int DeviceId[],int VenderId[])
{	   		
	unsigned int m=0;
	unsigned int pAHB, AHB;
	unsigned int vendID, deviceID;
	volatile unsigned int ahb_addr = (unsigned int )(LEON3_IO_AREA | LEON3_CONF_AREA |LEON3_AHB_SLAVE_CONF_AREA );
	for (unsigned int i = 0; i < LEON3_AHB_SLAVES ; i++ )
	{
		pAHB = (ahb_addr + (i * LEON3_AHB_CONF_WORDS *4));
		AHB = UsbJtagRead(pAHB);
		vendID = amba_vendor(AHB);
		deviceID = amba_device(AHB);
		if (vendID != 0 && deviceID !=0 )
		{
			
			DeviceId[m]=vendID;
			VenderId[m]=deviceID;
			m++;
		}	
	}		
}

/****************************************/
// function: collect AHB master device
// input: 
//			int DeviceId[]
//			int VenderId[]
// output:
//			none
/****************************************/
void Cusbjtag::ReadAhbmasterDevice(int DeviceId[],int VenderId[])
{	   		
	unsigned int m=0;
	unsigned int pAHB, AHB;
	unsigned int vendID, deviceID;
	volatile unsigned int ahb_addr = (unsigned int )(LEON3_IO_AREA | LEON3_CONF_AREA );
	for (unsigned int i = 0; i < 8 ; i++ )
	{
		pAHB = (ahb_addr + (i * LEON3_AHB_CONF_WORDS *4));
		AHB = UsbJtagRead(pAHB);
		vendID = amba_vendor(AHB);
		deviceID = amba_device(AHB);
		if (vendID != 0 && deviceID !=0 )
		{
			
			DeviceId[m]=vendID;
			VenderId[m]=deviceID;
			m++;
		}	
	}		
}

/****************************************/
// function: collect APB slave device
// input: 
//			int DeviceId[]
//			int VendorId[]
// output:
//			none
/****************************************/
void Cusbjtag::ReadApbDevice(int DeviceId[],int VenderId[])
{
	unsigned int pAPB, APB;
	unsigned int vendID, deviceID;
	unsigned int m=0;
	for (int i = 0; i < (int)LEON3_APB_SLAVES; i++) 
	{
		pAPB = (base + (i * LEON3_APB_CONF_WORDS * 4));
		APB = UsbJtagRead(pAPB);
		vendID = amba_vendor(APB);
		deviceID = amba_device(APB);
		if (vendID != 0 && deviceID !=0 )
		{
			DeviceId[m]=vendID;
			VenderId[m]=deviceID;
			m++;
			    
		}
	}
}
/****************************************/
// function: write data to addr in flash
// input: 
//			int addr
//			int data
// output:
//			BOOL type
/****************************************/
BOOL Cusbjtag::FlashWrite(int addr, int data)
{

	// enable stream
	if (AMTXHAL_CMDQ_Clr(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;
	if (AMTXHAL_CMDQ_SetAutoExeWhenFullEn(iceHandle, AMTXHAL_CMDQ_AUTOEXEWHENFULL_TRUE) != AMTXHAL_STATUS_SUCCESS)
		return false;

	// add write command to CMDQ
	if (!add_write_flash(addr,data))
		return false;

	// finalize stream
	if (AMTXHAL_CMDQ_Exe(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;
	if (AMTXHAL_CMDQ_Clr(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;

	// disable stream
	if (AMTXHAL_CMDQ_SetAutoExeWhenFullEn(iceHandle, AMTXHAL_CMDQ_AUTOEXEWHENFULL_FALSE) != AMTXHAL_STATUS_SUCCESS)
		return false;
		
	return TRUE;
}

/****************************************/
// function: read data from addr in flash
// input: 
//			int addr
// output:
//			unsigned int type
/****************************************/
unsigned int  Cusbjtag::FlashRead(int addr)
{
	char scob[4]; // SCan Output Byte buffer
	long numBytesReturned = 0;
	unsigned int nReturn=1;
	unsigned char tmp[4] = {0x00};

	// enable stream
	if (AMTXHAL_CMDQ_Clr(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return 0xffffffff;
	if (AMTXHAL_CMDQ_SetAutoExeWhenFullEn(iceHandle, AMTXHAL_CMDQ_AUTOEXEWHENFULL_TRUE) != AMTXHAL_STATUS_SUCCESS)
		return 0xffffffff;

	// intitialize the Scan Output buffer (SCOB)
	if (AMTXHAL_SCOB_Initialize(iceHandle, scob, 4 ) != AMTXHAL_STATUS_SUCCESS)
		return 0xffffffff;

	// add write command to CMDQ
	if (!add_read_flash(addr))
		return 0xffffffff;

	// finalize stream
	if (AMTXHAL_CMDQ_Exe(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return 0xffffffff;
	if (AMTXHAL_CMDQ_Clr(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return 0xffffffff;

	// finalize the Scan Output buffer (SCOB)
	if (AMTXHAL_SCOB_Finalize(iceHandle, &numBytesReturned) != AMTXHAL_STATUS_SUCCESS)
		return 0xffffffff;

	// SCOB data to nReturn buffer
	if (numBytesReturned != 4)
	{
	 // print an error
		return 0xffffffff;
	}
	else
	{
		tmp[0] = (unsigned char)scob[0];
		tmp[1] = (unsigned char)scob[1];
  		tmp[2] = (unsigned char)scob[2];
  		tmp[3] = (unsigned char)scob[3];
		if(addr%4==0)
		{
			nReturn  = ((unsigned int )tmp[3]) << 8;
			nReturn += ((unsigned int )tmp[2]) ;
		}
		else
		{
			nReturn = ((unsigned int )tmp[1]) << 8;
			nReturn += ((unsigned int )tmp[0]) ;
		}
	}

	// disable stream
	if (AMTXHAL_CMDQ_SetAutoExeWhenFullEn(iceHandle, AMTXHAL_CMDQ_AUTOEXEWHENFULL_FALSE) != AMTXHAL_STATUS_SUCCESS)
		return 0xffffffff;
		
	return nReturn;  
}

/****************************************/
// function: set jtag clock
// input: 
//			long hertz
// output:
//			none
/****************************************/
long Cusbjtag::SetJtagFrequency(long hertz)
{
	long status;
	status = AMTXHAL_CMDQ_Add_jtag_frequency(iceHandle, AMTXHAL_PORT_ID_DEFAULT, hertz);
	status = AMTXHAL_CMDQ_Exe(iceHandle);
	status = AMTXHAL_CMDQ_Clr(iceHandle);
	return status;
}

/****************************************/
// function: get jtag clock
// input: 
//			long hertz
// output:
//			none
/****************************************/
long Cusbjtag::GetjtagFrequency(long *pl_frequencyIsSafe,           // O - return AMTXHAL_JTAG_FREQUENCY_IS_SAFE_
							long *pl_frequencyIsInCMDQ,     // O - return AMTXHAL_JTAG_FREQUENCY_IS_IN_QUEUE_ 
							long *pl_frequencyInCMDQ,    // O - return JTAG frequency in the CMDQ if isInCMDQ
							long *pl_frequencyInICE)
{
	long status;
	status = AMTXHAL_JTAG_GetFrequency(iceHandle, AMTXHAL_PORT_ID_DEFAULT, 
										pl_frequencyIsSafe, pl_frequencyInCMDQ,\
										pl_frequencyInCMDQ, pl_frequencyInICE);
	return status;
}
/****************************************/
// function: execute SVF file
// input: 
//			int addr
// output:
//			unsigned int type
/****************************************/
long Cusbjtag::execute_svf(long portID, char *svfFile)
{
	long status = AMTXHAL_STATUS_SUCCESS;
	long tdoErrorFlag;
	
	// clear tdo error code
	status = AMTXHAL_JTAG_ClrTdoErrorFlag(iceHandle, portID);
	if (status  != AMTXHAL_STATUS_SUCCESS)
		return status;
	// execute whole svf file
	status = AMTXHAL_SVF_ExeFile(iceHandle, portID, svfFile, strlen(svfFile));
	if (status  != AMTXHAL_STATUS_SUCCESS)
		return status;
	// Get tdo Error info
    status = AMTXHAL_JTAG_GetTdoErrorFlag(iceHandle, portID, &tdoErrorFlag);
	if (status  != AMTXHAL_STATUS_SUCCESS)
		return status;

	return status;
}

/****************************************/
// function: get jtag chain info
// input: 
//			int addr
// output:
//			unsigned int type
/****************************************/
long Cusbjtag::GetJtagChainInfo(
								//long l_iceHandle,             // I - handle returned by AMTXHAL_ICE_Open function
								long l_portID,                 // I - for non-expert, use AMTXHAL_PORT_ID_DEFAULT
								long *pl_safeChainStatus,         // O - return AMTXHAL_XPLORE_JTAG_CHAIN_STATUS_ 
								long *pl_safeTrstLevel,    // O - return the level of the TRST see following note
								long *pl_safeFrequency,                   // O - return maximal frequency in Herz
								long *pl_safeTapNum)
{
	long status;
	status = AMTXHAL_JTAGXPLORE_GetSafeChainInfo(iceHandle, l_portID, pl_safeChainStatus, pl_safeTrstLevel, pl_safeFrequency, pl_safeTapNum);  
	return (status);
}

/****************************************/
// function: get TAPID
// input: 
//			int addr
// output:
//			unsigned int type
/****************************************/
long Cusbjtag::GetTapID( 
	//				 long l_iceHandle,             // I - handle returned by AMTXHAL_ICE_Open function
                     long l_portID,                 // I - for non-expert, use AMTXHAL_PORT_ID_DEFAULT
                     long l_tapIndex,     // I - 0 to(tapNum-1). _XPLORE_JTAG_GetChainInfo->safeTapNum
                     long *pl_tapStatus,                        // O - return AMTXHAL_XPLORE_JTAG_TAP_ 
                     long *pl_tapID)
{
	long status;
	status = AMTXHAL_JTAGXPLORE_GetTapID(iceHandle, l_portID, l_tapIndex, pl_tapStatus, pl_tapID);
	return status;
}


// test for amontec
bool Cusbjtag::UsbJtagWriteBlock(int addr, int *data, int size)
{
	int dataSize = 0;
	int startAddr = addr;
	int i = 0;

	// enable stream
	if (AMTXHAL_CMDQ_Clr(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;
	if (AMTXHAL_CMDQ_SetAutoExeWhenFullEn(iceHandle, AMTXHAL_CMDQ_AUTOEXEWHENFULL_TRUE) != AMTXHAL_STATUS_SUCCESS)
		return false;

	// add write in the stream
	for (dataSize = size, i; dataSize > 0; dataSize --, i++)
	{
		
		if (!(add_write_ram(startAddr, data[i]))) // if flag is false, write error
		{
			return false;
		}
		startAddr = startAddr + 4; // pointer to next adddress (32 bit)
	}

	// finalize stream
	if (AMTXHAL_CMDQ_Exe(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;
	if (AMTXHAL_CMDQ_Clr(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;
	// disable stream
	if (AMTXHAL_CMDQ_SetAutoExeWhenFullEn(iceHandle, AMTXHAL_CMDQ_AUTOEXEWHENFULL_FALSE) != AMTXHAL_STATUS_SUCCESS)
		return false;

	return true;

}

bool Cusbjtag::UsbJtagReadBlock(int addr, int *data, int size)
{
	
	return true;
  // AMONTEC team can help you but please complet your code //

}

bool Cusbjtag::UsbJtagFlashWriteBlock(int addr, int *data, int size)
{
	int startAddr = addr;
	int i = 0;
	int totalSize = 0;
	int writedata = 0;
	int readcmd = 0;

	// enable stream
	if (AMTXHAL_CMDQ_Clr(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;
	if (AMTXHAL_CMDQ_SetAutoExeWhenFullEn(iceHandle, AMTXHAL_CMDQ_AUTOEXEWHENFULL_TRUE) != AMTXHAL_STATUS_SUCCESS)
		return false;

	for (totalSize = size, i = 0; totalSize > 0; totalSize --, i++)
	{
		//
		if (startAddr % 4 == 0)
		{
			writedata = data[i];
			readcmd = 0x00100000;
		}
		else
		{
			writedata = data[i] >> 16;
			readcmd = 0x00000010;
		}
		if (!add_write_flash(startAddr,readcmd))
			return false;
	    if (!add_write_flash(startAddr,writedata))
			return false;
		startAddr = startAddr + 2;
	}
	
	// finalize stream
	if (AMTXHAL_CMDQ_Exe(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;
	if (AMTXHAL_CMDQ_Clr(iceHandle) != AMTXHAL_STATUS_SUCCESS)
		return false;
	// disable stream
	if (AMTXHAL_CMDQ_SetAutoExeWhenFullEn(iceHandle, AMTXHAL_CMDQ_AUTOEXEWHENFULL_FALSE) != AMTXHAL_STATUS_SUCCESS)
		return false;

	return true;
}

bool Cusbjtag::UsbJtagFlashReadBlock(int addr, int *data, int size)
{
	return true;
}