jtag.cpp

ARM核的边界扫描(JTAG)的实现,此代码在s3c2400上测试通过

		*readData++ = ReadBit();
	}
	*readData++ = ReadLastBit();		// do last bit
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
}
















//////////////////////////////////////////////////////////////////////////////
// Write                                                                    //
//////////////////////////////////////////////////////////////////////////////
void Write(unsigned int writeData, int dataLength)
{
	NextState(TMS_SELECT);
	NextState(TMS_CAPTURE);
	NextState(TMS_SHIFT);
	int bits = dataLength;
	//printf("Write %d\n", bits);
	while (--bits)		// do all except last bit
	{
		WriteBit(writeData & 1);
		writeData >>= 1;
	}
	WriteLastBit(writeData & 1);			// do last bit
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
}

//////////////////////////////////////////////////////////////////////////////
// Write                                                                    //
//////////////////////////////////////////////////////////////////////////////
void Write(const void *writeData, int dataLength)
{
	NextState(TMS_SELECT);
	NextState(TMS_CAPTURE);
	NextState(TMS_SHIFT);
	int bits = dataLength;
	//printf("Write %d\n", bits);
	const unsigned int *pWriteData = (const unsigned int *)writeData;
	while (bits)
	{
		unsigned int tmpWriteData = *pWriteData++;
		for (int intbits=32; intbits; intbits--)
		{
			if (!bits) break;		// do all bits
			if (--bits)
				WriteBit(tmpWriteData & 1);
			else
				WriteLastBit(tmpWriteData & 1);		// do last bit
			tmpWriteData >>= 1;
		}
	}
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
}

//////////////////////////////////////////////////////////////////////////////
// Write                                                                    //
//////////////////////////////////////////////////////////////////////////////
void Write(const unsigned char *writeData, int dataLength)
{
	NextState(TMS_SELECT);
	NextState(TMS_CAPTURE);
	NextState(TMS_SHIFT);
	int bits = dataLength;
	//printf("Write %d\n", bits);
	while (--bits)		// do all except last bit
	{
		WriteBit(*writeData++);
	}
	WriteLastBit(*writeData++);			// do last bit
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
}










//////////////////////////////////////////////////////////////////////////////
// Transfer                                                                 //
//////////////////////////////////////////////////////////////////////////////
unsigned int Transfer(unsigned int writeData, int dataLength)
{
	NextState(TMS_SELECT);
	NextState(TMS_CAPTURE);
	NextState(TMS_SHIFT);
	int bits = dataLength;
	//printf("Transfer %d\n", bits);
	unsigned int readData = 0;
	for (int bit=0; bit<bits-1; bit++)		// do all except last bit
	{
		readData += TransferBit(writeData & 1) << bit;
	}
	readData += TransferLastBit(writeData & 1) << (bits-1);		// do last bit
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
	return readData;
}

//////////////////////////////////////////////////////////////////////////////
// Transfer                                                                 //
//////////////////////////////////////////////////////////////////////////////
void Transfer(const void *writeData, void *readData, int dataLength)
{
	NextState(TMS_SELECT);
	NextState(TMS_CAPTURE);
	NextState(TMS_SHIFT);
	const unsigned int *pWriteData = (const unsigned int *)writeData;
	unsigned int *pReadData = (unsigned int *)readData;
	int bits = dataLength;
	//printf("Transfer %d\n", bits);
	while (bits)
	{
		unsigned int tmpReadData = 0;
		unsigned int tmpWriteData = *pWriteData++;
		for (int bit=0; bit<32; bit++)
		{
			if (!bits) break;		// do all bits
			if (--bits)
				tmpReadData += TransferBit(tmpWriteData & 1) << bit;
			else
				tmpReadData += TransferLastBit(tmpWriteData & 1) << bit;		// do last bit
			tmpWriteData >>= 1;
		}
		*pReadData++ = tmpReadData;
	}
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
}

//////////////////////////////////////////////////////////////////////////////
// Transfer                                                                 //
//////////////////////////////////////////////////////////////////////////////
void Transfer(void *transferData, int dataLength)
{
	NextState(TMS_SELECT);
	NextState(TMS_CAPTURE);
	NextState(TMS_SHIFT);
	unsigned int *pTransferData = (unsigned int *)transferData;
	int bits = dataLength;
	//printf("Transfer %d\n", bits);
	while (bits)
	{
		unsigned int tmpReadData = 0;
		unsigned int tmpWriteData = *pTransferData;
		for (int bit=0; bit<32; bit++)
		{
			if (!bits) break;		// do all bits
			if (--bits)
				tmpReadData += TransferBit(tmpWriteData & 1) << bit;
			else
				tmpReadData += TransferLastBit(tmpWriteData & 1) << bit;		// do last bit
			tmpWriteData >>= 1;
		}
		*pTransferData++ = tmpReadData;
	}
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
}

