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"
41 #define JLINK_WRITE_ENDPOINT 0x02
42 #define JLINK_READ_ENDPOINT 0x81
44 #define JLINK_USB_TIMEOUT 1000
46 // See Section 1.3.2 of the Segger JLink USB protocol manual
47 #define JLINK_IN_BUFFER_SIZE 2048
48 #define JLINK_OUT_BUFFER_SIZE 2*2048+4
49 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
51 /* Global USB buffers */
52 static u8 usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
53 static u8 usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
54 static u8 usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
56 /* Constants for JLink command */
57 #define EMU_CMD_VERSION 0x01
58 #define EMU_CMD_SET_SPEED 0x05
59 #define EMU_CMD_GET_STATE 0x07
60 #define EMU_CMD_HW_JTAG3 0xcf
61 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
62 #define EMU_CMD_HW_RESET0 0xdc
63 #define EMU_CMD_HW_RESET1 0xdd
64 #define EMU_CMD_HW_TRST0 0xde
65 #define EMU_CMD_HW_TRST1 0xdf
66 #define EMU_CMD_GET_CAPS 0xe8
68 /* max speed 12MHz v5.0 jlink */
69 #define JLINK_MAX_SPEED 12000
71 /* External interface functions */
72 static int jlink_execute_queue(void);
73 static int jlink_speed(int speed
);
74 static int jlink_speed_div(int speed
, int* khz
);
75 static int jlink_khz(int khz
, int *jtag_speed
);
76 static int jlink_register_commands(struct command_context_s
*cmd_ctx
);
77 static int jlink_init(void);
78 static int jlink_quit(void);
80 /* CLI command handler functions */
81 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
83 /* Queue command functions */
84 static void jlink_end_state(tap_state_t state
);
85 static void jlink_state_move(void);
86 static void jlink_path_move(int num_states
, tap_state_t
*path
);
87 static void jlink_runtest(int num_cycles
);
88 static void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
);
89 static void jlink_reset(int trst
, int srst
);
90 static void jlink_simple_command(u8 command
);
91 static int jlink_get_status(void);
93 /* J-Link tap buffer functions */
94 static void jlink_tap_init(void);
95 static int jlink_tap_execute(void);
96 static void jlink_tap_ensure_space(int scans
, int bits
);
97 static void jlink_tap_append_step(int tms
, int tdi
);
98 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
);
100 /* Jlink lowlevel functions */
101 typedef struct jlink_jtag
103 struct usb_dev_handle
* usb_handle
;
106 static jlink_jtag_t
*jlink_usb_open(void);
107 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
);
108 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
);
109 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
);
110 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
);
111 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
);
113 /* helper functions */
114 static int jlink_get_version_info(void);
116 #ifdef _DEBUG_USB_COMMS_
117 static void jlink_debug_buffer(u8
*buffer
, int length
);
120 static enum tap_state jlink_last_state
= TAP_RESET
;
122 static jlink_jtag_t
* jlink_jtag_handle
;
124 /***************************************************************************/
125 /* External interface implementation */
127 jtag_interface_t jlink_interface
=
130 .execute_queue
= jlink_execute_queue
,
131 .speed
= jlink_speed
,
132 .speed_div
= jlink_speed_div
,
134 .register_commands
= jlink_register_commands
,
139 static void jlink_execute_end_state(jtag_command_t
*cmd
)
141 DEBUG_JTAG_IO("end_state: %i", cmd
->cmd
.end_state
->end_state
);
143 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
144 jlink_end_state(cmd
->cmd
.end_state
->end_state
);
147 static void jlink_execute_runtest(jtag_command_t
*cmd
)
149 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
150 cmd
->cmd
.runtest
->num_cycles
,
151 cmd
->cmd
.runtest
->end_state
);
153 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
154 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
156 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
159 static void jlink_execute_statemove(jtag_command_t
*cmd
)
161 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
163 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
165 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
170 static void jlink_execute_pathmove(jtag_command_t
*cmd
)
172 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
173 cmd
->cmd
.pathmove
->num_states
,
174 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
176 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
177 cmd
->cmd
.pathmove
->path
);
180 static void jlink_execute_scan(jtag_command_t
*cmd
)
186 DEBUG_JTAG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
188 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
189 jlink_end_state(cmd
->cmd
.scan
->end_state
);
191 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
192 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
194 #ifdef _DEBUG_USB_COMMS_
195 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
197 type
= jtag_scan_type(cmd
->cmd
.scan
);
198 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
199 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
202 static void jlink_execute_reset(jtag_command_t
*cmd
)
204 DEBUG_JTAG_IO("reset trst: %i srst %i",
205 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
209 if (cmd
->cmd
.reset
->trst
== 1)
210 tap_set_state(TAP_RESET
);
212 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
215 static void jlink_execute_sleep(jtag_command_t
*cmd
)
217 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
219 jtag_sleep(cmd
->cmd
.sleep
->us
);
222 static void jlink_execute_command(jtag_command_t
*cmd
)
226 case JTAG_END_STATE
: jlink_execute_end_state(cmd
); break;
227 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
228 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
229 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
230 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
231 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
232 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
234 LOG_ERROR("BUG: unknown JTAG command type encountered");
239 static int jlink_execute_queue(void)
241 jtag_command_t
*cmd
= jtag_command_queue
;
245 jlink_execute_command(cmd
);
249 return jlink_tap_execute();
252 /* Sets speed in kHz. */
253 static int jlink_speed(int speed
)
257 if (speed
> JLINK_MAX_SPEED
)
259 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
260 speed
, JLINK_MAX_SPEED
);
264 /* check for RTCK setting */
268 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
269 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
270 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
272 result
= jlink_usb_write(jlink_jtag_handle
, 3);
275 LOG_ERROR("J-Link setting speed failed (%d)", result
);
276 return ERROR_JTAG_DEVICE_ERROR
;
282 static int jlink_speed_div(int speed
, int* khz
)
289 static int jlink_khz(int khz
, int *jtag_speed
)
296 static int jlink_register_commands(struct command_context_s
*cmd_ctx
)
298 register_command(cmd_ctx
, NULL
, "jlink_info", jlink_handle_jlink_info_command
, COMMAND_EXEC
,
303 static int jlink_init(void)
307 jlink_jtag_handle
= jlink_usb_open();
309 if (jlink_jtag_handle
== 0)
311 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
312 return ERROR_JTAG_INIT_FAILED
;
316 while (check_cnt
< 3)
318 if (jlink_get_version_info() == ERROR_OK
)
320 /* attempt to get status */
330 LOG_INFO("J-Link initial read failed, don't worry");
333 LOG_INFO("J-Link JTAG Interface ready");
337 jlink_speed(jtag_speed
);
342 static int jlink_quit(void)
344 jlink_usb_close(jlink_jtag_handle
);
348 /***************************************************************************/
349 /* Queue command implementations */
351 static void jlink_end_state(tap_state_t state
)
353 if (tap_is_state_stable(state
))
355 tap_set_end_state(state
);
359 LOG_ERROR("BUG: %i is not a valid end state", state
);
364 /* Goes to the end state. */
365 static void jlink_state_move(void)
369 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
371 for (i
= 0; i
< 7; i
++)
373 tms
= (tms_scan
>> i
) & 1;
374 jlink_tap_append_step(tms
, 0);
377 tap_set_state(tap_get_end_state());
380 static void jlink_path_move(int num_states
, tap_state_t
*path
)
384 for (i
= 0; i
< num_states
; i
++)
386 if (path
[i
] == tap_state_transition(tap_get_state(), false))
388 jlink_tap_append_step(0, 0);
390 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
392 jlink_tap_append_step(1, 0);
396 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
400 tap_set_state(path
[i
]);
403 tap_set_end_state(tap_get_state());
406 static void jlink_runtest(int num_cycles
)
410 tap_state_t saved_end_state
= tap_get_end_state();
412 /* only do a state_move when we're not already in IDLE */
413 if (tap_get_state() != TAP_IDLE
)
415 jlink_end_state(TAP_IDLE
);
419 /* execute num_cycles */
420 for (i
= 0; i
< num_cycles
; i
++)
422 jlink_tap_append_step(0, 0);
425 /* finish in end_state */
426 jlink_end_state(saved_end_state
);
427 if (tap_get_state() != tap_get_end_state())
433 static void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
)
435 tap_state_t saved_end_state
;
437 jlink_tap_ensure_space(1, scan_size
+ 8);
439 saved_end_state
= tap_get_end_state();
441 /* Move to appropriate scan state */
442 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
444 /* Only move if we're not already there */
445 if (tap_get_state() != tap_get_end_state())
448 jlink_end_state(saved_end_state
);
451 jlink_tap_append_scan(scan_size
, buffer
, command
);
453 /* We are in Exit1, go to Pause */
454 jlink_tap_append_step(0, 0);
456 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
458 if (tap_get_state() != tap_get_end_state())
464 static void jlink_reset(int trst
, int srst
)
466 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
468 /* Signals are active low */
471 jlink_simple_command(EMU_CMD_HW_RESET1
);
472 jlink_end_state(TAP_RESET
);
477 jlink_simple_command(EMU_CMD_HW_RESET0
);
482 jlink_simple_command(EMU_CMD_HW_TRST1
);
483 jlink_end_state(TAP_RESET
);
488 jlink_simple_command(EMU_CMD_HW_TRST0
);
492 static void jlink_simple_command(u8 command
)
496 DEBUG_JTAG_IO("0x%02x", command
);
498 usb_out_buffer
[0] = command
;
499 result
= jlink_usb_write(jlink_jtag_handle
, 1);
503 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
507 static int jlink_get_status(void)
511 jlink_simple_command(EMU_CMD_GET_STATE
);
513 result
= jlink_usb_read(jlink_jtag_handle
, 8);
516 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
517 return ERROR_JTAG_DEVICE_ERROR
;
520 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
521 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
522 vref
/ 1000, vref
% 1000, \
523 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
524 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
527 LOG_ERROR("Vref too low. Check Target Power\n");
532 static int jlink_get_version_info(void)
536 u32 jlink_caps
, jlink_max_size
;
538 /* query hardware version */
539 jlink_simple_command(EMU_CMD_VERSION
);
541 result
= jlink_usb_read(jlink_jtag_handle
, 2);
544 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
545 return ERROR_JTAG_DEVICE_ERROR
;
548 len
= buf_get_u32(usb_in_buffer
, 0, 16);
549 result
= jlink_usb_read(jlink_jtag_handle
, len
);
552 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
553 return ERROR_JTAG_DEVICE_ERROR
;
556 usb_in_buffer
[result
] = 0;
557 LOG_INFO("%s", (char *)usb_in_buffer
);
559 /* query hardware capabilities */
560 jlink_simple_command(EMU_CMD_GET_CAPS
);
562 result
= jlink_usb_read(jlink_jtag_handle
, 4);
565 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)\n", result
);
566 return ERROR_JTAG_DEVICE_ERROR
;
569 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
570 LOG_INFO("JLink caps 0x%x", jlink_caps
);
573 /* query hardware maximum memory block */
574 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
576 result
= jlink_usb_read(jlink_jtag_handle
, 4);
579 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)\n", result
);
580 return ERROR_JTAG_DEVICE_ERROR
;
583 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
584 LOG_INFO("JLink max mem block %i", jlink_max_size
);
590 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
592 if (jlink_get_version_info() == ERROR_OK
)
594 /* attempt to get status */
601 /***************************************************************************/
602 /* J-Link tap functions */
604 /* 2048 is the max value we can use here */
605 #define JLINK_TAP_BUFFER_SIZE 2048
607 static unsigned tap_length
;
608 static u8 tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
609 static u8 tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
610 static u8 tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
614 int first
; /* First bit position in tdo_buffer to read */
615 int length
; /* Number of bits to read */
616 scan_command_t
*command
; /* Corresponding scan command */
618 } pending_scan_result_t
;
620 #define MAX_PENDING_SCAN_RESULTS 256
622 static int pending_scan_results_length
;
623 static pending_scan_result_t pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
625 static void jlink_tap_init(void)
628 pending_scan_results_length
= 0;
631 static void jlink_tap_ensure_space(int scans
, int bits
)
633 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
634 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
;
636 if (scans
> available_scans
|| bits
> available_bits
)
642 static void jlink_tap_append_step(int tms
, int tdi
)
644 int index
= tap_length
/ 8;
646 if (index
>= JLINK_TAP_BUFFER_SIZE
)
648 LOG_ERROR("jlink_tap_append_step: overflow");
652 int bit_index
= tap_length
% 8;
653 u8 bit
= 1 << bit_index
;
655 // we do not pad TMS, so be sure to initialize all bits
657 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
660 tms_buffer
[index
] |= bit
;
662 tms_buffer
[index
] &= ~bit
;
665 tdi_buffer
[index
] |= bit
;
667 tdi_buffer
[index
] &= ~bit
;
672 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
)
674 pending_scan_result_t
*pending_scan_result
=
675 &pending_scan_results_buffer
[pending_scan_results_length
];
678 pending_scan_result
->first
= tap_length
;
679 pending_scan_result
->length
= length
;
680 pending_scan_result
->command
= command
;
681 pending_scan_result
->buffer
= buffer
;
683 for (i
= 0; i
< length
; i
++)
685 int tms
= i
< length
- 1 ? 0 : 1;
686 int tdi
= buffer
[i
/ 8] & (1 << (i
% 8));
687 jlink_tap_append_step(tms
, tdi
);
689 pending_scan_results_length
++;
692 /* Pad and send a tap sequence to the device, and receive the answer.
693 * For the purpose of padding we assume that we are in idle or pause state. */
694 static int jlink_tap_execute(void)
703 // number of full bytes (plus one if some would be left over)
704 byte_length
= TAP_SCAN_BYTES(tap_length
);
706 usb_out_buffer
[0] = EMU_CMD_HW_JTAG3
;
707 usb_out_buffer
[1] = 0;
708 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
709 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
710 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
711 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
713 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
714 tap_length
, jlink_last_state
);
716 result
= jlink_usb_message(jlink_jtag_handle
, 4 + 2 * byte_length
, byte_length
);
717 if (result
!= byte_length
)
719 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)", result
, byte_length
);
721 return ERROR_JTAG_QUEUE_FAILED
;
724 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
726 for (i
= 0; i
< pending_scan_results_length
; i
++)
728 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[i
];
729 u8
*buffer
= pending_scan_result
->buffer
;
730 int length
= pending_scan_result
->length
;
731 int first
= pending_scan_result
->first
;
732 scan_command_t
*command
= pending_scan_result
->command
;
735 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
737 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
739 #ifdef _DEBUG_USB_COMMS_
740 jlink_debug_buffer(buffer
, byte_length
);
743 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
746 return ERROR_JTAG_QUEUE_FAILED
;
749 if (pending_scan_result
->buffer
!= NULL
)
751 free(pending_scan_result
->buffer
);
759 /*****************************************************************************/
760 /* JLink USB low-level functions */
762 static jlink_jtag_t
* jlink_usb_open()
764 struct usb_bus
*busses
;
766 struct usb_device
*dev
;
768 jlink_jtag_t
*result
;
770 result
= (jlink_jtag_t
*) malloc(sizeof(jlink_jtag_t
));
776 busses
= usb_get_busses();
778 /* find jlink_jtag device in usb bus */
780 for (bus
= busses
; bus
; bus
= bus
->next
)
782 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
784 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
))
786 result
->usb_handle
= usb_open(dev
);
788 /* usb_set_configuration required under win32 */
789 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
790 usb_claim_interface(result
->usb_handle
, 0);
794 * This makes problems under Mac OS X. And is not needed
795 * under Windows. Hopefully this will not break a linux build
797 usb_set_altinterface(result
->usb_handle
, 0);
808 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
)
810 usb_close(jlink_jtag
->usb_handle
);
814 /* Send a message and receive the reply. */
815 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
)
820 result
= jlink_usb_write(jlink_jtag
, out_length
);
821 if (result
!= out_length
)
823 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
825 return ERROR_JTAG_DEVICE_ERROR
;
828 result
= jlink_usb_read(jlink_jtag
, in_length
);
829 if ((result
!= in_length
) && (result
!= (in_length
+ 1)))
831 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
833 return ERROR_JTAG_DEVICE_ERROR
;
836 if (result
== in_length
)
838 /* Must read the result from the EMU too */
839 result2
= jlink_usb_read_emu_result(jlink_jtag
);
842 LOG_ERROR("jlink_usb_read_emu_result failed "
843 "(requested=1, result=%d)", result2
);
844 return ERROR_JTAG_DEVICE_ERROR
;
847 /* Check the result itself */
848 result2
= usb_emu_result_buffer
[0];
852 /* Save the result, then remove it from return value */
853 result2
= usb_in_buffer
[result
--];
858 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
859 return ERROR_JTAG_DEVICE_ERROR
;
865 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
866 static int usb_bulk_with_retries(
867 int (*f
)(usb_dev_handle
*, int, char *, int, int),
868 usb_dev_handle
*dev
, int ep
,
869 char *bytes
, int size
, int timeout
)
871 int tries
= 3, count
= 0;
873 while (tries
&& (count
< size
))
875 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
878 else if ((-ETIMEDOUT
!= result
) || !--tries
)
884 static int wrap_usb_bulk_write(usb_dev_handle
*dev
, int ep
,
885 char *buff
, int size
, int timeout
)
887 /* usb_bulk_write() takes const char *buff */
888 return usb_bulk_write(dev
, ep
, buff
, size
, timeout
);
891 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
892 char *bytes
, int size
, int timeout
)
894 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
895 dev
, ep
, bytes
, size
, timeout
);
898 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
899 char *bytes
, int size
, int timeout
)
901 return usb_bulk_with_retries(&usb_bulk_read
,
902 dev
, ep
, bytes
, size
, timeout
);
905 /* Write data from out_buffer to USB. */
906 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
)
910 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
912 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
916 result
= usb_bulk_write_ex(jlink_jtag
->usb_handle
, JLINK_WRITE_ENDPOINT
,
917 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
919 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
921 #ifdef _DEBUG_USB_COMMS_
922 jlink_debug_buffer(usb_out_buffer
, out_length
);
927 /* Read data from USB into in_buffer. */
928 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
)
930 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
,
931 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
933 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
935 #ifdef _DEBUG_USB_COMMS_
936 jlink_debug_buffer(usb_in_buffer
, result
);
941 /* Read the result from the previous EMU cmd into result_buffer. */
942 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
)
944 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
,
945 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
948 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
950 #ifdef _DEBUG_USB_COMMS_
951 jlink_debug_buffer(usb_emu_result_buffer
, result
);
956 #ifdef _DEBUG_USB_COMMS_
957 #define BYTES_PER_LINE 16
959 static void jlink_debug_buffer(u8
*buffer
, int length
)
966 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
968 snprintf(line
, 5, "%04x", i
);
969 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
971 snprintf(s
, 4, " %02x", buffer
[j
]);
974 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)