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 "interface.h"
37 #define JLINK_WRITE_ENDPOINT 0x02
38 #define JLINK_READ_ENDPOINT 0x81
40 static unsigned int jlink_write_ep
= JLINK_WRITE_ENDPOINT
;
41 static unsigned int jlink_read_ep
= JLINK_READ_ENDPOINT
;
42 static unsigned int jlink_hw_jtag_version
= 2;
44 #define JLINK_USB_TIMEOUT 1000
46 // See Section 1.3.2 of the Segger JLink USB protocol manual
47 /* 2048 is the max value we can use here */
48 //#define JLINK_TAP_BUFFER_SIZE 2048
49 #define JLINK_TAP_BUFFER_SIZE 256
50 //#define JLINK_TAP_BUFFER_SIZE 384
52 #define JLINK_IN_BUFFER_SIZE 2048
53 #define JLINK_OUT_BUFFER_SIZE 2*2048 + 4
54 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
56 /* Global USB buffers */
57 static uint8_t usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
58 static uint8_t usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
59 static uint8_t usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
61 /* Constants for JLink command */
62 #define EMU_CMD_VERSION 0x01
63 #define EMU_CMD_SET_SPEED 0x05
64 #define EMU_CMD_GET_STATE 0x07
65 #define EMU_CMD_HW_CLOCK 0xc8
66 #define EMU_CMD_HW_TMS0 0xc9
67 #define EMU_CMD_HW_TMS1 0xca
68 #define EMU_CMD_HW_JTAG2 0xce
69 #define EMU_CMD_HW_JTAG3 0xcf
70 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
71 #define EMU_CMD_HW_RESET0 0xdc
72 #define EMU_CMD_HW_RESET1 0xdd
73 #define EMU_CMD_HW_TRST0 0xde
74 #define EMU_CMD_HW_TRST1 0xdf
75 #define EMU_CMD_GET_CAPS 0xe8
76 #define EMU_CMD_GET_HW_VERSION 0xf0
78 /* bits return from EMU_CMD_GET_CAPS */
79 #define EMU_CAP_GET_HW_VERSION 1
80 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11
82 /* max speed 12MHz v5.0 jlink */
83 #define JLINK_MAX_SPEED 12000
85 /* External interface functions */
86 static int jlink_execute_queue(void);
87 static int jlink_speed(int speed
);
88 static int jlink_speed_div(int speed
, int* khz
);
89 static int jlink_khz(int khz
, int *jtag_speed
);
90 static int jlink_register_commands(struct command_context
*cmd_ctx
);
91 static int jlink_init(void);
92 static int jlink_quit(void);
94 /* Queue command functions */
95 static void jlink_end_state(tap_state_t state
);
96 static void jlink_state_move(void);
97 static void jlink_path_move(int num_states
, tap_state_t
*path
);
98 static void jlink_runtest(int num_cycles
);
99 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
);
100 static void jlink_reset(int trst
, int srst
);
101 static void jlink_simple_command(uint8_t command
);
102 static int jlink_get_status(void);
104 /* J-Link tap buffer functions */
105 static void jlink_tap_init(void);
106 static int jlink_tap_execute(void);
107 static void jlink_tap_ensure_space(int scans
, int bits
);
108 static void jlink_tap_append_step(int tms
, int tdi
);
109 static void jlink_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
);
111 /* Jlink lowlevel functions */
113 struct usb_dev_handle
* usb_handle
;
116 static struct jlink
*jlink_usb_open(void);
117 static void jlink_usb_close(struct jlink
*jlink
);
118 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
);
119 static int jlink_usb_write(struct jlink
*jlink
, int out_length
);
120 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
);
121 static int jlink_usb_read_emu_result(struct jlink
*jlink
);
123 /* helper functions */
124 static int jlink_get_version_info(void);
126 #ifdef _DEBUG_USB_COMMS_
127 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
130 static enum tap_state jlink_last_state
= TAP_RESET
;
132 static struct jlink
* jlink_handle
;
134 /***************************************************************************/
135 /* External interface implementation */
137 struct jtag_interface jlink_interface
=
140 .execute_queue
= jlink_execute_queue
,
141 .speed
= jlink_speed
,
142 .speed_div
= jlink_speed_div
,
144 .register_commands
= jlink_register_commands
,
149 static void jlink_execute_runtest(struct jtag_command
*cmd
)
151 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
152 cmd
->cmd
.runtest
->num_cycles
,
153 cmd
->cmd
.runtest
->end_state
);
155 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
157 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
160 static void jlink_execute_statemove(struct jtag_command
*cmd
)
162 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
164 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
168 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
170 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
171 cmd
->cmd
.pathmove
->num_states
,
172 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
174 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
175 cmd
->cmd
.pathmove
->path
);
178 static void jlink_execute_scan(struct jtag_command
*cmd
)
184 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
186 jlink_end_state(cmd
->cmd
.scan
->end_state
);
188 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
189 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
191 #ifdef _DEBUG_USB_COMMS_
192 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
194 type
= jtag_scan_type(cmd
->cmd
.scan
);
195 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
196 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
199 static void jlink_execute_reset(struct jtag_command
*cmd
)
201 DEBUG_JTAG_IO("reset trst: %i srst %i",
202 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
205 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
209 static void jlink_execute_sleep(struct jtag_command
*cmd
)
211 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
213 jtag_sleep(cmd
->cmd
.sleep
->us
);
216 static void jlink_execute_command(struct jtag_command
*cmd
)
220 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
221 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
222 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
223 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
224 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
225 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
227 LOG_ERROR("BUG: unknown JTAG command type encountered");
232 static int jlink_execute_queue(void)
234 struct jtag_command
*cmd
= jtag_command_queue
;
238 jlink_execute_command(cmd
);
242 return jlink_tap_execute();
245 /* Sets speed in kHz. */
246 static int jlink_speed(int speed
)
250 if (speed
> JLINK_MAX_SPEED
)
252 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
253 speed
, JLINK_MAX_SPEED
);
257 /* check for RTCK setting */
261 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
262 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
263 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
265 result
= jlink_usb_write(jlink_handle
, 3);
268 LOG_ERROR("J-Link setting speed failed (%d)", result
);
269 return ERROR_JTAG_DEVICE_ERROR
;
275 static int jlink_speed_div(int speed
, int* khz
)
282 static int jlink_khz(int khz
, int *jtag_speed
)
289 static int jlink_init(void)
293 jlink_handle
= jlink_usb_open();
295 if (jlink_handle
== 0)
297 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
298 return ERROR_JTAG_INIT_FAILED
;
302 * The next three instructions were added after discovering a problem while using an oscilloscope. For the V8
303 * SAM-ICE dongle (and likely other j-link device variants), the reset line to the target microprocessor was found to
304 * cycle only intermittently during emulator startup (even after encountering the downstream reset instruction later
305 * 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
306 * state when starting an emulator and 2) something critical happens inside the dongle when it does the first read
307 * following a new USB session. Keeping the processor in reset during the first read collecting version information
308 * seems to prevent errant "J-Link command EMU_CMD_VERSION failed" issues.
311 LOG_INFO("J-Link initialization started / target CPU reset initiated");
312 jlink_simple_command(EMU_CMD_HW_TRST0
);
313 jlink_simple_command(EMU_CMD_HW_RESET0
);
316 jlink_hw_jtag_version
= 2;
318 if (jlink_get_version_info() == ERROR_OK
)
320 /* attempt to get status */
324 LOG_INFO("J-Link JTAG Interface ready");
329 jlink_speed(jtag_get_speed());
331 /* v5/6 jlink seems to have an issue if the first tap move
332 * is not divisible by 8, so we send a TLR on first power up */
333 for (i
= 0; i
< 8; i
++) {
334 jlink_tap_append_step(1, 0);
341 static int jlink_quit(void)
343 jlink_usb_close(jlink_handle
);
347 /***************************************************************************/
348 /* Queue command implementations */
350 static void jlink_end_state(tap_state_t state
)
352 if (tap_is_state_stable(state
))
354 tap_set_end_state(state
);
358 LOG_ERROR("BUG: %i is not a valid end state", state
);
363 /* Goes to the end state. */
364 static void jlink_state_move(void)
368 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
369 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
371 for (i
= 0; i
< tms_scan_bits
; i
++)
373 tms
= (tms_scan
>> i
) & 1;
374 jlink_tap_append_step(tms
, 0);
377 tap_set_state(tap_get_end_state());
380 static void jlink_path_move(int num_states
, tap_state_t
*path
)
384 for (i
= 0; i
< num_states
; i
++)
386 if (path
[i
] == tap_state_transition(tap_get_state(), false))
388 jlink_tap_append_step(0, 0);
390 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
392 jlink_tap_append_step(1, 0);
396 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
400 tap_set_state(path
[i
]);
403 tap_set_end_state(tap_get_state());
406 static void jlink_runtest(int num_cycles
)
410 tap_state_t saved_end_state
= tap_get_end_state();
412 jlink_tap_ensure_space(1,num_cycles
+ 16);
414 /* only do a state_move when we're not already in IDLE */
415 if (tap_get_state() != TAP_IDLE
)
417 jlink_end_state(TAP_IDLE
);
422 /* execute num_cycles */
423 for (i
= 0; i
< num_cycles
; i
++)
425 jlink_tap_append_step(0, 0);
428 /* finish in end_state */
429 jlink_end_state(saved_end_state
);
430 if (tap_get_state() != tap_get_end_state())
436 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
438 tap_state_t saved_end_state
;
440 jlink_tap_ensure_space(1, scan_size
+ 16);
442 saved_end_state
= tap_get_end_state();
444 /* Move to appropriate scan state */
445 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
447 /* Only move if we're not already there */
448 if (tap_get_state() != tap_get_end_state())
451 jlink_end_state(saved_end_state
);
454 jlink_tap_append_scan(scan_size
, buffer
, command
);
456 /* We are in Exit1, go to Pause */
457 jlink_tap_append_step(0, 0);
459 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
461 if (tap_get_state() != tap_get_end_state())
467 static void jlink_reset(int trst
, int srst
)
469 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
471 /* Signals are active low */
474 jlink_simple_command(EMU_CMD_HW_RESET1
);
478 jlink_simple_command(EMU_CMD_HW_RESET0
);
483 jlink_simple_command(EMU_CMD_HW_TRST0
);
488 jlink_simple_command(EMU_CMD_HW_TRST1
);
492 static void jlink_simple_command(uint8_t command
)
496 DEBUG_JTAG_IO("0x%02x", command
);
498 usb_out_buffer
[0] = command
;
499 result
= jlink_usb_write(jlink_handle
, 1);
503 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
507 static int jlink_get_status(void)
511 jlink_simple_command(EMU_CMD_GET_STATE
);
513 result
= jlink_usb_read(jlink_handle
, 8);
516 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
517 return ERROR_JTAG_DEVICE_ERROR
;
520 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
521 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
522 vref
/ 1000, vref
% 1000, \
523 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
524 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
527 LOG_ERROR("Vref too low. Check Target Power\n");
532 static int jlink_get_version_info(void)
536 uint32_t jlink_caps
, jlink_max_size
;
538 /* query hardware version */
539 jlink_simple_command(EMU_CMD_VERSION
);
541 result
= jlink_usb_read(jlink_handle
, 2);
544 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
545 return ERROR_JTAG_DEVICE_ERROR
;
548 len
= buf_get_u32(usb_in_buffer
, 0, 16);
549 if (len
> JLINK_IN_BUFFER_SIZE
)
551 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
552 len
= JLINK_IN_BUFFER_SIZE
;
555 result
= jlink_usb_read(jlink_handle
, len
);
558 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
559 return ERROR_JTAG_DEVICE_ERROR
;
562 usb_in_buffer
[result
] = 0;
563 LOG_INFO("%s", (char *)usb_in_buffer
);
565 /* query hardware capabilities */
566 jlink_simple_command(EMU_CMD_GET_CAPS
);
568 result
= jlink_usb_read(jlink_handle
, 4);
571 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
572 return ERROR_JTAG_DEVICE_ERROR
;
575 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
576 LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps
);
578 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
580 /* query hardware version */
581 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
583 result
= jlink_usb_read(jlink_handle
, 4);
586 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result
);
587 return ERROR_JTAG_DEVICE_ERROR
;
590 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
591 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
592 if (major_revision
>= 5)
593 jlink_hw_jtag_version
= 3;
595 LOG_INFO("JLink hw version %i", (int)jlink_hw_version
);
598 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
600 /* query hardware maximum memory block */
601 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
603 result
= jlink_usb_read(jlink_handle
, 4);
606 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
607 return ERROR_JTAG_DEVICE_ERROR
;
610 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
611 LOG_INFO("JLink max mem block %i", (int)jlink_max_size
);
617 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
619 if (jlink_get_version_info() == ERROR_OK
)
621 /* attempt to get status */
628 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
632 command_print(cmd_ctx
, "jlink hw jtag %i", jlink_hw_jtag_version
);
635 int request_version
= atoi(args
[0]);
636 switch (request_version
) {
638 jlink_hw_jtag_version
= request_version
;
641 return ERROR_COMMAND_SYNTAX_ERROR
;
646 return ERROR_COMMAND_SYNTAX_ERROR
;
652 static int jlink_register_commands(struct command_context
*cmd_ctx
)
655 register_command(cmd_ctx
, NULL
, "jlink_info",
656 &jlink_handle_jlink_info_command
, COMMAND_EXEC
,
658 register_command(cmd_ctx
, NULL
, "jlink_hw_jtag",
659 &jlink_handle_jlink_hw_jtag_command
, COMMAND_EXEC
,
660 "set/get jlink hw jtag command version [2 | 3]");
664 /***************************************************************************/
665 /* J-Link tap functions */
668 static unsigned tap_length
= 0;
669 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
670 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
671 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
673 struct pending_scan_result
{
674 int first
; /* First bit position in tdo_buffer to read */
675 int length
; /* Number of bits to read */
676 struct scan_command
*command
; /* Corresponding scan command */
680 #define MAX_PENDING_SCAN_RESULTS 256
682 static int pending_scan_results_length
;
683 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
685 static void jlink_tap_init(void)
688 pending_scan_results_length
= 0;
691 static void jlink_tap_ensure_space(int scans
, int bits
)
693 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
694 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
696 if (scans
> available_scans
|| bits
> available_bits
)
702 static void jlink_tap_append_step(int tms
, int tdi
)
704 int index
= tap_length
/ 8;
706 if (index
>= JLINK_TAP_BUFFER_SIZE
)
708 LOG_ERROR("jlink_tap_append_step: overflow");
709 *(uint32_t *)0xFFFFFFFF = 0;
713 int bit_index
= tap_length
% 8;
714 uint8_t bit
= 1 << bit_index
;
716 // we do not pad TMS, so be sure to initialize all bits
719 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
723 tms_buffer
[index
] |= bit
;
725 tms_buffer
[index
] &= ~bit
;
728 tdi_buffer
[index
] |= bit
;
730 tdi_buffer
[index
] &= ~bit
;
735 static void jlink_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
)
737 struct pending_scan_result
*pending_scan_result
=
738 &pending_scan_results_buffer
[pending_scan_results_length
];
741 pending_scan_result
->first
= tap_length
;
742 pending_scan_result
->length
= length
;
743 pending_scan_result
->command
= command
;
744 pending_scan_result
->buffer
= buffer
;
746 for (i
= 0; i
< length
; i
++)
748 int tms
= (i
< (length
- 1)) ? 0 : 1;
749 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
750 jlink_tap_append_step(tms
, tdi
);
752 pending_scan_results_length
++;
755 /* Pad and send a tap sequence to the device, and receive the answer.
756 * For the purpose of padding we assume that we are in idle or pause state. */
757 static int jlink_tap_execute(void)
766 /* JLink returns an extra NULL in packet when size of incoming
767 * message is a multiple of 64, creates problems with USB comms.
768 * WARNING: This will interfere with tap state counting. */
769 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
771 jlink_tap_append_step((tap_get_state() == TAP_RESET
)?1:0, 0);
774 // number of full bytes (plus one if some would be left over)
775 byte_length
= DIV_ROUND_UP(tap_length
, 8);
777 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
778 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
779 usb_out_buffer
[1] = 0;
780 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
781 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
782 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
783 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
785 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
786 tap_length
, jlink_last_state
);
788 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
789 if (result
!= byte_length
)
791 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
793 return ERROR_JTAG_QUEUE_FAILED
;
796 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
798 for (i
= 0; i
< pending_scan_results_length
; i
++)
800 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
801 uint8_t *buffer
= pending_scan_result
->buffer
;
802 int length
= pending_scan_result
->length
;
803 int first
= pending_scan_result
->first
;
804 struct scan_command
*command
= pending_scan_result
->command
;
807 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
809 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
811 #ifdef _DEBUG_USB_COMMS_
812 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
815 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
818 return ERROR_JTAG_QUEUE_FAILED
;
821 if (pending_scan_result
->buffer
!= NULL
)
823 free(pending_scan_result
->buffer
);
831 static struct usb_device
* find_jlink_device(void)
833 struct usb_bus
*busses
;
835 struct usb_device
*dev
;
840 busses
= usb_get_busses();
842 /* find jlink device in usb bus */
844 for (bus
= busses
; bus
; bus
= bus
->next
)
846 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
848 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
)) {
857 /*****************************************************************************/
858 /* JLink USB low-level functions */
860 static struct jlink
* jlink_usb_open()
862 struct usb_device
*dev
;
864 struct jlink
*result
;
866 result
= (struct jlink
*) malloc(sizeof(struct jlink
));
870 if ((dev
= find_jlink_device()) == NULL
) {
875 result
->usb_handle
= usb_open(dev
);
877 if (result
->usb_handle
)
880 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS AREA!!!!!!!!!!!
881 * The behavior of libusb is not completely consistent across Windows, Linux, and Mac OS X platforms. The actions taken
882 * in the following compiler conditionals may not agree with published documentation for libusb, but were found
883 * to be necessary through trials and tribulations. Even little tweaks can break one or more platforms, so if you do make changes
884 * test them carefully on all platforms before committing them!
889 usb_reset(result
->usb_handle
);
895 /* reopen jlink after usb_reset
896 * on win32 this may take a second or two to re-enumerate */
897 while ((dev
= find_jlink_device()) == NULL
)
912 result
->usb_handle
= usb_open(dev
);
917 if (result
->usb_handle
)
919 /* usb_set_configuration required under win32 */
920 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
921 usb_claim_interface(result
->usb_handle
, 0);
925 * This makes problems under Mac OS X. And is not needed
926 * under Windows. Hopefully this will not break a linux build
928 usb_set_altinterface(result
->usb_handle
, 0);
930 struct usb_interface
*iface
= dev
->config
->interface
;
931 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
932 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
934 uint8_t epnum
= desc
->endpoint
[i
].bEndpointAddress
;
935 bool is_input
= epnum
& 0x80;
936 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
938 jlink_read_ep
= epnum
;
940 jlink_write_ep
= epnum
;
951 static void jlink_usb_close(struct jlink
*jlink
)
953 usb_close(jlink
->usb_handle
);
957 /* Send a message and receive the reply. */
958 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
962 result
= jlink_usb_write(jlink
, out_length
);
963 if (result
!= out_length
)
965 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
967 return ERROR_JTAG_DEVICE_ERROR
;
970 result
= jlink_usb_read(jlink
, in_length
);
971 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
973 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
975 return ERROR_JTAG_DEVICE_ERROR
;
978 if (jlink_hw_jtag_version
< 3)
981 int result2
= ERROR_OK
;
982 if (result
== in_length
)
984 /* Must read the result from the EMU too */
985 result2
= jlink_usb_read_emu_result(jlink
);
988 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, result=%d, in_length=%i", result2
,in_length
);
989 /* Try again once, should only happen if (in_length%64 == 0) */
990 result2
= jlink_usb_read_emu_result(jlink
);
993 LOG_ERROR("jlink_usb_read_emu_result failed "
994 "(requested = 1, result=%d)", result2
);
995 return ERROR_JTAG_DEVICE_ERROR
;
999 /* Check the result itself */
1000 result2
= usb_emu_result_buffer
[0];
1004 /* Save the result, then remove it from return value */
1005 result2
= usb_in_buffer
[result
--];
1010 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
1011 return ERROR_JTAG_DEVICE_ERROR
;
1017 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
1018 static int usb_bulk_with_retries(
1019 int (*f
)(usb_dev_handle
*, int, char *, int, int),
1020 usb_dev_handle
*dev
, int ep
,
1021 char *bytes
, int size
, int timeout
)
1023 int tries
= 3, count
= 0;
1025 while (tries
&& (count
< size
))
1027 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1030 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1036 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
1037 char *buff
, int size
, int timeout
)
1039 /* usb_bulk_write() takes const char *buff */
1040 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1043 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
1044 char *bytes
, int size
, int timeout
)
1046 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1047 dev
, ep
, bytes
, size
, timeout
);
1050 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1051 char *bytes
, int size
, int timeout
)
1053 return usb_bulk_with_retries(&usb_bulk_read
,
1054 dev
, ep
, bytes
, size
, timeout
);
1057 /* Write data from out_buffer to USB. */
1058 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1062 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1064 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
1068 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1069 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1071 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
1073 #ifdef _DEBUG_USB_COMMS_
1074 jlink_debug_buffer(usb_out_buffer
, out_length
);
1079 /* Read data from USB into in_buffer. */
1080 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1082 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1083 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1085 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1087 #ifdef _DEBUG_USB_COMMS_
1088 jlink_debug_buffer(usb_in_buffer
, result
);
1093 /* Read the result from the previous EMU cmd into result_buffer. */
1094 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1096 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1097 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1100 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1102 #ifdef _DEBUG_USB_COMMS_
1103 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1108 #ifdef _DEBUG_USB_COMMS_
1109 #define BYTES_PER_LINE 16
1111 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1118 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1120 snprintf(line
, 5, "%04x", i
);
1121 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1123 snprintf(s
, 4, " %02x", buffer
[j
]);
1126 LOG_DEBUG("%s", line
);
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)