[s3load.git] / libnexys.c

#ifdef WIN32_NATIVE
#include "libnexys.win32.c"
#else
#define LIBNEXYS_INTERNAL
#include "libnexys.h"
#include <stdio.h>
#include <usb.h>

#define NEXYS2_VENDOR 0x1443
#define NEXYS2_DEVICE 0x0005

nexys2_t nexys2_init(void) {
	struct usb_bus *bus;
	struct usb_device *dev;
	usb_dev_handle *udev;
	int dev_found, ret;
	unsigned char buf[15];
	
	usb_init();

	usb_find_busses();
	usb_find_devices();

	udev = NULL;
	for (bus = usb_get_busses(); bus && !udev; bus = bus->next)
		for (dev = bus->devices; dev && !udev; dev = dev->next)
			if ((dev->descriptor.idVendor == NEXYS2_VENDOR) && (dev->descriptor.idProduct == NEXYS2_DEVICE))
				udev = usb_open(dev);

	if (!udev)
	{
		fprintf(stderr, "nexys2_init: no device found or device open failed\n");
		return NULL;
	}
	
	if (usb_set_configuration(udev, 1) < 0)
	{
		fprintf(stderr, "nexys2_init: failed to set configuration 1 -- check your permissions\n");
		return NULL;
	}
	
	if (usb_claim_interface(udev, 0) < 0)	/* Needed for libusb on win32.  This code somehow crashes win32 libusb/kernel anyway, but... */
	{
		fprintf(stderr, "nexys2_init: failed to claim interface 0 -- check your permissions\n");
		return NULL;
	}
	
	if (usb_clear_halt(udev, 0x01) < 0)	/* Sometimes the board locks up when you close it, so send this. */
	{
		fprintf(stderr, "nexys2_init: failed to clear halt on interface 0x01\n");
		return NULL;
	}
	
	ret = usb_control_msg(udev, 0x00, 0x09, 1, 0, NULL, 0, 1000);
	if (ret < 0)
	{
		fprintf(stderr, "nexys2_init: failed to send setup control message\n");
		return NULL;
	}
	
	ret = usb_control_msg(udev, 0xC0, 0xE4, 0, 0, buf, 14, 1000);
	if (ret < 0)
	{
		fprintf(stderr, "nexys2_init: failed to send serial number control message\n");
		return NULL;
	}
	
	buf[ret] = 0;
	fprintf(stderr, "nexys2_init: got serial number \"%s\" (%d bytes)\n", buf, ret);
	
	ret = usb_control_msg(udev, 0xC0, 0xE6, 0, 0, buf, 4, 1000);
	if (ret < 0)
	{
		fprintf(stderr, "nexys2_init: failed to send magic goo message\n");
		return NULL;
	}
	if (memcmp(buf, "\x01\x00\x02\x00", 4))
	{
		fprintf(stderr, "nexys2_init: magic goo did not return what we expected (%d, %02x %02x %02x %02x)\n", ret, buf[0], buf[1], buf[2], buf[3]);
		return NULL;
	}
	
	return udev;
}

static unsigned char common_response[64] =
	{ 0x00, 0x03, 0xf3, 0x77, 0x9f, 0xf5, 0xdf, 0xdd,
	  0xdf, 0xfe, 0x5f, 0xac, 0xff, 0xad, 0xf3, 0x34,
	  0xaf, 0xf5, 0xac, 0xf7, 0xca, 0xb7, 0xf7, 0x6f,
	  0xff, 0x5e, 0x5e, 0xf7, 0xfb, 0xfd, 0xfb, 0x37,
	  0x81, 0x53, 0xbf, 0x64, 0x59, 0x47, 0x59, 0x2d,
	  0xe8, 0x30, 0x77, 0xda, 0x4f, 0xaf, 0x7f, 0xd7,
	  0x5f, 0xee, 0xc7, 0x3b, 0xdf, 0x3e, 0xbf, 0x35,
	  0xd1, 0xdf, 0xef, 0x3f, 0x9f, 0xde, 0xfa, 0xe2
	};

