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_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
);
234 static int jlink_usb_read_emu_result(struct jlink
*jlink
);
236 /* helper functions */
237 static int jlink_get_version_info(void);
239 #ifdef _DEBUG_USB_COMMS_
240 static void jlink_debug_buffer(uint8_t *buffer
, int length
);
242 static inline void jlink_debug_buffer(uint8_t *buffer
, int length
)
247 static enum tap_state jlink_last_state
= TAP_RESET
;
249 static struct jlink
*jlink_handle
;
251 /* pid could be specified at runtime */
252 static uint16_t vids
[] = { VID
, 0 };
253 static uint16_t pids
[] = { PID
, 0 };
255 static uint32_t jlink_caps
;
256 static uint32_t jlink_hw_type
;
258 /* 256 byte non-volatile memory */
259 struct jlink_config
{
261 /* 0ffset 0x01 to 0x03 */
262 uint8_t reserved_1
[3];
263 uint32_t kickstart_power_on_jtag_pin_19
;
264 /* 0ffset 0x08 to 0x1f */
265 uint8_t reserved_2
[24];
266 /* IP only for J-Link Pro */
267 uint8_t ip_address
[4];
268 uint8_t subnet_mask
[4];
269 /* 0ffset 0x28 to 0x2f */
270 uint8_t reserved_3
[8];
271 uint8_t mac_address
[6];
272 /* 0ffset 0x36 to 0xff */
273 uint8_t reserved_4
[202];
274 } __attribute__ ((packed
));
275 struct jlink_config jlink_cfg
;
277 /***************************************************************************/
278 /* External interface implementation */
280 static void jlink_execute_runtest(struct jtag_command
*cmd
)
282 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
283 cmd
->cmd
.runtest
->num_cycles
,
284 cmd
->cmd
.runtest
->end_state
);
286 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
288 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
291 static void jlink_execute_statemove(struct jtag_command
*cmd
)
293 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
295 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
299 static void jlink_execute_pathmove(struct jtag_command
*cmd
)
301 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
302 cmd
->cmd
.pathmove
->num_states
,
303 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
305 jlink_path_move(cmd
->cmd
.pathmove
->num_states
,
306 cmd
->cmd
.pathmove
->path
);
309 static void jlink_execute_scan(struct jtag_command
*cmd
)
315 DEBUG_JTAG_IO("scan end in %s", tap_state_name(cmd
->cmd
.scan
->end_state
));
317 jlink_end_state(cmd
->cmd
.scan
->end_state
);
319 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
320 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
322 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
323 type
= jtag_scan_type(cmd
->cmd
.scan
);
324 jlink_scan(cmd
->cmd
.scan
->ir_scan
,
325 type
, buffer
, scan_size
, cmd
->cmd
.scan
);
328 static void jlink_execute_reset(struct jtag_command
*cmd
)
330 DEBUG_JTAG_IO("reset trst: %i srst %i",
331 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
334 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
338 static void jlink_execute_sleep(struct jtag_command
*cmd
)
340 DEBUG_JTAG_IO("sleep %" PRIi32
"", cmd
->cmd
.sleep
->us
);
342 jtag_sleep(cmd
->cmd
.sleep
->us
);
345 static void jlink_execute_command(struct jtag_command
*cmd
)
349 jlink_execute_runtest(cmd
);
352 jlink_execute_statemove(cmd
);
355 jlink_execute_pathmove(cmd
);
358 jlink_execute_scan(cmd
);
361 jlink_execute_reset(cmd
);
364 jlink_execute_sleep(cmd
);
367 LOG_ERROR("BUG: unknown JTAG command type encountered");
372 static int jlink_execute_queue(void)
374 struct jtag_command
*cmd
= jtag_command_queue
;
376 while (cmd
!= NULL
) {
377 jlink_execute_command(cmd
);
381 return jlink_tap_execute();
384 /* Sets speed in kHz. */
385 static int jlink_speed(int speed
)
389 if (speed
> JLINK_MAX_SPEED
) {
390 LOG_INFO("reduce speed request: %dkHz to %dkHz maximum",
391 speed
, JLINK_MAX_SPEED
);
392 speed
= JLINK_MAX_SPEED
;
395 /* check for RTCK setting */
399 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
400 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
401 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
403 result
= jlink_usb_write(jlink_handle
, 3);
405 LOG_ERROR("J-Link setting speed failed (%d)", result
);
406 return ERROR_JTAG_DEVICE_ERROR
;
412 static int jlink_speed_div(int speed
, int *khz
)
419 static int jlink_khz(int khz
, int *jtag_speed
)
427 * select transport interface
429 * @param iface [0..31] currently: 0=JTAG, 1=SWD
430 * @returns ERROR_OK or ERROR_ code
432 * @pre jlink_handle must be opened
433 * @pre function may be called only for devices, that have
434 * EMU_CAP_SELECT_IF capability enabled
436 static int jlink_select_interface(int iface
)
438 /* According to Segger's document RM08001-R7 Date: October 8, 2010,
439 * http://www.segger.com/admin/uploads/productDocs/RM08001_JLinkUSBProtocol.pdf
440 * section 5.5.3 EMU_CMD_SELECT_IF
441 * > SubCmd 1..31 to select interface (0..31)
443 * The table below states:
447 * This obviosly means that to select TIF_JTAG one should write SubCmd = 1.
449 * In fact, JTAG interface operates when SubCmd=0
451 * It looks like a typo in documentation, because interfaces 0..31 could not
452 * be selected by 1..31 range command.
454 assert(iface
>= 0 && iface
< 32);
457 /* get available interfaces */
458 usb_out_buffer
[0] = EMU_CMD_SELECT_IF
;
459 usb_out_buffer
[1] = 0xff;
461 result
= jlink_usb_io(jlink_handle
, 2, 4);
462 if (result
!= ERROR_OK
) {
463 LOG_ERROR("J-Link query interface failed (%d)", result
);
464 return ERROR_JTAG_DEVICE_ERROR
;
467 uint32_t iface_mask
= buf_get_u32(usb_in_buffer
, 0, 32);
469 if (!(iface_mask
& (1<<iface
))) {
470 LOG_ERROR("J-Link requesting to select unsupported interface (%x)", iface_mask
);
471 return ERROR_JTAG_DEVICE_ERROR
;
474 /* Select interface */
475 usb_out_buffer
[0] = EMU_CMD_SELECT_IF
;
476 usb_out_buffer
[1] = iface
;
478 result
= jlink_usb_io(jlink_handle
, 2, 4);
479 if (result
!= ERROR_OK
) {
480 LOG_ERROR("J-Link interface select failed (%d)", result
);
481 return ERROR_JTAG_DEVICE_ERROR
;
487 static int jlink_init(void)
491 jlink_handle
= jlink_usb_open();
493 if (jlink_handle
== 0) {
494 LOG_ERROR("Cannot find jlink Interface! Please check "
495 "connection and permissions.");
496 return ERROR_JTAG_INIT_FAILED
;
500 * The next three instructions were added after discovering a problem
501 * while using an oscilloscope.
502 * For the V8 SAM-ICE dongle (and likely other j-link device variants),
503 * the reset line to the target microprocessor was found to cycle only
504 * intermittently during emulator startup (even after encountering the
505 * downstream reset instruction later in the code).
506 * This was found to create two issues:
507 * 1) In general it is a bad practice to not reset a CPU to a known
508 * state when starting an emulator and
509 * 2) something critical happens inside the dongle when it does the
510 * first read following a new USB session.
511 * Keeping the processor in reset during the first read collecting
512 * version information seems to prevent errant
513 * "J-Link command EMU_CMD_VERSION failed" issues.
516 LOG_INFO("J-Link initialization started / target CPU reset initiated");
517 jlink_simple_command(EMU_CMD_HW_TRST0
);
518 jlink_simple_command(EMU_CMD_HW_RESET0
);
521 jlink_hw_jtag_version
= 2;
523 if (jlink_get_version_info() == ERROR_OK
) {
524 /* attempt to get status */
529 * Some versions of Segger's software do not select JTAG interface by default.
531 * Segger recommends to select interface necessarily as a part of init process,
532 * in case any previous session leaves improper interface selected.
534 * Until SWD implemented, select only JTAG interface here.
536 if (jlink_caps
& (1<<EMU_CAP_SELECT_IF
))
537 jlink_select_interface(0);
539 LOG_INFO("J-Link JTAG Interface ready");
545 /* v5/6 jlink seems to have an issue if the first tap move
546 * is not divisible by 8, so we send a TLR on first power up */
547 for (i
= 0; i
< 8; i
++)
548 jlink_tap_append_step(1, 0);
554 static int jlink_quit(void)
556 jlink_usb_close(jlink_handle
);
560 /***************************************************************************/
561 /* Queue command implementations */
563 static void jlink_end_state(tap_state_t state
)
565 if (tap_is_state_stable(state
))
566 tap_set_end_state(state
);
568 LOG_ERROR("BUG: %i is not a valid end state", state
);
573 /* Goes to the end state. */
574 static void jlink_state_move(void)
578 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
579 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
581 for (i
= 0; i
< tms_scan_bits
; i
++) {
582 tms
= (tms_scan
>> i
) & 1;
583 jlink_tap_append_step(tms
, 0);
586 tap_set_state(tap_get_end_state());
589 static void jlink_path_move(int num_states
, tap_state_t
*path
)
593 for (i
= 0; i
< num_states
; i
++) {
594 if (path
[i
] == tap_state_transition(tap_get_state(), false))
595 jlink_tap_append_step(0, 0);
596 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
597 jlink_tap_append_step(1, 0);
599 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
600 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
604 tap_set_state(path
[i
]);
607 tap_set_end_state(tap_get_state());
610 static void jlink_runtest(int num_cycles
)
614 tap_state_t saved_end_state
= tap_get_end_state();
616 jlink_tap_ensure_space(1, num_cycles
+ 16);
618 /* only do a state_move when we're not already in IDLE */
619 if (tap_get_state() != TAP_IDLE
) {
620 jlink_end_state(TAP_IDLE
);
625 /* execute num_cycles */
626 for (i
= 0; i
< num_cycles
; i
++)
627 jlink_tap_append_step(0, 0);
629 /* finish in end_state */
630 jlink_end_state(saved_end_state
);
631 if (tap_get_state() != tap_get_end_state())
635 static void jlink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
636 int scan_size
, struct scan_command
*command
)
638 tap_state_t saved_end_state
;
640 jlink_tap_ensure_space(1, scan_size
+ 16);
642 saved_end_state
= tap_get_end_state();
644 /* Move to appropriate scan state */
645 jlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
647 /* Only move if we're not already there */
648 if (tap_get_state() != tap_get_end_state())
651 jlink_end_state(saved_end_state
);
654 jlink_tap_append_scan(scan_size
, buffer
, command
);
656 /* We are in Exit1, go to Pause */
657 jlink_tap_append_step(0, 0);
659 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
661 if (tap_get_state() != tap_get_end_state())
665 static void jlink_reset(int trst
, int srst
)
667 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
669 /* Signals are active low */
671 jlink_simple_command(EMU_CMD_HW_RESET1
);
674 jlink_simple_command(EMU_CMD_HW_RESET0
);
677 jlink_simple_command(EMU_CMD_HW_TRST0
);
680 jlink_simple_command(EMU_CMD_HW_TRST1
);
683 static void jlink_simple_command(uint8_t command
)
687 DEBUG_JTAG_IO("0x%02x", command
);
689 usb_out_buffer
[0] = command
;
690 result
= jlink_usb_write(jlink_handle
, 1);
693 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
696 static int jlink_get_status(void)
700 jlink_simple_command(EMU_CMD_GET_STATE
);
702 result
= jlink_usb_read(jlink_handle
, 8);
704 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)", result
);
705 return ERROR_JTAG_DEVICE_ERROR
;
708 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
709 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d", \
710 vref
/ 1000, vref
% 1000, \
711 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
712 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
715 LOG_ERROR("Vref too low. Check Target Power");
720 #define jlink_dump_printf(context, expr ...) \
723 command_print(context, expr); \
728 static void jlink_caps_dump(struct command_context
*ctx
)
732 jlink_dump_printf(ctx
, "J-Link Capabilities");
734 for (i
= 1; i
< 31; i
++)
735 if (jlink_caps
& (1 << i
))
736 jlink_dump_printf(ctx
, "%s", jlink_cap_str
[i
]);
739 static void jlink_config_usb_address_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
744 jlink_dump_printf(ctx
, "USB-Address: 0x%x", cfg
->usb_address
);
747 static void jlink_config_kickstart_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
752 jlink_dump_printf(ctx
, "Kickstart power on JTAG-pin 19: 0x%x",
753 cfg
->kickstart_power_on_jtag_pin_19
);
756 static void jlink_config_mac_address_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
761 jlink_dump_printf(ctx
, "MAC Address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
762 cfg
->mac_address
[5], cfg
->mac_address
[4],
763 cfg
->mac_address
[3], cfg
->mac_address
[2],
764 cfg
->mac_address
[1], cfg
->mac_address
[0]);
767 static void jlink_config_ip_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
772 jlink_dump_printf(ctx
, "IP Address: %d.%d.%d.%d",
773 cfg
->ip_address
[3], cfg
->ip_address
[2],
774 cfg
->ip_address
[1], cfg
->ip_address
[0]);
775 jlink_dump_printf(ctx
, "Subnet Mask: %d.%d.%d.%d",
776 cfg
->subnet_mask
[3], cfg
->subnet_mask
[2],
777 cfg
->subnet_mask
[1], cfg
->subnet_mask
[0]);
780 static void jlink_config_dump(struct command_context
*ctx
, struct jlink_config
*cfg
)
785 jlink_dump_printf(ctx
, "J-Link configuration");
786 jlink_config_usb_address_dump(ctx
, cfg
);
787 jlink_config_kickstart_dump(ctx
, cfg
);
789 if (jlink_hw_type
== JLINK_HW_TYPE_JLINK_PRO
) {
790 jlink_config_ip_dump(ctx
, cfg
);
791 jlink_config_mac_address_dump(ctx
, cfg
);
795 static int jlink_get_config(struct jlink_config
*cfg
)
798 int size
= sizeof(struct jlink_config
);
800 usb_out_buffer
[0] = EMU_CMD_READ_CONFIG
;
801 result
= jlink_usb_io(jlink_handle
, 1, size
);
803 if (result
!= ERROR_OK
) {
804 LOG_ERROR("jlink_usb_read failed (requested=%d, result=%d)", size
, result
);
808 memcpy(cfg
, usb_in_buffer
, size
);
812 static int jlink_set_config(struct jlink_config
*cfg
)
815 int size
= sizeof(struct jlink_config
);
817 jlink_simple_command(EMU_CMD_WRITE_CONFIG
);
819 memcpy(usb_out_buffer
, cfg
, size
);
821 result
= jlink_usb_write(jlink_handle
, size
);
822 if (result
!= size
) {
823 LOG_ERROR("jlink_usb_write failed (requested=%d, result=%d)", 256, result
);
831 * List of unsupported version string markers.
833 * The firmware versions does not correspond directly with
834 * "Software and documentation pack for Windows", it may be
835 * distinguished by the "compile" date in the information string.
837 * For example, version string is:
838 * "J-Link ARM V8 compiled May 3 2012 18:36:22"
842 * The list must be terminated by NULL string.
844 static const char * const unsupported_versions
[] = {
847 NULL
/* End of list */
850 static void jlink_check_supported(const char *str
)
852 const char * const *p
= unsupported_versions
;
854 if (NULL
!= strstr(str
, *p
)) {
856 "Unsupported J-Link firmware version.\n"
857 " Please check http://www.segger.com/j-link-older-versions.html for updates");
864 static int jlink_get_version_info(void)
868 uint32_t jlink_max_size
;
870 /* query hardware version */
871 jlink_simple_command(EMU_CMD_VERSION
);
873 result
= jlink_usb_read(jlink_handle
, 2);
875 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
876 return ERROR_JTAG_DEVICE_ERROR
;
879 len
= buf_get_u32(usb_in_buffer
, 0, 16);
880 if (len
> JLINK_IN_BUFFER_SIZE
) {
881 LOG_ERROR("J-Link command EMU_CMD_VERSION impossible return length 0x%0x", len
);
882 len
= JLINK_IN_BUFFER_SIZE
;
885 result
= jlink_usb_read(jlink_handle
, len
);
887 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)", result
);
888 return ERROR_JTAG_DEVICE_ERROR
;
891 usb_in_buffer
[result
] = 0;
892 LOG_INFO("%s", (char *)usb_in_buffer
);
893 jlink_check_supported((char *)usb_in_buffer
);
895 /* query hardware capabilities */
896 jlink_simple_command(EMU_CMD_GET_CAPS
);
898 result
= jlink_usb_read(jlink_handle
, 4);
900 LOG_ERROR("J-Link command EMU_CMD_GET_CAPS failed (%d)", result
);
901 return ERROR_JTAG_DEVICE_ERROR
;
904 jlink_caps
= buf_get_u32(usb_in_buffer
, 0, 32);
905 LOG_INFO("J-Link caps 0x%x", (unsigned)jlink_caps
);
907 if (jlink_caps
& (1 << EMU_CAP_GET_HW_VERSION
)) {
908 /* query hardware version */
909 jlink_simple_command(EMU_CMD_GET_HW_VERSION
);
911 result
= jlink_usb_read(jlink_handle
, 4);
913 LOG_ERROR("J-Link command EMU_CMD_GET_HW_VERSION failed (%d)", result
);
914 return ERROR_JTAG_DEVICE_ERROR
;
917 uint32_t jlink_hw_version
= buf_get_u32(usb_in_buffer
, 0, 32);
918 uint32_t major_revision
= (jlink_hw_version
/ 10000) % 100;
919 jlink_hw_type
= (jlink_hw_version
/ 1000000) % 100;
920 if (major_revision
>= 5)
921 jlink_hw_jtag_version
= 3;
923 LOG_INFO("J-Link hw version %i", (int)jlink_hw_version
);
925 if (jlink_hw_type
>= JLINK_HW_TYPE_MAX
)
926 LOG_INFO("J-Link hw type uknown 0x%x", jlink_hw_type
);
928 LOG_INFO("J-Link hw type %s", jlink_hw_type_str
[jlink_hw_type
]);
931 if (jlink_caps
& (1 << EMU_CAP_GET_MAX_BLOCK_SIZE
)) {
932 /* query hardware maximum memory block */
933 jlink_simple_command(EMU_CMD_GET_MAX_MEM_BLOCK
);
935 result
= jlink_usb_read(jlink_handle
, 4);
937 LOG_ERROR("J-Link command EMU_CMD_GET_MAX_MEM_BLOCK failed (%d)", result
);
938 return ERROR_JTAG_DEVICE_ERROR
;
941 jlink_max_size
= buf_get_u32(usb_in_buffer
, 0, 32);
942 LOG_INFO("J-Link max mem block %i", (int)jlink_max_size
);
945 if (jlink_caps
& (1 << EMU_CAP_READ_CONFIG
)) {
946 if (jlink_get_config(&jlink_cfg
) != ERROR_OK
)
947 return ERROR_JTAG_DEVICE_ERROR
;
949 jlink_config_dump(NULL
, &jlink_cfg
);
955 COMMAND_HANDLER(jlink_pid_command
)
958 LOG_ERROR("Need exactly one argument to jlink_pid");
962 pids
[0] = strtoul(CMD_ARGV
[0], NULL
, 16);
969 COMMAND_HANDLER(jlink_handle_jlink_info_command
)
971 if (jlink_get_version_info() == ERROR_OK
) {
972 /* attempt to get status */
979 COMMAND_HANDLER(jlink_handle_jlink_caps_command
)
981 jlink_caps_dump(CMD_CTX
);
986 COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command
)
990 command_print(CMD_CTX
, "J-Link hw jtag %i", jlink_hw_jtag_version
);
993 int request_version
= atoi(CMD_ARGV
[0]);
994 switch (request_version
) {
997 jlink_hw_jtag_version
= request_version
;
1000 return ERROR_COMMAND_SYNTAX_ERROR
;
1005 return ERROR_COMMAND_SYNTAX_ERROR
;
1011 COMMAND_HANDLER(jlink_handle_jlink_kickstart_command
)
1016 jlink_config_kickstart_dump(CMD_CTX
, &jlink_cfg
);
1020 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], kickstart
);
1022 jlink_cfg
.kickstart_power_on_jtag_pin_19
= kickstart
;
1026 COMMAND_HANDLER(jlink_handle_jlink_mac_address_command
)
1034 jlink_config_mac_address_dump(CMD_CTX
, &jlink_cfg
);
1040 if ((strlen(str
) != 17) || (str
[2] != ':' || str
[5] != ':' || str
[8] != ':' ||
1041 str
[11] != ':' || str
[14] != ':')) {
1042 command_print(CMD_CTX
, "ethaddr miss format ff:ff:ff:ff:ff:ff");
1043 return ERROR_COMMAND_SYNTAX_ERROR
;
1046 for (i
= 5; i
>= 0; i
--) {
1047 addr
[i
] = strtoul(str
, &e
, 16);
1051 if (!(addr
[0] | addr
[1] | addr
[2] | addr
[3] | addr
[4] | addr
[5])) {
1052 command_print(CMD_CTX
, "invalid it's zero mac_address");
1053 return ERROR_COMMAND_SYNTAX_ERROR
;
1056 if (!(0x01 & addr
[0])) {
1057 command_print(CMD_CTX
, "invalid it's a multicat mac_address");
1058 return ERROR_COMMAND_SYNTAX_ERROR
;
1061 memcpy(jlink_cfg
.mac_address
, addr
, sizeof(addr
));
1066 static int string_to_ip(const char *s
, uint8_t *ip
, int *pos
)
1070 const char *s_save
= s
;
1076 for (i
= 0; i
< 4; i
++) {
1077 lip
[i
] = strtoul(s
, &e
, 10);
1079 if (*e
!= '.' && i
!= 3)
1087 memcpy(ip
, lip
, sizeof(lip
));
1091 static void cpy_ip(uint8_t *dst
, uint8_t *src
)
1095 for (i
= 0, j
= 3; i
< 4; i
++, j
--)
1099 COMMAND_HANDLER(jlink_handle_jlink_ip_command
)
1101 uint32_t ip_address
;
1102 uint32_t subnet_mask
= 0;
1105 uint8_t subnet_bits
= 24;
1108 jlink_config_ip_dump(CMD_CTX
, &jlink_cfg
);
1112 ret
= string_to_ip(CMD_ARGV
[0], (uint8_t *)&ip_address
, &i
);
1113 if (ret
!= ERROR_OK
)
1116 len
= strlen(CMD_ARGV
[0]);
1118 /* check for this format A.B.C.D/E */
1121 if (CMD_ARGV
[0][i
] != '/')
1122 return ERROR_COMMAND_SYNTAX_ERROR
;
1124 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0] + i
+ 1, subnet_bits
);
1127 ret
= string_to_ip(CMD_ARGV
[1], (uint8_t *)&subnet_mask
, &i
);
1128 if (ret
!= ERROR_OK
)
1134 subnet_mask
= (uint32_t)(subnet_bits
< 32 ?
1135 ((1ULL << subnet_bits
) - 1) : 0xffffffff);
1137 cpy_ip(jlink_cfg
.ip_address
, (uint8_t *)&ip_address
);
1138 cpy_ip(jlink_cfg
.subnet_mask
, (uint8_t *)&subnet_mask
);
1143 COMMAND_HANDLER(jlink_handle_jlink_reset_command
)
1145 memset(&jlink_cfg
, 0xff, sizeof(jlink_cfg
));
1149 COMMAND_HANDLER(jlink_handle_jlink_save_command
)
1151 if (!(jlink_caps
& (1 << EMU_CAP_WRITE_CONFIG
))) {
1152 command_print(CMD_CTX
, "J-Link write emulator configuration not supported");
1156 command_print(CMD_CTX
, "The J-Link need to be unpluged and repluged ta have the config effective");
1157 return jlink_set_config(&jlink_cfg
);
1160 COMMAND_HANDLER(jlink_handle_jlink_usb_address_command
)
1165 jlink_config_usb_address_dump(CMD_CTX
, &jlink_cfg
);
1169 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], address
);
1171 if (address
> 0x3 && address
!= 0xff) {
1172 command_print(CMD_CTX
, "USB Address must be between 0x00 and 0x03 or 0xff");
1173 return ERROR_COMMAND_SYNTAX_ERROR
;
1176 jlink_cfg
.usb_address
= address
;
1180 COMMAND_HANDLER(jlink_handle_jlink_config_command
)
1182 struct jlink_config cfg
;
1185 if (CMD_ARGC
== 0) {
1186 if (!(jlink_caps
& (1 << EMU_CAP_READ_CONFIG
))) {
1187 command_print(CMD_CTX
, "J-Link read emulator configuration not supported");
1191 ret
= jlink_get_config(&cfg
);
1193 if (ret
!= ERROR_OK
)
1194 command_print(CMD_CTX
, "J-Link read emulator configuration failled");
1196 jlink_config_dump(CMD_CTX
, &jlink_cfg
);
1203 static const struct command_registration jlink_config_subcommand_handlers
[] = {
1205 .name
= "kickstart",
1206 .handler
= &jlink_handle_jlink_kickstart_command
,
1207 .mode
= COMMAND_EXEC
,
1208 .help
= "set Kickstart power on JTAG-pin 19.",
1212 .name
= "mac_address",
1213 .handler
= &jlink_handle_jlink_mac_address_command
,
1214 .mode
= COMMAND_EXEC
,
1215 .help
= "set the MAC Address",
1216 .usage
= "[ff:ff:ff:ff:ff:ff]",
1220 .handler
= &jlink_handle_jlink_ip_command
,
1221 .mode
= COMMAND_EXEC
,
1222 .help
= "set the ip address of the J-Link Pro, "
1223 "where A.B.C.D is the ip, "
1224 "E the bit of the subnet mask, "
1225 "F.G.H.I the subnet mask",
1226 .usage
= "[A.B.C.D[/E] [F.G.H.I]]",
1230 .handler
= &jlink_handle_jlink_reset_command
,
1231 .mode
= COMMAND_EXEC
,
1232 .help
= "reset the current config",
1236 .handler
= &jlink_handle_jlink_save_command
,
1237 .mode
= COMMAND_EXEC
,
1238 .help
= "save the current config",
1241 .name
= "usb_address",
1242 .handler
= &jlink_handle_jlink_usb_address_command
,
1243 .mode
= COMMAND_EXEC
,
1244 .help
= "set the USB-Address, "
1245 "This will change the product id",
1246 .usage
= "[0x00 to 0x03 or 0xff]",
1248 COMMAND_REGISTRATION_DONE
1251 static const struct command_registration jlink_subcommand_handlers
[] = {
1254 .handler
= &jlink_handle_jlink_caps_command
,
1255 .mode
= COMMAND_EXEC
,
1256 .help
= "show jlink capabilities",
1260 .handler
= &jlink_handle_jlink_info_command
,
1261 .mode
= COMMAND_EXEC
,
1262 .help
= "show jlink info",
1266 .handler
= &jlink_handle_jlink_hw_jtag_command
,
1267 .mode
= COMMAND_EXEC
,
1268 .help
= "access J-Link HW JTAG command version",
1273 .handler
= &jlink_handle_jlink_config_command
,
1274 .mode
= COMMAND_EXEC
,
1275 .help
= "access J-Link configuration, "
1276 "if no argument this will dump the config",
1277 .chain
= jlink_config_subcommand_handlers
,
1281 .handler
= &jlink_pid_command
,
1282 .mode
= COMMAND_CONFIG
,
1283 .help
= "set the pid of the interface we want to use",
1285 COMMAND_REGISTRATION_DONE
1288 static const struct command_registration jlink_command_handlers
[] = {
1291 .mode
= COMMAND_ANY
,
1292 .help
= "perform jlink management",
1293 .chain
= jlink_subcommand_handlers
,
1295 COMMAND_REGISTRATION_DONE
1298 struct jtag_interface jlink_interface
= {
1300 .commands
= jlink_command_handlers
,
1301 .transports
= jtag_only
,
1303 .execute_queue
= jlink_execute_queue
,
1304 .speed
= jlink_speed
,
1305 .speed_div
= jlink_speed_div
,
1311 /***************************************************************************/
1312 /* J-Link tap functions */
1315 static unsigned tap_length
;
1316 static uint8_t tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
1317 static uint8_t tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
1318 static uint8_t tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
1320 struct pending_scan_result
{
1321 int first
; /* First bit position in tdo_buffer to read */
1322 int length
; /* Number of bits to read */
1323 struct scan_command
*command
; /* Corresponding scan command */
1327 #define MAX_PENDING_SCAN_RESULTS 256
1329 static int pending_scan_results_length
;
1330 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
1332 static void jlink_tap_init(void)
1335 pending_scan_results_length
= 0;
1338 static void jlink_tap_ensure_space(int scans
, int bits
)
1340 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
1341 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
- 32;
1343 if (scans
> available_scans
|| bits
> available_bits
)
1344 jlink_tap_execute();
1347 static void jlink_tap_append_step(int tms
, int tdi
)
1349 int index_var
= tap_length
/ 8;
1351 if (index_var
>= JLINK_TAP_BUFFER_SIZE
) {
1352 LOG_ERROR("jlink_tap_append_step: overflow");
1353 *(uint32_t *)0xFFFFFFFF = 0;
1357 int bit_index
= tap_length
% 8;
1358 uint8_t bit
= 1 << bit_index
;
1360 /* we do not pad TMS, so be sure to initialize all bits */
1362 tms_buffer
[index_var
] = tdi_buffer
[index_var
] = 0;
1365 tms_buffer
[index_var
] |= bit
;
1367 tms_buffer
[index_var
] &= ~bit
;
1370 tdi_buffer
[index_var
] |= bit
;
1372 tdi_buffer
[index_var
] &= ~bit
;
1377 static void jlink_tap_append_scan(int length
, uint8_t *buffer
,
1378 struct scan_command
*command
)
1380 struct pending_scan_result
*pending_scan_result
=
1381 &pending_scan_results_buffer
[pending_scan_results_length
];
1384 pending_scan_result
->first
= tap_length
;
1385 pending_scan_result
->length
= length
;
1386 pending_scan_result
->command
= command
;
1387 pending_scan_result
->buffer
= buffer
;
1389 for (i
= 0; i
< length
; i
++) {
1390 int tms
= (i
< (length
- 1)) ? 0 : 1;
1391 int tdi
= (buffer
[i
/ 8] & (1 << (i
% 8))) != 0;
1392 jlink_tap_append_step(tms
, tdi
);
1394 pending_scan_results_length
++;
1397 /* Pad and send a tap sequence to the device, and receive the answer.
1398 * For the purpose of padding we assume that we are in idle or pause state. */
1399 static int jlink_tap_execute(void)
1408 /* JLink returns an extra NULL in packet when size of incoming
1409 * message is a multiple of 64, creates problems with USB comms.
1410 * WARNING: This will interfere with tap state counting. */
1411 while ((DIV_ROUND_UP(tap_length
, 8) % 64) == 0)
1412 jlink_tap_append_step((tap_get_state() == TAP_RESET
) ? 1 : 0, 0);
1414 /* number of full bytes (plus one if some would be left over) */
1415 byte_length
= DIV_ROUND_UP(tap_length
, 8);
1417 bool use_jtag3
= jlink_hw_jtag_version
>= 3;
1418 usb_out_buffer
[0] = use_jtag3
? EMU_CMD_HW_JTAG3
: EMU_CMD_HW_JTAG2
;
1419 usb_out_buffer
[1] = 0;
1420 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
1421 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
1422 memcpy(usb_out_buffer
+ 4, tms_buffer
, byte_length
);
1423 memcpy(usb_out_buffer
+ 4 + byte_length
, tdi_buffer
, byte_length
);
1425 jlink_last_state
= jtag_debug_state_machine(tms_buffer
, tdi_buffer
,
1426 tap_length
, jlink_last_state
);
1428 result
= jlink_usb_message(jlink_handle
, 4 + 2 * byte_length
, byte_length
);
1429 if (result
!= byte_length
) {
1430 LOG_ERROR("jlink_tap_execute, wrong result %d (expected %d)",
1431 result
, byte_length
);
1433 return ERROR_JTAG_QUEUE_FAILED
;
1436 memcpy(tdo_buffer
, usb_in_buffer
, byte_length
);
1438 for (i
= 0; i
< pending_scan_results_length
; i
++) {
1439 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
1440 uint8_t *buffer
= pending_scan_result
->buffer
;
1441 int length
= pending_scan_result
->length
;
1442 int first
= pending_scan_result
->first
;
1443 struct scan_command
*command
= pending_scan_result
->command
;
1445 /* Copy to buffer */
1446 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
1448 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
1450 jlink_debug_buffer(buffer
, DIV_ROUND_UP(length
, 8));
1452 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
1454 return ERROR_JTAG_QUEUE_FAILED
;
1457 if (pending_scan_result
->buffer
!= NULL
)
1458 free(pending_scan_result
->buffer
);
1465 /*****************************************************************************/
1466 /* JLink USB low-level functions */
1468 static struct jlink
*jlink_usb_open()
1470 struct jtag_libusb_device_handle
*devh
;
1471 if (jtag_libusb_open(vids
, pids
, &devh
) != ERROR_OK
)
1474 /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
1475 * AREA!!!!!!!!!!! The behavior of libusb is not completely
1476 * consistent across Windows, Linux, and Mac OS X platforms.
1477 * The actions taken in the following compiler conditionals may
1478 * not agree with published documentation for libusb, but were
1479 * found to be necessary through trials and tribulations. Even
1480 * little tweaks can break one or more platforms, so if you do
1481 * make changes test them carefully on all platforms before
1487 jtag_libusb_reset_device(devh
);
1492 /* reopen jlink after usb_reset
1493 * on win32 this may take a second or two to re-enumerate */
1495 while ((retval
= jtag_libusb_open(vids
, pids
, &devh
)) != ERROR_OK
) {
1501 if (ERROR_OK
!= retval
)
1507 /* usb_set_configuration required under win32 */
1508 struct jtag_libusb_device
*udev
= jtag_libusb_get_device(devh
);
1509 jtag_libusb_set_configuration(devh
, 0);
1510 jtag_libusb_claim_interface(devh
, 0);
1514 * This makes problems under Mac OS X. And is not needed
1515 * under Windows. Hopefully this will not break a linux build
1517 usb_set_altinterface(result
->usb_handle
, 0);
1520 jtag_libusb_get_endpoints(udev
, &jlink_read_ep
, &jlink_write_ep
);
1522 struct jlink
*result
= malloc(sizeof(struct jlink
));
1523 result
->usb_handle
= devh
;
1527 static void jlink_usb_close(struct jlink
*jlink
)
1529 jtag_libusb_close(jlink
->usb_handle
);
1533 /* Send a message and receive the reply. */
1534 static int jlink_usb_message(struct jlink
*jlink
, int out_length
, int in_length
)
1538 result
= jlink_usb_write(jlink
, out_length
);
1539 if (result
!= out_length
) {
1540 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
1541 out_length
, result
);
1542 return ERROR_JTAG_DEVICE_ERROR
;
1545 result
= jlink_usb_read(jlink
, in_length
);
1546 if ((result
!= in_length
) && (result
!= (in_length
+ 1))) {
1547 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
1549 return ERROR_JTAG_DEVICE_ERROR
;
1552 if (jlink_hw_jtag_version
< 3)
1555 int result2
= ERROR_OK
;
1556 if (result
== in_length
) {
1557 /* Must read the result from the EMU too */
1558 result2
= jlink_usb_read_emu_result(jlink
);
1560 LOG_ERROR("jlink_usb_read_emu_result retried requested = 1, "
1561 "result=%d, in_length=%i", result2
, in_length
);
1562 /* Try again once, should only happen if (in_length%64 == 0) */
1563 result2
= jlink_usb_read_emu_result(jlink
);
1565 LOG_ERROR("jlink_usb_read_emu_result failed "
1566 "(requested = 1, result=%d)", result2
);
1567 return ERROR_JTAG_DEVICE_ERROR
;
1571 /* Check the result itself */
1572 result2
= usb_emu_result_buffer
[0];
1574 /* Save the result, then remove it from return value */
1575 result2
= usb_in_buffer
[result
--];
1579 LOG_ERROR("jlink_usb_message failed with result=%d)", result2
);
1580 return ERROR_JTAG_DEVICE_ERROR
;
1586 /* calls the given usb_bulk_* function, allowing for the data to
1587 * trickle in with some timeouts */
1588 static int usb_bulk_with_retries(
1589 int (*f
)(jtag_libusb_device_handle
*, int, char *, int, int),
1590 jtag_libusb_device_handle
*dev
, int ep
,
1591 char *bytes
, int size
, int timeout
)
1593 int tries
= 3, count
= 0;
1595 while (tries
&& (count
< size
)) {
1596 int result
= f(dev
, ep
, bytes
+ count
, size
- count
, timeout
);
1599 else if ((-ETIMEDOUT
!= result
) || !--tries
)
1605 static int wrap_usb_bulk_write(jtag_libusb_device_handle
*dev
, int ep
,
1606 char *buff
, int size
, int timeout
)
1608 /* usb_bulk_write() takes const char *buff */
1609 return jtag_libusb_bulk_write(dev
, ep
, buff
, size
, timeout
);
1612 static inline int usb_bulk_write_ex(jtag_libusb_device_handle
*dev
, int ep
,
1613 char *bytes
, int size
, int timeout
)
1615 return usb_bulk_with_retries(&wrap_usb_bulk_write
,
1616 dev
, ep
, bytes
, size
, timeout
);
1619 static inline int usb_bulk_read_ex(jtag_libusb_device_handle
*dev
, int ep
,
1620 char *bytes
, int size
, int timeout
)
1622 return usb_bulk_with_retries(&jtag_libusb_bulk_read
,
1623 dev
, ep
, bytes
, size
, timeout
);
1626 /* Write data from out_buffer to USB. */
1627 static int jlink_usb_write(struct jlink
*jlink
, int out_length
)
1631 if (out_length
> JLINK_OUT_BUFFER_SIZE
) {
1632 LOG_ERROR("jlink_write illegal out_length=%d (max=%d)",
1633 out_length
, JLINK_OUT_BUFFER_SIZE
);
1637 result
= usb_bulk_write_ex(jlink
->usb_handle
, jlink_write_ep
,
1638 (char *)usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
1640 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d",
1641 out_length
, result
);
1643 jlink_debug_buffer(usb_out_buffer
, out_length
);
1647 /* Read data from USB into in_buffer. */
1648 static int jlink_usb_read(struct jlink
*jlink
, int expected_size
)
1650 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1651 (char *)usb_in_buffer
, expected_size
, JLINK_USB_TIMEOUT
);
1653 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
1655 jlink_debug_buffer(usb_in_buffer
, result
);
1659 /* Read the result from the previous EMU cmd into result_buffer. */
1660 static int jlink_usb_read_emu_result(struct jlink
*jlink
)
1662 int result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1663 (char *)usb_emu_result_buffer
, 1 /* JLINK_EMU_RESULT_BUFFER_SIZE */,
1666 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
1668 jlink_debug_buffer(usb_emu_result_buffer
, result
);
1673 * Send a message and receive the reply - simple messages.
1675 * @param jlink pointer to driver data
1676 * @param out_length data length in @c usb_out_buffer
1677 * @param in_length data length to be read to @c usb_in_buffer
1679 static int jlink_usb_io(struct jlink
*jlink
, int out_length
, int in_length
)
1683 result
= jlink_usb_write(jlink
, out_length
);
1684 if (result
!= out_length
) {
1685 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
1686 out_length
, result
);
1687 return ERROR_JTAG_DEVICE_ERROR
;
1690 result
= jlink_usb_read(jlink
, in_length
);
1691 if (result
!= in_length
) {
1692 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)",
1694 return ERROR_JTAG_DEVICE_ERROR
;
1698 * Section 4.2.4 IN-transaction:
1699 * read dummy 0-byte packet if transaction size is
1700 * multiple of 64 bytes but not max. size of 0x8000
1702 if ((in_length
% 64) == 0 && in_length
!= 0x8000) {
1704 result
= usb_bulk_read_ex(jlink
->usb_handle
, jlink_read_ep
,
1705 &dummy_buffer
, 1, JLINK_USB_TIMEOUT
);
1707 LOG_ERROR("dummy byte read failed");
1708 return ERROR_JTAG_DEVICE_ERROR
;
1714 #ifdef _DEBUG_USB_COMMS_
1715 #define BYTES_PER_LINE 16
1717 static void jlink_debug_buffer(uint8_t *buffer
, int length
)
1724 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
) {
1725 snprintf(line
, 5, "%04x", i
);
1726 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++) {
1727 snprintf(s
, 4, " %02x", buffer
[j
]);
1730 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)