X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fpresto.c;h=d9661fc41f6afb1bc15760920d847aaca3c9836a;hp=624f1c7afcd74f51b77646e543599ec64aaa0c96;hb=d47e1b8f362379d8a2307f49e2b42115a3f40524;hpb=2c5fc392f019e78ae858ffd761bcb859f898ff53

diff --git a/src/jtag/presto.c b/src/jtag/presto.c
index 624f1c7afc..d9661fc41f 100644
--- a/src/jtag/presto.c
+++ b/src/jtag/presto.c
@@ -23,7 +23,6 @@
 
 #if IS_CYGWIN == 1
 #include "windows.h"
-#undef ERROR
 #endif
 
 #include "replacements.h"
@@ -49,6 +48,8 @@
 #include <ftd2xx.h>
 #elif BUILD_PRESTO_LIBFTDI == 1
 #include <ftdi.h>
+#else
+#error "BUG: either FTD2XX and LIBFTDI has to be used"
 #endif
 
 
@@ -107,7 +108,7 @@ typedef struct presto_s
 	struct ftdi_context ftdic;
 	int retval;
 #endif
-	
+
 	char serial[FT_DEVICE_SERNUM_LEN];
 
 	u8 buff_out[BUFFER_SIZE];
@@ -137,76 +138,74 @@ u8 presto_init_seq[] =
 	0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
 };
 
-int presto_write(u8 *buf, int size, u32* bytes_written)
+int presto_write(u8 *buf, int size)
 {
 #if BUILD_PRESTO_FTD2XX == 1
-	DWORD dw_bytes_written;
-	if ((presto->status = FT_Write(presto->handle, buf, size, &dw_bytes_written)) != FT_OK)
+	DWORD ftbytes;
+	if ((presto->status = FT_Write(presto->handle, buf, size, &ftbytes)) != FT_OK)
 	{
-		*bytes_written = dw_bytes_written;
-		ERROR("FT_Write returned: %lu", presto->status);
+		LOG_ERROR("FT_Write returned: %lu", presto->status);
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
-	else
-	{
-		*bytes_written = dw_bytes_written;
-		return ERROR_OK;	
-	}
+
 #elif BUILD_PRESTO_LIBFTDI == 1
+	u32 ftbytes;
 	if ((presto->retval = ftdi_write_data(&presto->ftdic, buf, size)) < 0)
 	{
-		*bytes_written = 0;
-		ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto->ftdic));
+		LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto->ftdic));
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
-	else
+	ftbytes = presto->retval;
+#endif
+
+	if (ftbytes != size)
 	{
-		*bytes_written = presto->retval; /* FIXME: Correct? */
-		return ERROR_OK;	
+		LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%i < %i)", ftbytes, size);
+		return ERROR_JTAG_DEVICE_ERROR;
 	}
-#endif
+
+	return ERROR_OK;
 }
 
-int presto_read(u8* buf, int size, u32* bytes_read)
+int presto_read(u8* buf, int size)
 {
 #if BUILD_PRESTO_FTD2XX == 1
-	DWORD dw_bytes_read;
-	int timeout = 5;
-	*bytes_read = 0;
-
-	while ((*bytes_read < size) && timeout--)
+	DWORD ftbytes;
+	if ((presto->status = FT_Read(presto->handle, buf, size, &ftbytes)) != FT_OK)
 	{
-		if ((presto->status = FT_Read(presto->handle, buf + *bytes_read, size - 
-			*bytes_read, &dw_bytes_read)) != FT_OK)		
-		{
-			*bytes_read = 0; 
-			ERROR("FT_Read returned: %lu", presto->status);
-			return ERROR_JTAG_DEVICE_ERROR;
-		}
-		*bytes_read += dw_bytes_read; 
+		LOG_ERROR("FT_Read returned: %lu", presto->status);
+		return ERROR_JTAG_DEVICE_ERROR;
 	}
+
 #elif BUILD_PRESTO_LIBFTDI == 1
-	int timeout = 100;
-	*bytes_read = 0;
-	
-	while ((*bytes_read < size) && timeout--)
+	u32 ftbytes = 0;
+
+	struct timeval timeout, now;
+	gettimeofday(&timeout, NULL);
+	timeval_add_time(&timeout, 1, 0); /* one second timeout */
+
+	while (ftbytes < size)
 	{
-		if ((presto->retval = ftdi_read_data(&presto->ftdic, buf + *bytes_read, size - *bytes_read)) < 0)
+		if ((presto->retval = ftdi_read_data(&presto->ftdic, buf + ftbytes, size - ftbytes)) < 0)
 		{
-			*bytes_read = 0;
-			ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto->ftdic));
+			LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto->ftdic));
 			return ERROR_JTAG_DEVICE_ERROR;
 		}
