Problem with comparison.
/Modules/CPLD_FPGA/XILINX_XVC/XVC_SOFTWARE/XVC_1x/mlab_xvcd.cpp
0,0 → 1,577
// MLAB Xilinx Virtual Cable Network Server
// ----------------------------------------
//
// (c) miho 2012 http://www.mlab.cz/PermaLink/XVC_SOFTWARE
//
// This program if free.
//
//
// History:
//
// 1.00 2012_09 Proof of concept (no configuration, not for public release)
// 1.01 2012_09 Added parameter for device selection
// 1.02 2012_12 Error handling and debugged
// 1.03 2012_12 Release version ready to publish
//
//
// Purpose:
//
// XILINX development software (ISE, WebPack) supports several types of JTAG programming
// cables. Among them there is one particularly interesting. It is Xilinx Virtual Cable
// which uses (documented) XVC network protocol to send JTAG commands across TCP/IP network.
// So it is possible to realize own hardware/software and have it directly supported by
// XILINX development software (both IMPACT and ChipScope).
//
// This program listens TCP data send by XILINX ISE IMAPACT (or ChipScope) and sends it
// to the JTAG device (typically FPGA) connected to FTDI USB Chip. You can use ordinary
// USB/RS232 translator based on FT232R chip or you can use our own module from
// http://www.mlab.cz/PermaLink/XVC_FT220X
//
// Target device JTAG port is connected to pins on FTDI USB chip. Program writes to standard
// output Which pins are used. Program writes what to set in ISE to enable XVC plugin.
//
//
// Environment:
//
// This is Win32 Console Application and run in WinXP / Win7 / Win8 both 32 and 64 bit.
//
// Program needs to listen to the network so it is necessary to allow doing so. In Windows
// firewall configuration enable networking for the exe file.
// WinXP: run as Administrator c:\WINDOWS\System32\firewall.cpl and add the exe file
// Win7: the system asks directly to do so
//
//
// Technology:
//
// The program uses Windows WINSOCK2 library for network communication
// and FTDI ftd2xx library for communication with FTDI USB chip.
// It can be staticly linked to minimize dependencies on libraries.
// Program requires FTDI drivers installed.
// Because of the usage of standard libraries you don't need to solve how to sign drivers.
//
// The program was debug with FT232R and FT220X device.
// It should work with any similar FTDI USB chip.
//
// XVC protocol is documented (you have to ask XILINX support to gain access).
// The program is inspired by the work http://debugmo.de/2012/02/xvcd-the-xilinx-virtual-cable-daemon/
// Ask Google about Xilinx Virtual Cable.
//
//
// Translation:
//
// MS Visual C++ 2010 Express (free, registration required)
// Create new empty project for Win32 Console Application and name project mlab_xvcd (to build mlab_xvcd.exe)
// Header Files / Add / Existing Items - all .h files
// Resource Files / Add / Existing Items - all .lib files
// Source Files / Add / Existing Items - all .cpp files
// Select Release version (no debug info)
// Set static linkage Project Properties / Configuration Release / Configuration Properties
// / Code Generation / Runtime Library = Multithreaded (/MT)
//
//
// Problems:
//
// Programming of SPI FLASH configuration memory connected to FPGA does not work. No idea why.
// It does not work for internal FLASH of Spartan XC3SxxAN either.
//
//
// Possible improvements:
//
// Linux version (Winsock library differs).
// External definition of JTAG pins.
 
 
// Library Definitions
// -------------------
 
#undef UNICODE
#define WIN32_LEAN_AND_MEAN
 
#include "mlab_xvcd.h" // Program Configuration
#include <windows.h> // Windows Console Application
#include <winsock2.h> // Windows WinSock2
#include <ws2tcpip.h> // Windows WinSock2
#include <stdlib.h> // Standard Library (exit, atoi, ...)
#include <stdio.h> // Standard IO (printf, ...)
#include <signal.h> // CTRL+C handling
 
// Link with library
#pragma comment (lib, "Ws2_32.lib")
 
#define XVC_RX_BUFLEN (XVC_JTAG_LEN/8*2+20) // Length of receive buffer in bytes (command+length+TMSbuffer+TDIbuffer)
#define XVC_TX_BUFLEN (XVC_JTAG_LEN/8) // Length of transmit buffer in bytes (TDObuffer)
 
 
// JTAG state machine
// ------------------
 
