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]");
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 target_process_reset(cmd_ctx
, reset_mode
);
1709 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1712 target_t
*target
= get_current_target(cmd_ctx
);
1714 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1717 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1719 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1722 return ERROR_COMMAND_SYNTAX_ERROR
;
1728 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1730 target_t
*target
= get_current_target(cmd_ctx
);
1735 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1738 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1743 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1745 const int line_bytecnt
= 32;
1758 target_t
*target
= get_current_target(cmd_ctx
);
1764 count
= strtoul(args
[1], NULL
, 0);
1766 address
= strtoul(args
[0], NULL
, 0);
1772 size
= 4; line_modulo
= line_bytecnt
/ 4;
1775 size
= 2; line_modulo
= line_bytecnt
/ 2;
1778 size
= 1; line_modulo
= line_bytecnt
/ 1;
1784 buffer
= calloc(count
, size
);
1785 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1786 if (retval
== ERROR_OK
)
1790 for (i
= 0; i
< count
; i
++)
1792 if (i
%line_modulo
== 0)
1793 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1798 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1801 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1804 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1808 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1810 command_print(cmd_ctx
, output
);
1821 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1828 target_t
*target
= get_current_target(cmd_ctx
);
1831 if ((argc
< 2) || (argc
> 3))
1832 return ERROR_COMMAND_SYNTAX_ERROR
;
1834 address
= strtoul(args
[0], NULL
, 0);
1835 value
= strtoul(args
[1], NULL
, 0);
1837 count
= strtoul(args
[2], NULL
, 0);
1843 target_buffer_set_u32(target
, value_buf
, value
);
1847 target_buffer_set_u16(target
, value_buf
, value
);
1851 value_buf
[0] = value
;
1854 return ERROR_COMMAND_SYNTAX_ERROR
;
1856 for (i
=0; i
<count
; i
++)
1862 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1865 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1868 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1873 if (retval
!=ERROR_OK
)
1883 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1889 u32 max_address
=0xffffffff;
1895 duration_t duration
;
1896 char *duration_text
;
1898 target_t
*target
= get_current_target(cmd_ctx
);
1900 if ((argc
< 1)||(argc
> 5))
1902 return ERROR_COMMAND_SYNTAX_ERROR
;
1905 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1908 image
.base_address_set
= 1;
1909 image
.base_address
= strtoul(args
[1], NULL
, 0);
1913 image
.base_address_set
= 0;
1917 image
.start_address_set
= 0;
1921 min_address
=strtoul(args
[3], NULL
, 0);
1925 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
1928 if (min_address
>max_address
)
1930 return ERROR_COMMAND_SYNTAX_ERROR
;
1934 duration_start_measure(&duration
);
1936 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1943 for (i
= 0; i
< image
.num_sections
; i
++)
1945 buffer
= malloc(image
.sections
[i
].size
);
1948 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1952 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1962 /* DANGER!!! beware of unsigned comparision here!!! */
1964 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
1965 (image
.sections
[i
].base_address
<max_address
))
1967 if (image
.sections
[i
].base_address
<min_address
)
1969 /* clip addresses below */
1970 offset
+=min_address
-image
.sections
[i
].base_address
;
1974 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
1976 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
1979 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
1984 image_size
+= length
;
1985 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
1991 duration_stop_measure(&duration
, &duration_text
);
1992 if (retval
==ERROR_OK
)
1994 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1996 free(duration_text
);
1998 image_close(&image
);
2004 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2011 int retval
=ERROR_OK
;
2013 duration_t duration
;
2014 char *duration_text
;
2016 target_t
*target
= get_current_target(cmd_ctx
);
2020 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2024 address
= strtoul(args
[1], NULL
, 0);
2025 size
= strtoul(args
[2], NULL
, 0);
2027 if ((address
& 3) || (size
& 3))
2029 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2033 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2038 duration_start_measure(&duration
);
2043 u32 this_run_size
= (size
> 560) ? 560 : size
;
2045 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2046 if (retval
!= ERROR_OK
)
2051 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2052 if (retval
!= ERROR_OK
)
2057 size
-= this_run_size
;
2058 address
+= this_run_size
;
2061 fileio_close(&fileio
);
2063 duration_stop_measure(&duration
, &duration_text
);
2064 if (retval
==ERROR_OK
)
2066 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2068 free(duration_text
);
2073 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2081 u32 mem_checksum
= 0;
2085 duration_t duration
;
2086 char *duration_text
;
2088 target_t
*target
= get_current_target(cmd_ctx
);
2092 return ERROR_COMMAND_SYNTAX_ERROR
;
2097 LOG_ERROR("no target selected");
2101 duration_start_measure(&duration
);
2105 image
.base_address_set
= 1;
2106 image
.base_address
= strtoul(args
[1], NULL
, 0);
2110 image
.base_address_set
= 0;
2111 image
.base_address
= 0x0;
2114 image
.start_address_set
= 0;
2116 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2123 for (i
= 0; i
< image
.num_sections
; i
++)
2125 buffer
= malloc(image
.sections
[i
].size
);
2128 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2131 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2137 /* calculate checksum of image */
2138 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2140 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2141 if( retval
!= ERROR_OK
)
2147 if( checksum
!= mem_checksum
)
2149 /* failed crc checksum, fall back to a binary compare */
2152 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2154 data
= (u8
*)malloc(buf_cnt
);
2156 /* Can we use 32bit word accesses? */
2158 int count
= buf_cnt
;
2159 if ((count
% 4) == 0)
2164 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2165 if (retval
== ERROR_OK
)
2168 for (t
= 0; t
< buf_cnt
; t
++)
2170 if (data
[t
] != buffer
[t
])
2172 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
]);
2185 image_size
+= buf_cnt
;
2188 duration_stop_measure(&duration
, &duration_text
);
2189 if (retval
==ERROR_OK
)
2191 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2193 free(duration_text
);
2195 image_close(&image
);
2200 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2203 target_t
*target
= get_current_target(cmd_ctx
);
2207 breakpoint_t
*breakpoint
= target
->breakpoints
;
2211 if (breakpoint
->type
== BKPT_SOFT
)
2213 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2214 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2219 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2221 breakpoint
= breakpoint
->next
;
2229 length
= strtoul(args
[1], NULL
, 0);
2232 if (strcmp(args
[2], "hw") == 0)
2235 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2237 LOG_ERROR("Failure setting breakpoints");
2241 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2246 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2252 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2254 target_t
*target
= get_current_target(cmd_ctx
);
2257 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2262 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2264 target_t
*target
= get_current_target(cmd_ctx
);
2269 watchpoint_t
*watchpoint
= target
->watchpoints
;
2273 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
);
2274 watchpoint
= watchpoint
->next
;
2279 enum watchpoint_rw type
= WPT_ACCESS
;
2280 u32 data_value
= 0x0;
2281 u32 data_mask
= 0xffffffff;
2297 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2303 data_value
= strtoul(args
[3], NULL
, 0);
2307 data_mask
= strtoul(args
[4], NULL
, 0);
2310 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2311 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2313 LOG_ERROR("Failure setting breakpoints");
2318 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2324 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2326 target_t
*target
= get_current_target(cmd_ctx
);
2329 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2334 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2337 target_t
*target
= get_current_target(cmd_ctx
);
2343 return ERROR_COMMAND_SYNTAX_ERROR
;
2345 va
= strtoul(args
[0], NULL
, 0);
2347 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2348 if (retval
== ERROR_OK
)
2350 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2354 /* lower levels will have logged a detailed error which is
2355 * forwarded to telnet/GDB session.
2360 static void writeLong(FILE *f
, int l
)
2365 char c
=(l
>>(i
*8))&0xff;
2366 fwrite(&c
, 1, 1, f
);
2370 static void writeString(FILE *f
, char *s
)
2372 fwrite(s
, 1, strlen(s
), f
);
2377 // Dump a gmon.out histogram file.
2378 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2381 FILE *f
=fopen(filename
, "w");
2384 fwrite("gmon", 1, 4, f
);
2385 writeLong(f
, 0x00000001); // Version
2386 writeLong(f
, 0); // padding
2387 writeLong(f
, 0); // padding
2388 writeLong(f
, 0); // padding
2390 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2392 // figure out bucket size
2395 for (i
=0; i
<sampleNum
; i
++)
2407 int addressSpace
=(max
-min
+1);
2409 static int const maxBuckets
=256*1024; // maximum buckets.
2410 int length
=addressSpace
;
2411 if (length
> maxBuckets
)
2415 int *buckets
=malloc(sizeof(int)*length
);
2421 memset(buckets
, 0, sizeof(int)*length
);
2422 for (i
=0; i
<sampleNum
;i
++)
2424 u32 address
=samples
[i
];
2425 long long a
=address
-min
;
2426 long long b
=length
-1;
2427 long long c
=addressSpace
-1;
2428 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2432 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2433 writeLong(f
, min
); // low_pc
2434 writeLong(f
, max
); // high_pc
2435 writeLong(f
, length
); // # of samples
2436 writeLong(f
, 64000000); // 64MHz
2437 writeString(f
, "seconds");
2438 for (i
=0; i
<(15-strlen("seconds")); i
++)
2440 fwrite("", 1, 1, f
); // padding
2442 writeString(f
, "s");
2444 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2446 char *data
=malloc(2*length
);
2449 for (i
=0; i
<length
;i
++)
2458 data
[i
*2+1]=(val
>>8)&0xff;
2461 fwrite(data
, 1, length
*2, f
);
2471 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2472 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2474 target_t
*target
= get_current_target(cmd_ctx
);
2475 struct timeval timeout
, now
;
2477 gettimeofday(&timeout
, NULL
);
2480 return ERROR_COMMAND_SYNTAX_ERROR
;
2483 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2489 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2491 static const int maxSample
=10000;
2492 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2497 int retval
=ERROR_OK
;
2498 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2499 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2503 target_poll(target
);
2504 if (target
->state
== TARGET_HALTED
)
2506 u32 t
=*((u32
*)reg
->value
);
2507 samples
[numSamples
++]=t
;
2508 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2509 target_poll(target
);
2510 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2511 } else if (target
->state
== TARGET_RUNNING
)
2513 // We want to quickly sample the PC.
2514 target_halt(target
);
2517 command_print(cmd_ctx
, "Target not halted or running");
2521 if (retval
!=ERROR_OK
)
2526 gettimeofday(&now
, NULL
);
2527 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2529 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2530 target_poll(target
);
2531 if (target
->state
== TARGET_HALTED
)
2533 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2535 target_poll(target
);
2536 writeGmon(samples
, numSamples
, args
[1]);
2537 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2546 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2549 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2552 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2556 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2557 valObjPtr
= Jim_NewIntObj(interp
, val
);
2558 if (!nameObjPtr
|| !valObjPtr
)
2564 Jim_IncrRefCount(nameObjPtr
);
2565 Jim_IncrRefCount(valObjPtr
);
2566 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2567 Jim_DecrRefCount(interp
, nameObjPtr
);
2568 Jim_DecrRefCount(interp
, valObjPtr
);
2570 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2574 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2577 command_context_t
*context
;
2584 const char *varname
;
2586 int i
, n
, e
, retval
;
2588 /* argv[1] = name of array to receive the data
2589 * argv[2] = desired width
2590 * argv[3] = memory address
2591 * argv[4] = count of times to read
2594 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2597 varname
= Jim_GetString(argv
[1], &len
);
2598 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2600 e
= Jim_GetLong(interp
, argv
[2], &l
);
2606 e
= Jim_GetLong(interp
, argv
[3], &l
);
2611 e
= Jim_GetLong(interp
, argv
[4], &l
);
2627 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2628 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2632 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2633 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2636 if ((addr
+ (len
* width
)) < addr
) {
2637 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2638 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2641 /* absurd transfer size? */
2643 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2644 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2649 ((width
== 2) && ((addr
& 1) == 0)) ||
2650 ((width
== 4) && ((addr
& 3) == 0))) {
2654 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2655 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2656 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2660 context
= Jim_GetAssocData(interp
, "context");
2661 if (context
== NULL
)
2663 LOG_ERROR("mem2array: no command context");
2666 target
= get_current_target(context
);
2669 LOG_ERROR("mem2array: no current target");
2680 /* Slurp... in buffer size chunks */
2682 count
= len
; /* in objects.. */
2683 if (count
> (sizeof(buffer
)/width
)) {
2684 count
= (sizeof(buffer
)/width
);
2687 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2688 if (retval
!= ERROR_OK
) {
2690 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2691 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2692 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2696 v
= 0; /* shut up gcc */
2697 for (i
= 0 ;i
< count
;i
++, n
++) {
2700 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2703 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2706 v
= buffer
[i
] & 0x0ff;
2709 new_int_array_element(interp
, varname
, n
, v
);
2715 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2720 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2723 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2727 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2731 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2738 Jim_IncrRefCount(nameObjPtr
);
2739 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2740 Jim_DecrRefCount(interp
, nameObjPtr
);
2742 if (valObjPtr
== NULL
)
2745 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2746 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2751 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2754 command_context_t
*context
;
2761 const char *varname
;
2763 int i
, n
, e
, retval
;
2765 /* argv[1] = name of array to get the data
2766 * argv[2] = desired width
2767 * argv[3] = memory address
2768 * argv[4] = count to write
2771 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2774 varname
= Jim_GetString(argv
[1], &len
);
2775 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2777 e
= Jim_GetLong(interp
, argv
[2], &l
);
2783 e
= Jim_GetLong(interp
, argv
[3], &l
);
2788 e
= Jim_GetLong(interp
, argv
[4], &l
);
2804 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2805 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2809 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2810 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2813 if ((addr
+ (len
* width
)) < addr
) {
2814 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2815 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2818 /* absurd transfer size? */
2820 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2821 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2826 ((width
== 2) && ((addr
& 1) == 0)) ||
2827 ((width
== 4) && ((addr
& 3) == 0))) {
2831 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2832 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2833 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2837 context
= Jim_GetAssocData(interp
, "context");
2838 if (context
== NULL
)
2840 LOG_ERROR("array2mem: no command context");
2843 target
= get_current_target(context
);
2846 LOG_ERROR("array2mem: no current target");
2857 /* Slurp... in buffer size chunks */
2859 count
= len
; /* in objects.. */
2860 if (count
> (sizeof(buffer
)/width
)) {
2861 count
= (sizeof(buffer
)/width
);
2864 v
= 0; /* shut up gcc */
2865 for (i
= 0 ;i
< count
;i
++, n
++) {
2866 get_int_array_element(interp
, varname
, n
, &v
);
2869 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2872 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2875 buffer
[i
] = v
& 0x0ff;
2881 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2882 if (retval
!= ERROR_OK
) {
2884 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2885 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2886 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2892 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)