X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Farm-jtag-ew.c;h=46c3107056d6950fb91149a4658ef8daaa9e216f;hb=445da543d8db868466dcef7e23f75b3c2b54bc72;hp=f5aa2c95730403db4d4928a6cfe87cb4248ec281;hpb=e211e4c6d2a3a59b914638506f7829ed763f251f;p=openocd.git

diff --git a/src/jtag/arm-jtag-ew.c b/src/jtag/arm-jtag-ew.c
index f5aa2c9573..46c3107056 100644
--- a/src/jtag/arm-jtag-ew.c
+++ b/src/jtag/arm-jtag-ew.c
@@ -1,5 +1,3 @@
-// vim:ts=4 sw=4: 
-
 /***************************************************************************
  *   Copyright (C) 2009 by Dimitar Dimitrov <dinuxbg@gmail.com>            *
  *   based on Dominic Rath's and Benedikt Sauter's usbprog.c               *
@@ -24,29 +22,11 @@
 #include "config.h"
 #endif
 
-#include "replacements.h"
-
-#include "jtag.h"
+#include "interface.h"
+#include "commands.h"
 #include <usb.h>
-#include <string.h>
-#include <ctype.h>
-
-/* system includes */
-
-#include "log.h"
+#include "usb_common.h"
 
-/* enable this to debug communication
- */
-#if 1
-#define _DEBUG_USB_COMMS_
-#define _DEBUG_JTAG_IO_
-#endif
-
-#ifdef _DEBUG_JTAG_IO_
-#define DEBUG_JTAG_IO(expr ...)	LOG_DEBUG(expr)
-#else
-#define DEBUG_JTAG_IO(expr ...)
-#endif
 
 #define USB_VID						0x15ba
 #define USB_PID						0x001e
@@ -73,113 +53,74 @@
 #define CMD_TGPWR_SETUP				0x22
 
 /* Global USB buffers */
-static u8 usb_in_buffer[ARMJTAGEW_IN_BUFFER_SIZE];
-static u8 usb_out_buffer[ARMJTAGEW_OUT_BUFFER_SIZE];
-
-/* External interface functions */
-int armjtagew_execute_queue(void);
-int armjtagew_speed(int speed);
-int armjtagew_khz(int khz, int *jtag_speed);
-int armjtagew_register_commands(struct command_context_s *cmd_ctx);
-int armjtagew_init(void);
-int armjtagew_quit(void);
-
-/* CLI command handler functions */
-int armjtagew_handle_armjtagew_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static uint8_t usb_in_buffer[ARMJTAGEW_IN_BUFFER_SIZE];
+static uint8_t usb_out_buffer[ARMJTAGEW_OUT_BUFFER_SIZE];
 
 /* Queue command functions */
-void armjtagew_end_state(tap_state_t state);
-void armjtagew_state_move(void);
-void armjtagew_path_move(int num_states, tap_state_t *path);
-void armjtagew_runtest(int num_cycles);
-void armjtagew_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command);
-void armjtagew_reset(int trst, int srst);
-void armjtagew_simple_command(u8 command);
-int armjtagew_get_status(void);
+static void armjtagew_end_state(tap_state_t state);
+static void armjtagew_state_move(void);
+static void armjtagew_path_move(int num_states, tap_state_t *path);
+static void armjtagew_runtest(int num_cycles);
+static void armjtagew_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
+static void armjtagew_reset(int trst, int srst);
+//static void armjtagew_simple_command(uint8_t command);
+static int armjtagew_get_status(void);
 
 /* tap buffer functions */
-void armjtagew_tap_init(void);
-int armjtagew_tap_execute(void);
-void armjtagew_tap_ensure_space(int scans, int bits);
-void armjtagew_tap_append_step(int tms, int tdi);
-void armjtagew_tap_append_scan(int length, u8 *buffer, scan_command_t *command);
+static void armjtagew_tap_init(void);
+static int armjtagew_tap_execute(void);
+static void armjtagew_tap_ensure_space(int scans, int bits);
+static void armjtagew_tap_append_step(int tms, int tdi);
+static void armjtagew_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command);
 
 /* ARM-JTAG-EW lowlevel functions */
-typedef struct armjtagew_jtag
-{
+struct armjtagew {
 	struct usb_dev_handle* usb_handle;
-} armjtagew_jtag_t;
+};
 
