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
,
94 int scan_size
, struct scan_command
*command
);
95 static void jlink_reset(int trst
, int srst
);
96 static void jlink_simple_command(uint8_t command
);
97 static int jlink_get_status(void);
99 /* J-Link tap buffer functions */
100 static void jlink_tap_init(void);
101 static int jlink_tap_execute(void);
102 static void jlink_tap_ensure_space(int scans
, int bits
);
103 static void jlink_tap_append_step(int tms
, int tdi
);
104 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
105 struct scan_command
*command
);
107 /* Jlink lowlevel functions */
109 struct usb_dev_handle
* usb_handle
;
112 static struct jlink
*jlink_usb_open(void);
113 static void jlink_usb_close(struct jlink
*jlink
);
114 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
);
115 static int jlink_usb_write(struct jlink
*jlink
, int out_length
);
116 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
);
117 static int jlink_usb_read_emu_result(struct jlink
*jlink
);
119 /* helper functions */
120 static int jlink_get_version_info(void);
122 #ifdef _DEBUG_USB_COMMS_
123 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
126 static enum tap_state jlink_last_state
= TAP_RESET
;
128 static struct jlink
* jlink_handle
;
130 /***************************************************************************/
131 /* External interface implementation */
133 static void jlink_execute_runtest(struct jtag_command
*cmd
)
135 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
136 cmd
->cmd
.runtest
->num_cycles
,
137 cmd
->cmd
.runtest
->end_state
);
139 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
141 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
144 static void jlink_execute_statemove(struct jtag_command
*cmd
)
146 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
148 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
152 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
154 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
155 cmd
->cmd
.pathmove
->num_states
,
156 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
158 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
159 cmd
->cmd
.pathmove
->path
);
162 static void jlink_execute_scan(struct jtag_command
*cmd
)
168 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
170 jlink_end_state(cmd
->cmd
.scan
->end_state
);
172 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
173 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
175 #ifdef _DEBUG_USB_COMMS_
176 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
178 type
= jtag_scan_type(cmd
->cmd
.scan
);
179 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
180 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
183 static void jlink_execute_reset(struct jtag_command
*cmd
)
185 DEBUG_JTAG_IO("reset trst: %i srst %i",
186 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
189 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
193 static void jlink_execute_sleep(struct jtag_command
*cmd
)
195 DEBUG_JTAG_IO("sleep %" PRIi32
"", cmd
->cmd
.sleep
->us
);
197 jtag_sleep(cmd
->cmd
.sleep
->us
);
200 static void jlink_execute_command(struct jtag_command
*cmd
)
204 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
205 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
206 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
207 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
208 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
209 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
211 LOG_ERROR("BUG: unknown JTAG command type encountered");
216 static int jlink_execute_queue(void)
218 struct jtag_command
*cmd
= jtag_command_queue
;
222 jlink_execute_command(cmd
);
226 return jlink_tap_execute();
229 /* Sets speed in kHz. */
230 static int jlink_speed(int speed
)
234 if (speed
> JLINK_MAX_SPEED
)
236 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
237 speed
, JLINK_MAX_SPEED
);
241 /* check for RTCK setting */
245 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
246 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
247 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
249 result
= jlink_usb_write(jlink_handle
, 3);
252 LOG_ERROR("J-Link setting speed failed (%d)", result
);
253 return ERROR_JTAG_DEVICE_ERROR
;
259 static int jlink_speed_div(int speed
, int* khz
)
266 static int jlink_khz(int khz
, int *jtag_speed
)
273 static int jlink_init(void)
277 jlink_handle
= jlink_usb_open();
279 if (jlink_handle
== 0)
281 LOG_ERROR("Cannot find jlink Interface! Please check "
282 "connection and permissions.");
283 return ERROR_JTAG_INIT_FAILED
;
287 * The next three instructions were added after discovering a problem
288 * while using an oscilloscope.
289 * For the V8 SAM-ICE dongle (and likely other j-link device variants),
290 * the reset line to the target microprocessor was found to cycle only
291 * intermittently during emulator startup (even after encountering the
292 * downstream reset instruction later in the code).
293 * This was found to create two issues:
294 * 1) In general it is a bad practice to not reset a CPU to a known
295 * state when starting an emulator and
296 * 2) something critical happens inside the dongle when it does the
297 * first read following a new USB session.
298 * Keeping the processor in reset during the first read collecting
299 * version information seems to prevent errant
300 * "J-Link command EMU_CMD_VERSION failed" issues.
303 LOG_INFO("J-Link initialization started / target CPU reset initiated");
304 jlink_simple_command(EMU_CMD_HW_TRST0
);
305 jlink_simple_command(EMU_CMD_HW_RESET0
);
308 jlink_hw_jtag_version
= 2;
310 if (jlink_get_version_info() == ERROR_OK
)
312 /* attempt to get status */
316 LOG_INFO("J-Link JTAG Interface ready");
321 jlink_speed(jtag_get_speed());
323 /* v5/6 jlink seems to have an issue if the first tap move
324 * is not divisible by 8, so we send a TLR on first power up */
325 for (i
= 0; i
< 8; i
++) {
326 jlink_tap_append_step(1, 0);
333 static int jlink_quit(void)
335 jlink_usb_close(jlink_handle
);
339 /***************************************************************************/
340 /* Queue command implementations */
342 static void jlink_end_state(tap_state_t state
)
344 if (tap_is_state_stable(state
))
346 tap_set_end_state(state
);
350 LOG_ERROR("BUG: %i is not a valid end state", state
);
355 /* Goes to the end state. */
356 static void jlink_state_move(void)
360 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
361 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
363 for (i
= 0; i
< tms_scan_bits
; i
++)
365 tms
= (tms_scan
>> i
) & 1;
366 jlink_tap_append_step(tms
, 0);
369 tap_set_state(tap_get_end_state());
372 static void jlink_path_move(int num_states
, tap_state_t
*path
)
376 for (i
= 0; i
< num_states
; i
++)
378 if (path
[i
] == tap_state_transition(tap_get_state(), false))
380 jlink_tap_append_step(0, 0);
382 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
384 jlink_tap_append_step(1, 0);
388 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
389 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
393 tap_set_state(path
[i
]);
396 tap_set_end_state(tap_get_state());
399 static void jlink_runtest(int num_cycles
)
403 tap_state_t saved_end_state
= tap_get_end_state();
405 jlink_tap_ensure_space(1,num_cycles
+ 16);
407 /* only do a state_move when we're not already in IDLE */
408 if (tap_get_state() != TAP_IDLE
)
410 jlink_end_state(TAP_IDLE
);
415 /* execute num_cycles */
416 for (i
= 0; i
< num_cycles
; i
++)
418 jlink_tap_append_step(0, 0);
421 /* finish in end_state */
422 jlink_end_state(saved_end_state
);
423 if (tap_get_state() != tap_get_end_state())
429 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
430 int scan_size
, struct scan_command
*command
)
432 tap_state_t saved_end_state
;
434 jlink_tap_ensure_space(1, scan_size
+ 16);
436 saved_end_state
= tap_get_end_state();
438 /* Move to appropriate scan state */
439 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
441 /* Only move if we're not already there */
442 if (tap_get_state() != tap_get_end_state())
445 jlink_end_state(saved_end_state
);
448 jlink_tap_append_scan(scan_size
, buffer
, command
);
450 /* We are in Exit1, go to Pause */
451 jlink_tap_append_step(0, 0);
453 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
455 if (tap_get_state() != tap_get_end_state())
461 static void jlink_reset(int trst
, int srst
)
463 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
465 /* Signals are active low */
468 jlink_simple_command(EMU_CMD_HW_RESET1
);
472 jlink_simple_command(EMU_CMD_HW_RESET0
);
477 jlink_simple_command(EMU_CMD_HW_TRST0
);
482 jlink_simple_command(EMU_CMD_HW_TRST1
);
486 static void jlink_simple_command(uint8_t command
)
490 DEBUG_JTAG_IO("0x%02x", command
);
492 usb_out_buffer
[0] = command
;
493 result
= jlink_usb_write(jlink_handle
, 1);
497 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
501 static int jlink_get_status(void)
505 jlink_simple_command(EMU_CMD_GET_STATE
);
507 result
= jlink_usb_read(jlink_handle
, 8);
510 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
511 return ERROR_JTAG_DEVICE_ERROR
;
514 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
515 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \
516 vref
/ 1000, vref
% 1000, \
517 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
518 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
521 LOG_ERROR("Vref too low. Check Target Power");
526 static int jlink_get_version_info(void)
530 uint32_t jlink_caps
, jlink_max_size
;
532 /* query hardware version */
533 jlink_simple_command(EMU_CMD_VERSION
);
535 result
= jlink_usb_read(jlink_handle
, 2);
538 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
539 return ERROR_JTAG_DEVICE_ERROR
;
542 len
= buf_get_u32(usb_in_buffer
, 0, 16);
543 if (len
> JLINK_IN_BUFFER_SIZE
)
545 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
546 len
= JLINK_IN_BUFFER_SIZE
;
549 result
= jlink_usb_read(jlink_handle
, len
);
552 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
553 return ERROR_JTAG_DEVICE_ERROR
;
556 usb_in_buffer
[result
] = 0;
557 LOG_INFO("%s", (char *)usb_in_buffer
);
559 /* query hardware capabilities */
560 jlink_simple_command(EMU_CMD_GET_CAPS
);
562 result
= jlink_usb_read(jlink_handle
, 4);
565 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", result
);
566 return ERROR_JTAG_DEVICE_ERROR
;
569 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
570 LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps
);
572 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
574 /* query hardware version */
575 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
577 result
= jlink_usb_read(jlink_handle
, 4);
580 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result
);
581 return ERROR_JTAG_DEVICE_ERROR
;
584 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
585 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
586 if (major_revision
>= 5)
587 jlink_hw_jtag_version
= 3;
589 LOG_INFO("JLink hw version %i", (int)jlink_hw_version
);
592 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
594 /* query hardware maximum memory block */
595 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
597 result
= jlink_usb_read(jlink_handle
, 4);
600 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", result
);
601 return ERROR_JTAG_DEVICE_ERROR
;
604 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
605 LOG_INFO("JLink max mem block %i", (int)jlink_max_size
);
611 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
613 if (jlink_get_version_info() == ERROR_OK
)
615 /* attempt to get status */
622 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
626 command_print(CMD_CTX
, "jlink hw jtag %i", jlink_hw_jtag_version
);
629 int request_version
= atoi(CMD_ARGV
[0]);
630 switch (request_version
) {
632 jlink_hw_jtag_version
= request_version
;
635 return ERROR_COMMAND_SYNTAX_ERROR
;
640 return ERROR_COMMAND_SYNTAX_ERROR
;
646 static const struct command_registration jlink_command_handlers
[] = {
648 .name
= "jlink_info",
649 .handler
= &jlink_handle_jlink_info_command
,
650 .mode
= COMMAND_EXEC
,
651 .help
= "show jlink info",
654 .name
= "jlink_hw_jtag",
655 .handler
= &jlink_handle_jlink_hw_jtag_command
,
656 .mode
= COMMAND_EXEC
,
657 .help
= "access J-Link HW JTAG command version",
660 COMMAND_REGISTRATION_DONE
663 struct jtag_interface jlink_interface
= {
665 .commands
= jlink_command_handlers
,
667 .execute_queue
= jlink_execute_queue
,
668 .speed
= jlink_speed
,
669 .speed_div
= jlink_speed_div
,
675 /***************************************************************************/
676 /* J-Link tap functions */
679 static unsigned tap_length
= 0;
680 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
681 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
682 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
684 struct pending_scan_result
{
685 int first
; /* First bit position in tdo_buffer to read */
686 int length
; /* Number of bits to read */
687 struct scan_command
*command
; /* Corresponding scan command */
691 #define MAX_PENDING_SCAN_RESULTS 256
693 static int pending_scan_results_length
;
694 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
696 static void jlink_tap_init(void)
699 pending_scan_results_length
= 0;
702 static void jlink_tap_ensure_space(int scans
, int bits
)
704 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
705 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
707 if (scans
> available_scans
|| bits
> available_bits
)
713 static void jlink_tap_append_step(int tms
, int tdi
)
715 int index
= tap_length
/ 8;
717 if (index
>= JLINK_TAP_BUFFER_SIZE
)
719 LOG_ERROR("jlink_tap_append_step: overflow");
720 *(uint32_t *)0xFFFFFFFF = 0;
724 int bit_index
= tap_length
% 8;
725 uint8_t bit
= 1 << bit_index
;
727 // we do not pad TMS, so be sure to initialize all bits
730 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
734 tms_buffer
[index
] |= bit
;
736 tms_buffer
[index
] &= ~bit
;
739 tdi_buffer
[index
] |= bit
;
741 tdi_buffer
[index
] &= ~bit
;
746 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
747 struct scan_command
*command
)
749 struct pending_scan_result
*pending_scan_result
=
750 &pending_scan_results_buffer
[pending_scan_results_length
];
753 pending_scan_result
->first
= tap_length
;
754 pending_scan_result
->length
= length
;
755 pending_scan_result
->command
= command
;
756 pending_scan_result
->buffer
= buffer
;
758 for (i
= 0; i
< length
; i
++)
760 int tms
= (i
< (length
- 1)) ? 0 : 1;
761 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
762 jlink_tap_append_step(tms
, tdi
);
764 pending_scan_results_length
++;
767 /* Pad and send a tap sequence to the device, and receive the answer.
768 * For the purpose of padding we assume that we are in idle or pause state. */
769 static int jlink_tap_execute(void)
778 /* JLink returns an extra NULL in packet when size of incoming
779 * message is a multiple of 64, creates problems with USB comms.
780 * WARNING: This will interfere with tap state counting. */
781 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
783 jlink_tap_append_step((tap_get_state() == TAP_RESET
) ? 1 : 0, 0);
786 // number of full bytes (plus one if some would be left over)
787 byte_length
= DIV_ROUND_UP(tap_length
, 8);
789 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
790 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
791 usb_out_buffer
[1] = 0;
792 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
793 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
794 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
795 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
797 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
798 tap_length
, jlink_last_state
);
800 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
801 if (result
!= byte_length
)
803 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
804 result
, byte_length
);
806 return ERROR_JTAG_QUEUE_FAILED
;
809 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
811 for (i
= 0; i
< pending_scan_results_length
; i
++)
813 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
814 uint8_t *buffer
= pending_scan_result
->buffer
;
815 int length
= pending_scan_result
->length
;
816 int first
= pending_scan_result
->first
;
817 struct scan_command
*command
= pending_scan_result
->command
;
820 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
822 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
824 #ifdef _DEBUG_USB_COMMS_
825 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
828 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
831 return ERROR_JTAG_QUEUE_FAILED
;
834 if (pending_scan_result
->buffer
!= NULL
)
836 free(pending_scan_result
->buffer
);
844 /*****************************************************************************/
845 /* JLink USB low-level functions */
847 static struct jlink
* jlink_usb_open()
851 const uint16_t vids
[] = { VID
, 0 };
852 const uint16_t pids
[] = { PID
, 0 };
853 struct usb_dev_handle
*dev
;
854 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
857 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
858 * AREA!!!!!!!!!!! The behavior of libusb is not completely
859 * consistent across Windows, Linux, and Mac OS X platforms.
860 * The actions taken in the following compiler conditionals may
861 * not agree with published documentation for libusb, but were
862 * found to be necessary through trials and tribulations. Even
863 * little tweaks can break one or more platforms, so if you do
864 * make changes test them carefully on all platforms before
875 /* reopen jlink after usb_reset
876 * on win32 this may take a second or two to re-enumerate */
878 while ((retval
= jtag_usb_open(vids
, pids
, &dev
)) != ERROR_OK
)
886 if (ERROR_OK
!= retval
)
892 /* usb_set_configuration required under win32 */
893 struct usb_device
*udev
= usb_device(dev
);
894 usb_set_configuration(dev
, udev
->config
[0].bConfigurationValue
);
895 usb_claim_interface(dev
, 0);
899 * This makes problems under Mac OS X. And is not needed
900 * under Windows. Hopefully this will not break a linux build
902 usb_set_altinterface(result
->usb_handle
, 0);
904 struct usb_interface
*iface
= udev
->config
->interface
;
905 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
906 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
908 uint8_t epnum
= desc
->endpoint
[i
].bEndpointAddress
;
909 bool is_input
= epnum
& 0x80;
910 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
912 jlink_read_ep
= epnum
;
914 jlink_write_ep
= epnum
;
917 struct jlink
*result
= malloc(sizeof(struct jlink
));
918 result
->usb_handle
= dev
;
922 static void jlink_usb_close(struct jlink
*jlink
)
924 usb_close(jlink
->usb_handle
);
928 /* Send a message and receive the reply. */
929 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
933 result
= jlink_usb_write(jlink
, out_length
);
934 if (result
!= out_length
)
936 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
938 return ERROR_JTAG_DEVICE_ERROR
;
941 result
= jlink_usb_read(jlink
, in_length
);
942 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
944 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
946 return ERROR_JTAG_DEVICE_ERROR
;
949 if (jlink_hw_jtag_version
< 3)
952 int result2
= ERROR_OK
;
953 if (result
== in_length
)
955 /* Must read the result from the EMU too */
956 result2
= jlink_usb_read_emu_result(jlink
);
959 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, "
960 "result=%d, in_length=%i", result2
, in_length
);
961 /* Try again once, should only happen if (in_length%64 == 0) */
962 result2
= jlink_usb_read_emu_result(jlink
);
965 LOG_ERROR("jlink_usb_read_emu_result failed "
966 "(requested = 1, result=%d)", result2
);
967 return ERROR_JTAG_DEVICE_ERROR
;
971 /* Check the result itself */
972 result2
= usb_emu_result_buffer
[0];
976 /* Save the result, then remove it from return value */
977 result2
= usb_in_buffer
[result
--];
982 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
983 return ERROR_JTAG_DEVICE_ERROR
;
989 /* calls the given usb_bulk_* function, allowing for the data to
990 * trickle in with some timeouts */
991 static int usb_bulk_with_retries(
992 int (*f
)(usb_dev_handle
*, int, char *, int, int),
993 usb_dev_handle
*dev
, int ep
,
994 char *bytes
, int size
, int timeout
)
996 int tries
= 3, count
= 0;
998 while (tries
&& (count
< size
))
1000 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1003 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1009 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
1010 char *buff
, int size
, int timeout
)
1012 /* usb_bulk_write() takes const char *buff */
1013 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1016 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
1017 char *bytes
, int size
, int timeout
)
1019 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1020 dev
, ep
, bytes
, size
, timeout
);
1023 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1024 char *bytes
, int size
, int timeout
)
1026 return usb_bulk_with_retries(&usb_bulk_read
,
1027 dev
, ep
, bytes
, size
, timeout
);
1030 /* Write data from out_buffer to USB. */
1031 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1035 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1037 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)",
1038 out_length
, JLINK_OUT_BUFFER_SIZE
);
1042 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1043 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1045 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d",
1046 out_length
, result
);
1048 #ifdef _DEBUG_USB_COMMS_
1049 jlink_debug_buffer(usb_out_buffer
, out_length
);
1054 /* Read data from USB into in_buffer. */
1055 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1057 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1058 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1060 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1062 #ifdef _DEBUG_USB_COMMS_
1063 jlink_debug_buffer(usb_in_buffer
, result
);
1068 /* Read the result from the previous EMU cmd into result_buffer. */
1069 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1071 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1072 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1075 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1077 #ifdef _DEBUG_USB_COMMS_
1078 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1083 #ifdef _DEBUG_USB_COMMS_
1084 #define BYTES_PER_LINE 16
1086 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1093 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1095 snprintf(line
, 5, "%04x", i
);
1096 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1098 snprintf(s
, 4, " %02x", buffer
[j
]);
1101 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)