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 2048
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_HW_RESET0 0xdc
61 #define EMU_CMD_HW_RESET1 0xdd
62 #define EMU_CMD_HW_TRST0 0xde
63 #define EMU_CMD_HW_TRST1 0xdf
65 /* max speed 12MHz v5.0 jlink */
66 #define JLINK_MAX_SPEED 12000
68 /* External interface functions */
69 static int jlink_execute_queue(void);
70 static int jlink_speed(int speed
);
71 static int jlink_speed_div(int speed
, int* khz
);
72 static int jlink_khz(int khz
, int *jtag_speed
);
73 static int jlink_register_commands(struct command_context_s
*cmd_ctx
);
74 static int jlink_init(void);
75 static int jlink_quit(void);
77 /* CLI command handler functions */
78 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
80 /* Queue command functions */
81 static void jlink_end_state(tap_state_t state
);
82 static void jlink_state_move(void);
83 static void jlink_path_move(int num_states
, tap_state_t
*path
);
84 static void jlink_runtest(int num_cycles
);
85 static void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
);
86 static void jlink_reset(int trst
, int srst
);
87 static void jlink_simple_command(u8 command
);
88 static int jlink_get_status(void);
90 /* J-Link tap buffer functions */
91 static void jlink_tap_init(void);
92 static int jlink_tap_execute(void);
93 static void jlink_tap_ensure_space(int scans
, int bits
);
94 static void jlink_tap_append_step(int tms
, int tdi
);
95 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
);
97 /* Jlink lowlevel functions */
98 typedef struct jlink_jtag
100 struct usb_dev_handle
* usb_handle
;
103 static jlink_jtag_t
*jlink_usb_open(void);
104 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
);
105 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
);
106 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
);
107 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
);
108 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
);
110 /* helper functions */
111 static int jlink_get_version_info(void);
113 #ifdef _DEBUG_USB_COMMS_
114 static void jlink_debug_buffer(u8
*buffer
, int length
);
117 static enum tap_state jlink_last_state
= TAP_RESET
;
119 static jlink_jtag_t
* jlink_jtag_handle
;
121 /***************************************************************************/
122 /* External interface implementation */
124 jtag_interface_t jlink_interface
=
127 .execute_queue
= jlink_execute_queue
,
128 .speed
= jlink_speed
,
129 .speed_div
= jlink_speed_div
,
131 .register_commands
= jlink_register_commands
,
136 static void jlink_execute_end_state(jtag_command_t
*cmd
)
138 DEBUG_JTAG_IO("end_state: %i", cmd
->cmd
.end_state
->end_state
);
140 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
141 jlink_end_state(cmd
->cmd
.end_state
->end_state
);
144 static void jlink_execute_runtest(jtag_command_t
*cmd
)
146 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
147 cmd
->cmd
.runtest
->num_cycles
,
148 cmd
->cmd
.runtest
->end_state
);
150 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
151 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
153 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
156 static void jlink_execute_statemove(jtag_command_t
*cmd
)
158 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
160 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
162 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
167 static void jlink_execute_pathmove(jtag_command_t
*cmd
)
169 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
170 cmd
->cmd
.pathmove
->num_states
,
171 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
173 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
174 cmd
->cmd
.pathmove
->path
);
177 static void jlink_execute_scan(jtag_command_t
*cmd
)
183 DEBUG_JTAG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
185 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
186 jlink_end_state(cmd
->cmd
.scan
->end_state
);
188 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
189 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
191 #ifdef _DEBUG_USB_COMMS_
192 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
194 type
= jtag_scan_type(cmd
->cmd
.scan
);
195 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
196 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
199 static void jlink_execute_reset(jtag_command_t
*cmd
)
201 DEBUG_JTAG_IO("reset trst: %i srst %i",
202 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
206 if (cmd
->cmd
.reset
->trst
== 1)
207 tap_set_state(TAP_RESET
);
209 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
212 static void jlink_execute_sleep(jtag_command_t
*cmd
)
214 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
216 jtag_sleep(cmd
->cmd
.sleep
->us
);
219 static void jlink_execute_command(jtag_command_t
*cmd
)
223 case JTAG_END_STATE
: jlink_execute_end_state(cmd
); break;
224 case JTAG_RUNTEST
: jlink_execute_runtest(cmd
); break;
225 case JTAG_STATEMOVE
: jlink_execute_statemove(cmd
); break;
226 case JTAG_PATHMOVE
: jlink_execute_pathmove(cmd
); break;
227 case JTAG_SCAN
: jlink_execute_scan(cmd
); break;
228 case JTAG_RESET
: jlink_execute_reset(cmd
); break;
229 case JTAG_SLEEP
: jlink_execute_sleep(cmd
); break;
231 LOG_ERROR("BUG: unknown JTAG command type encountered");
236 static int jlink_execute_queue(void)
238 jtag_command_t
*cmd
= jtag_command_queue
;
242 jlink_execute_command(cmd
);
246 return jlink_tap_execute();
249 /* Sets speed in kHz. */
250 static int jlink_speed(int speed
)
254 if (speed
> JLINK_MAX_SPEED
)
256 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
257 speed
, JLINK_MAX_SPEED
);
261 /* check for RTCK setting */
265 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
266 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
267 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
269 result
= jlink_usb_write(jlink_jtag_handle
, 3);
272 LOG_ERROR("J-Link setting speed failed (%d)", result
);
273 return ERROR_JTAG_DEVICE_ERROR
;
279 static int jlink_speed_div(int speed
, int* khz
)
286 static int jlink_khz(int khz
, int *jtag_speed
)
293 static int jlink_register_commands(struct command_context_s
*cmd_ctx
)
295 register_command(cmd_ctx
, NULL
, "jlink_info", jlink_handle_jlink_info_command
, COMMAND_EXEC
,
300 static int jlink_init(void)
304 jlink_jtag_handle
= jlink_usb_open();
306 if (jlink_jtag_handle
== 0)
308 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
309 return ERROR_JTAG_INIT_FAILED
;
313 while (check_cnt
< 3)
315 if (jlink_get_version_info() == ERROR_OK
)
317 /* attempt to get status */
327 LOG_INFO("J-Link initial read failed, don't worry");
330 LOG_INFO("J-Link JTAG Interface ready");
334 jlink_speed(jtag_speed
);
339 static int jlink_quit(void)
341 jlink_usb_close(jlink_jtag_handle
);
345 /***************************************************************************/
346 /* Queue command implementations */
348 static void jlink_end_state(tap_state_t state
)
350 if (tap_is_state_stable(state
))
352 tap_set_end_state(state
);
356 LOG_ERROR("BUG: %i is not a valid end state", state
);
361 /* Goes to the end state. */
362 static void jlink_state_move(void)
366 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
368 for (i
= 0; i
< 7; i
++)
370 tms
= (tms_scan
>> i
) & 1;
371 jlink_tap_append_step(tms
, 0);
374 tap_set_state(tap_get_end_state());
377 static void jlink_path_move(int num_states
, tap_state_t
*path
)
381 for (i
= 0; i
< num_states
; i
++)
383 if (path
[i
] == tap_state_transition(tap_get_state(), false))
385 jlink_tap_append_step(0, 0);
387 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
389 jlink_tap_append_step(1, 0);
393 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
397 tap_set_state(path
[i
]);
400 tap_set_end_state(tap_get_state());
403 static void jlink_runtest(int num_cycles
)
407 tap_state_t saved_end_state
= tap_get_end_state();
409 /* only do a state_move when we're not already in IDLE */
410 if (tap_get_state() != TAP_IDLE
)
412 jlink_end_state(TAP_IDLE
);
416 /* execute num_cycles */
417 for (i
= 0; i
< num_cycles
; i
++)
419 jlink_tap_append_step(0, 0);
422 /* finish in end_state */
423 jlink_end_state(saved_end_state
);
424 if (tap_get_state() != tap_get_end_state())
430 static void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
)
432 tap_state_t saved_end_state
;
434 jlink_tap_ensure_space(1, scan_size
+ 8);
436 saved_end_state
= tap_get_end_state();
438 /* Move to appropriate scan state */
439 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
441 /* Only move if we're not already there */
442 if (tap_get_state() != tap_get_end_state())
445 jlink_end_state(saved_end_state
);
448 jlink_tap_append_scan(scan_size
, buffer
, command
);
450 /* We are in Exit1, go to Pause */
451 jlink_tap_append_step(0, 0);
453 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
455 if (tap_get_state() != tap_get_end_state())
461 static void jlink_reset(int trst
, int srst
)
463 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
465 /* Signals are active low */
468 jlink_simple_command(EMU_CMD_HW_RESET1
);
469 jlink_end_state(TAP_RESET
);
474 jlink_simple_command(EMU_CMD_HW_RESET0
);
479 jlink_simple_command(EMU_CMD_HW_TRST1
);
480 jlink_end_state(TAP_RESET
);
485 jlink_simple_command(EMU_CMD_HW_TRST0
);
489 static void jlink_simple_command(u8 command
)
493 DEBUG_JTAG_IO("0x%02x", command
);
495 usb_out_buffer
[0] = command
;
496 result
= jlink_usb_write(jlink_jtag_handle
, 1);
500 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
504 static int jlink_get_status(void)
508 jlink_simple_command(EMU_CMD_GET_STATE
);
510 result
= jlink_usb_read(jlink_jtag_handle
, 8);
513 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
514 return ERROR_JTAG_DEVICE_ERROR
;
517 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
518 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
519 vref
/ 1000, vref
% 1000, \
520 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
521 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
524 LOG_ERROR("Vref too low. Check Target Power\n");
529 static int jlink_get_version_info(void)
534 /* query hardware version */
535 jlink_simple_command(EMU_CMD_VERSION
);
537 result
= jlink_usb_read(jlink_jtag_handle
, 2);
540 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n",
542 return ERROR_JTAG_DEVICE_ERROR
;
545 len
= buf_get_u32(usb_in_buffer
, 0, 16);
546 result
= jlink_usb_read(jlink_jtag_handle
, len
);
549 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n",
551 return ERROR_JTAG_DEVICE_ERROR
;
554 usb_in_buffer
[result
] = 0;
555 LOG_INFO("%s", (char *)usb_in_buffer
);
560 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
562 if (jlink_get_version_info() == ERROR_OK
)
564 /* attempt to get status */
571 /***************************************************************************/
572 /* J-Link tap functions */
574 /* 2048 is the max value we can use here */
575 #define JLINK_TAP_BUFFER_SIZE 2048
577 static unsigned tap_length
;
578 static u8 tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
579 static u8 tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
580 static u8 tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
584 int first
; /* First bit position in tdo_buffer to read */
585 int length
; /* Number of bits to read */
586 scan_command_t
*command
; /* Corresponding scan command */
588 } pending_scan_result_t
;
590 #define MAX_PENDING_SCAN_RESULTS 256
592 static int pending_scan_results_length
;
593 static pending_scan_result_t pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
597 static void jlink_tap_init(void)
600 pending_scan_results_length
= 0;
603 static void jlink_tap_ensure_space(int scans
, int bits
)
605 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
606 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
;
608 if (scans
> available_scans
|| bits
> available_bits
)
614 static void jlink_tap_append_step(int tms
, int tdi
)
617 int index
= tap_length
/ 8;
619 if (index
>= JLINK_TAP_BUFFER_SIZE
)
621 LOG_ERROR("jlink_tap_append_step: overflow");
625 int bit_index
= tap_length
% 8;
626 u8 bit
= 1 << bit_index
;
628 // we do not pad TMS, so be sure to initialize all bits
630 tms_buffer
[index
] = tdi_buffer
[index
] = 0;
633 tms_buffer
[index
] |= bit
;
635 tms_buffer
[index
] &= ~bit
;
638 tdi_buffer
[index
] |= bit
;
640 tdi_buffer
[index
] &= ~bit
;
645 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
)
647 pending_scan_result_t
*pending_scan_result
=
648 &pending_scan_results_buffer
[pending_scan_results_length
];
651 pending_scan_result
->first
= tap_length
;
652 pending_scan_result
->length
= length
;
653 pending_scan_result
->command
= command
;
654 pending_scan_result
->buffer
= buffer
;
656 for (i
= 0; i
< length
; i
++)
658 int tms
= i
< length
- 1 ? 0 : 1;
659 int tdi
= buffer
[i
/ 8] & (1 << (i
% 8));
660 jlink_tap_append_step(tms
, tdi
);
662 pending_scan_results_length
++;
665 /* Pad and send a tap sequence to the device, and receive the answer.
666 * For the purpose of padding we assume that we are in idle or pause state. */
667 static int jlink_tap_execute(void)
676 // number of full bytes (plus one if some would be left over)
677 byte_length
= TAP_SCAN_BYTES(tap_length
);
679 usb_out_buffer
[0] = EMU_CMD_HW_JTAG3
;
680 usb_out_buffer
[1] = 0;
681 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
682 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
683 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
684 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
686 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
687 tap_length
, jlink_last_state
);
689 result
= jlink_usb_message(jlink_jtag_handle
, 4 + 2 * byte_length
, byte_length
);
690 if (result
!= byte_length
)
692 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
693 result
, byte_length
);
694 return ERROR_JTAG_QUEUE_FAILED
;
697 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
699 for (i
= 0; i
< pending_scan_results_length
; i
++)
701 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[i
];
702 u8
*buffer
= pending_scan_result
->buffer
;
703 int length
= pending_scan_result
->length
;
704 int first
= pending_scan_result
->first
;
705 scan_command_t
*command
= pending_scan_result
->command
;
708 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
710 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
712 #ifdef _DEBUG_USB_COMMS_
713 jlink_debug_buffer(buffer
, byte_length
);
716 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
719 return ERROR_JTAG_QUEUE_FAILED
;
722 if (pending_scan_result
->buffer
!= NULL
)
724 free(pending_scan_result
->buffer
);
733 /*****************************************************************************/
734 /* JLink USB low-level functions */
736 static jlink_jtag_t
* jlink_usb_open()
738 struct usb_bus
*busses
;
740 struct usb_device
*dev
;
742 jlink_jtag_t
*result
;
744 result
= (jlink_jtag_t
*) malloc(sizeof(jlink_jtag_t
));
750 busses
= usb_get_busses();
752 /* find jlink_jtag device in usb bus */
754 for (bus
= busses
; bus
; bus
= bus
->next
)
756 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
758 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
))
760 result
->usb_handle
= usb_open(dev
);
762 /* usb_set_configuration required under win32 */
763 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
764 usb_claim_interface(result
->usb_handle
, 0);
768 * This makes problems under Mac OS X. And is not needed
769 * under Windows. Hopefully this will not break a linux build
771 usb_set_altinterface(result
->usb_handle
, 0);
782 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
)
784 usb_close(jlink_jtag
->usb_handle
);
788 /* Send a message and receive the reply. */
789 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
)
794 result
= jlink_usb_write(jlink_jtag
, out_length
);
795 if (result
!= out_length
)
797 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
799 return ERROR_JTAG_DEVICE_ERROR
;
802 result
= jlink_usb_read(jlink_jtag
, in_length
);
803 if ((result
!= in_length
) && (result
!= in_length
+ 1))
805 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
807 return ERROR_JTAG_DEVICE_ERROR
;
810 if (result
== in_length
)
812 /* Must read the result from the EMU too */
813 result2
= jlink_usb_read_emu_result(jlink_jtag
);
816 LOG_ERROR("jlink_usb_read_emu_result failed "
817 "(requested=1, result=%d)", result2
);
818 return ERROR_JTAG_DEVICE_ERROR
;
821 /* Check the result itself */
822 result2
= usb_emu_result_buffer
[0];
826 /* Save the result, then remove it from return value */
827 result2
= usb_in_buffer
[result
--];
832 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
833 return ERROR_JTAG_DEVICE_ERROR
;
839 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
840 static int usb_bulk_with_retries(
841 int (*f
)(usb_dev_handle
*, int, char *, int, int),
842 usb_dev_handle
*dev
, int ep
,
843 char *bytes
, int size
, int timeout
)
845 int rc
= 0, tries
= 3, this_size
;
847 while (tries
&& size
) {
849 this_size
= f(dev
, ep
, bytes
, size
, timeout
);
861 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
862 char *bytes
, int size
, int timeout
)
864 return usb_bulk_with_retries(&usb_bulk_write
,
865 dev
, ep
, bytes
, size
, timeout
);
867 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
868 char *bytes
, int size
, int timeout
)
870 return usb_bulk_with_retries(&usb_bulk_read
,
871 dev
, ep
, bytes
, size
, timeout
);
874 /* Write data from out_buffer to USB. */
875 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
)
879 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
881 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
885 result
= usb_bulk_write_ex(jlink_jtag
->usb_handle
, JLINK_WRITE_ENDPOINT
,
886 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
888 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
890 #ifdef _DEBUG_USB_COMMS_
891 jlink_debug_buffer(usb_out_buffer
, out_length
);
896 /* Read data from USB into in_buffer. */
897 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
)
899 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
,
900 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
902 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
904 #ifdef _DEBUG_USB_COMMS_
905 jlink_debug_buffer(usb_in_buffer
, result
);
910 /* Read the result from the previous EMU cmd into result_buffer. */
911 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
)
913 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
,
914 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
917 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
919 #ifdef _DEBUG_USB_COMMS_
920 jlink_debug_buffer(usb_emu_result_buffer
, result
);
925 #ifdef _DEBUG_USB_COMMS_
926 #define BYTES_PER_LINE 16
928 static void jlink_debug_buffer(u8
*buffer
, int length
)
935 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
937 snprintf(line
, 5, "%04x", i
);
938 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
940 snprintf(s
, 4, " %02x", buffer
[j
]);
943 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)