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
;
311 /* request target halt if necessary, and schedule further action */
315 if (reset_mode
!=RESET_RUN
)
317 if ((retval
= target_halt(target
))!=ERROR_OK
)
320 target
= target
->next
;
326 if ((retval
= target
->type
->deassert_reset(target
))!=ERROR_OK
)
328 target
= target
->next
;
334 /* We can fail to bring the target into the halted state, try after reset has been deasserted */
335 if (target
->reset_halt
)
337 /* wait up to 1 second for halt. */
338 target_wait_state(target
, TARGET_HALTED
, 1000);
339 if (target
->state
!= TARGET_HALTED
)
341 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
342 if ((retval
= target
->type
->halt(target
))!=ERROR_OK
)
347 target
= target
->next
;
351 LOG_DEBUG("Waiting for halted stated as appropriate");
353 if ((reset_mode
== RESET_HALT
) || (reset_mode
== RESET_INIT
))
358 /* Wait for reset to complete, maximum 5 seconds. */
359 if (((retval
=target_wait_state(target
, TARGET_HALTED
, 5000)))==ERROR_OK
)
361 if (reset_mode
== RESET_INIT
)
362 target_invoke_script(cmd_ctx
, target
, "post_reset");
364 target
= target
->next
;
368 /* We want any events to be processed before the prompt */
369 target_call_timer_callbacks_now();
374 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
380 static int default_mmu(struct target_s
*target
, int *enabled
)
386 static int default_examine(struct target_s
*target
)
388 target
->type
->examined
= 1;
393 /* Targets that correctly implement init+examine, i.e.
394 * no communication with target during init:
398 int target_examine(struct command_context_s
*cmd_ctx
)
400 int retval
= ERROR_OK
;
401 target_t
*target
= targets
;
404 if ((retval
= target
->type
->examine(target
))!=ERROR_OK
)
406 target
= target
->next
;
411 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
413 if (!target
->type
->examined
)
415 LOG_ERROR("Target not examined yet");
418 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
421 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
423 if (!target
->type
->examined
)
425 LOG_ERROR("Target not examined yet");
428 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
431 static int target_soft_reset_halt_imp(struct target_s
*target
)
433 if (!target
->type
->examined
)
435 LOG_ERROR("Target not examined yet");
438 return target
->type
->soft_reset_halt_imp(target
);
441 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
)
443 if (!target
->type
->examined
)
445 LOG_ERROR("Target not examined yet");
448 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
);
451 int target_init(struct command_context_s
*cmd_ctx
)
453 target_t
*target
= targets
;
457 target
->type
->examined
= 0;
458 if (target
->type
->examine
== NULL
)
460 target
->type
->examine
= default_examine
;
463 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
465 LOG_ERROR("target '%s' init failed", target
->type
->name
);
469 /* Set up default functions if none are provided by target */
470 if (target
->type
->virt2phys
== NULL
)
472 target
->type
->virt2phys
= default_virt2phys
;
474 target
->type
->virt2phys
= default_virt2phys
;
475 /* a non-invasive way(in terms of patches) to add some code that
476 * runs before the type->write/read_memory implementation
478 target
->type
->write_memory_imp
= target
->type
->write_memory
;
479 target
->type
->write_memory
= target_write_memory_imp
;
480 target
->type
->read_memory_imp
= target
->type
->read_memory
;
481 target
->type
->read_memory
= target_read_memory_imp
;
482 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
483 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
484 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
485 target
->type
->run_algorithm
= target_run_algorithm_imp
;
488 if (target
->type
->mmu
== NULL
)
490 target
->type
->mmu
= default_mmu
;
492 target
= target
->next
;
497 target_register_user_commands(cmd_ctx
);
498 target_register_timer_callback(handle_target
, 100, 1, NULL
);
504 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
506 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
508 if (callback
== NULL
)
510 return ERROR_INVALID_ARGUMENTS
;
515 while ((*callbacks_p
)->next
)
516 callbacks_p
= &((*callbacks_p
)->next
);
517 callbacks_p
= &((*callbacks_p
)->next
);
520 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
521 (*callbacks_p
)->callback
= callback
;
522 (*callbacks_p
)->priv
= priv
;
523 (*callbacks_p
)->next
= NULL
;
528 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
530 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
533 if (callback
== NULL
)
535 return ERROR_INVALID_ARGUMENTS
;
540 while ((*callbacks_p
)->next
)
541 callbacks_p
= &((*callbacks_p
)->next
);
542 callbacks_p
= &((*callbacks_p
)->next
);
545 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
546 (*callbacks_p
)->callback
= callback
;
547 (*callbacks_p
)->periodic
= periodic
;
548 (*callbacks_p
)->time_ms
= time_ms
;
550 gettimeofday(&now
, NULL
);
551 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
552 time_ms
-= (time_ms
% 1000);
553 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
554 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
556 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
557 (*callbacks_p
)->when
.tv_sec
+= 1;
560 (*callbacks_p
)->priv
= priv
;
561 (*callbacks_p
)->next
= NULL
;
566 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
568 target_event_callback_t
**p
= &target_event_callbacks
;
569 target_event_callback_t
*c
= target_event_callbacks
;
571 if (callback
== NULL
)
573 return ERROR_INVALID_ARGUMENTS
;
578 target_event_callback_t
*next
= c
->next
;
579 if ((c
->callback
== callback
) && (c
->priv
== priv
))
593 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
595 target_timer_callback_t
**p
= &target_timer_callbacks
;
596 target_timer_callback_t
*c
= target_timer_callbacks
;
598 if (callback
== NULL
)
600 return ERROR_INVALID_ARGUMENTS
;
605 target_timer_callback_t
*next
= c
->next
;
606 if ((c
->callback
== callback
) && (c
->priv
== priv
))
620 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
622 target_event_callback_t
*callback
= target_event_callbacks
;
623 target_event_callback_t
*next_callback
;
625 LOG_DEBUG("target event %i", event
);
629 next_callback
= callback
->next
;
630 callback
->callback(target
, event
, callback
->priv
);
631 callback
= next_callback
;
637 static int target_call_timer_callbacks_check_time(int checktime
)
639 target_timer_callback_t
*callback
= target_timer_callbacks
;
640 target_timer_callback_t
*next_callback
;
645 gettimeofday(&now
, NULL
);
649 next_callback
= callback
->next
;
651 if ((!checktime
&&callback
->periodic
)||
652 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
653 || (now
.tv_sec
> callback
->when
.tv_sec
)))
655 if(callback
->callback
!= NULL
)
657 callback
->callback(callback
->priv
);
658 if (callback
->periodic
)
660 int time_ms
= callback
->time_ms
;
661 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
662 time_ms
-= (time_ms
% 1000);
663 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
664 if (callback
->when
.tv_usec
> 1000000)
666 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
667 callback
->when
.tv_sec
+= 1;
671 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
675 callback
= next_callback
;
681 int target_call_timer_callbacks()
683 return target_call_timer_callbacks_check_time(1);
686 /* invoke periodic callbacks immediately */
687 int target_call_timer_callbacks_now()
689 return target_call_timer_callbacks(0);
692 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
694 working_area_t
*c
= target
->working_areas
;
695 working_area_t
*new_wa
= NULL
;
697 /* Reevaluate working area address based on MMU state*/
698 if (target
->working_areas
== NULL
)
702 retval
= target
->type
->mmu(target
, &enabled
);
703 if (retval
!= ERROR_OK
)
709 target
->working_area
= target
->working_area_virt
;
713 target
->working_area
= target
->working_area_phys
;
717 /* only allocate multiples of 4 byte */
720 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
721 size
= CEIL(size
, 4);
724 /* see if there's already a matching working area */
727 if ((c
->free
) && (c
->size
== size
))
735 /* if not, allocate a new one */
738 working_area_t
**p
= &target
->working_areas
;
739 u32 first_free
= target
->working_area
;
740 u32 free_size
= target
->working_area_size
;
742 LOG_DEBUG("allocating new working area");
744 c
= target
->working_areas
;
747 first_free
+= c
->size
;
748 free_size
-= c
->size
;
753 if (free_size
< size
)
755 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
756 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
759 new_wa
= malloc(sizeof(working_area_t
));
762 new_wa
->address
= first_free
;
764 if (target
->backup_working_area
)
766 new_wa
->backup
= malloc(new_wa
->size
);
767 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
771 new_wa
->backup
= NULL
;
774 /* put new entry in list */
778 /* mark as used, and return the new (reused) area */
788 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
793 if (restore
&&target
->backup_working_area
)
794 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
798 /* mark user pointer invalid */
805 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
807 return target_free_working_area_restore(target
, area
, 1);
810 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
812 working_area_t
*c
= target
->working_areas
;
816 working_area_t
*next
= c
->next
;
817 target_free_working_area_restore(target
, c
, restore
);
827 target
->working_areas
= NULL
;
832 int target_free_all_working_areas(struct target_s
*target
)
834 return target_free_all_working_areas_restore(target
, 1);
837 int target_register_commands(struct command_context_s
*cmd_ctx
)
839 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
840 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
841 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
842 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
843 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
846 /* script procedures */
847 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
848 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
852 int target_arch_state(struct target_s
*target
)
857 LOG_USER("No target has been configured");
861 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
863 if (target
->state
!=TARGET_HALTED
)
866 retval
=target
->type
->arch_state(target
);
870 /* Single aligned words are guaranteed to use 16 or 32 bit access
871 * mode respectively, otherwise data is handled as quickly as
874 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
877 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
879 if (!target
->type
->examined
)
881 LOG_ERROR("Target not examined yet");
885 if (address
+size
<address
)
887 /* GDB can request this when e.g. PC is 0xfffffffc*/
888 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
892 if (((address
% 2) == 0) && (size
== 2))
894 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
897 /* handle unaligned head bytes */
900 int unaligned
= 4 - (address
% 4);
902 if (unaligned
> size
)
905 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
909 address
+= unaligned
;
913 /* handle aligned words */
916 int aligned
= size
- (size
% 4);
918 /* use bulk writes above a certain limit. This may have to be changed */
921 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
926 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
935 /* handle tail writes of less than 4 bytes */
938 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
946 /* Single aligned words are guaranteed to use 16 or 32 bit access
947 * mode respectively, otherwise data is handled as quickly as
950 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
953 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
955 if (!target
->type
->examined
)
957 LOG_ERROR("Target not examined yet");
961 if (address
+size
<address
)
963 /* GDB can request this when e.g. PC is 0xfffffffc*/
964 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
968 if (((address
% 2) == 0) && (size
== 2))
970 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
973 /* handle unaligned head bytes */
976 int unaligned
= 4 - (address
% 4);
978 if (unaligned
> size
)
981 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
985 address
+= unaligned
;
989 /* handle aligned words */
992 int aligned
= size
- (size
% 4);
994 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1002 /* handle tail writes of less than 4 bytes */
1005 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1012 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1018 if (!target
->type
->examined
)
1020 LOG_ERROR("Target not examined yet");
1024 if ((retval
= target
->type
->checksum_memory(target
, address
,
1025 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1027 buffer
= malloc(size
);
1030 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1031 return ERROR_INVALID_ARGUMENTS
;
1033 retval
= target_read_buffer(target
, address
, size
, buffer
);
1034 if (retval
!= ERROR_OK
)
1040 /* convert to target endianess */
1041 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1044 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1045 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1048 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1057 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1060 if (!target
->type
->examined
)
1062 LOG_ERROR("Target not examined yet");
1066 if (target
->type
->blank_check_memory
== 0)
1067 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1069 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1074 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1077 if (!target
->type
->examined
)
1079 LOG_ERROR("Target not examined yet");
1083 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1085 if (retval
== ERROR_OK
)
1087 *value
= target_buffer_get_u32(target
, value_buf
);
1088 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1093 LOG_DEBUG("address: 0x%8.8x failed", address
);
1099 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1102 if (!target
->type
->examined
)
1104 LOG_ERROR("Target not examined yet");
1108 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1110 if (retval
== ERROR_OK
)
1112 *value
= target_buffer_get_u16(target
, value_buf
);
1113 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1118 LOG_DEBUG("address: 0x%8.8x failed", address
);
1124 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1126 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1127 if (!target
->type
->examined
)
1129 LOG_ERROR("Target not examined yet");
1133 if (retval
== ERROR_OK
)
1135 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1140 LOG_DEBUG("address: 0x%8.8x failed", address
);
1146 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1150 if (!target
->type
->examined
)
1152 LOG_ERROR("Target not examined yet");
1156 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1158 target_buffer_set_u32(target
, value_buf
, value
);
1159 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1161 LOG_DEBUG("failed: %i", retval
);
1167 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1171 if (!target
->type
->examined
)
1173 LOG_ERROR("Target not examined yet");
1177 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1179 target_buffer_set_u16(target
, value_buf
, value
);
1180 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1182 LOG_DEBUG("failed: %i", retval
);
1188 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1191 if (!target
->type
->examined
)
1193 LOG_ERROR("Target not examined yet");
1197 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1199 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1201 LOG_DEBUG("failed: %i", retval
);
1207 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1209 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1210 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1211 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1212 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1213 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1214 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1215 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init]");
1216 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1218 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1219 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1220 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1222 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1223 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1224 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1226 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1227 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1228 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1229 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1231 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]");
1232 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1233 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1235 target_request_register_commands(cmd_ctx
);
1236 trace_register_commands(cmd_ctx
);
1241 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1243 target_t
*target
= targets
;
1248 int num
= strtoul(args
[0], NULL
, 0);
1253 target
= target
->next
;
1257 cmd_ctx
->current_target
= num
;
1259 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1266 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1267 target
= target
->next
;
1273 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1280 return ERROR_COMMAND_SYNTAX_ERROR
;
1283 /* search for the specified target */
1284 if (args
[0] && (args
[0][0] != 0))
1286 for (i
= 0; target_types
[i
]; i
++)
1288 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1290 target_t
**last_target_p
= &targets
;
1292 /* register target specific commands */
1293 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1295 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1301 while ((*last_target_p
)->next
)
1302 last_target_p
= &((*last_target_p
)->next
);
1303 last_target_p
= &((*last_target_p
)->next
);
1306 *last_target_p
= malloc(sizeof(target_t
));
1308 /* allocate memory for each unique target type */
1309 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1310 *((*last_target_p
)->type
) = *target_types
[i
];
1312 if (strcmp(args
[1], "big") == 0)
1313 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1314 else if (strcmp(args
[1], "little") == 0)
1315 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1318 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1319 return ERROR_COMMAND_SYNTAX_ERROR
;
1322 if (strcmp(args
[2], "reset_halt") == 0)
1324 LOG_WARNING("reset_mode argument is obsolete.");
1325 return ERROR_COMMAND_SYNTAX_ERROR
;
1327 else if (strcmp(args
[2], "reset_run") == 0)
1329 LOG_WARNING("reset_mode argument is obsolete.");
1330 return ERROR_COMMAND_SYNTAX_ERROR
;
1332 else if (strcmp(args
[2], "reset_init") == 0)
1334 LOG_WARNING("reset_mode argument is obsolete.");
1335 return ERROR_COMMAND_SYNTAX_ERROR
;
1337 else if (strcmp(args
[2], "run_and_halt") == 0)
1339 LOG_WARNING("reset_mode argument is obsolete.");
1340 return ERROR_COMMAND_SYNTAX_ERROR
;
1342 else if (strcmp(args
[2], "run_and_init") == 0)
1344 LOG_WARNING("reset_mode argument is obsolete.");
1345 return ERROR_COMMAND_SYNTAX_ERROR
;
1349 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1354 (*last_target_p
)->working_area
= 0x0;
1355 (*last_target_p
)->working_area_size
= 0x0;
1356 (*last_target_p
)->working_areas
= NULL
;
1357 (*last_target_p
)->backup_working_area
= 0;
1359 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1360 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1361 (*last_target_p
)->reg_cache
= NULL
;
1362 (*last_target_p
)->breakpoints
= NULL
;
1363 (*last_target_p
)->watchpoints
= NULL
;
1364 (*last_target_p
)->next
= NULL
;
1365 (*last_target_p
)->arch_info
= NULL
;
1367 /* initialize trace information */
1368 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1369 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1370 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1371 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1372 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1373 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1374 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1375 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1377 (*last_target_p
)->dbgmsg
= NULL
;
1378 (*last_target_p
)->dbg_msg_enabled
= 0;
1380 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1388 /* no matching target found */
1391 LOG_ERROR("target '%s' not found", args
[0]);
1392 return ERROR_COMMAND_SYNTAX_ERROR
;
1398 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1400 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
1401 get_num_by_target(target
), name
,
1402 get_num_by_target(target
), name
);
1405 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1407 target_t
*target
= NULL
;
1409 if ((argc
< 4) || (argc
> 5))
1411 return ERROR_COMMAND_SYNTAX_ERROR
;
1414 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1417 return ERROR_COMMAND_SYNTAX_ERROR
;
1419 target_free_all_working_areas(target
);
1421 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1424 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1426 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1428 if (strcmp(args
[3], "backup") == 0)
1430 target
->backup_working_area
= 1;
1432 else if (strcmp(args
[3], "nobackup") == 0)
1434 target
->backup_working_area
= 0;
1438 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1439 return ERROR_COMMAND_SYNTAX_ERROR
;
1446 /* process target state changes */
1447 int handle_target(void *priv
)
1449 target_t
*target
= targets
;
1453 if (target_continous_poll
)
1455 /* polling may fail silently until the target has been examined */
1456 target_poll(target
);
1459 target
= target
->next
;
1465 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1474 target
= get_current_target(cmd_ctx
);
1476 /* list all available registers for the current target */
1479 reg_cache_t
*cache
= target
->reg_cache
;
1485 for (i
= 0; i
< cache
->num_regs
; i
++)
1487 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1488 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
);
1491 cache
= cache
->next
;
1497 /* access a single register by its ordinal number */
1498 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1500 int num
= strtoul(args
[0], NULL
, 0);
1501 reg_cache_t
*cache
= target
->reg_cache
;
1507 for (i
= 0; i
< cache
->num_regs
; i
++)
1511 reg
= &cache
->reg_list
[i
];
1517 cache
= cache
->next
;
1522 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1525 } else /* access a single register by its name */
1527 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1531 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1536 /* display a register */
1537 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1539 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1542 if (reg
->valid
== 0)
1544 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1545 if (arch_type
== NULL
)
1547 LOG_ERROR("BUG: encountered unregistered arch type");
1550 arch_type
->get(reg
);
1552 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1553 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1558 /* set register value */
1561 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1562 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1564 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1565 if (arch_type
== NULL
)
1567 LOG_ERROR("BUG: encountered unregistered arch type");
1571 arch_type
->set(reg
, buf
);
1573 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1574 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1582 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1588 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1590 target_t
*target
= get_current_target(cmd_ctx
);
1594 target_poll(target
);
1595 target_arch_state(target
);
1599 if (strcmp(args
[0], "on") == 0)
1601 target_continous_poll
= 1;
1603 else if (strcmp(args
[0], "off") == 0)
1605 target_continous_poll
= 0;
1609 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1617 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1625 ms
= strtoul(args
[0], &end
, 0) * 1000;
1628 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1632 target_t
*target
= get_current_target(cmd_ctx
);
1634 return target_wait_state(target
, TARGET_HALTED
, ms
);
1637 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1640 struct timeval timeout
, now
;
1642 gettimeofday(&timeout
, NULL
);
1643 timeval_add_time(&timeout
, 0, ms
* 1000);
1647 if ((retval
=target_poll(target
))!=ERROR_OK
)
1649 target_call_timer_callbacks_now();
1650 if (target
->state
== state
)
1657 LOG_USER("waiting for target %s...", target_state_strings
[state
]);
1660 gettimeofday(&now
, NULL
);
1661 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1663 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1671 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1674 target_t
*target
= get_current_target(cmd_ctx
);
1678 if ((retval
= target_halt(target
)) != ERROR_OK
)
1683 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1686 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1688 target_t
*target
= get_current_target(cmd_ctx
);
1690 LOG_USER("requesting target halt and executing a soft reset");
1692 target
->type
->soft_reset_halt(target
);
1697 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1699 enum target_reset_mode reset_mode
= RESET_RUN
;
1703 if (strcmp("run", args
[0]) == 0)
1704 reset_mode
= RESET_RUN
;
1705 else if (strcmp("halt", args
[0]) == 0)
1706 reset_mode
= RESET_HALT
;
1707 else if (strcmp("init", args
[0]) == 0)
1708 reset_mode
= RESET_INIT
;
1711 return ERROR_COMMAND_SYNTAX_ERROR
;
1715 /* reset *all* targets */
1716 target_process_reset(cmd_ctx
, reset_mode
);
1721 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1724 target_t
*target
= get_current_target(cmd_ctx
);
1726 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1729 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1731 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1734 return ERROR_COMMAND_SYNTAX_ERROR
;
1740 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1742 target_t
*target
= get_current_target(cmd_ctx
);
1747 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1750 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1755 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1757 const int line_bytecnt
= 32;
1770 target_t
*target
= get_current_target(cmd_ctx
);
1776 count
= strtoul(args
[1], NULL
, 0);
1778 address
= strtoul(args
[0], NULL
, 0);
1784 size
= 4; line_modulo
= line_bytecnt
/ 4;
1787 size
= 2; line_modulo
= line_bytecnt
/ 2;
1790 size
= 1; line_modulo
= line_bytecnt
/ 1;
1796 buffer
= calloc(count
, size
);
1797 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1798 if (retval
== ERROR_OK
)
1802 for (i
= 0; i
< count
; i
++)
1804 if (i
%line_modulo
== 0)
1805 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1810 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1813 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1816 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1820 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1822 command_print(cmd_ctx
, output
);
1833 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1840 target_t
*target
= get_current_target(cmd_ctx
);
1843 if ((argc
< 2) || (argc
> 3))
1844 return ERROR_COMMAND_SYNTAX_ERROR
;
1846 address
= strtoul(args
[0], NULL
, 0);
1847 value
= strtoul(args
[1], NULL
, 0);
1849 count
= strtoul(args
[2], NULL
, 0);
1855 target_buffer_set_u32(target
, value_buf
, value
);
1859 target_buffer_set_u16(target
, value_buf
, value
);
1863 value_buf
[0] = value
;
1866 return ERROR_COMMAND_SYNTAX_ERROR
;
1868 for (i
=0; i
<count
; i
++)
1874 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1877 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1880 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1885 if (retval
!=ERROR_OK
)
1895 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1901 u32 max_address
=0xffffffff;
1907 duration_t duration
;
1908 char *duration_text
;
1910 target_t
*target
= get_current_target(cmd_ctx
);
1912 if ((argc
< 1)||(argc
> 5))
1914 return ERROR_COMMAND_SYNTAX_ERROR
;
1917 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1920 image
.base_address_set
= 1;
1921 image
.base_address
= strtoul(args
[1], NULL
, 0);
1925 image
.base_address_set
= 0;
1929 image
.start_address_set
= 0;
1933 min_address
=strtoul(args
[3], NULL
, 0);
1937 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
1940 if (min_address
>max_address
)
1942 return ERROR_COMMAND_SYNTAX_ERROR
;
1946 duration_start_measure(&duration
);
1948 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1955 for (i
= 0; i
< image
.num_sections
; i
++)
1957 buffer
= malloc(image
.sections
[i
].size
);
1960 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1964 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1974 /* DANGER!!! beware of unsigned comparision here!!! */
1976 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
1977 (image
.sections
[i
].base_address
<max_address
))
1979 if (image
.sections
[i
].base_address
<min_address
)
1981 /* clip addresses below */
1982 offset
+=min_address
-image
.sections
[i
].base_address
;
1986 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
1988 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
1991 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
1996 image_size
+= length
;
1997 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2003 duration_stop_measure(&duration
, &duration_text
);
2004 if (retval
==ERROR_OK
)
2006 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2008 free(duration_text
);
2010 image_close(&image
);
2016 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2023 int retval
=ERROR_OK
;
2025 duration_t duration
;
2026 char *duration_text
;
2028 target_t
*target
= get_current_target(cmd_ctx
);
2032 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2036 address
= strtoul(args
[1], NULL
, 0);
2037 size
= strtoul(args
[2], NULL
, 0);
2039 if ((address
& 3) || (size
& 3))
2041 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2045 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2050 duration_start_measure(&duration
);
2055 u32 this_run_size
= (size
> 560) ? 560 : size
;
2057 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2058 if (retval
!= ERROR_OK
)
2063 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2064 if (retval
!= ERROR_OK
)
2069 size
-= this_run_size
;
2070 address
+= this_run_size
;
2073 fileio_close(&fileio
);
2075 duration_stop_measure(&duration
, &duration_text
);
2076 if (retval
==ERROR_OK
)
2078 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2080 free(duration_text
);
2085 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2093 u32 mem_checksum
= 0;
2097 duration_t duration
;
2098 char *duration_text
;
2100 target_t
*target
= get_current_target(cmd_ctx
);
2104 return ERROR_COMMAND_SYNTAX_ERROR
;
2109 LOG_ERROR("no target selected");
2113 duration_start_measure(&duration
);
2117 image
.base_address_set
= 1;
2118 image
.base_address
= strtoul(args
[1], NULL
, 0);
2122 image
.base_address_set
= 0;
2123 image
.base_address
= 0x0;
2126 image
.start_address_set
= 0;
2128 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2135 for (i
= 0; i
< image
.num_sections
; i
++)
2137 buffer
= malloc(image
.sections
[i
].size
);
2140 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2143 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2149 /* calculate checksum of image */
2150 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2152 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2153 if( retval
!= ERROR_OK
)
2159 if( checksum
!= mem_checksum
)
2161 /* failed crc checksum, fall back to a binary compare */
2164 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2166 data
= (u8
*)malloc(buf_cnt
);
2168 /* Can we use 32bit word accesses? */
2170 int count
= buf_cnt
;
2171 if ((count
% 4) == 0)
2176 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2177 if (retval
== ERROR_OK
)
2180 for (t
= 0; t
< buf_cnt
; t
++)
2182 if (data
[t
] != buffer
[t
])
2184 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
]);
2197 image_size
+= buf_cnt
;
2200 duration_stop_measure(&duration
, &duration_text
);
2201 if (retval
==ERROR_OK
)
2203 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2205 free(duration_text
);
2207 image_close(&image
);
2212 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2215 target_t
*target
= get_current_target(cmd_ctx
);
2219 breakpoint_t
*breakpoint
= target
->breakpoints
;
2223 if (breakpoint
->type
== BKPT_SOFT
)
2225 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2226 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2231 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2233 breakpoint
= breakpoint
->next
;
2241 length
= strtoul(args
[1], NULL
, 0);
2244 if (strcmp(args
[2], "hw") == 0)
2247 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2249 LOG_ERROR("Failure setting breakpoints");
2253 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2258 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2264 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2266 target_t
*target
= get_current_target(cmd_ctx
);
2269 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2274 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2276 target_t
*target
= get_current_target(cmd_ctx
);
2281 watchpoint_t
*watchpoint
= target
->watchpoints
;
2285 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
);
2286 watchpoint
= watchpoint
->next
;
2291 enum watchpoint_rw type
= WPT_ACCESS
;
2292 u32 data_value
= 0x0;
2293 u32 data_mask
= 0xffffffff;
2309 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2315 data_value
= strtoul(args
[3], NULL
, 0);
2319 data_mask
= strtoul(args
[4], NULL
, 0);
2322 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2323 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2325 LOG_ERROR("Failure setting breakpoints");
2330 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2336 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2338 target_t
*target
= get_current_target(cmd_ctx
);
2341 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2346 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2349 target_t
*target
= get_current_target(cmd_ctx
);
2355 return ERROR_COMMAND_SYNTAX_ERROR
;
2357 va
= strtoul(args
[0], NULL
, 0);
2359 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2360 if (retval
== ERROR_OK
)
2362 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2366 /* lower levels will have logged a detailed error which is
2367 * forwarded to telnet/GDB session.
2372 static void writeLong(FILE *f
, int l
)
2377 char c
=(l
>>(i
*8))&0xff;
2378 fwrite(&c
, 1, 1, f
);
2382 static void writeString(FILE *f
, char *s
)
2384 fwrite(s
, 1, strlen(s
), f
);
2389 // Dump a gmon.out histogram file.
2390 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2393 FILE *f
=fopen(filename
, "w");
2396 fwrite("gmon", 1, 4, f
);
2397 writeLong(f
, 0x00000001); // Version
2398 writeLong(f
, 0); // padding
2399 writeLong(f
, 0); // padding
2400 writeLong(f
, 0); // padding
2402 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2404 // figure out bucket size
2407 for (i
=0; i
<sampleNum
; i
++)
2419 int addressSpace
=(max
-min
+1);
2421 static int const maxBuckets
=256*1024; // maximum buckets.
2422 int length
=addressSpace
;
2423 if (length
> maxBuckets
)
2427 int *buckets
=malloc(sizeof(int)*length
);
2433 memset(buckets
, 0, sizeof(int)*length
);
2434 for (i
=0; i
<sampleNum
;i
++)
2436 u32 address
=samples
[i
];
2437 long long a
=address
-min
;
2438 long long b
=length
-1;
2439 long long c
=addressSpace
-1;
2440 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2444 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2445 writeLong(f
, min
); // low_pc
2446 writeLong(f
, max
); // high_pc
2447 writeLong(f
, length
); // # of samples
2448 writeLong(f
, 64000000); // 64MHz
2449 writeString(f
, "seconds");
2450 for (i
=0; i
<(15-strlen("seconds")); i
++)
2452 fwrite("", 1, 1, f
); // padding
2454 writeString(f
, "s");
2456 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2458 char *data
=malloc(2*length
);
2461 for (i
=0; i
<length
;i
++)
2470 data
[i
*2+1]=(val
>>8)&0xff;
2473 fwrite(data
, 1, length
*2, f
);
2483 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2484 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2486 target_t
*target
= get_current_target(cmd_ctx
);
2487 struct timeval timeout
, now
;
2489 gettimeofday(&timeout
, NULL
);
2492 return ERROR_COMMAND_SYNTAX_ERROR
;
2495 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2501 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2503 static const int maxSample
=10000;
2504 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2509 int retval
=ERROR_OK
;
2510 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2511 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2515 target_poll(target
);
2516 if (target
->state
== TARGET_HALTED
)
2518 u32 t
=*((u32
*)reg
->value
);
2519 samples
[numSamples
++]=t
;
2520 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2521 target_poll(target
);
2522 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2523 } else if (target
->state
== TARGET_RUNNING
)
2525 // We want to quickly sample the PC.
2526 target_halt(target
);
2529 command_print(cmd_ctx
, "Target not halted or running");
2533 if (retval
!=ERROR_OK
)
2538 gettimeofday(&now
, NULL
);
2539 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2541 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2542 target_poll(target
);
2543 if (target
->state
== TARGET_HALTED
)
2545 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2547 target_poll(target
);
2548 writeGmon(samples
, numSamples
, args
[1]);
2549 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2558 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2561 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2564 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2568 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2569 valObjPtr
= Jim_NewIntObj(interp
, val
);
2570 if (!nameObjPtr
|| !valObjPtr
)
2576 Jim_IncrRefCount(nameObjPtr
);
2577 Jim_IncrRefCount(valObjPtr
);
2578 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2579 Jim_DecrRefCount(interp
, nameObjPtr
);
2580 Jim_DecrRefCount(interp
, valObjPtr
);
2582 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2586 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2589 command_context_t
*context
;
2596 const char *varname
;
2598 int i
, n
, e
, retval
;
2600 /* argv[1] = name of array to receive the data
2601 * argv[2] = desired width
2602 * argv[3] = memory address
2603 * argv[4] = count of times to read
2606 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2609 varname
= Jim_GetString(argv
[1], &len
);
2610 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2612 e
= Jim_GetLong(interp
, argv
[2], &l
);
2618 e
= Jim_GetLong(interp
, argv
[3], &l
);
2623 e
= Jim_GetLong(interp
, argv
[4], &l
);
2639 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2640 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2644 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2645 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2648 if ((addr
+ (len
* width
)) < addr
) {
2649 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2650 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2653 /* absurd transfer size? */
2655 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2656 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2661 ((width
== 2) && ((addr
& 1) == 0)) ||
2662 ((width
== 4) && ((addr
& 3) == 0))) {
2666 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2667 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2668 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2672 context
= Jim_GetAssocData(interp
, "context");
2673 if (context
== NULL
)
2675 LOG_ERROR("mem2array: no command context");
2678 target
= get_current_target(context
);
2681 LOG_ERROR("mem2array: no current target");
2692 /* Slurp... in buffer size chunks */
2694 count
= len
; /* in objects.. */
2695 if (count
> (sizeof(buffer
)/width
)) {
2696 count
= (sizeof(buffer
)/width
);
2699 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2700 if (retval
!= ERROR_OK
) {
2702 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2703 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2704 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2708 v
= 0; /* shut up gcc */
2709 for (i
= 0 ;i
< count
;i
++, n
++) {
2712 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2715 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2718 v
= buffer
[i
] & 0x0ff;
2721 new_int_array_element(interp
, varname
, n
, v
);
2727 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2732 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2735 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2739 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2743 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2750 Jim_IncrRefCount(nameObjPtr
);
2751 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2752 Jim_DecrRefCount(interp
, nameObjPtr
);
2754 if (valObjPtr
== NULL
)
2757 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2758 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2763 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2766 command_context_t
*context
;
2773 const char *varname
;
2775 int i
, n
, e
, retval
;
2777 /* argv[1] = name of array to get the data
2778 * argv[2] = desired width
2779 * argv[3] = memory address
2780 * argv[4] = count to write
2783 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2786 varname
= Jim_GetString(argv
[1], &len
);
2787 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2789 e
= Jim_GetLong(interp
, argv
[2], &l
);
2795 e
= Jim_GetLong(interp
, argv
[3], &l
);
2800 e
= Jim_GetLong(interp
, argv
[4], &l
);
2816 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2817 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2821 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2822 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2825 if ((addr
+ (len
* width
)) < addr
) {
2826 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2827 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2830 /* absurd transfer size? */
2832 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2833 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2838 ((width
== 2) && ((addr
& 1) == 0)) ||
2839 ((width
== 4) && ((addr
& 3) == 0))) {
2843 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2844 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2845 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2849 context
= Jim_GetAssocData(interp
, "context");
2850 if (context
== NULL
)
2852 LOG_ERROR("array2mem: no command context");
2855 target
= get_current_target(context
);
2858 LOG_ERROR("array2mem: no current target");
2869 /* Slurp... in buffer size chunks */
2871 count
= len
; /* in objects.. */
2872 if (count
> (sizeof(buffer
)/width
)) {
2873 count
= (sizeof(buffer
)/width
);
2876 v
= 0; /* shut up gcc */
2877 for (i
= 0 ;i
< count
;i
++, n
++) {
2878 get_int_array_element(interp
, varname
, n
, &v
);
2881 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2884 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2887 buffer
[i
] = v
& 0x0ff;
2893 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2894 if (retval
!= ERROR_OK
) {
2896 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2897 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2898 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2904 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)