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
40 #define JLINK_WRITE_ENDPOINT 0x02
41 #define JLINK_READ_ENDPOINT 0x81
43 static unsigned int jlink_write_ep
= JLINK_WRITE_ENDPOINT
;
44 static unsigned int jlink_read_ep
= JLINK_READ_ENDPOINT
;
45 static unsigned int jlink_hw_jtag_version
= 2;
47 #define JLINK_USB_TIMEOUT 1000
49 // See Section 1.3.2 of the Segger JLink USB protocol manual
50 /* 2048 is the max value we can use here */
51 //#define JLINK_TAP_BUFFER_SIZE 2048
52 #define JLINK_TAP_BUFFER_SIZE 256
53 //#define JLINK_TAP_BUFFER_SIZE 384
55 #define JLINK_IN_BUFFER_SIZE 2048
56 #define JLINK_OUT_BUFFER_SIZE 2*2048 + 4
57 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
59 /* Global USB buffers */
60 static uint8_t usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
61 static uint8_t usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
62 static uint8_t usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
64 /* Constants for JLink command */
65 #define EMU_CMD_VERSION 0x01
66 #define EMU_CMD_SET_SPEED 0x05
67 #define EMU_CMD_GET_STATE 0x07
68 #define EMU_CMD_HW_CLOCK 0xc8
69 #define EMU_CMD_HW_TMS0 0xc9
70 #define EMU_CMD_HW_TMS1 0xca
71 #define EMU_CMD_HW_JTAG2 0xce
72 #define EMU_CMD_HW_JTAG3 0xcf
73 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
74 #define EMU_CMD_HW_RESET0 0xdc
75 #define EMU_CMD_HW_RESET1 0xdd
76 #define EMU_CMD_HW_TRST0 0xde
77 #define EMU_CMD_HW_TRST1 0xdf
78 #define EMU_CMD_GET_CAPS 0xe8
79 #define EMU_CMD_GET_HW_VERSION 0xf0
81 /* bits return from EMU_CMD_GET_CAPS */
82 #define EMU_CAP_GET_HW_VERSION 1
83 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11
85 /* max speed 12MHz v5.0 jlink */
86 #define JLINK_MAX_SPEED 12000
88 /* Queue command functions */
89 static void jlink_end_state(tap_state_t state
);
90 static void jlink_state_move(void);
91 static void jlink_path_move(int num_states
, tap_state_t
*path
);
92 static void jlink_runtest(int num_cycles
);
93 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
);
94 static void jlink_reset(int trst
, int srst
);
95 static void jlink_simple_command(uint8_t command
);
96 static int jlink_get_status(void);
98 /* J-Link tap buffer functions */
99 static void jlink_tap_init(void);
100 static int jlink_tap_execute(void);
101 static void jlink_tap_ensure_space(int scans
, int bits
);
102 static void jlink_tap_append_step(int tms
, int tdi
);
103 static void jlink_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
);
105 /* Jlink lowlevel functions */
107 struct usb_dev_handle
* usb_handle
;
110 static struct jlink
*jlink_usb_open(void);
111 static void jlink_usb_close(struct jlink
*jlink
);
112 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
);
113 static int jlink_usb_write(struct jlink
*jlink
, int out_length
);
114 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
);
115 static int jlink_usb_read_emu_result(struct jlink
*jlink
);
117 /* helper functions */
118 static int jlink_get_version_info(void);
120 #ifdef _DEBUG_USB_COMMS_
121 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
124 static enum tap_state jlink_last_state
= TAP_RESET
;
126 static struct jlink
* jlink_handle
;
128 /***************************************************************************/
129 /* External interface implementation */
131 static void jlink_execute_runtest(struct jtag_command
*cmd
)
133 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
134 cmd
->cmd
.runtest
->num_cycles
,
135 cmd
->cmd
.runtest
->end_state
);
137 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
139 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
142 static void jlink_execute_statemove(struct jtag_command
*cmd
)
144 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
146 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
150 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
152 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
153 cmd
->cmd
.pathmove
->num_states
,
154 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
156 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
157 cmd
->cmd
.pathmove
->path
);
160 static void jlink_execute_scan(struct jtag_command
*cmd
)
166 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
168 jlink_end_state(cmd
->cmd
.scan
->end_state
);
170 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
171 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
173 #ifdef _DEBUG_USB_COMMS_
174 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
176 type
= jtag_scan_type(cmd
->cmd
.scan
);
177 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
178 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
181 static void jlink_execute_reset(struct jtag_command
*cmd
)
183 DEBUG_JTAG_IO("reset trst: %i srst %i",
184 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
187 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
191 static void jlink_execute_sleep(struct jtag_command
*cmd
)
193 DEBUG_JTAG_IO("sleep %" PRIi32
"", cmd
->cmd
.sleep
->us
);
195 jtag_sleep(cmd
->cmd
.sleep
->us
);
198 static void jlink_execute_command(struct jtag_command
*cmd
)
202 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
203 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
204 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
205 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
206 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
207 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
209 LOG_ERROR("BUG: unknown JTAG command type encountered");
214 static int jlink_execute_queue(void)
216 struct jtag_command
*cmd
= jtag_command_queue
;
220 jlink_execute_command(cmd
);
224 return jlink_tap_execute();
227 /* Sets speed in kHz. */
228 static int jlink_speed(int speed
)
232 if (speed
> JLINK_MAX_SPEED
)
234 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
235 speed
, JLINK_MAX_SPEED
);
239 /* check for RTCK setting */
243 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
244 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
245 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
247 result
= jlink_usb_write(jlink_handle
, 3);
250 LOG_ERROR("J-Link setting speed failed (%d)", result
);
251 return ERROR_JTAG_DEVICE_ERROR
;
257 static int jlink_speed_div(int speed
, int* khz
)
264 static int jlink_khz(int khz
, int *jtag_speed
)
271 static int jlink_init(void)
275 jlink_handle
= jlink_usb_open();
277 if (jlink_handle
== 0)
279 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
280 return ERROR_JTAG_INIT_FAILED
;
284 * The next three instructions were added after discovering a problem while using an oscilloscope. For the V8
285 * SAM-ICE dongle (and likely other j-link device variants), the reset line to the target microprocessor was found to
286 * cycle only intermittently during emulator startup (even after encountering the downstream reset instruction later
287 * 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
288 * state when starting an emulator and 2) something critical happens inside the dongle when it does the first read
289 * following a new USB session. Keeping the processor in reset during the first read collecting version information
290 * seems to prevent errant "J-Link command EMU_CMD_VERSION failed" issues.
293 LOG_INFO("J-Link initialization started / target CPU reset initiated");
294 jlink_simple_command(EMU_CMD_HW_TRST0
);
295 jlink_simple_command(EMU_CMD_HW_RESET0
);
298 jlink_hw_jtag_version
= 2;
300 if (jlink_get_version_info() == ERROR_OK
)
302 /* attempt to get status */
306 LOG_INFO("J-Link JTAG Interface ready");
311 jlink_speed(jtag_get_speed());
313 /* v5/6 jlink seems to have an issue if the first tap move
314 * is not divisible by 8, so we send a TLR on first power up */
315 for (i
= 0; i
< 8; i
++) {
316 jlink_tap_append_step(1, 0);
323 static int jlink_quit(void)
325 jlink_usb_close(jlink_handle
);
329 /***************************************************************************/
330 /* Queue command implementations */
332 static void jlink_end_state(tap_state_t state
)
334 if (tap_is_state_stable(state
))
336 tap_set_end_state(state
);
340 LOG_ERROR("BUG: %i is not a valid end state", state
);
345 /* Goes to the end state. */
346 static void jlink_state_move(void)
350 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
351 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
353 for (i
= 0; i
< tms_scan_bits
; i
++)
355 tms
= (tms_scan
>> i
) & 1;
356 jlink_tap_append_step(tms
, 0);
359 tap_set_state(tap_get_end_state());
362 static void jlink_path_move(int num_states
, tap_state_t
*path
)
366 for (i
= 0; i
< num_states
; i
++)
368 if (path
[i
] == tap_state_transition(tap_get_state(), false))
370 jlink_tap_append_step(0, 0);
372 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
374 jlink_tap_append_step(1, 0);
378 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
382 tap_set_state(path
[i
]);
385 tap_set_end_state(tap_get_state());
388 static void jlink_runtest(int num_cycles
)
392 tap_state_t saved_end_state
= tap_get_end_state();
394 jlink_tap_ensure_space(1,num_cycles
+ 16);
396 /* only do a state_move when we're not already in IDLE */
397 if (tap_get_state() != TAP_IDLE
)
399 jlink_end_state(TAP_IDLE
);
404 /* execute num_cycles */
405 for (i
= 0; i
< num_cycles
; i
++)
407 jlink_tap_append_step(0, 0);
410 /* finish in end_state */
411 jlink_end_state(saved_end_state
);
412 if (tap_get_state() != tap_get_end_state())
418 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
420 tap_state_t saved_end_state
;
422 jlink_tap_ensure_space(1, scan_size
+ 16);
424 saved_end_state
= tap_get_end_state();
426 /* Move to appropriate scan state */
427 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
429 /* Only move if we're not already there */
430 if (tap_get_state() != tap_get_end_state())
433 jlink_end_state(saved_end_state
);
436 jlink_tap_append_scan(scan_size
, buffer
, command
);
438 /* We are in Exit1, go to Pause */
439 jlink_tap_append_step(0, 0);
441 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
443 if (tap_get_state() != tap_get_end_state())
449 static void jlink_reset(int trst
, int srst
)
451 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
453 /* Signals are active low */
456 jlink_simple_command(EMU_CMD_HW_RESET1
);
460 jlink_simple_command(EMU_CMD_HW_RESET0
);
465 jlink_simple_command(EMU_CMD_HW_TRST0
);
470 jlink_simple_command(EMU_CMD_HW_TRST1
);
474 static void jlink_simple_command(uint8_t command
)
478 DEBUG_JTAG_IO("0x%02x", command
);
480 usb_out_buffer
[0] = command
;
481 result
= jlink_usb_write(jlink_handle
, 1);
485 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
489 static int jlink_get_status(void)
493 jlink_simple_command(EMU_CMD_GET_STATE
);
495 result
= jlink_usb_read(jlink_handle
, 8);
498 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
499 return ERROR_JTAG_DEVICE_ERROR
;
502 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
503 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
504 vref
/ 1000, vref
% 1000, \
505 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
506 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
509 LOG_ERROR("Vref too low. Check Target Power\n");
514 static int jlink_get_version_info(void)
518 uint32_t jlink_caps
, jlink_max_size
;
520 /* query hardware version */
521 jlink_simple_command(EMU_CMD_VERSION
);
523 result
= jlink_usb_read(jlink_handle
, 2);
526 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
527 return ERROR_JTAG_DEVICE_ERROR
;
530 len
= buf_get_u32(usb_in_buffer
, 0, 16);
531 if (len
> JLINK_IN_BUFFER_SIZE
)
533 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
534 len
= JLINK_IN_BUFFER_SIZE
;
537 result
= jlink_usb_read(jlink_handle
, len
);
540 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
541 return ERROR_JTAG_DEVICE_ERROR
;
544 usb_in_buffer
[result
] = 0;
545 LOG_INFO("%s", (char *)usb_in_buffer
);
547 /* query hardware capabilities */
548 jlink_simple_command(EMU_CMD_GET_CAPS
);
550 result
= jlink_usb_read(jlink_handle
, 4);
553 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
554 return ERROR_JTAG_DEVICE_ERROR
;
557 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
558 LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps
);
560 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
562 /* query hardware version */
563 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
565 result
= jlink_usb_read(jlink_handle
, 4);
568 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result
);
569 return ERROR_JTAG_DEVICE_ERROR
;
572 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
573 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
574 if (major_revision
>= 5)
575 jlink_hw_jtag_version
= 3;
577 LOG_INFO("JLink hw version %i", (int)jlink_hw_version
);
580 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
582 /* query hardware maximum memory block */
583 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
585 result
= jlink_usb_read(jlink_handle
, 4);
588 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
589 return ERROR_JTAG_DEVICE_ERROR
;
592 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
593 LOG_INFO("JLink max mem block %i", (int)jlink_max_size
);
599 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
601 if (jlink_get_version_info() == ERROR_OK
)
603 /* attempt to get status */
610 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
614 command_print(CMD_CTX
, "jlink hw jtag %i", jlink_hw_jtag_version
);
617 int request_version
= atoi(CMD_ARGV
[0]);
618 switch (request_version
) {
620 jlink_hw_jtag_version
= request_version
;
623 return ERROR_COMMAND_SYNTAX_ERROR
;
628 return ERROR_COMMAND_SYNTAX_ERROR
;
634 static const struct command_registration jlink_command_handlers
[] = {
636 .name
= "jlink_info",
637 .handler
= &jlink_handle_jlink_info_command
,
638 .mode
= COMMAND_EXEC
,
639 .help
= "show jlink info",
642 .name
= "jlink_hw_jtag",
643 .handler
= &jlink_handle_jlink_hw_jtag_command
,
644 .mode
= COMMAND_EXEC
,
645 .help
= "access J-Link HW JTAG command version",
648 COMMAND_REGISTRATION_DONE
651 struct jtag_interface jlink_interface
= {
653 .commands
= jlink_command_handlers
,
655 .execute_queue
= jlink_execute_queue
,
656 .speed
= jlink_speed
,
657 .speed_div
= jlink_speed_div
,
663 /***************************************************************************/
664 /* J-Link tap functions */
667 static unsigned tap_length
= 0;
668 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
669 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
670 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
672 struct pending_scan_result
{
673 int first
; /* First bit position in tdo_buffer to read */
674 int length
; /* Number of bits to read */
675 struct scan_command
*command
; /* Corresponding scan command */
679 #define MAX_PENDING_SCAN_RESULTS 256
681 static int pending_scan_results_length
;
682 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
684 static void jlink_tap_init(void)
687 pending_scan_results_length
= 0;
690 static void jlink_tap_ensure_space(int scans
, int bits
)
692 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
693 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
695 if (scans
> available_scans
|| bits
> available_bits
)
701 static void jlink_tap_append_step(int tms
, int tdi
)
703 int index
= tap_length
/ 8;
705 if (index
>= JLINK_TAP_BUFFER_SIZE
)
707 LOG_ERROR("jlink_tap_append_step: overflow");
708 *(uint32_t *)0xFFFFFFFF = 0;
712 int bit_index
= tap_length
% 8;
713 uint8_t bit
= 1 << bit_index
;
715 // we do not pad TMS, so be sure to initialize all bits
718 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
722 tms_buffer
[index
] |= bit
;
724 tms_buffer
[index
] &= ~bit
;
727 tdi_buffer
[index
] |= bit
;
729 tdi_buffer
[index
] &= ~bit
;
734 static void jlink_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
)
736 struct pending_scan_result
*pending_scan_result
=
737 &pending_scan_results_buffer
[pending_scan_results_length
];
740 pending_scan_result
->first
= tap_length
;
741 pending_scan_result
->length
= length
;
742 pending_scan_result
->command
= command
;
743 pending_scan_result
->buffer
= buffer
;
745 for (i
= 0; i
< length
; i
++)
747 int tms
= (i
< (length
- 1)) ? 0 : 1;
748 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
749 jlink_tap_append_step(tms
, tdi
);
751 pending_scan_results_length
++;
754 /* Pad and send a tap sequence to the device, and receive the answer.
755 * For the purpose of padding we assume that we are in idle or pause state. */
756 static int jlink_tap_execute(void)
765 /* JLink returns an extra NULL in packet when size of incoming
766 * message is a multiple of 64, creates problems with USB comms.
767 * WARNING: This will interfere with tap state counting. */
768 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
770 jlink_tap_append_step((tap_get_state() == TAP_RESET
)?1:0, 0);
773 // number of full bytes (plus one if some would be left over)
774 byte_length
= DIV_ROUND_UP(tap_length
, 8);
776 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
777 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
778 usb_out_buffer
[1] = 0;
779 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
780 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
781 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
782 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
784 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
785 tap_length
, jlink_last_state
);
787 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
788 if (result
!= byte_length
)
790 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
792 return ERROR_JTAG_QUEUE_FAILED
;
795 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
797 for (i
= 0; i
< pending_scan_results_length
; i
++)
799 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
800 uint8_t *buffer
= pending_scan_result
->buffer
;
801 int length
= pending_scan_result
->length
;
802 int first
= pending_scan_result
->first
;
803 struct scan_command
*command
= pending_scan_result
->command
;
806 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
808 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
810 #ifdef _DEBUG_USB_COMMS_
811 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
814 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
817 return ERROR_JTAG_QUEUE_FAILED
;
820 if (pending_scan_result
->buffer
!= NULL
)
822 free(pending_scan_result
->buffer
);
830 /*****************************************************************************/
831 /* JLink USB low-level functions */
833 static struct jlink
* jlink_usb_open()
837 const uint16_t vids
[] = { VID
, 0 };
838 const uint16_t pids
[] = { PID
, 0 };
839 struct usb_dev_handle
*dev
;
840 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
843 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
844 * AREA!!!!!!!!!!! The behavior of libusb is not completely
845 * consistent across Windows, Linux, and Mac OS X platforms.
846 * The actions taken in the following compiler conditionals may
847 * not agree with published documentation for libusb, but were
848 * found to be necessary through trials and tribulations. Even
849 * little tweaks can break one or more platforms, so if you do
850 * make changes test them carefully on all platforms before
861 /* reopen jlink after usb_reset
862 * on win32 this may take a second or two to re-enumerate */
864 while ((retval
= jtag_usb_open(vids
, pids
, &dev
)) != ERROR_OK
)
872 if (ERROR_OK
!= retval
)
878 /* usb_set_configuration required under win32 */
879 struct usb_device
*udev
= usb_device(dev
);
880 usb_set_configuration(dev
, udev
->config
[0].bConfigurationValue
);
881 usb_claim_interface(dev
, 0);
885 * This makes problems under Mac OS X. And is not needed
886 * under Windows. Hopefully this will not break a linux build
888 usb_set_altinterface(result
->usb_handle
, 0);
890 struct usb_interface
*iface
= udev
->config
->interface
;
891 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
892 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
894 uint8_t epnum
= desc
->endpoint
[i
].bEndpointAddress
;
895 bool is_input
= epnum
& 0x80;
896 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
898 jlink_read_ep
= epnum
;
900 jlink_write_ep
= epnum
;
903 struct jlink
*result
= malloc(sizeof(struct jlink
));
904 result
->usb_handle
= dev
;
908 static void jlink_usb_close(struct jlink
*jlink
)
910 usb_close(jlink
->usb_handle
);
914 /* Send a message and receive the reply. */
915 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
919 result
= jlink_usb_write(jlink
, out_length
);
920 if (result
!= out_length
)
922 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
924 return ERROR_JTAG_DEVICE_ERROR
;
927 result
= jlink_usb_read(jlink
, in_length
);
928 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
930 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
932 return ERROR_JTAG_DEVICE_ERROR
;
935 if (jlink_hw_jtag_version
< 3)
938 int result2
= ERROR_OK
;
939 if (result
== in_length
)
941 /* Must read the result from the EMU too */
942 result2
= jlink_usb_read_emu_result(jlink
);
945 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, result=%d, in_length=%i", result2
,in_length
);
946 /* Try again once, should only happen if (in_length%64 == 0) */
947 result2
= jlink_usb_read_emu_result(jlink
);
950 LOG_ERROR("jlink_usb_read_emu_result failed "
951 "(requested = 1, result=%d)", result2
);
952 return ERROR_JTAG_DEVICE_ERROR
;
956 /* Check the result itself */
957 result2
= usb_emu_result_buffer
[0];
961 /* Save the result, then remove it from return value */
962 result2
= usb_in_buffer
[result
--];
967 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
968 return ERROR_JTAG_DEVICE_ERROR
;
974 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
975 static int usb_bulk_with_retries(
976 int (*f
)(usb_dev_handle
*, int, char *, int, int),
977 usb_dev_handle
*dev
, int ep
,
978 char *bytes
, int size
, int timeout
)
980 int tries
= 3, count
= 0;
982 while (tries
&& (count
< size
))
984 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
987 else if ((-ETIMEDOUT
!= result
) || !--tries
)
993 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
994 char *buff
, int size
, int timeout
)
996 /* usb_bulk_write() takes const char *buff */
997 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1000 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
1001 char *bytes
, int size
, int timeout
)
1003 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1004 dev
, ep
, bytes
, size
, timeout
);
1007 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1008 char *bytes
, int size
, int timeout
)
1010 return usb_bulk_with_retries(&usb_bulk_read
,
1011 dev
, ep
, bytes
, size
, timeout
);
1014 /* Write data from out_buffer to USB. */
1015 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1019 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1021 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
1025 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1026 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1028 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
1030 #ifdef _DEBUG_USB_COMMS_
1031 jlink_debug_buffer(usb_out_buffer
, out_length
);
1036 /* Read data from USB into in_buffer. */
1037 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1039 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1040 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1042 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1044 #ifdef _DEBUG_USB_COMMS_
1045 jlink_debug_buffer(usb_in_buffer
, result
);
1050 /* Read the result from the previous EMU cmd into result_buffer. */
1051 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1053 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1054 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1057 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1059 #ifdef _DEBUG_USB_COMMS_
1060 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1065 #ifdef _DEBUG_USB_COMMS_
1066 #define BYTES_PER_LINE 16
1068 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1075 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1077 snprintf(line
, 5, "%04x", i
);
1078 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1080 snprintf(s
, 4, " %02x", buffer
[j
]);
1083 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)