-armjtagew_jtag_t *armjtagew_usb_open(void);
-void armjtagew_usb_close(armjtagew_jtag_t *armjtagew_jtag);
-int armjtagew_usb_message(armjtagew_jtag_t *armjtagew_jtag, int out_length, int in_length);
-int armjtagew_usb_write(armjtagew_jtag_t *armjtagew_jtag, int out_length);
-int armjtagew_usb_read(armjtagew_jtag_t *armjtagew_jtag, int exp_in_length);
+static struct armjtagew *armjtagew_usb_open(void);
+static void armjtagew_usb_close(struct armjtagew *armjtagew);
+static int armjtagew_usb_message(struct armjtagew *armjtagew, int out_length, int in_length);
+static int armjtagew_usb_write(struct armjtagew *armjtagew, int out_length);
+static int armjtagew_usb_read(struct armjtagew *armjtagew, int exp_in_length);
 
 /* helper functions */
-int armjtagew_get_version_info(void);
+static int armjtagew_get_version_info(void);
 
 #ifdef _DEBUG_USB_COMMS_
-void armjtagew_debug_buffer(u8 *buffer, int length);
+static void armjtagew_debug_buffer(uint8_t *buffer, int length);
 #endif
 
-armjtagew_jtag_t* armjtagew_jtag_handle;
+static struct armjtagew* armjtagew_handle;
 
 
 
 /***************************************************************************/
 /* External interface implementation */
 