-		*bytes_read += presto->retval; /* FIXME: Correct? */
+		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)))
+			break;
 	}
 #endif
 
-	if (*bytes_read < size)
+	if (ftbytes != size)
 	{
-		ERROR("couldn't read the requested number of bytes from PRESTO (%i < %i)", *bytes_read, 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 (%i < %i)", ftbytes, size);
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
-	
+
 	return ERROR_OK;
 }
 
@@ -220,98 +219,122 @@ int presto_open_ftd2xx(char *req_serial)
 	FT_DEVICE device;
 
 	BYTE presto_data;
-	unsigned long ftbytes;
+	DWORD ftbytes;
 
 	presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
-	
+
 #if IS_WIN32 == 0
 	/* Add non-standard Vid/Pid to the linux driver */
 	if ((presto->status = FT_SetVIDPID(PRESTO_VID, PRESTO_PID)) != FT_OK)
 	{
-		ERROR("couldn't add PRESTO VID/PID");
+		LOG_ERROR("couldn't add PRESTO VID/PID");
 		exit(-1);
 	}
 #endif
 
 	if ((presto->status = FT_ListDevices(&numdevs, NULL, FT_LIST_NUMBER_ONLY)) != FT_OK)
 	{
-		ERROR("FT_ListDevices failed: %i", (int)presto->status);
-		return ERROR_JTAG_INIT_FAILED;
+		LOG_ERROR("FT_ListDevices failed: %i", (int)presto->status);
+		return ERROR_JTAG_DEVICE_ERROR;
 	}
-	
+
+	LOG_DEBUG("FTDI devices available: %i", numdevs);
 	for (i = 0; i < numdevs; i++)
 	{
-		if (FT_Open(i, &(presto->handle)) != FT_OK)
+		if ((presto->status = FT_Open(i, &(presto->handle))) != FT_OK)
 		{
-			ERROR("FT_Open failed: %i", (int)presto->status);
+			/* this is not fatal, the device may be legitimately open by other process, hence debug message only */
+			LOG_DEBUG("FT_Open failed: %i", (int)presto->status);
 			continue;
 		}
-			
-		if (FT_GetDeviceInfo(presto->handle, &device, &vidpid,
-				presto->serial, devname, NULL) == FT_OK)
+		LOG_DEBUG("FTDI device %i open", 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)))
 				break;
 		}
-		
+		else
+			LOG_DEBUG("FT_GetDeviceInfo failed: %i", presto->status);
+
+		LOG_DEBUG("FTDI device %i does not match, closing", i);
 		FT_Close(presto->handle);
 		presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
 	}
 
 	if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE)
-		return ERROR_JTAG_INIT_FAILED;
+		return ERROR_JTAG_DEVICE_ERROR; /* presto not open, return */
+
 	if ((presto->status = FT_SetLatencyTimer(presto->handle, 1)) != FT_OK)
-		return ERROR_JTAG_INIT_FAILED;
+		return ERROR_JTAG_DEVICE_ERROR;
+
+
 	if ((presto->status = FT_SetTimeouts(presto->handle, 100, 0)) != FT_OK)
-		return ERROR_JTAG_INIT_FAILED;
+		return ERROR_JTAG_DEVICE_ERROR;
+
 	if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
-		return ERROR_JTAG_INIT_FAILED;
+		return ERROR_JTAG_DEVICE_ERROR;
 
 	presto_data = 0xD0;
 	if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
