1 /***************************************************************************
2 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
3 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
28 #include "interface.h"
37 #define JLINK_WRITE_ENDPOINT 0x02
38 #define JLINK_READ_ENDPOINT 0x81
40 static unsigned int jlink_write_ep
= JLINK_WRITE_ENDPOINT
;
41 static unsigned int jlink_read_ep
= JLINK_READ_ENDPOINT
;
42 static unsigned int jlink_hw_jtag_version
= 2;
44 #define JLINK_USB_TIMEOUT 1000
46 // See Section 1.3.2 of the Segger JLink USB protocol manual
47 /* 2048 is the max value we can use here */
48 //#define JLINK_TAP_BUFFER_SIZE 2048
49 #define JLINK_TAP_BUFFER_SIZE 256
50 //#define JLINK_TAP_BUFFER_SIZE 384
52 #define JLINK_IN_BUFFER_SIZE 2048
53 #define JLINK_OUT_BUFFER_SIZE 2*2048 + 4
54 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
56 /* Global USB buffers */
57 static uint8_t usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
58 static uint8_t usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
59 static uint8_t usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
61 /* Constants for JLink command */
62 #define EMU_CMD_VERSION 0x01
63 #define EMU_CMD_SET_SPEED 0x05
64 #define EMU_CMD_GET_STATE 0x07
65 #define EMU_CMD_HW_CLOCK 0xc8
66 #define EMU_CMD_HW_TMS0 0xc9
67 #define EMU_CMD_HW_TMS1 0xca
68 #define EMU_CMD_HW_JTAG2 0xce
69 #define EMU_CMD_HW_JTAG3 0xcf
70 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
71 #define EMU_CMD_HW_RESET0 0xdc
72 #define EMU_CMD_HW_RESET1 0xdd
73 #define EMU_CMD_HW_TRST0 0xde
74 #define EMU_CMD_HW_TRST1 0xdf
75 #define EMU_CMD_GET_CAPS 0xe8
76 #define EMU_CMD_GET_HW_VERSION 0xf0
78 /* bits return from EMU_CMD_GET_CAPS */
79 #define EMU_CAP_GET_HW_VERSION 1
80 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11
82 /* max speed 12MHz v5.0 jlink */
83 #define JLINK_MAX_SPEED 12000
85 /* Queue command functions */
86 static void jlink_end_state(tap_state_t state
);
87 static void jlink_state_move(void);
88 static void jlink_path_move(int num_states
, tap_state_t
*path
);
89 static void jlink_runtest(int num_cycles
);
90 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
);
91 static void jlink_reset(int trst
, int srst
);
92 static void jlink_simple_command(uint8_t command
);
93 static int jlink_get_status(void);
95 /* J-Link tap buffer functions */
96 static void jlink_tap_init(void);
97 static int jlink_tap_execute(void);
98 static void jlink_tap_ensure_space(int scans
, int bits
);
99 static void jlink_tap_append_step(int tms
, int tdi
);
100 static void jlink_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
);
102 /* Jlink lowlevel functions */
104 struct usb_dev_handle
* usb_handle
;
107 static struct jlink
*jlink_usb_open(void);
108 static void jlink_usb_close(struct jlink
*jlink
);
109 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
);
110 static int jlink_usb_write(struct jlink
*jlink
, int out_length
);
111 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
);
112 static int jlink_usb_read_emu_result(struct jlink
*jlink
);
114 /* helper functions */
115 static int jlink_get_version_info(void);
117 #ifdef _DEBUG_USB_COMMS_
118 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
121 static enum tap_state jlink_last_state
= TAP_RESET
;
123 static struct jlink
* jlink_handle
;
125 /***************************************************************************/
126 /* External interface implementation */
128 static void jlink_execute_runtest(struct jtag_command
*cmd
)
130 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
131 cmd
->cmd
.runtest
->num_cycles
,
132 cmd
->cmd
.runtest
->end_state
);
134 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
136 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
139 static void jlink_execute_statemove(struct jtag_command
*cmd
)
141 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
143 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
147 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
149 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
150 cmd
->cmd
.pathmove
->num_states
,
151 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
153 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
154 cmd
->cmd
.pathmove
->path
);
157 static void jlink_execute_scan(struct jtag_command
*cmd
)
163 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
165 jlink_end_state(cmd
->cmd
.scan
->end_state
);
167 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
168 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
170 #ifdef _DEBUG_USB_COMMS_
171 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
173 type
= jtag_scan_type(cmd
->cmd
.scan
);
174 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
175 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
178 static void jlink_execute_reset(struct jtag_command
*cmd
)
180 DEBUG_JTAG_IO("reset trst: %i srst %i",
181 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
184 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
188 static void jlink_execute_sleep(struct jtag_command
*cmd
)
190 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
192 jtag_sleep(cmd
->cmd
.sleep
->us
);
195 static void jlink_execute_command(struct jtag_command
*cmd
)
199 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
200 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
201 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
202 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
203 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
204 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
206 LOG_ERROR("BUG: unknown JTAG command type encountered");
211 static int jlink_execute_queue(void)
213 struct jtag_command
*cmd
= jtag_command_queue
;
217 jlink_execute_command(cmd
);
221 return jlink_tap_execute();
224 /* Sets speed in kHz. */
225 static int jlink_speed(int speed
)
229 if (speed
> JLINK_MAX_SPEED
)
231 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
232 speed
, JLINK_MAX_SPEED
);
236 /* check for RTCK setting */
240 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
241 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
242 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
244 result
= jlink_usb_write(jlink_handle
, 3);
247 LOG_ERROR("J-Link setting speed failed (%d)", result
);
248 return ERROR_JTAG_DEVICE_ERROR
;
254 static int jlink_speed_div(int speed
, int* khz
)
261 static int jlink_khz(int khz
, int *jtag_speed
)
268 static int jlink_init(void)
272 jlink_handle
= jlink_usb_open();
274 if (jlink_handle
== 0)
276 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
277 return ERROR_JTAG_INIT_FAILED
;
281 * The next three instructions were added after discovering a problem while using an oscilloscope. For the V8
282 * SAM-ICE dongle (and likely other j-link device variants), the reset line to the target microprocessor was found to
283 * cycle only intermittently during emulator startup (even after encountering the downstream reset instruction later
284 * 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
285 * state when starting an emulator and 2) something critical happens inside the dongle when it does the first read
286 * following a new USB session. Keeping the processor in reset during the first read collecting version information
287 * seems to prevent errant "J-Link command EMU_CMD_VERSION failed" issues.
290 LOG_INFO("J-Link initialization started / target CPU reset initiated");
291 jlink_simple_command(EMU_CMD_HW_TRST0
);
292 jlink_simple_command(EMU_CMD_HW_RESET0
);
295 jlink_hw_jtag_version
= 2;
297 if (jlink_get_version_info() == ERROR_OK
)
299 /* attempt to get status */
303 LOG_INFO("J-Link JTAG Interface ready");
308 jlink_speed(jtag_get_speed());
310 /* v5/6 jlink seems to have an issue if the first tap move
311 * is not divisible by 8, so we send a TLR on first power up */
312 for (i
= 0; i
< 8; i
++) {
313 jlink_tap_append_step(1, 0);
320 static int jlink_quit(void)
322 jlink_usb_close(jlink_handle
);
326 /***************************************************************************/
327 /* Queue command implementations */
329 static void jlink_end_state(tap_state_t state
)
331 if (tap_is_state_stable(state
))
333 tap_set_end_state(state
);
337 LOG_ERROR("BUG: %i is not a valid end state", state
);
342 /* Goes to the end state. */
343 static void jlink_state_move(void)
347 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
348 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
350 for (i
= 0; i
< tms_scan_bits
; i
++)
352 tms
= (tms_scan
>> i
) & 1;
353 jlink_tap_append_step(tms
, 0);
356 tap_set_state(tap_get_end_state());
359 static void jlink_path_move(int num_states
, tap_state_t
*path
)
363 for (i
= 0; i
< num_states
; i
++)
365 if (path
[i
] == tap_state_transition(tap_get_state(), false))
367 jlink_tap_append_step(0, 0);
369 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
371 jlink_tap_append_step(1, 0);
375 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
379 tap_set_state(path
[i
]);
382 tap_set_end_state(tap_get_state());
385 static void jlink_runtest(int num_cycles
)
389 tap_state_t saved_end_state
= tap_get_end_state();
391 jlink_tap_ensure_space(1,num_cycles
+ 16);
393 /* only do a state_move when we're not already in IDLE */
394 if (tap_get_state() != TAP_IDLE
)
396 jlink_end_state(TAP_IDLE
);
401 /* execute num_cycles */
402 for (i
= 0; i
< num_cycles
; i
++)
404 jlink_tap_append_step(0, 0);
407 /* finish in end_state */
408 jlink_end_state(saved_end_state
);
409 if (tap_get_state() != tap_get_end_state())
415 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
417 tap_state_t saved_end_state
;
419 jlink_tap_ensure_space(1, scan_size
+ 16);
421 saved_end_state
= tap_get_end_state();
423 /* Move to appropriate scan state */
424 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
426 /* Only move if we're not already there */
427 if (tap_get_state() != tap_get_end_state())
430 jlink_end_state(saved_end_state
);
433 jlink_tap_append_scan(scan_size
, buffer
, command
);
435 /* We are in Exit1, go to Pause */
436 jlink_tap_append_step(0, 0);
438 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
440 if (tap_get_state() != tap_get_end_state())
446 static void jlink_reset(int trst
, int srst
)
448 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
450 /* Signals are active low */
453 jlink_simple_command(EMU_CMD_HW_RESET1
);
457 jlink_simple_command(EMU_CMD_HW_RESET0
);
462 jlink_simple_command(EMU_CMD_HW_TRST0
);
467 jlink_simple_command(EMU_CMD_HW_TRST1
);
471 static void jlink_simple_command(uint8_t command
)
475 DEBUG_JTAG_IO("0x%02x", command
);
477 usb_out_buffer
[0] = command
;
478 result
= jlink_usb_write(jlink_handle
, 1);
482 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
486 static int jlink_get_status(void)
490 jlink_simple_command(EMU_CMD_GET_STATE
);
492 result
= jlink_usb_read(jlink_handle
, 8);
495 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
496 return ERROR_JTAG_DEVICE_ERROR
;
499 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
500 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
501 vref
/ 1000, vref
% 1000, \
502 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
503 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
506 LOG_ERROR("Vref too low. Check Target Power\n");
511 static int jlink_get_version_info(void)
515 uint32_t jlink_caps
, jlink_max_size
;
517 /* query hardware version */
518 jlink_simple_command(EMU_CMD_VERSION
);
520 result
= jlink_usb_read(jlink_handle
, 2);
523 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
524 return ERROR_JTAG_DEVICE_ERROR
;
527 len
= buf_get_u32(usb_in_buffer
, 0, 16);
528 if (len
> JLINK_IN_BUFFER_SIZE
)
530 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
531 len
= JLINK_IN_BUFFER_SIZE
;
534 result
= jlink_usb_read(jlink_handle
, len
);
537 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
538 return ERROR_JTAG_DEVICE_ERROR
;
541 usb_in_buffer
[result
] = 0;
542 LOG_INFO("%s", (char *)usb_in_buffer
);
544 /* query hardware capabilities */
545 jlink_simple_command(EMU_CMD_GET_CAPS
);
547 result
= jlink_usb_read(jlink_handle
, 4);
550 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
551 return ERROR_JTAG_DEVICE_ERROR
;
554 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
555 LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps
);
557 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
559 /* query hardware version */
560 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
562 result
= jlink_usb_read(jlink_handle
, 4);
565 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result
);
566 return ERROR_JTAG_DEVICE_ERROR
;
569 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
570 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
571 if (major_revision
>= 5)
572 jlink_hw_jtag_version
= 3;
574 LOG_INFO("JLink hw version %i", (int)jlink_hw_version
);
577 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
579 /* query hardware maximum memory block */
580 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
582 result
= jlink_usb_read(jlink_handle
, 4);
585 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
586 return ERROR_JTAG_DEVICE_ERROR
;
589 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
590 LOG_INFO("JLink max mem block %i", (int)jlink_max_size
);
596 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
598 if (jlink_get_version_info() == ERROR_OK
)
600 /* attempt to get status */
607 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
611 command_print(CMD_CTX
, "jlink hw jtag %i", jlink_hw_jtag_version
);
614 int request_version
= atoi(CMD_ARGV
[0]);
615 switch (request_version
) {
617 jlink_hw_jtag_version
= request_version
;
620 return ERROR_COMMAND_SYNTAX_ERROR
;
625 return ERROR_COMMAND_SYNTAX_ERROR
;
631 static int jlink_register_commands(struct command_context
*cmd_ctx
)
634 register_command(cmd_ctx
, NULL
, "jlink_info",
635 &jlink_handle_jlink_info_command
, COMMAND_EXEC
,
637 register_command(cmd_ctx
, NULL
, "jlink_hw_jtag",
638 &jlink_handle_jlink_hw_jtag_command
, COMMAND_EXEC
,
639 "set/get jlink hw jtag command version [2 | 3]");
643 struct jtag_interface jlink_interface
= {
645 .execute_queue
= &jlink_execute_queue
,
646 .speed
= &jlink_speed
,
647 .speed_div
= &jlink_speed_div
,
649 .register_commands
= &jlink_register_commands
,
654 /***************************************************************************/
655 /* J-Link tap functions */
658 static unsigned tap_length
= 0;
659 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
660 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
661 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
663 struct pending_scan_result
{
664 int first
; /* First bit position in tdo_buffer to read */
665 int length
; /* Number of bits to read */
666 struct scan_command
*command
; /* Corresponding scan command */
670 #define MAX_PENDING_SCAN_RESULTS 256
672 static int pending_scan_results_length
;
673 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
675 static void jlink_tap_init(void)
678 pending_scan_results_length
= 0;
681 static void jlink_tap_ensure_space(int scans
, int bits
)
683 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
684 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
686 if (scans
> available_scans
|| bits
> available_bits
)
692 static void jlink_tap_append_step(int tms
, int tdi
)
694 int index
= tap_length
/ 8;
696 if (index
>= JLINK_TAP_BUFFER_SIZE
)
698 LOG_ERROR("jlink_tap_append_step: overflow");
699 *(uint32_t *)0xFFFFFFFF = 0;
703 int bit_index
= tap_length
% 8;
704 uint8_t bit
= 1 << bit_index
;
706 // we do not pad TMS, so be sure to initialize all bits
709 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
713 tms_buffer
[index
] |= bit
;
715 tms_buffer
[index
] &= ~bit
;
718 tdi_buffer
[index
] |= bit
;
720 tdi_buffer
[index
] &= ~bit
;
725 static void jlink_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
)
727 struct pending_scan_result
*pending_scan_result
=
728 &pending_scan_results_buffer
[pending_scan_results_length
];
731 pending_scan_result
->first
= tap_length
;
732 pending_scan_result
->length
= length
;
733 pending_scan_result
->command
= command
;
734 pending_scan_result
->buffer
= buffer
;
736 for (i
= 0; i
< length
; i
++)
738 int tms
= (i
< (length
- 1)) ? 0 : 1;
739 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
740 jlink_tap_append_step(tms
, tdi
);
742 pending_scan_results_length
++;
745 /* Pad and send a tap sequence to the device, and receive the answer.
746 * For the purpose of padding we assume that we are in idle or pause state. */
747 static int jlink_tap_execute(void)
756 /* JLink returns an extra NULL in packet when size of incoming
757 * message is a multiple of 64, creates problems with USB comms.
758 * WARNING: This will interfere with tap state counting. */
759 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
761 jlink_tap_append_step((tap_get_state() == TAP_RESET
)?1:0, 0);
764 // number of full bytes (plus one if some would be left over)
765 byte_length
= DIV_ROUND_UP(tap_length
, 8);
767 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
768 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
769 usb_out_buffer
[1] = 0;
770 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
771 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
772 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
773 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
775 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
776 tap_length
, jlink_last_state
);
778 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
779 if (result
!= byte_length
)
781 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
783 return ERROR_JTAG_QUEUE_FAILED
;
786 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
788 for (i
= 0; i
< pending_scan_results_length
; i
++)
790 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
791 uint8_t *buffer
= pending_scan_result
->buffer
;
792 int length
= pending_scan_result
->length
;
793 int first
= pending_scan_result
->first
;
794 struct scan_command
*command
= pending_scan_result
->command
;
797 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
799 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
801 #ifdef _DEBUG_USB_COMMS_
802 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
805 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
808 return ERROR_JTAG_QUEUE_FAILED
;
811 if (pending_scan_result
->buffer
!= NULL
)
813 free(pending_scan_result
->buffer
);
821 static struct usb_device
* find_jlink_device(void)
823 struct usb_bus
*busses
;
825 struct usb_device
*dev
;
830 busses
= usb_get_busses();
832 /* find jlink device in usb bus */
834 for (bus
= busses
; bus
; bus
= bus
->next
)
836 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
838 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
)) {
847 /*****************************************************************************/
848 /* JLink USB low-level functions */
850 static struct jlink
* jlink_usb_open()
852 struct usb_device
*dev
;
854 struct jlink
*result
;
856 result
= (struct jlink
*) malloc(sizeof(struct jlink
));
860 if ((dev
= find_jlink_device()) == NULL
) {
865 result
->usb_handle
= usb_open(dev
);
867 if (result
->usb_handle
)
870 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS AREA!!!!!!!!!!!
871 * The behavior of libusb is not completely consistent across Windows, Linux, and Mac OS X platforms. The actions taken
872 * in the following compiler conditionals may not agree with published documentation for libusb, but were found
873 * to be necessary through trials and tribulations. Even little tweaks can break one or more platforms, so if you do make changes
874 * test them carefully on all platforms before committing them!
879 usb_reset(result
->usb_handle
);
885 /* reopen jlink after usb_reset
886 * on win32 this may take a second or two to re-enumerate */
887 while ((dev
= find_jlink_device()) == NULL
)
902 result
->usb_handle
= usb_open(dev
);
907 if (result
->usb_handle
)
909 /* usb_set_configuration required under win32 */
910 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
911 usb_claim_interface(result
->usb_handle
, 0);
915 * This makes problems under Mac OS X. And is not needed
916 * under Windows. Hopefully this will not break a linux build
918 usb_set_altinterface(result
->usb_handle
, 0);
920 struct usb_interface
*iface
= dev
->config
->interface
;
921 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
922 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
924 uint8_t epnum
= desc
->endpoint
[i
].bEndpointAddress
;
925 bool is_input
= epnum
& 0x80;
926 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
928 jlink_read_ep
= epnum
;
930 jlink_write_ep
= epnum
;
941 static void jlink_usb_close(struct jlink
*jlink
)
943 usb_close(jlink
->usb_handle
);
947 /* Send a message and receive the reply. */
948 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
952 result
= jlink_usb_write(jlink
, out_length
);
953 if (result
!= out_length
)
955 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
957 return ERROR_JTAG_DEVICE_ERROR
;
960 result
= jlink_usb_read(jlink
, in_length
);
961 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
963 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
965 return ERROR_JTAG_DEVICE_ERROR
;
968 if (jlink_hw_jtag_version
< 3)
971 int result2
= ERROR_OK
;
972 if (result
== in_length
)
974 /* Must read the result from the EMU too */
975 result2
= jlink_usb_read_emu_result(jlink
);
978 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, result=%d, in_length=%i", result2
,in_length
);
979 /* Try again once, should only happen if (in_length%64 == 0) */
980 result2
= jlink_usb_read_emu_result(jlink
);
983 LOG_ERROR("jlink_usb_read_emu_result failed "
984 "(requested = 1, result=%d)", result2
);
985 return ERROR_JTAG_DEVICE_ERROR
;
989 /* Check the result itself */
990 result2
= usb_emu_result_buffer
[0];
994 /* Save the result, then remove it from return value */
995 result2
= usb_in_buffer
[result
--];
1000 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
1001 return ERROR_JTAG_DEVICE_ERROR
;
1007 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
1008 static int usb_bulk_with_retries(
1009 int (*f
)(usb_dev_handle
*, int, char *, int, int),
1010 usb_dev_handle
*dev
, int ep
,
1011 char *bytes
, int size
, int timeout
)
1013 int tries
= 3, count
= 0;
1015 while (tries
&& (count
< size
))
1017 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1020 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1026 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
1027 char *buff
, int size
, int timeout
)
1029 /* usb_bulk_write() takes const char *buff */
1030 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1033 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
1034 char *bytes
, int size
, int timeout
)
1036 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1037 dev
, ep
, bytes
, size
, timeout
);
1040 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1041 char *bytes
, int size
, int timeout
)
1043 return usb_bulk_with_retries(&usb_bulk_read
,
1044 dev
, ep
, bytes
, size
, timeout
);
1047 /* Write data from out_buffer to USB. */
1048 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1052 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1054 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
1058 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1059 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1061 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
1063 #ifdef _DEBUG_USB_COMMS_
1064 jlink_debug_buffer(usb_out_buffer
, out_length
);
1069 /* Read data from USB into in_buffer. */
1070 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1072 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1073 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1075 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1077 #ifdef _DEBUG_USB_COMMS_
1078 jlink_debug_buffer(usb_in_buffer
, result
);
1083 /* Read the result from the previous EMU cmd into result_buffer. */
1084 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1086 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1087 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1090 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1092 #ifdef _DEBUG_USB_COMMS_
1093 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1098 #ifdef _DEBUG_USB_COMMS_
1099 #define BYTES_PER_LINE 16
1101 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1108 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1110 snprintf(line
, 5, "%04x", i
);
1111 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1113 snprintf(s
, 4, " %02x", buffer
[j
]);
1116 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)