X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Fdrivers%2Fjlink.c;h=6507403e34763c61df499c7997c5bfab69609723;hb=bce76b80ccc1eca1f71327f27febf5c52b69b3ad;hp=f22ad7c63389e0e5aaf2fe2eb875cb8628bd39c5;hpb=e380930478a45cc78de6b807dc6f17d0a61298b4;p=openocd.git diff --git a/src/jtag/drivers/jlink.c b/src/jtag/drivers/jlink.c index f22ad7c633..6507403e34 100644 --- a/src/jtag/drivers/jlink.c +++ b/src/jtag/drivers/jlink.c @@ -32,10 +32,19 @@ /* See Segger's public documentation: * Reference manual for J-Link USB Protocol * Document RM08001-R6 Date: June 16, 2009 + * (Or newer, with some SWD information). + +http://www.segger.com/cms/admin/uploads/productDocs/RM08001_JLinkUSBProtocol.pdf */ -#define VID 0x1366 -#define PID 0x0101 +/* + * The default pid of the segger is 0x0101 + * But when you change the USB Address it will also + * + * pid = ( usb_address > 0x4) ? 0x0101 : (0x101 + usb_address) + */ +#define VID 0x1366, 0x1366, 0x1366, 0x1366 +#define PID 0x0101, 0x0102, 0x0103, 0x0104 #define JLINK_WRITE_ENDPOINT 0x02 #define JLINK_READ_ENDPOINT 0x81 @@ -46,10 +55,10 @@ 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 +// See Section 3.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 2048 +//#define JLINK_TAP_BUFFER_SIZE 256 //#define JLINK_TAP_BUFFER_SIZE 384 #define JLINK_IN_BUFFER_SIZE 2048 @@ -62,10 +71,10 @@ 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_VERSION 0x01 #define EMU_CMD_SET_SPEED 0x05 #define EMU_CMD_GET_STATE 0x07 -#define EMU_CMD_HW_CLOCK 0xc8 +#define EMU_CMD_HW_CLOCK 0xc8 #define EMU_CMD_HW_TMS0 0xc9 #define EMU_CMD_HW_TMS1 0xca #define EMU_CMD_HW_JTAG2 0xce @@ -79,8 +88,73 @@ static uint8_t usb_emu_result_buffer[JLINK_EMU_RESULT_BUFFER_SIZE]; #define EMU_CMD_GET_HW_VERSION 0xf0 /* bits return from EMU_CMD_GET_CAPS */ +#define EMU_CAP_RESERVED_1 0 #define EMU_CAP_GET_HW_VERSION 1 +#define EMU_CAP_WRITE_DCC 2 +#define EMU_CAP_ADAPTIVE_CLOCKING 3 +#define EMU_CAP_READ_CONFIG 4 +#define EMU_CAP_WRITE_CONFIG 5 +#define EMU_CAP_TRACE 6 +#define EMU_CAP_WRITE_MEM 7 +#define EMU_CAP_READ_MEM 8 +#define EMU_CAP_SPEED_INFO 9 +#define EMU_CAP_EXEC_CODE 10 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11 +#define EMU_CAP_GET_HW_INFO 12 +#define EMU_CAP_SET_KS_POWER 13 +#define EMU_CAP_RESET_STOP_TIMED 14 +#define EMU_CAP_RESERVED_2 15 +#define EMU_CAP_MEASURE_RTCK_REACT 16 +#define EMU_CAP_SELECT_IF 17 +#define EMU_CAP_RW_MEM_ARM79 18 +#define EMU_CAP_GET_COUNTERS 19 +#define EMU_CAP_READ_DCC 20 +#define EMU_CAP_GET_CPU_CAPS 21 +#define EMU_CAP_EXEC_CPU_CMD 22 +#define EMU_CAP_SWO 23 +#define EMU_CAP_WRITE_DCC_EX 24 +#define EMU_CAP_UPDATE_FIRMWARE_EX 25 +#define EMU_CAP_FILE_IO 26 +#define EMU_CAP_REGISTER 27 +#define EMU_CAP_INDICATORS 28 +#define EMU_CAP_TEST_NET_SPEED 29 +#define EMU_CAP_RAWTRACE 30 +#define EMU_CAP_RESERVED_3 31 + +static char *jlink_cap_str[] = { + "Always 1.", + "Supports command EMU_CMD_GET_HARDWARE_VERSION", + "Supports command EMU_CMD_WRITE_DCC", + "Supports adaptive clocking", + "Supports command EMU_CMD_READ_CONFIG", + "Supports command EMU_CMD_WRITE_CONFIG", + "Supports trace commands", + "Supports command EMU_CMD_WRITE_MEM", + "Supports command EMU_CMD_READ_MEM", + "Supports command EMU_CMD_GET_SPEED", + "Supports command EMU_CMD_CODE_...", + "Supports command EMU_CMD_GET_MAX_BLOCK_SIZE", + "Supports command EMU_CMD_GET_HW_INFO", + "Supports command EMU_CMD_SET_KS_POWER", + "Supports command EMU_CMD_HW_RELEASE_RESET_STOP_TIMED", + "Reserved", + "Supports command EMU_CMD_MEASURE_RTCK_REACT", + "Supports command EMU_CMD_HW_SELECT_IF", + "Supports command EMU_CMD_READ/WRITE_MEM_ARM79", + "Supports command EMU_CMD_GET_COUNTERS", + "Supports command EMU_CMD_READ_DCC", + "Supports command EMU_CMD_GET_CPU_CAPS", + "Supports command EMU_CMD_EXEC_CPU_CMD", + "Supports command EMU_CMD_SWO", + "Supports command EMU_CMD_WRITE_DCC_EX", + "Supports command EMU_CMD_UPDATE_FIRMWARE_EX", + "Supports command EMU_CMD_FILE_IO", + "Supports command EMU_CMD_REGISTER", + "Supports command EMU_CMD_INDICATORS", + "Supports command EMU_CMD_TEST_NET_SPEED", + "Supports command EMU_CMD_RAWTRACE", + "Reserved", +}; /* max speed 12MHz v5.0 jlink */ #define JLINK_MAX_SPEED 12000 @@ -90,7 +164,8 @@ 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, uint8_t *buffer, int scan_size, struct scan_command *command); +static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, + int scan_size, struct scan_command *command); static void jlink_reset(int trst, int srst); static void jlink_simple_command(uint8_t command); static int jlink_get_status(void); @@ -100,7 +175,8 @@ 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, uint8_t *buffer, struct scan_command *command); +static void jlink_tap_append_scan(int length, uint8_t *buffer, + struct scan_command *command); /* Jlink lowlevel functions */ struct jlink { @@ -125,6 +201,12 @@ static enum tap_state jlink_last_state = TAP_RESET; static struct jlink* jlink_handle; +/* pid could be specified at runtime */ +static uint16_t vids[] = { VID, 0 }; +static uint16_t pids[] = { PID, 0 }; + +static uint32_t jlink_caps; + /***************************************************************************/ /* External interface implementation */ @@ -200,7 +282,7 @@ static void jlink_execute_command(struct jtag_command *cmd) switch (cmd->type) { case JTAG_RUNTEST: jlink_execute_runtest(cmd); break; - case JTAG_STATEMOVE: jlink_execute_statemove(cmd); break; + case JTAG_TLR_RESET: jlink_execute_statemove(cmd); break; case JTAG_PATHMOVE: jlink_execute_pathmove(cmd); break; case JTAG_SCAN: jlink_execute_scan(cmd); break; case JTAG_RESET: jlink_execute_reset(cmd); break; @@ -231,9 +313,9 @@ static int jlink_speed(int speed) if (speed > JLINK_MAX_SPEED) { - LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum", + LOG_INFO("reduce speed request: %dkHz to %dkHz maximum", speed, JLINK_MAX_SPEED); - return ERROR_OK; + speed = JLINK_MAX_SPEED; } /* check for RTCK setting */ @@ -276,18 +358,26 @@ static int jlink_init(void) if (jlink_handle == 0) { - LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions."); + LOG_ERROR("Cannot find jlink Interface! Please check " + "connection and permissions."); return ERROR_JTAG_INIT_FAILED; } /* - * 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. + * 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"); @@ -308,7 +398,11 @@ static int jlink_init(void) jlink_reset(0, 0); jtag_sleep(3000); jlink_tap_init(); - jlink_speed(jtag_get_speed()); + int jtag_speed_var; + int retval = jtag_get_speed(&jtag_speed_var); + if (retval != ERROR_OK) + return retval; + jlink_speed(jtag_speed_var); /* 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 */ @@ -375,7 +469,8 @@ static void jlink_path_move(int num_states, tap_state_t *path) } else { - LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i])); + LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", + tap_state_name(tap_get_state()), tap_state_name(path[i])); exit(-1); } @@ -415,7 +510,8 @@ static void jlink_runtest(int num_cycles) } } -static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command) +static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, + int scan_size, struct scan_command *command) { tap_state_t saved_end_state; @@ -495,27 +591,47 @@ static int jlink_get_status(void) result = jlink_usb_read(jlink_handle, 8); if (result != 8) { - LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result); + LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)", result); return ERROR_JTAG_DEVICE_ERROR; } int vref = usb_in_buffer[0] + (usb_in_buffer[1] << 8); - LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \ + LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \ vref / 1000, vref % 1000, \ usb_in_buffer[2], usb_in_buffer[3], usb_in_buffer[4], \ usb_in_buffer[5], usb_in_buffer[6], usb_in_buffer[7]); if (vref < 1500) - LOG_ERROR("Vref too low. Check Target Power\n"); + LOG_ERROR("Vref too low. Check Target Power"); return ERROR_OK; } +#define jlink_dump_printf(context, expr ...) \ + do { \ + if (context) \ + command_print(context, expr); \ + else \ + LOG_INFO(expr); \ + } while(0); + + +static void jlink_caps_dump(struct command_context *ctx) +{ + int i; + + jlink_dump_printf(ctx, "J-Link Capabilities"); + + for (i = 1; i < 31; i++) + if (jlink_caps & (1 << i)) + jlink_dump_printf(ctx, "%s", jlink_cap_str[i]); +} + static int jlink_get_version_info(void) { int result; int len; - uint32_t jlink_caps, jlink_max_size; + uint32_t jlink_max_size; /* query hardware version */ jlink_simple_command(EMU_CMD_VERSION); @@ -523,7 +639,7 @@ static int jlink_get_version_info(void) result = jlink_usb_read(jlink_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)", result); return ERROR_JTAG_DEVICE_ERROR; } @@ -537,7 +653,7 @@ static int jlink_get_version_info(void) result = jlink_usb_read(jlink_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)", result); return ERROR_JTAG_DEVICE_ERROR; } @@ -550,12 +666,12 @@ static int jlink_get_version_info(void) result = jlink_usb_read(jlink_handle, 4); if (4 != result) { - LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result); + LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", 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); + LOG_INFO("J-Link caps 0x%x", (unsigned)jlink_caps); if (jlink_caps & (1 << EMU_CAP_GET_HW_VERSION)) { @@ -565,7 +681,7 @@ static int jlink_get_version_info(void) result = jlink_usb_read(jlink_handle, 4); if (4 != result) { - LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result); + LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result); return ERROR_JTAG_DEVICE_ERROR; } @@ -574,7 +690,7 @@ static int jlink_get_version_info(void) if (major_revision >= 5) jlink_hw_jtag_version = 3; - LOG_INFO("JLink hw version %i", (int)jlink_hw_version); + LOG_INFO("J-Link hw version %i", (int)jlink_hw_version); } if (jlink_caps & (1 << EMU_CAP_GET_MAX_BLOCK_SIZE)) @@ -585,17 +701,32 @@ static int jlink_get_version_info(void) result = jlink_usb_read(jlink_handle, 4); if (4 != result) { - LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result); + LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", 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); + LOG_INFO("J-Link max mem block %i", (int)jlink_max_size); } return ERROR_OK; } +COMMAND_HANDLER(jlink_pid_command) +{ + if (CMD_ARGC != 1) + { + LOG_ERROR("Need exactly one argument to jlink_pid"); + return ERROR_FAIL; + } + + pids[0] = strtoul(CMD_ARGV[0], NULL, 16); + pids[1] = 0; + vids[1] = 0; + + return ERROR_OK; +} + COMMAND_HANDLER(jlink_handle_jlink_info_command) { if (jlink_get_version_info() == ERROR_OK) @@ -607,11 +738,18 @@ COMMAND_HANDLER(jlink_handle_jlink_info_command) return ERROR_OK; } +COMMAND_HANDLER(jlink_handle_jlink_caps_command) +{ + jlink_caps_dump(CMD_CTX); + + return ERROR_OK; +} + COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command) { switch (CMD_ARGC) { case 0: - command_print(CMD_CTX, "jlink hw jtag %i", jlink_hw_jtag_version); + command_print(CMD_CTX, "J-Link hw jtag %i", jlink_hw_jtag_version); break; case 1: { int request_version = atoi(CMD_ARGV[0]); @@ -631,20 +769,42 @@ COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command) return ERROR_OK; } -static const struct command_registration jlink_command_handlers[] = { +static const struct command_registration jlink_subcommand_handlers[] = { + { + .name = "caps", + .handler = &jlink_handle_jlink_caps_command, + .mode = COMMAND_EXEC, + .help = "show jlink capabilities", + }, { - .name = "jlink_info", + .name = "info", .handler = &jlink_handle_jlink_info_command, .mode = COMMAND_EXEC, .help = "show jlink info", }, { - .name = "jlink_hw_jtag", + .name = "hw_jtag", .handler = &jlink_handle_jlink_hw_jtag_command, .mode = COMMAND_EXEC, .help = "access J-Link HW JTAG command version", .usage = "[2|3]", }, + { + .name = "pid", + .handler = &jlink_pid_command, + .mode = COMMAND_CONFIG, + .help = "set the pid of the interface we want to use", + }, + COMMAND_REGISTRATION_DONE +}; + +static const struct command_registration jlink_command_handlers[] = { + { + .name = "jlink", + .mode = COMMAND_ANY, + .help = "perform jlink management", + .chain = jlink_subcommand_handlers, + }, COMMAND_REGISTRATION_DONE }; @@ -700,9 +860,9 @@ static void jlink_tap_ensure_space(int scans, int bits) static void jlink_tap_append_step(int tms, int tdi) { - int index = tap_length / 8; + int index_var = tap_length / 8; - if (index >= JLINK_TAP_BUFFER_SIZE) + if (index_var >= JLINK_TAP_BUFFER_SIZE) { LOG_ERROR("jlink_tap_append_step: overflow"); *(uint32_t *)0xFFFFFFFF = 0; @@ -715,23 +875,24 @@ static void jlink_tap_append_step(int tms, int tdi) // we do not pad TMS, so be sure to initialize all bits if (0 == bit_index) { - tms_buffer[index] = tdi_buffer[index] = 0; + tms_buffer[index_var] = tdi_buffer[index_var] = 0; } if (tms) - tms_buffer[index] |= bit; + tms_buffer[index_var] |= bit; else - tms_buffer[index] &= ~bit; + tms_buffer[index_var] &= ~bit; if (tdi) - tdi_buffer[index] |= bit; + tdi_buffer[index_var] |= bit; else - tdi_buffer[index] &= ~bit; + tdi_buffer[index_var] &= ~bit; tap_length++; } -static void jlink_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command) +static void jlink_tap_append_scan(int length, uint8_t *buffer, + struct scan_command *command) { struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length]; @@ -767,7 +928,7 @@ static int jlink_tap_execute(void) * WARNING: This will interfere with tap state counting. */ while ((DIV_ROUND_UP(tap_length, 8) % 64) == 0) { - jlink_tap_append_step((tap_get_state() == TAP_RESET)?1:0, 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) @@ -787,7 +948,8 @@ static int jlink_tap_execute(void) result = jlink_usb_message(jlink_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; } @@ -834,8 +996,6 @@ static struct jlink* jlink_usb_open() { usb_init(); - const uint16_t vids[] = { VID, 0 }; - const uint16_t pids[] = { PID, 0 }; struct usb_dev_handle *dev; if (jtag_usb_open(vids, pids, &dev) != ERROR_OK) return NULL; @@ -942,7 +1102,8 @@ static int jlink_usb_message(struct jlink *jlink, int out_length, int in_length) result2 = jlink_usb_read_emu_result(jlink); if (1 != result2) { - LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, result=%d, in_length=%i", result2,in_length); + 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); if (1 != result2) @@ -971,7 +1132,8 @@ static int jlink_usb_message(struct jlink *jlink, int out_length, int in_length) return result; } -/* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */ +/* calls the given usb_bulk_* function, allowing for the data to + * trickle in with some timeouts */ static int usb_bulk_with_retries( int (*f)(usb_dev_handle *, int, char *, int, int), usb_dev_handle *dev, int ep, @@ -1018,14 +1180,16 @@ static int jlink_usb_write(struct jlink *jlink, int out_length) if (out_length > JLINK_OUT_BUFFER_SIZE) { - LOG_ERROR("jlink_write illegal out_length=%d (max=%d)", out_length, JLINK_OUT_BUFFER_SIZE); + LOG_ERROR("jlink_write illegal out_length=%d (max=%d)", + out_length, JLINK_OUT_BUFFER_SIZE); return -1; } result = usb_bulk_write_ex(jlink->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); + DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", + out_length, result); #ifdef _DEBUG_USB_COMMS_ jlink_debug_buffer(usb_out_buffer, out_length); @@ -1084,4 +1248,3 @@ static void jlink_debug_buffer(uint8_t *buffer, int length) } } #endif -