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 #define JLINK_IN_BUFFER_SIZE 8192
46 #define JLINK_OUT_BUFFER_SIZE 8192
47 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
49 /* Global USB buffers */
50 static u8 usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
51 static u8 usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
52 static u8 usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
54 /* Constants for JLink command */
55 #define EMU_CMD_VERSION 0x01
56 #define EMU_CMD_SET_SPEED 0x05
57 #define EMU_CMD_GET_STATE 0x07
58 #define EMU_CMD_HW_JTAG3 0xcf
59 #define EMU_CMD_HW_RESET0 0xdc
60 #define EMU_CMD_HW_RESET1 0xdd
61 #define EMU_CMD_HW_TRST0 0xde
62 #define EMU_CMD_HW_TRST1 0xdf
64 /* max speed 12MHz v5.0 jlink */
65 #define JLINK_MAX_SPEED 12000
67 /* External interface functions */
68 static int jlink_execute_queue(void);
69 static int jlink_speed(int speed
);
70 static int jlink_speed_div(int speed
, int* khz
);
71 static int jlink_khz(int khz
, int *jtag_speed
);
72 static int jlink_register_commands(struct command_context_s
*cmd_ctx
);
73 static int jlink_init(void);
74 static int jlink_quit(void);
76 /* CLI command handler functions */
77 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 /* Queue command functions */
80 static void jlink_end_state(tap_state_t state
);
81 static void jlink_state_move(void);
82 static void jlink_path_move(int num_states
, tap_state_t
*path
);
83 static void jlink_runtest(int num_cycles
);
84 static void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
);
85 static void jlink_reset(int trst
, int srst
);
86 static void jlink_simple_command(u8 command
);
87 static int jlink_get_status(void);
89 /* J-Link tap buffer functions */
90 static void jlink_tap_init(void);
91 static int jlink_tap_execute(void);
92 static void jlink_tap_ensure_space(int scans
, int bits
);
93 static void jlink_tap_append_step(int tms
, int tdi
);
94 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
);
96 /* Jlink lowlevel functions */
97 typedef struct jlink_jtag
99 struct usb_dev_handle
* usb_handle
;
102 static jlink_jtag_t
*jlink_usb_open(void);
103 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
);
104 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
);
105 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
);
106 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
);
107 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
);
109 /* helper functions */
110 static int jlink_get_version_info(void);
112 #ifdef _DEBUG_USB_COMMS_
113 static void jlink_debug_buffer(u8
*buffer
, int length
);
116 static jlink_jtag_t
* jlink_jtag_handle
;
118 /***************************************************************************/
119 /* External interface implementation */
121 jtag_interface_t jlink_interface
=
124 .execute_queue
= jlink_execute_queue
,
125 .speed
= jlink_speed
,
126 .speed_div
= jlink_speed_div
,
128 .register_commands
= jlink_register_commands
,
133 static int jlink_execute_queue(void)
135 jtag_command_t
*cmd
= jtag_command_queue
;
145 DEBUG_JTAG_IO("end_state: %i", cmd
->cmd
.end_state
->end_state
);
147 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
149 jlink_end_state(cmd
->cmd
.end_state
->end_state
);
154 DEBUG_JTAG_IO( "runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, \
155 cmd
->cmd
.runtest
->end_state
);
157 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
159 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
161 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
165 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
167 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
169 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
175 DEBUG_JTAG_IO("pathmove: %i states, end in %i", \
176 cmd
->cmd
.pathmove
->num_states
, \
177 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
179 jlink_path_move(cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
);
183 DEBUG_JTAG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
185 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
187 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
, type
, buffer
, scan_size
, cmd
->cmd
.scan
);
201 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
205 if (cmd
->cmd
.reset
->trst
== 1)
207 tap_set_state(TAP_RESET
);
209 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
213 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
215 jtag_sleep(cmd
->cmd
.sleep
->us
);
219 LOG_ERROR("BUG: unknown JTAG command type encountered");
225 return jlink_tap_execute();
228 /* Sets speed in kHz. */
229 static int jlink_speed(int speed
)
233 if (speed
> JLINK_MAX_SPEED
)
235 LOG_INFO("Ignoring speed request: %dkHz exceeds %dkHz maximum",
236 speed
, JLINK_MAX_SPEED
);
240 /* check for RTCK setting */
244 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
245 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
246 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
248 result
= jlink_usb_write(jlink_jtag_handle
, 3);
251 LOG_ERROR("J-Link setting speed failed (%d)", result
);
252 return ERROR_JTAG_DEVICE_ERROR
;
258 static int jlink_speed_div(int speed
, int* khz
)
265 static int jlink_khz(int khz
, int *jtag_speed
)
272 static int jlink_register_commands(struct command_context_s
*cmd_ctx
)
274 register_command(cmd_ctx
, NULL
, "jlink_info", jlink_handle_jlink_info_command
, COMMAND_EXEC
,
279 static int jlink_init(void)
283 jlink_jtag_handle
= jlink_usb_open();
285 if (jlink_jtag_handle
== 0)
287 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
288 return ERROR_JTAG_INIT_FAILED
;
292 while (check_cnt
< 3)
294 if (jlink_get_version_info() == ERROR_OK
)
296 /* attempt to get status */
306 LOG_INFO("J-Link initial read failed, don't worry");
309 LOG_INFO("J-Link JTAG Interface ready");
317 static int jlink_quit(void)
319 jlink_usb_close(jlink_jtag_handle
);
323 /***************************************************************************/
324 /* Queue command implementations */
326 static void jlink_end_state(tap_state_t state
)
328 if (tap_is_state_stable(state
))
330 tap_set_end_state(state
);
334 LOG_ERROR("BUG: %i is not a valid end state", state
);
339 /* Goes to the end state. */
340 static void jlink_state_move(void)
344 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
346 for (i
= 0; i
< 7; i
++)
348 tms
= (tms_scan
>> i
) & 1;
349 jlink_tap_append_step(tms
, 0);
352 tap_set_state(tap_get_end_state());
355 static void jlink_path_move(int num_states
, tap_state_t
*path
)
359 for (i
= 0; i
< num_states
; i
++)
361 if (path
[i
] == tap_state_transition(tap_get_state(), false))
363 jlink_tap_append_step(0, 0);
365 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
367 jlink_tap_append_step(1, 0);
371 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
375 tap_set_state(path
[i
]);
378 tap_set_end_state(tap_get_state());
381 static void jlink_runtest(int num_cycles
)
385 tap_state_t saved_end_state
= tap_get_end_state();
387 /* only do a state_move when we're not already in IDLE */
388 if (tap_get_state() != TAP_IDLE
)
390 jlink_end_state(TAP_IDLE
);
394 /* execute num_cycles */
395 for (i
= 0; i
< num_cycles
; i
++)
397 jlink_tap_append_step(0, 0);
400 /* finish in end_state */
401 jlink_end_state(saved_end_state
);
402 if (tap_get_state() != tap_get_end_state())
408 static void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
)
410 tap_state_t saved_end_state
;
412 jlink_tap_ensure_space(1, scan_size
+ 8);
414 saved_end_state
= tap_get_end_state();
416 /* Move to appropriate scan state */
417 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
419 /* Only move if we're not already there */
420 if (tap_get_state() != tap_get_end_state())
423 jlink_end_state(saved_end_state
);
426 jlink_tap_append_scan(scan_size
, buffer
, command
);
428 /* We are in Exit1, go to Pause */
429 jlink_tap_append_step(0, 0);
431 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
433 if (tap_get_state() != tap_get_end_state())
439 static void jlink_reset(int trst
, int srst
)
441 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
443 /* Signals are active low */
446 jlink_simple_command(EMU_CMD_HW_RESET1
);
450 jlink_simple_command(EMU_CMD_HW_RESET0
);
455 jlink_simple_command(EMU_CMD_HW_TRST1
);
459 jlink_simple_command(EMU_CMD_HW_TRST0
);
463 static void jlink_simple_command(u8 command
)
467 DEBUG_JTAG_IO("0x%02x", command
);
469 usb_out_buffer
[0] = command
;
470 result
= jlink_usb_write(jlink_jtag_handle
, 1);
474 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
478 static int jlink_get_status(void)
482 jlink_simple_command(EMU_CMD_GET_STATE
);
484 result
= jlink_usb_read(jlink_jtag_handle
, 8);
487 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
488 return ERROR_JTAG_DEVICE_ERROR
;
491 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
492 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
493 vref
/ 1000, vref
% 1000, \
494 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
495 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
498 LOG_ERROR("Vref too low. Check Target Power\n");
503 static int jlink_get_version_info(void)
508 /* query hardware version */
509 jlink_simple_command(EMU_CMD_VERSION
);
511 result
= jlink_usb_read(jlink_jtag_handle
, 2);
514 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n",
516 return ERROR_JTAG_DEVICE_ERROR
;
519 len
= buf_get_u32(usb_in_buffer
, 0, 16);
520 result
= jlink_usb_read(jlink_jtag_handle
, len
);
523 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n",
525 return ERROR_JTAG_DEVICE_ERROR
;
528 usb_in_buffer
[result
] = 0;
529 LOG_INFO("%s", (char *)usb_in_buffer
);
534 static int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
536 if (jlink_get_version_info() == ERROR_OK
)
538 /* attempt to get status */
545 /***************************************************************************/
546 /* J-Link tap functions */
548 /* 2048 is the max value we can use here */
549 #define JLINK_TAP_BUFFER_SIZE 2048
551 static unsigned tap_length
;
552 static u8 tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
553 static u8 tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
554 static u8 tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
558 int first
; /* First bit position in tdo_buffer to read */
559 int length
; /* Number of bits to read */
560 scan_command_t
*command
; /* Corresponding scan command */
562 } pending_scan_result_t
;
564 #define MAX_PENDING_SCAN_RESULTS 256
566 static int pending_scan_results_length
;
567 static pending_scan_result_t pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
571 static void jlink_tap_init(void)
574 pending_scan_results_length
= 0;
577 static void jlink_tap_ensure_space(int scans
, int bits
)
579 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
580 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
;
582 if (scans
> available_scans
|| bits
> available_bits
)
588 static void jlink_tap_append_step(int tms
, int tdi
)
591 int index
= tap_length
/ 8;
593 if (index
>= JLINK_TAP_BUFFER_SIZE
)
595 LOG_ERROR("jlink_tap_append_step: overflow");
599 int bit_index
= tap_length
% 8;
600 u8 bit
= 1 << bit_index
;
603 tms_buffer
[index
] |= bit
;
605 tms_buffer
[index
] &= ~bit
;
608 tdi_buffer
[index
] |= bit
;
610 tdi_buffer
[index
] &= ~bit
;
615 static void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
)
617 pending_scan_result_t
*pending_scan_result
=
618 &pending_scan_results_buffer
[pending_scan_results_length
];
621 pending_scan_result
->first
= tap_length
;
622 pending_scan_result
->length
= length
;
623 pending_scan_result
->command
= command
;
624 pending_scan_result
->buffer
= buffer
;
626 for (i
= 0; i
< length
; i
++)
628 int tms
= i
< length
- 1 ? 0 : 1;
629 int tdi
= buffer
[i
/ 8] & (1 << (i
% 8));
630 jlink_tap_append_step(tms
, tdi
);
632 pending_scan_results_length
++;
635 /* Pad and send a tap sequence to the device, and receive the answer.
636 * For the purpose of padding we assume that we are in idle or pause state. */
637 static int jlink_tap_execute(void)
648 /* Pad last byte so that tap_length is divisible by 8 */
649 while (tap_length
% 8 != 0)
651 /* More of the last TMS value keeps us in the same state,
652 * analogous to free-running JTAG interfaces. */
653 jlink_tap_append_step(last_tms
, 0);
656 byte_length
= tap_length
/ 8;
658 usb_out_buffer
[0] = EMU_CMD_HW_JTAG3
;
659 usb_out_buffer
[1] = 0;
660 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
661 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
664 for (i
= 0; i
< byte_length
; i
++)
666 usb_out_buffer
[tms_offset
+ i
] = tms_buffer
[i
];
669 tdi_offset
= tms_offset
+ byte_length
;
670 for (i
= 0; i
< byte_length
; i
++)
672 usb_out_buffer
[tdi_offset
+ i
] = tdi_buffer
[i
];
675 result
= jlink_usb_message(jlink_jtag_handle
, 4 + 2 * byte_length
, byte_length
);
677 if (result
!= byte_length
)
679 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
680 result
, byte_length
);
681 return ERROR_JTAG_QUEUE_FAILED
;
684 for (i
= 0; i
< byte_length
; i
++)
685 tdo_buffer
[i
] = usb_in_buffer
[i
];
687 for (i
= 0; i
< pending_scan_results_length
; i
++)
689 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[i
];
690 u8
*buffer
= pending_scan_result
->buffer
;
691 int length
= pending_scan_result
->length
;
692 int first
= pending_scan_result
->first
;
693 scan_command_t
*command
= pending_scan_result
->command
;
696 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
698 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
700 #ifdef _DEBUG_USB_COMMS_
701 jlink_debug_buffer(buffer
, byte_length
);
704 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
707 return ERROR_JTAG_QUEUE_FAILED
;
710 if (pending_scan_result
->buffer
!= NULL
)
712 free(pending_scan_result
->buffer
);
721 /*****************************************************************************/
722 /* JLink USB low-level functions */
724 static jlink_jtag_t
* jlink_usb_open()
726 struct usb_bus
*busses
;
728 struct usb_device
*dev
;
730 jlink_jtag_t
*result
;
732 result
= (jlink_jtag_t
*) malloc(sizeof(jlink_jtag_t
));
738 busses
= usb_get_busses();
740 /* find jlink_jtag device in usb bus */
742 for (bus
= busses
; bus
; bus
= bus
->next
)
744 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
746 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
))
748 result
->usb_handle
= usb_open(dev
);
750 /* usb_set_configuration required under win32 */
751 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
752 usb_claim_interface(result
->usb_handle
, 0);
756 * This makes problems under Mac OS X. And is not needed
757 * under Windows. Hopefully this will not break a linux build
759 usb_set_altinterface(result
->usb_handle
, 0);
770 static void jlink_usb_close(jlink_jtag_t
*jlink_jtag
)
772 usb_close(jlink_jtag
->usb_handle
);
776 /* Send a message and receive the reply. */
777 static int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
)
782 result
= jlink_usb_write(jlink_jtag
, out_length
);
783 if (result
!= out_length
)
785 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
787 return ERROR_JTAG_DEVICE_ERROR
;
790 result
= jlink_usb_read(jlink_jtag
, in_length
);
791 if ((result
!= in_length
) && (result
!= in_length
+ 1))
793 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
795 return ERROR_JTAG_DEVICE_ERROR
;
798 if (result
== in_length
)
800 /* Must read the result from the EMU too */
801 result2
= jlink_usb_read_emu_result(jlink_jtag
);
804 LOG_ERROR("jlink_usb_read_emu_result failed "
805 "(requested=1, result=%d)", result2
);
806 return ERROR_JTAG_DEVICE_ERROR
;
809 /* Check the result itself */
810 result2
= usb_emu_result_buffer
[0];
814 /* Save the result, then remove it from return value */
815 result2
= usb_in_buffer
[result
--];
820 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
821 return ERROR_JTAG_DEVICE_ERROR
;
827 /* calls the given usb_bulk_* function, allowing for the data to trickle in with some timeouts */
828 static int usb_bulk_with_retries(
829 int (*f
)(usb_dev_handle
*, int, char *, int, int),
830 usb_dev_handle
*dev
, int ep
,
831 char *bytes
, int size
, int timeout
)
833 int rc
= 0, tries
= 3, this_size
;
835 while (tries
&& size
) {
837 this_size
= f(dev
, ep
, bytes
, size
, timeout
);
849 static inline int usb_bulk_write_ex(usb_dev_handle
*dev
, int ep
,
850 char *bytes
, int size
, int timeout
)
852 return usb_bulk_with_retries(&usb_bulk_write
,
853 dev
, ep
, bytes
, size
, timeout
);
855 static inline int usb_bulk_read_ex(usb_dev_handle
*dev
, int ep
,
856 char *bytes
, int size
, int timeout
)
858 return usb_bulk_with_retries(&usb_bulk_read
,
859 dev
, ep
, bytes
, size
, timeout
);
862 /* Write data from out_buffer to USB. */
863 static int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
)
867 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
869 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
873 result
= usb_bulk_write_ex(jlink_jtag
->usb_handle
, JLINK_WRITE_ENDPOINT
,
874 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
876 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
878 #ifdef _DEBUG_USB_COMMS_
879 jlink_debug_buffer(usb_out_buffer
, out_length
);
884 /* Read data from USB into in_buffer. */
885 static int jlink_usb_read(jlink_jtag_t
*jlink_jtag
, int expected_size
)
887 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
,
888 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
890 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
892 #ifdef _DEBUG_USB_COMMS_
893 jlink_debug_buffer(usb_in_buffer
, result
);
898 /* Read the result from the previous EMU cmd into result_buffer. */
899 static int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
)
901 int result
= usb_bulk_read_ex(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
,
902 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
905 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
907 #ifdef _DEBUG_USB_COMMS_
908 jlink_debug_buffer(usb_emu_result_buffer
, result
);
913 #ifdef _DEBUG_USB_COMMS_
914 #define BYTES_PER_LINE 16
916 static void jlink_debug_buffer(u8
*buffer
, int length
)
923 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
925 snprintf(line
, 5, "%04x", i
);
926 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
928 snprintf(s
, 4, " %02x", buffer
[j
]);
931 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)