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 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 JLINK_OB_PID 0x0105
51 #define JLINK_WRITE_ENDPOINT 0x02
52 #define JLINK_READ_ENDPOINT 0x81
54 #define JLINK_OB_WRITE_ENDPOINT 0x06
55 #define JLINK_OB_READ_ENDPOINT 0x85
57 static unsigned int jlink_write_ep
= JLINK_WRITE_ENDPOINT
;
58 static unsigned int jlink_read_ep
= JLINK_READ_ENDPOINT
;
59 static unsigned int jlink_hw_jtag_version
= 2;
61 #define JLINK_USB_TIMEOUT 1000
63 /* See Section 3.3.2 of the Segger JLink USB protocol manual */
64 /* 2048 is the max value we can use here */
65 #define JLINK_TAP_BUFFER_SIZE 2048
66 /*#define JLINK_TAP_BUFFER_SIZE 256*/
67 /*#define JLINK_TAP_BUFFER_SIZE 384*/
69 #define JLINK_IN_BUFFER_SIZE (2048 + 1)
70 #define JLINK_OUT_BUFFER_SIZE (2*2048 + 4)
72 /* Global USB buffers */
73 static uint8_t usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
74 static uint8_t usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
76 /* Constants for JLink command */
77 #define EMU_CMD_VERSION 0x01
78 #define EMU_CMD_RESET_TRST 0x02
79 #define EMU_CMD_RESET_TARGET 0x03
80 #define EMU_CMD_SET_SPEED 0x05
81 #define EMU_CMD_GET_STATE 0x07
82 #define EMU_CMD_SET_KS_POWER 0x08
83 #define EMU_CMD_GET_SPEEDS 0xc0
84 #define EMU_CMD_GET_HW_INFO 0xc1
85 #define EMU_CMD_GET_COUNTERS 0xc2
86 #define EMU_CMD_SELECT_IF 0xc7
87 #define EMU_CMD_HW_CLOCK 0xc8
88 #define EMU_CMD_HW_TMS0 0xc9
89 #define EMU_CMD_HW_TMS1 0xca
90 #define EMU_CMD_HW_DATA0 0xcb
91 #define EMU_CMD_HW_DATA1 0xcc
92 #define EMU_CMD_HW_JTAG 0xcd
93 #define EMU_CMD_HW_JTAG2 0xce
94 #define EMU_CMD_HW_JTAG3 0xcf
95 #define EMU_CMD_HW_RELEASE_RESET_STOP_EX 0xd0
96 #define EMU_CMD_HW_RELEASE_RESET_STOP_TIMED 0xd1
97 #define EMU_CMD_GET_MAX_MEM_BLOCK 0xd4
98 #define EMU_CMD_HW_JTAG_WRITE 0xd5
99 #define EMU_CMD_HW_JTAG_GET_RESULT 0xd6
100 #define EMU_CMD_HW_RESET0 0xdc
101 #define EMU_CMD_HW_RESET1 0xdd
102 #define EMU_CMD_HW_TRST0 0xde
103 #define EMU_CMD_HW_TRST1 0xdf
104 #define EMU_CMD_GET_CAPS 0xe8
105 #define EMU_CMD_GET_CPU_CAPS 0xe9
106 #define EMU_CMD_EXEC_CPU_CMD 0xea
107 #define EMU_CMD_GET_CAPS_EX 0xed
108 #define EMU_CMD_GET_HW_VERSION 0xf0
109 #define EMU_CMD_WRITE_DCC 0xf1
110 #define EMU_CMD_READ_CONFIG 0xf2
111 #define EMU_CMD_WRITE_CONFIG 0xf3
112 #define EMU_CMD_WRITE_MEM 0xf4
113 #define EMU_CMD_READ_MEM 0xf5
114 #define EMU_CMD_MEASURE_RTCK_REACT 0xf6
115 #define EMU_CMD_WRITE_MEM_ARM79 0xf7
116 #define EMU_CMD_READ_MEM_ARM79 0xf8
118 /* bits return from EMU_CMD_GET_CAPS */
119 #define EMU_CAP_RESERVED_1 0
120 #define EMU_CAP_GET_HW_VERSION 1
121 #define EMU_CAP_WRITE_DCC 2
122 #define EMU_CAP_ADAPTIVE_CLOCKING 3
123 #define EMU_CAP_READ_CONFIG 4
124 #define EMU_CAP_WRITE_CONFIG 5
125 #define EMU_CAP_TRACE 6
126 #define EMU_CAP_WRITE_MEM 7
127 #define EMU_CAP_READ_MEM 8
128 #define EMU_CAP_SPEED_INFO 9
129 #define EMU_CAP_EXEC_CODE 10
130 #define EMU_CAP_GET_MAX_BLOCK_SIZE 11
131 #define EMU_CAP_GET_HW_INFO 12
132 #define EMU_CAP_SET_KS_POWER 13
133 #define EMU_CAP_RESET_STOP_TIMED 14
134 #define EMU_CAP_RESERVED_2 15
135 #define EMU_CAP_MEASURE_RTCK_REACT 16
136 #define EMU_CAP_SELECT_IF 17
137 #define EMU_CAP_RW_MEM_ARM79 18
138 #define EMU_CAP_GET_COUNTERS 19
139 #define EMU_CAP_READ_DCC 20
140 #define EMU_CAP_GET_CPU_CAPS 21
141 #define EMU_CAP_EXEC_CPU_CMD 22
142 #define EMU_CAP_SWO 23
143 #define EMU_CAP_WRITE_DCC_EX 24
144 #define EMU_CAP_UPDATE_FIRMWARE_EX 25
145 #define EMU_CAP_FILE_IO 26
146 #define EMU_CAP_REGISTER 27
147 #define EMU_CAP_INDICATORS 28
148 #define EMU_CAP_TEST_NET_SPEED 29
149 #define EMU_CAP_RAWTRACE 30
150 #define EMU_CAP_RESERVED_3 31
152 static char *jlink_cap_str
[] = {
154 "Supports command EMU_CMD_GET_HARDWARE_VERSION",
155 "Supports command EMU_CMD_WRITE_DCC",
156 "Supports adaptive clocking",
157 "Supports command EMU_CMD_READ_CONFIG",
158 "Supports command EMU_CMD_WRITE_CONFIG",
159 "Supports trace commands",
160 "Supports command EMU_CMD_WRITE_MEM",
161 "Supports command EMU_CMD_READ_MEM",
162 "Supports command EMU_CMD_GET_SPEED",
163 "Supports command EMU_CMD_CODE_...",
164 "Supports command EMU_CMD_GET_MAX_BLOCK_SIZE",
165 "Supports command EMU_CMD_GET_HW_INFO",
166 "Supports command EMU_CMD_SET_KS_POWER",
167 "Supports command EMU_CMD_HW_RELEASE_RESET_STOP_TIMED",
169 "Supports command EMU_CMD_MEASURE_RTCK_REACT",
170 "Supports command EMU_CMD_HW_SELECT_IF",
171 "Supports command EMU_CMD_READ/WRITE_MEM_ARM79",
172 "Supports command EMU_CMD_GET_COUNTERS",
173 "Supports command EMU_CMD_READ_DCC",
174 "Supports command EMU_CMD_GET_CPU_CAPS",
175 "Supports command EMU_CMD_EXEC_CPU_CMD",
176 "Supports command EMU_CMD_SWO",
177 "Supports command EMU_CMD_WRITE_DCC_EX",
178 "Supports command EMU_CMD_UPDATE_FIRMWARE_EX",
179 "Supports command EMU_CMD_FILE_IO",
180 "Supports command EMU_CMD_REGISTER",
181 "Supports command EMU_CMD_INDICATORS",
182 "Supports command EMU_CMD_TEST_NET_SPEED",
183 "Supports command EMU_CMD_RAWTRACE",
187 /* max speed 12MHz v5.0 jlink */
188 #define JLINK_MAX_SPEED 12000
190 /* J-Link hardware versions */
191 #define JLINK_HW_TYPE_JLINK 0
192 #define JLINK_HW_TYPE_JTRACE 1
193 #define JLINK_HW_TYPE_FLASHER 2
194 #define JLINK_HW_TYPE_JLINK_PRO 3
195 #define JLINK_HW_TYPE_MAX 4
197 static char *jlink_hw_type_str
[] = {
204 /* Queue command functions */
205 static void jlink_end_state(tap_state_t state
);
206 static void jlink_state_move(void);
207 static void jlink_path_move(int num_states
, tap_state_t
*path
);
208 static void jlink_runtest(int num_cycles
);
209 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
210 int scan_size
, struct scan_command
*command
);
211 static void jlink_reset(int trst
, int srst
);
212 static void jlink_simple_command(uint8_t command
);
213 static int jlink_get_status(void);
215 /* J-Link tap buffer functions */
216 static void jlink_tap_init(void);
217 static int jlink_tap_execute(void);
218 static void jlink_tap_ensure_space(int scans
, int bits
);
219 static void jlink_tap_append_step(int tms
, int tdi
);
220 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
221 struct scan_command
*command
);
223 /* Jlink lowlevel functions */
225 struct jtag_libusb_device_handle
*usb_handle
;
228 static struct jlink
*jlink_usb_open(void);
229 static void jlink_usb_close(struct jlink
*jlink
);
230 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
);
231 static int jlink_usb_io(struct jlink
*jlink
, int out_length
, int in_length
);
232 static int jlink_usb_write(struct jlink
*jlink
, int out_length
);
233 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
);
235 /* helper functions */
236 static int jlink_get_version_info(void);
238 #ifdef _DEBUG_USB_COMMS_
239 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
241 static inline void jlink_debug_buffer(uint8_t *buffer
, int length
)
246 static enum tap_state jlink_last_state
= TAP_RESET
;
248 static struct jlink
*jlink_handle
;
250 /* pid could be specified at runtime */
251 static uint16_t vids
[] = { 0x1366, 0x1366, 0x1366, 0x1366, 0x1366, 0 };
252 static uint16_t pids
[] = { 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0 };
254 static uint32_t jlink_caps
;
255 static uint32_t jlink_hw_type
;
257 /* 256 byte non-volatile memory */
258 struct jlink_config
{
260 /* 0ffset 0x01 to 0x03 */
261 uint8_t reserved_1
[3];
262 uint32_t kickstart_power_on_jtag_pin_19
;
263 /* 0ffset 0x08 to 0x1f */
264 uint8_t reserved_2
[24];
265 /* IP only for J-Link Pro */
266 uint8_t ip_address
[4];
267 uint8_t subnet_mask
[4];
268 /* 0ffset 0x28 to 0x2f */
269 uint8_t reserved_3
[8];
270 uint8_t mac_address
[6];
271 /* 0ffset 0x36 to 0xff */
272 uint8_t reserved_4
[202];
273 } __attribute__ ((packed
));
274 struct jlink_config jlink_cfg
;
276 /***************************************************************************/
277 /* External interface implementation */
279 static void jlink_execute_runtest(struct jtag_command
*cmd
)
281 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
282 cmd
->cmd
.runtest
->num_cycles
,
283 cmd
->cmd
.runtest
->end_state
);
285 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
287 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
290 static void jlink_execute_statemove(struct jtag_command
*cmd
)
292 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
294 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
298 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
300 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
301 cmd
->cmd
.pathmove
->num_states
,
302 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
304 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
305 cmd
->cmd
.pathmove
->path
);
308 static void jlink_execute_scan(struct jtag_command
*cmd
)
314 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
316 jlink_end_state(cmd
->cmd
.scan
->end_state
);
318 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
319 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
321 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
322 type
= jtag_scan_type(cmd
->cmd
.scan
);
323 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
324 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
327 static void jlink_execute_reset(struct jtag_command
*cmd
)
329 DEBUG_JTAG_IO("reset trst: %i srst %i",
330 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
333 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
337 static void jlink_execute_sleep(struct jtag_command
*cmd
)
339 DEBUG_JTAG_IO("sleep %" PRIi32
"", cmd
->cmd
.sleep
->us
);
341 jtag_sleep(cmd
->cmd
.sleep
->us
);
344 static void jlink_execute_command(struct jtag_command
*cmd
)
348 jlink_execute_runtest(cmd
);
351 jlink_execute_statemove(cmd
);
354 jlink_execute_pathmove(cmd
);
357 jlink_execute_scan(cmd
);
360 jlink_execute_reset(cmd
);
363 jlink_execute_sleep(cmd
);
366 LOG_ERROR("BUG: unknown JTAG command type encountered");
371 static int jlink_execute_queue(void)
373 struct jtag_command
*cmd
= jtag_command_queue
;
375 while (cmd
!= NULL
) {
376 jlink_execute_command(cmd
);
380 return jlink_tap_execute();
383 /* Sets speed in kHz. */
384 static int jlink_speed(int speed
)
388 if (speed
> JLINK_MAX_SPEED
) {
389 LOG_INFO("reduce speed request: %dkHz to %dkHz maximum",
390 speed
, JLINK_MAX_SPEED
);
391 speed
= JLINK_MAX_SPEED
;
394 /* check for RTCK setting */
398 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
399 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
400 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
402 result
= jlink_usb_write(jlink_handle
, 3);
404 LOG_ERROR("J-Link setting speed failed (%d)", result
);
405 return ERROR_JTAG_DEVICE_ERROR
;
411 static int jlink_speed_div(int speed
, int *khz
)
418 static int jlink_khz(int khz
, int *jtag_speed
)
426 * select transport interface
428 * @param iface [0..31] currently: 0=JTAG, 1=SWD
429 * @returns ERROR_OK or ERROR_ code
431 * @pre jlink_handle must be opened
432 * @pre function may be called only for devices, that have
433 * EMU_CAP_SELECT_IF capability enabled
435 static int jlink_select_interface(int iface
)
437 /* According to Segger's document RM08001-R7 Date: October 8, 2010,
438 * http://www.segger.com/admin/uploads/productDocs/RM08001_JLinkUSBProtocol.pdf
439 * section 5.5.3 EMU_CMD_SELECT_IF
440 * > SubCmd 1..31 to select interface (0..31)
442 * The table below states:
446 * This obviosly means that to select TIF_JTAG one should write SubCmd = 1.
448 * In fact, JTAG interface operates when SubCmd=0
450 * It looks like a typo in documentation, because interfaces 0..31 could not
451 * be selected by 1..31 range command.
453 assert(iface
>= 0 && iface
< 32);
456 /* get available interfaces */
457 usb_out_buffer
[0] = EMU_CMD_SELECT_IF
;
458 usb_out_buffer
[1] = 0xff;
460 result
= jlink_usb_io(jlink_handle
, 2, 4);
461 if (result
!= ERROR_OK
) {
462 LOG_ERROR("J-Link query interface failed (%d)", result
);
463 return ERROR_JTAG_DEVICE_ERROR
;
466 uint32_t iface_mask
= buf_get_u32(usb_in_buffer
, 0, 32);
468 if (!(iface_mask
& (1<<iface
))) {
469 LOG_ERROR("J-Link requesting to select unsupported interface (%" PRIx32
")", iface_mask
);
470 return ERROR_JTAG_DEVICE_ERROR
;
473 /* Select interface */
474 usb_out_buffer
[0] = EMU_CMD_SELECT_IF
;
475 usb_out_buffer
[1] = iface
;
477 result
= jlink_usb_io(jlink_handle
, 2, 4);
478 if (result
!= ERROR_OK
) {
479 LOG_ERROR("J-Link interface select failed (%d)", result
);
480 return ERROR_JTAG_DEVICE_ERROR
;
486 static int jlink_init(void)
490 jlink_handle
= jlink_usb_open();
492 if (jlink_handle
== 0) {
493 LOG_ERROR("Cannot find jlink Interface! Please check "
494 "connection and permissions.");
495 return ERROR_JTAG_INIT_FAILED
;
499 * The next three instructions were added after discovering a problem
500 * while using an oscilloscope.
501 * For the V8 SAM-ICE dongle (and likely other j-link device variants),
502 * the reset line to the target microprocessor was found to cycle only
503 * intermittently during emulator startup (even after encountering the
504 * downstream reset instruction later in the code).
505 * This was found to create two issues:
506 * 1) In general it is a bad practice to not reset a CPU to a known
507 * state when starting an emulator and
508 * 2) something critical happens inside the dongle when it does the
509 * first read following a new USB session.
510 * Keeping the processor in reset during the first read collecting
511 * version information seems to prevent errant
512 * "J-Link command EMU_CMD_VERSION failed" issues.
515 LOG_INFO("J-Link initialization started / target CPU reset initiated");
516 jlink_simple_command(EMU_CMD_HW_TRST0
);
517 jlink_simple_command(EMU_CMD_HW_RESET0
);
520 jlink_hw_jtag_version
= 2;
522 if (jlink_get_version_info() == ERROR_OK
) {
523 /* attempt to get status */
528 * Some versions of Segger's software do not select JTAG interface by default.
530 * Segger recommends to select interface necessarily as a part of init process,
531 * in case any previous session leaves improper interface selected.
533 * Until SWD implemented, select only JTAG interface here.
535 if (jlink_caps
& (1<<EMU_CAP_SELECT_IF
))
536 jlink_select_interface(0);
538 LOG_INFO("J-Link JTAG Interface ready");
544 /* v5/6 jlink seems to have an issue if the first tap move
545 * is not divisible by 8, so we send a TLR on first power up */
546 for (i
= 0; i
< 8; i
++)
547 jlink_tap_append_step(1, 0);
553 static int jlink_quit(void)
555 jlink_usb_close(jlink_handle
);
559 /***************************************************************************/
560 /* Queue command implementations */
562 static void jlink_end_state(tap_state_t state
)
564 if (tap_is_state_stable(state
))
565 tap_set_end_state(state
);
567 LOG_ERROR("BUG: %i is not a valid end state", state
);
572 /* Goes to the end state. */
573 static void jlink_state_move(void)
577 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
578 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
580 for (i
= 0; i
< tms_scan_bits
; i
++) {
581 tms
= (tms_scan
>> i
) & 1;
582 jlink_tap_append_step(tms
, 0);
585 tap_set_state(tap_get_end_state());
588 static void jlink_path_move(int num_states
, tap_state_t
*path
)
592 for (i
= 0; i
< num_states
; i
++) {
593 if (path
[i
] == tap_state_transition(tap_get_state(), false))
594 jlink_tap_append_step(0, 0);
595 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
596 jlink_tap_append_step(1, 0);
598 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
599 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
603 tap_set_state(path
[i
]);
606 tap_set_end_state(tap_get_state());
609 static void jlink_runtest(int num_cycles
)
613 tap_state_t saved_end_state
= tap_get_end_state();
615 jlink_tap_ensure_space(1, num_cycles
+ 16);
617 /* only do a state_move when we're not already in IDLE */
618 if (tap_get_state() != TAP_IDLE
) {
619 jlink_end_state(TAP_IDLE
);
624 /* execute num_cycles */
625 for (i
= 0; i
< num_cycles
; i
++)
626 jlink_tap_append_step(0, 0);
628 /* finish in end_state */
629 jlink_end_state(saved_end_state
);
630 if (tap_get_state() != tap_get_end_state())
634 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
635 int scan_size
, struct scan_command
*command
)
637 tap_state_t saved_end_state
;
639 jlink_tap_ensure_space(1, scan_size
+ 16);
641 saved_end_state
= tap_get_end_state();
643 /* Move to appropriate scan state */
644 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
646 /* Only move if we're not already there */
647 if (tap_get_state() != tap_get_end_state())
650 jlink_end_state(saved_end_state
);
653 jlink_tap_append_scan(scan_size
, buffer
, command
);
655 /* We are in Exit1, go to Pause */
656 jlink_tap_append_step(0, 0);
658 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
660 if (tap_get_state() != tap_get_end_state())
664 static void jlink_reset(int trst
, int srst
)
666 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
668 /* Signals are active low */
670 jlink_simple_command(EMU_CMD_HW_RESET1
);
673 jlink_simple_command(EMU_CMD_HW_RESET0
);
676 jlink_simple_command(EMU_CMD_HW_TRST0
);
679 jlink_simple_command(EMU_CMD_HW_TRST1
);
682 static void jlink_simple_command(uint8_t command
)
686 DEBUG_JTAG_IO("0x%02x", command
);
688 usb_out_buffer
[0] = command
;
689 result
= jlink_usb_write(jlink_handle
, 1);
692 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
695 static int jlink_get_status(void)
699 jlink_simple_command(EMU_CMD_GET_STATE
);
701 result
= jlink_usb_read(jlink_handle
, 8);
703 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)", result
);
704 return ERROR_JTAG_DEVICE_ERROR
;
707 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
708 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \
709 vref
/ 1000, vref
% 1000, \
710 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
711 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
714 LOG_ERROR("Vref too low. Check Target Power");
719 #define jlink_dump_printf(context, expr ...) \
722 command_print(context, expr); \
727 static void jlink_caps_dump(struct command_context
*ctx
)
731 jlink_dump_printf(ctx
, "J-Link Capabilities");
733 for (i
= 1; i
< 31; i
++)
734 if (jlink_caps
& (1 << i
))
735 jlink_dump_printf(ctx
, "%s", jlink_cap_str
[i
]);
738 static void jlink_config_usb_address_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
743 jlink_dump_printf(ctx
, "USB-Address: 0x%x", cfg
->usb_address
);
746 static void jlink_config_kickstart_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
751 jlink_dump_printf(ctx
, "Kickstart power on JTAG-pin 19: 0x%" PRIx32
,
752 cfg
->kickstart_power_on_jtag_pin_19
);
755 static void jlink_config_mac_address_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
760 jlink_dump_printf(ctx
, "MAC Address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
761 cfg
->mac_address
[5], cfg
->mac_address
[4],
762 cfg
->mac_address
[3], cfg
->mac_address
[2],
763 cfg
->mac_address
[1], cfg
->mac_address
[0]);
766 static void jlink_config_ip_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
771 jlink_dump_printf(ctx
, "IP Address: %d.%d.%d.%d",
772 cfg
->ip_address
[3], cfg
->ip_address
[2],
773 cfg
->ip_address
[1], cfg
->ip_address
[0]);
774 jlink_dump_printf(ctx
, "Subnet Mask: %d.%d.%d.%d",
775 cfg
->subnet_mask
[3], cfg
->subnet_mask
[2],
776 cfg
->subnet_mask
[1], cfg
->subnet_mask
[0]);
779 static void jlink_config_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
784 jlink_dump_printf(ctx
, "J-Link configuration");
785 jlink_config_usb_address_dump(ctx
, cfg
);
786 jlink_config_kickstart_dump(ctx
, cfg
);
788 if (jlink_hw_type
== JLINK_HW_TYPE_JLINK_PRO
) {
789 jlink_config_ip_dump(ctx
, cfg
);
790 jlink_config_mac_address_dump(ctx
, cfg
);
794 static int jlink_get_config(struct jlink_config
*cfg
)
797 int size
= sizeof(struct jlink_config
);
799 usb_out_buffer
[0] = EMU_CMD_READ_CONFIG
;
800 result
= jlink_usb_io(jlink_handle
, 1, size
);
802 if (result
!= ERROR_OK
) {
803 LOG_ERROR("jlink_usb_read failed (requested=%d, result=%d)", size
, result
);
807 memcpy(cfg
, usb_in_buffer
, size
);
811 static int jlink_set_config(struct jlink_config
*cfg
)
814 int size
= sizeof(struct jlink_config
);
816 jlink_simple_command(EMU_CMD_WRITE_CONFIG
);
818 memcpy(usb_out_buffer
, cfg
, size
);
820 result
= jlink_usb_write(jlink_handle
, size
);
821 if (result
!= size
) {
822 LOG_ERROR("jlink_usb_write failed (requested=%d, result=%d)", 256, result
);
830 * List of unsupported version string markers.
832 * The firmware versions does not correspond directly with
833 * "Software and documentation pack for Windows", it may be
834 * distinguished by the "compile" date in the information string.
836 * For example, version string is:
837 * "J-Link ARM V8 compiled May 3 2012 18:36:22"
841 * The list must be terminated by NULL string.
843 static const char * const unsupported_versions
[] = {
846 NULL
/* End of list */
849 static void jlink_check_supported(const char *str
)
851 const char * const *p
= unsupported_versions
;
853 if (NULL
!= strstr(str
, *p
)) {
855 "Unsupported J-Link firmware version.\n"
856 " Please check http://www.segger.com/j-link-older-versions.html for updates");
863 static int jlink_get_version_info(void)
867 uint32_t jlink_max_size
;
869 /* query hardware version */
870 jlink_simple_command(EMU_CMD_VERSION
);
872 result
= jlink_usb_read(jlink_handle
, 2);
874 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
875 return ERROR_JTAG_DEVICE_ERROR
;
878 len
= buf_get_u32(usb_in_buffer
, 0, 16);
879 if (len
> JLINK_IN_BUFFER_SIZE
) {
880 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
881 len
= JLINK_IN_BUFFER_SIZE
;
884 result
= jlink_usb_read(jlink_handle
, len
);
886 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
887 return ERROR_JTAG_DEVICE_ERROR
;
890 usb_in_buffer
[result
] = 0;
891 LOG_INFO("%s", (char *)usb_in_buffer
);
892 jlink_check_supported((char *)usb_in_buffer
);
894 /* query hardware capabilities */
895 jlink_simple_command(EMU_CMD_GET_CAPS
);
897 result
= jlink_usb_read(jlink_handle
, 4);
899 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", result
);
900 return ERROR_JTAG_DEVICE_ERROR
;
903 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
904 LOG_INFO("J-Link caps 0x%x", (unsigned)jlink_caps
);
906 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
)) {
907 /* query hardware version */
908 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
910 result
= jlink_usb_read(jlink_handle
, 4);
912 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result
);
913 return ERROR_JTAG_DEVICE_ERROR
;
916 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
917 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
918 jlink_hw_type
= (jlink_hw_version
/ 1000000) % 100;
919 if (major_revision
>= 5)
920 jlink_hw_jtag_version
= 3;
922 LOG_INFO("J-Link hw version %i", (int)jlink_hw_version
);
924 if (jlink_hw_type
>= JLINK_HW_TYPE_MAX
)
925 LOG_INFO("J-Link hw type uknown 0x%" PRIx32
, jlink_hw_type
);
927 LOG_INFO("J-Link hw type %s", jlink_hw_type_str
[jlink_hw_type
]);
930 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
)) {
931 /* query hardware maximum memory block */
932 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
934 result
= jlink_usb_read(jlink_handle
, 4);
936 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", result
);
937 return ERROR_JTAG_DEVICE_ERROR
;
940 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
941 LOG_INFO("J-Link max mem block %i", (int)jlink_max_size
);
944 if (jlink_caps
& (1 << EMU_CAP_READ_CONFIG
)) {
945 if (jlink_get_config(&jlink_cfg
) != ERROR_OK
)
946 return ERROR_JTAG_DEVICE_ERROR
;
948 jlink_config_dump(NULL
, &jlink_cfg
);
954 COMMAND_HANDLER(jlink_pid_command
)
957 LOG_ERROR("Need exactly one argument to jlink_pid");
961 pids
[0] = strtoul(CMD_ARGV
[0], NULL
, 16);
968 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
970 if (jlink_get_version_info() == ERROR_OK
) {
971 /* attempt to get status */
978 COMMAND_HANDLER(jlink_handle_jlink_caps_command
)
980 jlink_caps_dump(CMD_CTX
);
985 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
989 command_print(CMD_CTX
, "J-Link hw jtag %i", jlink_hw_jtag_version
);
992 int request_version
= atoi(CMD_ARGV
[0]);
993 switch (request_version
) {
996 jlink_hw_jtag_version
= request_version
;
999 return ERROR_COMMAND_SYNTAX_ERROR
;
1004 return ERROR_COMMAND_SYNTAX_ERROR
;
1010 COMMAND_HANDLER(jlink_handle_jlink_kickstart_command
)
1015 jlink_config_kickstart_dump(CMD_CTX
, &jlink_cfg
);
1019 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], kickstart
);
1021 jlink_cfg
.kickstart_power_on_jtag_pin_19
= kickstart
;
1025 COMMAND_HANDLER(jlink_handle_jlink_mac_address_command
)
1033 jlink_config_mac_address_dump(CMD_CTX
, &jlink_cfg
);
1039 if ((strlen(str
) != 17) || (str
[2] != ':' || str
[5] != ':' || str
[8] != ':' ||
1040 str
[11] != ':' || str
[14] != ':')) {
1041 command_print(CMD_CTX
, "ethaddr miss format ff:ff:ff:ff:ff:ff");
1042 return ERROR_COMMAND_SYNTAX_ERROR
;
1045 for (i
= 5; i
>= 0; i
--) {
1046 addr
[i
] = strtoul(str
, &e
, 16);
1050 if (!(addr
[0] | addr
[1] | addr
[2] | addr
[3] | addr
[4] | addr
[5])) {
1051 command_print(CMD_CTX
, "invalid it's zero mac_address");
1052 return ERROR_COMMAND_SYNTAX_ERROR
;
1055 if (!(0x01 & addr
[0])) {
1056 command_print(CMD_CTX
, "invalid it's a multicat mac_address");
1057 return ERROR_COMMAND_SYNTAX_ERROR
;
1060 memcpy(jlink_cfg
.mac_address
, addr
, sizeof(addr
));
1065 static int string_to_ip(const char *s
, uint8_t *ip
, int *pos
)
1069 const char *s_save
= s
;
1075 for (i
= 0; i
< 4; i
++) {
1076 lip
[i
] = strtoul(s
, &e
, 10);
1078 if (*e
!= '.' && i
!= 3)
1086 memcpy(ip
, lip
, sizeof(lip
));
1090 static void cpy_ip(uint8_t *dst
, uint8_t *src
)
1094 for (i
= 0, j
= 3; i
< 4; i
++, j
--)
1098 COMMAND_HANDLER(jlink_handle_jlink_ip_command
)
1100 uint32_t ip_address
;
1101 uint32_t subnet_mask
= 0;
1104 uint8_t subnet_bits
= 24;
1107 jlink_config_ip_dump(CMD_CTX
, &jlink_cfg
);
1111 ret
= string_to_ip(CMD_ARGV
[0], (uint8_t *)&ip_address
, &i
);
1112 if (ret
!= ERROR_OK
)
1115 len
= strlen(CMD_ARGV
[0]);
1117 /* check for this format A.B.C.D/E */
1120 if (CMD_ARGV
[0][i
] != '/')
1121 return ERROR_COMMAND_SYNTAX_ERROR
;
1123 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0] + i
+ 1, subnet_bits
);
1126 ret
= string_to_ip(CMD_ARGV
[1], (uint8_t *)&subnet_mask
, &i
);
1127 if (ret
!= ERROR_OK
)
1133 subnet_mask
= (uint32_t)(subnet_bits
< 32 ?
1134 ((1ULL << subnet_bits
) - 1) : 0xffffffff);
1136 cpy_ip(jlink_cfg
.ip_address
, (uint8_t *)&ip_address
);
1137 cpy_ip(jlink_cfg
.subnet_mask
, (uint8_t *)&subnet_mask
);
1142 COMMAND_HANDLER(jlink_handle_jlink_reset_command
)
1144 memset(&jlink_cfg
, 0xff, sizeof(jlink_cfg
));
1148 COMMAND_HANDLER(jlink_handle_jlink_save_command
)
1150 if (!(jlink_caps
& (1 << EMU_CAP_WRITE_CONFIG
))) {
1151 command_print(CMD_CTX
, "J-Link write emulator configuration not supported");
1155 command_print(CMD_CTX
, "The J-Link need to be unpluged and repluged ta have the config effective");
1156 return jlink_set_config(&jlink_cfg
);
1159 COMMAND_HANDLER(jlink_handle_jlink_usb_address_command
)
1164 jlink_config_usb_address_dump(CMD_CTX
, &jlink_cfg
);
1168 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], address
);
1170 if (address
> 0x3 && address
!= 0xff) {
1171 command_print(CMD_CTX
, "USB Address must be between 0x00 and 0x03 or 0xff");
1172 return ERROR_COMMAND_SYNTAX_ERROR
;
1175 jlink_cfg
.usb_address
= address
;
1179 COMMAND_HANDLER(jlink_handle_jlink_config_command
)
1181 struct jlink_config cfg
;
1184 if (CMD_ARGC
== 0) {
1185 if (!(jlink_caps
& (1 << EMU_CAP_READ_CONFIG
))) {
1186 command_print(CMD_CTX
, "J-Link read emulator configuration not supported");
1190 ret
= jlink_get_config(&cfg
);
1192 if (ret
!= ERROR_OK
)
1193 command_print(CMD_CTX
, "J-Link read emulator configuration failled");
1195 jlink_config_dump(CMD_CTX
, &jlink_cfg
);
1202 static const struct command_registration jlink_config_subcommand_handlers
[] = {
1204 .name
= "kickstart",
1205 .handler
= &jlink_handle_jlink_kickstart_command
,
1206 .mode
= COMMAND_EXEC
,
1207 .help
= "set Kickstart power on JTAG-pin 19.",
1211 .name
= "mac_address",
1212 .handler
= &jlink_handle_jlink_mac_address_command
,
1213 .mode
= COMMAND_EXEC
,
1214 .help
= "set the MAC Address",
1215 .usage
= "[ff:ff:ff:ff:ff:ff]",
1219 .handler
= &jlink_handle_jlink_ip_command
,
1220 .mode
= COMMAND_EXEC
,
1221 .help
= "set the ip address of the J-Link Pro, "
1222 "where A.B.C.D is the ip, "
1223 "E the bit of the subnet mask, "
1224 "F.G.H.I the subnet mask",
1225 .usage
= "[A.B.C.D[/E] [F.G.H.I]]",
1229 .handler
= &jlink_handle_jlink_reset_command
,
1230 .mode
= COMMAND_EXEC
,
1231 .help
= "reset the current config",
1235 .handler
= &jlink_handle_jlink_save_command
,
1236 .mode
= COMMAND_EXEC
,
1237 .help
= "save the current config",
1240 .name
= "usb_address",
1241 .handler
= &jlink_handle_jlink_usb_address_command
,
1242 .mode
= COMMAND_EXEC
,
1243 .help
= "set the USB-Address, "
1244 "This will change the product id",
1245 .usage
= "[0x00 to 0x03 or 0xff]",
1247 COMMAND_REGISTRATION_DONE
1250 static const struct command_registration jlink_subcommand_handlers
[] = {
1253 .handler
= &jlink_handle_jlink_caps_command
,
1254 .mode
= COMMAND_EXEC
,
1255 .help
= "show jlink capabilities",
1259 .handler
= &jlink_handle_jlink_info_command
,
1260 .mode
= COMMAND_EXEC
,
1261 .help
= "show jlink info",
1265 .handler
= &jlink_handle_jlink_hw_jtag_command
,
1266 .mode
= COMMAND_EXEC
,
1267 .help
= "access J-Link HW JTAG command version",
1272 .handler
= &jlink_handle_jlink_config_command
,
1273 .mode
= COMMAND_EXEC
,
1274 .help
= "access J-Link configuration, "
1275 "if no argument this will dump the config",
1276 .chain
= jlink_config_subcommand_handlers
,
1280 .handler
= &jlink_pid_command
,
1281 .mode
= COMMAND_CONFIG
,
1282 .help
= "set the pid of the interface we want to use",
1284 COMMAND_REGISTRATION_DONE
1287 static const struct command_registration jlink_command_handlers
[] = {
1290 .mode
= COMMAND_ANY
,
1291 .help
= "perform jlink management",
1292 .chain
= jlink_subcommand_handlers
,
1294 COMMAND_REGISTRATION_DONE
1297 struct jtag_interface jlink_interface
= {
1299 .commands
= jlink_command_handlers
,
1300 .transports
= jtag_only
,
1302 .execute_queue
= jlink_execute_queue
,
1303 .speed
= jlink_speed
,
1304 .speed_div
= jlink_speed_div
,
1310 /***************************************************************************/
1311 /* J-Link tap functions */
1314 static unsigned tap_length
;
1315 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
1316 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
1317 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
1319 struct pending_scan_result
{
1320 int first
; /* First bit position in tdo_buffer to read */
1321 int length
; /* Number of bits to read */
1322 struct scan_command
*command
; /* Corresponding scan command */
1326 #define MAX_PENDING_SCAN_RESULTS 256
1328 static int pending_scan_results_length
;
1329 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
1331 static void jlink_tap_init(void)
1334 pending_scan_results_length
= 0;
1337 static void jlink_tap_ensure_space(int scans
, int bits
)
1339 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
1340 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
1342 if (scans
> available_scans
|| bits
> available_bits
)
1343 jlink_tap_execute();
1346 static void jlink_tap_append_step(int tms
, int tdi
)
1348 int index_var
= tap_length
/ 8;
1350 assert(index_var
< JLINK_TAP_BUFFER_SIZE
);
1352 int bit_index
= tap_length
% 8;
1353 uint8_t bit
= 1 << bit_index
;
1355 /* we do not pad TMS, so be sure to initialize all bits */
1357 tms_buffer
[index_var
] = tdi_buffer
[index_var
] = 0;
1360 tms_buffer
[index_var
] |= bit
;
1362 tms_buffer
[index_var
] &= ~bit
;
1365 tdi_buffer
[index_var
] |= bit
;
1367 tdi_buffer
[index_var
] &= ~bit
;
1372 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
1373 struct scan_command
*command
)
1375 struct pending_scan_result
*pending_scan_result
=
1376 &pending_scan_results_buffer
[pending_scan_results_length
];
1379 pending_scan_result
->first
= tap_length
;
1380 pending_scan_result
->length
= length
;
1381 pending_scan_result
->command
= command
;
1382 pending_scan_result
->buffer
= buffer
;
1384 for (i
= 0; i
< length
; i
++) {
1385 int tms
= (i
< (length
- 1)) ? 0 : 1;
1386 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
1387 jlink_tap_append_step(tms
, tdi
);
1389 pending_scan_results_length
++;
1392 /* Pad and send a tap sequence to the device, and receive the answer.
1393 * For the purpose of padding we assume that we are in idle or pause state. */
1394 static int jlink_tap_execute(void)
1403 /* JLink returns an extra NULL in packet when size of incoming
1404 * message is a multiple of 64, creates problems with USB comms.
1405 * WARNING: This will interfere with tap state counting. */
1406 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
1407 jlink_tap_append_step((tap_get_state() == TAP_RESET
) ? 1 : 0, 0);
1409 /* number of full bytes (plus one if some would be left over) */
1410 byte_length
= DIV_ROUND_UP(tap_length
, 8);
1412 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
1413 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
1414 usb_out_buffer
[1] = 0;
1415 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
1416 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
1417 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
1418 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
1420 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
1421 tap_length
, jlink_last_state
);
1423 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
,
1424 use_jtag3
? byte_length
+ 1 : byte_length
);
1425 if (result
!= ERROR_OK
) {
1426 LOG_ERROR("jlink_tap_execute failed USB io (%d)", result
);
1428 return ERROR_JTAG_QUEUE_FAILED
;
1431 result
= use_jtag3
? usb_in_buffer
[byte_length
] : 0;
1433 LOG_ERROR("jlink_tap_execute failed, result %d (%s)", result
,
1434 result
== 1 ? "adaptive clocking timeout" : "unknown");
1436 return ERROR_JTAG_QUEUE_FAILED
;
1439 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
1441 for (i
= 0; i
< pending_scan_results_length
; i
++) {
1442 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
1443 uint8_t *buffer
= pending_scan_result
->buffer
;
1444 int length
= pending_scan_result
->length
;
1445 int first
= pending_scan_result
->first
;
1446 struct scan_command
*command
= pending_scan_result
->command
;
1448 /* Copy to buffer */
1449 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
1451 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
1453 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
1455 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
1457 return ERROR_JTAG_QUEUE_FAILED
;
1460 if (pending_scan_result
->buffer
!= NULL
)
1461 free(pending_scan_result
->buffer
);
1468 /*****************************************************************************/
1469 /* JLink USB low-level functions */
1471 static struct jlink
*jlink_usb_open()
1473 struct jtag_libusb_device_handle
*devh
;
1474 if (jtag_libusb_open(vids
, pids
, &devh
) != ERROR_OK
)
1477 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
1478 * AREA!!!!!!!!!!! The behavior of libusb is not completely
1479 * consistent across Windows, Linux, and Mac OS X platforms.
1480 * The actions taken in the following compiler conditionals may
1481 * not agree with published documentation for libusb, but were
1482 * found to be necessary through trials and tribulations. Even
1483 * little tweaks can break one or more platforms, so if you do
1484 * make changes test them carefully on all platforms before
1490 jtag_libusb_reset_device(devh
);
1495 /* reopen jlink after usb_reset
1496 * on win32 this may take a second or two to re-enumerate */
1498 while ((retval
= jtag_libusb_open(vids
, pids
, &devh
)) != ERROR_OK
) {
1504 if (ERROR_OK
!= retval
)
1510 /* usb_set_configuration required under win32 */
1511 struct jtag_libusb_device
*udev
= jtag_libusb_get_device(devh
);
1512 jtag_libusb_set_configuration(devh
, 0);
1513 jtag_libusb_claim_interface(devh
, 0);
1517 * This makes problems under Mac OS X. And is not needed
1518 * under Windows. Hopefully this will not break a linux build
1520 usb_set_altinterface(result
->usb_handle
, 0);
1523 /* Use the OB endpoints if the JLink we matched is a Jlink-OB adapter */
1524 uint16_t matched_pid
;
1525 if (jtag_libusb_get_pid(udev
, &matched_pid
) == ERROR_OK
) {
1526 if (matched_pid
== JLINK_OB_PID
) {
1527 jlink_read_ep
= JLINK_OB_WRITE_ENDPOINT
;
1528 jlink_write_ep
= JLINK_OB_READ_ENDPOINT
;
1532 jtag_libusb_get_endpoints(udev
, &jlink_read_ep
, &jlink_write_ep
);
1534 struct jlink
*result
= malloc(sizeof(struct jlink
));
1535 result
->usb_handle
= devh
;
1539 static void jlink_usb_close(struct jlink
*jlink
)
1541 jtag_libusb_close(jlink
->usb_handle
);
1545 /* Send a message and receive the reply. */
1546 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
1550 result
= jlink_usb_write(jlink
, out_length
);
1551 if (result
!= out_length
) {
1552 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
1553 out_length
, result
);
1554 return ERROR_JTAG_DEVICE_ERROR
;
1557 result
= jlink_usb_read(jlink
, in_length
);
1558 if (result
!= in_length
) {
1559 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
1561 return ERROR_JTAG_DEVICE_ERROR
;
1566 /* calls the given usb_bulk_* function, allowing for the data to
1567 * trickle in with some timeouts */
1568 static int usb_bulk_with_retries(
1569 int (*f
)(jtag_libusb_device_handle
*, int, char *, int, int),
1570 jtag_libusb_device_handle
*dev
, int ep
,
1571 char *bytes
, int size
, int timeout
)
1573 int tries
= 3, count
= 0;
1575 while (tries
&& (count
< size
)) {
1576 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1579 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1585 static int wrap_usb_bulk_write(jtag_libusb_device_handle
*dev
, int ep
,
1586 char *buff
, int size
, int timeout
)
1588 /* usb_bulk_write() takes const char *buff */
1589 return jtag_libusb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1592 static inline int usb_bulk_write_ex(jtag_libusb_device_handle
*dev
, int ep
,
1593 char *bytes
, int size
, int timeout
)
1595 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1596 dev
, ep
, bytes
, size
, timeout
);
1599 static inline int usb_bulk_read_ex(jtag_libusb_device_handle
*dev
, int ep
,
1600 char *bytes
, int size
, int timeout
)
1602 return usb_bulk_with_retries(&jtag_libusb_bulk_read
,
1603 dev
, ep
, bytes
, size
, timeout
);
1606 /* Write data from out_buffer to USB. */
1607 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1611 if (out_length
> JLINK_OUT_BUFFER_SIZE
) {
1612 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)",
1613 out_length
, JLINK_OUT_BUFFER_SIZE
);
1617 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1618 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1620 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d",
1621 out_length
, result
);
1623 jlink_debug_buffer(usb_out_buffer
, out_length
);
1627 /* Read data from USB into in_buffer. */
1628 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1630 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1631 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1633 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1635 jlink_debug_buffer(usb_in_buffer
, result
);
1640 * Send a message and receive the reply - simple messages.
1642 * @param jlink pointer to driver data
1643 * @param out_length data length in @c usb_out_buffer
1644 * @param in_length data length to be read to @c usb_in_buffer
1646 static int jlink_usb_io(struct jlink
*jlink
, int out_length
, int in_length
)
1650 result
= jlink_usb_write(jlink
, out_length
);
1651 if (result
!= out_length
) {
1652 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
1653 out_length
, result
);
1654 return ERROR_JTAG_DEVICE_ERROR
;
1657 result
= jlink_usb_read(jlink
, in_length
);
1658 if (result
!= in_length
) {
1659 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
1661 return ERROR_JTAG_DEVICE_ERROR
;
1665 * Section 4.2.4 IN-transaction:
1666 * read dummy 0-byte packet if transaction size is
1667 * multiple of 64 bytes but not max. size of 0x8000
1669 if ((in_length
% 64) == 0 && in_length
!= 0x8000) {
1671 result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1672 &dummy_buffer
, 1, JLINK_USB_TIMEOUT
);
1674 LOG_ERROR("dummy byte read failed");
1675 return ERROR_JTAG_DEVICE_ERROR
;
1681 #ifdef _DEBUG_USB_COMMS_
1682 #define BYTES_PER_LINE 16
1684 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1691 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
) {
1692 snprintf(line
, 5, "%04x", i
);
1693 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++) {
1694 snprintf(s
, 4, " %02x", buffer
[j
]);
1697 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)