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 /* pid could be specified at runtime */
140 static uint16_t vids
[] = { VID
, 0 };
141 static uint16_t pids
[] = { PID
, 0 };
143 /***************************************************************************/
144 /* External interface implementation */
146 static void jlink_execute_runtest(struct jtag_command
*cmd
)
148 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
149 cmd
->cmd
.runtest
->num_cycles
,
150 cmd
->cmd
.runtest
->end_state
);
152 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
154 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
157 static void jlink_execute_statemove(struct jtag_command
*cmd
)
159 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
161 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
165 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
167 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
168 cmd
->cmd
.pathmove
->num_states
,
169 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
171 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
172 cmd
->cmd
.pathmove
->path
);
175 static void jlink_execute_scan(struct jtag_command
*cmd
)
181 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
183 jlink_end_state(cmd
->cmd
.scan
->end_state
);
185 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
186 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
188 #ifdef _DEBUG_USB_COMMS_
189 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
191 type
= jtag_scan_type(cmd
->cmd
.scan
);
192 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
193 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
196 static void jlink_execute_reset(struct jtag_command
*cmd
)
198 DEBUG_JTAG_IO("reset trst: %i srst %i",
199 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
202 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
206 static void jlink_execute_sleep(struct jtag_command
*cmd
)
208 DEBUG_JTAG_IO("sleep %" PRIi32
"", cmd
->cmd
.sleep
->us
);
210 jtag_sleep(cmd
->cmd
.sleep
->us
);
213 static void jlink_execute_command(struct jtag_command
*cmd
)
217 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
218 case JTAG_TLR_RESET
: jlink_execute_statemove(cmd
); break;
219 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
220 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
221 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
222 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
224 LOG_ERROR("BUG: unknown JTAG command type encountered");
229 static int jlink_execute_queue(void)
231 struct jtag_command
*cmd
= jtag_command_queue
;
235 jlink_execute_command(cmd
);
239 return jlink_tap_execute();
242 /* Sets speed in kHz. */
243 static int jlink_speed(int speed
)
247 if (speed
> JLINK_MAX_SPEED
)
249 LOG_INFO("reduce speed request: %dkHz to %dkHz maximum",
250 speed
, JLINK_MAX_SPEED
);
251 speed
= JLINK_MAX_SPEED
;
254 /* check for RTCK setting */
258 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
259 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
260 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
262 result
= jlink_usb_write(jlink_handle
, 3);
265 LOG_ERROR("J-Link setting speed failed (%d)", result
);
266 return ERROR_JTAG_DEVICE_ERROR
;
272 static int jlink_speed_div(int speed
, int* khz
)
279 static int jlink_khz(int khz
, int *jtag_speed
)
286 static int jlink_init(void)
290 jlink_handle
= jlink_usb_open();
292 if (jlink_handle
== 0)
294 LOG_ERROR("Cannot find jlink Interface! Please check "
295 "connection and permissions.");
296 return ERROR_JTAG_INIT_FAILED
;
300 * The next three instructions were added after discovering a problem
301 * while using an oscilloscope.
302 * For the V8 SAM-ICE dongle (and likely other j-link device variants),
303 * the reset line to the target microprocessor was found to cycle only
304 * intermittently during emulator startup (even after encountering the
305 * downstream reset instruction later in the code).
306 * This was found to create two issues:
307 * 1) In general it is a bad practice to not reset a CPU to a known
308 * state when starting an emulator and
309 * 2) something critical happens inside the dongle when it does the
310 * first read following a new USB session.
311 * Keeping the processor in reset during the first read collecting
312 * version information seems to prevent errant
313 * "J-Link command EMU_CMD_VERSION failed" issues.
316 LOG_INFO("J-Link initialization started / target CPU reset initiated");
317 jlink_simple_command(EMU_CMD_HW_TRST0
);
318 jlink_simple_command(EMU_CMD_HW_RESET0
);
321 jlink_hw_jtag_version
= 2;
323 if (jlink_get_version_info() == ERROR_OK
)
325 /* attempt to get status */
329 LOG_INFO("J-Link JTAG Interface ready");
335 int retval
= jtag_get_speed(&jtag_speed_var
);
336 if (retval
!= ERROR_OK
)
338 jlink_speed(jtag_speed_var
);
340 /* v5/6 jlink seems to have an issue if the first tap move
341 * is not divisible by 8, so we send a TLR on first power up */
342 for (i
= 0; i
< 8; i
++) {
343 jlink_tap_append_step(1, 0);
350 static int jlink_quit(void)
352 jlink_usb_close(jlink_handle
);
356 /***************************************************************************/
357 /* Queue command implementations */
359 static void jlink_end_state(tap_state_t state
)
361 if (tap_is_state_stable(state
))
363 tap_set_end_state(state
);
367 LOG_ERROR("BUG: %i is not a valid end state", state
);
372 /* Goes to the end state. */
373 static void jlink_state_move(void)
377 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
378 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
380 for (i
= 0; i
< tms_scan_bits
; i
++)
382 tms
= (tms_scan
>> i
) & 1;
383 jlink_tap_append_step(tms
, 0);
386 tap_set_state(tap_get_end_state());
389 static void jlink_path_move(int num_states
, tap_state_t
*path
)
393 for (i
= 0; i
< num_states
; i
++)
395 if (path
[i
] == tap_state_transition(tap_get_state(), false))
397 jlink_tap_append_step(0, 0);
399 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
401 jlink_tap_append_step(1, 0);
405 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
406 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
410 tap_set_state(path
[i
]);
413 tap_set_end_state(tap_get_state());
416 static void jlink_runtest(int num_cycles
)
420 tap_state_t saved_end_state
= tap_get_end_state();
422 jlink_tap_ensure_space(1,num_cycles
+ 16);
424 /* only do a state_move when we're not already in IDLE */
425 if (tap_get_state() != TAP_IDLE
)
427 jlink_end_state(TAP_IDLE
);
432 /* execute num_cycles */
433 for (i
= 0; i
< num_cycles
; i
++)
435 jlink_tap_append_step(0, 0);
438 /* finish in end_state */
439 jlink_end_state(saved_end_state
);
440 if (tap_get_state() != tap_get_end_state())
446 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
447 int scan_size
, struct scan_command
*command
)
449 tap_state_t saved_end_state
;
451 jlink_tap_ensure_space(1, scan_size
+ 16);
453 saved_end_state
= tap_get_end_state();
455 /* Move to appropriate scan state */
456 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
458 /* Only move if we're not already there */
459 if (tap_get_state() != tap_get_end_state())
462 jlink_end_state(saved_end_state
);
465 jlink_tap_append_scan(scan_size
, buffer
, command
);
467 /* We are in Exit1, go to Pause */
468 jlink_tap_append_step(0, 0);
470 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
472 if (tap_get_state() != tap_get_end_state())
478 static void jlink_reset(int trst
, int srst
)
480 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
482 /* Signals are active low */
485 jlink_simple_command(EMU_CMD_HW_RESET1
);
489 jlink_simple_command(EMU_CMD_HW_RESET0
);
494 jlink_simple_command(EMU_CMD_HW_TRST0
);
499 jlink_simple_command(EMU_CMD_HW_TRST1
);
503 static void jlink_simple_command(uint8_t command
)
507 DEBUG_JTAG_IO("0x%02x", command
);
509 usb_out_buffer
[0] = command
;
510 result
= jlink_usb_write(jlink_handle
, 1);
514 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
518 static int jlink_get_status(void)
522 jlink_simple_command(EMU_CMD_GET_STATE
);
524 result
= jlink_usb_read(jlink_handle
, 8);
527 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)", result
);
528 return ERROR_JTAG_DEVICE_ERROR
;
531 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
532 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \
533 vref
/ 1000, vref
% 1000, \
534 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
535 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
538 LOG_ERROR("Vref too low. Check Target Power");
543 static int jlink_get_version_info(void)
547 uint32_t jlink_caps
, jlink_max_size
;
549 /* query hardware version */
550 jlink_simple_command(EMU_CMD_VERSION
);
552 result
= jlink_usb_read(jlink_handle
, 2);
555 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
556 return ERROR_JTAG_DEVICE_ERROR
;
559 len
= buf_get_u32(usb_in_buffer
, 0, 16);
560 if (len
> JLINK_IN_BUFFER_SIZE
)
562 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
563 len
= JLINK_IN_BUFFER_SIZE
;
566 result
= jlink_usb_read(jlink_handle
, len
);
569 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
570 return ERROR_JTAG_DEVICE_ERROR
;
573 usb_in_buffer
[result
] = 0;
574 LOG_INFO("%s", (char *)usb_in_buffer
);
576 /* query hardware capabilities */
577 jlink_simple_command(EMU_CMD_GET_CAPS
);
579 result
= jlink_usb_read(jlink_handle
, 4);
582 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", result
);
583 return ERROR_JTAG_DEVICE_ERROR
;
586 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
587 LOG_INFO("J-Link caps 0x%x", (unsigned)jlink_caps
);
589 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
591 /* query hardware version */
592 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
594 result
= jlink_usb_read(jlink_handle
, 4);
597 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result
);
598 return ERROR_JTAG_DEVICE_ERROR
;
601 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
602 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
603 if (major_revision
>= 5)
604 jlink_hw_jtag_version
= 3;
606 LOG_INFO("J-Link hw version %i", (int)jlink_hw_version
);
609 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
611 /* query hardware maximum memory block */
612 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
614 result
= jlink_usb_read(jlink_handle
, 4);
617 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", result
);
618 return ERROR_JTAG_DEVICE_ERROR
;
621 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
622 LOG_INFO("J-Link max mem block %i", (int)jlink_max_size
);
628 COMMAND_HANDLER(jlink_pid_command
)
632 LOG_ERROR("Need exactly one argument to jlink_pid");
636 pids
[0] = strtoul(CMD_ARGV
[0], NULL
, 16);
643 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
645 if (jlink_get_version_info() == ERROR_OK
)
647 /* attempt to get status */
654 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
658 command_print(CMD_CTX
, "J-Link hw jtag %i", jlink_hw_jtag_version
);
661 int request_version
= atoi(CMD_ARGV
[0]);
662 switch (request_version
) {
664 jlink_hw_jtag_version
= request_version
;
667 return ERROR_COMMAND_SYNTAX_ERROR
;
672 return ERROR_COMMAND_SYNTAX_ERROR
;
678 static const struct command_registration jlink_subcommand_handlers
[] = {
681 .handler
= &jlink_handle_jlink_info_command
,
682 .mode
= COMMAND_EXEC
,
683 .help
= "show jlink info",
687 .handler
= &jlink_handle_jlink_hw_jtag_command
,
688 .mode
= COMMAND_EXEC
,
689 .help
= "access J-Link HW JTAG command version",
694 .handler
= &jlink_pid_command
,
695 .mode
= COMMAND_CONFIG
,
696 .help
= "set the pid of the interface we want to use",
698 COMMAND_REGISTRATION_DONE
701 static const struct command_registration jlink_command_handlers
[] = {
705 .help
= "perform jlink management",
706 .chain
= jlink_subcommand_handlers
,
708 COMMAND_REGISTRATION_DONE
711 struct jtag_interface jlink_interface
= {
713 .commands
= jlink_command_handlers
,
715 .execute_queue
= jlink_execute_queue
,
716 .speed
= jlink_speed
,
717 .speed_div
= jlink_speed_div
,
723 /***************************************************************************/
724 /* J-Link tap functions */
727 static unsigned tap_length
= 0;
728 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
729 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
730 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
732 struct pending_scan_result
{
733 int first
; /* First bit position in tdo_buffer to read */
734 int length
; /* Number of bits to read */
735 struct scan_command
*command
; /* Corresponding scan command */
739 #define MAX_PENDING_SCAN_RESULTS 256
741 static int pending_scan_results_length
;
742 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
744 static void jlink_tap_init(void)
747 pending_scan_results_length
= 0;
750 static void jlink_tap_ensure_space(int scans
, int bits
)
752 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
753 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
755 if (scans
> available_scans
|| bits
> available_bits
)
761 static void jlink_tap_append_step(int tms
, int tdi
)
763 int index_var
= tap_length
/ 8;
765 if (index_var
>= JLINK_TAP_BUFFER_SIZE
)
767 LOG_ERROR("jlink_tap_append_step: overflow");
768 *(uint32_t *)0xFFFFFFFF = 0;
772 int bit_index
= tap_length
% 8;
773 uint8_t bit
= 1 << bit_index
;
775 // we do not pad TMS, so be sure to initialize all bits
778 tms_buffer
[index_var
] = tdi_buffer
[index_var
] = 0;
782 tms_buffer
[index_var
] |= bit
;
784 tms_buffer
[index_var
] &= ~bit
;
787 tdi_buffer
[index_var
] |= bit
;
789 tdi_buffer
[index_var
] &= ~bit
;
794 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
795 struct scan_command
*command
)
797 struct pending_scan_result
*pending_scan_result
=
798 &pending_scan_results_buffer
[pending_scan_results_length
];
801 pending_scan_result
->first
= tap_length
;
802 pending_scan_result
->length
= length
;
803 pending_scan_result
->command
= command
;
804 pending_scan_result
->buffer
= buffer
;
806 for (i
= 0; i
< length
; i
++)
808 int tms
= (i
< (length
- 1)) ? 0 : 1;
809 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
810 jlink_tap_append_step(tms
, tdi
);
812 pending_scan_results_length
++;
815 /* Pad and send a tap sequence to the device, and receive the answer.
816 * For the purpose of padding we assume that we are in idle or pause state. */
817 static int jlink_tap_execute(void)
826 /* JLink returns an extra NULL in packet when size of incoming
827 * message is a multiple of 64, creates problems with USB comms.
828 * WARNING: This will interfere with tap state counting. */
829 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
831 jlink_tap_append_step((tap_get_state() == TAP_RESET
) ? 1 : 0, 0);
834 // number of full bytes (plus one if some would be left over)
835 byte_length
= DIV_ROUND_UP(tap_length
, 8);
837 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
838 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
839 usb_out_buffer
[1] = 0;
840 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
841 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
842 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
843 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
845 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
846 tap_length
, jlink_last_state
);
848 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
849 if (result
!= byte_length
)
851 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
852 result
, byte_length
);
854 return ERROR_JTAG_QUEUE_FAILED
;
857 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
859 for (i
= 0; i
< pending_scan_results_length
; i
++)
861 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
862 uint8_t *buffer
= pending_scan_result
->buffer
;
863 int length
= pending_scan_result
->length
;
864 int first
= pending_scan_result
->first
;
865 struct scan_command
*command
= pending_scan_result
->command
;
868 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
870 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
872 #ifdef _DEBUG_USB_COMMS_
873 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
876 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
879 return ERROR_JTAG_QUEUE_FAILED
;
882 if (pending_scan_result
->buffer
!= NULL
)
884 free(pending_scan_result
->buffer
);
892 /*****************************************************************************/
893 /* JLink USB low-level functions */
895 static struct jlink
* jlink_usb_open()
899 struct usb_dev_handle
*dev
;
900 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
903 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
904 * AREA!!!!!!!!!!! The behavior of libusb is not completely
905 * consistent across Windows, Linux, and Mac OS X platforms.
906 * The actions taken in the following compiler conditionals may
907 * not agree with published documentation for libusb, but were
908 * found to be necessary through trials and tribulations. Even
909 * little tweaks can break one or more platforms, so if you do
910 * make changes test them carefully on all platforms before
921 /* reopen jlink after usb_reset
922 * on win32 this may take a second or two to re-enumerate */
924 while ((retval
= jtag_usb_open(vids
, pids
, &dev
)) != ERROR_OK
)
932 if (ERROR_OK
!= retval
)
938 /* usb_set_configuration required under win32 */
939 struct usb_device
*udev
= usb_device(dev
);
940 usb_set_configuration(dev
, udev
->config
[0].bConfigurationValue
);
941 usb_claim_interface(dev
, 0);
945 * This makes problems under Mac OS X. And is not needed
946 * under Windows. Hopefully this will not break a linux build
948 usb_set_altinterface(result
->usb_handle
, 0);
950 struct usb_interface
*iface
= udev
->config
->interface
;
951 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
952 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
954 uint8_t epnum
= desc
->endpoint
[i
].bEndpointAddress
;
955 bool is_input
= epnum
& 0x80;
956 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
958 jlink_read_ep
= epnum
;
960 jlink_write_ep
= epnum
;
963 struct jlink
*result
= malloc(sizeof(struct jlink
));
964 result
->usb_handle
= dev
;
968 static void jlink_usb_close(struct jlink
*jlink
)
970 usb_close(jlink
->usb_handle
);
974 /* Send a message and receive the reply. */
975 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
979 result
= jlink_usb_write(jlink
, out_length
);
980 if (result
!= out_length
)
982 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
984 return ERROR_JTAG_DEVICE_ERROR
;
987 result
= jlink_usb_read(jlink
, in_length
);
988 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
990 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
992 return ERROR_JTAG_DEVICE_ERROR
;
995 if (jlink_hw_jtag_version
< 3)
998 int result2
= ERROR_OK
;
999 if (result
== in_length
)
1001 /* Must read the result from the EMU too */
1002 result2
= jlink_usb_read_emu_result(jlink
);
1005 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, "
1006 "result=%d, in_length=%i", result2
, in_length
);
1007 /* Try again once, should only happen if (in_length%64 == 0) */
1008 result2
= jlink_usb_read_emu_result(jlink
);
1011 LOG_ERROR("jlink_usb_read_emu_result failed "
1012 "(requested = 1, result=%d)", result2
);
1013 return ERROR_JTAG_DEVICE_ERROR
;
1017 /* Check the result itself */
1018 result2
= usb_emu_result_buffer
[0];
1022 /* Save the result, then remove it from return value */
1023 result2
= usb_in_buffer
[result
--];
1028 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
1029 return ERROR_JTAG_DEVICE_ERROR
;
1035 /* calls the given usb_bulk_* function, allowing for the data to
1036 * trickle in with some timeouts */
1037 static int usb_bulk_with_retries(
1038 int (*f
)(usb_dev_handle
*, int, char *, int, int),
1039 usb_dev_handle
*dev
, int ep
,
1040 char *bytes
, int size
, int timeout
)
1042 int tries
= 3, count
= 0;
1044 while (tries
&& (count
< size
))
1046 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1049 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1055 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
1056 char *buff
, int size
, int timeout
)
1058 /* usb_bulk_write() takes const char *buff */
1059 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1062 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
1063 char *bytes
, int size
, int timeout
)
1065 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1066 dev
, ep
, bytes
, size
, timeout
);
1069 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1070 char *bytes
, int size
, int timeout
)
1072 return usb_bulk_with_retries(&usb_bulk_read
,
1073 dev
, ep
, bytes
, size
, timeout
);
1076 /* Write data from out_buffer to USB. */
1077 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1081 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1083 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)",
1084 out_length
, JLINK_OUT_BUFFER_SIZE
);
1088 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1089 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1091 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d",
1092 out_length
, result
);
1094 #ifdef _DEBUG_USB_COMMS_
1095 jlink_debug_buffer(usb_out_buffer
, out_length
);
1100 /* Read data from USB into in_buffer. */
1101 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1103 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1104 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1106 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1108 #ifdef _DEBUG_USB_COMMS_
1109 jlink_debug_buffer(usb_in_buffer
, result
);
1114 /* Read the result from the previous EMU cmd into result_buffer. */
1115 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1117 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1118 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1121 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1123 #ifdef _DEBUG_USB_COMMS_
1124 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1129 #ifdef _DEBUG_USB_COMMS_
1130 #define BYTES_PER_LINE 16
1132 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1139 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1141 snprintf(line
, 5, "%04x", i
);
1142 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1144 snprintf(s
, 4, " %02x", buffer
[j
]);
1147 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)