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"
30 #define USB_VID 0x15ba
31 #define USB_PID 0x001e
33 #define ARMJTAGEW_EPT_BULK_OUT 0x01u
34 #define ARMJTAGEW_EPT_BULK_IN 0x82u
36 #define ARMJTAGEW_USB_TIMEOUT 2000
38 #define ARMJTAGEW_IN_BUFFER_SIZE (4*1024)
39 #define ARMJTAGEW_OUT_BUFFER_SIZE (4*1024)
41 /* USB command request codes. */
42 #define CMD_GET_VERSION 0x00
43 #define CMD_SELECT_DPIMPL 0x10
44 #define CMD_SET_TCK_FREQUENCY 0x11
45 #define CMD_GET_TCK_FREQUENCY 0x12
46 #define CMD_MEASURE_MAX_TCK_FREQ 0x15
47 #define CMD_MEASURE_RTCK_RESPONSE 0x16
48 #define CMD_TAP_SHIFT 0x17
49 #define CMD_SET_TAPHW_STATE 0x20
50 #define CMD_GET_TAPHW_STATE 0x21
51 #define CMD_TGPWR_SETUP 0x22
53 /* Global USB buffers */
54 static uint8_t usb_in_buffer
[ARMJTAGEW_IN_BUFFER_SIZE
];
55 static uint8_t usb_out_buffer
[ARMJTAGEW_OUT_BUFFER_SIZE
];
57 /* Queue command functions */
58 static void armjtagew_end_state(tap_state_t state
);
59 static void armjtagew_state_move(void);
60 static void armjtagew_path_move(int num_states
, tap_state_t
*path
);
61 static void armjtagew_runtest(int num_cycles
);
62 static void armjtagew_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
);
63 static void armjtagew_reset(int trst
, int srst
);
64 //static void armjtagew_simple_command(uint8_t command);
65 static int armjtagew_get_status(void);
67 /* tap buffer functions */
68 static void armjtagew_tap_init(void);
69 static int armjtagew_tap_execute(void);
70 static void armjtagew_tap_ensure_space(int scans
, int bits
);
71 static void armjtagew_tap_append_step(int tms
, int tdi
);
72 static void armjtagew_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
);
74 /* ARM-JTAG-EW lowlevel functions */
76 struct usb_dev_handle
* usb_handle
;
79 static struct armjtagew
*armjtagew_usb_open(void);
80 static void armjtagew_usb_close(struct armjtagew
*armjtagew
);
81 static int armjtagew_usb_message(struct armjtagew
*armjtagew
, int out_length
, int in_length
);
82 static int armjtagew_usb_write(struct armjtagew
*armjtagew
, int out_length
);
83 static int armjtagew_usb_read(struct armjtagew
*armjtagew
, int exp_in_length
);
85 /* helper functions */
86 static int armjtagew_get_version_info(void);
88 #ifdef _DEBUG_USB_COMMS_
89 static void armjtagew_debug_buffer(uint8_t *buffer
, int length
);
92 static struct armjtagew
* armjtagew_handle
;
94 /***************************************************************************/
95 /* External interface implementation */
97 static int armjtagew_execute_queue(void)
99 struct jtag_command
*cmd
= jtag_command_queue
;
109 DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, \
110 cmd
->cmd
.runtest
->end_state
);
112 armjtagew_end_state(cmd
->cmd
.runtest
->end_state
);
113 armjtagew_runtest(cmd
->cmd
.runtest
->num_cycles
);
117 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
119 armjtagew_end_state(cmd
->cmd
.statemove
->end_state
);
120 armjtagew_state_move();
124 DEBUG_JTAG_IO("pathmove: %i states, end in %i", \
125 cmd
->cmd
.pathmove
->num_states
, \
126 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
128 armjtagew_path_move(cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
);
132 DEBUG_JTAG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
134 armjtagew_end_state(cmd
->cmd
.scan
->end_state
);
136 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
137 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
139 #ifdef _DEBUG_USB_COMMS_
140 armjtagew_debug_buffer(buffer
, (scan_size
+ 7) / 8);
142 type
= jtag_scan_type(cmd
->cmd
.scan
);
143 armjtagew_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
, cmd
->cmd
.scan
);
147 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
149 armjtagew_tap_execute();
151 if (cmd
->cmd
.reset
->trst
== 1)
153 tap_set_state(TAP_RESET
);
155 armjtagew_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
159 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
160 armjtagew_tap_execute();
161 jtag_sleep(cmd
->cmd
.sleep
->us
);
165 LOG_ERROR("BUG: unknown JTAG command type encountered");
171 return armjtagew_tap_execute();
174 /* Sets speed in kHz. */
175 static int armjtagew_speed(int speed
)
181 usb_out_buffer
[0] = CMD_SET_TCK_FREQUENCY
;
182 buf_set_u32(usb_out_buffer
+ 1, 0, 32, speed
*1000);
184 result
= armjtagew_usb_message(armjtagew_handle
, 5, 4);
188 LOG_ERROR("ARM-JTAG-EW setting speed failed (%d)", result
);
189 return ERROR_JTAG_DEVICE_ERROR
;
192 usb_out_buffer
[0] = CMD_GET_TCK_FREQUENCY
;
193 result
= armjtagew_usb_message(armjtagew_handle
, 1, 4);
194 speed_real
= (int)buf_get_u32(usb_in_buffer
, 0, 32) / 1000;
197 LOG_ERROR("ARM-JTAG-EW getting speed failed (%d)", result
);
198 return ERROR_JTAG_DEVICE_ERROR
;
202 LOG_INFO("Requested speed %dkHz, emulator reported %dkHz.", speed
, speed_real
);
208 static int armjtagew_khz(int khz
, int *jtag_speed
)
215 static int armjtagew_speed_div(int speed
, int* khz
)
222 static int armjtagew_init(void)
226 armjtagew_handle
= armjtagew_usb_open();
228 if (armjtagew_handle
== 0)
230 LOG_ERROR("Cannot find ARM-JTAG-EW Interface! Please check connection and permissions.");
231 return ERROR_JTAG_INIT_FAILED
;
235 while (check_cnt
< 3)
237 if (armjtagew_get_version_info() == ERROR_OK
)
239 /* attempt to get status */
240 armjtagew_get_status();
249 LOG_INFO("ARM-JTAG-EW initial read failed, don't worry");
252 /* Initial JTAG speed (for reset and initialization): 32 kHz */
255 LOG_INFO("ARM-JTAG-EW JTAG Interface ready");
257 armjtagew_reset(0, 0);
258 armjtagew_tap_init();
263 static int armjtagew_quit(void)
265 armjtagew_usb_close(armjtagew_handle
);
269 /***************************************************************************/
270 /* Queue command implementations */
272 static void armjtagew_end_state(tap_state_t state
)
274 if (tap_is_state_stable(state
))
276 tap_set_end_state(state
);
280 LOG_ERROR("BUG: %i is not a valid end state", state
);
285 /* Goes to the end state. */
286 static void armjtagew_state_move(void)
290 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
291 int tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
293 for (i
= 0; i
< tms_count
; i
++)
295 tms
= (tms_scan
>> i
) & 1;
296 armjtagew_tap_append_step(tms
, 0);
299 tap_set_state(tap_get_end_state());
302 static void armjtagew_path_move(int num_states
, tap_state_t
*path
)
306 for (i
= 0; i
< num_states
; i
++)
309 * TODO: The ARM-JTAG-EW hardware delays TDI with 3 TCK cycles when in RTCK mode.
310 * Either handle that here, or update the documentation with examples
311 * how to fix that in the configuration files.
313 if (path
[i
] == tap_state_transition(tap_get_state(), false))
315 armjtagew_tap_append_step(0, 0);
317 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
319 armjtagew_tap_append_step(1, 0);
323 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
327 tap_set_state(path
[i
]);
330 tap_set_end_state(tap_get_state());
333 static void armjtagew_runtest(int num_cycles
)
337 tap_state_t saved_end_state
= tap_get_end_state();
339 /* only do a state_move when we're not already in IDLE */
340 if (tap_get_state() != TAP_IDLE
)
342 armjtagew_end_state(TAP_IDLE
);
343 armjtagew_state_move();
346 /* execute num_cycles */
347 for (i
= 0; i
< num_cycles
; i
++)
349 armjtagew_tap_append_step(0, 0);
352 /* finish in end_state */
353 armjtagew_end_state(saved_end_state
);
354 if (tap_get_state() != tap_get_end_state())
356 armjtagew_state_move();
360 static void armjtagew_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
362 tap_state_t saved_end_state
;
364 armjtagew_tap_ensure_space(1, scan_size
+ 8);
366 saved_end_state
= tap_get_end_state();
368 /* Move to appropriate scan state */
369 armjtagew_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
371 armjtagew_state_move();
372 armjtagew_end_state(saved_end_state
);
375 armjtagew_tap_append_scan(scan_size
, buffer
, command
);
377 /* We are in Exit1, go to Pause */
378 armjtagew_tap_append_step(0, 0);
380 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
382 if (tap_get_state() != tap_get_end_state())
384 armjtagew_state_move();
388 static void armjtagew_reset(int trst
, int srst
)
390 const uint8_t trst_mask
= (1u << 5);
391 const uint8_t srst_mask
= (1u << 6);
394 uint8_t change_mask
= 0;
397 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
402 outp_en
&= ~srst_mask
; /* tristate */
403 change_mask
|= srst_mask
;
408 outp_en
|= srst_mask
;
409 change_mask
|= srst_mask
;
415 outp_en
&= ~trst_mask
; /* tristate */
416 change_mask
|= trst_mask
;
421 outp_en
|= trst_mask
;
422 change_mask
|= trst_mask
;
425 usb_out_buffer
[0] = CMD_SET_TAPHW_STATE
;
426 usb_out_buffer
[1] = val
;
427 usb_out_buffer
[2] = outp_en
;
428 usb_out_buffer
[3] = change_mask
;
429 result
= armjtagew_usb_write(armjtagew_handle
, 4);
432 LOG_ERROR("ARM-JTAG-EW TRST/SRST pin set failed failed (%d)", result
);
436 static int armjtagew_get_status(void)
440 usb_out_buffer
[0] = CMD_GET_TAPHW_STATE
;
441 result
= armjtagew_usb_message(armjtagew_handle
, 1, 12);
445 unsigned int u_tg
= buf_get_u32(usb_in_buffer
, 0, 16);
446 LOG_INFO("U_tg = %d mV, U_aux = %d mV, U_tgpwr = %d mV, I_tgpwr = %d mA, D1 = %d, Target power %s %s",
447 (int)(buf_get_u32(usb_in_buffer
+ 0, 0, 16)),
448 (int)(buf_get_u32(usb_in_buffer
+ 2, 0, 16)),
449 (int)(buf_get_u32(usb_in_buffer
+ 4, 0, 16)),
450 (int)(buf_get_u32(usb_in_buffer
+ 6, 0, 16)),
452 usb_in_buffer
[11] ? "OVERCURRENT" : "OK",
453 usb_in_buffer
[10] ? "enabled" : "disabled");
457 LOG_ERROR("Vref too low. Check Target Power");
462 LOG_ERROR("ARM-JTAG-EW command CMD_GET_TAPHW_STATE failed (%d)", result
);
468 static int armjtagew_get_version_info(void)
474 /* query hardware version */
475 usb_out_buffer
[0] = CMD_GET_VERSION
;
476 result
= armjtagew_usb_message(armjtagew_handle
, 1, 4 + 15 + 256);
480 LOG_ERROR("ARM-JTAG-EW command CMD_GET_VERSION failed (%d)", result
);
481 return ERROR_JTAG_DEVICE_ERROR
;
485 memcpy(sn
, usb_in_buffer
+ 4, 15);
487 memcpy(auxinfo
, usb_in_buffer
+ 4+15, 256);
490 LOG_INFO("ARM-JTAG-EW firmware version %d.%d, hardware revision %c, SN=%s, Additional info: %s", \
491 usb_in_buffer
[1], usb_in_buffer
[0], \
492 isgraph(usb_in_buffer
[2]) ? usb_in_buffer
[2] : 'X', \
495 if (1 != usb_in_buffer
[1] || 6 != usb_in_buffer
[0])
497 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]);
502 COMMAND_HANDLER(armjtagew_handle_armjtagew_info_command
)
504 if (armjtagew_get_version_info() == ERROR_OK
)
506 /* attempt to get status */
507 armjtagew_get_status();
513 static const struct command_registration armjtagew_command_handlers
[] = {
515 .name
= "armjtagew_info",
516 .handler
= &armjtagew_handle_armjtagew_info_command
,
517 .mode
= COMMAND_EXEC
,
518 .help
= "query armjtagew info",
520 COMMAND_REGISTRATION_DONE
523 struct jtag_interface armjtagew_interface
= {
524 .name
= "arm-jtag-ew",
525 .commands
= armjtagew_command_handlers
,
526 .transports
= jtag_only
,
527 .execute_queue
= armjtagew_execute_queue
,
528 .speed
= armjtagew_speed
,
529 .speed_div
= armjtagew_speed_div
,
530 .khz
= armjtagew_khz
,
531 .init
= armjtagew_init
,
532 .quit
= armjtagew_quit
,
535 /***************************************************************************/
536 /* ARM-JTAG-EW tap functions */
538 /* 2048 is the max value we can use here */
539 #define ARMJTAGEW_TAP_BUFFER_SIZE 2048
541 static int tap_length
;
542 static uint8_t tms_buffer
[ARMJTAGEW_TAP_BUFFER_SIZE
];
543 static uint8_t tdi_buffer
[ARMJTAGEW_TAP_BUFFER_SIZE
];
544 static uint8_t tdo_buffer
[ARMJTAGEW_TAP_BUFFER_SIZE
];
546 struct pending_scan_result
{
547 int first
; /* First bit position in tdo_buffer to read */
548 int length
; /* Number of bits to read */
549 struct scan_command
*command
; /* Corresponding scan command */
553 #define MAX_PENDING_SCAN_RESULTS 256
555 static int pending_scan_results_length
;
556 static struct pending_scan_result pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
560 static void armjtagew_tap_init(void)
563 pending_scan_results_length
= 0;
566 static void armjtagew_tap_ensure_space(int scans
, int bits
)
568 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
569 int available_bits
= ARMJTAGEW_TAP_BUFFER_SIZE
* 8 - tap_length
;
571 if (scans
> available_scans
|| bits
> available_bits
)
573 armjtagew_tap_execute();
577 static void armjtagew_tap_append_step(int tms
, int tdi
)
580 int index_local
= tap_length
/ 8;
582 if (index_local
< ARMJTAGEW_TAP_BUFFER_SIZE
)
584 int bit_index
= tap_length
% 8;
585 uint8_t bit
= 1 << bit_index
;
589 tms_buffer
[index_local
] |= bit
;
593 tms_buffer
[index_local
] &= ~bit
;
598 tdi_buffer
[index_local
] |= bit
;
602 tdi_buffer
[index_local
] &= ~bit
;
609 LOG_ERROR("armjtagew_tap_append_step, overflow");
613 void armjtagew_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
)
615 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[pending_scan_results_length
];
618 pending_scan_result
->first
= tap_length
;
619 pending_scan_result
->length
= length
;
620 pending_scan_result
->command
= command
;
621 pending_scan_result
->buffer
= buffer
;
623 for (i
= 0; i
< length
; i
++)
625 armjtagew_tap_append_step((i
< length
-1 ? 0 : 1), (buffer
[i
/8] >> (i
%8)) & 1);
627 pending_scan_results_length
++;
630 /* Pad and send a tap sequence to the device, and receive the answer.
631 * For the purpose of padding we assume that we are in idle or pause state. */
632 static int armjtagew_tap_execute(void)
642 /* Pad last byte so that tap_length is divisible by 8 */
643 while (tap_length
% 8 != 0)
645 /* More of the last TMS value keeps us in the same state,
646 * analogous to free-running JTAG interfaces. */
647 armjtagew_tap_append_step(last_tms
, 0);
650 byte_length
= tap_length
/ 8;
652 usb_out_buffer
[0] = CMD_TAP_SHIFT
;
653 buf_set_u32(usb_out_buffer
+ 1, 0, 16, byte_length
);
656 for (i
= 0; i
< byte_length
; i
++)
658 usb_out_buffer
[tms_offset
+ i
] = flip_u32(tms_buffer
[i
],8);
661 tdi_offset
= tms_offset
+ byte_length
;
662 for (i
= 0; i
< byte_length
; i
++)
664 usb_out_buffer
[tdi_offset
+ i
] = flip_u32(tdi_buffer
[i
],8);
667 result
= armjtagew_usb_message(armjtagew_handle
, 3 + 2 * byte_length
, byte_length
+ 4);
673 stat_local
= (int)buf_get_u32(usb_in_buffer
+ byte_length
, 0, 32);
675 LOG_ERROR("armjtagew_tap_execute, emulator returned error code %d for a CMD_TAP_SHIFT command", stat_local
);
676 return ERROR_JTAG_QUEUE_FAILED
;
679 for (i
= 0; i
< byte_length
; i
++)
681 tdo_buffer
[i
] = flip_u32(usb_in_buffer
[i
],8);
684 for (i
= 0; i
< pending_scan_results_length
; i
++)
686 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
687 uint8_t *buffer
= pending_scan_result
->buffer
;
688 int length
= pending_scan_result
->length
;
689 int first
= pending_scan_result
->first
;
690 struct scan_command
*command
= pending_scan_result
->command
;
693 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
695 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
697 #ifdef _DEBUG_USB_COMMS_
698 armjtagew_debug_buffer(buffer
, byte_length
);
701 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
703 armjtagew_tap_init();
704 return ERROR_JTAG_QUEUE_FAILED
;
707 if (pending_scan_result
->buffer
!= NULL
)
709 free(pending_scan_result
->buffer
);
715 LOG_ERROR("armjtagew_tap_execute, wrong result %d, expected %d", result
, byte_length
);
716 return ERROR_JTAG_QUEUE_FAILED
;
719 armjtagew_tap_init();
725 /*****************************************************************************/
726 /* JLink USB low-level functions */
728 static struct armjtagew
* armjtagew_usb_open()
732 const uint16_t vids
[] = { USB_VID
, 0 };
733 const uint16_t pids
[] = { USB_PID
, 0 };
734 struct usb_dev_handle
*dev
;
735 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
738 struct armjtagew
*result
= malloc(sizeof(struct armjtagew
));
739 result
->usb_handle
= dev
;
742 /* usb_set_configuration required under win32 */
743 usb_set_configuration(dev
, dev
->config
[0].bConfigurationValue
);
745 usb_claim_interface(dev
, 0);
748 * This makes problems under Mac OS X. And is not needed
749 * under Windows. Hopefully this will not break a linux build
751 usb_set_altinterface(dev
, 0);
756 static void armjtagew_usb_close(struct armjtagew
*armjtagew
)
758 usb_close(armjtagew
->usb_handle
);
762 /* Send a message and receive the reply. */
763 static int armjtagew_usb_message(struct armjtagew
*armjtagew
, int out_length
, int in_length
)
767 result
= armjtagew_usb_write(armjtagew
, out_length
);
768 if (result
== out_length
)
770 result
= armjtagew_usb_read(armjtagew
, in_length
);
771 if (result
!= in_length
)
773 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length
, result
);
779 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length
, result
);
785 /* Write data from out_buffer to USB. */
786 static int armjtagew_usb_write(struct armjtagew
*armjtagew
, int out_length
)
790 if (out_length
> ARMJTAGEW_OUT_BUFFER_SIZE
)
792 LOG_ERROR("armjtagew_write illegal out_length=%d (max=%d)", out_length
, ARMJTAGEW_OUT_BUFFER_SIZE
);
796 result
= usb_bulk_write(armjtagew
->usb_handle
, ARMJTAGEW_EPT_BULK_OUT
, \
797 (char*)usb_out_buffer
, out_length
, ARMJTAGEW_USB_TIMEOUT
);
799 DEBUG_JTAG_IO("armjtagew_usb_write, out_length = %d, result = %d", out_length
, result
);
801 #ifdef _DEBUG_USB_COMMS_
802 armjtagew_debug_buffer(usb_out_buffer
, out_length
);
807 /* Read data from USB into in_buffer. */
808 static int armjtagew_usb_read(struct armjtagew
*armjtagew
, int exp_in_length
)
810 int result
= usb_bulk_read(armjtagew
->usb_handle
, ARMJTAGEW_EPT_BULK_IN
, \
811 (char*)usb_in_buffer
, exp_in_length
, ARMJTAGEW_USB_TIMEOUT
);
813 DEBUG_JTAG_IO("armjtagew_usb_read, result = %d", result
);
815 #ifdef _DEBUG_USB_COMMS_
816 armjtagew_debug_buffer(usb_in_buffer
, result
);
821 #ifdef _DEBUG_USB_COMMS_
822 #define BYTES_PER_LINE 16
824 static void armjtagew_debug_buffer(uint8_t *buffer
, int length
)
831 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
833 snprintf(line
, 5, "%04x", i
);
834 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
836 snprintf(s
, 4, " %02x", buffer
[j
]);
839 LOG_DEBUG("%s", line
);
841 // 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)