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_runtest(jtag_command_t
*cmd
)
155 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
156 cmd
->cmd
.runtest
->num_cycles
,
157 cmd
->cmd
.runtest
->end_state
);
159 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
160 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
162 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
165 static void jlink_execute_statemove(jtag_command_t
*cmd
)
167 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
169 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
171 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
176 static void jlink_execute_pathmove(jtag_command_t
*cmd
)
178 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
179 cmd
->cmd
.pathmove
->num_states
,
180 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
182 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
183 cmd
->cmd
.pathmove
->path
);
186 static void jlink_execute_scan(jtag_command_t
*cmd
)
192 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
194 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
195 jlink_end_state(cmd
->cmd
.scan
->end_state
);
197 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
198 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
200 #ifdef _DEBUG_USB_COMMS_
201 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
203 type
= jtag_scan_type(cmd
->cmd
.scan
);
204 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
205 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
208 static void jlink_execute_reset(jtag_command_t
*cmd
)
210 DEBUG_JTAG_IO("reset trst: %i srst %i",
211 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
214 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
218 static void jlink_execute_sleep(jtag_command_t
*cmd
)
220 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
222 jtag_sleep(cmd
->cmd
.sleep
->us
);
225 static void jlink_execute_command(jtag_command_t
*cmd
)
229 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
230 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
231 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
232 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
233 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
234 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
236 LOG_ERROR("BUG: unknown JTAG command type encountered");
241 static int jlink_execute_queue(void)
243 jtag_command_t
*cmd
= jtag_command_queue
;
247 jlink_execute_command(cmd
);
251 return jlink_tap_execute();
254 /* Sets speed in kHz. */
255 static int jlink_speed(int speed
)
259 if (speed
> JLINK_MAX_SPEED
)
261 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
262 speed
, JLINK_MAX_SPEED
);
266 /* check for RTCK setting */
270 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
271 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
272 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
274 result
= jlink_usb_write(jlink_jtag_handle
, 3);
277 LOG_ERROR("J-Link setting speed failed (%d)", result
);
278 return ERROR_JTAG_DEVICE_ERROR
;
284 static int jlink_speed_div(int speed
, int* khz
)
291 static int jlink_khz(int khz
, int *jtag_speed
)
298 static int jlink_register_commands(struct command_context_s
*cmd_ctx
)
301 register_command(cmd_ctx
, NULL
, "jlink_info",
302 &jlink_handle_jlink_info_command
, COMMAND_EXEC
,
304 register_command(cmd_ctx
, NULL
, "jlink_hw_jtag",
305 &jlink_handle_jlink_hw_jtag_command
, COMMAND_EXEC
,
306 "set/get jlink hw jtag command version [2|3]");
310 static int jlink_init(void)
314 jlink_jtag_handle
= jlink_usb_open();
316 if (jlink_jtag_handle
== 0)
318 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
319 return ERROR_JTAG_INIT_FAILED
;
322 jlink_hw_jtag_version
= 2;
324 while (check_cnt
< 3)
326 if (jlink_get_version_info() == ERROR_OK
)
328 /* attempt to get status */
338 LOG_INFO("J-Link initial read failed, don't worry");
341 LOG_INFO("J-Link JTAG Interface ready");
346 jlink_speed(jtag_speed
);
351 static int jlink_quit(void)
353 jlink_usb_close(jlink_jtag_handle
);
357 /***************************************************************************/
358 /* Queue command implementations */
360 static void jlink_end_state(tap_state_t state
)
362 if (tap_is_state_stable(state
))
364 tap_set_end_state(state
);
368 LOG_ERROR("BUG: %i is not a valid end state", state
);
373 /* Goes to the end state. */
374 static void jlink_state_move(void)
378 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
379 u8 tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
381 for (i
= 0; i
< tms_scan_bits
; i
++)
383 tms
= (tms_scan
>> i
) & 1;
384 jlink_tap_append_step(tms
, 0);
387 tap_set_state(tap_get_end_state());
390 static void jlink_path_move(int num_states
, tap_state_t
*path
)
394 for (i
= 0; i
< num_states
; i
++)
396 if (path
[i
] == tap_state_transition(tap_get_state(), false))
398 jlink_tap_append_step(0, 0);
400 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
402 jlink_tap_append_step(1, 0);
406 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
410 tap_set_state(path
[i
]);
413 tap_set_end_state(tap_get_state());
416 static void jlink_runtest(int num_cycles
)
420 tap_state_t saved_end_state
= tap_get_end_state();
422 jlink_tap_ensure_space(1,num_cycles
+ 16);
424 /* only do a state_move when we're not already in IDLE */
425 if (tap_get_state() != TAP_IDLE
)
427 jlink_end_state(TAP_IDLE
);
432 /* execute num_cycles */
433 for (i
= 0; i
< num_cycles
; i
++)
435 jlink_tap_append_step(0, 0);
438 /* finish in end_state */
439 jlink_end_state(saved_end_state
);
440 if (tap_get_state() != tap_get_end_state())
446 static void jlink_scan(bool ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
)
448 tap_state_t saved_end_state
;
450 jlink_tap_ensure_space(1, scan_size
+ 16);
452 saved_end_state
= tap_get_end_state();
454 /* Move to appropriate scan state */
455 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
457 /* Only move if we're not already there */
458 if (tap_get_state() != tap_get_end_state())
461 jlink_end_state(saved_end_state
);
464 jlink_tap_append_scan(scan_size
, buffer
, command
);
466 /* We are in Exit1, go to Pause */
467 jlink_tap_append_step(0, 0);
469 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
471 if (tap_get_state() != tap_get_end_state())
477 static void jlink_reset(int trst
, int srst
)
479 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
481 /* Signals are active low */
484 jlink_simple_command(EMU_CMD_HW_RESET1
);
488 jlink_simple_command(EMU_CMD_HW_RESET0
);
493 jlink_simple_command(EMU_CMD_HW_TRST0
);
497 jlink_simple_command(EMU_CMD_HW_TRST1
);
499 jlink_end_state(TAP_RESET
);
504 static void jlink_simple_command(u8 command
)
508 DEBUG_JTAG_IO("0x%02x", command
);
510 usb_out_buffer
[0] = command
;
511 result
= jlink_usb_write(jlink_jtag_handle
, 1);
515 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
519 static int jlink_get_status(void)
523 jlink_simple_command(EMU_CMD_GET_STATE
);
525 result
= jlink_usb_read(jlink_jtag_handle
, 8);
528 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
529 return ERROR_JTAG_DEVICE_ERROR
;
532 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
533 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
534 vref
/ 1000, vref
% 1000, \
535 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
536 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
539 LOG_ERROR("Vref too low. Check Target Power\n");
544 static int jlink_get_version_info(void)
548 u32 jlink_caps
, jlink_max_size
;
550 /* query hardware version */
551 jlink_simple_command(EMU_CMD_VERSION
);
553 result
= jlink_usb_read(jlink_jtag_handle
, 2);
556 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
557 return ERROR_JTAG_DEVICE_ERROR
;
560 len
= buf_get_u32(usb_in_buffer
, 0, 16);
561 if (len
> JLINK_IN_BUFFER_SIZE
)
563 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
564 len
= JLINK_IN_BUFFER_SIZE
;
567 result
= jlink_usb_read(jlink_jtag_handle
, len
);
570 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
571 return ERROR_JTAG_DEVICE_ERROR
;
574 usb_in_buffer
[result
] = 0;
575 LOG_INFO("%s", (char *)usb_in_buffer
);
577 /* query hardware capabilities */
578 jlink_simple_command(EMU_CMD_GET_CAPS
);
580 result
= jlink_usb_read(jlink_jtag_handle
, 4);
583 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
584 return ERROR_JTAG_DEVICE_ERROR
;
587 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
588 LOG_INFO("JLink caps 0x%x", jlink_caps
);
590 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
))
592 /* query hardware version */
593 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
595 result
= jlink_usb_read(jlink_jtag_handle
, 4);
598 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)\n", result
);
599 return ERROR_JTAG_DEVICE_ERROR
;
602 u32 jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
603 u32 major_revision
= (jlink_hw_version
/ 10000) % 100;
604 if (major_revision
>= 5)
605 jlink_hw_jtag_version
= 3;
607 LOG_INFO("JLink hw version %i", jlink_hw_version
);
610 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
))
612 /* query hardware maximum memory block */
613 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
615 result
= jlink_usb_read(jlink_jtag_handle
, 4);
618 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
619 return ERROR_JTAG_DEVICE_ERROR
;
622 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
623 LOG_INFO("JLink max mem block %i", jlink_max_size
);
629 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
631 if (jlink_get_version_info() == ERROR_OK
)
633 /* attempt to get status */
640 static int jlink_handle_jlink_hw_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
644 command_print(cmd_ctx
, "jlink hw jtag %i", jlink_hw_jtag_version
);
647 int request_version
= atoi(args
[0]);
648 switch (request_version
) {
650 jlink_hw_jtag_version
= request_version
;
653 return ERROR_COMMAND_SYNTAX_ERROR
;
658 return ERROR_COMMAND_SYNTAX_ERROR
;
664 /***************************************************************************/
665 /* J-Link tap functions */
668 static unsigned tap_length
=0;
669 static u8 tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
670 static u8 tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
671 static u8 tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
675 int first
; /* First bit position in tdo_buffer to read */
676 int length
; /* Number of bits to read */
677 scan_command_t
*command
; /* Corresponding scan command */
679 } pending_scan_result_t
;
681 #define MAX_PENDING_SCAN_RESULTS 256
683 static int pending_scan_results_length
;
684 static pending_scan_result_t pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
686 static void jlink_tap_init(void)
689 pending_scan_results_length
= 0;
692 static void jlink_tap_ensure_space(int scans
, int bits
)
694 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
695 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
697 if (scans
> available_scans
|| bits
> available_bits
)
703 static void jlink_tap_append_step(int tms
, int tdi
)
705 int index
= tap_length
/ 8;
707 if (index
>= JLINK_TAP_BUFFER_SIZE
)
709 LOG_ERROR("jlink_tap_append_step: overflow");
710 *(u32
*)0xFFFFFFFF = 0;
714 int bit_index
= tap_length
% 8;
715 u8 bit
= 1 << bit_index
;
717 // we do not pad TMS, so be sure to initialize all bits
720 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
724 tms_buffer
[index
] |= bit
;
726 tms_buffer
[index
] &= ~bit
;
729 tdi_buffer
[index
] |= bit
;
731 tdi_buffer
[index
] &= ~bit
;
736 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
)
738 pending_scan_result_t
*pending_scan_result
=
739 &pending_scan_results_buffer
[pending_scan_results_length
];
742 pending_scan_result
->first
= tap_length
;
743 pending_scan_result
->length
= length
;
744 pending_scan_result
->command
= command
;
745 pending_scan_result
->buffer
= buffer
;
747 for (i
= 0; i
< length
; i
++)
749 int tms
= (i
< (length
- 1)) ? 0 : 1;
750 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8)))!=0;
751 jlink_tap_append_step(tms
, tdi
);
753 pending_scan_results_length
++;
756 /* Pad and send a tap sequence to the device, and receive the answer.
757 * For the purpose of padding we assume that we are in idle or pause state. */
758 static int jlink_tap_execute(void)
767 /* JLink returns an extra NULL in packet when size of in message is a multiple of 64, creates problems with usb comms */
768 /* WARNING This will interfere with tap state counting */
769 while ((TAP_SCAN_BYTES(tap_length
)%64)==0)
771 jlink_tap_append_step((tap_get_state() == TAP_RESET
)?1:0, 0);
774 // number of full bytes (plus one if some would be left over)
775 byte_length
= TAP_SCAN_BYTES(tap_length
);
777 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
778 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
779 usb_out_buffer
[1] = 0;
780 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
781 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
782 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
783 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
785 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
786 tap_length
, jlink_last_state
);
788 result
= jlink_usb_message(jlink_jtag_handle
, 4 + 2 * byte_length
, byte_length
);
789 if (result
!= byte_length
)
791 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
793 return ERROR_JTAG_QUEUE_FAILED
;
796 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
798 for (i
= 0; i
< pending_scan_results_length
; i
++)
800 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[i
];
801 u8
*buffer
= pending_scan_result
->buffer
;
802 int length
= pending_scan_result
->length
;
803 int first
= pending_scan_result
->first
;
804 scan_command_t
*command
= pending_scan_result
->command
;
807 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
809 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
811 #ifdef _DEBUG_USB_COMMS_
812 jlink_debug_buffer(buffer
, byte_length
);
815 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
818 return ERROR_JTAG_QUEUE_FAILED
;
821 if (pending_scan_result
->buffer
!= NULL
)
823 free(pending_scan_result
->buffer
);
831 /*****************************************************************************/
832 /* JLink USB low-level functions */
834 static jlink_jtag_t
* jlink_usb_open()
836 struct usb_bus
*busses
;
838 struct usb_device
*dev
;
840 jlink_jtag_t
*result
;
842 result
= (jlink_jtag_t
*) malloc(sizeof(jlink_jtag_t
));
848 busses
= usb_get_busses();
850 /* find jlink_jtag device in usb bus */
852 for (bus
= busses
; bus
; bus
= bus
->next
)
854 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
856 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
))
858 result
->usb_handle
= usb_open(dev
);
860 /* usb_set_configuration required under win32 */
861 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
862 usb_claim_interface(result
->usb_handle
, 0);
866 * This makes problems under Mac OS X. And is not needed
867 * under Windows. Hopefully this will not break a linux build
869 usb_set_altinterface(result
->usb_handle
, 0);
871 struct usb_interface
*iface
= dev
->config
->interface
;
872 struct usb_interface_descriptor
*desc
= iface
->altsetting
;
873 for (int i
= 0; i
< desc
->bNumEndpoints
; i
++)
875 u8 epnum
= desc
->endpoint
[i
].bEndpointAddress
;
876 bool is_input
= epnum
& 0x80;
877 LOG_DEBUG("usb ep %s %02x", is_input
? "in" : "out", epnum
);
879 jlink_read_ep
= epnum
;
881 jlink_write_ep
= epnum
;
893 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
)
895 usb_close(jlink_jtag
->usb_handle
);
899 /* Send a message and receive the reply. */
900 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
)
904 result
= jlink_usb_write(jlink_jtag
, out_length
);
905 if (result
!= out_length
)
907 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
909 return ERROR_JTAG_DEVICE_ERROR
;
912 result
= jlink_usb_read(jlink_jtag
, in_length
);
913 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
915 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
917 return ERROR_JTAG_DEVICE_ERROR
;
920 if (jlink_hw_jtag_version
< 3)
923 int result2
= ERROR_OK
;
924 if (result
== in_length
)
926 /* Must read the result from the EMU too */
927 result2
= jlink_usb_read_emu_result(jlink_jtag
);
930 LOG_ERROR("jlink_usb_read_emu_result retried requested=1, result=%d, in_length=%i", result2
,in_length
);
931 /* Try again once, should only happen if (in_length%64==0) */
932 result2
= jlink_usb_read_emu_result(jlink_jtag
);
935 LOG_ERROR("jlink_usb_read_emu_result failed "
936 "(requested=1, result=%d)", result2
);
937 return ERROR_JTAG_DEVICE_ERROR
;
941 /* Check the result itself */
942 result2
= usb_emu_result_buffer
[0];
946 /* Save the result, then remove it from return value */
947 result2
= usb_in_buffer
[result
--];
952 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
953 return ERROR_JTAG_DEVICE_ERROR
;
959 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
960 static int usb_bulk_with_retries(
961 int (*f
)(usb_dev_handle
*, int, char *, int, int),
962 usb_dev_handle
*dev
, int ep
,
963 char *bytes
, int size
, int timeout
)
965 int tries
= 3, count
= 0;
967 while (tries
&& (count
< size
))
969 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
972 else if ((-ETIMEDOUT
!= result
) || !--tries
)
978 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
979 char *buff
, int size
, int timeout
)
981 /* usb_bulk_write() takes const char *buff */
982 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
985 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
986 char *bytes
, int size
, int timeout
)
988 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
989 dev
, ep
, bytes
, size
, timeout
);
992 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
993 char *bytes
, int size
, int timeout
)
995 return usb_bulk_with_retries(&usb_bulk_read
,
996 dev
, ep
, bytes
, size
, timeout
);
999 /* Write data from out_buffer to USB. */
1000 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
)
1004 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
1006 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
1010 result
= usb_bulk_write_ex(jlink_jtag
->usb_handle
, jlink_write_ep
,
1011 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1013 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
1015 #ifdef _DEBUG_USB_COMMS_
1016 jlink_debug_buffer(usb_out_buffer
, out_length
);
1021 /* Read data from USB into in_buffer. */
1022 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
)
1024 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, jlink_read_ep
,
1025 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1027 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1029 #ifdef _DEBUG_USB_COMMS_
1030 jlink_debug_buffer(usb_in_buffer
, result
);
1035 /* Read the result from the previous EMU cmd into result_buffer. */
1036 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
)
1038 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, jlink_read_ep
,
1039 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1042 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1044 #ifdef _DEBUG_USB_COMMS_
1045 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1050 #ifdef _DEBUG_USB_COMMS_
1051 #define BYTES_PER_LINE 16
1053 static void jlink_debug_buffer(u8
*buffer
, int length
)
1060 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
1062 snprintf(line
, 5, "%04x", i
);
1063 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
1065 snprintf(s
, 4, " %02x", buffer
[j
]);
1068 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)