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>
48 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
50 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 extern target_type_t arm7tdmi_target
;
78 extern target_type_t arm720t_target
;
79 extern target_type_t arm9tdmi_target
;
80 extern target_type_t arm920t_target
;
81 extern target_type_t arm966e_target
;
82 extern target_type_t arm926ejs_target
;
83 extern target_type_t xscale_target
;
85 target_type_t
*target_types
[] =
97 target_t
*targets
= NULL
;
98 target_event_callback_t
*target_event_callbacks
= NULL
;
99 target_timer_callback_t
*target_timer_callbacks
= NULL
;
101 char *target_state_strings
[] =
110 char *target_debug_reason_strings
[] =
112 "debug request", "breakpoint", "watchpoint",
113 "watchpoint and breakpoint", "single step",
117 char *target_endianess_strings
[] =
123 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
125 static int target_continous_poll
= 1;
127 /* read a u32 from a buffer in target memory endianness */
128 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
130 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
131 return le_to_h_u32(buffer
);
133 return be_to_h_u32(buffer
);
136 /* read a u16 from a buffer in target memory endianness */
137 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
139 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
140 return le_to_h_u16(buffer
);
142 return be_to_h_u16(buffer
);
145 /* write a u32 to a buffer in target memory endianness */
146 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
148 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
149 h_u32_to_le(buffer
, value
);
151 h_u32_to_be(buffer
, value
);
154 /* write a u16 to a buffer in target memory endianness */
155 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
157 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
158 h_u16_to_le(buffer
, value
);
160 h_u16_to_be(buffer
, value
);
163 /* returns a pointer to the n-th configured target */
164 target_t
* get_target_by_num(int num
)
166 target_t
*target
= targets
;
173 target
= target
->next
;
180 int get_num_by_target(target_t
*query_target
)
182 target_t
*target
= targets
;
187 if (target
== query_target
)
189 target
= target
->next
;
196 target_t
* get_current_target(command_context_t
*cmd_ctx
)
198 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
202 ERROR("BUG: current_target out of bounds");
209 /* Process target initialization, when target entered debug out of reset
210 * the handler is unregistered at the end of this function, so it's only called once
212 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
215 struct command_context_s
*cmd_ctx
= priv
;
217 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
219 target_unregister_event_callback(target_init_handler
, priv
);
221 script
= fopen(target
->reset_script
, "r");
224 ERROR("couldn't open script file %s", target
->reset_script
);
228 INFO("executing reset script '%s'", target
->reset_script
);
229 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
232 jtag_execute_queue();
238 int target_run_and_halt_handler(void *priv
)
240 target_t
*target
= priv
;
242 target
->type
->halt(target
);
247 int target_process_reset(struct command_context_s
*cmd_ctx
)
249 int retval
= ERROR_OK
;
252 /* prepare reset_halt where necessary */
256 switch (target
->reset_mode
)
260 target
->type
->prepare_reset_halt(target
);
265 target
= target
->next
;
271 target
->type
->assert_reset(target
);
272 target
= target
->next
;
274 jtag_execute_queue();
276 /* request target halt if necessary, and schedule further action */
280 switch (target
->reset_mode
)
283 /* nothing to do if target just wants to be run */
285 case RESET_RUN_AND_HALT
:
287 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
289 case RESET_RUN_AND_INIT
:
291 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
292 target_register_event_callback(target_init_handler
, cmd_ctx
);
295 target
->type
->halt(target
);
298 target
->type
->halt(target
);
299 target_register_event_callback(target_init_handler
, cmd_ctx
);
302 ERROR("BUG: unknown target->reset_mode");
304 target
= target
->next
;
310 target
->type
->deassert_reset(target
);
311 target
= target
->next
;
313 jtag_execute_queue();
318 int target_init(struct command_context_s
*cmd_ctx
)
320 target_t
*target
= targets
;
324 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
326 ERROR("target '%s' init failed", target
->type
->name
);
329 target
= target
->next
;
334 target_register_user_commands(cmd_ctx
);
335 target_register_timer_callback(handle_target
, 100, 1, NULL
);
338 if (startup_mode
== DAEMON_RESET
)
339 target_process_reset(cmd_ctx
);
344 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
346 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
348 if (callback
== NULL
)
350 return ERROR_INVALID_ARGUMENTS
;
355 while ((*callbacks_p
)->next
)
356 callbacks_p
= &((*callbacks_p
)->next
);
357 callbacks_p
= &((*callbacks_p
)->next
);
360 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
361 (*callbacks_p
)->callback
= callback
;
362 (*callbacks_p
)->priv
= priv
;
363 (*callbacks_p
)->next
= NULL
;
368 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
370 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
373 if (callback
== NULL
)
375 return ERROR_INVALID_ARGUMENTS
;
380 while ((*callbacks_p
)->next
)
381 callbacks_p
= &((*callbacks_p
)->next
);
382 callbacks_p
= &((*callbacks_p
)->next
);
385 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
386 (*callbacks_p
)->callback
= callback
;
387 (*callbacks_p
)->periodic
= periodic
;
388 (*callbacks_p
)->time_ms
= time_ms
;
390 gettimeofday(&now
, NULL
);
391 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
392 time_ms
-= (time_ms
% 1000);
393 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
394 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
396 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
397 (*callbacks_p
)->when
.tv_sec
+= 1;
400 (*callbacks_p
)->priv
= priv
;
401 (*callbacks_p
)->next
= NULL
;
406 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
408 target_event_callback_t
**p
= &target_event_callbacks
;
409 target_event_callback_t
*c
= target_event_callbacks
;
411 if (callback
== NULL
)
413 return ERROR_INVALID_ARGUMENTS
;
418 target_event_callback_t
*next
= c
->next
;
419 if ((c
->callback
== callback
) && (c
->priv
== priv
))
433 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
435 target_timer_callback_t
**p
= &target_timer_callbacks
;
436 target_timer_callback_t
*c
= target_timer_callbacks
;
438 if (callback
== NULL
)
440 return ERROR_INVALID_ARGUMENTS
;
445 target_timer_callback_t
*next
= c
->next
;
446 if ((c
->callback
== callback
) && (c
->priv
== priv
))
460 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
462 target_event_callback_t
*callback
= target_event_callbacks
;
463 target_event_callback_t
*next_callback
;
465 DEBUG("target event %i", event
);
469 next_callback
= callback
->next
;
470 callback
->callback(target
, event
, callback
->priv
);
471 callback
= next_callback
;
477 int target_call_timer_callbacks()
479 target_timer_callback_t
*callback
= target_timer_callbacks
;
480 target_timer_callback_t
*next_callback
;
483 gettimeofday(&now
, NULL
);
487 next_callback
= callback
->next
;
489 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
490 || (now
.tv_sec
> callback
->when
.tv_sec
))
492 callback
->callback(callback
->priv
);
493 if (callback
->periodic
)
495 int time_ms
= callback
->time_ms
;
496 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
497 time_ms
-= (time_ms
% 1000);
498 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
499 if (callback
->when
.tv_usec
> 1000000)
501 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
502 callback
->when
.tv_sec
+= 1;
506 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
509 callback
= next_callback
;
515 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
517 working_area_t
*c
= target
->working_areas
;
518 working_area_t
*new_wa
= NULL
;
520 /* only allocate multiples of 4 byte */
523 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
524 size
= CEIL(size
, 4);
527 /* see if there's already a matching working area */
530 if ((c
->free
) && (c
->size
== size
))
538 /* if not, allocate a new one */
541 working_area_t
**p
= &target
->working_areas
;
542 u32 first_free
= target
->working_area
;
543 u32 free_size
= target
->working_area_size
;
545 DEBUG("allocating new working area");
547 c
= target
->working_areas
;
550 first_free
+= c
->size
;
551 free_size
-= c
->size
;
556 if (free_size
< size
)
558 WARNING("not enough working area available");
559 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
562 new_wa
= malloc(sizeof(working_area_t
));
565 new_wa
->address
= first_free
;
567 if (target
->backup_working_area
)
569 new_wa
->backup
= malloc(new_wa
->size
);
570 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
574 new_wa
->backup
= NULL
;
577 /* put new entry in list */
581 /* mark as used, and return the new (reused) area */
591 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
596 if (target
->backup_working_area
)
597 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
601 /* mark user pointer invalid */
608 int target_free_all_working_areas(struct target_s
*target
)
610 working_area_t
*c
= target
->working_areas
;
614 working_area_t
*next
= c
->next
;
615 target_free_working_area(target
, c
);
625 target
->working_areas
= NULL
;
630 int target_register_commands(struct command_context_s
*cmd_ctx
)
632 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
633 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
634 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
635 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
636 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
637 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
642 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
646 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
648 /* handle writes of less than 4 byte */
651 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
655 /* handle unaligned head bytes */
658 int unaligned
= 4 - (address
% 4);
660 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
664 address
+= unaligned
;
668 /* handle aligned words */
671 int aligned
= size
- (size
% 4);
673 /* use bulk writes above a certain limit. This may have to be changed */
676 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
681 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
690 /* handle tail writes of less than 4 bytes */
693 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
700 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
704 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
706 /* handle reads of less than 4 byte */
709 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
713 /* handle unaligned head bytes */
716 int unaligned
= 4 - (address
% 4);
718 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
722 address
+= unaligned
;
726 /* handle aligned words */
729 int aligned
= size
- (size
% 4);
731 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
739 /* handle tail writes of less than 4 bytes */
742 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
749 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
753 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
755 if (retval
== ERROR_OK
)
757 *value
= target_buffer_get_u32(target
, value_buf
);
758 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
763 DEBUG("address: 0x%8.8x failed", address
);
769 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
773 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
775 if (retval
== ERROR_OK
)
777 *value
= target_buffer_get_u16(target
, value_buf
);
778 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
783 DEBUG("address: 0x%8.8x failed", address
);
789 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
791 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
793 if (retval
== ERROR_OK
)
795 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
800 DEBUG("address: 0x%8.8x failed", address
);
806 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
811 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
813 target_buffer_set_u32(target
, value_buf
, value
);
814 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
816 DEBUG("failed: %i", retval
);
822 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
827 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
829 target_buffer_set_u16(target
, value_buf
, value
);
830 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
832 DEBUG("failed: %i", retval
);
838 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
842 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
844 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
846 DEBUG("failed: %i", retval
);
852 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
854 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
855 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
856 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
857 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
858 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
859 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction");
860 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
861 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
863 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
864 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
865 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
867 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
868 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
869 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
871 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
872 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
873 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
874 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
876 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex']");
877 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
878 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
879 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
884 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
886 target_t
*target
= targets
;
891 int num
= strtoul(args
[0], NULL
, 0);
896 target
= target
->next
;
900 cmd_ctx
->current_target
= num
;
902 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
909 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
910 target
= target
->next
;
916 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
923 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
927 /* search for the specified target */
928 if (args
[0] && (args
[0][0] != 0))
930 for (i
= 0; target_types
[i
]; i
++)
932 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
934 target_t
**last_target_p
= &targets
;
936 /* register target specific commands */
937 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
939 ERROR("couldn't register '%s' commands", args
[0]);
945 while ((*last_target_p
)->next
)
946 last_target_p
= &((*last_target_p
)->next
);
947 last_target_p
= &((*last_target_p
)->next
);
950 *last_target_p
= malloc(sizeof(target_t
));
952 (*last_target_p
)->type
= target_types
[i
];
954 if (strcmp(args
[1], "big") == 0)
955 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
956 else if (strcmp(args
[1], "little") == 0)
957 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
960 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
964 /* what to do on a target reset */
965 if (strcmp(args
[2], "reset_halt") == 0)
966 (*last_target_p
)->reset_mode
= RESET_HALT
;
967 else if (strcmp(args
[2], "reset_run") == 0)
968 (*last_target_p
)->reset_mode
= RESET_RUN
;
969 else if (strcmp(args
[2], "reset_init") == 0)
970 (*last_target_p
)->reset_mode
= RESET_INIT
;
971 else if (strcmp(args
[2], "run_and_halt") == 0)
972 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
973 else if (strcmp(args
[2], "run_and_init") == 0)
974 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
977 ERROR("unknown target startup mode %s", args
[2]);
980 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
982 (*last_target_p
)->reset_script
= NULL
;
983 (*last_target_p
)->post_halt_script
= NULL
;
984 (*last_target_p
)->pre_resume_script
= NULL
;
986 (*last_target_p
)->working_area
= 0x0;
987 (*last_target_p
)->working_area_size
= 0x0;
988 (*last_target_p
)->working_areas
= NULL
;
989 (*last_target_p
)->backup_working_area
= 0;
991 (*last_target_p
)->state
= TARGET_UNKNOWN
;
992 (*last_target_p
)->reg_cache
= NULL
;
993 (*last_target_p
)->breakpoints
= NULL
;
994 (*last_target_p
)->watchpoints
= NULL
;
995 (*last_target_p
)->next
= NULL
;
996 (*last_target_p
)->arch_info
= NULL
;
998 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1006 /* no matching target found */
1009 ERROR("target '%s' not found", args
[0]);
1016 /* usage: target_script <target#> <event> <script_file> */
1017 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1019 target_t
*target
= NULL
;
1023 ERROR("incomplete target_script command");
1027 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1031 ERROR("target number '%s' not defined", args
[0]);
1035 if (strcmp(args
[1], "reset") == 0)
1037 if (target
->reset_script
)
1038 free(target
->reset_script
);
1039 target
->reset_script
= strdup(args
[2]);
1041 else if (strcmp(args
[1], "post_halt") == 0)
1043 if (target
->post_halt_script
)
1044 free(target
->post_halt_script
);
1045 target
->post_halt_script
= strdup(args
[2]);
1047 else if (strcmp(args
[1], "pre_resume") == 0)
1049 if (target
->pre_resume_script
)
1050 free(target
->pre_resume_script
);
1051 target
->pre_resume_script
= strdup(args
[2]);
1055 ERROR("unknown event type: '%s", args
[1]);
1062 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1064 target_t
*target
= NULL
;
1068 ERROR("incomplete run_and_halt_time command");
1072 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1076 ERROR("target number '%s' not defined", args
[0]);
1080 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1085 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1087 target_t
*target
= NULL
;
1091 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1095 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1099 ERROR("target number '%s' not defined", args
[0]);
1103 target
->working_area
= strtoul(args
[1], NULL
, 0);
1104 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1106 if (strcmp(args
[3], "backup") == 0)
1108 target
->backup_working_area
= 1;
1110 else if (strcmp(args
[3], "nobackup") == 0)
1112 target
->backup_working_area
= 0;
1116 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1124 /* process target state changes */
1125 int handle_target(void *priv
)
1128 target_t
*target
= targets
;
1132 /* only poll if target isn't already halted */
1133 if (target
->state
!= TARGET_HALTED
)
1135 if (target_continous_poll
)
1136 if ((retval
= target
->type
->poll(target
)) < 0)
1138 ERROR("couldn't poll target, exiting");
1143 target
= target
->next
;
1149 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1158 target
= get_current_target(cmd_ctx
);
1160 /* list all available registers for the current target */
1163 reg_cache_t
*cache
= target
->reg_cache
;
1169 for (i
= 0; i
< cache
->num_regs
; i
++)
1171 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1172 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
);
1175 cache
= cache
->next
;
1181 /* access a single register by its ordinal number */
1182 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1184 int num
= strtoul(args
[0], NULL
, 0);
1185 reg_cache_t
*cache
= target
->reg_cache
;
1191 for (i
= 0; i
< cache
->num_regs
; i
++)
1195 reg
= &cache
->reg_list
[i
];
1201 cache
= cache
->next
;
1206 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1209 } else /* access a single register by its name */
1211 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1215 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1220 /* display a register */
1221 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1223 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1226 if (reg
->valid
== 0)
1228 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1229 if (arch_type
== NULL
)
1231 ERROR("BUG: encountered unregistered arch type");
1234 arch_type
->get(reg
);
1236 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1237 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1242 /* set register value */
1245 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1246 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1248 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1249 if (arch_type
== NULL
)
1251 ERROR("BUG: encountered unregistered arch type");
1255 arch_type
->set(reg
, buf
);
1257 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1258 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1266 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1271 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1273 target_t
*target
= get_current_target(cmd_ctx
);
1278 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1279 if (target
->state
== TARGET_HALTED
)
1281 target
->type
->arch_state(target
, buffer
, 512);
1283 command_print(cmd_ctx
, "%s", buffer
);
1288 if (strcmp(args
[0], "on") == 0)
1290 target_continous_poll
= 1;
1292 else if (strcmp(args
[0], "off") == 0)
1294 target_continous_poll
= 0;
1302 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1304 target_t
*target
= get_current_target(cmd_ctx
);
1305 struct timeval timeout
, now
;
1307 gettimeofday(&timeout
, NULL
);
1309 timeval_add_time(&timeout
, 5, 0);
1313 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
1315 command_print(cmd_ctx
, "usage: wait_halt [seconds]");
1320 command_print(cmd_ctx
, "waiting for target halted...");
1322 while(target
->type
->poll(target
))
1324 if (target
->state
== TARGET_HALTED
)
1326 command_print(cmd_ctx
, "target halted");
1329 target_call_timer_callbacks();
1331 gettimeofday(&now
, NULL
);
1332 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1334 command_print(cmd_ctx
, "timed out while waiting for target halt");
1335 ERROR("timed out while waiting for target halt");
1343 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1346 target_t
*target
= get_current_target(cmd_ctx
);
1350 command_print(cmd_ctx
, "requesting target halt...");
1352 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1356 case ERROR_TARGET_ALREADY_HALTED
:
1357 command_print(cmd_ctx
, "target already halted");
1359 case ERROR_TARGET_TIMEOUT
:
1360 command_print(cmd_ctx
, "target timed out... shutting down");
1363 command_print(cmd_ctx
, "unknown error... shutting down");
1372 /* what to do on daemon startup */
1373 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1377 if (strcmp(args
[0], "attach") == 0)
1379 startup_mode
= DAEMON_ATTACH
;
1382 else if (strcmp(args
[0], "reset") == 0)
1384 startup_mode
= DAEMON_RESET
;
1389 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1394 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1396 target_t
*target
= get_current_target(cmd_ctx
);
1399 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1401 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1405 case ERROR_TARGET_TIMEOUT
:
1406 command_print(cmd_ctx
, "target timed out... shutting down");
1409 command_print(cmd_ctx
, "unknown error... shutting down");
1417 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1419 target_t
*target
= get_current_target(cmd_ctx
);
1420 enum target_reset_mode reset_mode
= RESET_RUN
;
1426 if (strcmp("run", args
[0]) == 0)
1427 reset_mode
= RESET_RUN
;
1428 else if (strcmp("halt", args
[0]) == 0)
1429 reset_mode
= RESET_HALT
;
1430 else if (strcmp("init", args
[0]) == 0)
1431 reset_mode
= RESET_INIT
;
1432 else if (strcmp("run_and_halt", args
[0]) == 0)
1434 reset_mode
= RESET_RUN_AND_HALT
;
1437 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1440 else if (strcmp("run_and_init", args
[0]) == 0)
1442 reset_mode
= RESET_RUN_AND_INIT
;
1445 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1450 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1453 target
->reset_mode
= reset_mode
;
1456 target_process_reset(cmd_ctx
);
1461 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1464 target_t
*target
= get_current_target(cmd_ctx
);
1469 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1471 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1474 command_print(cmd_ctx
, "usage: resume [address]");
1478 if (retval
!= ERROR_OK
)
1482 case ERROR_TARGET_NOT_HALTED
:
1483 command_print(cmd_ctx
, "target not halted");
1486 command_print(cmd_ctx
, "unknown error... shutting down");
1494 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1496 target_t
*target
= get_current_target(cmd_ctx
);
1501 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1504 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1509 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1522 target_t
*target
= get_current_target(cmd_ctx
);
1528 count
= strtoul(args
[1], NULL
, 0);
1530 address
= strtoul(args
[0], NULL
, 0);
1548 buffer
= calloc(count
, size
);
1549 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1553 case ERROR_TARGET_UNALIGNED_ACCESS
:
1554 command_print(cmd_ctx
, "error: address not aligned");
1556 case ERROR_TARGET_NOT_HALTED
:
1557 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1559 case ERROR_TARGET_DATA_ABORT
:
1560 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1563 command_print(cmd_ctx
, "error: unknown error");
1571 for (i
= 0; i
< count
; i
++)
1574 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1579 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1582 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1585 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1589 if ((i
%8 == 7) || (i
== count
- 1))
1591 command_print(cmd_ctx
, output
);
1601 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1606 target_t
*target
= get_current_target(cmd_ctx
);
1612 address
= strtoul(args
[0], NULL
, 0);
1613 value
= strtoul(args
[1], NULL
, 0);
1618 target_buffer_set_u32(target
, value_buf
, value
);
1619 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1622 target_buffer_set_u16(target
, value_buf
, value
);
1623 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1626 value_buf
[0] = value
;
1627 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1635 case ERROR_TARGET_UNALIGNED_ACCESS
:
1636 command_print(cmd_ctx
, "error: address not aligned");
1638 case ERROR_TARGET_DATA_ABORT
:
1639 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1641 case ERROR_TARGET_NOT_HALTED
:
1642 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1647 command_print(cmd_ctx
, "error: unknown error");
1655 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
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 identify_image_type(&image
.type
, (argc
== 3) ? args
[2] : NULL
);
1679 image
.base_address_set
= 1;
1680 image
.base_address
= strtoul(args
[1], NULL
, 0);
1682 image
.start_address_set
= 0;
1684 duration_start_measure(&duration
);
1686 if (image_open(&image
, args
[0], FILEIO_READ
) != ERROR_OK
)
1688 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1693 for (i
= 0; i
< image
.num_sections
; i
++)
1695 buffer
= malloc(image
.sections
[i
].size
);
1696 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1698 ERROR("image_read_section failed with error code: %i", retval
);
1699 command_print(cmd_ctx
, "image reading failed, download aborted");
1701 image_close(&image
);
1704 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1705 image_size
+= buf_cnt
;
1706 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1711 duration_stop_measure(&duration
, &duration_text
);
1712 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1713 free(duration_text
);
1715 image_close(&image
);
1721 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1729 duration_t duration
;
1730 char *duration_text
;
1732 target_t
*target
= get_current_target(cmd_ctx
);
1736 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1740 address
= strtoul(args
[1], NULL
, 0);
1741 size
= strtoul(args
[2], NULL
, 0);
1743 if ((address
& 3) || (size
& 3))
1745 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1749 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1751 command_print(cmd_ctx
, "dump_image error: %s", fileio
.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(&fileio
, this_run_size
, buffer
, &size_written
);
1765 size
-= this_run_size
;
1766 address
+= this_run_size
;
1769 fileio_close(&fileio
);
1771 duration_stop_measure(&duration
, &duration_text
);
1772 command_print(cmd_ctx
, "dumped %lli byte in %s", fileio
.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)