int nexys2_jtag_enable(usb_dev_handle *udev)
{
	int ret;
	unsigned char message[64] =
		{ 0x07, 0x01, 0x00, 0x00, 0xdc, 0xff, 0xd3, 0x00,
		  0xf3, 0x99, 0x83, 0x7c, 0x08, 0x26, 0x80, 0x7c,
		  0xff, 0xff, 0xff, 0xff, 0x00, 0x26, 0x80, 0x7c,
		  0xf1, 0xe2, 0x90, 0x7c, 0xb7, 0x24, 0x80, 0x7c,
		  0x14, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x2a, 0x95, 0x80, 0x7c, 0x5b, 0x3d, 0x00, 0x11,
		  0x14, 0x07, 0x00, 0x00, 0xe8, 0x22, 0xa0, 0x00,
		  0x02, 0x00, 0x00, 0x00, 0xb3, 0x9e, 0x01, 0x11	/* XXX does this need to be sequenced? */
		};
	unsigned char resp[64];
	
	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_enable: write failed: %d (%s)\n", ret, usb_strerror());
		return -1;
	}
	
	if ((ret = usb_bulk_read(udev, 0x81, resp, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_enable: short read on response: %d\n", ret);
		return -1;
	}
	
	if (memcmp(resp, common_response, 64))
	{
		fprintf(stderr, "nexys2_jtag_enable: incorrect response?\n");
//		return -1;
	}
	
	return 0;
}

int nexys2_jtag_disable(usb_dev_handle *udev)
{
	int ret;
	unsigned char message[64] =
		{ 0x07, 0x00, 0xf3, 0x76, 0xdc, 0xff, 0xd3, 0x00,
		  0xf3, 0x99, 0x83, 0x7c, 0x08, 0x26, 0x80, 0x7c,
		  0xff, 0xff, 0xff, 0xff, 0x00, 0x26, 0x80, 0x7c,
		  0xf1, 0xe2, 0x90, 0x7c, 0xb7, 0x24, 0x80, 0x7c,
		  0x14, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x2a, 0x95, 0x80, 0x7c, 0x5b, 0x3d, 0x00, 0x11,
		  0x14, 0x07, 0x00, 0x00, 0xe8, 0x22, 0xa0, 0x00,
		  0x05, 0x00, 0x00, 0x00, 0xb3, 0x9e, 0x01, 0x11	/* XXX does this need to be sequenced? */
		};
	unsigned char resp[64];
	
	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_disable: write failed: %d (%s)\n", ret, usb_strerror());
		return -1;
	}
	
	if ((ret = usb_bulk_read(udev, 0x81, resp, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_disable: short read on response: %d\n", ret);
		return -1;
	}
	
	if (memcmp(resp, common_response, 64))
	{
		fprintf(stderr, "nexys2_jtag_disable: incorrect response?\n");
//		return -1;
	}
	
	return 0;
}

int nexys2_jtag_setbits(usb_dev_handle *udev, int tms, int tdi, int tck)
{
	int ret;
	unsigned char message[64] =
		{ 0x08, !!tms, !!tdi, !!tck, 0xdc, 0xff, 0xd3, 0x00,
		  0xf3, 0x99, 0x83, 0x7c, 0x08, 0x26, 0x80, 0x7c,
		  0xff, 0xff, 0xff, 0xff, 0x00, 0x26, 0x80, 0x7c,
		  0xf1, 0xe2, 0x90, 0x7c, 0xb7, 0x24, 0x80, 0x7c,
		  0x14, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x2a, 0x95, 0x80, 0x7c, 0x5b, 0x3d, 0x00, 0x11,
		  0x14, 0x07, 0x00, 0x00, 0xe8, 0x22, 0xa0, 0x00,
		  0x03, 0x00, 0x00, 0x00, 0xb3, 0x9e, 0x01, 0x11	/* XXX does this need to be sequenced? */
		};
	unsigned char resp[64];
	
	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_setbits: write failed: %d (%s)\n", ret, usb_strerror());
		return -1;
	}
	
/*	if ((ret = usb_bulk_read(udev, 0x81, resp, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_setbits: short read on response: %d\n", ret);
		return -1;
	}
	
	if (memcmp(resp, common_response, 64))
	{
		fprintf(stderr, "nexys2_jtag_setbits: incorrect response?\n");
		return -1;
	}*/
	
	return 0;
}

int nexys2_jtag_puttdi(usb_dev_handle *udev, int tms, int nbits, unsigned char *bits, unsigned char *obits)
{
	int wanttdo = obits ? 1 : 0;
	int bytesrem;
	int ret;
	
	unsigned char message[64] =
		{ 0x09, wanttdo, !!tms, 0x00, 0x00, (nbits >> 8) & 0xFF, nbits & 0xFF, 0x7C,
		  0xeb, 0x06, 0x91, 0x7c, 0x28, 0xfa, 0xd3, 0x00,
		  0xec, 0xfc, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
		};
	
	if (nbits > 0xFFFF)
	{
		fprintf(stderr, "nexys2_jtag_puttdi: too many bits!\n");
		return -1;
	}
	
	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_puttdi: write failed: %d (%s)\n", ret, usb_strerror());
		return -1;
	}
	
	bytesrem = nbits / 8 + ((nbits % 8) != 0);
	while (bytesrem)
	{
		int nbytes = (bytesrem > 512) ? 512 : bytesrem;
		if ((ret = usb_bulk_write(udev, 0x02, bits, nbytes, 1000)) < nbytes)
		{
			fprintf(stderr, "nexys2_jtag_puttdi: data write failed: %d (%s)\n", ret, usb_strerror());
			return -1;
		}
		bits += nbytes;
		bytesrem -= nbytes;
	}
	
	if (obits)
	{
		bytesrem = nbits / 8 + ((nbits % 8) != 0);
		while (bytesrem)
		{
			int nbytes = (bytesrem > 512) ? 512 : bytesrem;
			if ((ret = usb_bulk_read(udev, 0x86, obits, nbytes, 1000)) < nbytes)
			{
				fprintf(stderr, "nexys2_jtag_puttdi: data read failed: %d (%s)\n", ret, usb_strerror());
				return -1;
			}
			obits += nbytes;
			bytesrem -= nbytes;
		}
	}
	
	return 0;
}

