X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjlink.c;h=bab1a31ce6d2eb7e8b2d0c40b1d4cef16dc75251;hp=a229cec58180c8cef9bac5d74de7c670074b9c65;hb=84df52f9ea78e2d71bde648a16b69d80404c6421;hpb=779c44125a8804dabb40f59b068b55a9ac810096 diff --git a/src/jtag/jlink.c b/src/jtag/jlink.c index a229cec581..bab1a31ce6 100644 --- a/src/jtag/jlink.c +++ b/src/jtag/jlink.c @@ -25,14 +25,11 @@ #include "config.h" #endif -#include "replacements.h" - -#include "jtag.h" +#include "interface.h" +#include "commands.h" #include -#include -#include "log.h" #define VID 0x1366 #define PID 0x0101 @@ -40,27 +37,47 @@ #define JLINK_WRITE_ENDPOINT 0x02 #define JLINK_READ_ENDPOINT 0x81 +static unsigned int jlink_write_ep = JLINK_WRITE_ENDPOINT; +static unsigned int jlink_read_ep = JLINK_READ_ENDPOINT; +static unsigned int jlink_hw_jtag_version = 2; + #define JLINK_USB_TIMEOUT 1000 // See Section 1.3.2 of the Segger JLink USB protocol manual +/* 2048 is the max value we can use here */ +//#define JLINK_TAP_BUFFER_SIZE 2048 +#define JLINK_TAP_BUFFER_SIZE 256 +//#define JLINK_TAP_BUFFER_SIZE 384 + #define JLINK_IN_BUFFER_SIZE 2048 -#define JLINK_OUT_BUFFER_SIZE 2048 +#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_HW_JTAG3 0xcf -#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_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_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 + +/* bits return from EMU_CMD_GET_CAPS */ +#define EMU_CAP_GET_HW_VERSION 1 +#define EMU_CAP_GET_MAX_BLOCK_SIZE 11 /* max speed 12MHz v5.0 jlink */ #define JLINK_MAX_SPEED 12000 @@ -76,15 +93,16 @@ static int jlink_quit(void); /* CLI command handler functions */ static int jlink_handle_jlink_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int jlink_handle_jlink_hw_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); /* Queue command functions */ 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(int 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 */ @@ -92,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 @@ -111,9 +129,11 @@ 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; + static jlink_jtag_t* jlink_jtag_handle; /***************************************************************************/ @@ -131,22 +151,13 @@ jtag_interface_t jlink_interface = .quit = jlink_quit }; -static void jlink_execute_end_state(jtag_command_t *cmd) -{ - DEBUG_JTAG_IO("end_state: %i", cmd->cmd.end_state->end_state); - - if (cmd->cmd.end_state->end_state != TAP_INVALID) - jlink_end_state(cmd->cmd.end_state->end_state); -} - static void jlink_execute_runtest(jtag_command_t *cmd) { 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 != TAP_INVALID) - jlink_end_state(cmd->cmd.runtest->end_state); + jlink_end_state(cmd->cmd.runtest->end_state); jlink_runtest(cmd->cmd.runtest->num_cycles); } @@ -155,10 +166,7 @@ static void jlink_execute_statemove(jtag_command_t *cmd) { DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state); - if (cmd->cmd.statemove->end_state != TAP_INVALID) - { - jlink_end_state(cmd->cmd.statemove->end_state); - } + jlink_end_state(cmd->cmd.statemove->end_state); jlink_state_move(); } @@ -176,12 +184,11 @@ 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 %i", cmd->cmd.scan->end_state); + DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd->cmd.scan->end_state)); - if (cmd->cmd.scan->end_state != TAP_INVALID) - jlink_end_state(cmd->cmd.scan->end_state); + jlink_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); @@ -200,11 +207,8 @@ static void jlink_execute_reset(jtag_command_t *cmd) cmd->cmd.reset->trst, cmd->cmd.reset->srst); jlink_tap_execute(); - - if (cmd->cmd.reset->trst == 1) - tap_set_state(TAP_RESET); - jlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); + jlink_tap_execute(); } static void jlink_execute_sleep(jtag_command_t *cmd) @@ -218,7 +222,6 @@ static void jlink_execute_command(jtag_command_t *cmd) { switch (cmd->type) { - case JTAG_END_STATE: jlink_execute_end_state(cmd); break; case JTAG_RUNTEST: jlink_execute_runtest(cmd); break; case JTAG_STATEMOVE: jlink_execute_statemove(cmd); break; case JTAG_PATHMOVE: jlink_execute_pathmove(cmd); break; @@ -290,14 +293,20 @@ 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", jlink_handle_jlink_info_command, COMMAND_EXEC, + + 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]"); return ERROR_OK; } static int jlink_init(void) { int check_cnt; + int i; jlink_jtag_handle = jlink_usb_open(); @@ -307,6 +316,7 @@ static int jlink_init(void) return ERROR_JTAG_INIT_FAILED; } + jlink_hw_jtag_version = 2; check_cnt = 0; while (check_cnt < 3) { @@ -328,8 +338,16 @@ static int jlink_init(void) LOG_INFO("J-Link JTAG Interface ready"); 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 */ + for (i = 0; i < 8; i++) { + jlink_tap_append_step(1, 0); + } + jlink_tap_execute(); return ERROR_OK; } @@ -361,9 +379,10 @@ 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()); + 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 < 7; i++) + for (i = 0; i < tms_scan_bits; i++) { tms = (tms_scan >> i) & 1; jlink_tap_append_step(tms, 0); @@ -404,11 +423,14 @@ static void jlink_runtest(int num_cycles) tap_state_t saved_end_state = tap_get_end_state(); + jlink_tap_ensure_space(1,num_cycles + 16); + /* only do a state_move when we're not already in IDLE */ if (tap_get_state() != TAP_IDLE) { jlink_end_state(TAP_IDLE); jlink_state_move(); +// num_cycles--; } /* execute num_cycles */ @@ -425,11 +447,11 @@ static void jlink_runtest(int num_cycles) } } -static void jlink_scan(int 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; - jlink_tap_ensure_space(1, scan_size + 8); + jlink_tap_ensure_space(1, scan_size + 16); saved_end_state = tap_get_end_state(); @@ -464,27 +486,26 @@ static void jlink_reset(int trst, int srst) if (srst == 0) { jlink_simple_command(EMU_CMD_HW_RESET1); - jlink_end_state(TAP_RESET); - jlink_state_move(); } - else if (srst == 1) + if (srst == 1) { jlink_simple_command(EMU_CMD_HW_RESET0); } + if (trst == 1) + { + 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(); } - else if (trst == 1) - { - jlink_simple_command(EMU_CMD_HW_TRST0); - } } -static void jlink_simple_command(u8 command) +static void jlink_simple_command(uint8_t command) { int result; @@ -528,6 +549,7 @@ static int jlink_get_version_info(void) { int result; int len; + uint32_t jlink_caps, jlink_max_size; /* query hardware version */ jlink_simple_command(EMU_CMD_VERSION); @@ -535,23 +557,76 @@ static int jlink_get_version_info(void) result = jlink_usb_read(jlink_jtag_handle, 2); if (2 != result) { - LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", - result); + LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result); return ERROR_JTAG_DEVICE_ERROR; } len = buf_get_u32(usb_in_buffer, 0, 16); + if (len > JLINK_IN_BUFFER_SIZE) + { + 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) { - LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", - result); + LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result); return ERROR_JTAG_DEVICE_ERROR; } usb_in_buffer[result] = 0; LOG_INFO("%s", (char *)usb_in_buffer); + /* query hardware capabilities */ + jlink_simple_command(EMU_CMD_GET_CAPS); + + result = jlink_usb_read(jlink_jtag_handle, 4); + if (4 != result) + { + LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result); + return ERROR_JTAG_DEVICE_ERROR; + } + + jlink_caps = buf_get_u32(usb_in_buffer, 0, 32); + LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps); + + if (jlink_caps & (1 << EMU_CAP_GET_HW_VERSION)) + { + /* query hardware version */ + jlink_simple_command(EMU_CMD_GET_HW_VERSION); + + result = jlink_usb_read(jlink_jtag_handle, 4); + if (4 != result) + { + LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result); + return ERROR_JTAG_DEVICE_ERROR; + } + + 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", (int)jlink_hw_version); + } + + if (jlink_caps & (1 << EMU_CAP_GET_MAX_BLOCK_SIZE)) + { + /* query hardware maximum memory block */ + jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK); + + result = jlink_usb_read(jlink_jtag_handle, 4); + if (4 != result) + { + LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result); + return ERROR_JTAG_DEVICE_ERROR; + } + + jlink_max_size = buf_get_u32(usb_in_buffer, 0, 32); + LOG_INFO("JLink max mem block %i", (int)jlink_max_size); + } + return ERROR_OK; } @@ -566,23 +641,45 @@ static int jlink_handle_jlink_info_command(struct command_context_s *cmd_ctx, ch return ERROR_OK; } +static int jlink_handle_jlink_hw_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + switch (argc) { + case 0: + command_print(cmd_ctx, "jlink hw jtag %i", jlink_hw_jtag_version); + break; + case 1: { + int request_version = atoi(args[0]); + switch (request_version) { + case 2: case 3: + jlink_hw_jtag_version = request_version; + break; + default: + return ERROR_COMMAND_SYNTAX_ERROR; + } + break; + } + default: + return ERROR_COMMAND_SYNTAX_ERROR; + } + + return ERROR_OK; +} + /***************************************************************************/ /* J-Link tap functions */ -/* 2048 is the max value we can use here */ -#define JLINK_TAP_BUFFER_SIZE 2048 -static unsigned tap_length; -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 { 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; + uint8_t *buffer; } pending_scan_result_t; #define MAX_PENDING_SCAN_RESULTS 256 @@ -590,8 +687,6 @@ typedef struct static int pending_scan_results_length; static pending_scan_result_t pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS]; -static int last_tms; - static void jlink_tap_init(void) { tap_length = 0; @@ -601,7 +696,7 @@ static void jlink_tap_init(void) static void jlink_tap_ensure_space(int scans, int bits) { int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length; - int available_bits = JLINK_TAP_BUFFER_SIZE * 8 - tap_length; + int available_bits = JLINK_TAP_BUFFER_SIZE * 8 - tap_length - 32; if (scans > available_scans || bits > available_bits) { @@ -611,21 +706,23 @@ static void jlink_tap_ensure_space(int scans, int bits) static void jlink_tap_append_step(int tms, int tdi) { - last_tms = tms; int index = tap_length / 8; if (index >= JLINK_TAP_BUFFER_SIZE) { LOG_ERROR("jlink_tap_append_step: overflow"); + *(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) + { tms_buffer[index] = tdi_buffer[index] = 0; + } if (tms) tms_buffer[index] |= bit; @@ -640,7 +737,7 @@ 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 = &pending_scan_results_buffer[pending_scan_results_length]; @@ -653,8 +750,8 @@ 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)); + int tms = (i < (length - 1)) ? 0 : 1; + int tdi = (buffer[i / 8] & (1 << (i % 8))) != 0; jlink_tap_append_step(tms, tdi); } pending_scan_results_length++; @@ -665,50 +762,47 @@ static void jlink_tap_append_scan(int length, u8 *buffer, scan_command_t *comman static int jlink_tap_execute(void) { int byte_length; - int tms_offset; - int tdi_offset; int i; int result; if (!tap_length) return ERROR_OK; + /* 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) + { + jlink_tap_append_step((tap_get_state() == TAP_RESET)?1:0, 0); + } + // number of full bytes (plus one if some would be left over) - byte_length = tap_length / 8 + !!(tap_length % 8); + byte_length = TAP_SCAN_BYTES(tap_length); - usb_out_buffer[0] = EMU_CMD_HW_JTAG3; + bool use_jtag3 = jlink_hw_jtag_version >= 3; + usb_out_buffer[0] = use_jtag3 ? EMU_CMD_HW_JTAG3 : EMU_CMD_HW_JTAG2; usb_out_buffer[1] = 0; usb_out_buffer[2] = (tap_length >> 0) & 0xff; usb_out_buffer[3] = (tap_length >> 8) & 0xff; + memcpy(usb_out_buffer + 4, tms_buffer, byte_length); + memcpy(usb_out_buffer + 4 + byte_length, tdi_buffer, byte_length); - tms_offset = 4; - for (i = 0; i < byte_length; i++) - { - usb_out_buffer[tms_offset + i] = tms_buffer[i]; - } - - tdi_offset = tms_offset + byte_length; - for (i = 0; i < byte_length; i++) - { - usb_out_buffer[tdi_offset + i] = tdi_buffer[i]; - } + jlink_last_state = jtag_debug_state_machine(tms_buffer, tdi_buffer, + tap_length, jlink_last_state); result = jlink_usb_message(jlink_jtag_handle, 4 + 2 * byte_length, byte_length); - if (result != byte_length) { - LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", - result, byte_length); + LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result, byte_length); + jlink_tap_init(); return ERROR_JTAG_QUEUE_FAILED; } - for (i = 0; i < byte_length; i++) - tdo_buffer[i] = usb_in_buffer[i]; + memcpy(tdo_buffer, usb_in_buffer, byte_length); 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; + 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; @@ -719,7 +813,7 @@ static int jlink_tap_execute(void) DEBUG_JTAG_IO("pending scan result, length = %d", length); #ifdef _DEBUG_USB_COMMS_ - jlink_debug_buffer(buffer, byte_length); + jlink_debug_buffer(buffer, TAP_SCAN_BYTES(length)); #endif if (jtag_read_buffer(buffer, command) != ERROR_OK) @@ -735,7 +829,6 @@ static int jlink_tap_execute(void) } jlink_tap_init(); - return ERROR_OK; } @@ -779,6 +872,19 @@ static jlink_jtag_t* jlink_usb_open() */ 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++) + { + 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; } } @@ -798,7 +904,6 @@ static void jlink_usb_close(jlink_jtag_t *jlink_jtag) static int jlink_usb_message(jlink_jtag_t *jlink_jtag, int out_length, int in_length) { int result; - int result2; result = jlink_usb_write(jlink_jtag, out_length); if (result != out_length) @@ -809,22 +914,32 @@ static int jlink_usb_message(jlink_jtag_t *jlink_jtag, int out_length, int in_le } result = jlink_usb_read(jlink_jtag, in_length); - if ((result != in_length) && (result != in_length + 1)) + if ((result != in_length) && (result != (in_length + 1))) { LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length, result); return ERROR_JTAG_DEVICE_ERROR; } + if (jlink_hw_jtag_version < 3) + return result; + + int result2 = ERROR_OK; if (result == in_length) { /* Must read the result from the EMU too */ result2 = jlink_usb_read_emu_result(jlink_jtag); if (1 != result2) { - LOG_ERROR("jlink_usb_read_emu_result failed " - "(requested=1, result=%d)", result2); - return ERROR_JTAG_DEVICE_ERROR; + 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); + return ERROR_JTAG_DEVICE_ERROR; + } } /* Check the result itself */ @@ -851,28 +966,33 @@ static int usb_bulk_with_retries( usb_dev_handle *dev, int ep, char *bytes, int size, int timeout) { - int rc = 0, tries = 3, this_size; - - while (tries && size) { + int tries = 3, count = 0; - this_size = f(dev, ep, bytes, size, timeout); - if (this_size > 0) { - - size -= this_size; - rc += this_size; - bytes += this_size; - - } else - tries --; + while (tries && (count < size)) + { + int result = f(dev, ep, bytes + count, size - count, timeout); + if (result > 0) + count += result; + else if ((-ETIMEDOUT != result) || !--tries) + return result; } - return rc; + return count; } + +static int wrap_usb_bulk_write(usb_dev_handle *dev, int ep, + char *buff, int size, int timeout) +{ + /* usb_bulk_write() takes const char *buff */ + return usb_bulk_write(dev, ep, buff, size, timeout); +} + static inline int usb_bulk_write_ex(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout) { - return usb_bulk_with_retries(&usb_bulk_write, + return usb_bulk_with_retries(&wrap_usb_bulk_write, dev, ep, bytes, size, timeout); } + static inline int usb_bulk_read_ex(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout) { @@ -891,7 +1011,7 @@ static int jlink_usb_write(jlink_jtag_t *jlink_jtag, int out_length) return -1; } - result = usb_bulk_write_ex(jlink_jtag->usb_handle, JLINK_WRITE_ENDPOINT, + result = usb_bulk_write_ex(jlink_jtag->usb_handle, jlink_write_ep, (char *)usb_out_buffer, out_length, JLINK_USB_TIMEOUT); DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length, result); @@ -905,7 +1025,7 @@ static int jlink_usb_write(jlink_jtag_t *jlink_jtag, int out_length) /* Read data from USB into in_buffer. */ static int jlink_usb_read(jlink_jtag_t *jlink_jtag, int expected_size) { - int result = usb_bulk_read_ex(jlink_jtag->usb_handle, JLINK_READ_ENDPOINT, + int result = usb_bulk_read_ex(jlink_jtag->usb_handle, jlink_read_ep, (char *)usb_in_buffer, expected_size, JLINK_USB_TIMEOUT); DEBUG_JTAG_IO("jlink_usb_read, result = %d", result); @@ -919,7 +1039,7 @@ static int jlink_usb_read(jlink_jtag_t *jlink_jtag, int expected_size) /* Read the result from the previous EMU cmd into result_buffer. */ static int jlink_usb_read_emu_result(jlink_jtag_t *jlink_jtag) { - int result = usb_bulk_read_ex(jlink_jtag->usb_handle, JLINK_READ_ENDPOINT, + int result = usb_bulk_read_ex(jlink_jtag->usb_handle, jlink_read_ep, (char *)usb_emu_result_buffer, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */, JLINK_USB_TIMEOUT); @@ -934,7 +1054,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]; @@ -953,3 +1073,4 @@ static void jlink_debug_buffer(u8 *buffer, int length) } } #endif +