[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;
		}

		DPRINTF("read %d/%d bytes\n", i, writepos-writebuf);
		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	DPRINTF("read %d/%d bytes\n", i, writepos-writebuf);
	159	writepos = writebuf;
	160	}
8121bc50	161
	162	for (i = 0; i < num; i++) {
	163	DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
	164	(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
	165	tr[i].fAutoinc, tr[i].dwOptions);
	166
	167	port = (unsigned long)tr[i].dwPort;
	168	val = tr[i].Data.Byte;
	169
	170	#ifdef DEBUG
	171	if (tr[i].cmdTrans == 13)
	172	DPRINTF("write byte: %d\n", val);
	173	#endif
	174
b122ac4b	175	/* Pad writebuf for read-commands in stream */
d0e2002d	176	*writepos = last_data;
e81047b8	177	prev_data = last_data;
b122ac4b	178
8121bc50	179	if (port == ppbase + PP_DATA) {
	180	DPRINTF("data port\n");
	181
	182	data = 0x00;
	183	switch(tr[i].cmdTrans) {
	184	case PP_READ:
	185	ret = 0; /* We don't support reading of the data port */
	186	break;
	187
	188	case PP_WRITE:
	189	if (val & PP_TDI) {
	190	data \|= JTAGKEY_TDI;
	191	DPRINTF("TDI\n");
	192	} else {
	193	DPRINTF("!TDI\n");
	194	}
	195	if (val & PP_TCK) {
	196	data \|= JTAGKEY_TCK;
	197	DPRINTF("TCK\n");
	198	} else {
	199	DPRINTF("!TCK\n");
	200	}
	201	if (val & PP_TMS) {
	202	data \|= JTAGKEY_TMS;
	203	DPRINTF("TMS\n");
	204	} else {
	205	DPRINTF("!TMS\n");
	206	}
	207	if (val & PP_CTRL) {
d0e2002d	208	data = JTAGKEY_OEn;
8121bc50	209	DPRINTF("CTRL\n");
	210	} else {
	211	DPRINTF("!CTRL\n");
	212	}
8121bc50	213
d0e2002d	214	if (val & PP_PROG) {
	215	DPRINTF("PROG\n");
	216	} else {
	217	DPRINTF("!PROG\n");
	218	}
	219
	220	*writepos = data;
	221
b122ac4b	222	last_data = data;
d0e2002d	223	last_write = val;
8121bc50	224	break;
	225
	226	default:
	227	fprintf(stderr,"!!!Unsupported TRANSFER command: %lu!!!\n", tr[i].cmdTrans);
	228	ret = -1;
	229	break;
	230	}
b122ac4b	231	}
e81047b8	232
	233	if (nread \|\| (*writepos != prev_data))
	234	writepos++;
b122ac4b	235	}
b122ac4b	236
d0e2002d	237	if (nread)
	238	{
	239	DPRINTF("writing %d bytes\n", writepos-writebuf);
59b06a85	240
	241	*writepos = last_data;
	242	writepos++;
	243
9640dec9	244	jtagkey_set_bbmode(BITMODE_SYNCBB);
9640dec9	245	ftdi_write_data(&ftdic, writebuf, writepos-writebuf);
3f5287b7	246
9640dec9	247	i = 0;
	248	while (i < writepos-writebuf) {
	249	i += ftdi_read_data(&ftdic, readbuf, sizeof(readbuf));
d0e2002d	250	}
b122ac4b	251
b122ac4b	252	#ifdef DEBUG
d0e2002d	253	DPRINTF("write: ");
	254	hexdump(writebuf, writepos-writebuf);
	255	DPRINTF("read: ");
	256	hexdump(readbuf, i);
b122ac4b	257	#endif
b122ac4b	258
d0e2002d	259	writepos = writebuf;
	260	} else {
	261	return ret;
	262	}
	263
	264	readpos = readbuf;
b122ac4b	265
	266	for (i = 0; i < num; i++) {
	267	DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
	268	(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
	269	tr[i].fAutoinc, tr[i].dwOptions);
	270
	271	port = (unsigned long)tr[i].dwPort;
	272	val = tr[i].Data.Byte;
d0e2002d	273	readpos++;
b122ac4b	274
d0e2002d	275	if (port == ppbase + PP_DATA) {
	276	if (tr[i].cmdTrans == PP_WRITE) {
	277	last_write = val;
	278	}
	279	} else if (port == ppbase + PP_STATUS) {
	280	DPRINTF("status port (last write: 0x%x)\n", last_write);
8121bc50	281	switch(tr[i].cmdTrans) {
8121bc50	282	case PP_READ:
d0e2002d	283	data = *readpos;
59b06a85	284
8121bc50	285	#ifdef DEBUG
	286	DPRINTF("READ: 0x%x\n", data);
	287	jtagkey_state(data);
	288	#endif
	289
	290	val = 0x00;
d0e2002d	291	if ((data & JTAGKEY_TDO) && (last_write & PP_PROG))
8121bc50	292	val \|= PP_TDO;
8121bc50	293
d0e2002d	294	if (!(last_write & PP_PROG))
	295	val \|= 0x08;
	296
8121bc50	297	if (last_write & 0x40)
	298	val \|= 0x20;
	299	else
	300	val \|= 0x80;
	301	break;
	302
	303	case PP_WRITE:
	304	ret = 0; /* Status Port is readonly */
	305	break;
	306
	307	default:
	308	fprintf(stderr,"!!!Unsupported TRANSFER command: %lu!!!\n", tr[i].cmdTrans);
	309	ret = -1;
	310	break;
	311	}
8121bc50	312	} else {
8121bc50	313	ret = 0;
	314	}
	315
	316	tr[i].Data.Byte = val;
	317
	318	DPRINTF("dwPortReturn: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
	319	(unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
	320	tr[i].fAutoinc, tr[i].dwOptions);
	321	#ifdef DEBUG
	322	if (tr[i].cmdTrans == 10)
	323	DPRINTF("read byte: %d\n", tr[i].Data.Byte);
	324	#endif
	325	}
	326
	327	return ret;
	328	}