int nexys2_jtag_puttmstdi(usb_dev_handle *udev, int nbits, unsigned char *bits, unsigned char *obits)
{
	int wanttdo = obits ? 1 : 0;
	int bytesrem;
	int ret;
	
	unsigned char message[64] =
		{ 0x0a, wanttdo, 0x00, 0x00, (nbits >> 8) & 0xFF, nbits & 0xFF, 0x91, 0x7C,
		  0xeb, 0x06, 0x91, 0x7c, 0x28, 0xfa, 0xd3, 0x00,
		  0xec, 0xfc, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
		};
	
	if (nbits > 0xFFFF)
	{
		fprintf(stderr, "nexys2_jtag_puttmstdi: too many bits!\n");
		return -1;
	}
	
	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_puttmstdi: write failed: %d (%s)\n", ret, usb_strerror());
		return -1;
	}
	
	bytesrem = nbits / 4 + ((nbits % 4) != 0);
	while (bytesrem)
	{
		int nbytes = (bytesrem > 512) ? 512 : bytesrem;
		if ((ret = usb_bulk_write(udev, 0x02, bits, nbytes, 1000)) < nbytes)
		{
			fprintf(stderr, "nexys2_jtag_puttmstdi: data write failed: %d (%s)\n", ret, usb_strerror());
			return -1;
		}
		if (obits)
		{
			int nrbytes = nbytes/2 + (nbytes % 2);
			if ((ret = usb_bulk_read(udev, 0x86, obits, nrbytes, 1000)) < nrbytes)
			{
				fprintf(stderr, "nexys2_jtag_puttmstdi: data read failed: %d (%s)\n", ret, usb_strerror());
				return -1;
			}
			obits += nrbytes;
		}
		bits += nbytes;
		bytesrem -= nbytes;
	}
	
	return 0;
}