-		return ERROR_JTAG_INIT_FAILED;
+		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)
-		return ERROR_JTAG_INIT_FAILED;
+		return ERROR_JTAG_DEVICE_ERROR;
 
 	if (ftbytes!=1)
 	{
-		if ((presto->status = FT_SetBitMode(presto->handle, 0x80, 1)) != FT_OK)
-			return ERROR_JTAG_INIT_FAILED;
+		LOG_DEBUG("PRESTO reset");
+
 		if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
-			return ERROR_JTAG_INIT_FAILED ;
+			return ERROR_JTAG_DEVICE_ERROR;
+		if ((presto->status = FT_SetBitMode(presto->handle, 0x80, 1)) != FT_OK)
+			return ERROR_JTAG_DEVICE_ERROR;
 		if ((presto->status = FT_SetBaudRate(presto->handle, 9600)) != FT_OK)
-			return ERROR_JTAG_INIT_FAILED;
+			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)
-				return ERROR_JTAG_INIT_FAILED;
+				return ERROR_JTAG_DEVICE_ERROR;
 
 		usleep(100000);
 
 		if ((presto->status = FT_SetBitMode(presto->handle, 0x00, 0)) != FT_OK)
-			return ERROR_JTAG_INIT_FAILED;
+			return ERROR_JTAG_DEVICE_ERROR;
+
 		if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
-			return ERROR_JTAG_INIT_FAILED;
+			return ERROR_JTAG_DEVICE_ERROR;
 
 		presto_data = 0xD0;
 		if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
-			return ERROR_JTAG_INIT_FAILED;
+			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)
-			return ERROR_JTAG_INIT_FAILED;
+			return ERROR_JTAG_DEVICE_ERROR;
+
 		if (ftbytes!=1)
-			return ERROR_JTAG_INIT_FAILED;
+		{
+			LOG_DEBUG("PRESTO not responding");
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
 	}
 
 	if ((presto->status = FT_SetTimeouts(presto->handle, 0, 0)) != FT_OK)
-		return ERROR_JTAG_INIT_FAILED;
+		return ERROR_JTAG_DEVICE_ERROR;
+
 
 	presto->status = FT_Write(presto->handle, &presto_init_seq, sizeof(presto_init_seq), &ftbytes);
-	if (presto->status != FT_OK)
-		return ERROR_JTAG_INIT_FAILED;
-	if (ftbytes != sizeof(presto_init_seq))
-		return ERROR_JTAG_INIT_FAILED;
+	if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq))
+		return ERROR_JTAG_DEVICE_ERROR;
 
 	return ERROR_OK;
 }
@@ -320,41 +343,72 @@ int presto_open_ftd2xx(char *req_serial)
 int presto_open_libftdi(char *req_serial)
 {
 	u8 presto_data;
-	u32 ftbytes;
-		
-	DEBUG("searching for presto JTAG interface using libftdi");
+
+	LOG_DEBUG("searching for PRESTO using libftdi");
+
+	/* initialize FTDI context structure */
+	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)
 	{
-		ERROR("unable to open presto: %s", presto->ftdic.error_str);
-		return ERROR_JTAG_INIT_FAILED;
+		LOG_ERROR("unable to open PRESTO: %s", presto->ftdic.error_str);
+		return ERROR_JTAG_DEVICE_ERROR;
 	}
