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");
325 int retval
= jtag_get_speed(&jtag_speed_var
);
326 if (retval
!= ERROR_OK
)
328 jlink_speed(jtag_speed_var
);
330 /* v5/6 jlink seems to have an issue if the first tap move
331 * is not divisible by 8, so we send a TLR on first power up */
332 for (i
= 0; i
< 8; i
++) {
333 jlink_tap_append_step(1, 0);
340 static int jlink_quit(void)
342 jlink_usb_close(jlink_handle
);
346 /***************************************************************************/
347 /* Queue command implementations */
349 static void jlink_end_state(tap_state_t state
)
351 if (tap_is_state_stable(state
))
353 tap_set_end_state(state
);
357 LOG_ERROR("BUG: %i is not a valid end state", state
);
362 /* Goes to the end state. */
363 static void jlink_state_move(void)
367 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
368 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
370 for (i
= 0; i
< tms_scan_bits
; i
++)
372 tms
= (tms_scan
>> i
) & 1;
373 jlink_tap_append_step(tms
, 0);
376 tap_set_state(tap_get_end_state());
379 static void jlink_path_move(int num_states
, tap_state_t
*path
)
383 for (i
= 0; i
< num_states
; i
++)
385 if (path
[i
] == tap_state_transition(tap_get_state(), false))
387 jlink_tap_append_step(0, 0);
389 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
391 jlink_tap_append_step(1, 0);
395 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
396 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
400 tap_set_state(path
[i
]);
403 tap_set_end_state(tap_get_state());
406 static void jlink_runtest(int num_cycles
)
410 tap_state_t saved_end_state
= tap_get_end_state();
412 jlink_tap_ensure_space(1,num_cycles
+ 16);
414 /* only do a state_move when we're not already in IDLE */
415 if (tap_get_state() != TAP_IDLE
)
417 jlink_end_state(TAP_IDLE
);
422 /* execute num_cycles */
423 for (i
= 0; i
< num_cycles
; i
++)
425 jlink_tap_append_step(0, 0);
428 /* finish in end_state */
429 jlink_end_state(saved_end_state
);
430 if (tap_get_state() != tap_get_end_state())
436 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
437 int scan_size
, struct scan_command
*command
)
439 tap_state_t saved_end_state
;
441 jlink_tap_ensure_space(1, scan_size
+ 16);
443 saved_end_state
= tap_get_end_state();
445 /* Move to appropriate scan state */
446 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
448 /* Only move if we're not already there */
449 if (tap_get_state() != tap_get_end_state())
452 jlink_end_state(saved_end_state
);
455 jlink_tap_append_scan(scan_size
, buffer
, command
);
457 /* We are in Exit1, go to Pause */
458 jlink_tap_append_step(0, 0);
460 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
462 if (tap_get_state() != tap_get_end_state())
468 static void jlink_reset(int trst
, int srst
)
470 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
472 /* Signals are active low */
475 jlink_simple_command(EMU_CMD_HW_RESET1
);
479 jlink_simple_command(EMU_CMD_HW_RESET0
);
484 jlink_simple_command(EMU_CMD_HW_TRST0
);
489 jlink_simple_command(EMU_CMD_HW_TRST1
);
493 static void jlink_simple_command(uint8_t command
)
497 DEBUG_JTAG_IO("0x%02x", command
);
499 usb_out_buffer
[0] = command
;
500 result
= jlink_usb_write(jlink_handle
, 1);
504 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
508 static int jlink_get_status(void)
512 jlink_simple_command(EMU_CMD_GET_STATE
);
514 result
= jlink_usb_read(jlink_handle
, 8);
517 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
518 return ERROR_JTAG_DEVICE_ERROR
;
521 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
522 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \
523 vref
/ 1000, vref
% 1000, \
524 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
525 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
528 LOG_ERROR("Vref too low. Check Target Power");
533 static int jlink_get_version_info(void)
537 uint32_t jlink_caps
, jlink_max_size
;
539 /* query hardware version */
540 jlink_simple_command(EMU_CMD_VERSION
);
542 result
= jlink_usb_read(jlink_handle
, 2);
545 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
546 return ERROR_JTAG_DEVICE_ERROR
;
549 len
= buf_get_u32(usb_in_buffer
, 0, 16);
550 if (len
> JLINK_IN_BUFFER_SIZE
)
552 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
553 len
= JLINK_IN_BUFFER_SIZE
;
556 result
= jlink_usb_read(jlink_handle
, len
);
559 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
560 return ERROR_JTAG_DEVICE_ERROR
;
563 usb_in_buffer
[result
] = 0;
564 LOG_INFO("%s", (char *)usb_in_buffer
);
566 /* query hardware capabilities */
567 jlink_simple_command(EMU_CMD_GET_CAPS
);
569 result
= jlink_usb_read(jlink_handle
, 4);
572 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", result
);
573 return ERROR_JTAG_DEVICE_ERROR
;
576 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
577 LOG_INFO("JLink caps 0x%x", (unsigned)jlink_caps
);
579 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
581 /* query hardware version */
582 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
584 result
= jlink_usb_read(jlink_handle
, 4);
587 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result
);
588 return ERROR_JTAG_DEVICE_ERROR
;
591 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
592 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
593 if (major_revision
>= 5)
594 jlink_hw_jtag_version
= 3;
596 LOG_INFO("JLink hw version %i", (int)jlink_hw_version
);
599 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
601 /* query hardware maximum memory block */
602 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
604 result
= jlink_usb_read(jlink_handle
, 4);
607 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", result
);
608 return ERROR_JTAG_DEVICE_ERROR
;
611 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
612 LOG_INFO("JLink max mem block %i", (int)jlink_max_size
);
618 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
620 if (jlink_get_version_info() == ERROR_OK
)
622 /* attempt to get status */
629 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
633 command_print(CMD_CTX
, "jlink hw jtag %i", jlink_hw_jtag_version
);
636 int request_version
= atoi(CMD_ARGV
[0]);
637 switch (request_version
) {
639 jlink_hw_jtag_version
= request_version
;
642 return ERROR_COMMAND_SYNTAX_ERROR
;
647 return ERROR_COMMAND_SYNTAX_ERROR
;
653 static const struct command_registration jlink_command_handlers
[] = {
655 .name
= "jlink_info",
656 .handler
= &jlink_handle_jlink_info_command
,
657 .mode
= COMMAND_EXEC
,
658 .help
= "show jlink info",
661 .name
= "jlink_hw_jtag",
662 .handler
= &jlink_handle_jlink_hw_jtag_command
,
663 .mode
= COMMAND_EXEC
,
664 .help
= "access J-Link HW JTAG command version",
667 COMMAND_REGISTRATION_DONE
670 struct jtag_interface jlink_interface
= {
672 .commands
= jlink_command_handlers
,
674 .execute_queue
= jlink_execute_queue
,
675 .speed
= jlink_speed
,
676 .speed_div
= jlink_speed_div
,
682 /***************************************************************************/
683 /* J-Link tap functions */
686 static unsigned tap_length
= 0;
687 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
688 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
689 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
691 struct pending_scan_result
{
692 int first
; /* First bit position in tdo_buffer to read */
693 int length
; /* Number of bits to read */
694 struct scan_command
*command
; /* Corresponding scan command */
698 #define MAX_PENDING_SCAN_RESULTS 256
700 static int pending_scan_results_length
;
701 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
703 static void jlink_tap_init(void)
706 pending_scan_results_length
= 0;
709 static void jlink_tap_ensure_space(int scans
, int bits
)
711 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
712 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
714 if (scans
> available_scans
|| bits
> available_bits
)
720 static void jlink_tap_append_step(int tms
, int tdi
)
722 int index_var
= tap_length
/ 8;
724 if (index_var
>= JLINK_TAP_BUFFER_SIZE
)
726 LOG_ERROR("jlink_tap_append_step: overflow");
727 *(uint32_t *)0xFFFFFFFF = 0;
731 int bit_index
= tap_length
% 8;
732 uint8_t bit
= 1 << bit_index
;
734 // we do not pad TMS, so be sure to initialize all bits
737 tms_buffer
[index_var
] = tdi_buffer
[index_var
] = 0;
741 tms_buffer
[index_var
] |= bit
;
743 tms_buffer
[index_var
] &= ~bit
;
746 tdi_buffer
[index_var
] |= bit
;
748 tdi_buffer
[index_var
] &= ~bit
;
753 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
754 struct scan_command
*command
)
756 struct pending_scan_result
*pending_scan_result
=
757 &pending_scan_results_buffer
[pending_scan_results_length
];
760 pending_scan_result
->first
= tap_length
;
761 pending_scan_result
->length
= length
;
762 pending_scan_result
->command
= command
;
763 pending_scan_result
->buffer
= buffer
;
765 for (i
= 0; i
< length
; i
++)
767 int tms
= (i
< (length
- 1)) ? 0 : 1;
768 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
769 jlink_tap_append_step(tms
, tdi
);
771 pending_scan_results_length
++;
774 /* Pad and send a tap sequence to the device, and receive the answer.
775 * For the purpose of padding we assume that we are in idle or pause state. */
776 static int jlink_tap_execute(void)
785 /* JLink returns an extra NULL in packet when size of incoming
786 * message is a multiple of 64, creates problems with USB comms.
787 * WARNING: This will interfere with tap state counting. */
788 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
790 jlink_tap_append_step((tap_get_state() == TAP_RESET
) ? 1 : 0, 0);
793 // number of full bytes (plus one if some would be left over)
794 byte_length
= DIV_ROUND_UP(tap_length
, 8);
796 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
797 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
798 usb_out_buffer
[1] = 0;
799 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
800 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
801 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
802 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
804 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
805 tap_length
, jlink_last_state
);
807 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
808 if (result
!= byte_length
)
810 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
811 result
, byte_length
);
813 return ERROR_JTAG_QUEUE_FAILED
;
816 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
818 for (i
= 0; i
< pending_scan_results_length
; i
++)
820 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
821 uint8_t *buffer
= pending_scan_result
->buffer
;
822 int length
= pending_scan_result
->length
;
823 int first
= pending_scan_result
->first
;
824 struct scan_command
*command
= pending_scan_result
->command
;
827 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
829 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
831 #ifdef _DEBUG_USB_COMMS_
832 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
835 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
838 return ERROR_JTAG_QUEUE_FAILED
;
841 if (pending_scan_result
->buffer
!= NULL
)
843 free(pending_scan_result
->buffer
);
851 /*****************************************************************************/
852 /* JLink USB low-level functions */
854 static struct jlink
* jlink_usb_open()
858 const uint16_t vids
[] = { VID
, 0 };
859 const uint16_t pids
[] = { PID
, 0 };
860 struct usb_dev_handle
*dev
;
861 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
864 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
865 * AREA!!!!!!!!!!! The behavior of libusb is not completely
866 * consistent across Windows, Linux, and Mac OS X platforms.
867 * The actions taken in the following compiler conditionals may
868 * not agree with published documentation for libusb, but were
869 * found to be necessary through trials and tribulations. Even
870 * little tweaks can break one or more platforms, so if you do
871 * make changes test them carefully on all platforms before
882 /* reopen jlink after usb_reset
883 * on win32 this may take a second or two to re-enumerate */
885 while ((retval
= jtag_usb_open(vids
, pids
, &dev
)) != ERROR_OK
)
893 if (ERROR_OK
!= retval
)
899 /* usb_set_configuration required under win32 */
900 struct usb_device
*udev
= usb_device(dev
);
901 usb_set_configuration(dev
, udev
->config
[0].bConfigurationValue
);
902 usb_claim_interface(dev
, 0);
906 * This makes problems under Mac OS X. And is not needed
907 * under Windows. Hopefully this will not break a linux build
909 usb_set_altinterface(result
->usb_handle
, 0);
911 struct usb_interface
*iface
= udev
->config
->interface
;
912 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
913 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
915 uint8_t epnum
= desc
->endpoint
[i
].bEndpointAddress
;
916 bool is_input
= epnum
& 0x80;
917 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
919 jlink_read_ep
= epnum
;
921 jlink_write_ep
= epnum
;
924 struct jlink
*result
= malloc(sizeof(struct jlink
));
925 result
->usb_handle
= dev
;
929 static void jlink_usb_close(struct jlink
*jlink
)
931 usb_close(jlink
->usb_handle
);
935 /* Send a message and receive the reply. */
936 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
940 result
= jlink_usb_write(jlink
, out_length
);
941 if (result
!= out_length
)
943 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
945 return ERROR_JTAG_DEVICE_ERROR
;
948 result
= jlink_usb_read(jlink
, in_length
);
949 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
951 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
953 return ERROR_JTAG_DEVICE_ERROR
;
956 if (jlink_hw_jtag_version
< 3)
959 int result2
= ERROR_OK
;
960 if (result
== in_length
)
962 /* Must read the result from the EMU too */
963 result2
= jlink_usb_read_emu_result(jlink
);
966 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, "
967 "result=%d, in_length=%i", result2
, in_length
);
968 /* Try again once, should only happen if (in_length%64 == 0) */
969 result2
= jlink_usb_read_emu_result(jlink
);
972 LOG_ERROR("jlink_usb_read_emu_result failed "
973 "(requested = 1, result=%d)", result2
);
974 return ERROR_JTAG_DEVICE_ERROR
;
978 /* Check the result itself */
979 result2
= usb_emu_result_buffer
[0];
983 /* Save the result, then remove it from return value */
984 result2
= usb_in_buffer
[result
--];
989 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
990 return ERROR_JTAG_DEVICE_ERROR
;
996 /* calls the given usb_bulk_* function, allowing for the data to
997 * trickle in with some timeouts */
998 static int usb_bulk_with_retries(
999 int (*f
)(usb_dev_handle
*, int, char *, int, int),
1000 usb_dev_handle
*dev
, int ep
,
1001 char *bytes
, int size
, int timeout
)
1003 int tries
= 3, count
= 0;
1005 while (tries
&& (count
< size
))
1007 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1010 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1016 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
1017 char *buff
, int size
, int timeout
)
1019 /* usb_bulk_write() takes const char *buff */
1020 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1023 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
1024 char *bytes
, int size
, int timeout
)
1026 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1027 dev
, ep
, bytes
, size
, timeout
);
1030 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1031 char *bytes
, int size
, int timeout
)
1033 return usb_bulk_with_retries(&usb_bulk_read
,
1034 dev
, ep
, bytes
, size
, timeout
);
1037 /* Write data from out_buffer to USB. */
1038 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1042 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1044 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)",
1045 out_length
, JLINK_OUT_BUFFER_SIZE
);
1049 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1050 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1052 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d",
1053 out_length
, result
);
1055 #ifdef _DEBUG_USB_COMMS_
1056 jlink_debug_buffer(usb_out_buffer
, out_length
);
1061 /* Read data from USB into in_buffer. */
1062 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1064 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1065 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1067 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1069 #ifdef _DEBUG_USB_COMMS_
1070 jlink_debug_buffer(usb_in_buffer
, result
);
1075 /* Read the result from the previous EMU cmd into result_buffer. */
1076 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1078 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1079 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1082 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1084 #ifdef _DEBUG_USB_COMMS_
1085 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1090 #ifdef _DEBUG_USB_COMMS_
1091 #define BYTES_PER_LINE 16
1093 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1100 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1102 snprintf(line
, 5, "%04x", i
);
1103 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1105 snprintf(s
, 4, " %02x", buffer
[j
]);
1108 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)