int nexys2_jtag_gettdo(usb_dev_handle *udev, int tdi, int tms, int nbits, unsigned char *obits)
{
	int wanttdo = obits ? 1 : 0;
	int bytesrem;
	int ret;
	
	unsigned char message[64] =
		{ 0x0B, !!tdi, !!tms, 0x00, 0x00, (nbits >> 8) & 0xFF, nbits & 0xFF, 0x7C,
		  0xeb, 0x06, 0x91, 0x7c, 0x28, 0xfa, 0xd3, 0x00,
		  0xec, 0xfc, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
		};
	
	if (nbits > 0xFFFF)
	{
		fprintf(stderr, "nexys2_jtag_puttdo: too many bits!\n");
		return -1;
	}
	
	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
	{
		fprintf(stderr, "nexys2_jtag_gettdo: write failed: %d (%s)\n", ret, usb_strerror());
		return -1;
	}
	
	bytesrem = nbits / 8 + ((nbits % 8) != 0);
	while (bytesrem)
	{
		int nbytes = (bytesrem > 512) ? 512 : bytesrem;
		if ((ret = usb_bulk_read(udev, 0x86, obits, nbytes, 1000)) < nbytes)
		{
			fprintf(stderr, "nexys2_jtag_gettdo: data read failed: %d (%s)\n", ret, usb_strerror());
			return -1;
		}
		obits += nbytes;
		bytesrem -= nbytes;
	}
	
	return 0;
}

#endif

#ifdef TEST_DRIVER

void poke_idcode(nexys2_t nexys)
{
	unsigned char seq1[] = { 0xaa, 0x22};
	unsigned char seq2[] = { 0xaa, 0x02};
	unsigned int idcode = 0;
	
//	while(1)
	{
		while (nexys2_jtag_enable(nexys) < 0)
			;
		if (nexys2_jtag_puttmstdi(nexys, 8, seq1, NULL) < 0)
			return;
		do
		{
			if (nexys2_jtag_gettdo(nexys, 0, 0, 32, &idcode) < 0)
				return;
			printf("IDCODE: %08x\n", idcode);
		} while(idcode && (idcode != 0xFFFFFFFF));
		if (nexys2_jtag_puttmstdi(nexys, 8, seq2, NULL) < 0)
			return;
		if (nexys2_jtag_disable(nexys) < 0)
			return;
	}
}

void main()
{
	nexys2_t nexys;
	nexys = nexys2_init();
	if (!nexys)
		return;
	poke_idcode(nexys);
}