-	
+
 	if (ftdi_usb_reset(&presto->ftdic) < 0)
 	{
-		ERROR("unable to reset presto device");
-		return ERROR_JTAG_INIT_FAILED;
+		LOG_ERROR("unable to reset PRESTO device");
+		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 	if (ftdi_set_latency_timer(&presto->ftdic, 1) < 0)
 	{
-		ERROR("unable to set latency timer");
-		return ERROR_JTAG_INIT_FAILED;
+		LOG_ERROR("unable to set latency timer");
+		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 	if (ftdi_usb_purge_buffers(&presto->ftdic) < 0)
 	{
-		ERROR("unable to purge presto buffer");
-		return ERROR_JTAG_INIT_FAILED;
+		LOG_ERROR("unable to purge PRESTO buffers");
+		return ERROR_JTAG_DEVICE_ERROR;
 	}
-	
+
 	presto_data = 0xD0;
-	if ((presto->retval = presto_write(&presto_data, 1, &ftbytes)) != ERROR_OK)
-		return ERROR_JTAG_INIT_FAILED;
-	if ((presto->retval = presto_read(&presto_data, 1, &ftbytes)) != ERROR_OK)
-		return ERROR_JTAG_INIT_FAILED;
-	
+	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)
+	{
+		LOG_DEBUG("no response from PRESTO, retrying");
+
+		if (ftdi_usb_purge_buffers(&presto->ftdic) < 0)
+			return ERROR_JTAG_DEVICE_ERROR;
+
+		presto_data = 0xD0;
+		if (presto_write(&presto_data, 1) != ERROR_OK)
+			return ERROR_JTAG_DEVICE_ERROR;
+
+		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)
+	{
+		LOG_ERROR("error writing PRESTO init sequence");
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
 	return ERROR_OK;
 }
 #endif /* BUILD_PRESTO_LIBFTDI == 1 */
@@ -386,40 +440,40 @@ int presto_close(void)
 
 	int result = ERROR_OK;
 
-#if BUID_PRESTO_FTD2XX == 1
+#if BUILD_PRESTO_FTD2XX == 1
 	unsigned long ftbytes;
 
 	if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE)
 		return result;
 
-	presto->status = FT_Write(presto->handle, &presto_init_seq, sizeof(presto_init_seq), &ftbytes);
+	presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
 	if (presto->status != FT_OK)
-		result = PRST_ERR;
-	if (ftbytes != sizeof(presto_init_seq))
-		result = PRST_TIMEOUT;
+		result = ERROR_JTAG_DEVICE_ERROR;
+
+	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)
-		result = PRST_ERR;
+		result = ERROR_JTAG_DEVICE_ERROR;
 
 	if ((presto->status = FT_Close(presto->handle)) != FT_OK)
-		result = PRST_ERR;
+		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))) < 0)
-	{
+
+	if ((presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq))) != sizeof(presto_init_seq))
 		result = ERROR_JTAG_DEVICE_ERROR;
-	}
-	
+
 	if ((presto->retval = ftdi_set_latency_timer(&presto->ftdic, 16)) < 0)
-	{
 		result = ERROR_JTAG_DEVICE_ERROR;
-	}
-	
-	ftdi_deinit(&presto->ftdic);
-	
+
+	if ((presto->retval = ftdi_usb_close(&presto->ftdic)) < 0)
+		result = ERROR_JTAG_DEVICE_ERROR;
+	else
+		ftdi_deinit(&presto->ftdic);
 #endif
 
 	return result;
