[usb-driver] / jtagkey.c

#include <stdio.h>
#include <ftdi.h>
#include <unistd.h>
#include "usb-driver.h"
#include "jtagkey.h"

#define USBBUFSIZE 4096

static struct ftdi_context ftdic;
static unsigned int usb_maxlen = 0;
static unsigned char bitbang_mode;

int jtagkey_init(unsigned short vid, unsigned short pid) {
	int ret = 0;
	unsigned char c;

	if ((ret = ftdi_init(&ftdic)) != 0) {
		fprintf(stderr, "unable to initialise libftdi: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}
	
	if ((ret = ftdi_usb_open(&ftdic, vid, pid)) != 0) {
		fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}

	if ((ret = ftdi_usb_reset(&ftdic)) != 0) {
		fprintf(stderr, "unable reset device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}

	if ((ret = ftdi_set_interface(&ftdic, INTERFACE_A)) != 0) {
		fprintf(stderr, "unable to set interface: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}


	if ((ret = ftdi_write_data_get_chunksize(&ftdic, &usb_maxlen))  != 0) {
		fprintf(stderr, "unable to get write chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}

	if ((ret = ftdi_set_latency_timer(&ftdic, 1))  != 0) {
		fprintf(stderr, "unable to set latency timer: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}

	if ((ret = ftdi_set_baudrate(&ftdic, 500000))  != 0) {
		fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}

	c = 0x00;
	ftdi_write_data(&ftdic, &c, 1);

	if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK|JTAGKEY_TDI|JTAGKEY_TMS|JTAGKEY_OEn, BITMODE_BITBANG))  != 0) {
		fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}

	bitbang_mode = BITMODE_BITBANG;

	if ((ret = ftdi_usb_purge_buffers(&ftdic))  != 0) {
		fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
		return ret;
	}

	return ret;
}

void jtagkey_close() {
	ftdi_disable_bitbang(&ftdic);
	ftdi_usb_close(&ftdic);
	ftdi_deinit(&ftdic);
}

static int jtagkey_set_bbmode(unsigned char mode) {
	int ret = 0;

	if (bitbang_mode != mode) {
		DPRINTF("switching bitbang-mode!\n");

		/* Wait for the latency-timer to kick in */
		usleep(2);
		if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK|JTAGKEY_TDI|JTAGKEY_TMS|JTAGKEY_OEn, mode))  != 0) {
			fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
			return ret;
		}
		if ((ret = ftdi_usb_purge_buffers(&ftdic))  != 0) {
			fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
			return ret;
		}
		/* Wait for the FTDI2232 to settle */
		usleep(2);

		bitbang_mode = mode;
	}

	return ret;
}

void jtagkey_state(unsigned char data) {
	fprintf(stderr,"Pins high: ");

	if (data & JTAGKEY_TCK)
		fprintf(stderr,"TCK ");

	if (data & JTAGKEY_TDI)
		fprintf(stderr,"TDI ");

	if (data & JTAGKEY_TDO)
		fprintf(stderr,"TDO ");

	if (data & JTAGKEY_TMS)
		fprintf(stderr,"TMS ");

	if (data & JTAGKEY_VREF)
		fprintf(stderr,"VREF ");
	
	fprintf(stderr,"\n");
}

int jtagkey_transfer(WD_TRANSFER *tr, int fd, unsigned int request, int ppbase, int ecpbase, int num) {
	int ret = 0;
	int i;
	int nread = 0;
	unsigned long port;
	unsigned char val;
	static unsigned char last_data = 0;
	static unsigned char last_write = 0x00;
	static unsigned char writebuf[USBBUFSIZE], *writepos = writebuf;
	static unsigned char readbuf[USBBUFSIZE], *readpos;
	unsigned char data, prev_data;

	/* Count reads */
	for (i = 0; i < num; i++)
		if (tr[i].cmdTrans == PP_READ)
			nread++;

	/* Write combining */
	if ((writepos-writebuf > sizeof(writebuf)-num) || (nread && writepos-writebuf)) {
		unsigned char *pos = writebuf;
		int len;
		DPRINTF("writing %d bytes due to %d following reads in %d chunks or full buffer\n", writepos-writebuf, nread, num);

		jtagkey_set_bbmode(BITMODE_BITBANG);
		while (pos < writepos) {
			len = writepos-pos;

			if (len > usb_maxlen)
				len = usb_maxlen;

			DPRINTF("combined write of %d/%d\n",len,writepos-pos);
			ftdi_write_data(&ftdic, pos, len);
			pos += len;
		}

		writepos = writebuf;
	}

	for (i = 0; i < num; i++) {
		DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
				(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
				tr[i].fAutoinc, tr[i].dwOptions);

		port = (unsigned long)tr[i].dwPort;
		val = tr[i].Data.Byte;

#ifdef DEBUG
		if (tr[i].cmdTrans == 13)
			DPRINTF("write byte: %d\n", val);
#endif

		/* Pad writebuf for read-commands in stream */
		*writepos = last_data;
		prev_data = last_data;

		if (port == ppbase + PP_DATA) {
			DPRINTF("data port\n");

			data = 0x00;
			switch(tr[i].cmdTrans) {
				case PP_READ:
					ret = 0; /* We don't support reading of the data port */
					break;

				case PP_WRITE:
					if (val & PP_TDI) {
						data |= JTAGKEY_TDI;
						DPRINTF("TDI\n");
					} else {
						DPRINTF("!TDI\n");
					}
					if (val & PP_TCK) {
						data |= JTAGKEY_TCK;
						DPRINTF("TCK\n");
					} else {
						DPRINTF("!TCK\n");
					}
					if (val & PP_TMS) {
						data |= JTAGKEY_TMS;
						DPRINTF("TMS\n");
					} else {
						DPRINTF("!TMS\n");
					}
					if (val & PP_CTRL) {
						data = JTAGKEY_OEn;
						DPRINTF("CTRL\n");
					} else {
						DPRINTF("!CTRL\n");
					}

					if (val & PP_PROG) {
						DPRINTF("PROG\n");
					} else {
						DPRINTF("!PROG\n");
					}

					*writepos = data;

					last_data = data;
					last_write = val;
					break;

				default:
					fprintf(stderr,"!!!Unsupported TRANSFER command: %lu!!!\n", tr[i].cmdTrans);
					ret = -1;
					break;
			}
		}

		if (nread || (*writepos != prev_data))
			writepos++;
	}

	if (nread)
	{
		DPRINTF("writing %d bytes\n", writepos-writebuf);

		*writepos = last_data;
		writepos++;

		jtagkey_set_bbmode(BITMODE_SYNCBB);
		ftdi_write_data(&ftdic, writebuf, writepos-writebuf);

		i = 0;
		while (i < writepos-writebuf) {
			i += ftdi_read_data(&ftdic, readbuf, sizeof(readbuf));
		}

#ifdef DEBUG
		DPRINTF("write: ");
		hexdump(writebuf, writepos-writebuf);
		DPRINTF("read: ");
		hexdump(readbuf, i);
#endif

		writepos = writebuf;
	} else {
		return ret;
	}

	readpos = readbuf;

	for (i = 0; i < num; i++) {
		DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
				(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
				tr[i].fAutoinc, tr[i].dwOptions);

		port = (unsigned long)tr[i].dwPort;
		val = tr[i].Data.Byte;
		readpos++;

		if (port == ppbase + PP_DATA) {
			if (tr[i].cmdTrans == PP_WRITE) {
				last_write = val;
			}
		} else if (port == ppbase + PP_STATUS) {
			DPRINTF("status port (last write: 0x%x)\n", last_write);
			switch(tr[i].cmdTrans) {
				case PP_READ:
					data = *readpos;

#ifdef DEBUG
					DPRINTF("READ: 0x%x\n", data);
					jtagkey_state(data);
#endif

					val = 0x00;
					if ((data & JTAGKEY_TDO) && (last_write & PP_PROG))
						val |= PP_TDO;

					if (!(last_write & PP_PROG))
						val |= 0x08;

					if (last_write & 0x40)
						val |= 0x20;
					else
						val |= 0x80;
					break;

				case PP_WRITE:
					ret = 0; /* Status Port is readonly */
					break;

				default:
					fprintf(stderr,"!!!Unsupported TRANSFER command: %lu!!!\n", tr[i].cmdTrans);
					ret = -1;
					break;
			}
		} else {
			ret = 0;
		}

		tr[i].Data.Byte = val;

		DPRINTF("dwPortReturn: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
				(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
				tr[i].fAutoinc, tr[i].dwOptions);
#ifdef DEBUG
		if (tr[i].cmdTrans == 10)
			DPRINTF("read byte: %d\n", tr[i].Data.Byte);
#endif
	}

	return ret;
}
Commit	Line	Data
8121bc50	1	#include <stdio.h>
8121bc50	2	#include <ftdi.h>
9640dec9	3	#include <unistd.h>
8121bc50	4	#include "usb-driver.h"
	5	#include "jtagkey.h"
	6
4af4753d	7	#define USBBUFSIZE 4096
d0e2002d	8
8121bc50	9	static struct ftdi_context ftdic;
4af4753d	10	static unsigned int usb_maxlen = 0;
9640dec9	11	static unsigned char bitbang_mode;
8121bc50	12
	13	int jtagkey_init(unsigned short vid, unsigned short pid) {
	14	int ret = 0;
d0e2002d	15	unsigned char c;
8121bc50	16
	17	if ((ret = ftdi_init(&ftdic)) != 0) {
	18	fprintf(stderr, "unable to initialise libftdi: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	19	return ret;
	20	}
	21
	22	if ((ret = ftdi_usb_open(&ftdic, vid, pid)) != 0) {
	23	fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	24	return ret;
	25	}
	26
	27	if ((ret = ftdi_usb_reset(&ftdic)) != 0) {
	28	fprintf(stderr, "unable reset device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	29	return ret;
	30	}
	31
	32	if ((ret = ftdi_set_interface(&ftdic, INTERFACE_A)) != 0) {
	33	fprintf(stderr, "unable to set interface: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	34	return ret;
	35	}
	36
4af4753d	37
	38	if ((ret = ftdi_write_data_get_chunksize(&ftdic, &usb_maxlen)) != 0) {
	39	fprintf(stderr, "unable to get write chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
8121bc50	40	return ret;
	41	}
	42
	43	if ((ret = ftdi_set_latency_timer(&ftdic, 1)) != 0) {
	44	fprintf(stderr, "unable to set latency timer: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	45	return ret;
	46	}
	47
d0e2002d	48	if ((ret = ftdi_set_baudrate(&ftdic, 500000)) != 0) {
8121bc50	49	fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	50	return ret;
	51	}
	52
d0e2002d	53	c = 0x00;
	54	ftdi_write_data(&ftdic, &c, 1);
	55
4af4753d	56	if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK\|JTAGKEY_TDI\|JTAGKEY_TMS\|JTAGKEY_OEn, BITMODE_BITBANG)) != 0) {
8121bc50	57	fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	58	return ret;
	59	}
	60
9640dec9	61	bitbang_mode = BITMODE_BITBANG;
9640dec9	62
8121bc50	63	if ((ret = ftdi_usb_purge_buffers(&ftdic)) != 0) {
	64	fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	65	return ret;
	66	}
	67
	68	return ret;
	69	}
	70
	71	void jtagkey_close() {
	72	ftdi_disable_bitbang(&ftdic);
	73	ftdi_usb_close(&ftdic);
	74	ftdi_deinit(&ftdic);
	75	}
	76
9640dec9	77	static int jtagkey_set_bbmode(unsigned char mode) {
	78	int ret = 0;
	79
	80	if (bitbang_mode != mode) {
	81	DPRINTF("switching bitbang-mode!\n");
59b06a85	82
9640dec9	83	/* Wait for the latency-timer to kick in */
	84	usleep(2);
	85	if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK\|JTAGKEY_TDI\|JTAGKEY_TMS\|JTAGKEY_OEn, mode)) != 0) {
	86	fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	87	return ret;
	88	}
	89	if ((ret = ftdi_usb_purge_buffers(&ftdic)) != 0) {
	90	fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
	91	return ret;
	92	}
	93	/* Wait for the FTDI2232 to settle */
	94	usleep(2);
	95
	96	bitbang_mode = mode;
	97	}
	98
	99	return ret;
	100	}
	101
8121bc50	102	void jtagkey_state(unsigned char data) {
	103	fprintf(stderr,"Pins high: ");
	104
	105	if (data & JTAGKEY_TCK)
	106	fprintf(stderr,"TCK ");
	107
	108	if (data & JTAGKEY_TDI)
	109	fprintf(stderr,"TDI ");
	110
	111	if (data & JTAGKEY_TDO)
	112	fprintf(stderr,"TDO ");
	113
	114	if (data & JTAGKEY_TMS)
	115	fprintf(stderr,"TMS ");
	116
	117	if (data & JTAGKEY_VREF)
	118	fprintf(stderr,"VREF ");
	119
	120	fprintf(stderr,"\n");
	121	}
	122
	123	int jtagkey_transfer(WD_TRANSFER *tr, int fd, unsigned int request, int ppbase, int ecpbase, int num) {
	124	int ret = 0;
	125	int i;
d0e2002d	126	int nread = 0;
8121bc50	127	unsigned long port;
8121bc50	128	unsigned char val;
d0e2002d	129	static unsigned char last_data = 0;
e81047b8	130	static unsigned char last_write = 0x00;
d0e2002d	131	static unsigned char writebuf[USBBUFSIZE], *writepos = writebuf;
d0e2002d	132	static unsigned char readbuf[USBBUFSIZE], *readpos;
e81047b8	133	unsigned char data, prev_data;
d0e2002d	134
e81047b8	135	/* Count reads */
d0e2002d	136	for (i = 0; i < num; i++)
e81047b8	137	if (tr[i].cmdTrans == PP_READ)
d0e2002d	138	nread++;
	139
	140	/* Write combining */
	141	if ((writepos-writebuf > sizeof(writebuf)-num) \|\| (nread && writepos-writebuf)) {
4af4753d	142	unsigned char *pos = writebuf;
4af4753d	143	int len;
d0e2002d	144	DPRINTF("writing %d bytes due to %d following reads in %d chunks or full buffer\n", writepos-writebuf, nread, num);
d0e2002d	145
9640dec9	146	jtagkey_set_bbmode(BITMODE_BITBANG);
4af4753d	147	while (pos < writepos) {
85690a3f	148	len = writepos-pos;
85690a3f	149
4af4753d	150	if (len > usb_maxlen)
4af4753d	151	len = usb_maxlen;
d0e2002d	152
4af4753d	153	DPRINTF("combined write of %d/%d\n",len,writepos-pos);
	154	ftdi_write_data(&ftdic, pos, len);
	155	pos += len;
e81047b8	156	}
4af4753d	157
d0e2002d	158	writepos = writebuf;
d0e2002d	159	}
8121bc50	160
	161	for (i = 0; i < num; i++) {
	162	DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
	163	(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
	164	tr[i].fAutoinc, tr[i].dwOptions);
	165
	166	port = (unsigned long)tr[i].dwPort;
	167	val = tr[i].Data.Byte;
	168
	169	#ifdef DEBUG
	170	if (tr[i].cmdTrans == 13)
	171	DPRINTF("write byte: %d\n", val);
	172	#endif
	173
b122ac4b	174	/* Pad writebuf for read-commands in stream */
d0e2002d	175	*writepos = last_data;
e81047b8	176	prev_data = last_data;
b122ac4b	177
8121bc50	178	if (port == ppbase + PP_DATA) {
	179	DPRINTF("data port\n");
	180
	181	data = 0x00;
	182	switch(tr[i].cmdTrans) {
	183	case PP_READ:
	184	ret = 0; /* We don't support reading of the data port */
	185	break;
	186
	187	case PP_WRITE:
	188	if (val & PP_TDI) {
	189	data \|= JTAGKEY_TDI;
	190	DPRINTF("TDI\n");
	191	} else {
	192	DPRINTF("!TDI\n");
	193	}
	194	if (val & PP_TCK) {
	195	data \|= JTAGKEY_TCK;
	196	DPRINTF("TCK\n");
	197	} else {
	198	DPRINTF("!TCK\n");
	199	}
	200	if (val & PP_TMS) {
	201	data \|= JTAGKEY_TMS;
	202	DPRINTF("TMS\n");
	203	} else {
	204	DPRINTF("!TMS\n");
	205	}
	206	if (val & PP_CTRL) {
d0e2002d	207	data = JTAGKEY_OEn;
8121bc50	208	DPRINTF("CTRL\n");
	209	} else {
	210	DPRINTF("!CTRL\n");
	211	}
8121bc50	212
d0e2002d	213	if (val & PP_PROG) {
	214	DPRINTF("PROG\n");
	215	} else {
	216	DPRINTF("!PROG\n");
	217	}
	218
	219	*writepos = data;
	220
b122ac4b	221	last_data = data;
d0e2002d	222	last_write = val;
8121bc50	223	break;
	224
	225	default:
	226	fprintf(stderr,"!!!Unsupported TRANSFER command: %lu!!!\n", tr[i].cmdTrans);
	227	ret = -1;
	228	break;
	229	}
b122ac4b	230	}
e81047b8	231
	232	if (nread \|\| (*writepos != prev_data))
	233	writepos++;
b122ac4b	234	}
b122ac4b	235
d0e2002d	236	if (nread)
	237	{
	238	DPRINTF("writing %d bytes\n", writepos-writebuf);
59b06a85	239
	240	*writepos = last_data;
	241	writepos++;
	242
9640dec9	243	jtagkey_set_bbmode(BITMODE_SYNCBB);
9640dec9	244	ftdi_write_data(&ftdic, writebuf, writepos-writebuf);
3f5287b7	245
9640dec9	246	i = 0;
	247	while (i < writepos-writebuf) {
	248	i += ftdi_read_data(&ftdic, readbuf, sizeof(readbuf));
d0e2002d	249	}
b122ac4b	250
b122ac4b	251	#ifdef DEBUG
d0e2002d	252	DPRINTF("write: ");
	253	hexdump(writebuf, writepos-writebuf);
	254	DPRINTF("read: ");
	255	hexdump(readbuf, i);
b122ac4b	256	#endif
b122ac4b	257
d0e2002d	258	writepos = writebuf;
	259	} else {
	260	return ret;
	261	}
	262
	263	readpos = readbuf;
b122ac4b	264
	265	for (i = 0; i < num; i++) {
	266	DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
	267	(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
	268	tr[i].fAutoinc, tr[i].dwOptions);
	269
	270	port = (unsigned long)tr[i].dwPort;
	271	val = tr[i].Data.Byte;
d0e2002d	272	readpos++;
b122ac4b	273
d0e2002d	274	if (port == ppbase + PP_DATA) {
	275	if (tr[i].cmdTrans == PP_WRITE) {
	276	last_write = val;
	277	}
	278	} else if (port == ppbase + PP_STATUS) {
	279	DPRINTF("status port (last write: 0x%x)\n", last_write);
8121bc50	280	switch(tr[i].cmdTrans) {
8121bc50	281	case PP_READ:
d0e2002d	282	data = *readpos;
59b06a85	283
8121bc50	284	#ifdef DEBUG
	285	DPRINTF("READ: 0x%x\n", data);
	286	jtagkey_state(data);
	287	#endif
	288
	289	val = 0x00;
d0e2002d	290	if ((data & JTAGKEY_TDO) && (last_write & PP_PROG))
8121bc50	291	val \|= PP_TDO;
8121bc50	292
d0e2002d	293	if (!(last_write & PP_PROG))
	294	val \|= 0x08;
	295
8121bc50	296	if (last_write & 0x40)
	297	val \|= 0x20;
	298	else
	299	val \|= 0x80;
	300	break;
	301
	302	case PP_WRITE:
	303	ret = 0; /* Status Port is readonly */
	304	break;
	305
	306	default:
	307	fprintf(stderr,"!!!Unsupported TRANSFER command: %lu!!!\n", tr[i].cmdTrans);
	308	ret = -1;
	309	break;
	310	}
8121bc50	311	} else {
8121bc50	312	ret = 0;
	313	}
	314
	315	tr[i].Data.Byte = val;
	316
	317	DPRINTF("dwPortReturn: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
	318	(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
	319	tr[i].fAutoinc, tr[i].dwOptions);
	320	#ifdef DEBUG
	321	if (tr[i].cmdTrans == 10)
	322	DPRINTF("read byte: %d\n", tr[i].Data.Byte);
	323	#endif
	324	}
	325
	326	return ret;
	327	}