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 "replacements.h"
40 #define JLINK_WRITE_ENDPOINT 0x02
41 #define JLINK_READ_ENDPOINT 0x81
43 #define JLINK_USB_TIMEOUT 1000
45 // See Section 1.3.2 of the Segger JLink USB protocol manual
46 #define JLINK_IN_BUFFER_SIZE 2048
47 #define JLINK_OUT_BUFFER_SIZE 2*2048+4
48 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
50 /* Global USB buffers */
51 static u8 usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
52 static u8 usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
53 static u8 usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
55 /* Constants for JLink command */
56 #define EMU_CMD_VERSION 0x01
57 #define EMU_CMD_SET_SPEED 0x05
58 #define EMU_CMD_GET_STATE 0x07
59 #define EMU_CMD_HW_JTAG3 0xcf
60 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
61 #define EMU_CMD_HW_RESET0 0xdc
62 #define EMU_CMD_HW_RESET1 0xdd
63 #define EMU_CMD_HW_TRST0 0xde
64 #define EMU_CMD_HW_TRST1 0xdf
65 #define EMU_CMD_GET_CAPS 0xe8
67 /* max speed 12MHz v5.0 jlink */
68 #define JLINK_MAX_SPEED 12000
70 /* External interface functions */
71 static int jlink_execute_queue(void);
72 static int jlink_speed(int speed
);
73 static int jlink_speed_div(int speed
, int* khz
);
74 static int jlink_khz(int khz
, int *jtag_speed
);
75 static int jlink_register_commands(struct command_context_s
*cmd_ctx
);
76 static int jlink_init(void);
77 static int jlink_quit(void);
79 /* CLI command handler functions */
80 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 /* Queue command functions */
83 static void jlink_end_state(tap_state_t state
);
84 static void jlink_state_move(void);
85 static void jlink_path_move(int num_states
, tap_state_t
*path
);
86 static void jlink_runtest(int num_cycles
);
87 static void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
);
88 static void jlink_reset(int trst
, int srst
);
89 static void jlink_simple_command(u8 command
);
90 static int jlink_get_status(void);
92 /* J-Link tap buffer functions */
93 static void jlink_tap_init(void);
94 static int jlink_tap_execute(void);
95 static void jlink_tap_ensure_space(int scans
, int bits
);
96 static void jlink_tap_append_step(int tms
, int tdi
);
97 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
);
99 /* Jlink lowlevel functions */
100 typedef struct jlink_jtag
102 struct usb_dev_handle
* usb_handle
;
105 static jlink_jtag_t
*jlink_usb_open(void);
106 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
);
107 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
);
108 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
);
109 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
);
110 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
);
112 /* helper functions */
113 static int jlink_get_version_info(void);
115 #ifdef _DEBUG_USB_COMMS_
116 static void jlink_debug_buffer(u8
*buffer
, int length
);
119 static enum tap_state jlink_last_state
= TAP_RESET
;
121 static jlink_jtag_t
* jlink_jtag_handle
;
123 /***************************************************************************/
124 /* External interface implementation */
126 jtag_interface_t jlink_interface
=
129 .execute_queue
= jlink_execute_queue
,
130 .speed
= jlink_speed
,
131 .speed_div
= jlink_speed_div
,
133 .register_commands
= jlink_register_commands
,
138 static void jlink_execute_end_state(jtag_command_t
*cmd
)
140 DEBUG_JTAG_IO("end_state: %i", cmd
->cmd
.end_state
->end_state
);
142 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
143 jlink_end_state(cmd
->cmd
.end_state
->end_state
);
146 static void jlink_execute_runtest(jtag_command_t
*cmd
)
148 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
149 cmd
->cmd
.runtest
->num_cycles
,
150 cmd
->cmd
.runtest
->end_state
);
152 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
153 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
155 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
158 static void jlink_execute_statemove(jtag_command_t
*cmd
)
160 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
162 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
164 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
169 static void jlink_execute_pathmove(jtag_command_t
*cmd
)
171 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
172 cmd
->cmd
.pathmove
->num_states
,
173 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
175 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
176 cmd
->cmd
.pathmove
->path
);
179 static void jlink_execute_scan(jtag_command_t
*cmd
)
185 DEBUG_JTAG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
187 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
188 jlink_end_state(cmd
->cmd
.scan
->end_state
);
190 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
191 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
193 #ifdef _DEBUG_USB_COMMS_
194 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
196 type
= jtag_scan_type(cmd
->cmd
.scan
);
197 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
198 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
201 static void jlink_execute_reset(jtag_command_t
*cmd
)
203 DEBUG_JTAG_IO("reset trst: %i srst %i",
204 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
208 if (cmd
->cmd
.reset
->trst
== 1)
209 tap_set_state(TAP_RESET
);
211 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
214 static void jlink_execute_sleep(jtag_command_t
*cmd
)
216 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
218 jtag_sleep(cmd
->cmd
.sleep
->us
);
221 static void jlink_execute_command(jtag_command_t
*cmd
)
225 case JTAG_END_STATE
: jlink_execute_end_state(cmd
); break;
226 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
227 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
228 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
229 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
230 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
231 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
233 LOG_ERROR("BUG: unknown JTAG command type encountered");
238 static int jlink_execute_queue(void)
240 jtag_command_t
*cmd
= jtag_command_queue
;
244 jlink_execute_command(cmd
);
248 return jlink_tap_execute();
251 /* Sets speed in kHz. */
252 static int jlink_speed(int speed
)
256 if (speed
> JLINK_MAX_SPEED
)
258 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
259 speed
, JLINK_MAX_SPEED
);
263 /* check for RTCK setting */
267 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
268 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
269 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
271 result
= jlink_usb_write(jlink_jtag_handle
, 3);
274 LOG_ERROR("J-Link setting speed failed (%d)", result
);
275 return ERROR_JTAG_DEVICE_ERROR
;
281 static int jlink_speed_div(int speed
, int* khz
)
288 static int jlink_khz(int khz
, int *jtag_speed
)
295 static int jlink_register_commands(struct command_context_s
*cmd_ctx
)
297 register_command(cmd_ctx
, NULL
, "jlink_info", jlink_handle_jlink_info_command
, COMMAND_EXEC
,
302 static int jlink_init(void)
306 jlink_jtag_handle
= jlink_usb_open();
308 if (jlink_jtag_handle
== 0)
310 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
311 return ERROR_JTAG_INIT_FAILED
;
315 while (check_cnt
< 3)
317 if (jlink_get_version_info() == ERROR_OK
)
319 /* attempt to get status */
329 LOG_INFO("J-Link initial read failed, don't worry");
332 LOG_INFO("J-Link JTAG Interface ready");
336 jlink_speed(jtag_speed
);
341 static int jlink_quit(void)
343 jlink_usb_close(jlink_jtag_handle
);
347 /***************************************************************************/
348 /* Queue command implementations */
350 static void jlink_end_state(tap_state_t state
)
352 if (tap_is_state_stable(state
))
354 tap_set_end_state(state
);
358 LOG_ERROR("BUG: %i is not a valid end state", state
);
363 /* Goes to the end state. */
364 static void jlink_state_move(void)
368 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
370 for (i
= 0; i
< 7; 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", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
399 tap_set_state(path
[i
]);
402 tap_set_end_state(tap_get_state());
405 static void jlink_runtest(int num_cycles
)
409 tap_state_t saved_end_state
= tap_get_end_state();
411 /* only do a state_move when we're not already in IDLE */
412 if (tap_get_state() != TAP_IDLE
)
414 jlink_end_state(TAP_IDLE
);
418 /* execute num_cycles */
419 for (i
= 0; i
< num_cycles
; i
++)
421 jlink_tap_append_step(0, 0);
424 /* finish in end_state */
425 jlink_end_state(saved_end_state
);
426 if (tap_get_state() != tap_get_end_state())
432 static void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
)
434 tap_state_t saved_end_state
;
436 jlink_tap_ensure_space(1, scan_size
+ 8);
438 saved_end_state
= tap_get_end_state();
440 /* Move to appropriate scan state */
441 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
443 /* Only move if we're not already there */
444 if (tap_get_state() != tap_get_end_state())
447 jlink_end_state(saved_end_state
);
450 jlink_tap_append_scan(scan_size
, buffer
, command
);
452 /* We are in Exit1, go to Pause */
453 jlink_tap_append_step(0, 0);
455 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
457 if (tap_get_state() != tap_get_end_state())
463 static void jlink_reset(int trst
, int srst
)
465 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
467 /* Signals are active low */
470 jlink_simple_command(EMU_CMD_HW_RESET1
);
471 jlink_end_state(TAP_RESET
);
476 jlink_simple_command(EMU_CMD_HW_RESET0
);
481 jlink_simple_command(EMU_CMD_HW_TRST1
);
482 jlink_end_state(TAP_RESET
);
487 jlink_simple_command(EMU_CMD_HW_TRST0
);
491 static void jlink_simple_command(u8 command
)
495 DEBUG_JTAG_IO("0x%02x", command
);
497 usb_out_buffer
[0] = command
;
498 result
= jlink_usb_write(jlink_jtag_handle
, 1);
502 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
506 static int jlink_get_status(void)
510 jlink_simple_command(EMU_CMD_GET_STATE
);
512 result
= jlink_usb_read(jlink_jtag_handle
, 8);
515 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
516 return ERROR_JTAG_DEVICE_ERROR
;
519 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
520 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
521 vref
/ 1000, vref
% 1000, \
522 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
523 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
526 LOG_ERROR("Vref too low. Check Target Power\n");
531 static int jlink_get_version_info(void)
535 u32 jlink_caps
, jlink_max_size
;
537 /* query hardware version */
538 jlink_simple_command(EMU_CMD_VERSION
);
540 result
= jlink_usb_read(jlink_jtag_handle
, 2);
543 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
544 return ERROR_JTAG_DEVICE_ERROR
;
547 len
= buf_get_u32(usb_in_buffer
, 0, 16);
548 result
= jlink_usb_read(jlink_jtag_handle
, len
);
551 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
552 return ERROR_JTAG_DEVICE_ERROR
;
555 usb_in_buffer
[result
] = 0;
556 LOG_INFO("%s", (char *)usb_in_buffer
);
558 /* query hardware capabilities */
559 jlink_simple_command(EMU_CMD_GET_CAPS
);
561 result
= jlink_usb_read(jlink_jtag_handle
, 4);
564 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
565 return ERROR_JTAG_DEVICE_ERROR
;
568 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
569 LOG_INFO("JLink caps 0x%x", jlink_caps
);
572 /* query hardware maximum memory block */
573 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
575 result
= jlink_usb_read(jlink_jtag_handle
, 4);
578 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
579 return ERROR_JTAG_DEVICE_ERROR
;
582 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
583 LOG_INFO("JLink max mem block %i", jlink_max_size
);
589 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
591 if (jlink_get_version_info() == ERROR_OK
)
593 /* attempt to get status */
600 /***************************************************************************/
601 /* J-Link tap functions */
603 /* 2048 is the max value we can use here */
604 #define JLINK_TAP_BUFFER_SIZE 2048
606 static unsigned tap_length
;
607 static u8 tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
608 static u8 tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
609 static u8 tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
613 int first
; /* First bit position in tdo_buffer to read */
614 int length
; /* Number of bits to read */
615 scan_command_t
*command
; /* Corresponding scan command */
617 } pending_scan_result_t
;
619 #define MAX_PENDING_SCAN_RESULTS 256
621 static int pending_scan_results_length
;
622 static pending_scan_result_t pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
626 static void jlink_tap_init(void)
629 pending_scan_results_length
= 0;
632 static void jlink_tap_ensure_space(int scans
, int bits
)
634 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
635 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
;
637 if (scans
> available_scans
|| bits
> available_bits
)
643 static void jlink_tap_append_step(int tms
, int tdi
)
646 int index
= tap_length
/ 8;
648 if (index
>= JLINK_TAP_BUFFER_SIZE
)
650 LOG_ERROR("jlink_tap_append_step: overflow");
654 int bit_index
= tap_length
% 8;
655 u8 bit
= 1 << bit_index
;
657 // we do not pad TMS, so be sure to initialize all bits
659 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
662 tms_buffer
[index
] |= bit
;
664 tms_buffer
[index
] &= ~bit
;
667 tdi_buffer
[index
] |= bit
;
669 tdi_buffer
[index
] &= ~bit
;
674 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
)
676 pending_scan_result_t
*pending_scan_result
=
677 &pending_scan_results_buffer
[pending_scan_results_length
];
680 pending_scan_result
->first
= tap_length
;
681 pending_scan_result
->length
= length
;
682 pending_scan_result
->command
= command
;
683 pending_scan_result
->buffer
= buffer
;
685 for (i
= 0; i
< length
; i
++)
687 int tms
= i
< length
- 1 ? 0 : 1;
688 int tdi
= buffer
[i
/ 8] & (1 << (i
% 8));
689 jlink_tap_append_step(tms
, tdi
);
691 pending_scan_results_length
++;
694 /* Pad and send a tap sequence to the device, and receive the answer.
695 * For the purpose of padding we assume that we are in idle or pause state. */
696 static int jlink_tap_execute(void)
705 // number of full bytes (plus one if some would be left over)
706 byte_length
= TAP_SCAN_BYTES(tap_length
);
708 usb_out_buffer
[0] = EMU_CMD_HW_JTAG3
;
709 usb_out_buffer
[1] = 0;
710 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
711 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
712 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
713 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
715 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
716 tap_length
, jlink_last_state
);
718 result
= jlink_usb_message(jlink_jtag_handle
, 4 + 2 * byte_length
, byte_length
);
719 if (result
!= byte_length
)
721 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
723 return ERROR_JTAG_QUEUE_FAILED
;
726 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
728 for (i
= 0; i
< pending_scan_results_length
; i
++)
730 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[i
];
731 u8
*buffer
= pending_scan_result
->buffer
;
732 int length
= pending_scan_result
->length
;
733 int first
= pending_scan_result
->first
;
734 scan_command_t
*command
= pending_scan_result
->command
;
737 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
739 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
741 #ifdef _DEBUG_USB_COMMS_
742 jlink_debug_buffer(buffer
, byte_length
);
745 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
748 return ERROR_JTAG_QUEUE_FAILED
;
751 if (pending_scan_result
->buffer
!= NULL
)
753 free(pending_scan_result
->buffer
);
761 /*****************************************************************************/
762 /* JLink USB low-level functions */
764 static jlink_jtag_t
* jlink_usb_open()
766 struct usb_bus
*busses
;
768 struct usb_device
*dev
;
770 jlink_jtag_t
*result
;
772 result
= (jlink_jtag_t
*) malloc(sizeof(jlink_jtag_t
));
778 busses
= usb_get_busses();
780 /* find jlink_jtag device in usb bus */
782 for (bus
= busses
; bus
; bus
= bus
->next
)
784 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
786 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
))
788 result
->usb_handle
= usb_open(dev
);
790 /* usb_set_configuration required under win32 */
791 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
792 usb_claim_interface(result
->usb_handle
, 0);
796 * This makes problems under Mac OS X. And is not needed
797 * under Windows. Hopefully this will not break a linux build
799 usb_set_altinterface(result
->usb_handle
, 0);
810 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
)
812 usb_close(jlink_jtag
->usb_handle
);
816 /* Send a message and receive the reply. */
817 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
)
822 result
= jlink_usb_write(jlink_jtag
, out_length
);
823 if (result
!= out_length
)
825 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
827 return ERROR_JTAG_DEVICE_ERROR
;
830 result
= jlink_usb_read(jlink_jtag
, in_length
);
831 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
833 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
835 return ERROR_JTAG_DEVICE_ERROR
;
838 if (result
== in_length
)
840 /* Must read the result from the EMU too */
841 result2
= jlink_usb_read_emu_result(jlink_jtag
);
844 LOG_ERROR("jlink_usb_read_emu_result failed "
845 "(requested=1, result=%d)", result2
);
846 return ERROR_JTAG_DEVICE_ERROR
;
849 /* Check the result itself */
850 result2
= usb_emu_result_buffer
[0];
854 /* Save the result, then remove it from return value */
855 result2
= usb_in_buffer
[result
--];
860 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
861 return ERROR_JTAG_DEVICE_ERROR
;
867 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
868 static int usb_bulk_with_retries(
869 int (*f
)(usb_dev_handle
*, int, char *, int, int),
870 usb_dev_handle
*dev
, int ep
,
871 char *bytes
, int size
, int timeout
)
873 int rc
= 0, tries
= 3, this_size
;
875 while (tries
&& size
) {
877 this_size
= f(dev
, ep
, bytes
, size
, timeout
);
889 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
890 char *bytes
, int size
, int timeout
)
892 return usb_bulk_with_retries(&usb_bulk_write
,
893 dev
, ep
, bytes
, size
, timeout
);
895 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
896 char *bytes
, int size
, int timeout
)
898 return usb_bulk_with_retries(&usb_bulk_read
,
899 dev
, ep
, bytes
, size
, timeout
);
902 /* Write data from out_buffer to USB. */
903 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
)
907 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
909 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
913 result
= usb_bulk_write_ex(jlink_jtag
->usb_handle
, JLINK_WRITE_ENDPOINT
,
914 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
916 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
918 #ifdef _DEBUG_USB_COMMS_
919 jlink_debug_buffer(usb_out_buffer
, out_length
);
924 /* Read data from USB into in_buffer. */
925 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
)
927 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
,
928 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
930 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
932 #ifdef _DEBUG_USB_COMMS_
933 jlink_debug_buffer(usb_in_buffer
, result
);
938 /* Read the result from the previous EMU cmd into result_buffer. */
939 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
)
941 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
,
942 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
945 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
947 #ifdef _DEBUG_USB_COMMS_
948 jlink_debug_buffer(usb_emu_result_buffer
, result
);
953 #ifdef _DEBUG_USB_COMMS_
954 #define BYTES_PER_LINE 16
956 static void jlink_debug_buffer(u8
*buffer
, int length
)
963 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
965 snprintf(line
, 5, "%04x", i
);
966 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
968 snprintf(s
, 4, " %02x", buffer
[j
]);
971 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)