1 /***************************************************************************
2 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
3 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
28 #include <jtag/interface.h>
29 #include <jtag/commands.h>
30 #include "usb_common.h"
32 /* See Segger's public documentation:
33 * Reference manual for J-Link USB Protocol
34 * Document RM08001-R6 Date: June 16, 2009
35 * (Or newer, with some SWD information).
37 http://www.segger.com/cms/admin/uploads/productDocs/RM08001_JLinkUSBProtocol.pdf
41 * The default pid of the segger is 0x0101
42 * But when you change the USB Address it will also
44 * pid = ( usb_address > 0x4) ? 0x0101 : (0x101 + usb_address)
46 #define VID 0x1366, 0x1366, 0x1366, 0x1366
47 #define PID 0x0101, 0x0102, 0x0103, 0x0104
49 #define JLINK_WRITE_ENDPOINT 0x02
50 #define JLINK_READ_ENDPOINT 0x81
52 static unsigned int jlink_write_ep = JLINK_WRITE_ENDPOINT;
53 static unsigned int jlink_read_ep = JLINK_READ_ENDPOINT;
54 static unsigned int jlink_hw_jtag_version = 2;
56 #define JLINK_USB_TIMEOUT 1000
58 // See Section 1.3.2 of the Segger JLink USB protocol manual
59 /* 2048 is the max value we can use here */
60 //#define JLINK_TAP_BUFFER_SIZE 2048
61 #define JLINK_TAP_BUFFER_SIZE 256
62 //#define JLINK_TAP_BUFFER_SIZE 384
64 #define JLINK_IN_BUFFER_SIZE 2048
65 #define JLINK_OUT_BUFFER_SIZE 2*2048 + 4
66 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
68 /* Global USB buffers */
69 static uint8_t usb_in_buffer[JLINK_IN_BUFFER_SIZE];
70 static uint8_t usb_out_buffer[JLINK_OUT_BUFFER_SIZE];
71 static uint8_t usb_emu_result_buffer[JLINK_EMU_RESULT_BUFFER_SIZE];
73 /* Constants for JLink command */
74 #define EMU_CMD_VERSION 0x01
75 #define EMU_CMD_SET_SPEED 0x05
76 #define EMU_CMD_GET_STATE 0x07
77 #define EMU_CMD_HW_CLOCK 0xc8
78 #define EMU_CMD_HW_TMS0 0xc9
79 #define EMU_CMD_HW_TMS1 0xca
80 #define EMU_CMD_HW_JTAG2 0xce
81 #define EMU_CMD_HW_JTAG3 0xcf
82 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
83 #define EMU_CMD_HW_RESET0 0xdc
84 #define EMU_CMD_HW_RESET1 0xdd
85 #define EMU_CMD_HW_TRST0 0xde
86 #define EMU_CMD_HW_TRST1 0xdf
87 #define EMU_CMD_GET_CAPS 0xe8
88 #define EMU_CMD_GET_HW_VERSION 0xf0
90 /* bits return from EMU_CMD_GET_CAPS */
91 #define EMU_CAP_GET_HW_VERSION 1
92 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11
94 /* max speed 12MHz v5.0 jlink */
95 #define JLINK_MAX_SPEED 12000
97 /* Queue command functions */
98 static void jlink_end_state(tap_state_t state);
99 static void jlink_state_move(void);
100 static void jlink_path_move(int num_states, tap_state_t *path);
101 static void jlink_runtest(int num_cycles);
102 static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer,
103 int scan_size, struct scan_command *command);
104 static void jlink_reset(int trst, int srst);
105 static void jlink_simple_command(uint8_t command);
106 static int jlink_get_status(void);
108 /* J-Link tap buffer functions */
109 static void jlink_tap_init(void);
110 static int jlink_tap_execute(void);
111 static void jlink_tap_ensure_space(int scans, int bits);
112 static void jlink_tap_append_step(int tms, int tdi);
113 static void jlink_tap_append_scan(int length, uint8_t *buffer,
114 struct scan_command *command);
116 /* Jlink lowlevel functions */
118 struct usb_dev_handle* usb_handle;
121 static struct jlink *jlink_usb_open(void);
122 static void jlink_usb_close(struct jlink *jlink);
123 static int jlink_usb_message(struct jlink *jlink, int out_length, int in_length);
124 static int jlink_usb_write(struct jlink *jlink, int out_length);
125 static int jlink_usb_read(struct jlink *jlink, int expected_size);
126 static int jlink_usb_read_emu_result(struct jlink *jlink);
128 /* helper functions */
129 static int jlink_get_version_info(void);
131 #ifdef _DEBUG_USB_COMMS_
132 static void jlink_debug_buffer(uint8_t *buffer, int length);
135 static enum tap_state jlink_last_state = TAP_RESET;
137 static struct jlink* jlink_handle;
139 /***************************************************************************/
140 /* External interface implementation */
142 static void jlink_execute_runtest(struct jtag_command *cmd)
144 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
145 cmd->cmd.runtest->num_cycles,
146 cmd->cmd.runtest->end_state);
148 jlink_end_state(cmd->cmd.runtest->end_state);
150 jlink_runtest(cmd->cmd.runtest->num_cycles);
153 static void jlink_execute_statemove(struct jtag_command *cmd)
155 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
157 jlink_end_state(cmd->cmd.statemove->end_state);
161 static void jlink_execute_pathmove(struct jtag_command *cmd)
163 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
164 cmd->cmd.pathmove->num_states,
165 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
167 jlink_path_move(cmd->cmd.pathmove->num_states,
168 cmd->cmd.pathmove->path);
171 static void jlink_execute_scan(struct jtag_command *cmd)
177 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd->cmd.scan->end_state));
179 jlink_end_state(cmd->cmd.scan->end_state);
181 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
182 DEBUG_JTAG_IO("scan input, length = %d", scan_size);
184 #ifdef _DEBUG_USB_COMMS_
185 jlink_debug_buffer(buffer, (scan_size + 7) / 8);
187 type = jtag_scan_type(cmd->cmd.scan);
188 jlink_scan(cmd->cmd.scan->ir_scan,
189 type, buffer, scan_size, cmd->cmd.scan);
192 static void jlink_execute_reset(struct jtag_command *cmd)
194 DEBUG_JTAG_IO("reset trst: %i srst %i",
195 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
198 jlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
202 static void jlink_execute_sleep(struct jtag_command *cmd)
204 DEBUG_JTAG_IO("sleep %" PRIi32 "", cmd->cmd.sleep->us);
206 jtag_sleep(cmd->cmd.sleep->us);
209 static void jlink_execute_command(struct jtag_command *cmd)
213 case JTAG_RUNTEST: jlink_execute_runtest(cmd); break;
214 case JTAG_TLR_RESET: jlink_execute_statemove(cmd); break;
215 case JTAG_PATHMOVE: jlink_execute_pathmove(cmd); break;
216 case JTAG_SCAN: jlink_execute_scan(cmd); break;
217 case JTAG_RESET: jlink_execute_reset(cmd); break;
218 case JTAG_SLEEP: jlink_execute_sleep(cmd); break;
220 LOG_ERROR("BUG: unknown JTAG command type encountered");
225 static int jlink_execute_queue(void)
227 struct jtag_command *cmd = jtag_command_queue;
231 jlink_execute_command(cmd);
235 return jlink_tap_execute();
238 /* Sets speed in kHz. */
239 static int jlink_speed(int speed)
243 if (speed > JLINK_MAX_SPEED)
245 LOG_INFO("reduce speed request: %dkHz to %dkHz maximum",
246 speed, JLINK_MAX_SPEED);
247 speed = JLINK_MAX_SPEED;
250 /* check for RTCK setting */
254 usb_out_buffer[0] = EMU_CMD_SET_SPEED;
255 usb_out_buffer[1] = (speed >> 0) & 0xff;
256 usb_out_buffer[2] = (speed >> 8) & 0xff;
258 result = jlink_usb_write(jlink_handle, 3);
261 LOG_ERROR("J-Link setting speed failed (%d)", result);
262 return ERROR_JTAG_DEVICE_ERROR;
268 static int jlink_speed_div(int speed, int* khz)
275 static int jlink_khz(int khz, int *jtag_speed)
282 static int jlink_init(void)
286 jlink_handle = jlink_usb_open();
288 if (jlink_handle == 0)
290 LOG_ERROR("Cannot find jlink Interface! Please check "
291 "connection and permissions.");
292 return ERROR_JTAG_INIT_FAILED;
296 * The next three instructions were added after discovering a problem
297 * while using an oscilloscope.
298 * For the V8 SAM-ICE dongle (and likely other j-link device variants),
299 * the reset line to the target microprocessor was found to cycle only
300 * intermittently during emulator startup (even after encountering the
301 * downstream reset instruction later in the code).
302 * This was found to create two issues:
303 * 1) In general it is a bad practice to not reset a CPU to a known
304 * state when starting an emulator and
305 * 2) something critical happens inside the dongle when it does the
306 * first read following a new USB session.
307 * Keeping the processor in reset during the first read collecting
308 * version information seems to prevent errant
309 * "J-Link command EMU_CMD_VERSION failed" issues.
312 LOG_INFO("J-Link initialization started / target CPU reset initiated");
313 jlink_simple_command(EMU_CMD_HW_TRST0);
314 jlink_simple_command(EMU_CMD_HW_RESET0);
317 jlink_hw_jtag_version = 2;
319 if (jlink_get_version_info() == ERROR_OK)
321 /* attempt to get status */
325 LOG_INFO("J-Link JTAG Interface ready");
331 int retval = jtag_get_speed(&jtag_speed_var);
332 if (retval != ERROR_OK)
334 jlink_speed(jtag_speed_var);
336 /* v5/6 jlink seems to have an issue if the first tap move
337 * is not divisible by 8, so we send a TLR on first power up */
338 for (i = 0; i < 8; i++) {
339 jlink_tap_append_step(1, 0);
346 static int jlink_quit(void)
348 jlink_usb_close(jlink_handle);
352 /***************************************************************************/
353 /* Queue command implementations */
355 static void jlink_end_state(tap_state_t state)
357 if (tap_is_state_stable(state))
359 tap_set_end_state(state);
363 LOG_ERROR("BUG: %i is not a valid end state", state);
368 /* Goes to the end state. */
369 static void jlink_state_move(void)
373 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
374 uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
376 for (i = 0; i < tms_scan_bits; i++)
378 tms = (tms_scan >> i) & 1;
379 jlink_tap_append_step(tms, 0);
382 tap_set_state(tap_get_end_state());
385 static void jlink_path_move(int num_states, tap_state_t *path)
389 for (i = 0; i < num_states; i++)
391 if (path[i] == tap_state_transition(tap_get_state(), false))
393 jlink_tap_append_step(0, 0);
395 else if (path[i] == tap_state_transition(tap_get_state(), true))
397 jlink_tap_append_step(1, 0);
401 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
402 tap_state_name(tap_get_state()), tap_state_name(path[i]));
406 tap_set_state(path[i]);
409 tap_set_end_state(tap_get_state());
412 static void jlink_runtest(int num_cycles)
416 tap_state_t saved_end_state = tap_get_end_state();
418 jlink_tap_ensure_space(1,num_cycles + 16);
420 /* only do a state_move when we're not already in IDLE */
421 if (tap_get_state() != TAP_IDLE)
423 jlink_end_state(TAP_IDLE);
428 /* execute num_cycles */
429 for (i = 0; i < num_cycles; i++)
431 jlink_tap_append_step(0, 0);
434 /* finish in end_state */
435 jlink_end_state(saved_end_state);
436 if (tap_get_state() != tap_get_end_state())
442 static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer,
443 int scan_size, struct scan_command *command)
445 tap_state_t saved_end_state;
447 jlink_tap_ensure_space(1, scan_size + 16);
449 saved_end_state = tap_get_end_state();
451 /* Move to appropriate scan state */
452 jlink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
454 /* Only move if we're not already there */
455 if (tap_get_state() != tap_get_end_state())
458 jlink_end_state(saved_end_state);
461 jlink_tap_append_scan(scan_size, buffer, command);
463 /* We are in Exit1, go to Pause */
464 jlink_tap_append_step(0, 0);
466 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
468 if (tap_get_state() != tap_get_end_state())
474 static void jlink_reset(int trst, int srst)
476 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
478 /* Signals are active low */
481 jlink_simple_command(EMU_CMD_HW_RESET1);
485 jlink_simple_command(EMU_CMD_HW_RESET0);
490 jlink_simple_command(EMU_CMD_HW_TRST0);
495 jlink_simple_command(EMU_CMD_HW_TRST1);
499 static void jlink_simple_command(uint8_t command)
503 DEBUG_JTAG_IO("0x%02x", command);
505 usb_out_buffer[0] = command;
506 result = jlink_usb_write(jlink_handle, 1);
510 LOG_ERROR("J-Link command 0x%02x failed (%d)", command, result);
514 static int jlink_get_status(void)
518 jlink_simple_command(EMU_CMD_GET_STATE);
520 result = jlink_usb_read(jlink_handle, 8);
523 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)", result);
524 return ERROR_JTAG_DEVICE_ERROR;
527 int vref = usb_in_buffer[0] + (usb_in_buffer[1] << 8);
528 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \
529 vref / 1000, vref % 1000, \
530 usb_in_buffer[2], usb_in_buffer[3], usb_in_buffer[4], \
531 usb_in_buffer[5], usb_in_buffer[6], usb_in_buffer[7]);
534 LOG_ERROR("Vref too low. Check Target Power");
539 static int jlink_get_version_info(void)
543 uint32_t jlink_caps, jlink_max_size;
545 /* query hardware version */
546 jlink_simple_command(EMU_CMD_VERSION);
548 result = jlink_usb_read(jlink_handle, 2);
551 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result);
552 return ERROR_JTAG_DEVICE_ERROR;
555 len = buf_get_u32(usb_in_buffer, 0, 16);
556 if (len > JLINK_IN_BUFFER_SIZE)
558 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len);
559 len = JLINK_IN_BUFFER_SIZE;
562 result = jlink_usb_read(jlink_handle, len);
565 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result);
566 return ERROR_JTAG_DEVICE_ERROR;
569 usb_in_buffer[result] = 0;
570 LOG_INFO("%s", (char *)usb_in_buffer);
572 /* query hardware capabilities */
573 jlink_simple_command(EMU_CMD_GET_CAPS);
575 result = jlink_usb_read(jlink_handle, 4);
578 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", result);
579 return ERROR_JTAG_DEVICE_ERROR;
582 jlink_caps = buf_get_u32(usb_in_buffer, 0, 32);
583 LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps);
585 if (jlink_caps & (1 << EMU_CAP_GET_HW_VERSION))
587 /* query hardware version */
588 jlink_simple_command(EMU_CMD_GET_HW_VERSION);
590 result = jlink_usb_read(jlink_handle, 4);
593 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result);
594 return ERROR_JTAG_DEVICE_ERROR;
597 uint32_t jlink_hw_version = buf_get_u32(usb_in_buffer, 0, 32);
598 uint32_t major_revision = (jlink_hw_version / 10000) % 100;
599 if (major_revision >= 5)
600 jlink_hw_jtag_version = 3;
602 LOG_INFO("JLink hw version %i", (int)jlink_hw_version);
605 if (jlink_caps & (1 << EMU_CAP_GET_MAX_BLOCK_SIZE))
607 /* query hardware maximum memory block */
608 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK);
610 result = jlink_usb_read(jlink_handle, 4);
613 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", result);
614 return ERROR_JTAG_DEVICE_ERROR;
617 jlink_max_size = buf_get_u32(usb_in_buffer, 0, 32);
618 LOG_INFO("JLink max mem block %i", (int)jlink_max_size);
624 COMMAND_HANDLER(jlink_handle_jlink_info_command)
626 if (jlink_get_version_info() == ERROR_OK)
628 /* attempt to get status */
635 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command)
639 command_print(CMD_CTX, "jlink hw jtag %i", jlink_hw_jtag_version);
642 int request_version = atoi(CMD_ARGV[0]);
643 switch (request_version) {
645 jlink_hw_jtag_version = request_version;
648 return ERROR_COMMAND_SYNTAX_ERROR;
653 return ERROR_COMMAND_SYNTAX_ERROR;
659 static const struct command_registration jlink_command_handlers[] = {
661 .name = "jlink_info",
662 .handler = &jlink_handle_jlink_info_command,
663 .mode = COMMAND_EXEC,
664 .help = "show jlink info",
667 .name = "jlink_hw_jtag",
668 .handler = &jlink_handle_jlink_hw_jtag_command,
669 .mode = COMMAND_EXEC,
670 .help = "access J-Link HW JTAG command version",
673 COMMAND_REGISTRATION_DONE
676 struct jtag_interface jlink_interface = {
678 .commands = jlink_command_handlers,
680 .execute_queue = jlink_execute_queue,
681 .speed = jlink_speed,
682 .speed_div = jlink_speed_div,
688 /***************************************************************************/
689 /* J-Link tap functions */
692 static unsigned tap_length = 0;
693 static uint8_t tms_buffer[JLINK_TAP_BUFFER_SIZE];
694 static uint8_t tdi_buffer[JLINK_TAP_BUFFER_SIZE];
695 static uint8_t tdo_buffer[JLINK_TAP_BUFFER_SIZE];
697 struct pending_scan_result {
698 int first; /* First bit position in tdo_buffer to read */
699 int length; /* Number of bits to read */
700 struct scan_command *command; /* Corresponding scan command */
704 #define MAX_PENDING_SCAN_RESULTS 256
706 static int pending_scan_results_length;
707 static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
709 static void jlink_tap_init(void)
712 pending_scan_results_length = 0;
715 static void jlink_tap_ensure_space(int scans, int bits)
717 int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
718 int available_bits = JLINK_TAP_BUFFER_SIZE * 8 - tap_length - 32;
720 if (scans > available_scans || bits > available_bits)
726 static void jlink_tap_append_step(int tms, int tdi)
728 int index_var = tap_length / 8;
730 if (index_var >= JLINK_TAP_BUFFER_SIZE)
732 LOG_ERROR("jlink_tap_append_step: overflow");
733 *(uint32_t *)0xFFFFFFFF = 0;
737 int bit_index = tap_length % 8;
738 uint8_t bit = 1 << bit_index;
740 // we do not pad TMS, so be sure to initialize all bits
743 tms_buffer[index_var] = tdi_buffer[index_var] = 0;
747 tms_buffer[index_var] |= bit;
749 tms_buffer[index_var] &= ~bit;
752 tdi_buffer[index_var] |= bit;
754 tdi_buffer[index_var] &= ~bit;
759 static void jlink_tap_append_scan(int length, uint8_t *buffer,
760 struct scan_command *command)
762 struct pending_scan_result *pending_scan_result =
763 &pending_scan_results_buffer[pending_scan_results_length];
766 pending_scan_result->first = tap_length;
767 pending_scan_result->length = length;
768 pending_scan_result->command = command;
769 pending_scan_result->buffer = buffer;
771 for (i = 0; i < length; i++)
773 int tms = (i < (length - 1)) ? 0 : 1;
774 int tdi = (buffer[i / 8] & (1 << (i % 8))) != 0;
775 jlink_tap_append_step(tms, tdi);
777 pending_scan_results_length++;
780 /* Pad and send a tap sequence to the device, and receive the answer.
781 * For the purpose of padding we assume that we are in idle or pause state. */
782 static int jlink_tap_execute(void)
791 /* JLink returns an extra NULL in packet when size of incoming
792 * message is a multiple of 64, creates problems with USB comms.
793 * WARNING: This will interfere with tap state counting. */
794 while ((DIV_ROUND_UP(tap_length, 8) % 64) == 0)
796 jlink_tap_append_step((tap_get_state() == TAP_RESET) ? 1 : 0, 0);
799 // number of full bytes (plus one if some would be left over)
800 byte_length = DIV_ROUND_UP(tap_length, 8);
802 bool use_jtag3 = jlink_hw_jtag_version >= 3;
803 usb_out_buffer[0] = use_jtag3 ? EMU_CMD_HW_JTAG3 : EMU_CMD_HW_JTAG2;
804 usb_out_buffer[1] = 0;
805 usb_out_buffer[2] = (tap_length >> 0) & 0xff;
806 usb_out_buffer[3] = (tap_length >> 8) & 0xff;
807 memcpy(usb_out_buffer + 4, tms_buffer, byte_length);
808 memcpy(usb_out_buffer + 4 + byte_length, tdi_buffer, byte_length);
810 jlink_last_state = jtag_debug_state_machine(tms_buffer, tdi_buffer,
811 tap_length, jlink_last_state);
813 result = jlink_usb_message(jlink_handle, 4 + 2 * byte_length, byte_length);
814 if (result != byte_length)
816 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
817 result, byte_length);
819 return ERROR_JTAG_QUEUE_FAILED;
822 memcpy(tdo_buffer, usb_in_buffer, byte_length);
824 for (i = 0; i < pending_scan_results_length; i++)
826 struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i];
827 uint8_t *buffer = pending_scan_result->buffer;
828 int length = pending_scan_result->length;
829 int first = pending_scan_result->first;
830 struct scan_command *command = pending_scan_result->command;
833 buf_set_buf(tdo_buffer, first, buffer, 0, length);
835 DEBUG_JTAG_IO("pending scan result, length = %d", length);
837 #ifdef _DEBUG_USB_COMMS_
838 jlink_debug_buffer(buffer, DIV_ROUND_UP(length, 8));
841 if (jtag_read_buffer(buffer, command) != ERROR_OK)
844 return ERROR_JTAG_QUEUE_FAILED;
847 if (pending_scan_result->buffer != NULL)
849 free(pending_scan_result->buffer);
857 /*****************************************************************************/
858 /* JLink USB low-level functions */
860 static struct jlink* jlink_usb_open()
864 const uint16_t vids[] = { VID, 0 };
865 const uint16_t pids[] = { PID, 0 };
866 struct usb_dev_handle *dev;
867 if (jtag_usb_open(vids, pids, &dev) != ERROR_OK)
870 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
871 * AREA!!!!!!!!!!! The behavior of libusb is not completely
872 * consistent across Windows, Linux, and Mac OS X platforms.
873 * The actions taken in the following compiler conditionals may
874 * not agree with published documentation for libusb, but were
875 * found to be necessary through trials and tribulations. Even
876 * little tweaks can break one or more platforms, so if you do
877 * make changes test them carefully on all platforms before
888 /* reopen jlink after usb_reset
889 * on win32 this may take a second or two to re-enumerate */
891 while ((retval = jtag_usb_open(vids, pids, &dev)) != ERROR_OK)
899 if (ERROR_OK != retval)
905 /* usb_set_configuration required under win32 */
906 struct usb_device *udev = usb_device(dev);
907 usb_set_configuration(dev, udev->config[0].bConfigurationValue);
908 usb_claim_interface(dev, 0);
912 * This makes problems under Mac OS X. And is not needed
913 * under Windows. Hopefully this will not break a linux build
915 usb_set_altinterface(result->usb_handle, 0);
917 struct usb_interface *iface = udev->config->interface;
918 struct usb_interface_descriptor *desc = iface->altsetting;
919 for (int i = 0; i < desc->bNumEndpoints; i++)
921 uint8_t epnum = desc->endpoint[i].bEndpointAddress;
922 bool is_input = epnum & 0x80;
923 LOG_DEBUG("usb ep %s %02x", is_input ? "in" : "out", epnum);
925 jlink_read_ep = epnum;
927 jlink_write_ep = epnum;
930 struct jlink *result = malloc(sizeof(struct jlink));
931 result->usb_handle = dev;
935 static void jlink_usb_close(struct jlink *jlink)
937 usb_close(jlink->usb_handle);
941 /* Send a message and receive the reply. */
942 static int jlink_usb_message(struct jlink *jlink, int out_length, int in_length)
946 result = jlink_usb_write(jlink, out_length);
947 if (result != out_length)
949 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
951 return ERROR_JTAG_DEVICE_ERROR;
954 result = jlink_usb_read(jlink, in_length);
955 if ((result != in_length) && (result != (in_length + 1)))
957 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
959 return ERROR_JTAG_DEVICE_ERROR;
962 if (jlink_hw_jtag_version < 3)
965 int result2 = ERROR_OK;
966 if (result == in_length)
968 /* Must read the result from the EMU too */
969 result2 = jlink_usb_read_emu_result(jlink);
972 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, "
973 "result=%d, in_length=%i", result2, in_length);
974 /* Try again once, should only happen if (in_length%64 == 0) */
975 result2 = jlink_usb_read_emu_result(jlink);
978 LOG_ERROR("jlink_usb_read_emu_result failed "
979 "(requested = 1, result=%d)", result2);
980 return ERROR_JTAG_DEVICE_ERROR;
984 /* Check the result itself */
985 result2 = usb_emu_result_buffer[0];
989 /* Save the result, then remove it from return value */
990 result2 = usb_in_buffer[result--];
995 LOG_ERROR("jlink_usb_message failed with result=%d)", result2);
996 return ERROR_JTAG_DEVICE_ERROR;
1002 /* calls the given usb_bulk_* function, allowing for the data to
1003 * trickle in with some timeouts */
1004 static int usb_bulk_with_retries(
1005 int (*f)(usb_dev_handle *, int, char *, int, int),
1006 usb_dev_handle *dev, int ep,
1007 char *bytes, int size, int timeout)
1009 int tries = 3, count = 0;
1011 while (tries && (count < size))
1013 int result = f(dev, ep, bytes + count, size - count, timeout);
1016 else if ((-ETIMEDOUT != result) || !--tries)
1022 static int wrap_usb_bulk_write(usb_dev_handle *dev, int ep,
1023 char *buff, int size, int timeout)
1025 /* usb_bulk_write() takes const char *buff */
1026 return usb_bulk_write(dev, ep, buff, size, timeout);
1029 static inline int usb_bulk_write_ex(usb_dev_handle *dev, int ep,
1030 char *bytes, int size, int timeout)
1032 return usb_bulk_with_retries(&wrap_usb_bulk_write,
1033 dev, ep, bytes, size, timeout);
1036 static inline int usb_bulk_read_ex(usb_dev_handle *dev, int ep,
1037 char *bytes, int size, int timeout)
1039 return usb_bulk_with_retries(&usb_bulk_read,
1040 dev, ep, bytes, size, timeout);
1043 /* Write data from out_buffer to USB. */
1044 static int jlink_usb_write(struct jlink *jlink, int out_length)
1048 if (out_length > JLINK_OUT_BUFFER_SIZE)
1050 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)",
1051 out_length, JLINK_OUT_BUFFER_SIZE);
1055 result = usb_bulk_write_ex(jlink->usb_handle, jlink_write_ep,
1056 (char *)usb_out_buffer, out_length, JLINK_USB_TIMEOUT);
1058 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d",
1059 out_length, result);
1061 #ifdef _DEBUG_USB_COMMS_
1062 jlink_debug_buffer(usb_out_buffer, out_length);
1067 /* Read data from USB into in_buffer. */
1068 static int jlink_usb_read(struct jlink *jlink, int expected_size)
1070 int result = usb_bulk_read_ex(jlink->usb_handle, jlink_read_ep,
1071 (char *)usb_in_buffer, expected_size, JLINK_USB_TIMEOUT);
1073 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result);
1075 #ifdef _DEBUG_USB_COMMS_
1076 jlink_debug_buffer(usb_in_buffer, result);
1081 /* Read the result from the previous EMU cmd into result_buffer. */
1082 static int jlink_usb_read_emu_result(struct jlink *jlink)
1084 int result = usb_bulk_read_ex(jlink->usb_handle, jlink_read_ep,
1085 (char *)usb_emu_result_buffer, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1088 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result);
1090 #ifdef _DEBUG_USB_COMMS_
1091 jlink_debug_buffer(usb_emu_result_buffer, result);
1096 #ifdef _DEBUG_USB_COMMS_
1097 #define BYTES_PER_LINE 16
1099 static void jlink_debug_buffer(uint8_t *buffer, int length)
1106 for (i = 0; i < length; i += BYTES_PER_LINE)
1108 snprintf(line, 5, "%04x", i);
1109 for (j = i; j < i + BYTES_PER_LINE && j < length; j++)
1111 snprintf(s, 4, " %02x", buffer[j]);
1114 LOG_DEBUG("%s", line);