//////////////////////////////////////////////////////////////////////////////
// Transfer                                                                 //
//////////////////////////////////////////////////////////////////////////////
void Transfer(const unsigned char *writeData, unsigned char *readData, int dataLength)
{
	NextState(TMS_SELECT);
	NextState(TMS_CAPTURE);
	NextState(TMS_SHIFT);
	int bits = dataLength;
	//printf("Transfer %d\n", bits);
	while (--bits)		// do all except last bit
	{
		*readData++ = TransferBit(*writeData++);
	}
	*readData++ = TransferLastBit(*writeData++);		// do last bit
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
}

//////////////////////////////////////////////////////////////////////////////
// Transfer                                                                 //
//////////////////////////////////////////////////////////////////////////////
void Transfer(unsigned char *data, int dataLength)
{
	NextState(TMS_SELECT);
	NextState(TMS_CAPTURE);
	NextState(TMS_SHIFT);
	int bits = dataLength;
	//printf("Transfer %d\n", bits);
	while (--bits)		// do all except last bit
	{
		*data = TransferBit(*data);
		data++;
	}
	*data = TransferLastBit(*data);		// do last bit
	NextState(TMS_UPDATE);
	NextState(TMS_IDLE);
}







//////////////////////////////////////////////////////////////////////////////
// Close                                                                    //
//////////////////////////////////////////////////////////////////////////////
void Close()
{
	Reset();
	OUTP(0,0,0);	// power down
	//_outp(PORT+2, 0);	// high impedance
}

//////////////////////////////////////////////////////////////////////////////
// InitGiveIO                                                               //
//////////////////////////////////////////////////////////////////////////////
// activate GIVEIO driver for direct port access
int InitGiveIO()
{
	OSVERSIONINFO osvi;
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	GetVersionEx(&osvi);
	if (osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) return 0;
	HANDLE h = CreateFile("\\\\.\\giveio", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (h == INVALID_HANDLE_VALUE) { fprintf(stderr, "Error opening giveio driver!\n"); return -1; }
	CloseHandle(h);
	return 0;
}

//////////////////////////////////////////////////////////////////////////////
// Init                                                                     //
//////////////////////////////////////////////////////////////////////////////
int Init()
{
	// init direct I/O access
	if (InitGiveIO()) return -1;

	// init port
	OUTP(1,1,1);
	_outp(PORT+2, 2);	// output enable


	// test JTAG interface
	/*
	if ((_inp(PORT+1) & (1<<6 | 1<<5)) != (1<<6 | 1<<5)) { fprintf(stderr, "Cannot detect JTAG interface or is unpowered!\n"); return -1; }
	_outp(PORT, 0xFF ^ (1<<5 | 1<<7));
	if (_inp(PORT+1) & (1<<6 | 1<<5)) { fprintf(stderr, "Cannot detect JTAG interface or is unpowered!\n"); return -1; }
	*/

	// reset
	ResetToIdle();

	// default command/chain after reset
	currentCommand = -1;	// IDCODE
	currentDataChain = -1;	// EBS_CHAIN


	return 0;
}


//////////////////////////////////////////////////////////////////////////////
// Restart                                                                  //
//////////////////////////////////////////////////////////////////////////////
void Restart()
{
	Command(RESTART);
}



//////////////////////////////////////////////////////////////////////////////
// ~Namespace                                                               //
//////////////////////////////////////////////////////////////////////////////
}



//////////////////////////////////////////////////////////////////////////////
// Reverse                                                                  //
//////////////////////////////////////////////////////////////////////////////
unsigned int Reverse(unsigned int data)
{
	unsigned int data2 = 0;
	for (int bit=31; bit>=0; bit--)
	{
		if (data>>bit&1) data2 += 1<<(31-bit);
	}
	return data2;
}


//////////////////////////////////////////////////////////////////////////////
// GetMappedValue                                                           //
//////////////////////////////////////////////////////////////////////////////
/*unsigned int GetMappedValue(const unsigned char *ebs, const unsigned short *map, int bits)
{
	unsigned int value = 0;
	for (int bit=0; bit<bits; bit++)
	{
		value += ebs[map[bit]] << bit;
	}
	return value;
}

//////////////////////////////////////////////////////////////////////////////
// SetMappedValue                                                           //
//////////////////////////////////////////////////////////////////////////////
void SetMappedValue(unsigned char *ebs, const unsigned short *map, int bits, unsigned int data)
{
	for (int bit=0; bit<bits; bit++)
	{
		ebs[map[bit]] = data >> bit & 1;
	}
}*/