X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjlink.c;h=0b21c88610ba13eb04a4b9f932cc7e4c7153df20;hp=f7b8d6220ec4e1202c7b32724dc1ad08628d4ece;hb=e1c26950c03b09efe42b8a25dd83f1e50e22a507;hpb=a3e84343e202eb70ebce0ec1e8b15d7f9ce57f00 diff --git a/src/jtag/jlink.c b/src/jtag/jlink.c index f7b8d6220e..0b21c88610 100644 --- a/src/jtag/jlink.c +++ b/src/jtag/jlink.c @@ -50,33 +50,33 @@ static unsigned int jlink_hw_jtag_version = 2; //#define JLINK_TAP_BUFFER_SIZE 384 #define JLINK_IN_BUFFER_SIZE 2048 -#define JLINK_OUT_BUFFER_SIZE 2*2048+4 +#define JLINK_OUT_BUFFER_SIZE 2*2048 + 4 #define JLINK_EMU_RESULT_BUFFER_SIZE 64 /* Global USB buffers */ -static u8 usb_in_buffer[JLINK_IN_BUFFER_SIZE]; -static u8 usb_out_buffer[JLINK_OUT_BUFFER_SIZE]; -static u8 usb_emu_result_buffer[JLINK_EMU_RESULT_BUFFER_SIZE]; +static uint8_t usb_in_buffer[JLINK_IN_BUFFER_SIZE]; +static uint8_t usb_out_buffer[JLINK_OUT_BUFFER_SIZE]; +static uint8_t usb_emu_result_buffer[JLINK_EMU_RESULT_BUFFER_SIZE]; /* Constants for JLink command */ -#define EMU_CMD_VERSION 0x01 -#define EMU_CMD_SET_SPEED 0x05 -#define EMU_CMD_GET_STATE 0x07 +#define EMU_CMD_VERSION 0x01 +#define EMU_CMD_SET_SPEED 0x05 +#define EMU_CMD_GET_STATE 0x07 #define EMU_CMD_HW_CLOCK 0xc8 -#define EMU_CMD_HW_TMS0 0xc9 -#define EMU_CMD_HW_TMS1 0xca -#define EMU_CMD_HW_JTAG2 0xce -#define EMU_CMD_HW_JTAG3 0xcf +#define EMU_CMD_HW_TMS0 0xc9 +#define EMU_CMD_HW_TMS1 0xca +#define EMU_CMD_HW_JTAG2 0xce +#define EMU_CMD_HW_JTAG3 0xcf #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4 -#define EMU_CMD_HW_RESET0 0xdc -#define EMU_CMD_HW_RESET1 0xdd -#define EMU_CMD_HW_TRST0 0xde -#define EMU_CMD_HW_TRST1 0xdf -#define EMU_CMD_GET_CAPS 0xe8 -#define EMU_CMD_GET_HW_VERSION 0xf0 +#define EMU_CMD_HW_RESET0 0xdc +#define EMU_CMD_HW_RESET1 0xdd +#define EMU_CMD_HW_TRST0 0xde +#define EMU_CMD_HW_TRST1 0xdf +#define EMU_CMD_GET_CAPS 0xe8 +#define EMU_CMD_GET_HW_VERSION 0xf0 /* bits return from EMU_CMD_GET_CAPS */ -#define EMU_CAP_GET_HW_VERSION 1 +#define EMU_CAP_GET_HW_VERSION 1 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11 /* max speed 12MHz v5.0 jlink */ @@ -100,9 +100,9 @@ static void jlink_end_state(tap_state_t state); static void jlink_state_move(void); static void jlink_path_move(int num_states, tap_state_t *path); static void jlink_runtest(int num_cycles); -static void jlink_scan(bool ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command); +static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command); static void jlink_reset(int trst, int srst); -static void jlink_simple_command(u8 command); +static void jlink_simple_command(uint8_t command); static int jlink_get_status(void); /* J-Link tap buffer functions */ @@ -110,7 +110,7 @@ static void jlink_tap_init(void); static int jlink_tap_execute(void); static void jlink_tap_ensure_space(int scans, int bits); static void jlink_tap_append_step(int tms, int tdi); -static void jlink_tap_append_scan(int length, u8 *buffer, scan_command_t *command); +static void jlink_tap_append_scan(int length, uint8_t *buffer, scan_command_t *command); /* Jlink lowlevel functions */ typedef struct jlink_jtag @@ -129,7 +129,7 @@ static int jlink_usb_read_emu_result(jlink_jtag_t *jlink_jtag); static int jlink_get_version_info(void); #ifdef _DEBUG_USB_COMMS_ -static void jlink_debug_buffer(u8 *buffer, int length); +static void jlink_debug_buffer(uint8_t *buffer, int length); #endif static enum tap_state jlink_last_state = TAP_RESET; @@ -139,7 +139,7 @@ static jlink_jtag_t* jlink_jtag_handle; /***************************************************************************/ /* External interface implementation */ -jtag_interface_t jlink_interface = +struct jtag_interface jlink_interface = { .name = "jlink", .execute_queue = jlink_execute_queue, @@ -184,7 +184,7 @@ static void jlink_execute_scan(jtag_command_t *cmd) { int scan_size; enum scan_type type; - u8 *buffer; + uint8_t *buffer; DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd->cmd.scan->end_state)); @@ -294,20 +294,19 @@ static int jlink_khz(int khz, int *jtag_speed) static int jlink_register_commands(struct command_context_s *cmd_ctx) { - register_command(cmd_ctx, NULL, "jlink_info", + register_command(cmd_ctx, NULL, "jlink_info", &jlink_handle_jlink_info_command, COMMAND_EXEC, "query jlink info"); register_command(cmd_ctx, NULL, "jlink_hw_jtag", &jlink_handle_jlink_hw_jtag_command, COMMAND_EXEC, - "set/get jlink hw jtag command version [2|3]"); + "set/get jlink hw jtag command version [2 | 3]"); return ERROR_OK; } static int jlink_init(void) { - int check_cnt; int i; - + jlink_jtag_handle = jlink_usb_open(); if (jlink_jtag_handle == 0) @@ -316,23 +315,27 @@ static int jlink_init(void) return ERROR_JTAG_INIT_FAILED; } - jlink_hw_jtag_version = 2; - check_cnt = 0; - while (check_cnt < 3) - { - if (jlink_get_version_info() == ERROR_OK) - { - /* attempt to get status */ - jlink_get_status(); - break; - } + /* + * The next three instructions were added after discovering a problem while using an oscilloscope. For the V8 + * SAM-ICE dongle (and likely other j-link device variants), the reset line to the target microprocessor was found to + * cycle only intermittently during emulator startup (even after encountering the downstream reset instruction later + * in the code). This was found to create two issues: 1) In general it is a bad practice to not reset a CPU to a known + * state when starting an emulator and 2) something critical happens inside the dongle when it does the first read + * following a new USB session. Keeping the processor in reset during the first read collecting version information + * seems to prevent errant "J-Link command EMU_CMD_VERSION failed" issues. + */ + + LOG_INFO("J-Link initialization started / target CPU reset initiated"); + jlink_simple_command(EMU_CMD_HW_TRST0); + jlink_simple_command(EMU_CMD_HW_RESET0); + usleep(1000); - check_cnt++; - } + jlink_hw_jtag_version = 2; - if (check_cnt == 3) + if (jlink_get_version_info() == ERROR_OK) { - LOG_INFO("J-Link initial read failed, don't worry"); + /* attempt to get status */ + jlink_get_status(); } LOG_INFO("J-Link JTAG Interface ready"); @@ -340,15 +343,15 @@ static int jlink_init(void) jlink_reset(0, 0); jtag_sleep(3000); jlink_tap_init(); - jlink_speed(jtag_speed); + jlink_speed(jtag_get_speed()); /* v5/6 jlink seems to have an issue if the first tap move - * is not divisible by 8, so we send a TLR on first power up */ + * is not divisible by 8, so we send a TLR on first power up */ for (i = 0; i < 8; i++) { jlink_tap_append_step(1, 0); } jlink_tap_execute(); - + return ERROR_OK; } @@ -379,8 +382,8 @@ static void jlink_state_move(void) { int i; int tms = 0; - u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); - u8 tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state()); + uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); + uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state()); for (i = 0; i < tms_scan_bits; i++) { @@ -447,7 +450,7 @@ static void jlink_runtest(int num_cycles) } } -static void jlink_scan(bool ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command) +static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command) { tap_state_t saved_end_state; @@ -496,16 +499,14 @@ static void jlink_reset(int trst, int srst) { jlink_simple_command(EMU_CMD_HW_TRST0); } + if (trst == 0) { jlink_simple_command(EMU_CMD_HW_TRST1); - jtag_sleep(5000); - jlink_end_state(TAP_RESET); - jlink_state_move(); } } -static void jlink_simple_command(u8 command) +static void jlink_simple_command(uint8_t command) { int result; @@ -549,7 +550,7 @@ static int jlink_get_version_info(void) { int result; int len; - u32 jlink_caps, jlink_max_size; + uint32_t jlink_caps, jlink_max_size; /* query hardware version */ jlink_simple_command(EMU_CMD_VERSION); @@ -567,7 +568,7 @@ static int jlink_get_version_info(void) LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len); len = JLINK_IN_BUFFER_SIZE; } - + result = jlink_usb_read(jlink_jtag_handle, len); if (result != len) { @@ -589,7 +590,7 @@ static int jlink_get_version_info(void) } jlink_caps = buf_get_u32(usb_in_buffer, 0, 32); - LOG_INFO("JLink caps 0x%x", jlink_caps); + LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps); if (jlink_caps & (1 << EMU_CAP_GET_HW_VERSION)) { @@ -603,12 +604,12 @@ static int jlink_get_version_info(void) return ERROR_JTAG_DEVICE_ERROR; } - u32 jlink_hw_version = buf_get_u32(usb_in_buffer, 0, 32); - u32 major_revision = (jlink_hw_version / 10000) % 100; + uint32_t jlink_hw_version = buf_get_u32(usb_in_buffer, 0, 32); + uint32_t major_revision = (jlink_hw_version / 10000) % 100; if (major_revision >= 5) jlink_hw_jtag_version = 3; - LOG_INFO("JLink hw version %i", jlink_hw_version); + LOG_INFO("JLink hw version %i", (int)jlink_hw_version); } if (jlink_caps & (1 << EMU_CAP_GET_MAX_BLOCK_SIZE)) @@ -624,7 +625,7 @@ static int jlink_get_version_info(void) } jlink_max_size = buf_get_u32(usb_in_buffer, 0, 32); - LOG_INFO("JLink max mem block %i", jlink_max_size); + LOG_INFO("JLink max mem block %i", (int)jlink_max_size); } return ERROR_OK; @@ -669,23 +670,22 @@ static int jlink_handle_jlink_hw_jtag_command(struct command_context_s *cmd_ctx, /* J-Link tap functions */ -static unsigned tap_length=0; -static u8 tms_buffer[JLINK_TAP_BUFFER_SIZE]; -static u8 tdi_buffer[JLINK_TAP_BUFFER_SIZE]; -static u8 tdo_buffer[JLINK_TAP_BUFFER_SIZE]; +static unsigned tap_length = 0; +static uint8_t tms_buffer[JLINK_TAP_BUFFER_SIZE]; +static uint8_t tdi_buffer[JLINK_TAP_BUFFER_SIZE]; +static uint8_t tdo_buffer[JLINK_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; + 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 void jlink_tap_init(void) { @@ -711,12 +711,12 @@ static void jlink_tap_append_step(int tms, int tdi) if (index >= JLINK_TAP_BUFFER_SIZE) { LOG_ERROR("jlink_tap_append_step: overflow"); - *(u32 *)0xFFFFFFFF = 0; + *(uint32_t *)0xFFFFFFFF = 0; exit(-1); } int bit_index = tap_length % 8; - u8 bit = 1 << bit_index; + uint8_t bit = 1 << bit_index; // we do not pad TMS, so be sure to initialize all bits if (0 == bit_index) @@ -737,9 +737,9 @@ static void jlink_tap_append_step(int tms, int tdi) tap_length++; } -static void jlink_tap_append_scan(int length, u8 *buffer, scan_command_t *command) +static void jlink_tap_append_scan(int length, uint8_t *buffer, scan_command_t *command) { - pending_scan_result_t *pending_scan_result = + struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length]; int i; @@ -751,7 +751,7 @@ static void jlink_tap_append_scan(int length, u8 *buffer, scan_command_t *comman for (i = 0; i < length; i++) { int tms = (i < (length - 1)) ? 0 : 1; - int tdi = (buffer[i / 8] & (1 << (i % 8)))!=0; + int tdi = (buffer[i / 8] & (1 << (i % 8))) != 0; jlink_tap_append_step(tms, tdi); } pending_scan_results_length++; @@ -770,7 +770,7 @@ static int jlink_tap_execute(void) /* JLink returns an extra NULL in packet when size of in message is a multiple of 64, creates problems with usb comms */ /* WARNING This will interfere with tap state counting */ - while ((TAP_SCAN_BYTES(tap_length)%64)==0) + while ((TAP_SCAN_BYTES(tap_length)%64) == 0) { jlink_tap_append_step((tap_get_state() == TAP_RESET)?1:0, 0); } @@ -801,8 +801,8 @@ static int jlink_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; @@ -832,13 +832,37 @@ static int jlink_tap_execute(void) return ERROR_OK; } +static struct usb_device* find_jlink_device(void) +{ + struct usb_bus *busses; + struct usb_bus *bus; + struct usb_device *dev; + + usb_find_busses(); + usb_find_devices(); + + busses = usb_get_busses(); + + /* find jlink_jtag device in usb bus */ + + for (bus = busses; bus; bus = bus->next) + { + for (dev = bus->devices; dev; dev = dev->next) + { + if ((dev->descriptor.idVendor == VID) && (dev->descriptor.idProduct == PID)) { + return dev; + } + } + } + + return NULL; +} + /*****************************************************************************/ /* JLink USB low-level functions */ static jlink_jtag_t* jlink_usb_open() { - struct usb_bus *busses; - struct usb_bus *bus; struct usb_device *dev; jlink_jtag_t *result; @@ -846,47 +870,81 @@ static jlink_jtag_t* jlink_usb_open() result = (jlink_jtag_t*) malloc(sizeof(jlink_jtag_t)); usb_init(); - usb_find_busses(); - usb_find_devices(); - busses = usb_get_busses(); + if ((dev = find_jlink_device()) == NULL) { + free(result); + return NULL; + } - /* find jlink_jtag device in usb bus */ + result->usb_handle = usb_open(dev); - for (bus = busses; bus; bus = bus->next) + if (result->usb_handle) { - for (dev = bus->devices; dev; dev = dev->next) + + /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS AREA!!!!!!!!!!! + * The behavior of libusb is not completely consistent across Windows, Linux, and Mac OS X platforms. The actions taken + * in the following compiler conditionals may not agree with published documentation for libusb, but were found + * to be necessary through trials and tribulations. Even little tweaks can break one or more platforms, so if you do make changes + * test them carefully on all platforms before committing them! + */ + +#if IS_WIN32 == 0 + + usb_reset(result->usb_handle); + +#if IS_DARWIN == 0 + + int timeout = 5; + + /* reopen jlink after usb_reset + * on win32 this may take a second or two to re-enumerate */ + while ((dev = find_jlink_device()) == NULL) { - if ((dev->descriptor.idVendor == VID) && (dev->descriptor.idProduct == PID)) - { - result->usb_handle = usb_open(dev); + usleep(1000); + timeout--; + if (!timeout) { + break; + } + } - /* usb_set_configuration required under win32 */ - usb_set_configuration(result->usb_handle, dev->config[0].bConfigurationValue); - usb_claim_interface(result->usb_handle, 0); + if (dev == NULL) + { + free(result); + return NULL; + } + + result->usb_handle = usb_open(dev); +#endif + +#endif + + if (result->usb_handle) + { + /* usb_set_configuration required under win32 */ + usb_set_configuration(result->usb_handle, dev->config[0].bConfigurationValue); + usb_claim_interface(result->usb_handle, 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(result->usb_handle, 0); #endif - struct usb_interface *iface = dev->config->interface; - struct usb_interface_descriptor *desc = iface->altsetting; - for (int i = 0; i < desc->bNumEndpoints; i++) - { - u8 epnum = desc->endpoint[i].bEndpointAddress; - bool is_input = epnum & 0x80; - LOG_DEBUG("usb ep %s %02x", is_input ? "in" : "out", epnum); - if (is_input) - jlink_read_ep = epnum; - else - jlink_write_ep = epnum; - } - - return result; + struct usb_interface *iface = dev->config->interface; + struct usb_interface_descriptor *desc = iface->altsetting; + for (int i = 0; i < desc->bNumEndpoints; i++) + { + uint8_t epnum = desc->endpoint[i].bEndpointAddress; + bool is_input = epnum & 0x80; + LOG_DEBUG("usb ep %s %02x", is_input ? "in" : "out", epnum); + if (is_input) + jlink_read_ep = epnum; + else + jlink_write_ep = epnum; } + + return result; } } @@ -931,13 +989,13 @@ static int jlink_usb_message(jlink_jtag_t *jlink_jtag, int out_length, int in_le result2 = jlink_usb_read_emu_result(jlink_jtag); if (1 != result2) { - LOG_ERROR("jlink_usb_read_emu_result retried requested=1, result=%d, in_length=%i", result2,in_length); - /* Try again once, should only happen if (in_length%64==0) */ + LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, result=%d, in_length=%i", result2,in_length); + /* Try again once, should only happen if (in_length%64 == 0) */ result2 = jlink_usb_read_emu_result(jlink_jtag); if (1 != result2) { LOG_ERROR("jlink_usb_read_emu_result failed " - "(requested=1, result=%d)", result2); + "(requested = 1, result=%d)", result2); return ERROR_JTAG_DEVICE_ERROR; } } @@ -1054,7 +1112,7 @@ static int jlink_usb_read_emu_result(jlink_jtag_t *jlink_jtag) #ifdef _DEBUG_USB_COMMS_ #define BYTES_PER_LINE 16 -static void jlink_debug_buffer(u8 *buffer, int length) +static void jlink_debug_buffer(uint8_t *buffer, int length) { char line[81]; char s[4];