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
43 #define JLINK_WRITE_ENDPOINT 0x02
44 #define JLINK_READ_ENDPOINT 0x81
46 static unsigned int jlink_write_ep
= JLINK_WRITE_ENDPOINT
;
47 static unsigned int jlink_read_ep
= JLINK_READ_ENDPOINT
;
48 static unsigned int jlink_hw_jtag_version
= 2;
50 #define JLINK_USB_TIMEOUT 1000
52 // See Section 1.3.2 of the Segger JLink USB protocol manual
53 /* 2048 is the max value we can use here */
54 //#define JLINK_TAP_BUFFER_SIZE 2048
55 #define JLINK_TAP_BUFFER_SIZE 256
56 //#define JLINK_TAP_BUFFER_SIZE 384
58 #define JLINK_IN_BUFFER_SIZE 2048
59 #define JLINK_OUT_BUFFER_SIZE 2*2048 + 4
60 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
62 /* Global USB buffers */
63 static uint8_t usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
64 static uint8_t usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
65 static uint8_t usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
67 /* Constants for JLink command */
68 #define EMU_CMD_VERSION 0x01
69 #define EMU_CMD_SET_SPEED 0x05
70 #define EMU_CMD_GET_STATE 0x07
71 #define EMU_CMD_HW_CLOCK 0xc8
72 #define EMU_CMD_HW_TMS0 0xc9
73 #define EMU_CMD_HW_TMS1 0xca
74 #define EMU_CMD_HW_JTAG2 0xce
75 #define EMU_CMD_HW_JTAG3 0xcf
76 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
77 #define EMU_CMD_HW_RESET0 0xdc
78 #define EMU_CMD_HW_RESET1 0xdd
79 #define EMU_CMD_HW_TRST0 0xde
80 #define EMU_CMD_HW_TRST1 0xdf
81 #define EMU_CMD_GET_CAPS 0xe8
82 #define EMU_CMD_GET_HW_VERSION 0xf0
84 /* bits return from EMU_CMD_GET_CAPS */
85 #define EMU_CAP_GET_HW_VERSION 1
86 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11
88 /* max speed 12MHz v5.0 jlink */
89 #define JLINK_MAX_SPEED 12000
91 /* Queue command functions */
92 static void jlink_end_state(tap_state_t state
);
93 static void jlink_state_move(void);
94 static void jlink_path_move(int num_states
, tap_state_t
*path
);
95 static void jlink_runtest(int num_cycles
);
96 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
97 int scan_size
, struct scan_command
*command
);
98 static void jlink_reset(int trst
, int srst
);
99 static void jlink_simple_command(uint8_t command
);
100 static int jlink_get_status(void);
102 /* J-Link tap buffer functions */
103 static void jlink_tap_init(void);
104 static int jlink_tap_execute(void);
105 static void jlink_tap_ensure_space(int scans
, int bits
);
106 static void jlink_tap_append_step(int tms
, int tdi
);
107 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
108 struct scan_command
*command
);
110 /* Jlink lowlevel functions */
112 struct usb_dev_handle
* usb_handle
;
115 static struct jlink
*jlink_usb_open(void);
116 static void jlink_usb_close(struct jlink
*jlink
);
117 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
);
118 static int jlink_usb_write(struct jlink
*jlink
, int out_length
);
119 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
);
120 static int jlink_usb_read_emu_result(struct jlink
*jlink
);
122 /* helper functions */
123 static int jlink_get_version_info(void);
125 #ifdef _DEBUG_USB_COMMS_
126 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
129 static enum tap_state jlink_last_state
= TAP_RESET
;
131 static struct jlink
* jlink_handle
;
133 /***************************************************************************/
134 /* External interface implementation */
136 static void jlink_execute_runtest(struct jtag_command
*cmd
)
138 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
139 cmd
->cmd
.runtest
->num_cycles
,
140 cmd
->cmd
.runtest
->end_state
);
142 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
144 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
147 static void jlink_execute_statemove(struct jtag_command
*cmd
)
149 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
151 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
155 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
157 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
158 cmd
->cmd
.pathmove
->num_states
,
159 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
161 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
162 cmd
->cmd
.pathmove
->path
);
165 static void jlink_execute_scan(struct jtag_command
*cmd
)
171 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
173 jlink_end_state(cmd
->cmd
.scan
->end_state
);
175 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
176 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
178 #ifdef _DEBUG_USB_COMMS_
179 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
181 type
= jtag_scan_type(cmd
->cmd
.scan
);
182 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
183 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
186 static void jlink_execute_reset(struct jtag_command
*cmd
)
188 DEBUG_JTAG_IO("reset trst: %i srst %i",
189 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
192 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
196 static void jlink_execute_sleep(struct jtag_command
*cmd
)
198 DEBUG_JTAG_IO("sleep %" PRIi32
"", cmd
->cmd
.sleep
->us
);
200 jtag_sleep(cmd
->cmd
.sleep
->us
);
203 static void jlink_execute_command(struct jtag_command
*cmd
)
207 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
208 case JTAG_TLR_RESET
: jlink_execute_statemove(cmd
); break;
209 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
210 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
211 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
212 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
214 LOG_ERROR("BUG: unknown JTAG command type encountered");
219 static int jlink_execute_queue(void)
221 struct jtag_command
*cmd
= jtag_command_queue
;
225 jlink_execute_command(cmd
);
229 return jlink_tap_execute();
232 /* Sets speed in kHz. */
233 static int jlink_speed(int speed
)
237 if (speed
> JLINK_MAX_SPEED
)
239 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
240 speed
, JLINK_MAX_SPEED
);
244 /* check for RTCK setting */
248 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
249 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
250 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
252 result
= jlink_usb_write(jlink_handle
, 3);
255 LOG_ERROR("J-Link setting speed failed (%d)", result
);
256 return ERROR_JTAG_DEVICE_ERROR
;
262 static int jlink_speed_div(int speed
, int* khz
)
269 static int jlink_khz(int khz
, int *jtag_speed
)
276 static int jlink_init(void)
280 jlink_handle
= jlink_usb_open();
282 if (jlink_handle
== 0)
284 LOG_ERROR("Cannot find jlink Interface! Please check "
285 "connection and permissions.");
286 return ERROR_JTAG_INIT_FAILED
;
290 * The next three instructions were added after discovering a problem
291 * while using an oscilloscope.
292 * For the V8 SAM-ICE dongle (and likely other j-link device variants),
293 * the reset line to the target microprocessor was found to cycle only
294 * intermittently during emulator startup (even after encountering the
295 * downstream reset instruction later in the code).
296 * This was found to create two issues:
297 * 1) In general it is a bad practice to not reset a CPU to a known
298 * state when starting an emulator and
299 * 2) something critical happens inside the dongle when it does the
300 * first read following a new USB session.
301 * Keeping the processor in reset during the first read collecting
302 * version information seems to prevent errant
303 * "J-Link command EMU_CMD_VERSION failed" issues.
306 LOG_INFO("J-Link initialization started / target CPU reset initiated");
307 jlink_simple_command(EMU_CMD_HW_TRST0
);
308 jlink_simple_command(EMU_CMD_HW_RESET0
);
311 jlink_hw_jtag_version
= 2;
313 if (jlink_get_version_info() == ERROR_OK
)
315 /* attempt to get status */
319 LOG_INFO("J-Link JTAG Interface ready");
324 jlink_speed(jtag_get_speed());
326 /* v5/6 jlink seems to have an issue if the first tap move
327 * is not divisible by 8, so we send a TLR on first power up */
328 for (i
= 0; i
< 8; i
++) {
329 jlink_tap_append_step(1, 0);
336 static int jlink_quit(void)
338 jlink_usb_close(jlink_handle
);
342 /***************************************************************************/
343 /* Queue command implementations */
345 static void jlink_end_state(tap_state_t state
)
347 if (tap_is_state_stable(state
))
349 tap_set_end_state(state
);
353 LOG_ERROR("BUG: %i is not a valid end state", state
);
358 /* Goes to the end state. */
359 static void jlink_state_move(void)
363 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
364 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
366 for (i
= 0; i
< tms_scan_bits
; i
++)
368 tms
= (tms_scan
>> i
) & 1;
369 jlink_tap_append_step(tms
, 0);
372 tap_set_state(tap_get_end_state());
375 static void jlink_path_move(int num_states
, tap_state_t
*path
)
379 for (i
= 0; i
< num_states
; i
++)
381 if (path
[i
] == tap_state_transition(tap_get_state(), false))
383 jlink_tap_append_step(0, 0);
385 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
387 jlink_tap_append_step(1, 0);
391 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
392 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
396 tap_set_state(path
[i
]);
399 tap_set_end_state(tap_get_state());
402 static void jlink_runtest(int num_cycles
)
406 tap_state_t saved_end_state
= tap_get_end_state();
408 jlink_tap_ensure_space(1,num_cycles
+ 16);
410 /* only do a state_move when we're not already in IDLE */
411 if (tap_get_state() != TAP_IDLE
)
413 jlink_end_state(TAP_IDLE
);
418 /* execute num_cycles */
419 for (i
= 0; i
< num_cycles
; i
++)
421 jlink_tap_append_step(0, 0);
424 /* finish in end_state */
425 jlink_end_state(saved_end_state
);
426 if (tap_get_state() != tap_get_end_state())
432 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
433 int scan_size
, struct scan_command
*command
)
435 tap_state_t saved_end_state
;
437 jlink_tap_ensure_space(1, scan_size
+ 16);
439 saved_end_state
= tap_get_end_state();
441 /* Move to appropriate scan state */
442 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
444 /* Only move if we're not already there */
445 if (tap_get_state() != tap_get_end_state())
448 jlink_end_state(saved_end_state
);
451 jlink_tap_append_scan(scan_size
, buffer
, command
);
453 /* We are in Exit1, go to Pause */
454 jlink_tap_append_step(0, 0);
456 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
458 if (tap_get_state() != tap_get_end_state())
464 static void jlink_reset(int trst
, int srst
)
466 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
468 /* Signals are active low */
471 jlink_simple_command(EMU_CMD_HW_RESET1
);
475 jlink_simple_command(EMU_CMD_HW_RESET0
);
480 jlink_simple_command(EMU_CMD_HW_TRST0
);
485 jlink_simple_command(EMU_CMD_HW_TRST1
);
489 static void jlink_simple_command(uint8_t command
)
493 DEBUG_JTAG_IO("0x%02x", command
);
495 usb_out_buffer
[0] = command
;
496 result
= jlink_usb_write(jlink_handle
, 1);
500 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
504 static int jlink_get_status(void)
508 jlink_simple_command(EMU_CMD_GET_STATE
);
510 result
= jlink_usb_read(jlink_handle
, 8);
513 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
514 return ERROR_JTAG_DEVICE_ERROR
;
517 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
518 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \
519 vref
/ 1000, vref
% 1000, \
520 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
521 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
524 LOG_ERROR("Vref too low. Check Target Power");
529 static int jlink_get_version_info(void)
533 uint32_t jlink_caps
, jlink_max_size
;
535 /* query hardware version */
536 jlink_simple_command(EMU_CMD_VERSION
);
538 result
= jlink_usb_read(jlink_handle
, 2);
541 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
542 return ERROR_JTAG_DEVICE_ERROR
;
545 len
= buf_get_u32(usb_in_buffer
, 0, 16);
546 if (len
> JLINK_IN_BUFFER_SIZE
)
548 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
549 len
= JLINK_IN_BUFFER_SIZE
;
552 result
= jlink_usb_read(jlink_handle
, len
);
555 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
556 return ERROR_JTAG_DEVICE_ERROR
;
559 usb_in_buffer
[result
] = 0;
560 LOG_INFO("%s", (char *)usb_in_buffer
);
562 /* query hardware capabilities */
563 jlink_simple_command(EMU_CMD_GET_CAPS
);
565 result
= jlink_usb_read(jlink_handle
, 4);
568 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", result
);
569 return ERROR_JTAG_DEVICE_ERROR
;
572 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
573 LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps
);
575 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
577 /* query hardware version */
578 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
580 result
= jlink_usb_read(jlink_handle
, 4);
583 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result
);
584 return ERROR_JTAG_DEVICE_ERROR
;
587 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
588 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
589 if (major_revision
>= 5)
590 jlink_hw_jtag_version
= 3;
592 LOG_INFO("JLink hw version %i", (int)jlink_hw_version
);
595 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
597 /* query hardware maximum memory block */
598 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
600 result
= jlink_usb_read(jlink_handle
, 4);
603 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", result
);
604 return ERROR_JTAG_DEVICE_ERROR
;
607 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
608 LOG_INFO("JLink max mem block %i", (int)jlink_max_size
);
614 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
616 if (jlink_get_version_info() == ERROR_OK
)
618 /* attempt to get status */
625 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
629 command_print(CMD_CTX
, "jlink hw jtag %i", jlink_hw_jtag_version
);
632 int request_version
= atoi(CMD_ARGV
[0]);
633 switch (request_version
) {
635 jlink_hw_jtag_version
= request_version
;
638 return ERROR_COMMAND_SYNTAX_ERROR
;
643 return ERROR_COMMAND_SYNTAX_ERROR
;
649 static const struct command_registration jlink_command_handlers
[] = {
651 .name
= "jlink_info",
652 .handler
= &jlink_handle_jlink_info_command
,
653 .mode
= COMMAND_EXEC
,
654 .help
= "show jlink info",
657 .name
= "jlink_hw_jtag",
658 .handler
= &jlink_handle_jlink_hw_jtag_command
,
659 .mode
= COMMAND_EXEC
,
660 .help
= "access J-Link HW JTAG command version",
663 COMMAND_REGISTRATION_DONE
666 struct jtag_interface jlink_interface
= {
668 .commands
= jlink_command_handlers
,
670 .execute_queue
= jlink_execute_queue
,
671 .speed
= jlink_speed
,
672 .speed_div
= jlink_speed_div
,
678 /***************************************************************************/
679 /* J-Link tap functions */
682 static unsigned tap_length
= 0;
683 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
684 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
685 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
687 struct pending_scan_result
{
688 int first
; /* First bit position in tdo_buffer to read */
689 int length
; /* Number of bits to read */
690 struct scan_command
*command
; /* Corresponding scan command */
694 #define MAX_PENDING_SCAN_RESULTS 256
696 static int pending_scan_results_length
;
697 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
699 static void jlink_tap_init(void)
702 pending_scan_results_length
= 0;
705 static void jlink_tap_ensure_space(int scans
, int bits
)
707 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
708 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
710 if (scans
> available_scans
|| bits
> available_bits
)
716 static void jlink_tap_append_step(int tms
, int tdi
)
718 int index_var
= tap_length
/ 8;
720 if (index_var
>= JLINK_TAP_BUFFER_SIZE
)
722 LOG_ERROR("jlink_tap_append_step: overflow");
723 *(uint32_t *)0xFFFFFFFF = 0;
727 int bit_index
= tap_length
% 8;
728 uint8_t bit
= 1 << bit_index
;
730 // we do not pad TMS, so be sure to initialize all bits
733 tms_buffer
[index_var
] = tdi_buffer
[index_var
] = 0;
737 tms_buffer
[index_var
] |= bit
;
739 tms_buffer
[index_var
] &= ~bit
;
742 tdi_buffer
[index_var
] |= bit
;
744 tdi_buffer
[index_var
] &= ~bit
;
749 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
750 struct scan_command
*command
)
752 struct pending_scan_result
*pending_scan_result
=
753 &pending_scan_results_buffer
[pending_scan_results_length
];
756 pending_scan_result
->first
= tap_length
;
757 pending_scan_result
->length
= length
;
758 pending_scan_result
->command
= command
;
759 pending_scan_result
->buffer
= buffer
;
761 for (i
= 0; i
< length
; i
++)
763 int tms
= (i
< (length
- 1)) ? 0 : 1;
764 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
765 jlink_tap_append_step(tms
, tdi
);
767 pending_scan_results_length
++;
770 /* Pad and send a tap sequence to the device, and receive the answer.
771 * For the purpose of padding we assume that we are in idle or pause state. */
772 static int jlink_tap_execute(void)
781 /* JLink returns an extra NULL in packet when size of incoming
782 * message is a multiple of 64, creates problems with USB comms.
783 * WARNING: This will interfere with tap state counting. */
784 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
786 jlink_tap_append_step((tap_get_state() == TAP_RESET
) ? 1 : 0, 0);
789 // number of full bytes (plus one if some would be left over)
790 byte_length
= DIV_ROUND_UP(tap_length
, 8);
792 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
793 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
794 usb_out_buffer
[1] = 0;
795 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
796 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
797 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
798 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
800 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
801 tap_length
, jlink_last_state
);
803 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
804 if (result
!= byte_length
)
806 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
807 result
, byte_length
);
809 return ERROR_JTAG_QUEUE_FAILED
;
812 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
814 for (i
= 0; i
< pending_scan_results_length
; i
++)
816 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
817 uint8_t *buffer
= pending_scan_result
->buffer
;
818 int length
= pending_scan_result
->length
;
819 int first
= pending_scan_result
->first
;
820 struct scan_command
*command
= pending_scan_result
->command
;
823 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
825 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
827 #ifdef _DEBUG_USB_COMMS_
828 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
831 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
834 return ERROR_JTAG_QUEUE_FAILED
;
837 if (pending_scan_result
->buffer
!= NULL
)
839 free(pending_scan_result
->buffer
);
847 /*****************************************************************************/
848 /* JLink USB low-level functions */
850 static struct jlink
* jlink_usb_open()
854 const uint16_t vids
[] = { VID
, 0 };
855 const uint16_t pids
[] = { PID
, 0 };
856 struct usb_dev_handle
*dev
;
857 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
860 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
861 * AREA!!!!!!!!!!! The behavior of libusb is not completely
862 * consistent across Windows, Linux, and Mac OS X platforms.
863 * The actions taken in the following compiler conditionals may
864 * not agree with published documentation for libusb, but were
865 * found to be necessary through trials and tribulations. Even
866 * little tweaks can break one or more platforms, so if you do
867 * make changes test them carefully on all platforms before
878 /* reopen jlink after usb_reset
879 * on win32 this may take a second or two to re-enumerate */
881 while ((retval
= jtag_usb_open(vids
, pids
, &dev
)) != ERROR_OK
)
889 if (ERROR_OK
!= retval
)
895 /* usb_set_configuration required under win32 */
896 struct usb_device
*udev
= usb_device(dev
);
897 usb_set_configuration(dev
, udev
->config
[0].bConfigurationValue
);
898 usb_claim_interface(dev
, 0);
902 * This makes problems under Mac OS X. And is not needed
903 * under Windows. Hopefully this will not break a linux build
905 usb_set_altinterface(result
->usb_handle
, 0);
907 struct usb_interface
*iface
= udev
->config
->interface
;
908 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
909 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
911 uint8_t epnum
= desc
->endpoint
[i
].bEndpointAddress
;
912 bool is_input
= epnum
& 0x80;
913 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
915 jlink_read_ep
= epnum
;
917 jlink_write_ep
= epnum
;
920 struct jlink
*result
= malloc(sizeof(struct jlink
));
921 result
->usb_handle
= dev
;
925 static void jlink_usb_close(struct jlink
*jlink
)
927 usb_close(jlink
->usb_handle
);
931 /* Send a message and receive the reply. */
932 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
936 result
= jlink_usb_write(jlink
, out_length
);
937 if (result
!= out_length
)
939 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
941 return ERROR_JTAG_DEVICE_ERROR
;
944 result
= jlink_usb_read(jlink
, in_length
);
945 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
947 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
949 return ERROR_JTAG_DEVICE_ERROR
;
952 if (jlink_hw_jtag_version
< 3)
955 int result2
= ERROR_OK
;
956 if (result
== in_length
)
958 /* Must read the result from the EMU too */
959 result2
= jlink_usb_read_emu_result(jlink
);
962 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, "
963 "result=%d, in_length=%i", result2
, in_length
);
964 /* Try again once, should only happen if (in_length%64 == 0) */
965 result2
= jlink_usb_read_emu_result(jlink
);
968 LOG_ERROR("jlink_usb_read_emu_result failed "
969 "(requested = 1, result=%d)", result2
);
970 return ERROR_JTAG_DEVICE_ERROR
;
974 /* Check the result itself */
975 result2
= usb_emu_result_buffer
[0];
979 /* Save the result, then remove it from return value */
980 result2
= usb_in_buffer
[result
--];
985 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
986 return ERROR_JTAG_DEVICE_ERROR
;
992 /* calls the given usb_bulk_* function, allowing for the data to
993 * trickle in with some timeouts */
994 static int usb_bulk_with_retries(
995 int (*f
)(usb_dev_handle
*, int, char *, int, int),
996 usb_dev_handle
*dev
, int ep
,
997 char *bytes
, int size
, int timeout
)
999 int tries
= 3, count
= 0;
1001 while (tries
&& (count
< size
))
1003 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1006 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1012 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
1013 char *buff
, int size
, int timeout
)
1015 /* usb_bulk_write() takes const char *buff */
1016 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1019 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
1020 char *bytes
, int size
, int timeout
)
1022 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1023 dev
, ep
, bytes
, size
, timeout
);
1026 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1027 char *bytes
, int size
, int timeout
)
1029 return usb_bulk_with_retries(&usb_bulk_read
,
1030 dev
, ep
, bytes
, size
, timeout
);
1033 /* Write data from out_buffer to USB. */
1034 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1038 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1040 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)",
1041 out_length
, JLINK_OUT_BUFFER_SIZE
);
1045 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1046 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1048 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d",
1049 out_length
, result
);
1051 #ifdef _DEBUG_USB_COMMS_
1052 jlink_debug_buffer(usb_out_buffer
, out_length
);
1057 /* Read data from USB into in_buffer. */
1058 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1060 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1061 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1063 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1065 #ifdef _DEBUG_USB_COMMS_
1066 jlink_debug_buffer(usb_in_buffer
, result
);
1071 /* Read the result from the previous EMU cmd into result_buffer. */
1072 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1074 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1075 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1078 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1080 #ifdef _DEBUG_USB_COMMS_
1081 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1086 #ifdef _DEBUG_USB_COMMS_
1087 #define BYTES_PER_LINE 16
1089 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1096 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1098 snprintf(line
, 5, "%04x", i
);
1099 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1101 snprintf(s
, 4, " %02x", buffer
[j
]);
1104 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)