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 ***************************************************************************/
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 u8 usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
57 static u8 usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
58 static u8 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 /* External interface functions */
85 static int jlink_execute_queue(void);
86 static int jlink_speed(int speed
);
87 static int jlink_speed_div(int speed
, int* khz
);
88 static int jlink_khz(int khz
, int *jtag_speed
);
89 static int jlink_register_commands(struct command_context_s
*cmd_ctx
);
90 static int jlink_init(void);
91 static int jlink_quit(void);
93 /* CLI command handler functions */
94 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
95 static int jlink_handle_jlink_hw_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
97 /* Queue command functions */
98 static void jlink_end_state(tap_state_t state
);
99 static void jlink_state_move(void);
100 static void jlink_path_move(int num_states
, tap_state_t
*path
);
101 static void jlink_runtest(int num_cycles
);
102 static void jlink_scan(bool ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
);
103 static void jlink_reset(int trst
, int srst
);
104 static void jlink_simple_command(u8 command
);
105 static int jlink_get_status(void);
107 /* J-Link tap buffer functions */
108 static void jlink_tap_init(void);
109 static int jlink_tap_execute(void);
110 static void jlink_tap_ensure_space(int scans
, int bits
);
111 static void jlink_tap_append_step(int tms
, int tdi
);
112 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
);
114 /* Jlink lowlevel functions */
115 typedef struct jlink_jtag
117 struct usb_dev_handle
* usb_handle
;
120 static jlink_jtag_t
*jlink_usb_open(void);
121 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
);
122 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
);
123 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
);
124 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
);
125 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
);
127 /* helper functions */
128 static int jlink_get_version_info(void);
130 #ifdef _DEBUG_USB_COMMS_
131 static void jlink_debug_buffer(u8
*buffer
, int length
);
134 static enum tap_state jlink_last_state
= TAP_RESET
;
136 static jlink_jtag_t
* jlink_jtag_handle
;
138 /***************************************************************************/
139 /* External interface implementation */
141 jtag_interface_t jlink_interface
=
144 .execute_queue
= jlink_execute_queue
,
145 .speed
= jlink_speed
,
146 .speed_div
= jlink_speed_div
,
148 .register_commands
= jlink_register_commands
,
153 static void jlink_execute_end_state(jtag_command_t
*cmd
)
155 DEBUG_JTAG_IO("end_state: %i", cmd
->cmd
.end_state
->end_state
);
157 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
158 jlink_end_state(cmd
->cmd
.end_state
->end_state
);
161 static void jlink_execute_runtest(jtag_command_t
*cmd
)
163 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
164 cmd
->cmd
.runtest
->num_cycles
,
165 cmd
->cmd
.runtest
->end_state
);
167 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
168 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
170 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
173 static void jlink_execute_statemove(jtag_command_t
*cmd
)
175 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
177 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
179 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
184 static void jlink_execute_pathmove(jtag_command_t
*cmd
)
186 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
187 cmd
->cmd
.pathmove
->num_states
,
188 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
190 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
191 cmd
->cmd
.pathmove
->path
);
194 static void jlink_execute_scan(jtag_command_t
*cmd
)
200 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
202 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
203 jlink_end_state(cmd
->cmd
.scan
->end_state
);
205 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
206 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
208 #ifdef _DEBUG_USB_COMMS_
209 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
211 type
= jtag_scan_type(cmd
->cmd
.scan
);
212 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
213 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
216 static void jlink_execute_reset(jtag_command_t
*cmd
)
218 DEBUG_JTAG_IO("reset trst: %i srst %i",
219 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
222 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
226 static void jlink_execute_sleep(jtag_command_t
*cmd
)
228 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
230 jtag_sleep(cmd
->cmd
.sleep
->us
);
233 static void jlink_execute_command(jtag_command_t
*cmd
)
237 case JTAG_END_STATE
: jlink_execute_end_state(cmd
); break;
238 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
239 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
240 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
241 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
242 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
243 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
245 LOG_ERROR("BUG: unknown JTAG command type encountered");
250 static int jlink_execute_queue(void)
252 jtag_command_t
*cmd
= jtag_command_queue
;
256 jlink_execute_command(cmd
);
260 return jlink_tap_execute();
263 /* Sets speed in kHz. */
264 static int jlink_speed(int speed
)
268 if (speed
> JLINK_MAX_SPEED
)
270 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
271 speed
, JLINK_MAX_SPEED
);
275 /* check for RTCK setting */
279 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
280 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
281 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
283 result
= jlink_usb_write(jlink_jtag_handle
, 3);
286 LOG_ERROR("J-Link setting speed failed (%d)", result
);
287 return ERROR_JTAG_DEVICE_ERROR
;
293 static int jlink_speed_div(int speed
, int* khz
)
300 static int jlink_khz(int khz
, int *jtag_speed
)
307 static int jlink_register_commands(struct command_context_s
*cmd_ctx
)
310 register_command(cmd_ctx
, NULL
, "jlink_info",
311 &jlink_handle_jlink_info_command
, COMMAND_EXEC
,
313 register_command(cmd_ctx
, NULL
, "jlink_hw_jtag",
314 &jlink_handle_jlink_hw_jtag_command
, COMMAND_EXEC
,
315 "set/get jlink hw jtag command version [2|3]");
319 static int jlink_init(void)
323 jlink_jtag_handle
= jlink_usb_open();
325 if (jlink_jtag_handle
== 0)
327 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
328 return ERROR_JTAG_INIT_FAILED
;
331 jlink_hw_jtag_version
= 2;
333 while (check_cnt
< 3)
335 if (jlink_get_version_info() == ERROR_OK
)
337 /* attempt to get status */
347 LOG_INFO("J-Link initial read failed, don't worry");
350 LOG_INFO("J-Link JTAG Interface ready");
355 jlink_speed(jtag_speed
);
360 static int jlink_quit(void)
362 jlink_usb_close(jlink_jtag_handle
);
366 /***************************************************************************/
367 /* Queue command implementations */
369 static void jlink_end_state(tap_state_t state
)
371 if (tap_is_state_stable(state
))
373 tap_set_end_state(state
);
377 LOG_ERROR("BUG: %i is not a valid end state", state
);
382 /* Goes to the end state. */
383 static void jlink_state_move(void)
387 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
388 u8 tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
390 for (i
= 0; i
< tms_scan_bits
; i
++)
392 tms
= (tms_scan
>> i
) & 1;
393 jlink_tap_append_step(tms
, 0);
396 tap_set_state(tap_get_end_state());
399 static void jlink_path_move(int num_states
, tap_state_t
*path
)
403 for (i
= 0; i
< num_states
; i
++)
405 if (path
[i
] == tap_state_transition(tap_get_state(), false))
407 jlink_tap_append_step(0, 0);
409 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
411 jlink_tap_append_step(1, 0);
415 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
419 tap_set_state(path
[i
]);
422 tap_set_end_state(tap_get_state());
425 static void jlink_runtest(int num_cycles
)
429 tap_state_t saved_end_state
= tap_get_end_state();
431 jlink_tap_ensure_space(1,num_cycles
+ 16);
433 /* only do a state_move when we're not already in IDLE */
434 if (tap_get_state() != TAP_IDLE
)
436 jlink_end_state(TAP_IDLE
);
441 /* execute num_cycles */
442 for (i
= 0; i
< num_cycles
; i
++)
444 jlink_tap_append_step(0, 0);
447 /* finish in end_state */
448 jlink_end_state(saved_end_state
);
449 if (tap_get_state() != tap_get_end_state())
455 static void jlink_scan(bool ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
)
457 tap_state_t saved_end_state
;
459 jlink_tap_ensure_space(1, scan_size
+ 16);
461 saved_end_state
= tap_get_end_state();
463 /* Move to appropriate scan state */
464 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
466 /* Only move if we're not already there */
467 if (tap_get_state() != tap_get_end_state())
470 jlink_end_state(saved_end_state
);
473 jlink_tap_append_scan(scan_size
, buffer
, command
);
475 /* We are in Exit1, go to Pause */
476 jlink_tap_append_step(0, 0);
478 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
480 if (tap_get_state() != tap_get_end_state())
486 static void jlink_reset(int trst
, int srst
)
488 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
490 /* Signals are active low */
493 jlink_simple_command(EMU_CMD_HW_RESET1
);
497 jlink_simple_command(EMU_CMD_HW_RESET0
);
502 jlink_simple_command(EMU_CMD_HW_TRST0
);
506 jlink_simple_command(EMU_CMD_HW_TRST1
);
508 jlink_end_state(TAP_RESET
);
513 static void jlink_simple_command(u8 command
)
517 DEBUG_JTAG_IO("0x%02x", command
);
519 usb_out_buffer
[0] = command
;
520 result
= jlink_usb_write(jlink_jtag_handle
, 1);
524 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
528 static int jlink_get_status(void)
532 jlink_simple_command(EMU_CMD_GET_STATE
);
534 result
= jlink_usb_read(jlink_jtag_handle
, 8);
537 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
538 return ERROR_JTAG_DEVICE_ERROR
;
541 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
542 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
543 vref
/ 1000, vref
% 1000, \
544 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
545 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
548 LOG_ERROR("Vref too low. Check Target Power\n");
553 static int jlink_get_version_info(void)
557 u32 jlink_caps
, jlink_max_size
;
559 /* query hardware version */
560 jlink_simple_command(EMU_CMD_VERSION
);
562 result
= jlink_usb_read(jlink_jtag_handle
, 2);
565 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
566 return ERROR_JTAG_DEVICE_ERROR
;
569 len
= buf_get_u32(usb_in_buffer
, 0, 16);
570 if (len
> JLINK_IN_BUFFER_SIZE
)
572 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
573 len
= JLINK_IN_BUFFER_SIZE
;
576 result
= jlink_usb_read(jlink_jtag_handle
, len
);
579 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
580 return ERROR_JTAG_DEVICE_ERROR
;
583 usb_in_buffer
[result
] = 0;
584 LOG_INFO("%s", (char *)usb_in_buffer
);
586 /* query hardware capabilities */
587 jlink_simple_command(EMU_CMD_GET_CAPS
);
589 result
= jlink_usb_read(jlink_jtag_handle
, 4);
592 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
593 return ERROR_JTAG_DEVICE_ERROR
;
596 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
597 LOG_INFO("JLink caps 0x%x", jlink_caps
);
599 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
601 /* query hardware version */
602 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
604 result
= jlink_usb_read(jlink_jtag_handle
, 4);
607 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result
);
608 return ERROR_JTAG_DEVICE_ERROR
;
611 u32 jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
612 u32 major_revision
= (jlink_hw_version
/ 10000) % 100;
613 if (major_revision
>= 5)
614 jlink_hw_jtag_version
= 3;
616 LOG_INFO("JLink hw version %i", jlink_hw_version
);
619 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
621 /* query hardware maximum memory block */
622 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
624 result
= jlink_usb_read(jlink_jtag_handle
, 4);
627 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
628 return ERROR_JTAG_DEVICE_ERROR
;
631 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
632 LOG_INFO("JLink max mem block %i", jlink_max_size
);
638 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
640 if (jlink_get_version_info() == ERROR_OK
)
642 /* attempt to get status */
649 static int jlink_handle_jlink_hw_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
653 command_print(cmd_ctx
, "jlink hw jtag %i", jlink_hw_jtag_version
);
656 int request_version
= atoi(args
[0]);
657 switch (request_version
) {
659 jlink_hw_jtag_version
= request_version
;
662 return ERROR_COMMAND_SYNTAX_ERROR
;
667 return ERROR_COMMAND_SYNTAX_ERROR
;
673 /***************************************************************************/
674 /* J-Link tap functions */
677 static unsigned tap_length
=0;
678 static u8 tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
679 static u8 tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
680 static u8 tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
684 int first
; /* First bit position in tdo_buffer to read */
685 int length
; /* Number of bits to read */
686 scan_command_t
*command
; /* Corresponding scan command */
688 } pending_scan_result_t
;
690 #define MAX_PENDING_SCAN_RESULTS 256
692 static int pending_scan_results_length
;
693 static pending_scan_result_t pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
695 static void jlink_tap_init(void)
698 pending_scan_results_length
= 0;
701 static void jlink_tap_ensure_space(int scans
, int bits
)
703 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
704 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
706 if (scans
> available_scans
|| bits
> available_bits
)
712 static void jlink_tap_append_step(int tms
, int tdi
)
714 int index
= tap_length
/ 8;
716 if (index
>= JLINK_TAP_BUFFER_SIZE
)
718 LOG_ERROR("jlink_tap_append_step: overflow");
719 *(u32
*)0xFFFFFFFF = 0;
723 int bit_index
= tap_length
% 8;
724 u8 bit
= 1 << bit_index
;
726 // we do not pad TMS, so be sure to initialize all bits
729 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
733 tms_buffer
[index
] |= bit
;
735 tms_buffer
[index
] &= ~bit
;
738 tdi_buffer
[index
] |= bit
;
740 tdi_buffer
[index
] &= ~bit
;
745 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
)
747 pending_scan_result_t
*pending_scan_result
=
748 &pending_scan_results_buffer
[pending_scan_results_length
];
751 pending_scan_result
->first
= tap_length
;
752 pending_scan_result
->length
= length
;
753 pending_scan_result
->command
= command
;
754 pending_scan_result
->buffer
= buffer
;
756 for (i
= 0; i
< length
; i
++)
758 int tms
= (i
< (length
- 1)) ? 0 : 1;
759 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8)))!=0;
760 jlink_tap_append_step(tms
, tdi
);
762 pending_scan_results_length
++;
765 /* Pad and send a tap sequence to the device, and receive the answer.
766 * For the purpose of padding we assume that we are in idle or pause state. */
767 static int jlink_tap_execute(void)
776 /* JLink returns an extra NULL in packet when size of in message is a multiple of 64, creates problems with usb comms */
777 /* WARNING This will interfere with tap state counting */
778 while ((TAP_SCAN_BYTES(tap_length
)%64)==0)
780 jlink_tap_append_step((tap_get_state() == TAP_RESET
)?1:0, 0);
783 // number of full bytes (plus one if some would be left over)
784 byte_length
= TAP_SCAN_BYTES(tap_length
);
786 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
787 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
788 usb_out_buffer
[1] = 0;
789 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
790 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
791 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
792 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
794 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
795 tap_length
, jlink_last_state
);
797 result
= jlink_usb_message(jlink_jtag_handle
, 4 + 2 * byte_length
, byte_length
);
798 if (result
!= byte_length
)
800 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
802 return ERROR_JTAG_QUEUE_FAILED
;
805 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
807 for (i
= 0; i
< pending_scan_results_length
; i
++)
809 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[i
];
810 u8
*buffer
= pending_scan_result
->buffer
;
811 int length
= pending_scan_result
->length
;
812 int first
= pending_scan_result
->first
;
813 scan_command_t
*command
= pending_scan_result
->command
;
816 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
818 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
820 #ifdef _DEBUG_USB_COMMS_
821 jlink_debug_buffer(buffer
, byte_length
);
824 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
827 return ERROR_JTAG_QUEUE_FAILED
;
830 if (pending_scan_result
->buffer
!= NULL
)
832 free(pending_scan_result
->buffer
);
840 /*****************************************************************************/
841 /* JLink USB low-level functions */
843 static jlink_jtag_t
* jlink_usb_open()
845 struct usb_bus
*busses
;
847 struct usb_device
*dev
;
849 jlink_jtag_t
*result
;
851 result
= (jlink_jtag_t
*) malloc(sizeof(jlink_jtag_t
));
857 busses
= usb_get_busses();
859 /* find jlink_jtag device in usb bus */
861 for (bus
= busses
; bus
; bus
= bus
->next
)
863 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
865 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
))
867 result
->usb_handle
= usb_open(dev
);
869 /* usb_set_configuration required under win32 */
870 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
871 usb_claim_interface(result
->usb_handle
, 0);
875 * This makes problems under Mac OS X. And is not needed
876 * under Windows. Hopefully this will not break a linux build
878 usb_set_altinterface(result
->usb_handle
, 0);
880 struct usb_interface
*iface
= dev
->config
->interface
;
881 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
882 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
884 u8 epnum
= desc
->endpoint
[i
].bEndpointAddress
;
885 bool is_input
= epnum
& 0x80;
886 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
888 jlink_read_ep
= epnum
;
890 jlink_write_ep
= epnum
;
902 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
)
904 usb_close(jlink_jtag
->usb_handle
);
908 /* Send a message and receive the reply. */
909 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
)
913 result
= jlink_usb_write(jlink_jtag
, out_length
);
914 if (result
!= out_length
)
916 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
918 return ERROR_JTAG_DEVICE_ERROR
;
921 result
= jlink_usb_read(jlink_jtag
, in_length
);
922 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
924 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
926 return ERROR_JTAG_DEVICE_ERROR
;
929 if (jlink_hw_jtag_version
< 3)
932 int result2
= ERROR_OK
;
933 if (result
== in_length
)
935 /* Must read the result from the EMU too */
936 result2
= jlink_usb_read_emu_result(jlink_jtag
);
939 LOG_ERROR("jlink_usb_read_emu_result retried requested=1, result=%d, in_length=%i", result2
,in_length
);
940 /* Try again once, should only happen if (in_length%64==0) */
941 result2
= jlink_usb_read_emu_result(jlink_jtag
);
944 LOG_ERROR("jlink_usb_read_emu_result failed "
945 "(requested=1, result=%d)", result2
);
946 return ERROR_JTAG_DEVICE_ERROR
;
950 /* Check the result itself */
951 result2
= usb_emu_result_buffer
[0];
955 /* Save the result, then remove it from return value */
956 result2
= usb_in_buffer
[result
--];
961 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
962 return ERROR_JTAG_DEVICE_ERROR
;
968 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
969 static int usb_bulk_with_retries(
970 int (*f
)(usb_dev_handle
*, int, char *, int, int),
971 usb_dev_handle
*dev
, int ep
,
972 char *bytes
, int size
, int timeout
)
974 int tries
= 3, count
= 0;
976 while (tries
&& (count
< size
))
978 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
981 else if ((-ETIMEDOUT
!= result
) || !--tries
)
987 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
988 char *buff
, int size
, int timeout
)
990 /* usb_bulk_write() takes const char *buff */
991 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
994 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
995 char *bytes
, int size
, int timeout
)
997 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
998 dev
, ep
, bytes
, size
, timeout
);
1001 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
1002 char *bytes
, int size
, int timeout
)
1004 return usb_bulk_with_retries(&usb_bulk_read
,
1005 dev
, ep
, bytes
, size
, timeout
);
1008 /* Write data from out_buffer to USB. */
1009 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
)
1013 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1015 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
1019 result
= usb_bulk_write_ex(jlink_jtag
->usb_handle
, jlink_write_ep
,
1020 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1022 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
1024 #ifdef _DEBUG_USB_COMMS_
1025 jlink_debug_buffer(usb_out_buffer
, out_length
);
1030 /* Read data from USB into in_buffer. */
1031 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
)
1033 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, jlink_read_ep
,
1034 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1036 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1038 #ifdef _DEBUG_USB_COMMS_
1039 jlink_debug_buffer(usb_in_buffer
, result
);
1044 /* Read the result from the previous EMU cmd into result_buffer. */
1045 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
)
1047 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, jlink_read_ep
,
1048 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1051 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1053 #ifdef _DEBUG_USB_COMMS_
1054 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1059 #ifdef _DEBUG_USB_COMMS_
1060 #define BYTES_PER_LINE 16
1062 static void jlink_debug_buffer(u8
*buffer
, int length
)
1069 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1071 snprintf(line
, 5, "%04x", i
);
1072 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1074 snprintf(s
, 4, " %02x", buffer
[j
]);
1077 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)