build: cleanup src/jtag/drivers directory

Change-Id: I99c08ec0132d5a15250050e718310f1ddd9fe546
Signed-off-by: Spencer Oliver <spen@spen-soft.co.uk>
Reviewed-on: http://openocd.zylin.com/425
Tested-by: jenkins

1 files changed, 146 insertions, 152 deletions

diff --git a/src/jtag/drivers/presto.c b/src/jtag/drivers/presto.c
index 0de48ffd..28576a79 100644
--- a/src/jtag/drivers/presto.c
+++ b/src/jtag/drivers/presto.c
@@ -35,7 +35,6 @@
 #include <helper/time_support.h>
 #include "bitq.h"
 
-
 /* PRESTO access library includes */
 #if BUILD_PRESTO_FTD2XX == 1
 #include <ftd2xx.h>
@@ -72,16 +71,16 @@ struct presto {
 	int buff_out_pos;
 
 	uint8_t buff_in[BUFFER_SIZE];
-	int buff_in_exp; /* expected in buffer length */
-	int buff_in_len; /* length of data received */
+	int buff_in_exp;/* expected in buffer length */
+	int buff_in_len;/* length of data received */
 	int buff_in_pos;
 
 	unsigned long total_out;
 	unsigned long total_in;
 
-	int jtag_tms; /* last tms state */
-	int jtag_tck; /* last tck state */
-	int jtag_rst; /* last trst state */
+	int jtag_tms;	/* last tms state */
+	int jtag_tck;	/* last tck state */
+	int jtag_rst;	/* last trst state */
 
 	int jtag_tdi_data;
 	int jtag_tdi_count;
@@ -92,8 +91,7 @@ struct presto {
 static struct presto presto_state;
 static struct presto *presto = &presto_state;
 
-static uint8_t presto_init_seq[] =
-{
+static uint8_t presto_init_seq[] = {
 	0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
 };
 
@@ -101,38 +99,37 @@ static int presto_write(uint8_t *buf, uint32_t size)
 {
 #if BUILD_PRESTO_FTD2XX == 1
 	DWORD ftbytes;
-	if ((presto->status = FT_Write(presto->handle, buf, size, &ftbytes)) != FT_OK)
-	{
+	presto->status = FT_Write(presto->handle, buf, size, &ftbytes);
+	if (presto->status != FT_OK) {
 		LOG_ERROR("FT_Write returned: %s", ftd2xx_status_string(presto->status));
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 #elif BUILD_PRESTO_LIBFTDI == 1
 	uint32_t ftbytes;
-	if ((presto->retval = ftdi_write_data(&presto->ftdic, buf, size)) < 0)
-	{
+	presto->retval = ftdi_write_data(&presto->ftdic, buf, size);
+	if (presto->retval < 0) {
 		LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto->ftdic));
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 	ftbytes = presto->retval;
 #endif
 
-	if (ftbytes != size)
-	{
+	if (ftbytes != size) {
 		LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)",
-			  (unsigned)ftbytes, (unsigned)size);
+			(unsigned)ftbytes, (unsigned)size);
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 	return ERROR_OK;
 }
 
-static int presto_read(uint8_t* buf, uint32_t size)
+static int presto_read(uint8_t *buf, uint32_t size)
 {
 #if BUILD_PRESTO_FTD2XX == 1
 	DWORD ftbytes;
-	if ((presto->status = FT_Read(presto->handle, buf, size, &ftbytes)) != FT_OK)
-	{
+	presto->status = FT_Read(presto->handle, buf, size, &ftbytes);
+	if (presto->status != FT_OK) {
 		LOG_ERROR("FT_Read returned: %s", ftd2xx_status_string(presto->status));
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
@@ -142,28 +139,28 @@ static int presto_read(uint8_t* buf, uint32_t size)
 
 	struct timeval timeout, now;
 	gettimeofday(&timeout, NULL);
-	timeval_add_time(&timeout, 1, 0); /* one second timeout */
+	timeval_add_time(&timeout, 1, 0);	/* one second timeout */
 
-	while (ftbytes < size)
-	{
-		if ((presto->retval = ftdi_read_data(&presto->ftdic, buf + ftbytes, size - ftbytes)) < 0)
-		{
+	while (ftbytes < size) {
+		presto->retval = ftdi_read_data(&presto->ftdic, buf + ftbytes, size - ftbytes);
+		if (presto->retval < 0) {
 			LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto->ftdic));
 			return ERROR_JTAG_DEVICE_ERROR;
 		}
 		ftbytes += presto->retval;
 
 		gettimeofday(&now, NULL);
-		if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec > timeout.tv_usec)))
+		if ((now.tv_sec > timeout.tv_sec) ||
+				((now.tv_sec == timeout.tv_sec) && (now.tv_usec > timeout.tv_usec)))
 			break;
 	}
 #endif
 
-	if (ftbytes != size)
-	{
-		/* this is just a warning, there might have been timeout when detecting PRESTO, which is not fatal */
+	if (ftbytes != size) {
+		/* this is just a warning, there might have been timeout when detecting PRESTO,
+		 *which is not fatal */
 		LOG_WARNING("couldn't read the requested number of bytes from PRESTO (%u < %u)",
-			    (unsigned)ftbytes, (unsigned)size);
+			(unsigned)ftbytes, (unsigned)size);
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
@@ -186,39 +183,39 @@ static int presto_open_ftd2xx(char *req_serial)
 
 #if IS_WIN32 == 0
 	/* Add non-standard Vid/Pid to the linux driver */
-	if ((presto->status = FT_SetVIDPID(PRESTO_VID, PRESTO_PID)) != FT_OK)
-	{
+	presto->status = FT_SetVIDPID(PRESTO_VID, PRESTO_PID);
+	if (presto->status != FT_OK) {
 		LOG_ERROR("couldn't add PRESTO VID/PID");
 		exit(-1);
 	}
 #endif
 
-	if ((presto->status = FT_ListDevices(&numdevs, NULL, FT_LIST_NUMBER_ONLY)) != FT_OK)
-	{
+	presto->status = FT_ListDevices(&numdevs, NULL, FT_LIST_NUMBER_ONLY);
+	if (presto->status != FT_OK) {
 		LOG_ERROR("FT_ListDevices failed: %s", ftd2xx_status_string(presto->status));
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 	LOG_DEBUG("FTDI devices available: %" PRIu32, (uint32_t)numdevs);
-	for (i = 0; i < numdevs; i++)
-	{
-		if ((presto->status = FT_Open(i, &(presto->handle))) != FT_OK)
-		{
-			/* this is not fatal, the device may be legitimately open by other process, hence debug message only */
+	for (i = 0; i < numdevs; i++) {
+		presto->status = FT_Open(i, &(presto->handle));
+		if (presto->status != FT_OK) {
+			/* this is not fatal, the device may be legitimately open by other process,
+			 *hence debug message only */
 			LOG_DEBUG("FT_Open failed: %s", ftd2xx_status_string(presto->status));
 			continue;
 		}
 		LOG_DEBUG("FTDI device %i open", (int)i);
 
-		if ((presto->status = FT_GetDeviceInfo(presto->handle, &device, &vidpid,
-				presto->serial, devname, NULL)) == FT_OK)
-		{
-			if (vidpid == PRESTO_VID_PID
-					&& (req_serial == NULL || !strcmp(presto->serial, req_serial)))
+		presto->status = FT_GetDeviceInfo(presto->handle, &device,
+				&vidpid, presto->serial, devname, NULL);
+		if (presto->status == FT_OK) {
+			if (vidpid == PRESTO_VID_PID && (req_serial == NULL ||
+					!strcmp(presto->serial, req_serial)))
 				break;
-		}
-		else
-			LOG_DEBUG("FT_GetDeviceInfo failed: %s", ftd2xx_status_string(presto->status));
+		} else
+			LOG_DEBUG("FT_GetDeviceInfo failed: %s", ftd2xx_status_string(
+					presto->status));
 
 		LOG_DEBUG("FTDI device %i does not match, closing", (int)i);
 		FT_Close(presto->handle);
@@ -226,74 +223,87 @@ static int presto_open_ftd2xx(char *req_serial)
 	}
 
 	if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE)
-		return ERROR_JTAG_DEVICE_ERROR; /* presto not open, return */
+		return ERROR_JTAG_DEVICE_ERROR;	/* presto not open, return */
 
-	if ((presto->status = FT_SetLatencyTimer(presto->handle, 1)) != FT_OK)
+	presto->status = FT_SetLatencyTimer(presto->handle, 1);
+	if (presto->status != FT_OK)
 		return ERROR_JTAG_DEVICE_ERROR;
 
-
-	if ((presto->status = FT_SetTimeouts(presto->handle, 100, 0)) != FT_OK)
+	presto->status = FT_SetTimeouts(presto->handle, 100, 0);
+	if (presto->status != FT_OK)
 		return ERROR_JTAG_DEVICE_ERROR;
 
-	if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
+	presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
+	if (presto->status != FT_OK)
 		return ERROR_JTAG_DEVICE_ERROR;
 
 	presto_data = 0xD0;
-	if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
+	presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes);
+	if (presto->status != FT_OK)
 		return ERROR_JTAG_DEVICE_ERROR;
 
-	/* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
-	   probably a bug in library threading */
+	/* delay between first write/read turnaround (after purge?) necessary
+	 * under Linux for unknown reason,
+	 * probably a bug in library threading */
 	usleep(100000);
-	if ((presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
+	presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes);
+	if (presto->status != FT_OK)
 		return ERROR_JTAG_DEVICE_ERROR;
 
-	if (ftbytes != 1)
-	{
+	if (ftbytes != 1) {
 		LOG_DEBUG("PRESTO reset");
 
-		if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
+		presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
+		if (presto->status != FT_OK)
 			return ERROR_JTAG_DEVICE_ERROR;
-		if ((presto->status = FT_SetBitMode(presto->handle, 0x80, 1)) != FT_OK)
+		presto->status = FT_SetBitMode(presto->handle, 0x80, 1);
+		if (presto->status != FT_OK)
 			return ERROR_JTAG_DEVICE_ERROR;
-		if ((presto->status = FT_SetBaudRate(presto->handle, 9600)) != FT_OK)
+		presto->status = FT_SetBaudRate(presto->handle, 9600);
+		if (presto->status != FT_OK)
 			return ERROR_JTAG_DEVICE_ERROR;
 
 		presto_data = 0;
-		for (i = 0; i < 4 * 62; i++)
-			if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
+		for (i = 0; i < 4 * 62; i++) {
+			presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes);
+			if (presto->status != FT_OK)
 				return ERROR_JTAG_DEVICE_ERROR;
-
+		}
 		usleep(100000);
 
-		if ((presto->status = FT_SetBitMode(presto->handle, 0x00, 0)) != FT_OK)
+		presto->status = FT_SetBitMode(presto->handle, 0x00, 0);
+		if (presto->status != FT_OK)
 			return ERROR_JTAG_DEVICE_ERROR;
 
-		if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
+		presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
+		if (presto->status != FT_OK)
 			return ERROR_JTAG_DEVICE_ERROR;
 
 		presto_data = 0xD0;
-		if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
+		presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes);
+		if (presto->status != FT_OK)
 			return ERROR_JTAG_DEVICE_ERROR;
 
 		/* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
 		   probably a bug in library threading */
 		usleep(100000);
-		if ((presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
+		presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes);
+		if (presto->status != FT_OK)
 			return ERROR_JTAG_DEVICE_ERROR;
 
-		if (ftbytes != 1)
-		{
+		if (ftbytes != 1) {
 			LOG_DEBUG("PRESTO not responding");
 			return ERROR_JTAG_DEVICE_ERROR;
 		}
 	}
 
-	if ((presto->status = FT_SetTimeouts(presto->handle, 0, 0)) != FT_OK)
+	presto->status = FT_SetTimeouts(presto->handle, 0, 0);
+	if (presto->status != FT_OK)
 		return ERROR_JTAG_DEVICE_ERROR;
 
+	presto->status = FT_Write(presto->handle, &presto_init_seq,
+			sizeof(presto_init_seq), &ftbytes);
 
-	presto->status = FT_Write(presto->handle, &presto_init_seq, sizeof(presto_init_seq), &ftbytes);
 	if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq))
 		return ERROR_JTAG_DEVICE_ERROR;
 
@@ -308,46 +318,39 @@ static int presto_open_libftdi(char *req_serial)
 	LOG_DEBUG("searching for PRESTO using libftdi");
 
 	/* initialize FTDI context structure */
-	if (ftdi_init(&presto->ftdic) < 0)
-	{
+	if (ftdi_init(&presto->ftdic) < 0) {
 		LOG_ERROR("unable to init libftdi: %s", presto->ftdic.error_str);
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 	/* context, vendor id, product id */
-	if (ftdi_usb_open_desc(&presto->ftdic, PRESTO_VID, PRESTO_PID, NULL, req_serial) < 0)
-	{
+	if (ftdi_usb_open_desc(&presto->ftdic, PRESTO_VID, PRESTO_PID, NULL, req_serial) < 0) {
 		LOG_ERROR("unable to open PRESTO: %s", presto->ftdic.error_str);
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
-	if (ftdi_usb_reset(&presto->ftdic) < 0)
-	{
+	if (ftdi_usb_reset(&presto->ftdic) < 0) {
 		LOG_ERROR("unable to reset PRESTO device");
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
-	if (ftdi_set_latency_timer(&presto->ftdic, 1) < 0)
-	{
+	if (ftdi_set_latency_timer(&presto->ftdic, 1) < 0) {
 		LOG_ERROR("unable to set latency timer");
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
-	if (ftdi_usb_purge_buffers(&presto->ftdic) < 0)
-	{
+	if (ftdi_usb_purge_buffers(&presto->ftdic) < 0) {
 		LOG_ERROR("unable to purge PRESTO buffers");
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 	presto_data = 0xD0;
-	if (presto_write(&presto_data, 1) != ERROR_OK)
-	{
+	if (presto_write(&presto_data, 1) != ERROR_OK) {
 		LOG_ERROR("error writing to PRESTO");
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
-	if (presto_read(&presto_data, 1) != ERROR_OK)
-	{
+	if (presto_read(&presto_data, 1) != ERROR_OK) {
 		LOG_DEBUG("no response from PRESTO, retrying");
 
 		if (ftdi_usb_purge_buffers(&presto->ftdic) < 0)
@@ -357,22 +360,20 @@ static int presto_open_libftdi(char *req_serial)
 		if (presto_write(&presto_data, 1) != ERROR_OK)
 			return ERROR_JTAG_DEVICE_ERROR;
 
-		if (presto_read(&presto_data, 1) != ERROR_OK)
-		{
+		if (presto_read(&presto_data, 1) != ERROR_OK) {
 			LOG_ERROR("no response from PRESTO, giving up");
 			return ERROR_JTAG_DEVICE_ERROR;
 		}
 	}
 
-	if (presto_write(presto_init_seq, sizeof(presto_init_seq)) != ERROR_OK)
-	{
+	if (presto_write(presto_init_seq, sizeof(presto_init_seq)) != ERROR_OK) {
 		LOG_ERROR("error writing PRESTO init sequence");
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 	return ERROR_OK;
 }
-#endif /* BUILD_PRESTO_LIBFTDI == 1 */
+#endif	/* BUILD_PRESTO_LIBFTDI == 1 */
 
 static int presto_open(char *req_serial)
 {
@@ -414,27 +415,35 @@ static int presto_close(void)
 	if (presto->status != FT_OK)
 		result = ERROR_JTAG_DEVICE_ERROR;
 
-	presto->status = FT_Write(presto->handle, &presto_init_seq, sizeof(presto_init_seq), &ftbytes);
+	presto->status = FT_Write(presto->handle,
+			&presto_init_seq,
+			sizeof(presto_init_seq),
+			&ftbytes);
 	if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq))
 		result = ERROR_JTAG_DEVICE_ERROR;
 
-	if ((presto->status = FT_SetLatencyTimer(presto->handle, 16)) != FT_OK)
+	presto->status = FT_SetLatencyTimer(presto->handle, 16);
+	if (presto->status != FT_OK)
 		result = ERROR_JTAG_DEVICE_ERROR;
 
-	if ((presto->status = FT_Close(presto->handle)) != FT_OK)
+	presto->status = FT_Close(presto->handle);
+	if (presto->status != FT_OK)
 		result = ERROR_JTAG_DEVICE_ERROR;
 	else
 		presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
 
 #elif BUILD_PRESTO_LIBFTDI == 1
 
-	if ((presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq))) != sizeof(presto_init_seq))
+	presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq));
+	if (presto->retval != sizeof(presto_init_seq))
 		result = ERROR_JTAG_DEVICE_ERROR;
 
-	if ((presto->retval = ftdi_set_latency_timer(&presto->ftdic, 16)) < 0)
+	presto->retval = ftdi_set_latency_timer(&presto->ftdic, 16);
+	if (presto->retval < 0)
 		result = ERROR_JTAG_DEVICE_ERROR;
 
-	if ((presto->retval = ftdi_usb_close(&presto->ftdic)) < 0)
+	presto->retval = ftdi_usb_close(&presto->ftdic);
+	if (presto->retval < 0)
 		result = ERROR_JTAG_DEVICE_ERROR;
 	else
 		ftdi_deinit(&presto->ftdic);
@@ -449,17 +458,15 @@ static int presto_flush(void)
 		return ERROR_OK;
 
 #if BUILD_PRESTO_FTD2XX == 1
-	if (presto->status != FT_OK)
+	if (presto->status != FT_OK) {
 #elif BUILD_PRESTO_LIBFTDI == 1
-	if (presto->retval < 0)
+	if (presto->retval < 0) {
 #endif
-	{
 		LOG_DEBUG("error in previous communication, canceling I/O operation");
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
-	if (presto_write(presto->buff_out, presto->buff_out_pos) != ERROR_OK)
-	{
+	if (presto_write(presto->buff_out, presto->buff_out_pos) != ERROR_OK) {
 		presto->buff_out_pos = 0;
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
@@ -473,8 +480,7 @@ static int presto_flush(void)
 	presto->buff_in_pos = 0;
 	presto->buff_in_len = 0;
 
-	if (presto_read(presto->buff_in, presto->buff_in_exp) != ERROR_OK)
-	{
+	if (presto_read(presto->buff_in, presto->buff_in_exp) != ERROR_OK) {
 		presto->buff_in_exp = 0;
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
@@ -488,21 +494,21 @@ static int presto_flush(void)
 
 static int presto_sendbyte(int data)
 {
-	if (data == EOF) return presto_flush();
+	if (data == EOF)
+		return presto_flush();
 
-	if (presto->buff_out_pos < BUFFER_SIZE)
-	{
+	if (presto->buff_out_pos < BUFFER_SIZE) {
 		presto->buff_out[presto->buff_out_pos++] = (uint8_t)data;
-		if (((data & 0xC0) == 0x40) || ((data & 0xD0)== 0xD0))
+		if (((data & 0xC0) == 0x40) || ((data & 0xD0) == 0xD0))
 			presto->buff_in_exp++;
-	}
-	else
+	} else
 		return ERROR_JTAG_DEVICE_ERROR;
 
 #if BUILD_PRESTO_FTD2XX == 1
 	if (presto->buff_out_pos >= BUFFER_SIZE)
 #elif BUILD_PRESTO_LIBFTDI == 1
-	/* libftdi does not do background read, be sure that USB IN buffer does not overflow (128 bytes only!) */
+	/* libftdi does not do background read, be sure that USB IN buffer does not overflow (128
+	 *bytes only!) */
 	if (presto->buff_out_pos >= BUFFER_SIZE || presto->buff_in_exp == 128)
 #endif
 		return presto_flush();
@@ -536,8 +542,7 @@ static int presto_tdi_flush(void)
 	if (presto->jtag_tdi_count == 0)
 		return 0;
 
-	if (presto->jtag_tck == 0)
-	{
+	if (presto->jtag_tck == 0) {
 		LOG_ERROR("BUG: unexpected TAP condition, TCK low");
 		return -1;
 	}
@@ -552,8 +557,7 @@ static int presto_tdi_flush(void)
 
 static int presto_tck_idle(void)
 {
-	if (presto->jtag_tck == 1)
-	{
+	if (presto->jtag_tck == 1) {
 		presto_sendbyte(0xCA);
 		presto->jtag_tck = 0;
 	}
@@ -569,11 +573,8 @@ static int presto_bitq_out(int tms, int tdi, int tdo_req)
 	unsigned char cmd;
 
 	if (presto->jtag_tck == 0)
-	{
-		presto_sendbyte(0xA4); /* LED idicator - JTAG active */
-	}
-	else if (presto->jtag_speed == 0 && !tdo_req && tms == presto->jtag_tms)
-	{
+		presto_sendbyte(0xA4);	/* LED idicator - JTAG active */
+	else if (presto->jtag_speed == 0 && !tdo_req && tms == presto->jtag_tms) {
 		presto->jtag_tdi_data |= (tdi != 0) << presto->jtag_tdi_count;
 
 		if (++presto->jtag_tdi_count == 4)
@@ -587,8 +588,7 @@ static int presto_bitq_out(int tms, int tdi, int tdo_req)
 	cmd = tdi ? 0xCB : 0xCA;
 	presto_sendbyte(cmd);
 
-	if (tms != presto->jtag_tms)
-	{
+	if (tms != presto->jtag_tms) {
 		presto_sendbyte((tms ? 0xEC : 0xE8) | (presto->jtag_rst ? 0x02 : 0));
 		presto->jtag_tms = tms;
 	}
@@ -614,7 +614,7 @@ static int presto_bitq_flush(void)
 	presto_tdi_flush();
 	presto_tck_idle();
 
-	presto_sendbyte(0xA0); /* LED idicator - JTAG idle */
+	presto_sendbyte(0xA0);	/* LED idicator - JTAG idle */
 
 	return presto_flush();
 }
@@ -630,7 +630,8 @@ static int presto_bitq_in(void)
 {
 	if (presto->buff_in_pos >= presto->buff_in_len)
 		return -1;
-	if (presto->buff_in[presto->buff_in_pos++]&0x08) return 1;
+	if (presto->buff_in[presto->buff_in_pos++]&0x08)
+		return 1;
 	return 0;
 }
 
@@ -641,8 +642,7 @@ static int presto_bitq_sleep(unsigned long us)
 	presto_tdi_flush();
 	presto_tck_idle();
 
-	if (us > 100000)
-	{
+	if (us > 100000) {
 		presto_bitq_flush();
 		jtag_sleep(us);
 		return 0;
@@ -671,40 +671,42 @@ static int presto_bitq_reset(int trst, int srst)
 }
 
 static struct bitq_interface presto_bitq = {
-		.out = &presto_bitq_out,
-		.flush = &presto_bitq_flush,
-		.sleep = &presto_bitq_sleep,
-		.reset = &presto_bitq_reset,
-		.in_rdy = &presto_bitq_in_rdy,
-		.in = &presto_bitq_in,
-	};
+	.out = &presto_bitq_out,
+	.flush = &presto_bitq_flush,
+	.sleep = &presto_bitq_sleep,
+	.reset = &presto_bitq_reset,
+	.in_rdy = &presto_bitq_in_rdy,
+	.in = &presto_bitq_in,
+};
 
 /* -------------------------------------------------------------------------- */
 
 static int presto_adapter_khz(int khz, int *jtag_speed)
 {
-	if (khz < 0)
-	{
+	if (khz < 0) {
 		*jtag_speed = 0;
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	if (khz >= 3000) *jtag_speed = 0;
-	else *jtag_speed = (1000 + khz-1)/khz;
+	if (khz >= 3000)
+		*jtag_speed = 0;
+	else
+		*jtag_speed = (1000 + khz-1)/khz;
 
 	return 0;
 }
 
 static int presto_jtag_speed_div(int speed, int *khz)
 {
-	if ((speed < 0) || (speed > 1000))
-	{
+	if ((speed < 0) || (speed > 1000)) {
 		*khz = 0;
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	if (speed == 0) *khz = 3000;
-	else *khz = 1000/speed;
+	if (speed == 0)
+		*khz = 3000;
+	else
+		*khz = 1000/speed;
 
 	return 0;
 }
@@ -714,9 +716,7 @@ static int presto_jtag_speed(int speed)
 	int khz;
 
 	if (presto_jtag_speed_div(speed, &khz))
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 
 	presto->jtag_speed = speed;
 
@@ -732,16 +732,12 @@ static char *presto_serial;
 
 COMMAND_HANDLER(presto_handle_serial_command)
 {
-	if (CMD_ARGC == 1)
-	{
+	if (CMD_ARGC == 1) {
 		if (presto_serial)
 			free(presto_serial);
 		presto_serial = strdup(CMD_ARGV[0]);
-	}
-	else
-	{
-	    return ERROR_COMMAND_SYNTAX_ERROR;
-	}
+	} else
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	return ERROR_OK;
 }
@@ -759,8 +755,7 @@ static const struct command_registration presto_command_handlers[] = {
 
 static int presto_jtag_init(void)
 {
-	if (presto_open(presto_serial) != ERROR_OK)
-	{
+	if (presto_open(presto_serial) != ERROR_OK) {
 		presto_close();
 		if (presto_serial != NULL)
 			LOG_ERROR("Cannot open PRESTO, serial number '%s'", presto_serial);
@@ -780,8 +775,7 @@ static int presto_jtag_quit(void)
 	presto_close();
 	LOG_INFO("PRESTO closed");
 
-	if (presto_serial)
-	{
+	if (presto_serial) {
 		free(presto_serial);
 		presto_serial = NULL;
 	}