@@ -428,33 +482,26 @@ int presto_close(void)
 
 int presto_flush(void)
 {
-	u32 ftbytes;
-
 	if (presto->buff_out_pos == 0)
 		return ERROR_OK;
 
 #if BUILD_PRESTO_FTD2XX == 1
 	if (presto->status != FT_OK)
 #elif BUILD_PRESTO_LIBFTDI == 1
-	if (presto->retval != ERROR_OK)
+	if (presto->retval < 0)
 #endif
-		return ERROR_JTAG_DEVICE_ERROR;
-
-
-	if (presto_write(presto->buff_out, presto->buff_out_pos, &ftbytes) != ERROR_OK)
 	{
-		presto->buff_out_pos = 0;
+		LOG_DEBUG("error in previous communication, canceling I/O operation");
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
-	presto->total_out += ftbytes;
-
-	if (presto->buff_out_pos != ftbytes)
+	if (presto_write(presto->buff_out, presto->buff_out_pos) != ERROR_OK)
 	{
 		presto->buff_out_pos = 0;
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
+	presto->total_out += presto->buff_out_pos;
 	presto->buff_out_pos = 0;
 
 	if (presto->buff_in_exp == 0)
@@ -463,20 +510,13 @@ int presto_flush(void)
 	presto->buff_in_pos = 0;
 	presto->buff_in_len = 0;
 
-	if (presto_read(presto->buff_in, presto->buff_in_exp, &ftbytes) != ERROR_OK)
-	{
-		presto->buff_in_exp = 0;
-		return ERROR_JTAG_DEVICE_ERROR;
-	}
-
-	presto->total_in += ftbytes;
-
-	if (ftbytes != presto->buff_in_exp)
+	if (presto_read(presto->buff_in, presto->buff_in_exp) != ERROR_OK)
 	{
 		presto->buff_in_exp = 0;
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
+	presto->total_in += presto->buff_in_exp;
 	presto->buff_in_len = presto->buff_in_exp;
 	presto->buff_in_exp = 0;
 
@@ -497,9 +537,14 @@ int presto_sendbyte(int data)
 	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!) */
+	if (presto->buff_out_pos >= BUFFER_SIZE || presto->buff_in_exp==128)
+#endif
 		return presto_flush();
-	
+
 	return ERROR_OK;
 }
 
@@ -511,7 +556,7 @@ int presto_getbyte(void)
 
 	if (presto->buff_in_exp == 0)
 		return -1;
-	
+
 	if (presto_flush() != ERROR_OK)
 		return -1;
 
@@ -541,7 +586,7 @@ int presto_bitq_out(int tms, int tdi, int tdo_req)
 			presto->jtag_tdi_data = (tdi != 0);
 		else
 			presto->jtag_tdi_data |= (tdi != 0) << presto->jtag_tdi_count;
-		
+
 		if (++presto->jtag_tdi_count == 4)
 		{
 			presto->jtag_tdi_data |= (presto->jtag_tdi_count - 1) << 4;
@@ -668,12 +713,12 @@ int presto_jtag_speed(int speed)
 
 	if ((speed < 0) || (speed > 3))
 	{
-		INFO("valid speed values: 0 (3 MHz), 1 (1.5 MHz), 2 (750 kHz) and 3 (93.75 kHz)");
+		LOG_INFO("valid speed values: 0 (3 MHz), 1 (1.5 MHz), 2 (750 kHz) and 3 (93.75 kHz)");
 		return ERROR_INVALID_ARGUMENTS;
 	}
 
 	jtag_speed = speed;
-	INFO("setting speed to %d, max. TCK freq. is %s", speed, presto_speed_text[speed]);
+	LOG_INFO("setting speed to %d, max. TCK freq. is %s", speed, presto_speed_text[speed]);
 	return presto_sendbyte(0xA8 | speed);
 }
 
@@ -690,7 +735,7 @@ int presto_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, c
 	}
 	else
 	{
-		ERROR("expected exactly one argument to presto_serial <serial-number>");
+		LOG_ERROR("expected exactly one argument to presto_serial <serial-number>");
 	}
 
 	return ERROR_OK;
@@ -711,16 +756,16 @@ int presto_jtag_init(void)
 	{
 		presto_close();
 		if (presto_serial != NULL)
-			ERROR("Cannot open PRESTO, serial number '%s'", presto_serial);
+			LOG_ERROR("Cannot open PRESTO, serial number '%s'", presto_serial);
 		else
-			ERROR("Cannot open PRESTO");
+			LOG_ERROR("Cannot open PRESTO");
 		return ERROR_JTAG_INIT_FAILED;
 	}
-	INFO("PRESTO open, serial number '%s'", presto->serial);
-	
+	LOG_INFO("PRESTO open, serial number '%s'", presto->serial);
+
 	/* use JTAG speed setting from configuration file */
 	presto_jtag_speed(jtag_speed);
-	
+
 	bitq_interface = &presto_bitq;
 	return ERROR_OK;
 }
@@ -730,7 +775,7 @@ int presto_jtag_quit(void)
 {
 	bitq_cleanup();
 	presto_close();
-	INFO("PRESTO closed");
+	LOG_INFO("PRESTO closed");
 
 	if (presto_serial)
 	{