1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
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 ***************************************************************************/
24 #include "replacements.h"
28 #include "configuration.h"
29 #include "binarybuffer.h"
36 #include <sys/types.h>
44 #include <time_support.h>
49 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
51 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 extern target_type_t arm7tdmi_target
;
79 extern target_type_t arm720t_target
;
80 extern target_type_t arm9tdmi_target
;
81 extern target_type_t arm920t_target
;
82 extern target_type_t arm966e_target
;
83 extern target_type_t arm926ejs_target
;
84 extern target_type_t xscale_target
;
85 extern target_type_t cortexm3_target
;
87 target_type_t
*target_types
[] =
100 target_t
*targets
= NULL
;
101 target_event_callback_t
*target_event_callbacks
= NULL
;
102 target_timer_callback_t
*target_timer_callbacks
= NULL
;
104 char *target_state_strings
[] =
113 char *target_debug_reason_strings
[] =
115 "debug request", "breakpoint", "watchpoint",
116 "watchpoint and breakpoint", "single step",
120 char *target_endianess_strings
[] =
126 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
128 static int target_continous_poll
= 1;
130 /* read a u32 from a buffer in target memory endianness */
131 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
133 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
134 return le_to_h_u32(buffer
);
136 return be_to_h_u32(buffer
);
139 /* read a u16 from a buffer in target memory endianness */
140 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
142 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
143 return le_to_h_u16(buffer
);
145 return be_to_h_u16(buffer
);
148 /* write a u32 to a buffer in target memory endianness */
149 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
151 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
152 h_u32_to_le(buffer
, value
);
154 h_u32_to_be(buffer
, value
);
157 /* write a u16 to a buffer in target memory endianness */
158 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
160 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
161 h_u16_to_le(buffer
, value
);
163 h_u16_to_be(buffer
, value
);
166 /* returns a pointer to the n-th configured target */
167 target_t
* get_target_by_num(int num
)
169 target_t
*target
= targets
;
176 target
= target
->next
;
183 int get_num_by_target(target_t
*query_target
)
185 target_t
*target
= targets
;
190 if (target
== query_target
)
192 target
= target
->next
;
199 target_t
* get_current_target(command_context_t
*cmd_ctx
)
201 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
205 ERROR("BUG: current_target out of bounds");
212 /* Process target initialization, when target entered debug out of reset
213 * the handler is unregistered at the end of this function, so it's only called once
215 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
218 struct command_context_s
*cmd_ctx
= priv
;
220 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
222 target_unregister_event_callback(target_init_handler
, priv
);
224 script
= fopen(target
->reset_script
, "r");
227 ERROR("couldn't open script file %s", target
->reset_script
);
231 INFO("executing reset script '%s'", target
->reset_script
);
232 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
235 jtag_execute_queue();
241 int target_run_and_halt_handler(void *priv
)
243 target_t
*target
= priv
;
245 target
->type
->halt(target
);
250 int target_process_reset(struct command_context_s
*cmd_ctx
)
252 int retval
= ERROR_OK
;
255 /* prepare reset_halt where necessary */
259 switch (target
->reset_mode
)
263 target
->type
->prepare_reset_halt(target
);
268 target
= target
->next
;
274 target
->type
->assert_reset(target
);
275 target
= target
->next
;
277 jtag_execute_queue();
279 /* request target halt if necessary, and schedule further action */
283 switch (target
->reset_mode
)
286 /* nothing to do if target just wants to be run */
288 case RESET_RUN_AND_HALT
:
290 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
292 case RESET_RUN_AND_INIT
:
294 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
295 target_register_event_callback(target_init_handler
, cmd_ctx
);
298 target
->type
->halt(target
);
301 target
->type
->halt(target
);
302 target_register_event_callback(target_init_handler
, cmd_ctx
);
305 ERROR("BUG: unknown target->reset_mode");
307 target
= target
->next
;
313 target
->type
->deassert_reset(target
);
314 target
= target
->next
;
316 jtag_execute_queue();
321 int target_init(struct command_context_s
*cmd_ctx
)
323 target_t
*target
= targets
;
327 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
329 ERROR("target '%s' init failed", target
->type
->name
);
332 target
= target
->next
;
337 target_register_user_commands(cmd_ctx
);
338 target_register_timer_callback(handle_target
, 100, 1, NULL
);
341 if (startup_mode
== DAEMON_RESET
)
342 target_process_reset(cmd_ctx
);
347 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
349 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
351 if (callback
== NULL
)
353 return ERROR_INVALID_ARGUMENTS
;
358 while ((*callbacks_p
)->next
)
359 callbacks_p
= &((*callbacks_p
)->next
);
360 callbacks_p
= &((*callbacks_p
)->next
);
363 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
364 (*callbacks_p
)->callback
= callback
;
365 (*callbacks_p
)->priv
= priv
;
366 (*callbacks_p
)->next
= NULL
;
371 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
373 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
376 if (callback
== NULL
)
378 return ERROR_INVALID_ARGUMENTS
;
383 while ((*callbacks_p
)->next
)
384 callbacks_p
= &((*callbacks_p
)->next
);
385 callbacks_p
= &((*callbacks_p
)->next
);
388 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
389 (*callbacks_p
)->callback
= callback
;
390 (*callbacks_p
)->periodic
= periodic
;
391 (*callbacks_p
)->time_ms
= time_ms
;
393 gettimeofday(&now
, NULL
);
394 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
395 time_ms
-= (time_ms
% 1000);
396 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
397 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
399 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
400 (*callbacks_p
)->when
.tv_sec
+= 1;
403 (*callbacks_p
)->priv
= priv
;
404 (*callbacks_p
)->next
= NULL
;
409 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
411 target_event_callback_t
**p
= &target_event_callbacks
;
412 target_event_callback_t
*c
= target_event_callbacks
;
414 if (callback
== NULL
)
416 return ERROR_INVALID_ARGUMENTS
;
421 target_event_callback_t
*next
= c
->next
;
422 if ((c
->callback
== callback
) && (c
->priv
== priv
))
436 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
438 target_timer_callback_t
**p
= &target_timer_callbacks
;
439 target_timer_callback_t
*c
= target_timer_callbacks
;
441 if (callback
== NULL
)
443 return ERROR_INVALID_ARGUMENTS
;
448 target_timer_callback_t
*next
= c
->next
;
449 if ((c
->callback
== callback
) && (c
->priv
== priv
))
463 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
465 target_event_callback_t
*callback
= target_event_callbacks
;
466 target_event_callback_t
*next_callback
;
468 DEBUG("target event %i", event
);
472 next_callback
= callback
->next
;
473 callback
->callback(target
, event
, callback
->priv
);
474 callback
= next_callback
;
480 int target_call_timer_callbacks()
482 target_timer_callback_t
*callback
= target_timer_callbacks
;
483 target_timer_callback_t
*next_callback
;
486 gettimeofday(&now
, NULL
);
490 next_callback
= callback
->next
;
492 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
493 || (now
.tv_sec
> callback
->when
.tv_sec
))
495 callback
->callback(callback
->priv
);
496 if (callback
->periodic
)
498 int time_ms
= callback
->time_ms
;
499 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
500 time_ms
-= (time_ms
% 1000);
501 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
502 if (callback
->when
.tv_usec
> 1000000)
504 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
505 callback
->when
.tv_sec
+= 1;
509 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
512 callback
= next_callback
;
518 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
520 working_area_t
*c
= target
->working_areas
;
521 working_area_t
*new_wa
= NULL
;
523 /* only allocate multiples of 4 byte */
526 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
527 size
= CEIL(size
, 4);
530 /* see if there's already a matching working area */
533 if ((c
->free
) && (c
->size
== size
))
541 /* if not, allocate a new one */
544 working_area_t
**p
= &target
->working_areas
;
545 u32 first_free
= target
->working_area
;
546 u32 free_size
= target
->working_area_size
;
548 DEBUG("allocating new working area");
550 c
= target
->working_areas
;
553 first_free
+= c
->size
;
554 free_size
-= c
->size
;
559 if (free_size
< size
)
561 WARNING("not enough working area available");
562 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
565 new_wa
= malloc(sizeof(working_area_t
));
568 new_wa
->address
= first_free
;
570 if (target
->backup_working_area
)
572 new_wa
->backup
= malloc(new_wa
->size
);
573 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
577 new_wa
->backup
= NULL
;
580 /* put new entry in list */
584 /* mark as used, and return the new (reused) area */
594 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
599 if (target
->backup_working_area
)
600 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
604 /* mark user pointer invalid */
611 int target_free_all_working_areas(struct target_s
*target
)
613 working_area_t
*c
= target
->working_areas
;
617 working_area_t
*next
= c
->next
;
618 target_free_working_area(target
, c
);
628 target
->working_areas
= NULL
;
633 int target_register_commands(struct command_context_s
*cmd_ctx
)
635 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
636 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
637 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
638 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
639 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
640 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
645 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
649 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
651 /* handle writes of less than 4 byte */
654 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
658 /* handle unaligned head bytes */
661 int unaligned
= 4 - (address
% 4);
663 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
667 address
+= unaligned
;
671 /* handle aligned words */
674 int aligned
= size
- (size
% 4);
676 /* use bulk writes above a certain limit. This may have to be changed */
679 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
684 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
693 /* handle tail writes of less than 4 bytes */
696 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
703 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
707 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
709 /* handle reads of less than 4 byte */
712 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
716 /* handle unaligned head bytes */
719 int unaligned
= 4 - (address
% 4);
721 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
725 address
+= unaligned
;
729 /* handle aligned words */
732 int aligned
= size
- (size
% 4);
734 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
742 /* handle tail writes of less than 4 bytes */
745 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
752 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
756 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
758 if (retval
== ERROR_OK
)
760 *value
= target_buffer_get_u32(target
, value_buf
);
761 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
766 DEBUG("address: 0x%8.8x failed", address
);
772 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
776 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
778 if (retval
== ERROR_OK
)
780 *value
= target_buffer_get_u16(target
, value_buf
);
781 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
786 DEBUG("address: 0x%8.8x failed", address
);
792 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
794 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
796 if (retval
== ERROR_OK
)
798 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
803 DEBUG("address: 0x%8.8x failed", address
);
809 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
814 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
816 target_buffer_set_u32(target
, value_buf
, value
);
817 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
819 DEBUG("failed: %i", retval
);
825 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
830 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
832 target_buffer_set_u16(target
, value_buf
, value
);
833 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
835 DEBUG("failed: %i", retval
);
841 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
845 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
847 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
849 DEBUG("failed: %i", retval
);
855 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
857 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
858 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
859 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
860 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
861 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
862 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction");
863 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
864 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
866 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
867 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
868 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
870 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
871 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
872 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
874 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
875 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
876 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
877 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
879 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf']");
880 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
881 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
882 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
887 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
889 target_t
*target
= targets
;
894 int num
= strtoul(args
[0], NULL
, 0);
899 target
= target
->next
;
903 cmd_ctx
->current_target
= num
;
905 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
912 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
913 target
= target
->next
;
919 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
926 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
930 /* search for the specified target */
931 if (args
[0] && (args
[0][0] != 0))
933 for (i
= 0; target_types
[i
]; i
++)
935 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
937 target_t
**last_target_p
= &targets
;
939 /* register target specific commands */
940 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
942 ERROR("couldn't register '%s' commands", args
[0]);
948 while ((*last_target_p
)->next
)
949 last_target_p
= &((*last_target_p
)->next
);
950 last_target_p
= &((*last_target_p
)->next
);
953 *last_target_p
= malloc(sizeof(target_t
));
955 (*last_target_p
)->type
= target_types
[i
];
957 if (strcmp(args
[1], "big") == 0)
958 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
959 else if (strcmp(args
[1], "little") == 0)
960 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
963 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
967 /* what to do on a target reset */
968 if (strcmp(args
[2], "reset_halt") == 0)
969 (*last_target_p
)->reset_mode
= RESET_HALT
;
970 else if (strcmp(args
[2], "reset_run") == 0)
971 (*last_target_p
)->reset_mode
= RESET_RUN
;
972 else if (strcmp(args
[2], "reset_init") == 0)
973 (*last_target_p
)->reset_mode
= RESET_INIT
;
974 else if (strcmp(args
[2], "run_and_halt") == 0)
975 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
976 else if (strcmp(args
[2], "run_and_init") == 0)
977 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
980 ERROR("unknown target startup mode %s", args
[2]);
983 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
985 (*last_target_p
)->reset_script
= NULL
;
986 (*last_target_p
)->post_halt_script
= NULL
;
987 (*last_target_p
)->pre_resume_script
= NULL
;
989 (*last_target_p
)->working_area
= 0x0;
990 (*last_target_p
)->working_area_size
= 0x0;
991 (*last_target_p
)->working_areas
= NULL
;
992 (*last_target_p
)->backup_working_area
= 0;
994 (*last_target_p
)->state
= TARGET_UNKNOWN
;
995 (*last_target_p
)->reg_cache
= NULL
;
996 (*last_target_p
)->breakpoints
= NULL
;
997 (*last_target_p
)->watchpoints
= NULL
;
998 (*last_target_p
)->next
= NULL
;
999 (*last_target_p
)->arch_info
= NULL
;
1001 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1009 /* no matching target found */
1012 ERROR("target '%s' not found", args
[0]);
1019 /* usage: target_script <target#> <event> <script_file> */
1020 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1022 target_t
*target
= NULL
;
1026 ERROR("incomplete target_script command");
1030 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1034 ERROR("target number '%s' not defined", args
[0]);
1038 if (strcmp(args
[1], "reset") == 0)
1040 if (target
->reset_script
)
1041 free(target
->reset_script
);
1042 target
->reset_script
= strdup(args
[2]);
1044 else if (strcmp(args
[1], "post_halt") == 0)
1046 if (target
->post_halt_script
)
1047 free(target
->post_halt_script
);
1048 target
->post_halt_script
= strdup(args
[2]);
1050 else if (strcmp(args
[1], "pre_resume") == 0)
1052 if (target
->pre_resume_script
)
1053 free(target
->pre_resume_script
);
1054 target
->pre_resume_script
= strdup(args
[2]);
1058 ERROR("unknown event type: '%s", args
[1]);
1065 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1067 target_t
*target
= NULL
;
1071 ERROR("incomplete run_and_halt_time command");
1075 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1079 ERROR("target number '%s' not defined", args
[0]);
1083 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1088 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1090 target_t
*target
= NULL
;
1094 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1098 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1102 ERROR("target number '%s' not defined", args
[0]);
1106 target
->working_area
= strtoul(args
[1], NULL
, 0);
1107 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1109 if (strcmp(args
[3], "backup") == 0)
1111 target
->backup_working_area
= 1;
1113 else if (strcmp(args
[3], "nobackup") == 0)
1115 target
->backup_working_area
= 0;
1119 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1127 /* process target state changes */
1128 int handle_target(void *priv
)
1131 target_t
*target
= targets
;
1135 /* only poll if target isn't already halted */
1136 if (target
->state
!= TARGET_HALTED
)
1138 if (target_continous_poll
)
1139 if ((retval
= target
->type
->poll(target
)) < 0)
1141 ERROR("couldn't poll target, exiting");
1146 target
= target
->next
;
1152 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1161 target
= get_current_target(cmd_ctx
);
1163 /* list all available registers for the current target */
1166 reg_cache_t
*cache
= target
->reg_cache
;
1172 for (i
= 0; i
< cache
->num_regs
; i
++)
1174 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1175 command_print(cmd_ctx
, "(%i) %s (/%i): 0x%s (dirty: %i, valid: %i)", count
++, cache
->reg_list
[i
].name
, cache
->reg_list
[i
].size
, value
, cache
->reg_list
[i
].dirty
, cache
->reg_list
[i
].valid
);
1178 cache
= cache
->next
;
1184 /* access a single register by its ordinal number */
1185 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1187 int num
= strtoul(args
[0], NULL
, 0);
1188 reg_cache_t
*cache
= target
->reg_cache
;
1194 for (i
= 0; i
< cache
->num_regs
; i
++)
1198 reg
= &cache
->reg_list
[i
];
1204 cache
= cache
->next
;
1209 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1212 } else /* access a single register by its name */
1214 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1218 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1223 /* display a register */
1224 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1226 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1229 if (reg
->valid
== 0)
1231 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1232 if (arch_type
== NULL
)
1234 ERROR("BUG: encountered unregistered arch type");
1237 arch_type
->get(reg
);
1239 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1240 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1245 /* set register value */
1248 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1249 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1251 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1252 if (arch_type
== NULL
)
1254 ERROR("BUG: encountered unregistered arch type");
1258 arch_type
->set(reg
, buf
);
1260 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1261 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1269 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1274 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1276 target_t
*target
= get_current_target(cmd_ctx
);
1281 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1282 if (target
->state
== TARGET_HALTED
)
1284 target
->type
->arch_state(target
, buffer
, 512);
1286 command_print(cmd_ctx
, "%s", buffer
);
1291 if (strcmp(args
[0], "on") == 0)
1293 target_continous_poll
= 1;
1295 else if (strcmp(args
[0], "off") == 0)
1297 target_continous_poll
= 0;
1305 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1307 target_t
*target
= get_current_target(cmd_ctx
);
1308 struct timeval timeout
, now
;
1310 gettimeofday(&timeout
, NULL
);
1312 timeval_add_time(&timeout
, 5, 0);
1316 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
1318 command_print(cmd_ctx
, "usage: wait_halt [seconds]");
1323 command_print(cmd_ctx
, "waiting for target halted...");
1325 while(target
->type
->poll(target
))
1327 if (target
->state
== TARGET_HALTED
)
1329 command_print(cmd_ctx
, "target halted");
1332 target_call_timer_callbacks();
1334 gettimeofday(&now
, NULL
);
1335 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1337 command_print(cmd_ctx
, "timed out while waiting for target halt");
1338 ERROR("timed out while waiting for target halt");
1346 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1349 target_t
*target
= get_current_target(cmd_ctx
);
1353 command_print(cmd_ctx
, "requesting target halt...");
1355 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1359 case ERROR_TARGET_ALREADY_HALTED
:
1360 command_print(cmd_ctx
, "target already halted");
1362 case ERROR_TARGET_TIMEOUT
:
1363 command_print(cmd_ctx
, "target timed out... shutting down");
1366 command_print(cmd_ctx
, "unknown error... shutting down");
1375 /* what to do on daemon startup */
1376 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1380 if (strcmp(args
[0], "attach") == 0)
1382 startup_mode
= DAEMON_ATTACH
;
1385 else if (strcmp(args
[0], "reset") == 0)
1387 startup_mode
= DAEMON_RESET
;
1392 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1397 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1399 target_t
*target
= get_current_target(cmd_ctx
);
1402 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1404 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1408 case ERROR_TARGET_TIMEOUT
:
1409 command_print(cmd_ctx
, "target timed out... shutting down");
1412 command_print(cmd_ctx
, "unknown error... shutting down");
1420 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1422 target_t
*target
= get_current_target(cmd_ctx
);
1423 enum target_reset_mode reset_mode
= RESET_RUN
;
1429 if (strcmp("run", args
[0]) == 0)
1430 reset_mode
= RESET_RUN
;
1431 else if (strcmp("halt", args
[0]) == 0)
1432 reset_mode
= RESET_HALT
;
1433 else if (strcmp("init", args
[0]) == 0)
1434 reset_mode
= RESET_INIT
;
1435 else if (strcmp("run_and_halt", args
[0]) == 0)
1437 reset_mode
= RESET_RUN_AND_HALT
;
1440 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1443 else if (strcmp("run_and_init", args
[0]) == 0)
1445 reset_mode
= RESET_RUN_AND_INIT
;
1448 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1453 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1456 target
->reset_mode
= reset_mode
;
1459 target_process_reset(cmd_ctx
);
1464 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1467 target_t
*target
= get_current_target(cmd_ctx
);
1472 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1474 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1477 command_print(cmd_ctx
, "usage: resume [address]");
1481 if (retval
!= ERROR_OK
)
1485 case ERROR_TARGET_NOT_HALTED
:
1486 command_print(cmd_ctx
, "target not halted");
1489 command_print(cmd_ctx
, "unknown error... shutting down");
1497 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1499 target_t
*target
= get_current_target(cmd_ctx
);
1504 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1507 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1512 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1525 target_t
*target
= get_current_target(cmd_ctx
);
1531 count
= strtoul(args
[1], NULL
, 0);
1533 address
= strtoul(args
[0], NULL
, 0);
1551 buffer
= calloc(count
, size
);
1552 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1556 case ERROR_TARGET_UNALIGNED_ACCESS
:
1557 command_print(cmd_ctx
, "error: address not aligned");
1559 case ERROR_TARGET_NOT_HALTED
:
1560 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1562 case ERROR_TARGET_DATA_ABORT
:
1563 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1566 command_print(cmd_ctx
, "error: unknown error");
1574 for (i
= 0; i
< count
; i
++)
1577 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1582 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1585 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1588 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1592 if ((i
%8 == 7) || (i
== count
- 1))
1594 command_print(cmd_ctx
, output
);
1604 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1609 target_t
*target
= get_current_target(cmd_ctx
);
1615 address
= strtoul(args
[0], NULL
, 0);
1616 value
= strtoul(args
[1], NULL
, 0);
1621 target_buffer_set_u32(target
, value_buf
, value
);
1622 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1625 target_buffer_set_u16(target
, value_buf
, value
);
1626 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1629 value_buf
[0] = value
;
1630 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1638 case ERROR_TARGET_UNALIGNED_ACCESS
:
1639 command_print(cmd_ctx
, "error: address not aligned");
1641 case ERROR_TARGET_DATA_ABORT
:
1642 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1644 case ERROR_TARGET_NOT_HALTED
:
1645 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1650 command_print(cmd_ctx
, "error: unknown error");
1658 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1668 duration_t duration
;
1669 char *duration_text
;
1671 target_t
*target
= get_current_target(cmd_ctx
);
1675 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1679 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1682 image
.base_address_set
= 1;
1683 image
.base_address
= strtoul(args
[1], NULL
, 0);
1687 image
.base_address_set
= 0;
1690 image
.start_address_set
= 0;
1692 duration_start_measure(&duration
);
1694 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1696 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1701 for (i
= 0; i
< image
.num_sections
; i
++)
1703 buffer
= malloc(image
.sections
[i
].size
);
1704 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1706 ERROR("image_read_section failed with error code: %i", retval
);
1707 command_print(cmd_ctx
, "image reading failed, download aborted");
1709 image_close(&image
);
1712 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1713 image_size
+= buf_cnt
;
1714 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1719 duration_stop_measure(&duration
, &duration_text
);
1720 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1721 free(duration_text
);
1723 image_close(&image
);
1729 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1737 duration_t duration
;
1738 char *duration_text
;
1740 target_t
*target
= get_current_target(cmd_ctx
);
1744 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1748 address
= strtoul(args
[1], NULL
, 0);
1749 size
= strtoul(args
[2], NULL
, 0);
1751 if ((address
& 3) || (size
& 3))
1753 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1757 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1759 command_print(cmd_ctx
, "dump_image error: %s", fileio
.error_str
);
1763 duration_start_measure(&duration
);
1768 u32 this_run_size
= (size
> 560) ? 560 : size
;
1770 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1771 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1773 size
-= this_run_size
;
1774 address
+= this_run_size
;
1777 fileio_close(&fileio
);
1779 duration_stop_measure(&duration
, &duration_text
);
1780 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
1781 free(duration_text
);
1787 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1790 target_t
*target
= get_current_target(cmd_ctx
);
1794 breakpoint_t
*breakpoint
= target
->breakpoints
;
1798 if (breakpoint
->type
== BKPT_SOFT
)
1800 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
1801 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
1806 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
1808 breakpoint
= breakpoint
->next
;
1816 length
= strtoul(args
[1], NULL
, 0);
1819 if (strcmp(args
[2], "hw") == 0)
1822 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
1826 case ERROR_TARGET_NOT_HALTED
:
1827 command_print(cmd_ctx
, "target must be halted to set breakpoints");
1829 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1830 command_print(cmd_ctx
, "no more breakpoints available");
1833 command_print(cmd_ctx
, "unknown error, breakpoint not set");
1839 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
1844 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
1850 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1852 target_t
*target
= get_current_target(cmd_ctx
);
1855 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
1860 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1862 target_t
*target
= get_current_target(cmd_ctx
);
1866 watchpoint_t
*watchpoint
= target
->watchpoints
;
1870 command_print(cmd_ctx
, "address: 0x%8.8x, mask: 0x%8.8x, r/w/a: %i, value: 0x%8.8x, mask: 0x%8.8x", watchpoint
->address
, watchpoint
->length
, watchpoint
->rw
, watchpoint
->value
, watchpoint
->mask
);
1871 watchpoint
= watchpoint
->next
;
1876 enum watchpoint_rw type
= WPT_ACCESS
;
1877 u32 data_value
= 0x0;
1878 u32 data_mask
= 0xffffffff;
1894 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1900 data_value
= strtoul(args
[3], NULL
, 0);
1904 data_mask
= strtoul(args
[4], NULL
, 0);
1906 watchpoint_add(target
, strtoul(args
[0], NULL
, 0), strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
);
1910 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1916 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1918 target_t
*target
= get_current_target(cmd_ctx
);
1921 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
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)