// JTAG States
enum
{
test_logic_reset, run_test_idle, // Starts from 0
 
select_dr_scan, capture_dr, shift_dr,
exit1_dr, pause_dr, exit2_dr, update_dr,
 
select_ir_scan, capture_ir, shift_ir,
exit1_ir, pause_ir, exit2_ir, update_ir,
 
num_states
};
 
 
// JTAG State Machine transfer Function
static int jtagStep(int state, int tms)
{
static const int next_state[num_states][2] =
{
/* JTAG State -->> New State */
/* -------------------------------------------------------------*/
/* | TMS=0 | TMS=1 */
/* -------------------------------------------------------------*/
/* [test_logic_reset] -> */ { run_test_idle, test_logic_reset },
/* [run_test_idle] -> */ { run_test_idle, select_dr_scan },
/* [select_dr_scan] -> */ { capture_dr, select_ir_scan },
/* [capture_dr] -> */ { shift_dr, exit1_dr },
/* [shift_dr] -> */ { shift_dr, exit1_dr },
/* [exit1_dr] -> */ { pause_dr, update_dr },
/* [pause_dr] -> */ { pause_dr, exit2_dr },
/* [exit2_dr] -> */ { shift_dr, update_dr },
/* [update_dr] -> */ { run_test_idle, select_dr_scan },
/* [select_ir_scan] -> */ { capture_ir, test_logic_reset },
/* [capture_ir] -> */ { shift_ir, exit1_ir },
/* [shift_ir] -> */ { shift_ir, exit1_ir },
/* [exit1_ir] -> */ { pause_ir, update_ir },
/* [pause_ir] -> */ { pause_ir, exit2_ir },
/* [exit2_ir] -> */ { shift_ir, update_ir },
/* [update_ir] -> */ { run_test_idle, select_dr_scan }
};
 
return next_state[state][tms];
}
 
 
int handleData(SOCKET ClientSocket)
{
 
bool seen_tlr = false;
bool jtagError = false;
 
static int jtag_state;
 
do
{
int iResult;
 
// Read Command
char command[16];
int commandLen = 0;
 
// Read String terminated by ':'
do
{
iResult = recv(ClientSocket, command+commandLen, 1, 0);
if (iResult==0)
{
printf("\n Connection Closed\n\n");
return -1;
}
else if (iResult==1)
{
commandLen++;
}
else
{
fprintf(stderr, "Error Reading Command\n");
return -2;
}
}
while (command[commandLen-1]!=':' && commandLen<sizeof(command)-1 );
command[commandLen] = char(0);
 
if (0==strncmp(command, "shift:", sizeof(command)))
{
}
else
{
fprintf(stderr, "Invalid Command '%s'\n", command);
return -2;
}
 
// Read Length (in bits, 32bit integer)
int len;
 
iResult = recv(ClientSocket, (char *)&len, 4, 0); // pøepsat pøenositelnì
if (iResult==0)
{
printf("\n Connection Closed\n\n");
return -1;
}
if (iResult != 4)
{
fprintf(stderr, "Reading Length Failed\n");
return -2;
}
 
char buffer[2048];
 
// Read Data (data string for TMS and TDI)
int nr_bytes = (len + 7) / 8;
if (nr_bytes * 2 > sizeof(buffer))
{
fprintf(stderr, "Buffer Size Exceeded\n");
return -2;
}
 
int iReceivedBytes=0;
while (iReceivedBytes<nr_bytes * 2)
{
iResult = recv(ClientSocket, buffer+iReceivedBytes, nr_bytes * 2 - iReceivedBytes, 0);
if (iResult==0)
{
printf("\n Connection Closed\n\n");
return -1;
}
if (iResult<=0)
{
fprintf(stderr, "Reading Data Failed %d %d\n", iResult, nr_bytes * 2);
return -2;
}
iReceivedBytes += iResult;
}
 
char result[1024];
memset(result, 0, nr_bytes);
 
// Deal with JTAG
 
// Only allow exiting if the state is rti and the IR
// has the default value (IDCODE) by going through test_logic_reset.
// As soon as going through capture_dr or capture_ir no exit is
// allowed as this will change DR/IR.
seen_tlr = (seen_tlr || jtag_state == test_logic_reset) && (jtag_state != capture_dr) && (jtag_state != capture_ir);
// Due to a weird bug(??) xilinx impacts goes through another "capture_ir"/"capture_dr" cycle after
// reading IR/DR which unfortunately sets IR to the read-out IR value.
// Just ignore these transactions.
if ((jtag_state == exit1_ir && len == 5 && buffer[0] == 0x17) || (jtag_state == exit1_dr && len == 4 && buffer[0] == 0x0b))
{
// printf("Ignoring Bogus jtag State movement at jtag_state %d\n", jtag_state);
}
else
{
for (int i = 0; i < len; ++i)
{
//
// Do the actual cycle.
//
int tms = !!(buffer[i/8] & (1<<(i&7)));
//
// Track the state.
//
jtag_state = jtagStep(jtag_state, tms);
}
if (jtagScan((unsigned char *) buffer, (unsigned char *) buffer + nr_bytes, (unsigned char *) result, len) < 0)
{
//fprintf(stderr, "jtagScan failed\n");
// Can't stop now, have to sent (any) answer not to hung the IMPACT
jtagError = true;
}
}
 
// Send the Ansver
iResult = send(ClientSocket, result, nr_bytes, 0 );
if (iResult == SOCKET_ERROR)
{
printf("Send Failed with Error: %d\n", WSAGetLastError());
closesocket(ClientSocket);
WSACleanup();
return -2;
}
// printf("Bytes Sent: %d\n", iSendResult);
// printf("jtag state %d\n", jtag_state);
}
while (!(seen_tlr && jtag_state == run_test_idle));
 
return jtagError ? -2 : 0;
}
 
 
// Stop Handler - switch JTAG port off and stop program
void stopHandler(int sig)
{
jtagClosePort();
exit(1);
}
 
 
// Print help and stop program with error
void Help(char *progName)
{
fprintf(stderr, "Bad Parameters\n");
fprintf(stderr, "\n");
fprintf(stderr, "Usage: %s [arg]\n", progName);
fprintf(stderr, "\n");
fprintf(stderr, " Where [arg] is one of: \n");
fprintf(stderr, " -d Description Fing FTDI device by Description\n");
fprintf(stderr, " -l Location Fing FTDI device by Loaction\n");
fprintf(stderr, " -s Serial_number Fing FTDI device by it's SN\n");
fprintf(stderr, " -n Number Use N-th FTDI device\n");
fprintf(stderr, " The first FTDI device is used if no argument\n");
exit(2);
}
 
 
int __cdecl main(int argc, char *argv[])
{
// Variables
bool verbose = true;
 
// Program Info
printf("\n");
printf("Xilinx Virtual Cable Network Server\n");
printf("===================================\n");
printf("(c) miho 2012 v " VERSION "\n\n");
 
// Get program name
char *cp;
char *progName;
cp = argv[0];
progName=cp;
while (cp[0]!='\0')
{
if (cp[0]=='/' || cp[0]=='\\')
progName=cp+1;
cp++;
}
 
// Process command line params
char *findDeviceByStr = 0; // String parameter
int findDeviceBy = 0; // What does the string means
 
if (argc>1)
{
if (argc==3)
{
findDeviceByStr = argv[2];
if (strcmp(argv[1], "-d")==0)
{
findDeviceBy = OPEN_BY_DESCRIPTION;
}
else if (strcmp(argv[1], "-l")==0)
{
findDeviceBy = OPEN_BY_LOCATION;
}
else if (strcmp(argv[1], "-s")==0)
{
findDeviceBy = OPEN_BY_SERIAL_NUMBER;
}
else if (strcmp(argv[1], "-n")==0)
{
findDeviceBy = 0;
}
else
{
Help(progName);
}
}
else
{
Help(progName);
}
}
else
{
// Empty String - find device by number and number is empty
findDeviceBy = 0;
findDeviceByStr = "";
}
 
// Find, Init and Open FTDI USB Chip
if (jtagOpenPort(findDeviceBy, findDeviceByStr)<0) {
// No Device Found
fprintf(stderr, "ERROR: No Device Found\n");
return -1;
}
 
// Signal Handler (for CRTL+C)
signal(SIGINT, &stopHandler);
 
printf("Starting Network Server\n");
WSADATA wsaData;
int iResult;
 
SOCKET ListenSocket = INVALID_SOCKET;
SOCKET ClientSocket = INVALID_SOCKET;
 
// Initialize Winsock
iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
if (iResult != 0)
{
fprintf(stderr, "WSAStartup failed with error: %d\n", iResult);
jtagClosePort();
return -2;
}
 
// Display HostName and Address
char sMyName[255];
gethostname(sMyName, sizeof(sMyName));
printf(" Host Name %s\n", sMyName);
hostent * pHostInfo;
pHostInfo = gethostbyname(sMyName);
printf(" Network Name %s\n", pHostInfo->h_name);
if (pHostInfo->h_length>0 && pHostInfo->h_length<=16)
{
printf(" Host Address ");
for (int i=0; i<pHostInfo->h_length-1; i++)
{
printf("%d.", (unsigned char)pHostInfo->h_addr_list[0][i]);
}
printf("%d\n", (unsigned char)pHostInfo->h_addr_list[0][pHostInfo->h_length-1]);
}
 
// Create Protocol Structure
struct addrinfo hints;
ZeroMemory(&hints, sizeof(hints));
hints.ai_family = AF_INET; // IP6
hints.ai_socktype = SOCK_STREAM; // Reliable two-way connection
hints.ai_protocol = IPPROTO_TCP; // Protocol TCP
hints.ai_flags = AI_PASSIVE;
 
// Resolve the server address and port (allocate structure "result")
struct addrinfo *result = NULL;
iResult = getaddrinfo(NULL, XVC_TCP_PORT, &hints, &result);
if ( iResult != 0 )
{
fprintf(stderr, "getaddrinfo failed with error: %d\n", iResult);
WSACleanup();
jtagClosePort();
return -2;
}
 
// Create a SOCKET
ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
if (ListenSocket == INVALID_SOCKET)
{
fprintf(stderr, "socket failed with error: %ld\n", WSAGetLastError());
freeaddrinfo(result);
WSACleanup();
jtagClosePort();
return -2;
}
 
// Bind the SOCKED (assign the address)
iResult = bind(ListenSocket, result->ai_addr, (int)result->ai_addrlen);
if (iResult == SOCKET_ERROR)
{
fprintf(stderr, "Bind failed with error: %d\n", WSAGetLastError());
freeaddrinfo(result);
closesocket(ListenSocket);
WSACleanup();
jtagClosePort();
return -2;
}
 
if (verbose)
{
printf(" Bound Socket %s\n", XVC_TCP_PORT);
}
 
// Help for user
printf(" Set in IMPACT xilinx_xvc host=%s:%s disableversioncheck=true\n", sMyName, XVC_TCP_PORT);
 
freeaddrinfo(result);
 
// Listen SOCKET
iResult = listen(ListenSocket, SOMAXCONN);
if (iResult == SOCKET_ERROR)
{
printf("listen failed with error: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
jtagClosePort();
return -2;
}
 
printf("\n");
 
do
{
printf(" Listen\n");
jtagSetLED(true);
 
// Accept a client SOCKET
sockaddr ClientSocetAddr;
int ClientSocetAddrLen = sizeof(sockaddr);
ClientSocket = accept(ListenSocket, &ClientSocetAddr, &ClientSocetAddrLen);
if (ClientSocket == INVALID_SOCKET)
{
printf("accept failed with error: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
jtagClosePort();
return -2;
}
 
// Print Accepted + Address
printf(" Accepted ");
jtagSetLED(false);
for (int i=2; i<2+4-1; i++)
{
printf("%d.", (unsigned char)ClientSocetAddr.sa_data[i]);
}
printf("%d:%d\n", (unsigned char)ClientSocetAddr.sa_data[2+4-1], (unsigned char)ClientSocetAddr.sa_data[0]*256+(unsigned char)ClientSocetAddr.sa_data[1]);
 
// Process Data until the peer shuts down the connection
int Cnt = 0;
printf(" Handle Data ");
do
{
iResult = handleData(ClientSocket);
if (iResult>=0)
{
printf(".");
Cnt++;
if (Cnt>40)
{
Cnt = 0;
printf("\n ");
}
}
}
while (iResult >= 0);
 
// Connection Closed by peer
if (iResult==-1)
{
// JTAG port
jtagSetIdle();
}
 
// Error - shutdown the connection
if (iResult==-2)
{
fprintf(stderr, " Disconnect\n");
iResult = shutdown(ClientSocket, SD_SEND);
if (iResult == SOCKET_ERROR)
{
fprintf(stderr, "shutdown failed with error: %d\n", WSAGetLastError());
}
iResult=-2; // Error
}
 
// cleanup
closesocket(ClientSocket);
 
}
// If not Error Listen Again
while (iResult!=-2);
 
// cleanup
closesocket(ListenSocket);
WSACleanup();
jtagClosePort();
 
return 1;
}