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 * Copyright (C) 2011 by Jean-Christophe PLAGNIOL-VIILARD *
9 * plagnioj@jcrosoft.com *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
31 #include <jtag/interface.h>
32 #include <jtag/commands.h>
33 #include "libusb_common.h"
35 /* See Segger's public documentation:
36 * Reference manual for J-Link USB Protocol
37 * Document RM08001-R6 Date: June 16, 2009
38 * (Or newer, with some SWD information).
39 * http://www.segger.com/cms/admin/uploads/productDocs/RM08001_JLinkUSBProtocol.pdf
43 * The default pid of the segger is 0x0101
44 * But when you change the USB Address it will also
46 * pid = ( usb_address > 0x4) ? 0x0101 : (0x101 + usb_address)
49 #define VID 0x1366, 0x1366, 0x1366, 0x1366
50 #define PID 0x0101, 0x0102, 0x0103, 0x0104
52 #define JLINK_WRITE_ENDPOINT 0x02
53 #define JLINK_READ_ENDPOINT 0x81
55 static unsigned int jlink_write_ep
= JLINK_WRITE_ENDPOINT
;
56 static unsigned int jlink_read_ep
= JLINK_READ_ENDPOINT
;
57 static unsigned int jlink_hw_jtag_version
= 2;
59 #define JLINK_USB_TIMEOUT 1000
61 /* See Section 3.3.2 of the Segger JLink USB protocol manual */
62 /* 2048 is the max value we can use here */
63 #define JLINK_TAP_BUFFER_SIZE 2048
64 /*#define JLINK_TAP_BUFFER_SIZE 256*/
65 /*#define JLINK_TAP_BUFFER_SIZE 384*/
67 #define JLINK_IN_BUFFER_SIZE 2048
68 #define JLINK_OUT_BUFFER_SIZE (2*2048 + 4)
69 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
71 /* Global USB buffers */
72 static uint8_t usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
73 static uint8_t usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
74 static uint8_t usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
76 /* Constants for JLink command */
77 #define EMU_CMD_VERSION 0x01
78 #define EMU_CMD_SET_SPEED 0x05
79 #define EMU_CMD_GET_STATE 0x07
80 #define EMU_CMD_HW_CLOCK 0xc8
81 #define EMU_CMD_HW_TMS0 0xc9
82 #define EMU_CMD_HW_TMS1 0xca
83 #define EMU_CMD_HW_JTAG2 0xce
84 #define EMU_CMD_HW_JTAG3 0xcf
85 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
86 #define EMU_CMD_HW_RESET0 0xdc
87 #define EMU_CMD_HW_RESET1 0xdd
88 #define EMU_CMD_HW_TRST0 0xde
89 #define EMU_CMD_HW_TRST1 0xdf
90 #define EMU_CMD_GET_CAPS 0xe8
91 #define EMU_CMD_GET_HW_VERSION 0xf0
92 #define EMU_CMD_READ_CONFIG 0xf2
93 #define EMU_CMD_WRITE_CONFIG 0xf3
95 /* bits return from EMU_CMD_GET_CAPS */
96 #define EMU_CAP_RESERVED_1 0
97 #define EMU_CAP_GET_HW_VERSION 1
98 #define EMU_CAP_WRITE_DCC 2
99 #define EMU_CAP_ADAPTIVE_CLOCKING 3
100 #define EMU_CAP_READ_CONFIG 4
101 #define EMU_CAP_WRITE_CONFIG 5
102 #define EMU_CAP_TRACE 6
103 #define EMU_CAP_WRITE_MEM 7
104 #define EMU_CAP_READ_MEM 8
105 #define EMU_CAP_SPEED_INFO 9
106 #define EMU_CAP_EXEC_CODE 10
107 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11
108 #define EMU_CAP_GET_HW_INFO 12
109 #define EMU_CAP_SET_KS_POWER 13
110 #define EMU_CAP_RESET_STOP_TIMED 14
111 #define EMU_CAP_RESERVED_2 15
112 #define EMU_CAP_MEASURE_RTCK_REACT 16
113 #define EMU_CAP_SELECT_IF 17
114 #define EMU_CAP_RW_MEM_ARM79 18
115 #define EMU_CAP_GET_COUNTERS 19
116 #define EMU_CAP_READ_DCC 20
117 #define EMU_CAP_GET_CPU_CAPS 21
118 #define EMU_CAP_EXEC_CPU_CMD 22
119 #define EMU_CAP_SWO 23
120 #define EMU_CAP_WRITE_DCC_EX 24
121 #define EMU_CAP_UPDATE_FIRMWARE_EX 25
122 #define EMU_CAP_FILE_IO 26
123 #define EMU_CAP_REGISTER 27
124 #define EMU_CAP_INDICATORS 28
125 #define EMU_CAP_TEST_NET_SPEED 29
126 #define EMU_CAP_RAWTRACE 30
127 #define EMU_CAP_RESERVED_3 31
129 static char *jlink_cap_str
[] = {
131 "Supports command EMU_CMD_GET_HARDWARE_VERSION",
132 "Supports command EMU_CMD_WRITE_DCC",
133 "Supports adaptive clocking",
134 "Supports command EMU_CMD_READ_CONFIG",
135 "Supports command EMU_CMD_WRITE_CONFIG",
136 "Supports trace commands",
137 "Supports command EMU_CMD_WRITE_MEM",
138 "Supports command EMU_CMD_READ_MEM",
139 "Supports command EMU_CMD_GET_SPEED",
140 "Supports command EMU_CMD_CODE_...",
141 "Supports command EMU_CMD_GET_MAX_BLOCK_SIZE",
142 "Supports command EMU_CMD_GET_HW_INFO",
143 "Supports command EMU_CMD_SET_KS_POWER",
144 "Supports command EMU_CMD_HW_RELEASE_RESET_STOP_TIMED",
146 "Supports command EMU_CMD_MEASURE_RTCK_REACT",
147 "Supports command EMU_CMD_HW_SELECT_IF",
148 "Supports command EMU_CMD_READ/WRITE_MEM_ARM79",
149 "Supports command EMU_CMD_GET_COUNTERS",
150 "Supports command EMU_CMD_READ_DCC",
151 "Supports command EMU_CMD_GET_CPU_CAPS",
152 "Supports command EMU_CMD_EXEC_CPU_CMD",
153 "Supports command EMU_CMD_SWO",
154 "Supports command EMU_CMD_WRITE_DCC_EX",
155 "Supports command EMU_CMD_UPDATE_FIRMWARE_EX",
156 "Supports command EMU_CMD_FILE_IO",
157 "Supports command EMU_CMD_REGISTER",
158 "Supports command EMU_CMD_INDICATORS",
159 "Supports command EMU_CMD_TEST_NET_SPEED",
160 "Supports command EMU_CMD_RAWTRACE",
164 /* max speed 12MHz v5.0 jlink */
165 #define JLINK_MAX_SPEED 12000
167 /* J-Link hardware versions */
168 #define JLINK_HW_TYPE_JLINK 0
169 #define JLINK_HW_TYPE_JTRACE 1
170 #define JLINK_HW_TYPE_FLASHER 2
171 #define JLINK_HW_TYPE_JLINK_PRO 3
172 #define JLINK_HW_TYPE_MAX 4
174 static char *jlink_hw_type_str
[] = {
181 /* Queue command functions */
182 static void jlink_end_state(tap_state_t state
);
183 static void jlink_state_move(void);
184 static void jlink_path_move(int num_states
, tap_state_t
*path
);
185 static void jlink_runtest(int num_cycles
);
186 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
187 int scan_size
, struct scan_command
*command
);
188 static void jlink_reset(int trst
, int srst
);
189 static void jlink_simple_command(uint8_t command
);
190 static int jlink_get_status(void);
192 /* J-Link tap buffer functions */
193 static void jlink_tap_init(void);
194 static int jlink_tap_execute(void);
195 static void jlink_tap_ensure_space(int scans
, int bits
);
196 static void jlink_tap_append_step(int tms
, int tdi
);
197 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
198 struct scan_command
*command
);
200 /* Jlink lowlevel functions */
202 struct jtag_libusb_device_handle
*usb_handle
;
205 static struct jlink
*jlink_usb_open(void);
206 static void jlink_usb_close(struct jlink
*jlink
);
207 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
);
208 static int jlink_usb_write(struct jlink
*jlink
, int out_length
);
209 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
);
210 static int jlink_usb_read_emu_result(struct jlink
*jlink
);
212 /* helper functions */
213 static int jlink_get_version_info(void);
215 #ifdef _DEBUG_USB_COMMS_
216 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
218 static inline void jlink_debug_buffer(uint8_t *buffer
, int length
)
223 static enum tap_state jlink_last_state
= TAP_RESET
;
225 static struct jlink
*jlink_handle
;
227 /* pid could be specified at runtime */
228 static uint16_t vids
[] = { VID
, 0 };
229 static uint16_t pids
[] = { PID
, 0 };
231 static uint32_t jlink_caps
;
232 static uint32_t jlink_hw_type
;
234 /* 256 byte non-volatile memory */
235 struct jlink_config
{
237 /* 0ffset 0x01 to 0x03 */
238 uint8_t reserved_1
[3];
239 uint32_t kickstart_power_on_jtag_pin_19
;
240 /* 0ffset 0x08 to 0x1f */
241 uint8_t reserved_2
[24];
242 /* IP only for J-Link Pro */
243 uint8_t ip_address
[4];
244 uint8_t subnet_mask
[4];
245 /* 0ffset 0x28 to 0x2f */
246 uint8_t reserved_3
[8];
247 uint8_t mac_address
[6];
248 /* 0ffset 0x36 to 0xff */
249 uint8_t reserved_4
[202];
250 } __attribute__ ((packed
));
251 struct jlink_config jlink_cfg
;
253 /***************************************************************************/
254 /* External interface implementation */
256 static void jlink_execute_runtest(struct jtag_command
*cmd
)
258 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
259 cmd
->cmd
.runtest
->num_cycles
,
260 cmd
->cmd
.runtest
->end_state
);
262 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
264 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
267 static void jlink_execute_statemove(struct jtag_command
*cmd
)
269 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
271 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
275 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
277 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
278 cmd
->cmd
.pathmove
->num_states
,
279 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
281 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
282 cmd
->cmd
.pathmove
->path
);
285 static void jlink_execute_scan(struct jtag_command
*cmd
)
291 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
293 jlink_end_state(cmd
->cmd
.scan
->end_state
);
295 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
296 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
298 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
299 type
= jtag_scan_type(cmd
->cmd
.scan
);
300 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
301 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
304 static void jlink_execute_reset(struct jtag_command
*cmd
)
306 DEBUG_JTAG_IO("reset trst: %i srst %i",
307 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
310 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
314 static void jlink_execute_sleep(struct jtag_command
*cmd
)
316 DEBUG_JTAG_IO("sleep %" PRIi32
"", cmd
->cmd
.sleep
->us
);
318 jtag_sleep(cmd
->cmd
.sleep
->us
);
321 static void jlink_execute_command(struct jtag_command
*cmd
)
325 jlink_execute_runtest(cmd
);
328 jlink_execute_statemove(cmd
);
331 jlink_execute_pathmove(cmd
);
334 jlink_execute_scan(cmd
);
337 jlink_execute_reset(cmd
);
340 jlink_execute_sleep(cmd
);
343 LOG_ERROR("BUG: unknown JTAG command type encountered");
348 static int jlink_execute_queue(void)
350 struct jtag_command
*cmd
= jtag_command_queue
;
352 while (cmd
!= NULL
) {
353 jlink_execute_command(cmd
);
357 return jlink_tap_execute();
360 /* Sets speed in kHz. */
361 static int jlink_speed(int speed
)
365 if (speed
> JLINK_MAX_SPEED
) {
366 LOG_INFO("reduce speed request: %dkHz to %dkHz maximum",
367 speed
, JLINK_MAX_SPEED
);
368 speed
= JLINK_MAX_SPEED
;
371 /* check for RTCK setting */
375 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
376 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
377 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
379 result
= jlink_usb_write(jlink_handle
, 3);
381 LOG_ERROR("J-Link setting speed failed (%d)", result
);
382 return ERROR_JTAG_DEVICE_ERROR
;
388 static int jlink_speed_div(int speed
, int *khz
)
395 static int jlink_khz(int khz
, int *jtag_speed
)
402 static int jlink_init(void)
406 jlink_handle
= jlink_usb_open();
408 if (jlink_handle
== 0) {
409 LOG_ERROR("Cannot find jlink Interface! Please check "
410 "connection and permissions.");
411 return ERROR_JTAG_INIT_FAILED
;
415 * The next three instructions were added after discovering a problem
416 * while using an oscilloscope.
417 * For the V8 SAM-ICE dongle (and likely other j-link device variants),
418 * the reset line to the target microprocessor was found to cycle only
419 * intermittently during emulator startup (even after encountering the
420 * downstream reset instruction later in the code).
421 * This was found to create two issues:
422 * 1) In general it is a bad practice to not reset a CPU to a known
423 * state when starting an emulator and
424 * 2) something critical happens inside the dongle when it does the
425 * first read following a new USB session.
426 * Keeping the processor in reset during the first read collecting
427 * version information seems to prevent errant
428 * "J-Link command EMU_CMD_VERSION failed" issues.
431 LOG_INFO("J-Link initialization started / target CPU reset initiated");
432 jlink_simple_command(EMU_CMD_HW_TRST0
);
433 jlink_simple_command(EMU_CMD_HW_RESET0
);
436 jlink_hw_jtag_version
= 2;
438 if (jlink_get_version_info() == ERROR_OK
) {
439 /* attempt to get status */
443 LOG_INFO("J-Link JTAG Interface ready");
449 /* v5/6 jlink seems to have an issue if the first tap move
450 * is not divisible by 8, so we send a TLR on first power up */
451 for (i
= 0; i
< 8; i
++)
452 jlink_tap_append_step(1, 0);
458 static int jlink_quit(void)
460 jlink_usb_close(jlink_handle
);
464 /***************************************************************************/
465 /* Queue command implementations */
467 static void jlink_end_state(tap_state_t state
)
469 if (tap_is_state_stable(state
))
470 tap_set_end_state(state
);
472 LOG_ERROR("BUG: %i is not a valid end state", state
);
477 /* Goes to the end state. */
478 static void jlink_state_move(void)
482 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
483 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
485 for (i
= 0; i
< tms_scan_bits
; i
++) {
486 tms
= (tms_scan
>> i
) & 1;
487 jlink_tap_append_step(tms
, 0);
490 tap_set_state(tap_get_end_state());
493 static void jlink_path_move(int num_states
, tap_state_t
*path
)
497 for (i
= 0; i
< num_states
; i
++) {
498 if (path
[i
] == tap_state_transition(tap_get_state(), false))
499 jlink_tap_append_step(0, 0);
500 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
501 jlink_tap_append_step(1, 0);
503 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
504 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
508 tap_set_state(path
[i
]);
511 tap_set_end_state(tap_get_state());
514 static void jlink_runtest(int num_cycles
)
518 tap_state_t saved_end_state
= tap_get_end_state();
520 jlink_tap_ensure_space(1, num_cycles
+ 16);
522 /* only do a state_move when we're not already in IDLE */
523 if (tap_get_state() != TAP_IDLE
) {
524 jlink_end_state(TAP_IDLE
);
529 /* execute num_cycles */
530 for (i
= 0; i
< num_cycles
; i
++)
531 jlink_tap_append_step(0, 0);
533 /* finish in end_state */
534 jlink_end_state(saved_end_state
);
535 if (tap_get_state() != tap_get_end_state())
539 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
540 int scan_size
, struct scan_command
*command
)
542 tap_state_t saved_end_state
;
544 jlink_tap_ensure_space(1, scan_size
+ 16);
546 saved_end_state
= tap_get_end_state();
548 /* Move to appropriate scan state */
549 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
551 /* Only move if we're not already there */
552 if (tap_get_state() != tap_get_end_state())
555 jlink_end_state(saved_end_state
);
558 jlink_tap_append_scan(scan_size
, buffer
, command
);
560 /* We are in Exit1, go to Pause */
561 jlink_tap_append_step(0, 0);
563 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
565 if (tap_get_state() != tap_get_end_state())
569 static void jlink_reset(int trst
, int srst
)
571 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
573 /* Signals are active low */
575 jlink_simple_command(EMU_CMD_HW_RESET1
);
578 jlink_simple_command(EMU_CMD_HW_RESET0
);
581 jlink_simple_command(EMU_CMD_HW_TRST0
);
584 jlink_simple_command(EMU_CMD_HW_TRST1
);
587 static void jlink_simple_command(uint8_t command
)
591 DEBUG_JTAG_IO("0x%02x", command
);
593 usb_out_buffer
[0] = command
;
594 result
= jlink_usb_write(jlink_handle
, 1);
597 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
600 static int jlink_get_status(void)
604 jlink_simple_command(EMU_CMD_GET_STATE
);
606 result
= jlink_usb_read(jlink_handle
, 8);
608 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)", result
);
609 return ERROR_JTAG_DEVICE_ERROR
;
612 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
613 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \
614 vref
/ 1000, vref
% 1000, \
615 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
616 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
619 LOG_ERROR("Vref too low. Check Target Power");
624 #define jlink_dump_printf(context, expr ...) \
627 command_print(context, expr); \
632 static void jlink_caps_dump(struct command_context
*ctx
)
636 jlink_dump_printf(ctx
, "J-Link Capabilities");
638 for (i
= 1; i
< 31; i
++)
639 if (jlink_caps
& (1 << i
))
640 jlink_dump_printf(ctx
, "%s", jlink_cap_str
[i
]);
643 static void jlink_config_usb_address_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
648 jlink_dump_printf(ctx
, "USB-Address: 0x%x", cfg
->usb_address
);
651 static void jlink_config_kickstart_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
656 jlink_dump_printf(ctx
, "Kickstart power on JTAG-pin 19: 0x%x",
657 cfg
->kickstart_power_on_jtag_pin_19
);
660 static void jlink_config_mac_address_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
665 jlink_dump_printf(ctx
, "MAC Address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
666 cfg
->mac_address
[5], cfg
->mac_address
[4],
667 cfg
->mac_address
[3], cfg
->mac_address
[2],
668 cfg
->mac_address
[1], cfg
->mac_address
[0]);
671 static void jlink_config_ip_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
676 jlink_dump_printf(ctx
, "IP Address: %d.%d.%d.%d",
677 cfg
->ip_address
[3], cfg
->ip_address
[2],
678 cfg
->ip_address
[1], cfg
->ip_address
[0]);
679 jlink_dump_printf(ctx
, "Subnet Mask: %d.%d.%d.%d",
680 cfg
->subnet_mask
[3], cfg
->subnet_mask
[2],
681 cfg
->subnet_mask
[1], cfg
->subnet_mask
[0]);
684 static void jlink_config_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
689 jlink_dump_printf(ctx
, "J-Link configuration");
690 jlink_config_usb_address_dump(ctx
, cfg
);
691 jlink_config_kickstart_dump(ctx
, cfg
);
693 if (jlink_hw_type
== JLINK_HW_TYPE_JLINK_PRO
) {
694 jlink_config_ip_dump(ctx
, cfg
);
695 jlink_config_mac_address_dump(ctx
, cfg
);
699 static int jlink_get_config(struct jlink_config
*cfg
)
702 int size
= sizeof(struct jlink_config
);
704 jlink_simple_command(EMU_CMD_READ_CONFIG
);
706 result
= jlink_usb_read(jlink_handle
, size
);
707 if (size
!= result
) {
708 LOG_ERROR("jlink_usb_read failed (requested=%d, result=%d)", size
, result
);
712 memcpy(cfg
, usb_in_buffer
, size
);
715 * Section 4.2.4 IN-transaction
716 * read dummy 0-byte packet
718 jlink_usb_read(jlink_handle
, 1);
723 static int jlink_set_config(struct jlink_config
*cfg
)
726 int size
= sizeof(struct jlink_config
);
728 jlink_simple_command(EMU_CMD_WRITE_CONFIG
);
730 memcpy(usb_out_buffer
, cfg
, size
);
732 result
= jlink_usb_write(jlink_handle
, size
);
733 if (result
!= size
) {
734 LOG_ERROR("jlink_usb_write failed (requested=%d, result=%d)", 256, result
);
742 * List of unsupported version string markers.
744 * The firmware versions does not correspond directly with
745 * "Software and documentation pack for Windows", it may be
746 * distinguished by the "compile" date in the information string.
748 * For example, version string is:
749 * "J-Link ARM V8 compiled May 3 2012 18:36:22"
753 * The list must be terminated by NULL string.
755 static const char * const unsupported_versions
[] = {
758 "Mar 19 2012", /* V4.44 */
759 "May 3 2012", /* V4.46 "J-Link ARM V8 compiled May 3 2012 18:36:22" */
760 NULL
/* End of list */
763 static void jlink_check_supported(const char *str
)
765 const char * const *p
= unsupported_versions
;
767 if (NULL
!= strstr(str
, *p
)) {
769 "Unsupported J-Link firmware version.\n"
770 " Please check http://www.segger.com/j-link-older-versions.html for updates");
777 static int jlink_get_version_info(void)
781 uint32_t jlink_max_size
;
783 /* query hardware version */
784 jlink_simple_command(EMU_CMD_VERSION
);
786 result
= jlink_usb_read(jlink_handle
, 2);
788 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
789 return ERROR_JTAG_DEVICE_ERROR
;
792 len
= buf_get_u32(usb_in_buffer
, 0, 16);
793 if (len
> JLINK_IN_BUFFER_SIZE
) {
794 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
795 len
= JLINK_IN_BUFFER_SIZE
;
798 result
= jlink_usb_read(jlink_handle
, len
);
800 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
801 return ERROR_JTAG_DEVICE_ERROR
;
804 usb_in_buffer
[result
] = 0;
805 LOG_INFO("%s", (char *)usb_in_buffer
);
806 jlink_check_supported((char *)usb_in_buffer
);
808 /* query hardware capabilities */
809 jlink_simple_command(EMU_CMD_GET_CAPS
);
811 result
= jlink_usb_read(jlink_handle
, 4);
813 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", result
);
814 return ERROR_JTAG_DEVICE_ERROR
;
817 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
818 LOG_INFO("J-Link caps 0x%x", (unsigned)jlink_caps
);
820 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
)) {
821 /* query hardware version */
822 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
824 result
= jlink_usb_read(jlink_handle
, 4);
826 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result
);
827 return ERROR_JTAG_DEVICE_ERROR
;
830 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
831 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
832 jlink_hw_type
= (jlink_hw_version
/ 1000000) % 100;
833 if (major_revision
>= 5)
834 jlink_hw_jtag_version
= 3;
836 LOG_INFO("J-Link hw version %i", (int)jlink_hw_version
);
838 if (jlink_hw_type
>= JLINK_HW_TYPE_MAX
)
839 LOG_INFO("J-Link hw type uknown 0x%x", jlink_hw_type
);
841 LOG_INFO("J-Link hw type %s", jlink_hw_type_str
[jlink_hw_type
]);
844 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
)) {
845 /* query hardware maximum memory block */
846 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
848 result
= jlink_usb_read(jlink_handle
, 4);
850 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", result
);
851 return ERROR_JTAG_DEVICE_ERROR
;
854 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
855 LOG_INFO("J-Link max mem block %i", (int)jlink_max_size
);
858 if (jlink_caps
& (1 << EMU_CAP_READ_CONFIG
)) {
859 if (jlink_get_config(&jlink_cfg
) != ERROR_OK
)
860 return ERROR_JTAG_DEVICE_ERROR
;
862 jlink_config_dump(NULL
, &jlink_cfg
);
868 COMMAND_HANDLER(jlink_pid_command
)
871 LOG_ERROR("Need exactly one argument to jlink_pid");
875 pids
[0] = strtoul(CMD_ARGV
[0], NULL
, 16);
882 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
884 if (jlink_get_version_info() == ERROR_OK
) {
885 /* attempt to get status */
892 COMMAND_HANDLER(jlink_handle_jlink_caps_command
)
894 jlink_caps_dump(CMD_CTX
);
899 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
903 command_print(CMD_CTX
, "J-Link hw jtag %i", jlink_hw_jtag_version
);
906 int request_version
= atoi(CMD_ARGV
[0]);
907 switch (request_version
) {
910 jlink_hw_jtag_version
= request_version
;
913 return ERROR_COMMAND_SYNTAX_ERROR
;
918 return ERROR_COMMAND_SYNTAX_ERROR
;
924 COMMAND_HANDLER(jlink_handle_jlink_kickstart_command
)
929 jlink_config_kickstart_dump(CMD_CTX
, &jlink_cfg
);
933 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], kickstart
);
935 jlink_cfg
.kickstart_power_on_jtag_pin_19
= kickstart
;
939 COMMAND_HANDLER(jlink_handle_jlink_mac_address_command
)
947 jlink_config_mac_address_dump(CMD_CTX
, &jlink_cfg
);
953 if ((strlen(str
) != 17) || (str
[2] != ':' || str
[5] != ':' || str
[8] != ':' ||
954 str
[11] != ':' || str
[14] != ':')) {
955 command_print(CMD_CTX
, "ethaddr miss format ff:ff:ff:ff:ff:ff");
956 return ERROR_COMMAND_SYNTAX_ERROR
;
959 for (i
= 5; i
>= 0; i
--) {
960 addr
[i
] = strtoul(str
, &e
, 16);
964 if (!(addr
[0] | addr
[1] | addr
[2] | addr
[3] | addr
[4] | addr
[5])) {
965 command_print(CMD_CTX
, "invalid it's zero mac_address");
966 return ERROR_COMMAND_SYNTAX_ERROR
;
969 if (!(0x01 & addr
[0])) {
970 command_print(CMD_CTX
, "invalid it's a multicat mac_address");
971 return ERROR_COMMAND_SYNTAX_ERROR
;
974 memcpy(jlink_cfg
.mac_address
, addr
, sizeof(addr
));
979 static int string_to_ip(const char *s
, uint8_t *ip
, int *pos
)
983 const char *s_save
= s
;
989 for (i
= 0; i
< 4; i
++) {
990 lip
[i
] = strtoul(s
, &e
, 10);
992 if (*e
!= '.' && i
!= 3)
1000 memcpy(ip
, lip
, sizeof(lip
));
1004 static void cpy_ip(uint8_t *dst
, uint8_t *src
)
1008 for (i
= 0, j
= 3; i
< 4; i
++, j
--)
1012 COMMAND_HANDLER(jlink_handle_jlink_ip_command
)
1014 uint32_t ip_address
;
1015 uint32_t subnet_mask
= 0;
1018 uint8_t subnet_bits
= 24;
1021 jlink_config_ip_dump(CMD_CTX
, &jlink_cfg
);
1025 ret
= string_to_ip(CMD_ARGV
[0], (uint8_t *)&ip_address
, &i
);
1026 if (ret
!= ERROR_OK
)
1029 len
= strlen(CMD_ARGV
[0]);
1031 /* check for this format A.B.C.D/E */
1034 if (CMD_ARGV
[0][i
] != '/')
1035 return ERROR_COMMAND_SYNTAX_ERROR
;
1037 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0] + i
+ 1, subnet_bits
);
1040 ret
= string_to_ip(CMD_ARGV
[1], (uint8_t *)&subnet_mask
, &i
);
1041 if (ret
!= ERROR_OK
)
1047 subnet_mask
= (uint32_t)(subnet_bits
< 32 ?
1048 ((1ULL << subnet_bits
) - 1) : 0xffffffff);
1050 cpy_ip(jlink_cfg
.ip_address
, (uint8_t *)&ip_address
);
1051 cpy_ip(jlink_cfg
.subnet_mask
, (uint8_t *)&subnet_mask
);
1056 COMMAND_HANDLER(jlink_handle_jlink_reset_command
)
1058 memset(&jlink_cfg
, 0xff, sizeof(jlink_cfg
));
1062 COMMAND_HANDLER(jlink_handle_jlink_save_command
)
1064 if (!(jlink_caps
& (1 << EMU_CAP_WRITE_CONFIG
))) {
1065 command_print(CMD_CTX
, "J-Link write emulator configuration not supported");
1069 command_print(CMD_CTX
, "The J-Link need to be unpluged and repluged ta have the config effective");
1070 return jlink_set_config(&jlink_cfg
);
1073 COMMAND_HANDLER(jlink_handle_jlink_usb_address_command
)
1078 jlink_config_usb_address_dump(CMD_CTX
, &jlink_cfg
);
1082 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], address
);
1084 if (address
> 0x3 && address
!= 0xff) {
1085 command_print(CMD_CTX
, "USB Address must be between 0x00 and 0x03 or 0xff");
1086 return ERROR_COMMAND_SYNTAX_ERROR
;
1089 jlink_cfg
.usb_address
= address
;
1093 COMMAND_HANDLER(jlink_handle_jlink_config_command
)
1095 struct jlink_config cfg
;
1098 if (CMD_ARGC
== 0) {
1099 if (!(jlink_caps
& (1 << EMU_CAP_READ_CONFIG
))) {
1100 command_print(CMD_CTX
, "J-Link read emulator configuration not supported");
1104 ret
= jlink_get_config(&cfg
);
1106 if (ret
!= ERROR_OK
)
1107 command_print(CMD_CTX
, "J-Link read emulator configuration failled");
1109 jlink_config_dump(CMD_CTX
, &jlink_cfg
);
1116 static const struct command_registration jlink_config_subcommand_handlers
[] = {
1118 .name
= "kickstart",
1119 .handler
= &jlink_handle_jlink_kickstart_command
,
1120 .mode
= COMMAND_EXEC
,
1121 .help
= "set Kickstart power on JTAG-pin 19.",
1125 .name
= "mac_address",
1126 .handler
= &jlink_handle_jlink_mac_address_command
,
1127 .mode
= COMMAND_EXEC
,
1128 .help
= "set the MAC Address",
1129 .usage
= "[ff:ff:ff:ff:ff:ff]",
1133 .handler
= &jlink_handle_jlink_ip_command
,
1134 .mode
= COMMAND_EXEC
,
1135 .help
= "set the ip address of the J-Link Pro, "
1136 "where A.B.C.D is the ip, "
1137 "E the bit of the subnet mask, "
1138 "F.G.H.I the subnet mask",
1139 .usage
= "[A.B.C.D[/E] [F.G.H.I]]",
1143 .handler
= &jlink_handle_jlink_reset_command
,
1144 .mode
= COMMAND_EXEC
,
1145 .help
= "reset the current config",
1149 .handler
= &jlink_handle_jlink_save_command
,
1150 .mode
= COMMAND_EXEC
,
1151 .help
= "save the current config",
1154 .name
= "usb_address",
1155 .handler
= &jlink_handle_jlink_usb_address_command
,
1156 .mode
= COMMAND_EXEC
,
1157 .help
= "set the USB-Address, "
1158 "This will change the product id",
1159 .usage
= "[0x00 to 0x03 or 0xff]",
1161 COMMAND_REGISTRATION_DONE
1164 static const struct command_registration jlink_subcommand_handlers
[] = {
1167 .handler
= &jlink_handle_jlink_caps_command
,
1168 .mode
= COMMAND_EXEC
,
1169 .help
= "show jlink capabilities",
1173 .handler
= &jlink_handle_jlink_info_command
,
1174 .mode
= COMMAND_EXEC
,
1175 .help
= "show jlink info",
1179 .handler
= &jlink_handle_jlink_hw_jtag_command
,
1180 .mode
= COMMAND_EXEC
,
1181 .help
= "access J-Link HW JTAG command version",
1186 .handler
= &jlink_handle_jlink_config_command
,
1187 .mode
= COMMAND_EXEC
,
1188 .help
= "access J-Link configuration, "
1189 "if no argument this will dump the config",
1190 .chain
= jlink_config_subcommand_handlers
,
1194 .handler
= &jlink_pid_command
,
1195 .mode
= COMMAND_CONFIG
,
1196 .help
= "set the pid of the interface we want to use",
1198 COMMAND_REGISTRATION_DONE
1201 static const struct command_registration jlink_command_handlers
[] = {
1204 .mode
= COMMAND_ANY
,
1205 .help
= "perform jlink management",
1206 .chain
= jlink_subcommand_handlers
,
1208 COMMAND_REGISTRATION_DONE
1211 struct jtag_interface jlink_interface
= {
1213 .commands
= jlink_command_handlers
,
1215 .execute_queue
= jlink_execute_queue
,
1216 .speed
= jlink_speed
,
1217 .speed_div
= jlink_speed_div
,
1223 /***************************************************************************/
1224 /* J-Link tap functions */
1227 static unsigned tap_length
;
1228 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
1229 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
1230 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
1232 struct pending_scan_result
{
1233 int first
; /* First bit position in tdo_buffer to read */
1234 int length
; /* Number of bits to read */
1235 struct scan_command
*command
; /* Corresponding scan command */
1239 #define MAX_PENDING_SCAN_RESULTS 256
1241 static int pending_scan_results_length
;
1242 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
1244 static void jlink_tap_init(void)
1247 pending_scan_results_length
= 0;
1250 static void jlink_tap_ensure_space(int scans
, int bits
)
1252 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
1253 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
1255 if (scans
> available_scans
|| bits
> available_bits
)
1256 jlink_tap_execute();
1259 static void jlink_tap_append_step(int tms
, int tdi
)
1261 int index_var
= tap_length
/ 8;
1263 if (index_var
>= JLINK_TAP_BUFFER_SIZE
) {
1264 LOG_ERROR("jlink_tap_append_step: overflow");
1265 *(uint32_t *)0xFFFFFFFF = 0;
1269 int bit_index
= tap_length
% 8;
1270 uint8_t bit
= 1 << bit_index
;
1272 /* we do not pad TMS, so be sure to initialize all bits */
1274 tms_buffer
[index_var
] = tdi_buffer
[index_var
] = 0;
1277 tms_buffer
[index_var
] |= bit
;
1279 tms_buffer
[index_var
] &= ~bit
;
1282 tdi_buffer
[index_var
] |= bit
;
1284 tdi_buffer
[index_var
] &= ~bit
;
1289 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
1290 struct scan_command
*command
)
1292 struct pending_scan_result
*pending_scan_result
=
1293 &pending_scan_results_buffer
[pending_scan_results_length
];
1296 pending_scan_result
->first
= tap_length
;
1297 pending_scan_result
->length
= length
;
1298 pending_scan_result
->command
= command
;
1299 pending_scan_result
->buffer
= buffer
;
1301 for (i
= 0; i
< length
; i
++) {
1302 int tms
= (i
< (length
- 1)) ? 0 : 1;
1303 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
1304 jlink_tap_append_step(tms
, tdi
);
1306 pending_scan_results_length
++;
1309 /* Pad and send a tap sequence to the device, and receive the answer.
1310 * For the purpose of padding we assume that we are in idle or pause state. */
1311 static int jlink_tap_execute(void)
1320 /* JLink returns an extra NULL in packet when size of incoming
1321 * message is a multiple of 64, creates problems with USB comms.
1322 * WARNING: This will interfere with tap state counting. */
1323 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
1324 jlink_tap_append_step((tap_get_state() == TAP_RESET
) ? 1 : 0, 0);
1326 /* number of full bytes (plus one if some would be left over) */
1327 byte_length
= DIV_ROUND_UP(tap_length
, 8);
1329 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
1330 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
1331 usb_out_buffer
[1] = 0;
1332 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
1333 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
1334 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
1335 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
1337 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
1338 tap_length
, jlink_last_state
);
1340 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
1341 if (result
!= byte_length
) {
1342 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
1343 result
, byte_length
);
1345 return ERROR_JTAG_QUEUE_FAILED
;
1348 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
1350 for (i
= 0; i
< pending_scan_results_length
; i
++) {
1351 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
1352 uint8_t *buffer
= pending_scan_result
->buffer
;
1353 int length
= pending_scan_result
->length
;
1354 int first
= pending_scan_result
->first
;
1355 struct scan_command
*command
= pending_scan_result
->command
;
1357 /* Copy to buffer */
1358 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
1360 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
1362 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
1364 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
1366 return ERROR_JTAG_QUEUE_FAILED
;
1369 if (pending_scan_result
->buffer
!= NULL
)
1370 free(pending_scan_result
->buffer
);
1377 /*****************************************************************************/
1378 /* JLink USB low-level functions */
1380 static struct jlink
*jlink_usb_open()
1382 struct jtag_libusb_device_handle
*devh
;
1383 if (jtag_libusb_open(vids
, pids
, &devh
) != ERROR_OK
)
1386 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
1387 * AREA!!!!!!!!!!! The behavior of libusb is not completely
1388 * consistent across Windows, Linux, and Mac OS X platforms.
1389 * The actions taken in the following compiler conditionals may
1390 * not agree with published documentation for libusb, but were
1391 * found to be necessary through trials and tribulations. Even
1392 * little tweaks can break one or more platforms, so if you do
1393 * make changes test them carefully on all platforms before
1399 jtag_libusb_reset_device(devh
);
1404 /* reopen jlink after usb_reset
1405 * on win32 this may take a second or two to re-enumerate */
1407 while ((retval
= jtag_libusb_open(vids
, pids
, &devh
)) != ERROR_OK
) {
1413 if (ERROR_OK
!= retval
)
1419 /* usb_set_configuration required under win32 */
1420 struct jtag_libusb_device
*udev
= jtag_libusb_get_device(devh
);
1421 jtag_libusb_set_configuration(devh
, 0);
1422 jtag_libusb_claim_interface(devh
, 0);
1426 * This makes problems under Mac OS X. And is not needed
1427 * under Windows. Hopefully this will not break a linux build
1429 usb_set_altinterface(result
->usb_handle
, 0);
1432 jtag_libusb_get_endpoints(udev
, &jlink_read_ep
, &jlink_write_ep
);
1434 struct jlink
*result
= malloc(sizeof(struct jlink
));
1435 result
->usb_handle
= devh
;
1439 static void jlink_usb_close(struct jlink
*jlink
)
1441 jtag_libusb_close(jlink
->usb_handle
);
1445 /* Send a message and receive the reply. */
1446 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
1450 result
= jlink_usb_write(jlink
, out_length
);
1451 if (result
!= out_length
) {
1452 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
1453 out_length
, result
);
1454 return ERROR_JTAG_DEVICE_ERROR
;
1457 result
= jlink_usb_read(jlink
, in_length
);
1458 if ((result
!= in_length
) && (result
!= (in_length
+ 1))) {
1459 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
1461 return ERROR_JTAG_DEVICE_ERROR
;
1464 if (jlink_hw_jtag_version
< 3)
1467 int result2
= ERROR_OK
;
1468 if (result
== in_length
) {
1469 /* Must read the result from the EMU too */
1470 result2
= jlink_usb_read_emu_result(jlink
);
1472 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, "
1473 "result=%d, in_length=%i", result2
, in_length
);
1474 /* Try again once, should only happen if (in_length%64 == 0) */
1475 result2
= jlink_usb_read_emu_result(jlink
);
1477 LOG_ERROR("jlink_usb_read_emu_result failed "
1478 "(requested = 1, result=%d)", result2
);
1479 return ERROR_JTAG_DEVICE_ERROR
;
1483 /* Check the result itself */
1484 result2
= usb_emu_result_buffer
[0];
1486 /* Save the result, then remove it from return value */
1487 result2
= usb_in_buffer
[result
--];
1491 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
1492 return ERROR_JTAG_DEVICE_ERROR
;
1498 /* calls the given usb_bulk_* function, allowing for the data to
1499 * trickle in with some timeouts */
1500 static int usb_bulk_with_retries(
1501 int (*f
)(jtag_libusb_device_handle
*, int, char *, int, int),
1502 jtag_libusb_device_handle
*dev
, int ep
,
1503 char *bytes
, int size
, int timeout
)
1505 int tries
= 3, count
= 0;
1507 while (tries
&& (count
< size
)) {
1508 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1511 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1517 static int wrap_usb_bulk_write(jtag_libusb_device_handle
*dev
, int ep
,
1518 char *buff
, int size
, int timeout
)
1520 /* usb_bulk_write() takes const char *buff */
1521 return jtag_libusb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1524 static inline int usb_bulk_write_ex(jtag_libusb_device_handle
*dev
, int ep
,
1525 char *bytes
, int size
, int timeout
)
1527 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1528 dev
, ep
, bytes
, size
, timeout
);
1531 static inline int usb_bulk_read_ex(jtag_libusb_device_handle
*dev
, int ep
,
1532 char *bytes
, int size
, int timeout
)
1534 return usb_bulk_with_retries(&jtag_libusb_bulk_read
,
1535 dev
, ep
, bytes
, size
, timeout
);
1538 /* Write data from out_buffer to USB. */
1539 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1543 if (out_length
> JLINK_OUT_BUFFER_SIZE
) {
1544 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)",
1545 out_length
, JLINK_OUT_BUFFER_SIZE
);
1549 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1550 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1552 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d",
1553 out_length
, result
);
1555 jlink_debug_buffer(usb_out_buffer
, out_length
);
1559 /* Read data from USB into in_buffer. */
1560 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1562 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1563 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1565 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1567 jlink_debug_buffer(usb_in_buffer
, result
);
1571 /* Read the result from the previous EMU cmd into result_buffer. */
1572 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1574 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1575 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1578 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1580 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1584 #ifdef _DEBUG_USB_COMMS_
1585 #define BYTES_PER_LINE 16
1587 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1594 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
) {
1595 snprintf(line
, 5, "%04x", i
);
1596 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++) {
1597 snprintf(s
, 4, " %02x", buffer
[j
]);
1600 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)