1 /***************************************************************************
2 * Copyright (C) 2009 by Dimitar Dimitrov <dinuxbg@gmail.com> *
3 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
25 #include <jtag/interface.h>
26 #include <jtag/commands.h>
28 #include "usb_common.h"
31 #define USB_VID 0x15ba
32 #define USB_PID 0x001e
34 #define ARMJTAGEW_EPT_BULK_OUT 0x01u
35 #define ARMJTAGEW_EPT_BULK_IN 0x82u
37 #define ARMJTAGEW_USB_TIMEOUT 2000
39 #define ARMJTAGEW_IN_BUFFER_SIZE (4*1024)
40 #define ARMJTAGEW_OUT_BUFFER_SIZE (4*1024)
43 /* USB command request codes. */
44 #define CMD_GET_VERSION 0x00
45 #define CMD_SELECT_DPIMPL 0x10
46 #define CMD_SET_TCK_FREQUENCY 0x11
47 #define CMD_GET_TCK_FREQUENCY 0x12
48 #define CMD_MEASURE_MAX_TCK_FREQ 0x15
49 #define CMD_MEASURE_RTCK_RESPONSE 0x16
50 #define CMD_TAP_SHIFT 0x17
51 #define CMD_SET_TAPHW_STATE 0x20
52 #define CMD_GET_TAPHW_STATE 0x21
53 #define CMD_TGPWR_SETUP 0x22
55 /* Global USB buffers */
56 static uint8_t usb_in_buffer
[ARMJTAGEW_IN_BUFFER_SIZE
];
57 static uint8_t usb_out_buffer
[ARMJTAGEW_OUT_BUFFER_SIZE
];
59 /* Queue command functions */
60 static void armjtagew_end_state(tap_state_t state
);
61 static void armjtagew_state_move(void);
62 static void armjtagew_path_move(int num_states
, tap_state_t
*path
);
63 static void armjtagew_runtest(int num_cycles
);
64 static void armjtagew_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
);
65 static void armjtagew_reset(int trst
, int srst
);
66 //static void armjtagew_simple_command(uint8_t command);
67 static int armjtagew_get_status(void);
69 /* tap buffer functions */
70 static void armjtagew_tap_init(void);
71 static int armjtagew_tap_execute(void);
72 static void armjtagew_tap_ensure_space(int scans
, int bits
);
73 static void armjtagew_tap_append_step(int tms
, int tdi
);
74 static void armjtagew_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
);
76 /* ARM-JTAG-EW lowlevel functions */
78 struct usb_dev_handle
* usb_handle
;
81 static struct armjtagew
*armjtagew_usb_open(void);
82 static void armjtagew_usb_close(struct armjtagew
*armjtagew
);
83 static int armjtagew_usb_message(struct armjtagew
*armjtagew
, int out_length
, int in_length
);
84 static int armjtagew_usb_write(struct armjtagew
*armjtagew
, int out_length
);
85 static int armjtagew_usb_read(struct armjtagew
*armjtagew
, int exp_in_length
);
87 /* helper functions */
88 static int armjtagew_get_version_info(void);
90 #ifdef _DEBUG_USB_COMMS_
91 static void armjtagew_debug_buffer(uint8_t *buffer
, int length
);
94 static struct armjtagew
* armjtagew_handle
;
98 /***************************************************************************/
99 /* External interface implementation */
101 static int armjtagew_execute_queue(void)
103 struct jtag_command
*cmd
= jtag_command_queue
;
113 DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, \
114 cmd
->cmd
.runtest
->end_state
);
116 armjtagew_end_state(cmd
->cmd
.runtest
->end_state
);
117 armjtagew_runtest(cmd
->cmd
.runtest
->num_cycles
);
121 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
123 armjtagew_end_state(cmd
->cmd
.statemove
->end_state
);
124 armjtagew_state_move();
128 DEBUG_JTAG_IO("pathmove: %i states, end in %i", \
129 cmd
->cmd
.pathmove
->num_states
, \
130 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
132 armjtagew_path_move(cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
);
136 DEBUG_JTAG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
138 armjtagew_end_state(cmd
->cmd
.scan
->end_state
);
140 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
141 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
143 #ifdef _DEBUG_USB_COMMS_
144 armjtagew_debug_buffer(buffer
, (scan_size
+ 7) / 8);
146 type
= jtag_scan_type(cmd
->cmd
.scan
);
147 armjtagew_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
, cmd
->cmd
.scan
);
151 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
153 armjtagew_tap_execute();
155 if (cmd
->cmd
.reset
->trst
== 1)
157 tap_set_state(TAP_RESET
);
159 armjtagew_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
163 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
164 armjtagew_tap_execute();
165 jtag_sleep(cmd
->cmd
.sleep
->us
);
169 LOG_ERROR("BUG: unknown JTAG command type encountered");
175 return armjtagew_tap_execute();
179 /* Sets speed in kHz. */
180 static int armjtagew_speed(int speed
)
186 usb_out_buffer
[0] = CMD_SET_TCK_FREQUENCY
;
187 buf_set_u32(usb_out_buffer
+ 1, 0, 32, speed
*1000);
189 result
= armjtagew_usb_message(armjtagew_handle
, 5, 4);
193 LOG_ERROR("ARM-JTAG-EW setting speed failed (%d)", result
);
194 return ERROR_JTAG_DEVICE_ERROR
;
197 usb_out_buffer
[0] = CMD_GET_TCK_FREQUENCY
;
198 result
= armjtagew_usb_message(armjtagew_handle
, 1, 4);
199 speed_real
= (int)buf_get_u32(usb_in_buffer
,0,32) / 1000;
202 LOG_ERROR("ARM-JTAG-EW getting speed failed (%d)", result
);
203 return ERROR_JTAG_DEVICE_ERROR
;
207 LOG_INFO("Requested speed %dkHz, emulator reported %dkHz.", speed
, speed_real
);
214 static int armjtagew_khz(int khz
, int *jtag_speed
)
221 static int armjtagew_speed_div(int speed
, int* khz
)
229 static int armjtagew_init(void)
233 armjtagew_handle
= armjtagew_usb_open();
235 if (armjtagew_handle
== 0)
237 LOG_ERROR("Cannot find ARM-JTAG-EW Interface! Please check connection and permissions.");
238 return ERROR_JTAG_INIT_FAILED
;
242 while (check_cnt
< 3)
244 if (armjtagew_get_version_info() == ERROR_OK
)
246 /* attempt to get status */
247 armjtagew_get_status();
256 LOG_INFO("ARM-JTAG-EW initial read failed, don't worry");
259 // Initial JTAG speed (for reset and initialization): 32 kHz
262 LOG_INFO("ARM-JTAG-EW JTAG Interface ready");
264 armjtagew_reset(0, 0);
265 armjtagew_tap_init();
270 static int armjtagew_quit(void)
272 armjtagew_usb_close(armjtagew_handle
);
276 /***************************************************************************/
277 /* Queue command implementations */
279 static void armjtagew_end_state(tap_state_t state
)
281 if (tap_is_state_stable(state
))
283 tap_set_end_state(state
);
287 LOG_ERROR("BUG: %i is not a valid end state", state
);
292 /* Goes to the end state. */
293 static void armjtagew_state_move(void)
297 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
298 int tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
300 for (i
= 0; i
< tms_count
; i
++)
302 tms
= (tms_scan
>> i
) & 1;
303 armjtagew_tap_append_step(tms
, 0);
306 tap_set_state(tap_get_end_state());
309 static void armjtagew_path_move(int num_states
, tap_state_t
*path
)
313 for (i
= 0; i
< num_states
; i
++)
316 * TODO: The ARM-JTAG-EW hardware delays TDI with 3 TCK cycles when in RTCK mode.
317 * Either handle that here, or update the documentation with examples
318 * how to fix that in the configuration files.
320 if (path
[i
] == tap_state_transition(tap_get_state(), false))
322 armjtagew_tap_append_step(0, 0);
324 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
326 armjtagew_tap_append_step(1, 0);
330 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
334 tap_set_state(path
[i
]);
337 tap_set_end_state(tap_get_state());
340 static void armjtagew_runtest(int num_cycles
)
344 tap_state_t saved_end_state
= tap_get_end_state();
346 /* only do a state_move when we're not already in IDLE */
347 if (tap_get_state() != TAP_IDLE
)
349 armjtagew_end_state(TAP_IDLE
);
350 armjtagew_state_move();
353 /* execute num_cycles */
354 for (i
= 0; i
< num_cycles
; i
++)
356 armjtagew_tap_append_step(0, 0);
359 /* finish in end_state */
360 armjtagew_end_state(saved_end_state
);
361 if (tap_get_state() != tap_get_end_state())
363 armjtagew_state_move();
367 static void armjtagew_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
369 tap_state_t saved_end_state
;
371 armjtagew_tap_ensure_space(1, scan_size
+ 8);
373 saved_end_state
= tap_get_end_state();
375 /* Move to appropriate scan state */
376 armjtagew_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
378 armjtagew_state_move();
379 armjtagew_end_state(saved_end_state
);
382 armjtagew_tap_append_scan(scan_size
, buffer
, command
);
384 /* We are in Exit1, go to Pause */
385 armjtagew_tap_append_step(0, 0);
387 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
389 if (tap_get_state() != tap_get_end_state())
391 armjtagew_state_move();
395 static void armjtagew_reset(int trst
, int srst
)
397 const uint8_t trst_mask
= (1u << 5);
398 const uint8_t srst_mask
= (1u << 6);
401 uint8_t change_mask
= 0;
404 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
409 outp_en
&= ~srst_mask
; /* tristate */
410 change_mask
|= srst_mask
;
415 outp_en
|= srst_mask
;
416 change_mask
|= srst_mask
;
422 outp_en
&= ~trst_mask
; /* tristate */
423 change_mask
|= trst_mask
;
428 outp_en
|= trst_mask
;
429 change_mask
|= trst_mask
;
432 usb_out_buffer
[0] = CMD_SET_TAPHW_STATE
;
433 usb_out_buffer
[1] = val
;
434 usb_out_buffer
[2] = outp_en
;
435 usb_out_buffer
[3] = change_mask
;
436 result
= armjtagew_usb_write(armjtagew_handle
, 4);
439 LOG_ERROR("ARM-JTAG-EW TRST/SRST pin set failed failed (%d)", result
);
444 static int armjtagew_get_status(void)
448 usb_out_buffer
[0] = CMD_GET_TAPHW_STATE
;
449 result
= armjtagew_usb_message(armjtagew_handle
, 1, 12);
453 unsigned int u_tg
= buf_get_u32(usb_in_buffer
, 0, 16);
454 LOG_INFO("U_tg = %d mV, U_aux = %d mV, U_tgpwr = %d mV, I_tgpwr = %d mA, D1 = %d, Target power %s %s",
455 (int)(buf_get_u32(usb_in_buffer
+ 0, 0, 16)),
456 (int)(buf_get_u32(usb_in_buffer
+ 2, 0, 16)),
457 (int)(buf_get_u32(usb_in_buffer
+ 4, 0, 16)),
458 (int)(buf_get_u32(usb_in_buffer
+ 6, 0, 16)),
460 usb_in_buffer
[11] ? "OVERCURRENT" : "OK",
461 usb_in_buffer
[10] ? "enabled" : "disabled");
465 LOG_ERROR("Vref too low. Check Target Power");
470 LOG_ERROR("ARM-JTAG-EW command CMD_GET_TAPHW_STATE failed (%d)", result
);
476 static int armjtagew_get_version_info(void)
482 /* query hardware version */
483 usb_out_buffer
[0] = CMD_GET_VERSION
;
484 result
= armjtagew_usb_message(armjtagew_handle
, 1, 4 + 15 + 256);
488 LOG_ERROR("ARM-JTAG-EW command CMD_GET_VERSION failed (%d)", result
);
489 return ERROR_JTAG_DEVICE_ERROR
;
493 memcpy(sn
, usb_in_buffer
+ 4, 15);
495 memcpy(auxinfo
, usb_in_buffer
+ 4+15, 256);
498 LOG_INFO("ARM-JTAG-EW firmware version %d.%d, hardware revision %c, SN=%s, Additional info: %s", \
499 usb_in_buffer
[1], usb_in_buffer
[0], \
500 isgraph(usb_in_buffer
[2]) ? usb_in_buffer
[2] : 'X', \
503 if (1 != usb_in_buffer
[1] || 6 != usb_in_buffer
[0])
505 LOG_WARNING("ARM-JTAG-EW firmware version %d.%d is untested with this version of OpenOCD. You might experience unexpected behavior.", usb_in_buffer
[1], usb_in_buffer
[0]);
510 COMMAND_HANDLER(armjtagew_handle_armjtagew_info_command
)
512 if (armjtagew_get_version_info() == ERROR_OK
)
514 /* attempt to get status */
515 armjtagew_get_status();
521 static const struct command_registration armjtagew_command_handlers
[] = {
523 .name
= "armjtagew_info",
524 .handler
= &armjtagew_handle_armjtagew_info_command
,
525 .mode
= COMMAND_EXEC
,
526 .help
= "query armjtagew info",
528 COMMAND_REGISTRATION_DONE
531 struct jtag_interface armjtagew_interface
= {
532 .name
= "arm-jtag-ew",
533 .commands
= armjtagew_command_handlers
,
534 .transports
= jtag_only
,
536 .execute_queue
= armjtagew_execute_queue
,
537 .speed
= armjtagew_speed
,
538 .speed_div
= armjtagew_speed_div
,
539 .khz
= armjtagew_khz
,
540 .init
= armjtagew_init
,
541 .quit
= armjtagew_quit
,
544 /***************************************************************************/
545 /* ARM-JTAG-EW tap functions */
547 /* 2048 is the max value we can use here */
548 #define ARMJTAGEW_TAP_BUFFER_SIZE 2048
550 static int tap_length
;
551 static uint8_t tms_buffer
[ARMJTAGEW_TAP_BUFFER_SIZE
];
552 static uint8_t tdi_buffer
[ARMJTAGEW_TAP_BUFFER_SIZE
];
553 static uint8_t tdo_buffer
[ARMJTAGEW_TAP_BUFFER_SIZE
];
555 struct pending_scan_result
{
556 int first
; /* First bit position in tdo_buffer to read */
557 int length
; /* Number of bits to read */
558 struct scan_command
*command
; /* Corresponding scan command */
562 #define MAX_PENDING_SCAN_RESULTS 256
564 static int pending_scan_results_length
;
565 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
569 static void armjtagew_tap_init(void)
572 pending_scan_results_length
= 0;
575 static void armjtagew_tap_ensure_space(int scans
, int bits
)
577 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
578 int available_bits
= ARMJTAGEW_TAP_BUFFER_SIZE
* 8 - tap_length
;
580 if (scans
> available_scans
|| bits
> available_bits
)
582 armjtagew_tap_execute();
586 static void armjtagew_tap_append_step(int tms
, int tdi
)
589 int index_local
= tap_length
/ 8;
591 if (index_local
< ARMJTAGEW_TAP_BUFFER_SIZE
)
593 int bit_index
= tap_length
% 8;
594 uint8_t bit
= 1 << bit_index
;
598 tms_buffer
[index_local
] |= bit
;
602 tms_buffer
[index_local
] &= ~bit
;
607 tdi_buffer
[index_local
] |= bit
;
611 tdi_buffer
[index_local
] &= ~bit
;
618 LOG_ERROR("armjtagew_tap_append_step, overflow");
622 void armjtagew_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
)
624 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[pending_scan_results_length
];
627 pending_scan_result
->first
= tap_length
;
628 pending_scan_result
->length
= length
;
629 pending_scan_result
->command
= command
;
630 pending_scan_result
->buffer
= buffer
;
632 for (i
= 0; i
< length
; i
++)
634 armjtagew_tap_append_step((i
< length
-1 ? 0 : 1), (buffer
[i
/8] >> (i
%8)) & 1);
636 pending_scan_results_length
++;
639 /* Pad and send a tap sequence to the device, and receive the answer.
640 * For the purpose of padding we assume that we are in idle or pause state. */
641 static int armjtagew_tap_execute(void)
651 /* Pad last byte so that tap_length is divisible by 8 */
652 while (tap_length
% 8 != 0)
654 /* More of the last TMS value keeps us in the same state,
655 * analogous to free-running JTAG interfaces. */
656 armjtagew_tap_append_step(last_tms
, 0);
659 byte_length
= tap_length
/ 8;
661 usb_out_buffer
[0] = CMD_TAP_SHIFT
;
662 buf_set_u32(usb_out_buffer
+ 1, 0, 16, byte_length
);
665 for (i
= 0; i
< byte_length
; i
++)
667 usb_out_buffer
[tms_offset
+ i
] = flip_u32(tms_buffer
[i
],8);
670 tdi_offset
= tms_offset
+ byte_length
;
671 for (i
= 0; i
< byte_length
; i
++)
673 usb_out_buffer
[tdi_offset
+ i
] = flip_u32(tdi_buffer
[i
],8);
676 result
= armjtagew_usb_message(armjtagew_handle
, 3 + 2 * byte_length
, byte_length
+ 4);
682 stat_local
= (int)buf_get_u32(usb_in_buffer
+ byte_length
, 0, 32);
684 LOG_ERROR("armjtagew_tap_execute, emulator returned error code %d for a CMD_TAP_SHIFT command", stat_local
);
685 return ERROR_JTAG_QUEUE_FAILED
;
688 for (i
= 0; i
< byte_length
; i
++)
690 tdo_buffer
[i
] = flip_u32(usb_in_buffer
[i
],8);
693 for (i
= 0; i
< pending_scan_results_length
; i
++)
695 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
696 uint8_t *buffer
= pending_scan_result
->buffer
;
697 int length
= pending_scan_result
->length
;
698 int first
= pending_scan_result
->first
;
699 struct scan_command
*command
= pending_scan_result
->command
;
702 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
704 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
706 #ifdef _DEBUG_USB_COMMS_
707 armjtagew_debug_buffer(buffer
, byte_length
);
710 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
712 armjtagew_tap_init();
713 return ERROR_JTAG_QUEUE_FAILED
;
716 if (pending_scan_result
->buffer
!= NULL
)
718 free(pending_scan_result
->buffer
);
724 LOG_ERROR("armjtagew_tap_execute, wrong result %d, expected %d", result
, byte_length
);
725 return ERROR_JTAG_QUEUE_FAILED
;
728 armjtagew_tap_init();
734 /*****************************************************************************/
735 /* JLink USB low-level functions */
737 static struct armjtagew
* armjtagew_usb_open()
741 const uint16_t vids
[] = { USB_VID
, 0 };
742 const uint16_t pids
[] = { USB_PID
, 0 };
743 struct usb_dev_handle
*dev
;
744 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
747 struct armjtagew
*result
= malloc(sizeof(struct armjtagew
));
748 result
->usb_handle
= dev
;
751 /* usb_set_configuration required under win32 */
752 usb_set_configuration(dev
, dev
->config
[0].bConfigurationValue
);
754 usb_claim_interface(dev
, 0);
757 * This makes problems under Mac OS X. And is not needed
758 * under Windows. Hopefully this will not break a linux build
760 usb_set_altinterface(dev
, 0);
765 static void armjtagew_usb_close(struct armjtagew
*armjtagew
)
767 usb_close(armjtagew
->usb_handle
);
771 /* Send a message and receive the reply. */
772 static int armjtagew_usb_message(struct armjtagew
*armjtagew
, int out_length
, int in_length
)
776 result
= armjtagew_usb_write(armjtagew
, out_length
);
777 if (result
== out_length
)
779 result
= armjtagew_usb_read(armjtagew
, in_length
);
780 if (result
!= in_length
)
782 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length
, result
);
788 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length
, result
);
794 /* Write data from out_buffer to USB. */
795 static int armjtagew_usb_write(struct armjtagew
*armjtagew
, int out_length
)
799 if (out_length
> ARMJTAGEW_OUT_BUFFER_SIZE
)
801 LOG_ERROR("armjtagew_write illegal out_length=%d (max=%d)", out_length
, ARMJTAGEW_OUT_BUFFER_SIZE
);
805 result
= usb_bulk_write(armjtagew
->usb_handle
, ARMJTAGEW_EPT_BULK_OUT
, \
806 (char*)usb_out_buffer
, out_length
, ARMJTAGEW_USB_TIMEOUT
);
808 DEBUG_JTAG_IO("armjtagew_usb_write, out_length = %d, result = %d", out_length
, result
);
810 #ifdef _DEBUG_USB_COMMS_
811 armjtagew_debug_buffer(usb_out_buffer
, out_length
);
816 /* Read data from USB into in_buffer. */
817 static int armjtagew_usb_read(struct armjtagew
*armjtagew
, int exp_in_length
)
819 int result
= usb_bulk_read(armjtagew
->usb_handle
, ARMJTAGEW_EPT_BULK_IN
, \
820 (char*)usb_in_buffer
, exp_in_length
, ARMJTAGEW_USB_TIMEOUT
);
822 DEBUG_JTAG_IO("armjtagew_usb_read, result = %d", result
);
824 #ifdef _DEBUG_USB_COMMS_
825 armjtagew_debug_buffer(usb_in_buffer
, result
);
831 #ifdef _DEBUG_USB_COMMS_
832 #define BYTES_PER_LINE 16
834 static void armjtagew_debug_buffer(uint8_t *buffer
, int length
)
841 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
843 snprintf(line
, 5, "%04x", i
);
844 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
846 snprintf(s
, 4, " %02x", buffer
[j
]);
849 LOG_DEBUG("%s", line
);
851 // Prevent GDB timeout (writing to log might take some time)
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)