1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
27 #include "replacements.h"
29 #include "target_request.h"
32 #include "configuration.h"
33 #include "binarybuffer.h"
40 #include <sys/types.h>
48 #include <time_support.h>
53 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
55 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
80 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
84 extern target_type_t arm7tdmi_target
;
85 extern target_type_t arm720t_target
;
86 extern target_type_t arm9tdmi_target
;
87 extern target_type_t arm920t_target
;
88 extern target_type_t arm966e_target
;
89 extern target_type_t arm926ejs_target
;
90 extern target_type_t feroceon_target
;
91 extern target_type_t xscale_target
;
92 extern target_type_t cortexm3_target
;
93 extern target_type_t arm11_target
;
94 extern target_type_t mips_m4k_target
;
96 target_type_t
*target_types
[] =
112 target_t
*targets
= NULL
;
113 target_event_callback_t
*target_event_callbacks
= NULL
;
114 target_timer_callback_t
*target_timer_callbacks
= NULL
;
116 char *target_state_strings
[] =
125 char *target_debug_reason_strings
[] =
127 "debug request", "breakpoint", "watchpoint",
128 "watchpoint and breakpoint", "single step",
129 "target not halted", "undefined"
132 char *target_endianess_strings
[] =
138 static int target_continous_poll
= 1;
140 /* read a u32 from a buffer in target memory endianness */
141 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
143 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
144 return le_to_h_u32(buffer
);
146 return be_to_h_u32(buffer
);
149 /* read a u16 from a buffer in target memory endianness */
150 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
152 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
153 return le_to_h_u16(buffer
);
155 return be_to_h_u16(buffer
);
158 /* write a u32 to a buffer in target memory endianness */
159 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
161 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
162 h_u32_to_le(buffer
, value
);
164 h_u32_to_be(buffer
, value
);
167 /* write a u16 to a buffer in target memory endianness */
168 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
170 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
171 h_u16_to_le(buffer
, value
);
173 h_u16_to_be(buffer
, value
);
176 /* returns a pointer to the n-th configured target */
177 target_t
* get_target_by_num(int num
)
179 target_t
*target
= targets
;
186 target
= target
->next
;
193 int get_num_by_target(target_t
*query_target
)
195 target_t
*target
= targets
;
200 if (target
== query_target
)
202 target
= target
->next
;
209 target_t
* get_current_target(command_context_t
*cmd_ctx
)
211 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
215 LOG_ERROR("BUG: current_target out of bounds");
223 int target_poll(struct target_s
*target
)
225 /* We can't poll until after examine */
226 if (!target
->type
->examined
)
228 /* Fail silently lest we pollute the log */
231 return target
->type
->poll(target
);
234 int target_halt(struct target_s
*target
)
236 /* We can't poll until after examine */
237 if (!target
->type
->examined
)
239 LOG_ERROR("Target not examined yet");
242 return target
->type
->halt(target
);
245 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
249 /* We can't poll until after examine */
250 if (!target
->type
->examined
)
252 LOG_ERROR("Target not examined yet");
256 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
257 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
260 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
266 int target_process_reset(struct command_context_s
*cmd_ctx
, enum target_reset_mode reset_mode
)
268 int retval
= ERROR_OK
;
274 target_invoke_script(cmd_ctx
, target
, "pre_reset");
275 target
= target
->next
;
278 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
281 keep_alive(); /* we might be running on a very slow JTAG clk */
283 /* First time this is executed after launching OpenOCD, it will read out
284 * the type of CPU, etc. and init Embedded ICE registers in host
287 * It will also set up ICE registers in the target.
289 * However, if we assert TRST later, we need to set up the registers again.
291 * For the "reset halt/init" case we must only set up the registers here.
293 if ((retval
= target_examine()) != ERROR_OK
)
296 keep_alive(); /* we might be running on a very slow JTAG clk */
301 /* we have no idea what state the target is in, so we
302 * have to drop working areas
304 target_free_all_working_areas_restore(target
, 0);
305 target
->reset_halt
=((reset_mode
==RESET_HALT
)||(reset_mode
==RESET_INIT
));
306 if ((retval
= target
->type
->assert_reset(target
))!=ERROR_OK
)
308 target
= target
->next
;
314 if ((retval
= target
->type
->deassert_reset(target
))!=ERROR_OK
)
316 target
= target
->next
;
322 /* We can fail to bring the target into the halted state, try after reset has been deasserted */
323 if (target
->reset_halt
)
325 /* wait up to 1 second for halt. */
326 target_wait_state(target
, TARGET_HALTED
, 1000);
327 if (target
->state
!= TARGET_HALTED
)
329 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
330 if ((retval
= target
->type
->halt(target
))!=ERROR_OK
)
335 target
= target
->next
;
339 LOG_DEBUG("Waiting for halted stated as appropriate");
341 if ((reset_mode
== RESET_HALT
) || (reset_mode
== RESET_INIT
))
346 /* Wait for reset to complete, maximum 5 seconds. */
347 if (((retval
=target_wait_state(target
, TARGET_HALTED
, 5000)))==ERROR_OK
)
349 if (reset_mode
== RESET_INIT
)
350 target_invoke_script(cmd_ctx
, target
, "post_reset");
352 target
= target
->next
;
356 /* We want any events to be processed before the prompt */
357 target_call_timer_callbacks_now();
362 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
368 static int default_mmu(struct target_s
*target
, int *enabled
)
374 static int default_examine(struct target_s
*target
)
376 target
->type
->examined
= 1;
381 /* Targets that correctly implement init+examine, i.e.
382 * no communication with target during init:
386 int target_examine(void)
388 int retval
= ERROR_OK
;
389 target_t
*target
= targets
;
392 if ((retval
= target
->type
->examine(target
))!=ERROR_OK
)
394 target
= target
->next
;
399 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
401 if (!target
->type
->examined
)
403 LOG_ERROR("Target not examined yet");
406 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
409 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
411 if (!target
->type
->examined
)
413 LOG_ERROR("Target not examined yet");
416 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
419 static int target_soft_reset_halt_imp(struct target_s
*target
)
421 if (!target
->type
->examined
)
423 LOG_ERROR("Target not examined yet");
426 return target
->type
->soft_reset_halt_imp(target
);
429 static int target_run_algorithm_imp(struct target_s
*target
, int num_mem_params
, mem_param_t
*mem_params
, int num_reg_params
, reg_param_t
*reg_param
, u32 entry_point
, u32 exit_point
, int timeout_ms
, void *arch_info
)
431 if (!target
->type
->examined
)
433 LOG_ERROR("Target not examined yet");
436 return target
->type
->run_algorithm_imp(target
, num_mem_params
, mem_params
, num_reg_params
, reg_param
, entry_point
, exit_point
, timeout_ms
, arch_info
);
439 int target_init(struct command_context_s
*cmd_ctx
)
441 target_t
*target
= targets
;
445 target
->type
->examined
= 0;
446 if (target
->type
->examine
== NULL
)
448 target
->type
->examine
= default_examine
;
451 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
453 LOG_ERROR("target '%s' init failed", target
->type
->name
);
457 /* Set up default functions if none are provided by target */
458 if (target
->type
->virt2phys
== NULL
)
460 target
->type
->virt2phys
= default_virt2phys
;
462 target
->type
->virt2phys
= default_virt2phys
;
463 /* a non-invasive way(in terms of patches) to add some code that
464 * runs before the type->write/read_memory implementation
466 target
->type
->write_memory_imp
= target
->type
->write_memory
;
467 target
->type
->write_memory
= target_write_memory_imp
;
468 target
->type
->read_memory_imp
= target
->type
->read_memory
;
469 target
->type
->read_memory
= target_read_memory_imp
;
470 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
471 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
472 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
473 target
->type
->run_algorithm
= target_run_algorithm_imp
;
476 if (target
->type
->mmu
== NULL
)
478 target
->type
->mmu
= default_mmu
;
480 target
= target
->next
;
485 target_register_user_commands(cmd_ctx
);
486 target_register_timer_callback(handle_target
, 100, 1, NULL
);
492 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
494 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
496 if (callback
== NULL
)
498 return ERROR_INVALID_ARGUMENTS
;
503 while ((*callbacks_p
)->next
)
504 callbacks_p
= &((*callbacks_p
)->next
);
505 callbacks_p
= &((*callbacks_p
)->next
);
508 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
509 (*callbacks_p
)->callback
= callback
;
510 (*callbacks_p
)->priv
= priv
;
511 (*callbacks_p
)->next
= NULL
;
516 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
518 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
521 if (callback
== NULL
)
523 return ERROR_INVALID_ARGUMENTS
;
528 while ((*callbacks_p
)->next
)
529 callbacks_p
= &((*callbacks_p
)->next
);
530 callbacks_p
= &((*callbacks_p
)->next
);
533 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
534 (*callbacks_p
)->callback
= callback
;
535 (*callbacks_p
)->periodic
= periodic
;
536 (*callbacks_p
)->time_ms
= time_ms
;
538 gettimeofday(&now
, NULL
);
539 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
540 time_ms
-= (time_ms
% 1000);
541 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
542 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
544 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
545 (*callbacks_p
)->when
.tv_sec
+= 1;
548 (*callbacks_p
)->priv
= priv
;
549 (*callbacks_p
)->next
= NULL
;
554 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
556 target_event_callback_t
**p
= &target_event_callbacks
;
557 target_event_callback_t
*c
= target_event_callbacks
;
559 if (callback
== NULL
)
561 return ERROR_INVALID_ARGUMENTS
;
566 target_event_callback_t
*next
= c
->next
;
567 if ((c
->callback
== callback
) && (c
->priv
== priv
))
581 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
583 target_timer_callback_t
**p
= &target_timer_callbacks
;
584 target_timer_callback_t
*c
= target_timer_callbacks
;
586 if (callback
== NULL
)
588 return ERROR_INVALID_ARGUMENTS
;
593 target_timer_callback_t
*next
= c
->next
;
594 if ((c
->callback
== callback
) && (c
->priv
== priv
))
608 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
610 target_event_callback_t
*callback
= target_event_callbacks
;
611 target_event_callback_t
*next_callback
;
613 LOG_DEBUG("target event %i", event
);
617 next_callback
= callback
->next
;
618 callback
->callback(target
, event
, callback
->priv
);
619 callback
= next_callback
;
625 static int target_call_timer_callbacks_check_time(int checktime
)
627 target_timer_callback_t
*callback
= target_timer_callbacks
;
628 target_timer_callback_t
*next_callback
;
633 gettimeofday(&now
, NULL
);
637 next_callback
= callback
->next
;
639 if ((!checktime
&&callback
->periodic
)||
640 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
641 || (now
.tv_sec
> callback
->when
.tv_sec
)))
643 if(callback
->callback
!= NULL
)
645 callback
->callback(callback
->priv
);
646 if (callback
->periodic
)
648 int time_ms
= callback
->time_ms
;
649 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
650 time_ms
-= (time_ms
% 1000);
651 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
652 if (callback
->when
.tv_usec
> 1000000)
654 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
655 callback
->when
.tv_sec
+= 1;
659 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
663 callback
= next_callback
;
669 int target_call_timer_callbacks(void)
671 return target_call_timer_callbacks_check_time(1);
674 /* invoke periodic callbacks immediately */
675 int target_call_timer_callbacks_now(void)
677 return target_call_timer_callbacks();
680 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
682 working_area_t
*c
= target
->working_areas
;
683 working_area_t
*new_wa
= NULL
;
685 /* Reevaluate working area address based on MMU state*/
686 if (target
->working_areas
== NULL
)
690 retval
= target
->type
->mmu(target
, &enabled
);
691 if (retval
!= ERROR_OK
)
697 target
->working_area
= target
->working_area_virt
;
701 target
->working_area
= target
->working_area_phys
;
705 /* only allocate multiples of 4 byte */
708 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
709 size
= CEIL(size
, 4);
712 /* see if there's already a matching working area */
715 if ((c
->free
) && (c
->size
== size
))
723 /* if not, allocate a new one */
726 working_area_t
**p
= &target
->working_areas
;
727 u32 first_free
= target
->working_area
;
728 u32 free_size
= target
->working_area_size
;
730 LOG_DEBUG("allocating new working area");
732 c
= target
->working_areas
;
735 first_free
+= c
->size
;
736 free_size
-= c
->size
;
741 if (free_size
< size
)
743 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
744 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
747 new_wa
= malloc(sizeof(working_area_t
));
750 new_wa
->address
= first_free
;
752 if (target
->backup_working_area
)
754 new_wa
->backup
= malloc(new_wa
->size
);
755 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
759 new_wa
->backup
= NULL
;
762 /* put new entry in list */
766 /* mark as used, and return the new (reused) area */
776 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
781 if (restore
&&target
->backup_working_area
)
782 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
786 /* mark user pointer invalid */
793 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
795 return target_free_working_area_restore(target
, area
, 1);
798 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
800 working_area_t
*c
= target
->working_areas
;
804 working_area_t
*next
= c
->next
;
805 target_free_working_area_restore(target
, c
, restore
);
815 target
->working_areas
= NULL
;
820 int target_free_all_working_areas(struct target_s
*target
)
822 return target_free_all_working_areas_restore(target
, 1);
825 int target_register_commands(struct command_context_s
*cmd_ctx
)
827 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
828 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
829 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
830 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
831 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
834 /* script procedures */
835 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
836 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
840 int target_arch_state(struct target_s
*target
)
845 LOG_USER("No target has been configured");
849 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
851 if (target
->state
!=TARGET_HALTED
)
854 retval
=target
->type
->arch_state(target
);
858 /* Single aligned words are guaranteed to use 16 or 32 bit access
859 * mode respectively, otherwise data is handled as quickly as
862 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
865 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
867 if (!target
->type
->examined
)
869 LOG_ERROR("Target not examined yet");
873 if (address
+size
<address
)
875 /* GDB can request this when e.g. PC is 0xfffffffc*/
876 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
880 if (((address
% 2) == 0) && (size
== 2))
882 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
885 /* handle unaligned head bytes */
888 int unaligned
= 4 - (address
% 4);
890 if (unaligned
> size
)
893 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
897 address
+= unaligned
;
901 /* handle aligned words */
904 int aligned
= size
- (size
% 4);
906 /* use bulk writes above a certain limit. This may have to be changed */
909 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
914 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
923 /* handle tail writes of less than 4 bytes */
926 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
934 /* Single aligned words are guaranteed to use 16 or 32 bit access
935 * mode respectively, otherwise data is handled as quickly as
938 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
941 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
943 if (!target
->type
->examined
)
945 LOG_ERROR("Target not examined yet");
949 if (address
+size
<address
)
951 /* GDB can request this when e.g. PC is 0xfffffffc*/
952 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
956 if (((address
% 2) == 0) && (size
== 2))
958 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
961 /* handle unaligned head bytes */
964 int unaligned
= 4 - (address
% 4);
966 if (unaligned
> size
)
969 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
973 address
+= unaligned
;
977 /* handle aligned words */
980 int aligned
= size
- (size
% 4);
982 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
990 /* handle tail writes of less than 4 bytes */
993 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1000 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1006 if (!target
->type
->examined
)
1008 LOG_ERROR("Target not examined yet");
1012 if ((retval
= target
->type
->checksum_memory(target
, address
,
1013 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1015 buffer
= malloc(size
);
1018 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1019 return ERROR_INVALID_ARGUMENTS
;
1021 retval
= target_read_buffer(target
, address
, size
, buffer
);
1022 if (retval
!= ERROR_OK
)
1028 /* convert to target endianess */
1029 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1032 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1033 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1036 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1045 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1048 if (!target
->type
->examined
)
1050 LOG_ERROR("Target not examined yet");
1054 if (target
->type
->blank_check_memory
== 0)
1055 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1057 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1062 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1065 if (!target
->type
->examined
)
1067 LOG_ERROR("Target not examined yet");
1071 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1073 if (retval
== ERROR_OK
)
1075 *value
= target_buffer_get_u32(target
, value_buf
);
1076 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1081 LOG_DEBUG("address: 0x%8.8x failed", address
);
1087 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1090 if (!target
->type
->examined
)
1092 LOG_ERROR("Target not examined yet");
1096 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1098 if (retval
== ERROR_OK
)
1100 *value
= target_buffer_get_u16(target
, value_buf
);
1101 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1106 LOG_DEBUG("address: 0x%8.8x failed", address
);
1112 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1114 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1115 if (!target
->type
->examined
)
1117 LOG_ERROR("Target not examined yet");
1121 if (retval
== ERROR_OK
)
1123 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1128 LOG_DEBUG("address: 0x%8.8x failed", address
);
1134 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1138 if (!target
->type
->examined
)
1140 LOG_ERROR("Target not examined yet");
1144 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1146 target_buffer_set_u32(target
, value_buf
, value
);
1147 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1149 LOG_DEBUG("failed: %i", retval
);
1155 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1159 if (!target
->type
->examined
)
1161 LOG_ERROR("Target not examined yet");
1165 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1167 target_buffer_set_u16(target
, value_buf
, value
);
1168 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1170 LOG_DEBUG("failed: %i", retval
);
1176 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1179 if (!target
->type
->examined
)
1181 LOG_ERROR("Target not examined yet");
1185 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1187 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1189 LOG_DEBUG("failed: %i", retval
);
1195 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1197 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1198 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1199 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1200 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1201 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1202 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1203 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init] - default is run");
1204 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1206 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1207 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1208 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1210 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1211 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1212 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1214 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1215 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1216 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1217 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1219 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
1220 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1221 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1223 target_request_register_commands(cmd_ctx
);
1224 trace_register_commands(cmd_ctx
);
1229 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1231 target_t
*target
= targets
;
1236 int num
= strtoul(args
[0], NULL
, 0);
1241 target
= target
->next
;
1245 cmd_ctx
->current_target
= num
;
1247 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1254 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1255 target
= target
->next
;
1261 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1268 return ERROR_COMMAND_SYNTAX_ERROR
;
1271 /* search for the specified target */
1272 if (args
[0] && (args
[0][0] != 0))
1274 for (i
= 0; target_types
[i
]; i
++)
1276 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1278 target_t
**last_target_p
= &targets
;
1280 /* register target specific commands */
1281 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1283 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1289 while ((*last_target_p
)->next
)
1290 last_target_p
= &((*last_target_p
)->next
);
1291 last_target_p
= &((*last_target_p
)->next
);
1294 *last_target_p
= malloc(sizeof(target_t
));
1296 /* allocate memory for each unique target type */
1297 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1298 *((*last_target_p
)->type
) = *target_types
[i
];
1300 if (strcmp(args
[1], "big") == 0)
1301 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1302 else if (strcmp(args
[1], "little") == 0)
1303 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1306 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1307 return ERROR_COMMAND_SYNTAX_ERROR
;
1310 if (strcmp(args
[2], "reset_halt") == 0)
1312 LOG_WARNING("reset_mode argument is obsolete.");
1313 return ERROR_COMMAND_SYNTAX_ERROR
;
1315 else if (strcmp(args
[2], "reset_run") == 0)
1317 LOG_WARNING("reset_mode argument is obsolete.");
1318 return ERROR_COMMAND_SYNTAX_ERROR
;
1320 else if (strcmp(args
[2], "reset_init") == 0)
1322 LOG_WARNING("reset_mode argument is obsolete.");
1323 return ERROR_COMMAND_SYNTAX_ERROR
;
1325 else if (strcmp(args
[2], "run_and_halt") == 0)
1327 LOG_WARNING("reset_mode argument is obsolete.");
1328 return ERROR_COMMAND_SYNTAX_ERROR
;
1330 else if (strcmp(args
[2], "run_and_init") == 0)
1332 LOG_WARNING("reset_mode argument is obsolete.");
1333 return ERROR_COMMAND_SYNTAX_ERROR
;
1337 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1342 (*last_target_p
)->working_area
= 0x0;
1343 (*last_target_p
)->working_area_size
= 0x0;
1344 (*last_target_p
)->working_areas
= NULL
;
1345 (*last_target_p
)->backup_working_area
= 0;
1347 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1348 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1349 (*last_target_p
)->reg_cache
= NULL
;
1350 (*last_target_p
)->breakpoints
= NULL
;
1351 (*last_target_p
)->watchpoints
= NULL
;
1352 (*last_target_p
)->next
= NULL
;
1353 (*last_target_p
)->arch_info
= NULL
;
1355 /* initialize trace information */
1356 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1357 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1358 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1359 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1360 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1361 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1362 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1363 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1365 (*last_target_p
)->dbgmsg
= NULL
;
1366 (*last_target_p
)->dbg_msg_enabled
= 0;
1368 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1376 /* no matching target found */
1379 LOG_ERROR("target '%s' not found", args
[0]);
1380 return ERROR_COMMAND_SYNTAX_ERROR
;
1386 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1388 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
1389 get_num_by_target(target
), name
,
1390 get_num_by_target(target
), name
);
1393 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1395 target_t
*target
= NULL
;
1397 if ((argc
< 4) || (argc
> 5))
1399 return ERROR_COMMAND_SYNTAX_ERROR
;
1402 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1405 return ERROR_COMMAND_SYNTAX_ERROR
;
1407 target_free_all_working_areas(target
);
1409 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1412 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1414 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1416 if (strcmp(args
[3], "backup") == 0)
1418 target
->backup_working_area
= 1;
1420 else if (strcmp(args
[3], "nobackup") == 0)
1422 target
->backup_working_area
= 0;
1426 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1427 return ERROR_COMMAND_SYNTAX_ERROR
;
1434 /* process target state changes */
1435 int handle_target(void *priv
)
1437 target_t
*target
= targets
;
1441 if (target_continous_poll
)
1443 /* polling may fail silently until the target has been examined */
1444 target_poll(target
);
1447 target
= target
->next
;
1453 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1462 target
= get_current_target(cmd_ctx
);
1464 /* list all available registers for the current target */
1467 reg_cache_t
*cache
= target
->reg_cache
;
1473 for (i
= 0; i
< cache
->num_regs
; i
++)
1475 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1476 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
);
1479 cache
= cache
->next
;
1485 /* access a single register by its ordinal number */
1486 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1488 int num
= strtoul(args
[0], NULL
, 0);
1489 reg_cache_t
*cache
= target
->reg_cache
;
1495 for (i
= 0; i
< cache
->num_regs
; i
++)
1499 reg
= &cache
->reg_list
[i
];
1505 cache
= cache
->next
;
1510 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1513 } else /* access a single register by its name */
1515 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1519 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1524 /* display a register */
1525 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1527 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1530 if (reg
->valid
== 0)
1532 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1533 if (arch_type
== NULL
)
1535 LOG_ERROR("BUG: encountered unregistered arch type");
1538 arch_type
->get(reg
);
1540 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1541 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1546 /* set register value */
1549 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1550 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1552 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1553 if (arch_type
== NULL
)
1555 LOG_ERROR("BUG: encountered unregistered arch type");
1559 arch_type
->set(reg
, buf
);
1561 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1562 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1570 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1576 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1578 target_t
*target
= get_current_target(cmd_ctx
);
1582 target_poll(target
);
1583 target_arch_state(target
);
1587 if (strcmp(args
[0], "on") == 0)
1589 target_continous_poll
= 1;
1591 else if (strcmp(args
[0], "off") == 0)
1593 target_continous_poll
= 0;
1597 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1605 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1613 ms
= strtoul(args
[0], &end
, 0) * 1000;
1616 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1620 target_t
*target
= get_current_target(cmd_ctx
);
1622 return target_wait_state(target
, TARGET_HALTED
, ms
);
1625 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1628 struct timeval timeout
, now
;
1630 gettimeofday(&timeout
, NULL
);
1631 timeval_add_time(&timeout
, 0, ms
* 1000);
1635 if ((retval
=target_poll(target
))!=ERROR_OK
)
1637 target_call_timer_callbacks_now();
1638 if (target
->state
== state
)
1645 LOG_USER("waiting for target %s...", target_state_strings
[state
]);
1648 gettimeofday(&now
, NULL
);
1649 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1651 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1659 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1662 target_t
*target
= get_current_target(cmd_ctx
);
1666 if ((retval
= target_halt(target
)) != ERROR_OK
)
1671 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1674 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1676 target_t
*target
= get_current_target(cmd_ctx
);
1678 LOG_USER("requesting target halt and executing a soft reset");
1680 target
->type
->soft_reset_halt(target
);
1685 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1687 enum target_reset_mode reset_mode
= RESET_RUN
;
1691 if (strcmp("run", args
[0]) == 0)
1692 reset_mode
= RESET_RUN
;
1693 else if (strcmp("halt", args
[0]) == 0)
1694 reset_mode
= RESET_HALT
;
1695 else if (strcmp("init", args
[0]) == 0)
1696 reset_mode
= RESET_INIT
;
1699 return ERROR_COMMAND_SYNTAX_ERROR
;
1703 /* reset *all* targets */
1704 return target_process_reset(cmd_ctx
, reset_mode
);
1707 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1710 target_t
*target
= get_current_target(cmd_ctx
);
1712 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1715 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1717 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1720 return ERROR_COMMAND_SYNTAX_ERROR
;
1726 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1728 target_t
*target
= get_current_target(cmd_ctx
);
1733 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1736 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1741 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1743 const int line_bytecnt
= 32;
1756 target_t
*target
= get_current_target(cmd_ctx
);
1762 count
= strtoul(args
[1], NULL
, 0);
1764 address
= strtoul(args
[0], NULL
, 0);
1770 size
= 4; line_modulo
= line_bytecnt
/ 4;
1773 size
= 2; line_modulo
= line_bytecnt
/ 2;
1776 size
= 1; line_modulo
= line_bytecnt
/ 1;
1782 buffer
= calloc(count
, size
);
1783 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1784 if (retval
== ERROR_OK
)
1788 for (i
= 0; i
< count
; i
++)
1790 if (i
%line_modulo
== 0)
1791 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1796 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1799 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1802 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1806 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1808 command_print(cmd_ctx
, output
);
1819 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1826 target_t
*target
= get_current_target(cmd_ctx
);
1829 if ((argc
< 2) || (argc
> 3))
1830 return ERROR_COMMAND_SYNTAX_ERROR
;
1832 address
= strtoul(args
[0], NULL
, 0);
1833 value
= strtoul(args
[1], NULL
, 0);
1835 count
= strtoul(args
[2], NULL
, 0);
1841 target_buffer_set_u32(target
, value_buf
, value
);
1845 target_buffer_set_u16(target
, value_buf
, value
);
1849 value_buf
[0] = value
;
1852 return ERROR_COMMAND_SYNTAX_ERROR
;
1854 for (i
=0; i
<count
; i
++)
1860 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1863 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1866 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1871 if (retval
!=ERROR_OK
)
1881 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1887 u32 max_address
=0xffffffff;
1893 duration_t duration
;
1894 char *duration_text
;
1896 target_t
*target
= get_current_target(cmd_ctx
);
1898 if ((argc
< 1)||(argc
> 5))
1900 return ERROR_COMMAND_SYNTAX_ERROR
;
1903 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1906 image
.base_address_set
= 1;
1907 image
.base_address
= strtoul(args
[1], NULL
, 0);
1911 image
.base_address_set
= 0;
1915 image
.start_address_set
= 0;
1919 min_address
=strtoul(args
[3], NULL
, 0);
1923 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
1926 if (min_address
>max_address
)
1928 return ERROR_COMMAND_SYNTAX_ERROR
;
1932 duration_start_measure(&duration
);
1934 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1941 for (i
= 0; i
< image
.num_sections
; i
++)
1943 buffer
= malloc(image
.sections
[i
].size
);
1946 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1950 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1960 /* DANGER!!! beware of unsigned comparision here!!! */
1962 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
1963 (image
.sections
[i
].base_address
<max_address
))
1965 if (image
.sections
[i
].base_address
<min_address
)
1967 /* clip addresses below */
1968 offset
+=min_address
-image
.sections
[i
].base_address
;
1972 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
1974 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
1977 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
1982 image_size
+= length
;
1983 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
1989 duration_stop_measure(&duration
, &duration_text
);
1990 if (retval
==ERROR_OK
)
1992 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1994 free(duration_text
);
1996 image_close(&image
);
2002 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2009 int retval
=ERROR_OK
;
2011 duration_t duration
;
2012 char *duration_text
;
2014 target_t
*target
= get_current_target(cmd_ctx
);
2018 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2022 address
= strtoul(args
[1], NULL
, 0);
2023 size
= strtoul(args
[2], NULL
, 0);
2025 if ((address
& 3) || (size
& 3))
2027 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2031 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2036 duration_start_measure(&duration
);
2041 u32 this_run_size
= (size
> 560) ? 560 : size
;
2043 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2044 if (retval
!= ERROR_OK
)
2049 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2050 if (retval
!= ERROR_OK
)
2055 size
-= this_run_size
;
2056 address
+= this_run_size
;
2059 fileio_close(&fileio
);
2061 duration_stop_measure(&duration
, &duration_text
);
2062 if (retval
==ERROR_OK
)
2064 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2066 free(duration_text
);
2071 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2079 u32 mem_checksum
= 0;
2083 duration_t duration
;
2084 char *duration_text
;
2086 target_t
*target
= get_current_target(cmd_ctx
);
2090 return ERROR_COMMAND_SYNTAX_ERROR
;
2095 LOG_ERROR("no target selected");
2099 duration_start_measure(&duration
);
2103 image
.base_address_set
= 1;
2104 image
.base_address
= strtoul(args
[1], NULL
, 0);
2108 image
.base_address_set
= 0;
2109 image
.base_address
= 0x0;
2112 image
.start_address_set
= 0;
2114 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2121 for (i
= 0; i
< image
.num_sections
; i
++)
2123 buffer
= malloc(image
.sections
[i
].size
);
2126 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2129 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2135 /* calculate checksum of image */
2136 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2138 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2139 if( retval
!= ERROR_OK
)
2145 if( checksum
!= mem_checksum
)
2147 /* failed crc checksum, fall back to a binary compare */
2150 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2152 data
= (u8
*)malloc(buf_cnt
);
2154 /* Can we use 32bit word accesses? */
2156 int count
= buf_cnt
;
2157 if ((count
% 4) == 0)
2162 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2163 if (retval
== ERROR_OK
)
2166 for (t
= 0; t
< buf_cnt
; t
++)
2168 if (data
[t
] != buffer
[t
])
2170 command_print(cmd_ctx
, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", t
+ image
.sections
[i
].base_address
, data
[t
], buffer
[t
]);
2183 image_size
+= buf_cnt
;
2186 duration_stop_measure(&duration
, &duration_text
);
2187 if (retval
==ERROR_OK
)
2189 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2191 free(duration_text
);
2193 image_close(&image
);
2198 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2201 target_t
*target
= get_current_target(cmd_ctx
);
2205 breakpoint_t
*breakpoint
= target
->breakpoints
;
2209 if (breakpoint
->type
== BKPT_SOFT
)
2211 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2212 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2217 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2219 breakpoint
= breakpoint
->next
;
2227 length
= strtoul(args
[1], NULL
, 0);
2230 if (strcmp(args
[2], "hw") == 0)
2233 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2235 LOG_ERROR("Failure setting breakpoints");
2239 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2244 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2250 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2252 target_t
*target
= get_current_target(cmd_ctx
);
2255 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2260 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2262 target_t
*target
= get_current_target(cmd_ctx
);
2267 watchpoint_t
*watchpoint
= target
->watchpoints
;
2271 command_print(cmd_ctx
, "address: 0x%8.8x, len: 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
);
2272 watchpoint
= watchpoint
->next
;
2277 enum watchpoint_rw type
= WPT_ACCESS
;
2278 u32 data_value
= 0x0;
2279 u32 data_mask
= 0xffffffff;
2295 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2301 data_value
= strtoul(args
[3], NULL
, 0);
2305 data_mask
= strtoul(args
[4], NULL
, 0);
2308 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2309 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2311 LOG_ERROR("Failure setting breakpoints");
2316 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2322 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2324 target_t
*target
= get_current_target(cmd_ctx
);
2327 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2332 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2335 target_t
*target
= get_current_target(cmd_ctx
);
2341 return ERROR_COMMAND_SYNTAX_ERROR
;
2343 va
= strtoul(args
[0], NULL
, 0);
2345 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2346 if (retval
== ERROR_OK
)
2348 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2352 /* lower levels will have logged a detailed error which is
2353 * forwarded to telnet/GDB session.
2358 static void writeLong(FILE *f
, int l
)
2363 char c
=(l
>>(i
*8))&0xff;
2364 fwrite(&c
, 1, 1, f
);
2368 static void writeString(FILE *f
, char *s
)
2370 fwrite(s
, 1, strlen(s
), f
);
2375 // Dump a gmon.out histogram file.
2376 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2379 FILE *f
=fopen(filename
, "w");
2382 fwrite("gmon", 1, 4, f
);
2383 writeLong(f
, 0x00000001); // Version
2384 writeLong(f
, 0); // padding
2385 writeLong(f
, 0); // padding
2386 writeLong(f
, 0); // padding
2388 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2390 // figure out bucket size
2393 for (i
=0; i
<sampleNum
; i
++)
2405 int addressSpace
=(max
-min
+1);
2407 static int const maxBuckets
=256*1024; // maximum buckets.
2408 int length
=addressSpace
;
2409 if (length
> maxBuckets
)
2413 int *buckets
=malloc(sizeof(int)*length
);
2419 memset(buckets
, 0, sizeof(int)*length
);
2420 for (i
=0; i
<sampleNum
;i
++)
2422 u32 address
=samples
[i
];
2423 long long a
=address
-min
;
2424 long long b
=length
-1;
2425 long long c
=addressSpace
-1;
2426 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2430 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2431 writeLong(f
, min
); // low_pc
2432 writeLong(f
, max
); // high_pc
2433 writeLong(f
, length
); // # of samples
2434 writeLong(f
, 64000000); // 64MHz
2435 writeString(f
, "seconds");
2436 for (i
=0; i
<(15-strlen("seconds")); i
++)
2438 fwrite("", 1, 1, f
); // padding
2440 writeString(f
, "s");
2442 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2444 char *data
=malloc(2*length
);
2447 for (i
=0; i
<length
;i
++)
2456 data
[i
*2+1]=(val
>>8)&0xff;
2459 fwrite(data
, 1, length
*2, f
);
2469 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2470 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2472 target_t
*target
= get_current_target(cmd_ctx
);
2473 struct timeval timeout
, now
;
2475 gettimeofday(&timeout
, NULL
);
2478 return ERROR_COMMAND_SYNTAX_ERROR
;
2481 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2487 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2489 static const int maxSample
=10000;
2490 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2495 int retval
=ERROR_OK
;
2496 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2497 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2501 target_poll(target
);
2502 if (target
->state
== TARGET_HALTED
)
2504 u32 t
=*((u32
*)reg
->value
);
2505 samples
[numSamples
++]=t
;
2506 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2507 target_poll(target
);
2508 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2509 } else if (target
->state
== TARGET_RUNNING
)
2511 // We want to quickly sample the PC.
2512 target_halt(target
);
2515 command_print(cmd_ctx
, "Target not halted or running");
2519 if (retval
!=ERROR_OK
)
2524 gettimeofday(&now
, NULL
);
2525 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2527 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2528 target_poll(target
);
2529 if (target
->state
== TARGET_HALTED
)
2531 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2533 target_poll(target
);
2534 writeGmon(samples
, numSamples
, args
[1]);
2535 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2544 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2547 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2550 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2554 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2555 valObjPtr
= Jim_NewIntObj(interp
, val
);
2556 if (!nameObjPtr
|| !valObjPtr
)
2562 Jim_IncrRefCount(nameObjPtr
);
2563 Jim_IncrRefCount(valObjPtr
);
2564 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2565 Jim_DecrRefCount(interp
, nameObjPtr
);
2566 Jim_DecrRefCount(interp
, valObjPtr
);
2568 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2572 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2575 command_context_t
*context
;
2582 const char *varname
;
2584 int i
, n
, e
, retval
;
2586 /* argv[1] = name of array to receive the data
2587 * argv[2] = desired width
2588 * argv[3] = memory address
2589 * argv[4] = count of times to read
2592 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2595 varname
= Jim_GetString(argv
[1], &len
);
2596 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2598 e
= Jim_GetLong(interp
, argv
[2], &l
);
2604 e
= Jim_GetLong(interp
, argv
[3], &l
);
2609 e
= Jim_GetLong(interp
, argv
[4], &l
);
2625 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2626 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2630 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2631 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2634 if ((addr
+ (len
* width
)) < addr
) {
2635 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2636 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2639 /* absurd transfer size? */
2641 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2642 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2647 ((width
== 2) && ((addr
& 1) == 0)) ||
2648 ((width
== 4) && ((addr
& 3) == 0))) {
2652 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2653 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2654 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2658 context
= Jim_GetAssocData(interp
, "context");
2659 if (context
== NULL
)
2661 LOG_ERROR("mem2array: no command context");
2664 target
= get_current_target(context
);
2667 LOG_ERROR("mem2array: no current target");
2678 /* Slurp... in buffer size chunks */
2680 count
= len
; /* in objects.. */
2681 if (count
> (sizeof(buffer
)/width
)) {
2682 count
= (sizeof(buffer
)/width
);
2685 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2686 if (retval
!= ERROR_OK
) {
2688 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2689 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2690 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2694 v
= 0; /* shut up gcc */
2695 for (i
= 0 ;i
< count
;i
++, n
++) {
2698 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2701 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2704 v
= buffer
[i
] & 0x0ff;
2707 new_int_array_element(interp
, varname
, n
, v
);
2713 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2718 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2721 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2725 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2729 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2736 Jim_IncrRefCount(nameObjPtr
);
2737 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2738 Jim_DecrRefCount(interp
, nameObjPtr
);
2740 if (valObjPtr
== NULL
)
2743 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2744 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2749 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2752 command_context_t
*context
;
2759 const char *varname
;
2761 int i
, n
, e
, retval
;
2763 /* argv[1] = name of array to get the data
2764 * argv[2] = desired width
2765 * argv[3] = memory address
2766 * argv[4] = count to write
2769 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2772 varname
= Jim_GetString(argv
[1], &len
);
2773 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2775 e
= Jim_GetLong(interp
, argv
[2], &l
);
2781 e
= Jim_GetLong(interp
, argv
[3], &l
);
2786 e
= Jim_GetLong(interp
, argv
[4], &l
);
2802 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2803 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2807 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2808 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2811 if ((addr
+ (len
* width
)) < addr
) {
2812 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2813 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2816 /* absurd transfer size? */
2818 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2819 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2824 ((width
== 2) && ((addr
& 1) == 0)) ||
2825 ((width
== 4) && ((addr
& 3) == 0))) {
2829 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2830 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2831 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2835 context
= Jim_GetAssocData(interp
, "context");
2836 if (context
== NULL
)
2838 LOG_ERROR("array2mem: no command context");
2841 target
= get_current_target(context
);
2844 LOG_ERROR("array2mem: no current target");
2855 /* Slurp... in buffer size chunks */
2857 count
= len
; /* in objects.. */
2858 if (count
> (sizeof(buffer
)/width
)) {
2859 count
= (sizeof(buffer
)/width
);
2862 v
= 0; /* shut up gcc */
2863 for (i
= 0 ;i
< count
;i
++, n
++) {
2864 get_int_array_element(interp
, varname
, n
, &v
);
2867 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2870 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2873 buffer
[i
] = v
& 0x0ff;
2879 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2880 if (retval
!= ERROR_OK
) {
2882 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2883 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2884 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2890 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
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)