-jtag_interface_t armjtagew_interface =
+static int armjtagew_execute_queue(void)
 {
-	.name = "arm-jtag-ew",
-	.execute_queue = armjtagew_execute_queue,
-	.speed = armjtagew_speed,
-	.khz = armjtagew_khz,
-	.register_commands = armjtagew_register_commands,
-	.init = armjtagew_init,
-	.quit = armjtagew_quit
-};
-
-
-int armjtagew_execute_queue(void)
-{
-	jtag_command_t *cmd = jtag_command_queue;
+	struct jtag_command *cmd = jtag_command_queue;
 	int scan_size;
 	enum scan_type type;
-	u8 *buffer;
+	uint8_t *buffer;
 
 	while (cmd != NULL)
 	{
 		switch (cmd->type)
 		{
-			case JTAG_END_STATE:
-				DEBUG_JTAG_IO("end_state: %i", cmd->cmd.end_state->end_state);
-
-				if (cmd->cmd.end_state->end_state != -1)
-				{
-					armjtagew_end_state(cmd->cmd.end_state->end_state);
-				}
-				break;
-
 			case JTAG_RUNTEST:
-				DEBUG_JTAG_IO( "runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \
+				DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \
 					cmd->cmd.runtest->end_state);
 
-				if (cmd->cmd.runtest->end_state != -1)
-				{
-					armjtagew_end_state(cmd->cmd.runtest->end_state);
-				}
+				armjtagew_end_state(cmd->cmd.runtest->end_state);
 				armjtagew_runtest(cmd->cmd.runtest->num_cycles);
 				break;
 
 			case JTAG_STATEMOVE:
 				DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
 
-				if (cmd->cmd.statemove->end_state != -1)
-				{
-					armjtagew_end_state(cmd->cmd.statemove->end_state);
-				}
+				armjtagew_end_state(cmd->cmd.statemove->end_state);
 				armjtagew_state_move();
 				break;
 
@@ -194,10 +135,7 @@ int armjtagew_execute_queue(void)
 			case JTAG_SCAN:
 				DEBUG_JTAG_IO("scan end in %i", cmd->cmd.scan->end_state);
 
-				if (cmd->cmd.scan->end_state != -1)
-				{
-					armjtagew_end_state(cmd->cmd.scan->end_state);
-				}
+				armjtagew_end_state(cmd->cmd.scan->end_state);
 
 				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
 				DEBUG_JTAG_IO("scan input, length = %d", scan_size);
@@ -239,16 +177,16 @@ int armjtagew_execute_queue(void)
 
 
 /* Sets speed in kHz. */
-int armjtagew_speed(int speed)
+static int armjtagew_speed(int speed)
 {
     int result;
     int speed_real;
 
 
     usb_out_buffer[0] = CMD_SET_TCK_FREQUENCY;
-	buf_set_u32(usb_out_buffer+1, 0, 32, speed);
+	buf_set_u32(usb_out_buffer + 1, 0, 32, speed);
 
-    result = armjtagew_usb_message(armjtagew_jtag_handle, 4, 4);
+    result = armjtagew_usb_message(armjtagew_handle, 4, 4);
 
     if (result < 0)
     {
@@ -257,43 +195,36 @@ int armjtagew_speed(int speed)
     }
 
 	usb_out_buffer[0] = CMD_GET_TCK_FREQUENCY;
-    result = armjtagew_usb_message(armjtagew_jtag_handle, 1, 4);
+    result = armjtagew_usb_message(armjtagew_handle, 1, 4);
 	speed_real = (int)buf_get_u32(usb_in_buffer,0,32);
-	if(result < 0) 
+	if (result < 0)
 	{
         LOG_ERROR("ARM-JTAG-EW getting speed failed (%d)", result);
         return ERROR_JTAG_DEVICE_ERROR;
-	} 
+	}
 	else
 	{
-    	LOG_INFO("Requested speed %dkHz, emulator reported %dkHz.", speed, speed_real);
+	LOG_INFO("Requested speed %dkHz, emulator reported %dkHz.", speed, speed_real);
 	}
 
     return ERROR_OK;
 }
 
 
-int armjtagew_khz(int khz, int *jtag_speed)
+static int armjtagew_khz(int khz, int *jtag_speed)
 {
 	*jtag_speed = khz;
 
 	return ERROR_OK;
 }
 
-int armjtagew_register_commands(struct command_context_s *cmd_ctx)
-{
-	register_command(cmd_ctx, NULL, "armjtagew_info", armjtagew_handle_armjtagew_info_command, COMMAND_EXEC,
-		"query armjtagew info");
-	return ERROR_OK;
-}
-
-int armjtagew_init(void)
+static int armjtagew_init(void)
 {
 	int check_cnt;
 
-	armjtagew_jtag_handle = armjtagew_usb_open();
+	armjtagew_handle = armjtagew_usb_open();
 
-	if (armjtagew_jtag_handle == 0)
+	if (armjtagew_handle == 0)
 	{
 		LOG_ERROR("Cannot find ARM-JTAG-EW Interface! Please check connection and permissions.");
 		return ERROR_JTAG_INIT_FAILED;
@@ -325,16 +256,16 @@ int armjtagew_init(void)
 	return ERROR_OK;
 }
 
-int armjtagew_quit(void)
+static int armjtagew_quit(void)
 {
-	armjtagew_usb_close(armjtagew_jtag_handle);
+	armjtagew_usb_close(armjtagew_handle);
 	return ERROR_OK;
 }
 
 /***************************************************************************/
 /* Queue command implementations */
 
-void armjtagew_end_state(tap_state_t state)
+static void armjtagew_end_state(tap_state_t state)
 {
 	if (tap_is_state_stable(state))
 	{
@@ -348,13 +279,14 @@ void armjtagew_end_state(tap_state_t state)
 }
 
 /* Goes to the end state. */
-void armjtagew_state_move(void)
+static void armjtagew_state_move(void)
 {
 	int i;
 	int tms = 0;
-	u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
+	uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
+	int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
 
-	for (i = 0; i < 7; i++)
+	for (i = 0; i < tms_count; i++)
 	{
 		tms = (tms_scan >> i) & 1;
 		armjtagew_tap_append_step(tms, 0);
@@ -363,14 +295,14 @@ void armjtagew_state_move(void)
 	tap_set_state(tap_get_end_state());
 }
 
-void armjtagew_path_move(int num_states, tap_state_t *path)
+static void armjtagew_path_move(int num_states, tap_state_t *path)
 {
 	int i;
 
 	for (i = 0; i < num_states; i++)
 	{
 		/*
-		 * TODO: The ARM-JTAG-EW hardware delays TDI with 3 TCK cycles when in RTCK mode. 
+		 * TODO: The ARM-JTAG-EW hardware delays TDI with 3 TCK cycles when in RTCK mode.
 		 * Either handle that here, or update the documentation with examples
 		 * how to fix that in the configuration files.
 		 */
@@ -394,7 +326,7 @@ void armjtagew_path_move(int num_states, tap_state_t *path)
 	tap_set_end_state(tap_get_state());
 }
 
-void armjtagew_runtest(int num_cycles)
+static void armjtagew_runtest(int num_cycles)
 {
 	int i;
 
@@ -421,7 +353,7 @@ void armjtagew_runtest(int num_cycles)
 	}
 }
 
-void armjtagew_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command)
+static void armjtagew_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
 {
 	tap_state_t saved_end_state;
 
@@ -449,13 +381,13 @@ void armjtagew_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size,
 	}
 }
 
-void armjtagew_reset(int trst, int srst)
+static void armjtagew_reset(int trst, int srst)
 {
-	const u8 trst_mask = (1u<<5);
-	const u8 srst_mask = (1u<<6);
-	u8 val = 0;
-	u8 outp_en = 0;
-	u8 change_mask = 0;
+	const uint8_t trst_mask = (1u << 5);
+	const uint8_t srst_mask = (1u << 6);
+	uint8_t val = 0;
+	uint8_t outp_en = 0;
+	uint8_t change_mask = 0;
 	int result;
 
 	LOG_DEBUG("trst: %i, srst: %i", trst, srst);
@@ -490,7 +422,7 @@ void armjtagew_reset(int trst, int srst)
 	usb_out_buffer[1] = val;
 	usb_out_buffer[2] = outp_en;
 	usb_out_buffer[3] = change_mask;
-	result = armjtagew_usb_write(armjtagew_jtag_handle, 4);
+	result = armjtagew_usb_write(armjtagew_handle, 4);
 	if (result != 4)
 	{
 		LOG_ERROR("ARM-JTAG-EW TRST/SRST pin set failed failed (%d)", result);
@@ -498,24 +430,24 @@ void armjtagew_reset(int trst, int srst)
 }
 
 
-int armjtagew_get_status(void)
+static int armjtagew_get_status(void)
 {
 	int result;
 
 	usb_out_buffer[0] = CMD_GET_TAPHW_STATE;
-	result = armjtagew_usb_message(armjtagew_jtag_handle, 1, 12);
+	result = armjtagew_usb_message(armjtagew_handle, 1, 12);
 
 	if (result == 0)
 	{
 		unsigned int u_tg = buf_get_u32(usb_in_buffer, 0, 16);
-		LOG_INFO("U_tg = %d mV, U_aux = %d mV, U_tgpwr = %d mV, I_tgpwr = %d mA, D1 = %d, Target power %s %s\n", \
-			buf_get_u32(usb_in_buffer + 0, 0, 16), \
-			buf_get_u32(usb_in_buffer + 2, 0, 16), \
-			buf_get_u32(usb_in_buffer + 4, 0, 16), \
-			buf_get_u32(usb_in_buffer + 6, 0, 16), \
-			usb_in_buffer[9], \
-			usb_in_buffer[11] ? "OVERCURRENT" : "OK", \
-			usb_in_buffer[10] ? "enabled" : "disabled");
+		LOG_INFO("U_tg = %d mV, U_aux = %d mV, U_tgpwr = %d mV, I_tgpwr = %d mA, D1 = %d, Target power %s %s\n",
+			 (int)(buf_get_u32(usb_in_buffer + 0, 0, 16)),
+			 (int)(buf_get_u32(usb_in_buffer + 2, 0, 16)),
+			 (int)(buf_get_u32(usb_in_buffer + 4, 0, 16)),
+			 (int)(buf_get_u32(usb_in_buffer + 6, 0, 16)),
+			 usb_in_buffer[9],
+			 usb_in_buffer[11] ? "OVERCURRENT" : "OK",
+			 usb_in_buffer[10] ? "enabled" : "disabled");
 
 		if (u_tg < 1500)
 		{
@@ -530,7 +462,7 @@ int armjtagew_get_status(void)
 	return ERROR_OK;
 }
 
-int armjtagew_get_version_info(void)
+static int armjtagew_get_version_info(void)
 {
 	int result;
 	char sn[16];
@@ -538,18 +470,18 @@ int armjtagew_get_version_info(void)
 
 	/* query hardware version */
 	usb_out_buffer[0] = CMD_GET_VERSION;
-	result = armjtagew_usb_message(armjtagew_jtag_handle, 1, 4+15+256);
+	result = armjtagew_usb_message(armjtagew_handle, 1, 4 + 15 + 256);
 
-	if (result != 0) 
+	if (result != 0)
 	{
 		LOG_ERROR("ARM-JTAG-EW command CMD_GET_VERSION failed (%d)\n", result);
 		return ERROR_JTAG_DEVICE_ERROR;
 	}
 
 
-	memcpy(sn, usb_in_buffer+4, 15);
+	memcpy(sn, usb_in_buffer + 4, 15);
 	sn[15] = '\0';
-	memcpy(auxinfo, usb_in_buffer+4+15, 256);
+	memcpy(auxinfo, usb_in_buffer + 4+15, 256);
 	auxinfo[256] = '\0';
 
 	LOG_INFO("ARM-JTAG-EW firmware version %d.%d, hardware revision %c, SN=%s, Additional info: %s", \
@@ -559,7 +491,7 @@ int armjtagew_get_version_info(void)
 	return ERROR_OK;
 }
 
-int armjtagew_handle_armjtagew_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(armjtagew_handle_armjtagew_info_command)
 {
 	if (armjtagew_get_version_info() == ERROR_OK)
 	{
@@ -570,6 +502,29 @@ int armjtagew_handle_armjtagew_info_command(struct command_context_s *cmd_ctx, c
 	return ERROR_OK;
 }
 
+static const struct command_registration armjtagew_command_handlers[] = {
+	{
+		.name = "armjtagew_info",
+		.handler = &armjtagew_handle_armjtagew_info_command,
+		.mode = COMMAND_EXEC,
+		.help = "query armjtagew info",
+	},
+	COMMAND_REGISTRATION_DONE
+};
+
+struct jtag_interface armjtagew_interface = {
+		.name = "arm-jtag-ew",
+
+		.commands = armjtagew_command_handlers,
+
+		.execute_queue = &armjtagew_execute_queue,
+		.speed = &armjtagew_speed,
+		.khz = &armjtagew_khz,
+
+		.init = &armjtagew_init,
+		.quit = &armjtagew_quit,
+	};
+
 /***************************************************************************/
 /* ARM-JTAG-EW tap functions */
 
@@ -577,32 +532,31 @@ int armjtagew_handle_armjtagew_info_command(struct command_context_s *cmd_ctx, c
 #define ARMJTAGEW_TAP_BUFFER_SIZE 2048
 
 static int tap_length;
-static u8 tms_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
-static u8 tdi_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
-static u8 tdo_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
+static uint8_t tms_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
+static uint8_t tdi_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
+static uint8_t tdo_buffer[ARMJTAGEW_TAP_BUFFER_SIZE];
 
-typedef struct
-{
+struct pending_scan_result {
 	int first;	/* First bit position in tdo_buffer to read */
 	int length; /* Number of bits to read */
-	scan_command_t *command; /* Corresponding scan command */
-	u8 *buffer;
-} pending_scan_result_t;
+	struct scan_command *command; /* Corresponding scan command */
+	uint8_t *buffer;
+};
 
 #define MAX_PENDING_SCAN_RESULTS 256
 
 static int pending_scan_results_length;
-static pending_scan_result_t pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
+static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
 
 static int last_tms;
 
-void armjtagew_tap_init(void)
+static void armjtagew_tap_init(void)
 {
 	tap_length = 0;
 	pending_scan_results_length = 0;
 }
 
-void armjtagew_tap_ensure_space(int scans, int bits)
+static void armjtagew_tap_ensure_space(int scans, int bits)
 {
 	int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
 	int available_bits = ARMJTAGEW_TAP_BUFFER_SIZE * 8 - tap_length;
@@ -613,7 +567,7 @@ void armjtagew_tap_ensure_space(int scans, int bits)
 	}
 }
 
-void armjtagew_tap_append_step(int tms, int tdi)
+static void armjtagew_tap_append_step(int tms, int tdi)
 {
 	last_tms = tms;
 	int index = tap_length / 8;
@@ -621,7 +575,7 @@ void armjtagew_tap_append_step(int tms, int tdi)
 	if (index < ARMJTAGEW_TAP_BUFFER_SIZE)
 	{
 		int bit_index = tap_length % 8;
-		u8 bit = 1 << bit_index;
+		uint8_t bit = 1 << bit_index;
 
 		if (tms)
 		{
@@ -649,9 +603,9 @@ void armjtagew_tap_append_step(int tms, int tdi)
 	}
 }
 
-void armjtagew_tap_append_scan(int length, u8 *buffer, scan_command_t *command)
+void armjtagew_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command)
 {
-	pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
+	struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
 	int i;
 
 	pending_scan_result->first = tap_length;
@@ -668,7 +622,7 @@ void armjtagew_tap_append_scan(int length, u8 *buffer, scan_command_t *command)
 
 /* Pad and send a tap sequence to the device, and receive the answer.
  * For the purpose of padding we assume that we are in idle or pause state. */
-int armjtagew_tap_execute(void)
+static int armjtagew_tap_execute(void)
 {
 	int byte_length;
 	int tms_offset;
@@ -689,7 +643,7 @@ int armjtagew_tap_execute(void)
 		byte_length = tap_length / 8;
 
 		usb_out_buffer[0] = CMD_TAP_SHIFT;
-		buf_set_u32(usb_out_buffer+1, 0, 16, byte_length);
+		buf_set_u32(usb_out_buffer + 1, 0, 16, byte_length);
 
 		tms_offset = 3;
 		for (i = 0; i < byte_length; i++)
@@ -703,14 +657,14 @@ int armjtagew_tap_execute(void)
 			usb_out_buffer[tdi_offset + i] = flip_u32(tdi_buffer[i],8);
 		}
 
-		result = armjtagew_usb_message(armjtagew_jtag_handle, 3 + 2 * byte_length, byte_length + 4);
+		result = armjtagew_usb_message(armjtagew_handle, 3 + 2 * byte_length, byte_length + 4);
 
 		if (result == 0)
 		{
 			int stat;
 
 			stat = (int)buf_get_u32(usb_in_buffer + byte_length, 0, 32);
-			if(stat) {
+			if (stat) {
 				LOG_ERROR("armjtagew_tap_execute, emulator returned error code %d for a CMD_TAP_SHIFT command", stat);
 				return ERROR_JTAG_QUEUE_FAILED;
 			}
@@ -722,11 +676,11 @@ int armjtagew_tap_execute(void)
 
 			for (i = 0; i < pending_scan_results_length; i++)
 			{
-				pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[i];
-				u8 *buffer = pending_scan_result->buffer;
+				struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i];
+				uint8_t *buffer = pending_scan_result->buffer;
 				int length = pending_scan_result->length;
 				int first = pending_scan_result->first;
-				scan_command_t *command = pending_scan_result->command;
+				struct scan_command *command = pending_scan_result->command;
 
 				/* Copy to buffer */
 				buf_set_buf(tdo_buffer, first, buffer, 0, length);
@@ -764,70 +718,50 @@ int armjtagew_tap_execute(void)
 /*****************************************************************************/
 /* JLink USB low-level functions */
 
-armjtagew_jtag_t* armjtagew_usb_open()
+static struct armjtagew* armjtagew_usb_open()
 {
-	struct usb_bus *busses;
-	struct usb_bus *bus;
-	struct usb_device *dev;
-
-	armjtagew_jtag_t *result;
-
-	result = (armjtagew_jtag_t*) malloc(sizeof(armjtagew_jtag_t));
-
 	usb_init();
-	usb_find_busses();
-	usb_find_devices();
-
-	busses = usb_get_busses();
 
-	/* find armjtagew_jtag device in usb bus */
+	const uint16_t vids[] = { USB_VID, 0 };
+	const uint16_t pids[] = { USB_PID, 0 };
+	struct usb_dev_handle *dev;
+	if (jtag_usb_open(vids, pids, &dev) != ERROR_OK)
+		return NULL;
 
-	for (bus = busses; bus; bus = bus->next)
-	{
-		for (dev = bus->devices; dev; dev = dev->next)
-		{
-			if ((dev->descriptor.idVendor == USB_VID) && (dev->descriptor.idProduct == USB_PID))
-			{
-				result->usb_handle = usb_open(dev);
+	struct armjtagew *result = malloc(sizeof(struct armjtagew));
+	result->usb_handle = dev;
 
 #if 0
-				/* usb_set_configuration required under win32 */
-				usb_set_configuration(result->usb_handle, dev->config[0].bConfigurationValue);
+	/* usb_set_configuration required under win32 */
+	usb_set_configuration(dev, dev->config[0].bConfigurationValue);
 #endif
-				usb_claim_interface(result->usb_handle, 0);
-
+	usb_claim_interface(dev, 0);
 #if 0
-				/*
-				 * This makes problems under Mac OS X. And is not needed
-				 * under Windows. Hopefully this will not break a linux build
-				 */
-				usb_set_altinterface(result->usb_handle, 0);
+	/*
+	 * This makes problems under Mac OS X. And is not needed
+	 * under Windows. Hopefully this will not break a linux build
+	 */
+	usb_set_altinterface(dev, 0);
 #endif
-				return result;
-			}
-		}
-	}
-
-	free(result);
-	return NULL;
+	return result;
 }
 
-void armjtagew_usb_close(armjtagew_jtag_t *armjtagew_jtag)
+static void armjtagew_usb_close(struct armjtagew *armjtagew)
 {
-	usb_close(armjtagew_jtag->usb_handle);
-	free(armjtagew_jtag);
+	usb_close(armjtagew->usb_handle);
+	free(armjtagew);
 }
 
 /* Send a message and receive the reply. */
-int armjtagew_usb_message(armjtagew_jtag_t *armjtagew_jtag, int out_length, int in_length)
+static int armjtagew_usb_message(struct armjtagew *armjtagew, int out_length, int in_length)
 {
 	int result;
 
-	result = armjtagew_usb_write(armjtagew_jtag, out_length);
+	result = armjtagew_usb_write(armjtagew, out_length);
 	if (result == out_length)
 	{
-		result = armjtagew_usb_read(armjtagew_jtag, in_length);
-		if (result != in_length) 
+		result = armjtagew_usb_read(armjtagew, in_length);
+		if (result != in_length)
 		{
 			LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length, result);
 			return -1;
@@ -842,17 +776,17 @@ int armjtagew_usb_message(armjtagew_jtag_t *armjtagew_jtag, int out_length, int
 }
 
 /* Write data from out_buffer to USB. */
-int armjtagew_usb_write(armjtagew_jtag_t *armjtagew_jtag, int out_length)
+static int armjtagew_usb_write(struct armjtagew *armjtagew, int out_length)
 {
 	int result;
 
 	if (out_length > ARMJTAGEW_OUT_BUFFER_SIZE)
 	{
-		LOG_ERROR("armjtagew_jtag_write illegal out_length=%d (max=%d)", out_length, ARMJTAGEW_OUT_BUFFER_SIZE);
+		LOG_ERROR("armjtagew_write illegal out_length=%d (max=%d)", out_length, ARMJTAGEW_OUT_BUFFER_SIZE);
 		return -1;
 	}
 
-	result = usb_bulk_write(armjtagew_jtag->usb_handle, ARMJTAGEW_EPT_BULK_OUT, \
+	result = usb_bulk_write(armjtagew->usb_handle, ARMJTAGEW_EPT_BULK_OUT, \
 		(char*)usb_out_buffer, out_length, ARMJTAGEW_USB_TIMEOUT);
 
 	DEBUG_JTAG_IO("armjtagew_usb_write, out_length = %d, result = %d", out_length, result);
@@ -864,9 +798,9 @@ int armjtagew_usb_write(armjtagew_jtag_t *armjtagew_jtag, int out_length)
 }
 
 /* Read data from USB into in_buffer. */
-int armjtagew_usb_read(armjtagew_jtag_t *armjtagew_jtag, int exp_in_length)
+static int armjtagew_usb_read(struct armjtagew *armjtagew, int exp_in_length)
 {
-	int result = usb_bulk_read(armjtagew_jtag->usb_handle, ARMJTAGEW_EPT_BULK_IN, \
+	int result = usb_bulk_read(armjtagew->usb_handle, ARMJTAGEW_EPT_BULK_IN, \
 		(char*)usb_in_buffer, exp_in_length, ARMJTAGEW_USB_TIMEOUT);
 
 	DEBUG_JTAG_IO("armjtagew_usb_read, result = %d", result);
@@ -881,7 +815,7 @@ int armjtagew_usb_read(armjtagew_jtag_t *armjtagew_jtag, int exp_in_length)
 #ifdef _DEBUG_USB_COMMS_
 #define BYTES_PER_LINE  16
 
-void armjtagew_debug_buffer(u8 *buffer, int length)
+static void armjtagew_debug_buffer(uint8_t *buffer, int length)
 {
 	char line[81];
 	char s[4];
@@ -896,7 +830,7 @@ void armjtagew_debug_buffer(u8 *buffer, int length)
 			snprintf(s, 4, " %02x", buffer[j]);
 			strcat(line, s);
 		}
-		LOG_DEBUG(line);
+		LOG_DEBUG("%s", line);
 	}
 }
 #endif