#endif
Commit	Line	Data
5ee943f9 JW	1	#ifdef WIN32_NATIVE
	2	#include "libnexys.win32.c"
	3	#else
	4	#define LIBNEXYS_INTERNAL
	5	#include "libnexys.h"
	6	#include <stdio.h>
	7	#include <usb.h>
	8
	9	#define NEXYS2_VENDOR 0x1443
	10	#define NEXYS2_DEVICE 0x0005
	11
	12	nexys2_t nexys2_init(void) {
	13	struct usb_bus *bus;
	14	struct usb_device *dev;
	15	usb_dev_handle *udev;
	16	int dev_found, ret;
	17	unsigned char buf[15];
	18
	19	usb_init();
	20
	21	usb_find_busses();
	22	usb_find_devices();
	23
	24	udev = NULL;
	25	for (bus = usb_get_busses(); bus && !udev; bus = bus->next)
	26	for (dev = bus->devices; dev && !udev; dev = dev->next)
	27	if ((dev->descriptor.idVendor == NEXYS2_VENDOR) && (dev->descriptor.idProduct == NEXYS2_DEVICE))
	28	udev = usb_open(dev);
	29
	30	if (!udev)
	31	{
	32	fprintf(stderr, "nexys2_init: no device found or device open failed\n");
	33	return NULL;
	34	}
	35
	36	if (usb_set_configuration(udev, 1) < 0)
	37	{
	38	fprintf(stderr, "nexys2_init: failed to set configuration 1 -- check your permissions\n");
	39	return NULL;
	40	}
	41
	42	if (usb_claim_interface(udev, 0) < 0) /* Needed for libusb on win32. This code somehow crashes win32 libusb/kernel anyway, but... */
	43	{
	44	fprintf(stderr, "nexys2_init: failed to claim interface 0 -- check your permissions\n");
	45	return NULL;
	46	}
	47
	48	if (usb_clear_halt(udev, 0x01) < 0) /* Sometimes the board locks up when you close it, so send this. */
	49	{
	50	fprintf(stderr, "nexys2_init: failed to clear halt on interface 0x01\n");
	51	return NULL;
	52	}
	53
	54	ret = usb_control_msg(udev, 0x00, 0x09, 1, 0, NULL, 0, 1000);
	55	if (ret < 0)
	56	{
	57	fprintf(stderr, "nexys2_init: failed to send setup control message\n");
	58	return NULL;
	59	}
	60
	61	ret = usb_control_msg(udev, 0xC0, 0xE4, 0, 0, buf, 14, 1000);
	62	if (ret < 0)
	63	{
	64	fprintf(stderr, "nexys2_init: failed to send serial number control message\n");
65	return NULL;
66	}
67
68	buf[ret] = 0;
69	fprintf(stderr, "nexys2_init: got serial number \"%s\" (%d bytes)\n", buf, ret);
70
71	ret = usb_control_msg(udev, 0xC0, 0xE6, 0, 0, buf, 4, 1000);
72	if (ret < 0)
73	{
74	fprintf(stderr, "nexys2_init: failed to send magic goo message\n");
75	return NULL;
76	}
77	if (memcmp(buf, "\x01\x00\x02\x00", 4))
78	{
79	fprintf(stderr, "nexys2_init: magic goo did not return what we expected (%d, %02x %02x %02x %02x)\n", ret, buf[0], buf[1], buf[2], buf[3]);
80	return NULL;
81	}
82
83	return udev;
84	}
85
86	static unsigned char common_response[64] =
87	{ 0x00, 0x03, 0xf3, 0x77, 0x9f, 0xf5, 0xdf, 0xdd,
88	0xdf, 0xfe, 0x5f, 0xac, 0xff, 0xad, 0xf3, 0x34,
89	0xaf, 0xf5, 0xac, 0xf7, 0xca, 0xb7, 0xf7, 0x6f,
90	0xff, 0x5e, 0x5e, 0xf7, 0xfb, 0xfd, 0xfb, 0x37,
91	0x81, 0x53, 0xbf, 0x64, 0x59, 0x47, 0x59, 0x2d,
92	0xe8, 0x30, 0x77, 0xda, 0x4f, 0xaf, 0x7f, 0xd7,
93	0x5f, 0xee, 0xc7, 0x3b, 0xdf, 0x3e, 0xbf, 0x35,
94	0xd1, 0xdf, 0xef, 0x3f, 0x9f, 0xde, 0xfa, 0xe2
95	};
96
97	int nexys2_jtag_enable(usb_dev_handle *udev)
98	{
99	int ret;
100	unsigned char message[64] =
101	{ 0x07, 0x01, 0x00, 0x00, 0xdc, 0xff, 0xd3, 0x00,
102	0xf3, 0x99, 0x83, 0x7c, 0x08, 0x26, 0x80, 0x7c,
103	0xff, 0xff, 0xff, 0xff, 0x00, 0x26, 0x80, 0x7c,
104	0xf1, 0xe2, 0x90, 0x7c, 0xb7, 0x24, 0x80, 0x7c,
105	0x14, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
106	0x2a, 0x95, 0x80, 0x7c, 0x5b, 0x3d, 0x00, 0x11,
107	0x14, 0x07, 0x00, 0x00, 0xe8, 0x22, 0xa0, 0x00,
108	0x02, 0x00, 0x00, 0x00, 0xb3, 0x9e, 0x01, 0x11 /* XXX does this need to be sequenced? */
109	};
110	unsigned char resp[64];
111
112	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
113	{
114	fprintf(stderr, "nexys2_jtag_enable: write failed: %d (%s)\n", ret, usb_strerror());
115	return -1;
116	}
117
118	if ((ret = usb_bulk_read(udev, 0x81, resp, 64, 1000)) < 64)
119	{
120	fprintf(stderr, "nexys2_jtag_enable: short read on response: %d\n", ret);
121	return -1;
122	}
123
124	if (memcmp(resp, common_response, 64))
125	{
126	fprintf(stderr, "nexys2_jtag_enable: incorrect response?\n");
127	// return -1;
128	}
129
130	return 0;
131	}
132
133	int nexys2_jtag_disable(usb_dev_handle *udev)
134	{
135	int ret;
136	unsigned char message[64] =
137	{ 0x07, 0x00, 0xf3, 0x76, 0xdc, 0xff, 0xd3, 0x00,
138	0xf3, 0x99, 0x83, 0x7c, 0x08, 0x26, 0x80, 0x7c,
139	0xff, 0xff, 0xff, 0xff, 0x00, 0x26, 0x80, 0x7c,
140	0xf1, 0xe2, 0x90, 0x7c, 0xb7, 0x24, 0x80, 0x7c,
141	0x14, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
142	0x2a, 0x95, 0x80, 0x7c, 0x5b, 0x3d, 0x00, 0x11,
143	0x14, 0x07, 0x00, 0x00, 0xe8, 0x22, 0xa0, 0x00,
144	0x05, 0x00, 0x00, 0x00, 0xb3, 0x9e, 0x01, 0x11 /* XXX does this need to be sequenced? */
145	};
146	unsigned char resp[64];
147
148	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
149	{
150	fprintf(stderr, "nexys2_jtag_disable: write failed: %d (%s)\n", ret, usb_strerror());
151	return -1;
152	}
153
154	if ((ret = usb_bulk_read(udev, 0x81, resp, 64, 1000)) < 64)
155	{
156	fprintf(stderr, "nexys2_jtag_disable: short read on response: %d\n", ret);
157	return -1;
158	}
159
160	if (memcmp(resp, common_response, 64))
161	{
162	fprintf(stderr, "nexys2_jtag_disable: incorrect response?\n");
163	// return -1;
164	}
165
166	return 0;
167	}
168
169	int nexys2_jtag_setbits(usb_dev_handle *udev, int tms, int tdi, int tck)
170	{
171	int ret;
172	unsigned char message[64] =
173	{ 0x08, !!tms, !!tdi, !!tck, 0xdc, 0xff, 0xd3, 0x00,
174	0xf3, 0x99, 0x83, 0x7c, 0x08, 0x26, 0x80, 0x7c,
175	0xff, 0xff, 0xff, 0xff, 0x00, 0x26, 0x80, 0x7c,
176	0xf1, 0xe2, 0x90, 0x7c, 0xb7, 0x24, 0x80, 0x7c,
177	0x14, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
178	0x2a, 0x95, 0x80, 0x7c, 0x5b, 0x3d, 0x00, 0x11,
179	0x14, 0x07, 0x00, 0x00, 0xe8, 0x22, 0xa0, 0x00,
180	0x03, 0x00, 0x00, 0x00, 0xb3, 0x9e, 0x01, 0x11 /* XXX does this need to be sequenced? */
181	};
182	unsigned char resp[64];
183
184	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
185	{
186	fprintf(stderr, "nexys2_jtag_setbits: write failed: %d (%s)\n", ret, usb_strerror());
187	return -1;
188	}
189
190	/* if ((ret = usb_bulk_read(udev, 0x81, resp, 64, 1000)) < 64)
191	{
192	fprintf(stderr, "nexys2_jtag_setbits: short read on response: %d\n", ret);
193	return -1;
194	}
195
196	if (memcmp(resp, common_response, 64))
197	{
198	fprintf(stderr, "nexys2_jtag_setbits: incorrect response?\n");
199	return -1;
200	}*/
201
202	return 0;
203	}
204
205	int nexys2_jtag_puttdi(usb_dev_handle udev, int tms, int nbits, unsigned char bits, unsigned char *obits)
206	{
207	int wanttdo = obits ? 1 : 0;
208	int bytesrem;
209	int ret;
210
211	unsigned char message[64] =
212	{ 0x09, wanttdo, !!tms, 0x00, 0x00, (nbits >> 8) & 0xFF, nbits & 0xFF, 0x7C,
213	0xeb, 0x06, 0x91, 0x7c, 0x28, 0xfa, 0xd3, 0x00,
214	0xec, 0xfc, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00,
215	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
216	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
217	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
218	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
219	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
220	};
221
222	if (nbits > 0xFFFF)
223	{
224	fprintf(stderr, "nexys2_jtag_puttdi: too many bits!\n");
225	return -1;
226	}
227
228	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
229	{
230	fprintf(stderr, "nexys2_jtag_puttdi: write failed: %d (%s)\n", ret, usb_strerror());
231	return -1;
232	}
233
234	bytesrem = nbits / 8 + ((nbits % 8) != 0);
235	while (bytesrem)
236	{
237	int nbytes = (bytesrem > 512) ? 512 : bytesrem;
238	if ((ret = usb_bulk_write(udev, 0x02, bits, nbytes, 1000)) < nbytes)
239	{
240	fprintf(stderr, "nexys2_jtag_puttdi: data write failed: %d (%s)\n", ret, usb_strerror());
241	return -1;
242	}
243	bits += nbytes;
244	bytesrem -= nbytes;
245	}
246
247	if (obits)
248	{
249	bytesrem = nbits / 8 + ((nbits % 8) != 0);
250	while (bytesrem)
251	{
252	int nbytes = (bytesrem > 512) ? 512 : bytesrem;
253	if ((ret = usb_bulk_read(udev, 0x86, obits, nbytes, 1000)) < nbytes)
254	{
255	fprintf(stderr, "nexys2_jtag_puttdi: data read failed: %d (%s)\n", ret, usb_strerror());
256	return -1;
257	}
258	obits += nbytes;
259	bytesrem -= nbytes;
260	}
261	}
262
263	return 0;
264	}
265
266	int nexys2_jtag_puttmstdi(usb_dev_handle udev, int nbits, unsigned char bits, unsigned char *obits)
267	{
268	int wanttdo = obits ? 1 : 0;
269	int bytesrem;
270	int ret;
271
272	unsigned char message[64] =
273	{ 0x0a, wanttdo, 0x00, 0x00, (nbits >> 8) & 0xFF, nbits & 0xFF, 0x91, 0x7C,
274	0xeb, 0x06, 0x91, 0x7c, 0x28, 0xfa, 0xd3, 0x00,
275	0xec, 0xfc, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00,
276	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
277	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
278	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
279	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
280	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
281	};
282
283	if (nbits > 0xFFFF)
284	{
285	fprintf(stderr, "nexys2_jtag_puttmstdi: too many bits!\n");
286	return -1;
287	}
288
289	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
290	{
291	fprintf(stderr, "nexys2_jtag_puttmstdi: write failed: %d (%s)\n", ret, usb_strerror());
292	return -1;
293	}
294
295	bytesrem = nbits / 4 + ((nbits % 4) != 0);
296	while (bytesrem)
297	{
298	int nbytes = (bytesrem > 512) ? 512 : bytesrem;
299	if ((ret = usb_bulk_write(udev, 0x02, bits, nbytes, 1000)) < nbytes)
300	{
301	fprintf(stderr, "nexys2_jtag_puttmstdi: data write failed: %d (%s)\n", ret, usb_strerror());
302	return -1;
303	}
304	if (obits)
305	{
306	int nrbytes = nbytes/2 + (nbytes % 2);
307	if ((ret = usb_bulk_read(udev, 0x86, obits, nrbytes, 1000)) < nrbytes)
308	{
309	fprintf(stderr, "nexys2_jtag_puttmstdi: data read failed: %d (%s)\n", ret, usb_strerror());
310	return -1;
311	}
312	obits += nrbytes;
313	}
314	bits += nbytes;
315	bytesrem -= nbytes;
316	}
317
318	return 0;
319	}
320
321	int nexys2_jtag_gettdo(usb_dev_handle udev, int tdi, int tms, int nbits, unsigned char obits)
322	{
323	int wanttdo = obits ? 1 : 0;
324	int bytesrem;
325	int ret;
326
327	unsigned char message[64] =
328	{ 0x0B, !!tdi, !!tms, 0x00, 0x00, (nbits >> 8) & 0xFF, nbits & 0xFF, 0x7C,
329	0xeb, 0x06, 0x91, 0x7c, 0x28, 0xfa, 0xd3, 0x00,
330	0xec, 0xfc, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00,
331	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
332	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
333	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
334	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
335	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
336	};
337
338	if (nbits > 0xFFFF)
339	{
340	fprintf(stderr, "nexys2_jtag_puttdo: too many bits!\n");
341	return -1;
342	}
343
344	if ((ret = usb_bulk_write(udev, 0x01, message, 64, 1000)) < 64)
345	{
346	fprintf(stderr, "nexys2_jtag_gettdo: write failed: %d (%s)\n", ret, usb_strerror());
347	return -1;
348	}
349
350	bytesrem = nbits / 8 + ((nbits % 8) != 0);
351	while (bytesrem)
352	{
353	int nbytes = (bytesrem > 512) ? 512 : bytesrem;
354	if ((ret = usb_bulk_read(udev, 0x86, obits, nbytes, 1000)) < nbytes)
355	{
356	fprintf(stderr, "nexys2_jtag_gettdo: data read failed: %d (%s)\n", ret, usb_strerror());
357	return -1;
358	}
359	obits += nbytes;
360	bytesrem -= nbytes;
361	}
362
363	return 0;
364	}
365
366	#endif
367
368	#ifdef TEST_DRIVER
369
370	void poke_idcode(nexys2_t nexys)
371	{
372	unsigned char seq1[] = { 0xaa, 0x22};
373	unsigned char seq2[] = { 0xaa, 0x02};
374	unsigned int idcode = 0;
375
376	// while(1)
377	{
378	while (nexys2_jtag_enable(nexys) < 0)
379	;
380	if (nexys2_jtag_puttmstdi(nexys, 8, seq1, NULL) < 0)
381	return;
382	do
383	{
384	if (nexys2_jtag_gettdo(nexys, 0, 0, 32, &idcode) < 0)
385	return;
386	printf("IDCODE: %08x\n", idcode);
387	} while(idcode && (idcode != 0xFFFFFFFF));
388	if (nexys2_jtag_puttmstdi(nexys, 8, seq2, NULL) < 0)
389	return;
390	if (nexys2_jtag_disable(nexys) < 0)
391	return;
392	}
393	}
394
395	void main()
396	{
397	nexys2_t nexys;
398	nexys = nexys2_init();
399	if (!nexys)
400	return;
401	poke_idcode(nexys);
402	}
403
404	#endif
405