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"
35 #include <sys/types.h>
43 #include <time_support.h>
47 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
49 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 extern target_type_t arm7tdmi_target
;
77 extern target_type_t arm720t_target
;
78 extern target_type_t arm9tdmi_target
;
79 extern target_type_t arm920t_target
;
80 extern target_type_t arm966e_target
;
81 extern target_type_t arm926ejs_target
;
82 extern target_type_t xscale_target
;
84 target_type_t
*target_types
[] =
96 target_t
*targets
= NULL
;
97 target_event_callback_t
*target_event_callbacks
= NULL
;
98 target_timer_callback_t
*target_timer_callbacks
= NULL
;
100 char *target_state_strings
[] =
109 char *target_debug_reason_strings
[] =
111 "debug request", "breakpoint", "watchpoint",
112 "watchpoint and breakpoint", "single step",
116 char *target_endianess_strings
[] =
122 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
124 static int target_continous_poll
= 1;
126 /* read a u32 from a buffer in target memory endianness */
127 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
129 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
130 return le_to_h_u32(buffer
);
132 return be_to_h_u32(buffer
);
135 /* read a u16 from a buffer in target memory endianness */
136 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
138 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
139 return le_to_h_u16(buffer
);
141 return be_to_h_u16(buffer
);
144 /* write a u32 to a buffer in target memory endianness */
145 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
147 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
148 h_u32_to_le(buffer
, value
);
150 h_u32_to_be(buffer
, value
);
153 /* write a u16 to a buffer in target memory endianness */
154 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
156 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
157 h_u16_to_le(buffer
, value
);
159 h_u16_to_be(buffer
, value
);
162 /* returns a pointer to the n-th configured target */
163 target_t
* get_target_by_num(int num
)
165 target_t
*target
= targets
;
172 target
= target
->next
;
179 int get_num_by_target(target_t
*query_target
)
181 target_t
*target
= targets
;
186 if (target
== query_target
)
188 target
= target
->next
;
195 target_t
* get_current_target(command_context_t
*cmd_ctx
)
197 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
201 ERROR("BUG: current_target out of bounds");
208 /* Process target initialization, when target entered debug out of reset
209 * the handler is unregistered at the end of this function, so it's only called once
211 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
214 struct command_context_s
*cmd_ctx
= priv
;
216 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
218 target_unregister_event_callback(target_init_handler
, priv
);
220 script
= fopen(target
->reset_script
, "r");
223 ERROR("couldn't open script file %s", target
->reset_script
);
227 INFO("executing reset script '%s'", target
->reset_script
);
228 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
231 jtag_execute_queue();
237 int target_run_and_halt_handler(void *priv
)
239 target_t
*target
= priv
;
241 target
->type
->halt(target
);
246 int target_process_reset(struct command_context_s
*cmd_ctx
)
248 int retval
= ERROR_OK
;
251 /* prepare reset_halt where necessary */
255 switch (target
->reset_mode
)
259 target
->type
->prepare_reset_halt(target
);
264 target
= target
->next
;
270 target
->type
->assert_reset(target
);
271 target
= target
->next
;
273 jtag_execute_queue();
275 /* request target halt if necessary, and schedule further action */
279 switch (target
->reset_mode
)
282 /* nothing to do if target just wants to be run */
284 case RESET_RUN_AND_HALT
:
286 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
288 case RESET_RUN_AND_INIT
:
290 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
291 target_register_event_callback(target_init_handler
, cmd_ctx
);
294 target
->type
->halt(target
);
297 target
->type
->halt(target
);
298 target_register_event_callback(target_init_handler
, cmd_ctx
);
301 ERROR("BUG: unknown target->reset_mode");
303 target
= target
->next
;
309 target
->type
->deassert_reset(target
);
310 target
= target
->next
;
312 jtag_execute_queue();
317 int target_init(struct command_context_s
*cmd_ctx
)
319 target_t
*target
= targets
;
323 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
325 ERROR("target '%s' init failed", target
->type
->name
);
328 target
= target
->next
;
333 target_register_user_commands(cmd_ctx
);
334 target_register_timer_callback(handle_target
, 100, 1, NULL
);
337 if (startup_mode
== DAEMON_RESET
)
338 target_process_reset(cmd_ctx
);
343 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
345 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
347 if (callback
== NULL
)
349 return ERROR_INVALID_ARGUMENTS
;
354 while ((*callbacks_p
)->next
)
355 callbacks_p
= &((*callbacks_p
)->next
);
356 callbacks_p
= &((*callbacks_p
)->next
);
359 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
360 (*callbacks_p
)->callback
= callback
;
361 (*callbacks_p
)->priv
= priv
;
362 (*callbacks_p
)->next
= NULL
;
367 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
369 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
372 if (callback
== NULL
)
374 return ERROR_INVALID_ARGUMENTS
;
379 while ((*callbacks_p
)->next
)
380 callbacks_p
= &((*callbacks_p
)->next
);
381 callbacks_p
= &((*callbacks_p
)->next
);
384 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
385 (*callbacks_p
)->callback
= callback
;
386 (*callbacks_p
)->periodic
= periodic
;
387 (*callbacks_p
)->time_ms
= time_ms
;
389 gettimeofday(&now
, NULL
);
390 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
391 time_ms
-= (time_ms
% 1000);
392 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
393 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
395 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
396 (*callbacks_p
)->when
.tv_sec
+= 1;
399 (*callbacks_p
)->priv
= priv
;
400 (*callbacks_p
)->next
= NULL
;
405 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
407 target_event_callback_t
**p
= &target_event_callbacks
;
408 target_event_callback_t
*c
= target_event_callbacks
;
410 if (callback
== NULL
)
412 return ERROR_INVALID_ARGUMENTS
;
417 target_event_callback_t
*next
= c
->next
;
418 if ((c
->callback
== callback
) && (c
->priv
== priv
))
432 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
434 target_timer_callback_t
**p
= &target_timer_callbacks
;
435 target_timer_callback_t
*c
= target_timer_callbacks
;
437 if (callback
== NULL
)
439 return ERROR_INVALID_ARGUMENTS
;
444 target_timer_callback_t
*next
= c
->next
;
445 if ((c
->callback
== callback
) && (c
->priv
== priv
))
459 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
461 target_event_callback_t
*callback
= target_event_callbacks
;
462 target_event_callback_t
*next_callback
;
464 DEBUG("target event %i", event
);
468 next_callback
= callback
->next
;
469 callback
->callback(target
, event
, callback
->priv
);
470 callback
= next_callback
;
476 int target_call_timer_callbacks()
478 target_timer_callback_t
*callback
= target_timer_callbacks
;
479 target_timer_callback_t
*next_callback
;
482 gettimeofday(&now
, NULL
);
486 next_callback
= callback
->next
;
488 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
489 || (now
.tv_sec
> callback
->when
.tv_sec
))
491 callback
->callback(callback
->priv
);
492 if (callback
->periodic
)
494 int time_ms
= callback
->time_ms
;
495 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
496 time_ms
-= (time_ms
% 1000);
497 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
498 if (callback
->when
.tv_usec
> 1000000)
500 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
501 callback
->when
.tv_sec
+= 1;
505 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
508 callback
= next_callback
;
514 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
516 working_area_t
*c
= target
->working_areas
;
517 working_area_t
*new_wa
= NULL
;
519 /* only allocate multiples of 4 byte */
522 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
523 size
= CEIL(size
, 4);
526 /* see if there's already a matching working area */
529 if ((c
->free
) && (c
->size
== size
))
537 /* if not, allocate a new one */
540 working_area_t
**p
= &target
->working_areas
;
541 u32 first_free
= target
->working_area
;
542 u32 free_size
= target
->working_area_size
;
544 DEBUG("allocating new working area");
546 c
= target
->working_areas
;
549 first_free
+= c
->size
;
550 free_size
-= c
->size
;
555 if (free_size
< size
)
557 WARNING("not enough working area available");
558 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
561 new_wa
= malloc(sizeof(working_area_t
));
564 new_wa
->address
= first_free
;
566 if (target
->backup_working_area
)
568 new_wa
->backup
= malloc(new_wa
->size
);
569 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
573 new_wa
->backup
= NULL
;
576 /* put new entry in list */
580 /* mark as used, and return the new (reused) area */
590 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
595 if (target
->backup_working_area
)
596 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
600 /* mark user pointer invalid */
607 int target_free_all_working_areas(struct target_s
*target
)
609 working_area_t
*c
= target
->working_areas
;
613 working_area_t
*next
= c
->next
;
614 target_free_working_area(target
, c
);
624 target
->working_areas
= NULL
;
629 int target_register_commands(struct command_context_s
*cmd_ctx
)
631 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
632 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
633 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
634 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
635 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
636 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
641 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
645 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
647 /* handle writes of less than 4 byte */
650 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
654 /* handle unaligned head bytes */
657 int unaligned
= 4 - (address
% 4);
659 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
663 address
+= unaligned
;
667 /* handle aligned words */
670 int aligned
= size
- (size
% 4);
672 /* use bulk writes above a certain limit. This may have to be changed */
675 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
680 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
689 /* handle tail writes of less than 4 bytes */
692 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
699 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
703 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
705 /* handle reads of less than 4 byte */
708 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
712 /* handle unaligned head bytes */
715 int unaligned
= 4 - (address
% 4);
717 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
721 address
+= unaligned
;
725 /* handle aligned words */
728 int aligned
= size
- (size
% 4);
730 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
738 /* handle tail writes of less than 4 bytes */
741 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
748 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
752 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
754 if (retval
== ERROR_OK
)
756 *value
= target_buffer_get_u32(target
, value_buf
);
757 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
762 DEBUG("address: 0x%8.8x failed", address
);
768 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
772 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
774 if (retval
== ERROR_OK
)
776 *value
= target_buffer_get_u16(target
, value_buf
);
777 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
782 DEBUG("address: 0x%8.8x failed", address
);
788 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
790 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
792 if (retval
== ERROR_OK
)
794 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
799 DEBUG("address: 0x%8.8x failed", address
);
805 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
810 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
812 target_buffer_set_u32(target
, value_buf
, value
);
813 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
815 DEBUG("failed: %i", retval
);
821 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
826 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
828 target_buffer_set_u16(target
, value_buf
, value
);
829 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
831 DEBUG("failed: %i", retval
);
837 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
841 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
843 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
845 DEBUG("failed: %i", retval
);
851 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
853 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
854 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
855 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
856 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
857 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
858 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction");
859 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
860 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
862 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
863 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
864 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
866 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
867 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
868 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
870 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
871 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
872 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
873 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
875 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex']");
876 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
877 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
878 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
883 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
885 target_t
*target
= targets
;
890 int num
= strtoul(args
[0], NULL
, 0);
895 target
= target
->next
;
899 cmd_ctx
->current_target
= num
;
901 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
908 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
909 target
= target
->next
;
915 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
922 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
926 /* search for the specified target */
927 if (args
[0] && (args
[0][0] != 0))
929 for (i
= 0; target_types
[i
]; i
++)
931 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
933 target_t
**last_target_p
= &targets
;
935 /* register target specific commands */
936 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
938 ERROR("couldn't register '%s' commands", args
[0]);
944 while ((*last_target_p
)->next
)
945 last_target_p
= &((*last_target_p
)->next
);
946 last_target_p
= &((*last_target_p
)->next
);
949 *last_target_p
= malloc(sizeof(target_t
));
951 (*last_target_p
)->type
= target_types
[i
];
953 if (strcmp(args
[1], "big") == 0)
954 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
955 else if (strcmp(args
[1], "little") == 0)
956 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
959 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
963 /* what to do on a target reset */
964 if (strcmp(args
[2], "reset_halt") == 0)
965 (*last_target_p
)->reset_mode
= RESET_HALT
;
966 else if (strcmp(args
[2], "reset_run") == 0)
967 (*last_target_p
)->reset_mode
= RESET_RUN
;
968 else if (strcmp(args
[2], "reset_init") == 0)
969 (*last_target_p
)->reset_mode
= RESET_INIT
;
970 else if (strcmp(args
[2], "run_and_halt") == 0)
971 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
972 else if (strcmp(args
[2], "run_and_init") == 0)
973 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
976 ERROR("unknown target startup mode %s", args
[2]);
979 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
981 (*last_target_p
)->reset_script
= NULL
;
982 (*last_target_p
)->post_halt_script
= NULL
;
983 (*last_target_p
)->pre_resume_script
= NULL
;
985 (*last_target_p
)->working_area
= 0x0;
986 (*last_target_p
)->working_area_size
= 0x0;
987 (*last_target_p
)->working_areas
= NULL
;
988 (*last_target_p
)->backup_working_area
= 0;
990 (*last_target_p
)->state
= TARGET_UNKNOWN
;
991 (*last_target_p
)->reg_cache
= NULL
;
992 (*last_target_p
)->breakpoints
= NULL
;
993 (*last_target_p
)->watchpoints
= NULL
;
994 (*last_target_p
)->next
= NULL
;
995 (*last_target_p
)->arch_info
= NULL
;
997 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1005 /* no matching target found */
1008 ERROR("target '%s' not found", args
[0]);
1015 /* usage: target_script <target#> <event> <script_file> */
1016 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1018 target_t
*target
= NULL
;
1022 ERROR("incomplete target_script command");
1026 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1030 ERROR("target number '%s' not defined", args
[0]);
1034 if (strcmp(args
[1], "reset") == 0)
1036 if (target
->reset_script
)
1037 free(target
->reset_script
);
1038 target
->reset_script
= strdup(args
[2]);
1040 else if (strcmp(args
[1], "post_halt") == 0)
1042 if (target
->post_halt_script
)
1043 free(target
->post_halt_script
);
1044 target
->post_halt_script
= strdup(args
[2]);
1046 else if (strcmp(args
[1], "pre_resume") == 0)
1048 if (target
->pre_resume_script
)
1049 free(target
->pre_resume_script
);
1050 target
->pre_resume_script
= strdup(args
[2]);
1054 ERROR("unknown event type: '%s", args
[1]);
1061 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1063 target_t
*target
= NULL
;
1067 ERROR("incomplete run_and_halt_time command");
1071 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1075 ERROR("target number '%s' not defined", args
[0]);
1079 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1084 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1086 target_t
*target
= NULL
;
1090 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1094 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1098 ERROR("target number '%s' not defined", args
[0]);
1102 target
->working_area
= strtoul(args
[1], NULL
, 0);
1103 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1105 if (strcmp(args
[3], "backup") == 0)
1107 target
->backup_working_area
= 1;
1109 else if (strcmp(args
[3], "nobackup") == 0)
1111 target
->backup_working_area
= 0;
1115 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1123 /* process target state changes */
1124 int handle_target(void *priv
)
1127 target_t
*target
= targets
;
1131 /* only poll if target isn't already halted */
1132 if (target
->state
!= TARGET_HALTED
)
1134 if (target_continous_poll
)
1135 if ((retval
= target
->type
->poll(target
)) < 0)
1137 ERROR("couldn't poll target, exiting");
1142 target
= target
->next
;
1148 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1157 target
= get_current_target(cmd_ctx
);
1159 /* list all available registers for the current target */
1162 reg_cache_t
*cache
= target
->reg_cache
;
1168 for (i
= 0; i
< cache
->num_regs
; i
++)
1170 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1171 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
);
1174 cache
= cache
->next
;
1180 /* access a single register by its ordinal number */
1181 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1183 int num
= strtoul(args
[0], NULL
, 0);
1184 reg_cache_t
*cache
= target
->reg_cache
;
1190 for (i
= 0; i
< cache
->num_regs
; i
++)
1194 reg
= &cache
->reg_list
[i
];
1200 cache
= cache
->next
;
1205 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1208 } else /* access a single register by its name */
1210 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1214 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1219 /* display a register */
1220 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1222 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1225 if (reg
->valid
== 0)
1227 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1228 if (arch_type
== NULL
)
1230 ERROR("BUG: encountered unregistered arch type");
1233 arch_type
->get(reg
);
1235 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1236 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1241 /* set register value */
1244 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1245 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1247 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1248 if (arch_type
== NULL
)
1250 ERROR("BUG: encountered unregistered arch type");
1254 arch_type
->set(reg
, buf
);
1256 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1257 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1265 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1270 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1272 target_t
*target
= get_current_target(cmd_ctx
);
1277 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1278 if (target
->state
== TARGET_HALTED
)
1280 target
->type
->arch_state(target
, buffer
, 512);
1282 command_print(cmd_ctx
, "%s", buffer
);
1287 if (strcmp(args
[0], "on") == 0)
1289 target_continous_poll
= 1;
1291 else if (strcmp(args
[0], "off") == 0)
1293 target_continous_poll
= 0;
1301 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1303 target_t
*target
= get_current_target(cmd_ctx
);
1304 struct timeval timeout
, now
;
1306 gettimeofday(&timeout
, NULL
);
1308 timeval_add_time(&timeout
, 5, 0);
1312 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
1314 command_print(cmd_ctx
, "usage: wait_halt [seconds]");
1319 command_print(cmd_ctx
, "waiting for target halted...");
1321 while(target
->type
->poll(target
))
1323 if (target
->state
== TARGET_HALTED
)
1325 command_print(cmd_ctx
, "target halted");
1328 target_call_timer_callbacks();
1330 gettimeofday(&now
, NULL
);
1331 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1333 command_print(cmd_ctx
, "timed out while waiting for target halt");
1334 ERROR("timed out while waiting for target halt");
1342 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1345 target_t
*target
= get_current_target(cmd_ctx
);
1349 command_print(cmd_ctx
, "requesting target halt...");
1351 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1355 case ERROR_TARGET_ALREADY_HALTED
:
1356 command_print(cmd_ctx
, "target already halted");
1358 case ERROR_TARGET_TIMEOUT
:
1359 command_print(cmd_ctx
, "target timed out... shutting down");
1362 command_print(cmd_ctx
, "unknown error... shutting down");
1371 /* what to do on daemon startup */
1372 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1376 if (strcmp(args
[0], "attach") == 0)
1378 startup_mode
= DAEMON_ATTACH
;
1381 else if (strcmp(args
[0], "reset") == 0)
1383 startup_mode
= DAEMON_RESET
;
1388 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1393 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1395 target_t
*target
= get_current_target(cmd_ctx
);
1398 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1400 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1404 case ERROR_TARGET_TIMEOUT
:
1405 command_print(cmd_ctx
, "target timed out... shutting down");
1408 command_print(cmd_ctx
, "unknown error... shutting down");
1416 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1418 target_t
*target
= get_current_target(cmd_ctx
);
1419 enum target_reset_mode reset_mode
= RESET_RUN
;
1425 if (strcmp("run", args
[0]) == 0)
1426 reset_mode
= RESET_RUN
;
1427 else if (strcmp("halt", args
[0]) == 0)
1428 reset_mode
= RESET_HALT
;
1429 else if (strcmp("init", args
[0]) == 0)
1430 reset_mode
= RESET_INIT
;
1431 else if (strcmp("run_and_halt", args
[0]) == 0)
1433 reset_mode
= RESET_RUN_AND_HALT
;
1436 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1439 else if (strcmp("run_and_init", args
[0]) == 0)
1441 reset_mode
= RESET_RUN_AND_INIT
;
1444 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1449 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1452 target
->reset_mode
= reset_mode
;
1455 target_process_reset(cmd_ctx
);
1460 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1463 target_t
*target
= get_current_target(cmd_ctx
);
1468 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1470 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1473 command_print(cmd_ctx
, "usage: resume [address]");
1477 if (retval
!= ERROR_OK
)
1481 case ERROR_TARGET_NOT_HALTED
:
1482 command_print(cmd_ctx
, "target not halted");
1485 command_print(cmd_ctx
, "unknown error... shutting down");
1493 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1495 target_t
*target
= get_current_target(cmd_ctx
);
1500 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1503 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1508 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1521 target_t
*target
= get_current_target(cmd_ctx
);
1527 count
= strtoul(args
[1], NULL
, 0);
1529 address
= strtoul(args
[0], NULL
, 0);
1547 buffer
= calloc(count
, size
);
1548 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1552 case ERROR_TARGET_UNALIGNED_ACCESS
:
1553 command_print(cmd_ctx
, "error: address not aligned");
1555 case ERROR_TARGET_NOT_HALTED
:
1556 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1558 case ERROR_TARGET_DATA_ABORT
:
1559 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1562 command_print(cmd_ctx
, "error: unknown error");
1570 for (i
= 0; i
< count
; i
++)
1573 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1578 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1581 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1584 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1588 if ((i
%8 == 7) || (i
== count
- 1))
1590 command_print(cmd_ctx
, output
);
1600 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1605 target_t
*target
= get_current_target(cmd_ctx
);
1611 address
= strtoul(args
[0], NULL
, 0);
1612 value
= strtoul(args
[1], NULL
, 0);
1617 target_buffer_set_u32(target
, value_buf
, value
);
1618 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1621 target_buffer_set_u16(target
, value_buf
, value
);
1622 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1625 value_buf
[0] = value
;
1626 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1634 case ERROR_TARGET_UNALIGNED_ACCESS
:
1635 command_print(cmd_ctx
, "error: address not aligned");
1637 case ERROR_TARGET_DATA_ABORT
:
1638 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1640 case ERROR_TARGET_NOT_HALTED
:
1641 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1646 command_print(cmd_ctx
, "error: unknown error");
1654 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1662 enum fileio_pri_type pri_type
= FILEIO_IMAGE
;
1663 fileio_image_t image_info
;
1664 enum fileio_sec_type sec_type
;
1666 duration_t duration
;
1667 char *duration_text
;
1669 target_t
*target
= get_current_target(cmd_ctx
);
1673 command_print(cmd_ctx
, "usage: load_image <filename> <address> [type]");
1677 memset(&file
, 0, sizeof(fileio_t
));
1678 fileio_identify_image_type(&sec_type
, (argc
== 3) ? args
[2] : NULL
);
1680 image_info
.base_address
= strtoul(args
[1], NULL
, 0);
1681 image_info
.has_start_address
= 0;
1683 buffer
= malloc(128 * 1024);
1685 duration_start_measure(&duration
);
1687 if (fileio_open(&file
, args
[0], FILEIO_READ
,
1688 pri_type
, &image_info
, sec_type
) != ERROR_OK
)
1690 command_print(cmd_ctx
, "load_image error: %s", file
.error_str
);
1694 binary_size
= file
.size
;
1695 address
= image_info
.base_address
;
1696 while ((binary_size
> 0) &&
1697 (fileio_read(&file
, 128 * 1024, buffer
, &buf_cnt
) == ERROR_OK
))
1699 target_write_buffer(target
, address
, buf_cnt
, buffer
);
1701 binary_size
-= buf_cnt
;
1706 duration_stop_measure(&duration
, &duration_text
);
1707 command_print(cmd_ctx
, "downloaded %lli byte in %s", file
.size
, duration_text
);
1708 free(duration_text
);
1710 fileio_close(&file
);
1716 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1719 fileio_image_t image_info
;
1725 duration_t duration
;
1726 char *duration_text
;
1728 target_t
*target
= get_current_target(cmd_ctx
);
1732 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1736 address
= strtoul(args
[1], NULL
, 0);
1737 size
= strtoul(args
[2], NULL
, 0);
1739 if ((address
& 3) || (size
& 3))
1741 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1745 image_info
.base_address
= address
;
1746 image_info
.has_start_address
= 0;
1748 if (fileio_open(&file
, args
[0], FILEIO_WRITE
,
1749 FILEIO_IMAGE
, &image_info
, FILEIO_PLAIN
) != ERROR_OK
)
1751 command_print(cmd_ctx
, "dump_image error: %s", file
.error_str
);
1755 duration_start_measure(&duration
);
1760 u32 this_run_size
= (size
> 560) ? 560 : size
;
1762 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1763 fileio_write(&file
, this_run_size
, buffer
, &size_written
);
1765 size
-= this_run_size
;
1766 address
+= this_run_size
;
1769 fileio_close(&file
);
1771 duration_stop_measure(&duration
, &duration_text
);
1772 command_print(cmd_ctx
, "dumped %lli byte in %s", file
.size
, duration_text
);
1773 free(duration_text
);
1779 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1782 target_t
*target
= get_current_target(cmd_ctx
);
1786 breakpoint_t
*breakpoint
= target
->breakpoints
;
1790 if (breakpoint
->type
== BKPT_SOFT
)
1792 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
1793 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
1798 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
1800 breakpoint
= breakpoint
->next
;
1808 length
= strtoul(args
[1], NULL
, 0);
1811 if (strcmp(args
[2], "hw") == 0)
1814 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
1818 case ERROR_TARGET_NOT_HALTED
:
1819 command_print(cmd_ctx
, "target must be halted to set breakpoints");
1821 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1822 command_print(cmd_ctx
, "no more breakpoints available");
1825 command_print(cmd_ctx
, "unknown error, breakpoint not set");
1831 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
1836 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
1842 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1844 target_t
*target
= get_current_target(cmd_ctx
);
1847 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
1852 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1854 target_t
*target
= get_current_target(cmd_ctx
);
1858 watchpoint_t
*watchpoint
= target
->watchpoints
;
1862 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
);
1863 watchpoint
= watchpoint
->next
;
1868 enum watchpoint_rw type
= WPT_ACCESS
;
1869 u32 data_value
= 0x0;
1870 u32 data_mask
= 0xffffffff;
1886 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1892 data_value
= strtoul(args
[3], NULL
, 0);
1896 data_mask
= strtoul(args
[4], NULL
, 0);
1898 watchpoint_add(target
, strtoul(args
[0], NULL
, 0), strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
);
1902 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1908 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1910 target_t
*target
= get_current_target(cmd_ctx
);
1913 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)