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
;
83 target_type_t
*target_types
[] =
94 target_t
*targets
= NULL
;
95 target_event_callback_t
*target_event_callbacks
= NULL
;
96 target_timer_callback_t
*target_timer_callbacks
= NULL
;
98 char *target_state_strings
[] =
107 char *target_debug_reason_strings
[] =
109 "debug request", "breakpoint", "watchpoint",
110 "watchpoint and breakpoint", "single step",
114 char *target_endianess_strings
[] =
120 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
122 static int target_continous_poll
= 1;
124 /* read a u32 from a buffer in target memory endianness */
125 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
127 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
128 return le_to_h_u32(buffer
);
130 return be_to_h_u32(buffer
);
133 /* read a u16 from a buffer in target memory endianness */
134 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
136 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
137 return le_to_h_u16(buffer
);
139 return be_to_h_u16(buffer
);
142 /* write a u32 to a buffer in target memory endianness */
143 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
145 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
146 h_u32_to_le(buffer
, value
);
148 h_u32_to_be(buffer
, value
);
151 /* write a u16 to a buffer in target memory endianness */
152 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
154 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
155 h_u16_to_le(buffer
, value
);
157 h_u16_to_be(buffer
, value
);
160 /* returns a pointer to the n-th configured target */
161 target_t
* get_target_by_num(int num
)
163 target_t
*target
= targets
;
170 target
= target
->next
;
177 int get_num_by_target(target_t
*query_target
)
179 target_t
*target
= targets
;
184 if (target
== query_target
)
186 target
= target
->next
;
193 target_t
* get_current_target(command_context_t
*cmd_ctx
)
195 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
199 ERROR("BUG: current_target out of bounds");
206 /* Process target initialization, when target entered debug out of reset
207 * the handler is unregistered at the end of this function, so it's only called once
209 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
212 struct command_context_s
*cmd_ctx
= priv
;
214 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
216 target_unregister_event_callback(target_init_handler
, priv
);
218 script
= fopen(target
->reset_script
, "r");
221 ERROR("couldn't open script file %s", target
->reset_script
);
225 INFO("executing reset script '%s'", target
->reset_script
);
226 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
229 jtag_execute_queue();
235 int target_run_and_halt_handler(void *priv
)
237 target_t
*target
= priv
;
239 target
->type
->halt(target
);
244 int target_process_reset(struct command_context_s
*cmd_ctx
)
246 int retval
= ERROR_OK
;
252 target
->type
->assert_reset(target
);
253 target
= target
->next
;
255 jtag_execute_queue();
257 /* request target halt if necessary, and schedule further action */
261 switch (target
->reset_mode
)
264 /* nothing to do if target just wants to be run */
266 case RESET_RUN_AND_HALT
:
268 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
270 case RESET_RUN_AND_INIT
:
272 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
273 target_register_event_callback(target_init_handler
, cmd_ctx
);
276 target
->type
->halt(target
);
279 target
->type
->halt(target
);
280 target_register_event_callback(target_init_handler
, cmd_ctx
);
283 ERROR("BUG: unknown target->reset_mode");
285 target
= target
->next
;
291 target
->type
->deassert_reset(target
);
292 target
= target
->next
;
294 jtag_execute_queue();
299 int target_init(struct command_context_s
*cmd_ctx
)
301 target_t
*target
= targets
;
305 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
307 ERROR("target '%s' init failed", target
->type
->name
);
310 target
= target
->next
;
315 target_register_user_commands(cmd_ctx
);
316 target_register_timer_callback(handle_target
, 100, 1, NULL
);
319 if (startup_mode
== DAEMON_RESET
)
320 target_process_reset(cmd_ctx
);
325 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
327 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
329 if (callback
== NULL
)
331 return ERROR_INVALID_ARGUMENTS
;
336 while ((*callbacks_p
)->next
)
337 callbacks_p
= &((*callbacks_p
)->next
);
338 callbacks_p
= &((*callbacks_p
)->next
);
341 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
342 (*callbacks_p
)->callback
= callback
;
343 (*callbacks_p
)->priv
= priv
;
344 (*callbacks_p
)->next
= NULL
;
349 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
351 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
354 if (callback
== NULL
)
356 return ERROR_INVALID_ARGUMENTS
;
361 while ((*callbacks_p
)->next
)
362 callbacks_p
= &((*callbacks_p
)->next
);
363 callbacks_p
= &((*callbacks_p
)->next
);
366 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
367 (*callbacks_p
)->callback
= callback
;
368 (*callbacks_p
)->periodic
= periodic
;
369 (*callbacks_p
)->time_ms
= time_ms
;
371 gettimeofday(&now
, NULL
);
372 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
373 time_ms
-= (time_ms
% 1000);
374 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
375 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
377 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
378 (*callbacks_p
)->when
.tv_sec
+= 1;
381 (*callbacks_p
)->priv
= priv
;
382 (*callbacks_p
)->next
= NULL
;
387 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
389 target_event_callback_t
**p
= &target_event_callbacks
;
390 target_event_callback_t
*c
= target_event_callbacks
;
392 if (callback
== NULL
)
394 return ERROR_INVALID_ARGUMENTS
;
399 target_event_callback_t
*next
= c
->next
;
400 if ((c
->callback
== callback
) && (c
->priv
== priv
))
414 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
416 target_timer_callback_t
**p
= &target_timer_callbacks
;
417 target_timer_callback_t
*c
= target_timer_callbacks
;
419 if (callback
== NULL
)
421 return ERROR_INVALID_ARGUMENTS
;
426 target_timer_callback_t
*next
= c
->next
;
427 if ((c
->callback
== callback
) && (c
->priv
== priv
))
441 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
443 target_event_callback_t
*callback
= target_event_callbacks
;
444 target_event_callback_t
*next_callback
;
446 DEBUG("target event %i", event
);
450 next_callback
= callback
->next
;
451 callback
->callback(target
, event
, callback
->priv
);
452 callback
= next_callback
;
458 int target_call_timer_callbacks()
460 target_timer_callback_t
*callback
= target_timer_callbacks
;
461 target_timer_callback_t
*next_callback
;
464 gettimeofday(&now
, NULL
);
468 next_callback
= callback
->next
;
470 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
471 || (now
.tv_sec
> callback
->when
.tv_sec
))
473 callback
->callback(callback
->priv
);
474 if (callback
->periodic
)
476 int time_ms
= callback
->time_ms
;
477 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
478 time_ms
-= (time_ms
% 1000);
479 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
480 if (callback
->when
.tv_usec
> 1000000)
482 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
483 callback
->when
.tv_sec
+= 1;
487 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
490 callback
= next_callback
;
496 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
498 working_area_t
*c
= target
->working_areas
;
499 working_area_t
*new_wa
= NULL
;
501 /* only allocate multiples of 4 byte */
504 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
505 size
= CEIL(size
, 4);
508 /* see if there's already a matching working area */
511 if ((c
->free
) && (c
->size
== size
))
519 /* if not, allocate a new one */
522 working_area_t
**p
= &target
->working_areas
;
523 u32 first_free
= target
->working_area
;
524 u32 free_size
= target
->working_area_size
;
526 DEBUG("allocating new working area");
528 c
= target
->working_areas
;
531 first_free
+= c
->size
;
532 free_size
-= c
->size
;
537 if (free_size
< size
)
539 WARNING("not enough working area available");
540 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
543 new_wa
= malloc(sizeof(working_area_t
));
546 new_wa
->address
= first_free
;
548 if (target
->backup_working_area
)
550 new_wa
->backup
= malloc(new_wa
->size
);
551 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
555 new_wa
->backup
= NULL
;
558 /* put new entry in list */
562 /* mark as used, and return the new (reused) area */
572 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
577 if (target
->backup_working_area
)
578 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
582 /* mark user pointer invalid */
589 int target_free_all_working_areas(struct target_s
*target
)
591 working_area_t
*c
= target
->working_areas
;
595 working_area_t
*next
= c
->next
;
596 target_free_working_area(target
, c
);
606 target
->working_areas
= NULL
;
611 int target_register_commands(struct command_context_s
*cmd_ctx
)
613 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
614 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
615 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
616 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
617 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
618 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
623 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
627 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
629 /* handle writes of less than 4 byte */
632 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
636 /* handle unaligned head bytes */
639 int unaligned
= 4 - (address
% 4);
641 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
645 address
+= unaligned
;
649 /* handle aligned words */
652 int aligned
= size
- (size
% 4);
654 /* use bulk writes above a certain limit. This may have to be changed */
657 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
662 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
671 /* handle tail writes of less than 4 bytes */
674 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
681 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
685 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
687 /* handle reads of less than 4 byte */
690 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
694 /* handle unaligned head bytes */
697 int unaligned
= 4 - (address
% 4);
699 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
703 address
+= unaligned
;
707 /* handle aligned words */
710 int aligned
= size
- (size
% 4);
712 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
720 /* handle tail writes of less than 4 bytes */
723 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
730 void target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
734 target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
736 *value
= target_buffer_get_u32(target
, value_buf
);
738 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
741 void target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
745 target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
747 *value
= target_buffer_get_u16(target
, value_buf
);
749 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
752 void target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
754 target
->type
->read_memory(target
, address
, 1, 1, value
);
756 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
759 void target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
763 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
765 target_buffer_set_u32(target
, value_buf
, value
);
766 target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
769 void target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
773 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
775 target_buffer_set_u16(target
, value_buf
, value
);
776 target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
779 void target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
781 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
783 target
->type
->read_memory(target
, address
, 1, 1, &value
);
786 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
788 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
789 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
790 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
791 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
792 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
793 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction");
794 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
795 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
797 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
798 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
799 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
801 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
802 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
803 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
805 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
806 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
807 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
808 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
810 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex']");
811 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
812 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
813 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
818 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
820 target_t
*target
= targets
;
825 int num
= strtoul(args
[0], NULL
, 0);
830 target
= target
->next
;
834 cmd_ctx
->current_target
= num
;
836 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
843 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
844 target
= target
->next
;
850 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
857 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
861 /* search for the specified target */
862 if (args
[0] && (args
[0][0] != 0))
864 for (i
= 0; target_types
[i
]; i
++)
866 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
868 target_t
**last_target_p
= &targets
;
870 /* register target specific commands */
871 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
873 ERROR("couldn't register '%s' commands", args
[0]);
879 while ((*last_target_p
)->next
)
880 last_target_p
= &((*last_target_p
)->next
);
881 last_target_p
= &((*last_target_p
)->next
);
884 *last_target_p
= malloc(sizeof(target_t
));
886 (*last_target_p
)->type
= target_types
[i
];
888 if (strcmp(args
[1], "big") == 0)
889 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
890 else if (strcmp(args
[1], "little") == 0)
891 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
894 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
898 /* what to do on a target reset */
899 if (strcmp(args
[2], "reset_halt") == 0)
900 (*last_target_p
)->reset_mode
= RESET_HALT
;
901 else if (strcmp(args
[2], "reset_run") == 0)
902 (*last_target_p
)->reset_mode
= RESET_RUN
;
903 else if (strcmp(args
[2], "reset_init") == 0)
904 (*last_target_p
)->reset_mode
= RESET_INIT
;
905 else if (strcmp(args
[2], "run_and_halt") == 0)
906 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
907 else if (strcmp(args
[2], "run_and_init") == 0)
908 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
911 ERROR("unknown target startup mode %s", args
[2]);
914 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
916 (*last_target_p
)->reset_script
= NULL
;
917 (*last_target_p
)->post_halt_script
= NULL
;
918 (*last_target_p
)->pre_resume_script
= NULL
;
920 (*last_target_p
)->working_area
= 0x0;
921 (*last_target_p
)->working_area_size
= 0x0;
922 (*last_target_p
)->working_areas
= NULL
;
923 (*last_target_p
)->backup_working_area
= 0;
925 (*last_target_p
)->state
= TARGET_UNKNOWN
;
926 (*last_target_p
)->reg_cache
= NULL
;
927 (*last_target_p
)->breakpoints
= NULL
;
928 (*last_target_p
)->watchpoints
= NULL
;
929 (*last_target_p
)->next
= NULL
;
930 (*last_target_p
)->arch_info
= NULL
;
932 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
940 /* no matching target found */
943 ERROR("target '%s' not found", args
[0]);
950 /* usage: target_script <target#> <event> <script_file> */
951 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
953 target_t
*target
= NULL
;
957 ERROR("incomplete target_script command");
961 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
965 ERROR("target number '%s' not defined", args
[0]);
969 if (strcmp(args
[1], "reset") == 0)
971 if (target
->reset_script
)
972 free(target
->reset_script
);
973 target
->reset_script
= strdup(args
[2]);
975 else if (strcmp(args
[1], "post_halt") == 0)
977 if (target
->post_halt_script
)
978 free(target
->post_halt_script
);
979 target
->post_halt_script
= strdup(args
[2]);
981 else if (strcmp(args
[1], "pre_resume") == 0)
983 if (target
->pre_resume_script
)
984 free(target
->pre_resume_script
);
985 target
->pre_resume_script
= strdup(args
[2]);
989 ERROR("unknown event type: '%s", args
[1]);
996 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
998 target_t
*target
= NULL
;
1002 ERROR("incomplete run_and_halt_time command");
1006 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1010 ERROR("target number '%s' not defined", args
[0]);
1014 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1019 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1021 target_t
*target
= NULL
;
1025 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1029 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1033 ERROR("target number '%s' not defined", args
[0]);
1037 target
->working_area
= strtoul(args
[1], NULL
, 0);
1038 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1040 if (strcmp(args
[3], "backup") == 0)
1042 target
->backup_working_area
= 1;
1044 else if (strcmp(args
[3], "nobackup") == 0)
1046 target
->backup_working_area
= 0;
1050 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1058 /* process target state changes */
1059 int handle_target(void *priv
)
1062 target_t
*target
= targets
;
1066 /* only poll if target isn't already halted */
1067 if (target
->state
!= TARGET_HALTED
)
1069 if (target_continous_poll
)
1070 if ((retval
= target
->type
->poll(target
)) < 0)
1072 ERROR("couldn't poll target, exiting");
1077 target
= target
->next
;
1083 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1092 target
= get_current_target(cmd_ctx
);
1094 /* list all available registers for the current target */
1097 reg_cache_t
*cache
= target
->reg_cache
;
1103 for (i
= 0; i
< cache
->num_regs
; i
++)
1105 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1106 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
);
1109 cache
= cache
->next
;
1115 /* access a single register by its ordinal number */
1116 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1118 int num
= strtoul(args
[0], NULL
, 0);
1119 reg_cache_t
*cache
= target
->reg_cache
;
1125 for (i
= 0; i
< cache
->num_regs
; i
++)
1129 reg
= &cache
->reg_list
[i
];
1135 cache
= cache
->next
;
1140 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1143 } else /* access a single register by its name */
1145 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1149 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1154 /* display a register */
1155 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1157 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1160 if (reg
->valid
== 0)
1162 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1163 if (arch_type
== NULL
)
1165 ERROR("BUG: encountered unregistered arch type");
1168 arch_type
->get(reg
);
1170 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1171 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1176 /* set register value */
1179 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1180 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1182 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1183 if (arch_type
== NULL
)
1185 ERROR("BUG: encountered unregistered arch type");
1189 arch_type
->set(reg
, buf
);
1191 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1192 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1200 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1205 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1207 target_t
*target
= get_current_target(cmd_ctx
);
1212 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1213 if (target
->state
== TARGET_HALTED
)
1215 target
->type
->arch_state(target
, buffer
, 512);
1217 command_print(cmd_ctx
, "%s", buffer
);
1222 if (strcmp(args
[0], "on") == 0)
1224 target_continous_poll
= 1;
1226 else if (strcmp(args
[0], "off") == 0)
1228 target_continous_poll
= 0;
1236 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1238 target_t
*target
= get_current_target(cmd_ctx
);
1239 struct timeval timeout
, now
;
1241 gettimeofday(&timeout
, NULL
);
1243 timeval_add_time(&timeout
, 5, 0);
1247 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
1249 command_print(cmd_ctx
, "usage: wait_halt [seconds]");
1254 command_print(cmd_ctx
, "waiting for target halted...");
1256 while(target
->type
->poll(target
))
1258 if (target
->state
== TARGET_HALTED
)
1260 command_print(cmd_ctx
, "target halted");
1263 target_call_timer_callbacks();
1265 gettimeofday(&now
, NULL
);
1266 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1268 command_print(cmd_ctx
, "timed out while waiting for target halt");
1269 ERROR("timed out while waiting for target halt");
1277 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1280 target_t
*target
= get_current_target(cmd_ctx
);
1284 command_print(cmd_ctx
, "requesting target halt...");
1286 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1290 case ERROR_TARGET_ALREADY_HALTED
:
1291 command_print(cmd_ctx
, "target already halted");
1293 case ERROR_TARGET_TIMEOUT
:
1294 command_print(cmd_ctx
, "target timed out... shutting down");
1297 command_print(cmd_ctx
, "unknown error... shutting down");
1306 /* what to do on daemon startup */
1307 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1311 if (strcmp(args
[0], "attach") == 0)
1313 startup_mode
= DAEMON_ATTACH
;
1316 else if (strcmp(args
[0], "reset") == 0)
1318 startup_mode
= DAEMON_RESET
;
1323 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1328 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1330 target_t
*target
= get_current_target(cmd_ctx
);
1333 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1335 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1339 case ERROR_TARGET_TIMEOUT
:
1340 command_print(cmd_ctx
, "target timed out... shutting down");
1343 command_print(cmd_ctx
, "unknown error... shutting down");
1351 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1353 target_t
*target
= get_current_target(cmd_ctx
);
1354 enum target_reset_mode reset_mode
= RESET_RUN
;
1360 if (strcmp("run", args
[0]) == 0)
1361 reset_mode
= RESET_RUN
;
1362 else if (strcmp("halt", args
[0]) == 0)
1363 reset_mode
= RESET_HALT
;
1364 else if (strcmp("init", args
[0]) == 0)
1365 reset_mode
= RESET_INIT
;
1366 else if (strcmp("run_and_halt", args
[0]) == 0)
1368 reset_mode
= RESET_RUN_AND_HALT
;
1371 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1374 else if (strcmp("run_and_init", args
[0]) == 0)
1376 reset_mode
= RESET_RUN_AND_INIT
;
1379 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1384 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1387 target
->reset_mode
= reset_mode
;
1390 target_process_reset(cmd_ctx
);
1395 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1398 target_t
*target
= get_current_target(cmd_ctx
);
1403 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1405 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1408 command_print(cmd_ctx
, "usage: resume [address]");
1412 if (retval
!= ERROR_OK
)
1416 case ERROR_TARGET_NOT_HALTED
:
1417 command_print(cmd_ctx
, "target not halted");
1420 command_print(cmd_ctx
, "unknown error... shutting down");
1428 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1430 target_t
*target
= get_current_target(cmd_ctx
);
1435 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1438 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1443 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1456 target_t
*target
= get_current_target(cmd_ctx
);
1462 count
= strtoul(args
[1], NULL
, 0);
1464 address
= strtoul(args
[0], NULL
, 0);
1482 buffer
= calloc(count
, size
);
1483 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1487 case ERROR_TARGET_UNALIGNED_ACCESS
:
1488 command_print(cmd_ctx
, "error: address not aligned");
1490 case ERROR_TARGET_NOT_HALTED
:
1491 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1493 case ERROR_TARGET_DATA_ABORT
:
1494 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1497 command_print(cmd_ctx
, "error: unknown error");
1505 for (i
= 0; i
< count
; i
++)
1508 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1513 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1516 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1519 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1523 if ((i
%8 == 7) || (i
== count
- 1))
1525 command_print(cmd_ctx
, output
);
1535 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1540 target_t
*target
= get_current_target(cmd_ctx
);
1546 address
= strtoul(args
[0], NULL
, 0);
1547 value
= strtoul(args
[1], NULL
, 0);
1552 target_buffer_set_u32(target
, value_buf
, value
);
1553 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1556 target_buffer_set_u16(target
, value_buf
, value
);
1557 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1560 value_buf
[0] = value
;
1561 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1569 case ERROR_TARGET_UNALIGNED_ACCESS
:
1570 command_print(cmd_ctx
, "error: address not aligned");
1572 case ERROR_TARGET_DATA_ABORT
:
1573 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1575 case ERROR_TARGET_NOT_HALTED
:
1576 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1581 command_print(cmd_ctx
, "error: unknown error");
1589 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1597 enum fileio_pri_type pri_type
= FILEIO_IMAGE
;
1598 fileio_image_t image_info
;
1599 enum fileio_sec_type sec_type
;
1601 duration_t duration
;
1602 char *duration_text
;
1604 target_t
*target
= get_current_target(cmd_ctx
);
1608 command_print(cmd_ctx
, "usage: load_image <filename> <address> [type]");
1612 memset(&file
, 0, sizeof(fileio_t
));
1613 fileio_identify_image_type(&sec_type
, (argc
== 3) ? args
[2] : NULL
);
1615 image_info
.base_address
= strtoul(args
[1], NULL
, 0);
1616 image_info
.has_start_address
= 0;
1618 buffer
= malloc(128 * 1024);
1620 duration_start_measure(&duration
);
1622 if (fileio_open(&file
, args
[0], FILEIO_READ
,
1623 pri_type
, &image_info
, sec_type
) != ERROR_OK
)
1625 command_print(cmd_ctx
, "load_image error: %s", file
.error_str
);
1629 binary_size
= file
.size
;
1630 address
= image_info
.base_address
;
1631 while ((binary_size
> 0) &&
1632 (fileio_read(&file
, 128 * 1024, buffer
, &buf_cnt
) == ERROR_OK
))
1634 target_write_buffer(target
, address
, buf_cnt
, buffer
);
1636 binary_size
-= buf_cnt
;
1641 duration_stop_measure(&duration
, &duration_text
);
1642 command_print(cmd_ctx
, "downloaded %lli byte in %s", file
.size
, duration_text
);
1643 free(duration_text
);
1645 fileio_close(&file
);
1651 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1654 fileio_image_t image_info
;
1660 duration_t duration
;
1661 char *duration_text
;
1663 target_t
*target
= get_current_target(cmd_ctx
);
1667 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1671 address
= strtoul(args
[1], NULL
, 0);
1672 size
= strtoul(args
[2], NULL
, 0);
1674 if ((address
& 3) || (size
& 3))
1676 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1680 image_info
.base_address
= address
;
1681 image_info
.has_start_address
= 0;
1683 if (fileio_open(&file
, args
[0], FILEIO_WRITE
,
1684 FILEIO_IMAGE
, &image_info
, FILEIO_PLAIN
) != ERROR_OK
)
1686 command_print(cmd_ctx
, "dump_image error: %s", file
.error_str
);
1690 duration_start_measure(&duration
);
1695 u32 this_run_size
= (size
> 560) ? 560 : size
;
1697 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1698 fileio_write(&file
, this_run_size
, buffer
, &size_written
);
1700 size
-= this_run_size
;
1701 address
+= this_run_size
;
1704 fileio_close(&file
);
1706 duration_stop_measure(&duration
, &duration_text
);
1707 command_print(cmd_ctx
, "dumped %lli byte in %s", file
.size
, duration_text
);
1708 free(duration_text
);
1714 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1717 target_t
*target
= get_current_target(cmd_ctx
);
1721 breakpoint_t
*breakpoint
= target
->breakpoints
;
1725 if (breakpoint
->type
== BKPT_SOFT
)
1727 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
1728 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
1733 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
1735 breakpoint
= breakpoint
->next
;
1743 length
= strtoul(args
[1], NULL
, 0);
1746 if (strcmp(args
[2], "hw") == 0)
1749 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
1753 case ERROR_TARGET_NOT_HALTED
:
1754 command_print(cmd_ctx
, "target must be halted to set breakpoints");
1756 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1757 command_print(cmd_ctx
, "no more breakpoints available");
1760 command_print(cmd_ctx
, "unknown error, breakpoint not set");
1766 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
1771 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
1777 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1779 target_t
*target
= get_current_target(cmd_ctx
);
1782 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
1787 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1789 target_t
*target
= get_current_target(cmd_ctx
);
1793 watchpoint_t
*watchpoint
= target
->watchpoints
;
1797 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
);
1798 watchpoint
= watchpoint
->next
;
1803 enum watchpoint_rw type
= WPT_ACCESS
;
1804 u32 data_value
= 0x0;
1805 u32 data_mask
= 0xffffffff;
1821 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1827 data_value
= strtoul(args
[3], NULL
, 0);
1831 data_mask
= strtoul(args
[4], NULL
, 0);
1833 watchpoint_add(target
, strtoul(args
[0], NULL
, 0), strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
);
1837 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1843 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1845 target_t
*target
= get_current_target(cmd_ctx
);
1848 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)