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"
30 #include "usb_common.h"
36 #define JLINK_WRITE_ENDPOINT 0x02
37 #define JLINK_READ_ENDPOINT 0x81
39 static unsigned int jlink_write_ep
= JLINK_WRITE_ENDPOINT
;
40 static unsigned int jlink_read_ep
= JLINK_READ_ENDPOINT
;
41 static unsigned int jlink_hw_jtag_version
= 2;
43 #define JLINK_USB_TIMEOUT 1000
45 // See Section 1.3.2 of the Segger JLink USB protocol manual
46 /* 2048 is the max value we can use here */
47 //#define JLINK_TAP_BUFFER_SIZE 2048
48 #define JLINK_TAP_BUFFER_SIZE 256
49 //#define JLINK_TAP_BUFFER_SIZE 384
51 #define JLINK_IN_BUFFER_SIZE 2048
52 #define JLINK_OUT_BUFFER_SIZE 2*2048 + 4
53 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
55 /* Global USB buffers */
56 static uint8_t usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
57 static uint8_t usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
58 static uint8_t usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
60 /* Constants for JLink command */
61 #define EMU_CMD_VERSION 0x01
62 #define EMU_CMD_SET_SPEED 0x05
63 #define EMU_CMD_GET_STATE 0x07
64 #define EMU_CMD_HW_CLOCK 0xc8
65 #define EMU_CMD_HW_TMS0 0xc9
66 #define EMU_CMD_HW_TMS1 0xca
67 #define EMU_CMD_HW_JTAG2 0xce
68 #define EMU_CMD_HW_JTAG3 0xcf
69 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
70 #define EMU_CMD_HW_RESET0 0xdc
71 #define EMU_CMD_HW_RESET1 0xdd
72 #define EMU_CMD_HW_TRST0 0xde
73 #define EMU_CMD_HW_TRST1 0xdf
74 #define EMU_CMD_GET_CAPS 0xe8
75 #define EMU_CMD_GET_HW_VERSION 0xf0
77 /* bits return from EMU_CMD_GET_CAPS */
78 #define EMU_CAP_GET_HW_VERSION 1
79 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11
81 /* max speed 12MHz v5.0 jlink */
82 #define JLINK_MAX_SPEED 12000
84 /* Queue command functions */
85 static void jlink_end_state(tap_state_t state
);
86 static void jlink_state_move(void);
87 static void jlink_path_move(int num_states
, tap_state_t
*path
);
88 static void jlink_runtest(int num_cycles
);
89 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
);
90 static void jlink_reset(int trst
, int srst
);
91 static void jlink_simple_command(uint8_t command
);
92 static int jlink_get_status(void);
94 /* J-Link tap buffer functions */
95 static void jlink_tap_init(void);
96 static int jlink_tap_execute(void);
97 static void jlink_tap_ensure_space(int scans
, int bits
);
98 static void jlink_tap_append_step(int tms
, int tdi
);
99 static void jlink_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
);
101 /* Jlink lowlevel functions */
103 struct usb_dev_handle
* usb_handle
;
106 static struct jlink
*jlink_usb_open(void);
107 static void jlink_usb_close(struct jlink
*jlink
);
108 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
);
109 static int jlink_usb_write(struct jlink
*jlink
, int out_length
);
110 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
);
111 static int jlink_usb_read_emu_result(struct jlink
*jlink
);
113 /* helper functions */
114 static int jlink_get_version_info(void);
116 #ifdef _DEBUG_USB_COMMS_
117 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
120 static enum tap_state jlink_last_state
= TAP_RESET
;
122 static struct jlink
* jlink_handle
;
124 /***************************************************************************/
125 /* External interface implementation */
127 static void jlink_execute_runtest(struct jtag_command
*cmd
)
129 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
130 cmd
->cmd
.runtest
->num_cycles
,
131 cmd
->cmd
.runtest
->end_state
);
133 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
135 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
138 static void jlink_execute_statemove(struct jtag_command
*cmd
)
140 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
142 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
146 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
148 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
149 cmd
->cmd
.pathmove
->num_states
,
150 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
152 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
153 cmd
->cmd
.pathmove
->path
);
156 static void jlink_execute_scan(struct jtag_command
*cmd
)
162 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
164 jlink_end_state(cmd
->cmd
.scan
->end_state
);
166 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
167 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
169 #ifdef _DEBUG_USB_COMMS_
170 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
172 type
= jtag_scan_type(cmd
->cmd
.scan
);
173 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
174 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
177 static void jlink_execute_reset(struct jtag_command
*cmd
)
179 DEBUG_JTAG_IO("reset trst: %i srst %i",
180 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
183 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
187 static void jlink_execute_sleep(struct jtag_command
*cmd
)
189 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
191 jtag_sleep(cmd
->cmd
.sleep
->us
);
194 static void jlink_execute_command(struct jtag_command
*cmd
)
198 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
199 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
200 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
201 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
202 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
203 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
205 LOG_ERROR("BUG: unknown JTAG command type encountered");
210 static int jlink_execute_queue(void)
212 struct jtag_command
*cmd
= jtag_command_queue
;
216 jlink_execute_command(cmd
);
220 return jlink_tap_execute();
223 /* Sets speed in kHz. */
224 static int jlink_speed(int speed
)
228 if (speed
> JLINK_MAX_SPEED
)
230 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
231 speed
, JLINK_MAX_SPEED
);
235 /* check for RTCK setting */
239 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
240 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
241 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
243 result
= jlink_usb_write(jlink_handle
, 3);
246 LOG_ERROR("J-Link setting speed failed (%d)", result
);
247 return ERROR_JTAG_DEVICE_ERROR
;
253 static int jlink_speed_div(int speed
, int* khz
)
260 static int jlink_khz(int khz
, int *jtag_speed
)
267 static int jlink_init(void)
271 jlink_handle
= jlink_usb_open();
273 if (jlink_handle
== 0)
275 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
276 return ERROR_JTAG_INIT_FAILED
;
280 * The next three instructions were added after discovering a problem while using an oscilloscope. For the V8
281 * SAM-ICE dongle (and likely other j-link device variants), the reset line to the target microprocessor was found to
282 * cycle only intermittently during emulator startup (even after encountering the downstream reset instruction later
283 * 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
284 * state when starting an emulator and 2) something critical happens inside the dongle when it does the first read
285 * following a new USB session. Keeping the processor in reset during the first read collecting version information
286 * seems to prevent errant "J-Link command EMU_CMD_VERSION failed" issues.
289 LOG_INFO("J-Link initialization started / target CPU reset initiated");
290 jlink_simple_command(EMU_CMD_HW_TRST0
);
291 jlink_simple_command(EMU_CMD_HW_RESET0
);
294 jlink_hw_jtag_version
= 2;
296 if (jlink_get_version_info() == ERROR_OK
)
298 /* attempt to get status */
302 LOG_INFO("J-Link JTAG Interface ready");
307 jlink_speed(jtag_get_speed());
309 /* v5/6 jlink seems to have an issue if the first tap move
310 * is not divisible by 8, so we send a TLR on first power up */
311 for (i
= 0; i
< 8; i
++) {
312 jlink_tap_append_step(1, 0);
319 static int jlink_quit(void)
321 jlink_usb_close(jlink_handle
);
325 /***************************************************************************/
326 /* Queue command implementations */
328 static void jlink_end_state(tap_state_t state
)
330 if (tap_is_state_stable(state
))
332 tap_set_end_state(state
);
336 LOG_ERROR("BUG: %i is not a valid end state", state
);
341 /* Goes to the end state. */
342 static void jlink_state_move(void)
346 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
347 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
349 for (i
= 0; i
< tms_scan_bits
; i
++)
351 tms
= (tms_scan
>> i
) & 1;
352 jlink_tap_append_step(tms
, 0);
355 tap_set_state(tap_get_end_state());
358 static void jlink_path_move(int num_states
, tap_state_t
*path
)
362 for (i
= 0; i
< num_states
; i
++)
364 if (path
[i
] == tap_state_transition(tap_get_state(), false))
366 jlink_tap_append_step(0, 0);
368 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
370 jlink_tap_append_step(1, 0);
374 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
378 tap_set_state(path
[i
]);
381 tap_set_end_state(tap_get_state());
384 static void jlink_runtest(int num_cycles
)
388 tap_state_t saved_end_state
= tap_get_end_state();
390 jlink_tap_ensure_space(1,num_cycles
+ 16);
392 /* only do a state_move when we're not already in IDLE */
393 if (tap_get_state() != TAP_IDLE
)
395 jlink_end_state(TAP_IDLE
);
400 /* execute num_cycles */
401 for (i
= 0; i
< num_cycles
; i
++)
403 jlink_tap_append_step(0, 0);
406 /* finish in end_state */
407 jlink_end_state(saved_end_state
);
408 if (tap_get_state() != tap_get_end_state())
414 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
416 tap_state_t saved_end_state
;
418 jlink_tap_ensure_space(1, scan_size
+ 16);
420 saved_end_state
= tap_get_end_state();
422 /* Move to appropriate scan state */
423 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
425 /* Only move if we're not already there */
426 if (tap_get_state() != tap_get_end_state())
429 jlink_end_state(saved_end_state
);
432 jlink_tap_append_scan(scan_size
, buffer
, command
);
434 /* We are in Exit1, go to Pause */
435 jlink_tap_append_step(0, 0);
437 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
439 if (tap_get_state() != tap_get_end_state())
445 static void jlink_reset(int trst
, int srst
)
447 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
449 /* Signals are active low */
452 jlink_simple_command(EMU_CMD_HW_RESET1
);
456 jlink_simple_command(EMU_CMD_HW_RESET0
);
461 jlink_simple_command(EMU_CMD_HW_TRST0
);
466 jlink_simple_command(EMU_CMD_HW_TRST1
);
470 static void jlink_simple_command(uint8_t command
)
474 DEBUG_JTAG_IO("0x%02x", command
);
476 usb_out_buffer
[0] = command
;
477 result
= jlink_usb_write(jlink_handle
, 1);
481 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
485 static int jlink_get_status(void)
489 jlink_simple_command(EMU_CMD_GET_STATE
);
491 result
= jlink_usb_read(jlink_handle
, 8);
494 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
495 return ERROR_JTAG_DEVICE_ERROR
;
498 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
499 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
500 vref
/ 1000, vref
% 1000, \
501 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
502 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
505 LOG_ERROR("Vref too low. Check Target Power\n");
510 static int jlink_get_version_info(void)
514 uint32_t jlink_caps
, jlink_max_size
;
516 /* query hardware version */
517 jlink_simple_command(EMU_CMD_VERSION
);
519 result
= jlink_usb_read(jlink_handle
, 2);
522 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
523 return ERROR_JTAG_DEVICE_ERROR
;
526 len
= buf_get_u32(usb_in_buffer
, 0, 16);
527 if (len
> JLINK_IN_BUFFER_SIZE
)
529 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
530 len
= JLINK_IN_BUFFER_SIZE
;
533 result
= jlink_usb_read(jlink_handle
, len
);
536 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
537 return ERROR_JTAG_DEVICE_ERROR
;
540 usb_in_buffer
[result
] = 0;
541 LOG_INFO("%s", (char *)usb_in_buffer
);
543 /* query hardware capabilities */
544 jlink_simple_command(EMU_CMD_GET_CAPS
);
546 result
= jlink_usb_read(jlink_handle
, 4);
549 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
550 return ERROR_JTAG_DEVICE_ERROR
;
553 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
554 LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps
);
556 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
558 /* query hardware version */
559 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
561 result
= jlink_usb_read(jlink_handle
, 4);
564 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result
);
565 return ERROR_JTAG_DEVICE_ERROR
;
568 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
569 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
570 if (major_revision
>= 5)
571 jlink_hw_jtag_version
= 3;
573 LOG_INFO("JLink hw version %i", (int)jlink_hw_version
);
576 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
578 /* query hardware maximum memory block */
579 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
581 result
= jlink_usb_read(jlink_handle
, 4);
584 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
585 return ERROR_JTAG_DEVICE_ERROR
;
588 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
589 LOG_INFO("JLink max mem block %i", (int)jlink_max_size
);
595 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
597 if (jlink_get_version_info() == ERROR_OK
)
599 /* attempt to get status */
606 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
610 command_print(CMD_CTX
, "jlink hw jtag %i", jlink_hw_jtag_version
);
613 int request_version
= atoi(CMD_ARGV
[0]);
614 switch (request_version
) {
616 jlink_hw_jtag_version
= request_version
;
619 return ERROR_COMMAND_SYNTAX_ERROR
;
624 return ERROR_COMMAND_SYNTAX_ERROR
;
630 static const struct command_registration jlink_command_handlers
[] = {
632 .name
= "jlink_info",
633 .handler
= &jlink_handle_jlink_info_command
,
634 .mode
= COMMAND_EXEC
,
635 .help
= "show jlink info",
638 .name
= "jlink_hw_jtag",
639 .handler
= &jlink_handle_jlink_hw_jtag_command
,
640 .mode
= COMMAND_EXEC
,
641 .help
= "access J-Link HW JTAG command version",
644 COMMAND_REGISTRATION_DONE
647 struct jtag_interface jlink_interface
= {
650 .commands
= jlink_command_handlers
,
652 .execute_queue
= &jlink_execute_queue
,
653 .speed
= &jlink_speed
,
654 .speed_div
= &jlink_speed_div
,
661 /***************************************************************************/
662 /* J-Link tap functions */
665 static unsigned tap_length
= 0;
666 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
667 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
668 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
670 struct pending_scan_result
{
671 int first
; /* First bit position in tdo_buffer to read */
672 int length
; /* Number of bits to read */
673 struct scan_command
*command
; /* Corresponding scan command */
677 #define MAX_PENDING_SCAN_RESULTS 256
679 static int pending_scan_results_length
;
680 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
682 static void jlink_tap_init(void)
685 pending_scan_results_length
= 0;
688 static void jlink_tap_ensure_space(int scans
, int bits
)
690 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
691 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
693 if (scans
> available_scans
|| bits
> available_bits
)
699 static void jlink_tap_append_step(int tms
, int tdi
)
701 int index
= tap_length
/ 8;
703 if (index
>= JLINK_TAP_BUFFER_SIZE
)
705 LOG_ERROR("jlink_tap_append_step: overflow");
706 *(uint32_t *)0xFFFFFFFF = 0;
710 int bit_index
= tap_length
% 8;
711 uint8_t bit
= 1 << bit_index
;
713 // we do not pad TMS, so be sure to initialize all bits
716 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
720 tms_buffer
[index
] |= bit
;
722 tms_buffer
[index
] &= ~bit
;
725 tdi_buffer
[index
] |= bit
;
727 tdi_buffer
[index
] &= ~bit
;
732 static void jlink_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
)
734 struct pending_scan_result
*pending_scan_result
=
735 &pending_scan_results_buffer
[pending_scan_results_length
];
738 pending_scan_result
->first
= tap_length
;
739 pending_scan_result
->length
= length
;
740 pending_scan_result
->command
= command
;
741 pending_scan_result
->buffer
= buffer
;
743 for (i
= 0; i
< length
; i
++)
745 int tms
= (i
< (length
- 1)) ? 0 : 1;
746 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
747 jlink_tap_append_step(tms
, tdi
);
749 pending_scan_results_length
++;
752 /* Pad and send a tap sequence to the device, and receive the answer.
753 * For the purpose of padding we assume that we are in idle or pause state. */
754 static int jlink_tap_execute(void)
763 /* JLink returns an extra NULL in packet when size of incoming
764 * message is a multiple of 64, creates problems with USB comms.
765 * WARNING: This will interfere with tap state counting. */
766 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
768 jlink_tap_append_step((tap_get_state() == TAP_RESET
)?1:0, 0);
771 // number of full bytes (plus one if some would be left over)
772 byte_length
= DIV_ROUND_UP(tap_length
, 8);
774 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
775 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
776 usb_out_buffer
[1] = 0;
777 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
778 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
779 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
780 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
782 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
783 tap_length
, jlink_last_state
);
785 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
786 if (result
!= byte_length
)
788 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
790 return ERROR_JTAG_QUEUE_FAILED
;
793 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
795 for (i
= 0; i
< pending_scan_results_length
; i
++)
797 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
798 uint8_t *buffer
= pending_scan_result
->buffer
;
799 int length
= pending_scan_result
->length
;
800 int first
= pending_scan_result
->first
;
801 struct scan_command
*command
= pending_scan_result
->command
;
804 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
806 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
808 #ifdef _DEBUG_USB_COMMS_
809 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
812 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
815 return ERROR_JTAG_QUEUE_FAILED
;
818 if (pending_scan_result
->buffer
!= NULL
)
820 free(pending_scan_result
->buffer
);
828 /*****************************************************************************/
829 /* JLink USB low-level functions */
831 static struct jlink
* jlink_usb_open()
835 const uint16_t vids
[] = { VID
, 0 };
836 const uint16_t pids
[] = { PID
, 0 };
837 struct usb_dev_handle
*dev
;
838 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
841 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
842 * AREA!!!!!!!!!!! The behavior of libusb is not completely
843 * consistent across Windows, Linux, and Mac OS X platforms.
844 * The actions taken in the following compiler conditionals may
845 * not agree with published documentation for libusb, but were
846 * found to be necessary through trials and tribulations. Even
847 * little tweaks can break one or more platforms, so if you do
848 * make changes test them carefully on all platforms before
859 /* reopen jlink after usb_reset
860 * on win32 this may take a second or two to re-enumerate */
862 while ((retval
= jtag_usb_open(vids
, pids
, &dev
)) != ERROR_OK
)
870 if (ERROR_OK
!= retval
)
876 /* usb_set_configuration required under win32 */
877 struct usb_device
*udev
= usb_device(dev
);
878 usb_set_configuration(dev
, udev
->config
[0].bConfigurationValue
);
879 usb_claim_interface(dev
, 0);
883 * This makes problems under Mac OS X. And is not needed
884 * under Windows. Hopefully this will not break a linux build
886 usb_set_altinterface(result
->usb_handle
, 0);
888 struct usb_interface
*iface
= udev
->config
->interface
;
889 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
890 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
892 uint8_t epnum
= desc
->endpoint
[i
].bEndpointAddress
;
893 bool is_input
= epnum
& 0x80;
894 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
896 jlink_read_ep
= epnum
;
898 jlink_write_ep
= epnum
;
901 struct jlink
*result
= malloc(sizeof(struct jlink
));
902 result
->usb_handle
= dev
;
906 static void jlink_usb_close(struct jlink
*jlink
)
908 usb_close(jlink
->usb_handle
);
912 /* Send a message and receive the reply. */
913 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
917 result
= jlink_usb_write(jlink
, out_length
);
918 if (result
!= out_length
)
920 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
922 return ERROR_JTAG_DEVICE_ERROR
;
925 result
= jlink_usb_read(jlink
, in_length
);
926 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
928 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
930 return ERROR_JTAG_DEVICE_ERROR
;
933 if (jlink_hw_jtag_version
< 3)
936 int result2
= ERROR_OK
;
937 if (result
== in_length
)
939 /* Must read the result from the EMU too */
940 result2
= jlink_usb_read_emu_result(jlink
);
943 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, result=%d, in_length=%i", result2
,in_length
);
944 /* Try again once, should only happen if (in_length%64 == 0) */
945 result2
= jlink_usb_read_emu_result(jlink
);
948 LOG_ERROR("jlink_usb_read_emu_result failed "
949 "(requested = 1, result=%d)", result2
);
950 return ERROR_JTAG_DEVICE_ERROR
;
954 /* Check the result itself */
955 result2
= usb_emu_result_buffer
[0];
959 /* Save the result, then remove it from return value */
960 result2
= usb_in_buffer
[result
--];
965 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
966 return ERROR_JTAG_DEVICE_ERROR
;
972 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
973 static int usb_bulk_with_retries(
974 int (*f
)(usb_dev_handle
*, int, char *, int, int),
975 usb_dev_handle
*dev
, int ep
,
976 char *bytes
, int size
, int timeout
)
978 int tries
= 3, count
= 0;
980 while (tries
&& (count
< size
))
982 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
985 else if ((-ETIMEDOUT
!= result
) || !--tries
)
991 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
992 char *buff
, int size
, int timeout
)
994 /* usb_bulk_write() takes const char *buff */
995 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
998 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
999 char *bytes
, int size
, int timeout
)
1001 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1002 dev
, ep
, bytes
, size
, timeout
);
1005 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1006 char *bytes
, int size
, int timeout
)
1008 return usb_bulk_with_retries(&usb_bulk_read
,
1009 dev
, ep
, bytes
, size
, timeout
);
1012 /* Write data from out_buffer to USB. */
1013 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1017 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1019 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
1023 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1024 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1026 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
1028 #ifdef _DEBUG_USB_COMMS_
1029 jlink_debug_buffer(usb_out_buffer
, out_length
);
1034 /* Read data from USB into in_buffer. */
1035 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1037 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1038 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1040 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1042 #ifdef _DEBUG_USB_COMMS_
1043 jlink_debug_buffer(usb_in_buffer
, result
);
1048 /* Read the result from the previous EMU cmd into result_buffer. */
1049 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1051 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1052 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1055 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1057 #ifdef _DEBUG_USB_COMMS_
1058 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1063 #ifdef _DEBUG_USB_COMMS_
1064 #define BYTES_PER_LINE 16
1066 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1073 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1075 snprintf(line
, 5, "%04x", i
);
1076 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1078 snprintf(s
, 4, " %02x", buffer
[j
]);
1081 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)