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 #define INCLUDE_JTAG_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 u8 usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
58 static u8 usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
59 static u8 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 /* External interface functions */
86 static int jlink_execute_queue(void);
87 static int jlink_speed(int speed
);
88 static int jlink_speed_div(int speed
, int* khz
);
89 static int jlink_khz(int khz
, int *jtag_speed
);
90 static int jlink_register_commands(struct command_context_s
*cmd_ctx
);
91 static int jlink_init(void);
92 static int jlink_quit(void);
94 /* CLI command handler functions */
95 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
96 static int jlink_handle_jlink_hw_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
98 /* Queue command functions */
99 static void jlink_end_state(tap_state_t state
);
100 static void jlink_state_move(void);
101 static void jlink_path_move(int num_states
, tap_state_t
*path
);
102 static void jlink_runtest(int num_cycles
);
103 static void jlink_scan(bool ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
);
104 static void jlink_reset(int trst
, int srst
);
105 static void jlink_simple_command(u8 command
);
106 static int jlink_get_status(void);
108 /* J-Link tap buffer functions */
109 static void jlink_tap_init(void);
110 static int jlink_tap_execute(void);
111 static void jlink_tap_ensure_space(int scans
, int bits
);
112 static void jlink_tap_append_step(int tms
, int tdi
);
113 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
);
115 /* Jlink lowlevel functions */
116 typedef struct jlink_jtag
118 struct usb_dev_handle
* usb_handle
;
121 static jlink_jtag_t
*jlink_usb_open(void);
122 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
);
123 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
);
124 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
);
125 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
);
126 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
);
128 /* helper functions */
129 static int jlink_get_version_info(void);
131 #ifdef _DEBUG_USB_COMMS_
132 static void jlink_debug_buffer(u8
*buffer
, int length
);
135 static enum tap_state jlink_last_state
= TAP_RESET
;
137 static jlink_jtag_t
* jlink_jtag_handle
;
139 /***************************************************************************/
140 /* External interface implementation */
142 jtag_interface_t jlink_interface
=
145 .execute_queue
= jlink_execute_queue
,
146 .speed
= jlink_speed
,
147 .speed_div
= jlink_speed_div
,
149 .register_commands
= jlink_register_commands
,
154 static void jlink_execute_runtest(jtag_command_t
*cmd
)
156 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
157 cmd
->cmd
.runtest
->num_cycles
,
158 cmd
->cmd
.runtest
->end_state
);
160 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
161 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
163 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
166 static void jlink_execute_statemove(jtag_command_t
*cmd
)
168 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
170 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
172 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
177 static void jlink_execute_pathmove(jtag_command_t
*cmd
)
179 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
180 cmd
->cmd
.pathmove
->num_states
,
181 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
183 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
184 cmd
->cmd
.pathmove
->path
);
187 static void jlink_execute_scan(jtag_command_t
*cmd
)
193 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
195 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
196 jlink_end_state(cmd
->cmd
.scan
->end_state
);
198 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
199 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
201 #ifdef _DEBUG_USB_COMMS_
202 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
204 type
= jtag_scan_type(cmd
->cmd
.scan
);
205 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
206 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
209 static void jlink_execute_reset(jtag_command_t
*cmd
)
211 DEBUG_JTAG_IO("reset trst: %i srst %i",
212 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
215 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
219 static void jlink_execute_sleep(jtag_command_t
*cmd
)
221 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
223 jtag_sleep(cmd
->cmd
.sleep
->us
);
226 static void jlink_execute_command(jtag_command_t
*cmd
)
230 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
231 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
232 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
233 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
234 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
235 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
237 LOG_ERROR("BUG: unknown JTAG command type encountered");
242 static int jlink_execute_queue(void)
244 jtag_command_t
*cmd
= jtag_command_queue
;
248 jlink_execute_command(cmd
);
252 return jlink_tap_execute();
255 /* Sets speed in kHz. */
256 static int jlink_speed(int speed
)
260 if (speed
> JLINK_MAX_SPEED
)
262 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
263 speed
, JLINK_MAX_SPEED
);
267 /* check for RTCK setting */
271 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
272 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
273 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
275 result
= jlink_usb_write(jlink_jtag_handle
, 3);
278 LOG_ERROR("J-Link setting speed failed (%d)", result
);
279 return ERROR_JTAG_DEVICE_ERROR
;
285 static int jlink_speed_div(int speed
, int* khz
)
292 static int jlink_khz(int khz
, int *jtag_speed
)
299 static int jlink_register_commands(struct command_context_s
*cmd_ctx
)
302 register_command(cmd_ctx
, NULL
, "jlink_info",
303 &jlink_handle_jlink_info_command
, COMMAND_EXEC
,
305 register_command(cmd_ctx
, NULL
, "jlink_hw_jtag",
306 &jlink_handle_jlink_hw_jtag_command
, COMMAND_EXEC
,
307 "set/get jlink hw jtag command version [2|3]");
311 static int jlink_init(void)
315 jlink_jtag_handle
= jlink_usb_open();
317 if (jlink_jtag_handle
== 0)
319 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
320 return ERROR_JTAG_INIT_FAILED
;
323 jlink_hw_jtag_version
= 2;
325 while (check_cnt
< 3)
327 if (jlink_get_version_info() == ERROR_OK
)
329 /* attempt to get status */
339 LOG_INFO("J-Link initial read failed, don't worry");
342 LOG_INFO("J-Link JTAG Interface ready");
347 jlink_speed(jtag_speed
);
352 static int jlink_quit(void)
354 jlink_usb_close(jlink_jtag_handle
);
358 /***************************************************************************/
359 /* Queue command implementations */
361 static void jlink_end_state(tap_state_t state
)
363 if (tap_is_state_stable(state
))
365 tap_set_end_state(state
);
369 LOG_ERROR("BUG: %i is not a valid end state", state
);
374 /* Goes to the end state. */
375 static void jlink_state_move(void)
379 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
380 u8 tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
382 for (i
= 0; i
< tms_scan_bits
; i
++)
384 tms
= (tms_scan
>> i
) & 1;
385 jlink_tap_append_step(tms
, 0);
388 tap_set_state(tap_get_end_state());
391 static void jlink_path_move(int num_states
, tap_state_t
*path
)
395 for (i
= 0; i
< num_states
; i
++)
397 if (path
[i
] == tap_state_transition(tap_get_state(), false))
399 jlink_tap_append_step(0, 0);
401 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
403 jlink_tap_append_step(1, 0);
407 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
411 tap_set_state(path
[i
]);
414 tap_set_end_state(tap_get_state());
417 static void jlink_runtest(int num_cycles
)
421 tap_state_t saved_end_state
= tap_get_end_state();
423 jlink_tap_ensure_space(1,num_cycles
+ 16);
425 /* only do a state_move when we're not already in IDLE */
426 if (tap_get_state() != TAP_IDLE
)
428 jlink_end_state(TAP_IDLE
);
433 /* execute num_cycles */
434 for (i
= 0; i
< num_cycles
; i
++)
436 jlink_tap_append_step(0, 0);
439 /* finish in end_state */
440 jlink_end_state(saved_end_state
);
441 if (tap_get_state() != tap_get_end_state())
447 static void jlink_scan(bool ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
)
449 tap_state_t saved_end_state
;
451 jlink_tap_ensure_space(1, scan_size
+ 16);
453 saved_end_state
= tap_get_end_state();
455 /* Move to appropriate scan state */
456 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
458 /* Only move if we're not already there */
459 if (tap_get_state() != tap_get_end_state())
462 jlink_end_state(saved_end_state
);
465 jlink_tap_append_scan(scan_size
, buffer
, command
);
467 /* We are in Exit1, go to Pause */
468 jlink_tap_append_step(0, 0);
470 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
472 if (tap_get_state() != tap_get_end_state())
478 static void jlink_reset(int trst
, int srst
)
480 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
482 /* Signals are active low */
485 jlink_simple_command(EMU_CMD_HW_RESET1
);
489 jlink_simple_command(EMU_CMD_HW_RESET0
);
494 jlink_simple_command(EMU_CMD_HW_TRST0
);
498 jlink_simple_command(EMU_CMD_HW_TRST1
);
500 jlink_end_state(TAP_RESET
);
505 static void jlink_simple_command(u8 command
)
509 DEBUG_JTAG_IO("0x%02x", command
);
511 usb_out_buffer
[0] = command
;
512 result
= jlink_usb_write(jlink_jtag_handle
, 1);
516 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
520 static int jlink_get_status(void)
524 jlink_simple_command(EMU_CMD_GET_STATE
);
526 result
= jlink_usb_read(jlink_jtag_handle
, 8);
529 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
530 return ERROR_JTAG_DEVICE_ERROR
;
533 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
534 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
535 vref
/ 1000, vref
% 1000, \
536 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
537 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
540 LOG_ERROR("Vref too low. Check Target Power\n");
545 static int jlink_get_version_info(void)
549 u32 jlink_caps
, jlink_max_size
;
551 /* query hardware version */
552 jlink_simple_command(EMU_CMD_VERSION
);
554 result
= jlink_usb_read(jlink_jtag_handle
, 2);
557 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
558 return ERROR_JTAG_DEVICE_ERROR
;
561 len
= buf_get_u32(usb_in_buffer
, 0, 16);
562 if (len
> JLINK_IN_BUFFER_SIZE
)
564 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
565 len
= JLINK_IN_BUFFER_SIZE
;
568 result
= jlink_usb_read(jlink_jtag_handle
, len
);
571 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
572 return ERROR_JTAG_DEVICE_ERROR
;
575 usb_in_buffer
[result
] = 0;
576 LOG_INFO("%s", (char *)usb_in_buffer
);
578 /* query hardware capabilities */
579 jlink_simple_command(EMU_CMD_GET_CAPS
);
581 result
= jlink_usb_read(jlink_jtag_handle
, 4);
584 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
585 return ERROR_JTAG_DEVICE_ERROR
;
588 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
589 LOG_INFO("JLink caps 0x%x", jlink_caps
);
591 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
593 /* query hardware version */
594 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
596 result
= jlink_usb_read(jlink_jtag_handle
, 4);
599 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result
);
600 return ERROR_JTAG_DEVICE_ERROR
;
603 u32 jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
604 u32 major_revision
= (jlink_hw_version
/ 10000) % 100;
605 if (major_revision
>= 5)
606 jlink_hw_jtag_version
= 3;
608 LOG_INFO("JLink hw version %i", jlink_hw_version
);
611 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
613 /* query hardware maximum memory block */
614 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
616 result
= jlink_usb_read(jlink_jtag_handle
, 4);
619 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
620 return ERROR_JTAG_DEVICE_ERROR
;
623 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
624 LOG_INFO("JLink max mem block %i", jlink_max_size
);
630 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
632 if (jlink_get_version_info() == ERROR_OK
)
634 /* attempt to get status */
641 static int jlink_handle_jlink_hw_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
645 command_print(cmd_ctx
, "jlink hw jtag %i", jlink_hw_jtag_version
);
648 int request_version
= atoi(args
[0]);
649 switch (request_version
) {
651 jlink_hw_jtag_version
= request_version
;
654 return ERROR_COMMAND_SYNTAX_ERROR
;
659 return ERROR_COMMAND_SYNTAX_ERROR
;
665 /***************************************************************************/
666 /* J-Link tap functions */
669 static unsigned tap_length
=0;
670 static u8 tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
671 static u8 tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
672 static u8 tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
676 int first
; /* First bit position in tdo_buffer to read */
677 int length
; /* Number of bits to read */
678 scan_command_t
*command
; /* Corresponding scan command */
680 } pending_scan_result_t
;
682 #define MAX_PENDING_SCAN_RESULTS 256
684 static int pending_scan_results_length
;
685 static pending_scan_result_t pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
687 static void jlink_tap_init(void)
690 pending_scan_results_length
= 0;
693 static void jlink_tap_ensure_space(int scans
, int bits
)
695 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
696 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
698 if (scans
> available_scans
|| bits
> available_bits
)
704 static void jlink_tap_append_step(int tms
, int tdi
)
706 int index
= tap_length
/ 8;
708 if (index
>= JLINK_TAP_BUFFER_SIZE
)
710 LOG_ERROR("jlink_tap_append_step: overflow");
711 *(u32
*)0xFFFFFFFF = 0;
715 int bit_index
= tap_length
% 8;
716 u8 bit
= 1 << bit_index
;
718 // we do not pad TMS, so be sure to initialize all bits
721 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
725 tms_buffer
[index
] |= bit
;
727 tms_buffer
[index
] &= ~bit
;
730 tdi_buffer
[index
] |= bit
;
732 tdi_buffer
[index
] &= ~bit
;
737 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
)
739 pending_scan_result_t
*pending_scan_result
=
740 &pending_scan_results_buffer
[pending_scan_results_length
];
743 pending_scan_result
->first
= tap_length
;
744 pending_scan_result
->length
= length
;
745 pending_scan_result
->command
= command
;
746 pending_scan_result
->buffer
= buffer
;
748 for (i
= 0; i
< length
; i
++)
750 int tms
= (i
< (length
- 1)) ? 0 : 1;
751 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8)))!=0;
752 jlink_tap_append_step(tms
, tdi
);
754 pending_scan_results_length
++;
757 /* Pad and send a tap sequence to the device, and receive the answer.
758 * For the purpose of padding we assume that we are in idle or pause state. */
759 static int jlink_tap_execute(void)
768 /* JLink returns an extra NULL in packet when size of in message is a multiple of 64, creates problems with usb comms */
769 /* WARNING This will interfere with tap state counting */
770 while ((TAP_SCAN_BYTES(tap_length
)%64)==0)
772 jlink_tap_append_step((tap_get_state() == TAP_RESET
)?1:0, 0);
775 // number of full bytes (plus one if some would be left over)
776 byte_length
= TAP_SCAN_BYTES(tap_length
);
778 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
779 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
780 usb_out_buffer
[1] = 0;
781 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
782 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
783 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
784 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
786 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
787 tap_length
, jlink_last_state
);
789 result
= jlink_usb_message(jlink_jtag_handle
, 4 + 2 * byte_length
, byte_length
);
790 if (result
!= byte_length
)
792 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
794 return ERROR_JTAG_QUEUE_FAILED
;
797 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
799 for (i
= 0; i
< pending_scan_results_length
; i
++)
801 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[i
];
802 u8
*buffer
= pending_scan_result
->buffer
;
803 int length
= pending_scan_result
->length
;
804 int first
= pending_scan_result
->first
;
805 scan_command_t
*command
= pending_scan_result
->command
;
808 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
810 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
812 #ifdef _DEBUG_USB_COMMS_
813 jlink_debug_buffer(buffer
, TAP_SCAN_BYTES(length
));
816 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
819 return ERROR_JTAG_QUEUE_FAILED
;
822 if (pending_scan_result
->buffer
!= NULL
)
824 free(pending_scan_result
->buffer
);
832 /*****************************************************************************/
833 /* JLink USB low-level functions */
835 static jlink_jtag_t
* jlink_usb_open()
837 struct usb_bus
*busses
;
839 struct usb_device
*dev
;
841 jlink_jtag_t
*result
;
843 result
= (jlink_jtag_t
*) malloc(sizeof(jlink_jtag_t
));
849 busses
= usb_get_busses();
851 /* find jlink_jtag device in usb bus */
853 for (bus
= busses
; bus
; bus
= bus
->next
)
855 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
857 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
))
859 result
->usb_handle
= usb_open(dev
);
861 /* usb_set_configuration required under win32 */
862 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
863 usb_claim_interface(result
->usb_handle
, 0);
867 * This makes problems under Mac OS X. And is not needed
868 * under Windows. Hopefully this will not break a linux build
870 usb_set_altinterface(result
->usb_handle
, 0);
872 struct usb_interface
*iface
= dev
->config
->interface
;
873 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
874 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
876 u8 epnum
= desc
->endpoint
[i
].bEndpointAddress
;
877 bool is_input
= epnum
& 0x80;
878 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
880 jlink_read_ep
= epnum
;
882 jlink_write_ep
= epnum
;
894 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
)
896 usb_close(jlink_jtag
->usb_handle
);
900 /* Send a message and receive the reply. */
901 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
)
905 result
= jlink_usb_write(jlink_jtag
, out_length
);
906 if (result
!= out_length
)
908 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
910 return ERROR_JTAG_DEVICE_ERROR
;
913 result
= jlink_usb_read(jlink_jtag
, in_length
);
914 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
916 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
918 return ERROR_JTAG_DEVICE_ERROR
;
921 if (jlink_hw_jtag_version
< 3)
924 int result2
= ERROR_OK
;
925 if (result
== in_length
)
927 /* Must read the result from the EMU too */
928 result2
= jlink_usb_read_emu_result(jlink_jtag
);
931 LOG_ERROR("jlink_usb_read_emu_result retried requested=1, result=%d, in_length=%i", result2
,in_length
);
932 /* Try again once, should only happen if (in_length%64==0) */
933 result2
= jlink_usb_read_emu_result(jlink_jtag
);
936 LOG_ERROR("jlink_usb_read_emu_result failed "
937 "(requested=1, result=%d)", result2
);
938 return ERROR_JTAG_DEVICE_ERROR
;
942 /* Check the result itself */
943 result2
= usb_emu_result_buffer
[0];
947 /* Save the result, then remove it from return value */
948 result2
= usb_in_buffer
[result
--];
953 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
954 return ERROR_JTAG_DEVICE_ERROR
;
960 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
961 static int usb_bulk_with_retries(
962 int (*f
)(usb_dev_handle
*, int, char *, int, int),
963 usb_dev_handle
*dev
, int ep
,
964 char *bytes
, int size
, int timeout
)
966 int tries
= 3, count
= 0;
968 while (tries
&& (count
< size
))
970 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
973 else if ((-ETIMEDOUT
!= result
) || !--tries
)
979 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
980 char *buff
, int size
, int timeout
)
982 /* usb_bulk_write() takes const char *buff */
983 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
986 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
987 char *bytes
, int size
, int timeout
)
989 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
990 dev
, ep
, bytes
, size
, timeout
);
993 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
994 char *bytes
, int size
, int timeout
)
996 return usb_bulk_with_retries(&usb_bulk_read
,
997 dev
, ep
, bytes
, size
, timeout
);
1000 /* Write data from out_buffer to USB. */
1001 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
)
1005 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1007 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
1011 result
= usb_bulk_write_ex(jlink_jtag
->usb_handle
, jlink_write_ep
,
1012 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1014 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
1016 #ifdef _DEBUG_USB_COMMS_
1017 jlink_debug_buffer(usb_out_buffer
, out_length
);
1022 /* Read data from USB into in_buffer. */
1023 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
)
1025 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, jlink_read_ep
,
1026 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1028 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1030 #ifdef _DEBUG_USB_COMMS_
1031 jlink_debug_buffer(usb_in_buffer
, result
);
1036 /* Read the result from the previous EMU cmd into result_buffer. */
1037 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
)
1039 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, jlink_read_ep
,
1040 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1043 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1045 #ifdef _DEBUG_USB_COMMS_
1046 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1051 #ifdef _DEBUG_USB_COMMS_
1052 #define BYTES_PER_LINE 16
1054 static void jlink_debug_buffer(u8
*buffer
, int length
)
1061 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1063 snprintf(line
, 5, "%04x", i
);
1064 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1066 snprintf(s
, 4, " %02x", buffer
[j
]);
1069 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)