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(cmd_ctx
)) != 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 target
->type
->assert_reset(target
);
307 target
= target
->next
;
309 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
311 LOG_WARNING("JTAG communication failed asserting reset.");
315 /* request target halt if necessary, and schedule further action */
319 if (reset_mode
!=RESET_RUN
)
321 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
324 target
= target
->next
;
327 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
329 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
336 target
->type
->deassert_reset(target
);
337 /* We can fail to bring the target into the halted state */
339 if (target
->reset_halt
&&((target
->state
!= TARGET_HALTED
)))
341 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
342 target
->type
->halt(target
);
345 target
= target
->next
;
348 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
350 LOG_WARNING("JTAG communication failed while deasserting reset.");
354 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
356 /* If TRST was asserted we need to set up registers again */
357 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
361 LOG_DEBUG("Waiting for halted stated as appropriate");
363 if ((reset_mode
== RESET_HALT
) || (reset_mode
== RESET_INIT
))
368 /* Wait for reset to complete, maximum 5 seconds. */
369 if (((retval
=target_wait_state(target
, TARGET_HALTED
, 5000)))==ERROR_OK
)
371 if (reset_mode
== RESET_INIT
)
372 target_invoke_script(cmd_ctx
, target
, "post_reset");
374 target
= target
->next
;
378 /* We want any events to be processed before the prompt */
379 target_call_timer_callbacks_now();
384 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
390 static int default_mmu(struct target_s
*target
, int *enabled
)
396 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
398 target
->type
->examined
= 1;
403 /* Targets that correctly implement init+examine, i.e.
404 * no communication with target during init:
408 int target_examine(struct command_context_s
*cmd_ctx
)
410 int retval
= ERROR_OK
;
411 target_t
*target
= targets
;
414 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
416 target
= target
->next
;
421 static int target_write_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
->write_memory_imp(target
, address
, size
, count
, buffer
);
431 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
433 if (!target
->type
->examined
)
435 LOG_ERROR("Target not examined yet");
438 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
441 static int target_soft_reset_halt_imp(struct target_s
*target
)
443 if (!target
->type
->examined
)
445 LOG_ERROR("Target not examined yet");
448 return target
->type
->soft_reset_halt_imp(target
);
451 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
)
453 if (!target
->type
->examined
)
455 LOG_ERROR("Target not examined yet");
458 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
);
461 int target_init(struct command_context_s
*cmd_ctx
)
463 target_t
*target
= targets
;
467 target
->type
->examined
= 0;
468 if (target
->type
->examine
== NULL
)
470 target
->type
->examine
= default_examine
;
473 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
475 LOG_ERROR("target '%s' init failed", target
->type
->name
);
479 /* Set up default functions if none are provided by target */
480 if (target
->type
->virt2phys
== NULL
)
482 target
->type
->virt2phys
= default_virt2phys
;
484 target
->type
->virt2phys
= default_virt2phys
;
485 /* a non-invasive way(in terms of patches) to add some code that
486 * runs before the type->write/read_memory implementation
488 target
->type
->write_memory_imp
= target
->type
->write_memory
;
489 target
->type
->write_memory
= target_write_memory_imp
;
490 target
->type
->read_memory_imp
= target
->type
->read_memory
;
491 target
->type
->read_memory
= target_read_memory_imp
;
492 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
493 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
494 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
495 target
->type
->run_algorithm
= target_run_algorithm_imp
;
498 if (target
->type
->mmu
== NULL
)
500 target
->type
->mmu
= default_mmu
;
502 target
= target
->next
;
507 target_register_user_commands(cmd_ctx
);
508 target_register_timer_callback(handle_target
, 100, 1, NULL
);
514 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
516 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
518 if (callback
== NULL
)
520 return ERROR_INVALID_ARGUMENTS
;
525 while ((*callbacks_p
)->next
)
526 callbacks_p
= &((*callbacks_p
)->next
);
527 callbacks_p
= &((*callbacks_p
)->next
);
530 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
531 (*callbacks_p
)->callback
= callback
;
532 (*callbacks_p
)->priv
= priv
;
533 (*callbacks_p
)->next
= NULL
;
538 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
540 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
543 if (callback
== NULL
)
545 return ERROR_INVALID_ARGUMENTS
;
550 while ((*callbacks_p
)->next
)
551 callbacks_p
= &((*callbacks_p
)->next
);
552 callbacks_p
= &((*callbacks_p
)->next
);
555 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
556 (*callbacks_p
)->callback
= callback
;
557 (*callbacks_p
)->periodic
= periodic
;
558 (*callbacks_p
)->time_ms
= time_ms
;
560 gettimeofday(&now
, NULL
);
561 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
562 time_ms
-= (time_ms
% 1000);
563 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
564 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
566 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
567 (*callbacks_p
)->when
.tv_sec
+= 1;
570 (*callbacks_p
)->priv
= priv
;
571 (*callbacks_p
)->next
= NULL
;
576 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
578 target_event_callback_t
**p
= &target_event_callbacks
;
579 target_event_callback_t
*c
= target_event_callbacks
;
581 if (callback
== NULL
)
583 return ERROR_INVALID_ARGUMENTS
;
588 target_event_callback_t
*next
= c
->next
;
589 if ((c
->callback
== callback
) && (c
->priv
== priv
))
603 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
605 target_timer_callback_t
**p
= &target_timer_callbacks
;
606 target_timer_callback_t
*c
= target_timer_callbacks
;
608 if (callback
== NULL
)
610 return ERROR_INVALID_ARGUMENTS
;
615 target_timer_callback_t
*next
= c
->next
;
616 if ((c
->callback
== callback
) && (c
->priv
== priv
))
630 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
632 target_event_callback_t
*callback
= target_event_callbacks
;
633 target_event_callback_t
*next_callback
;
635 LOG_DEBUG("target event %i", event
);
639 next_callback
= callback
->next
;
640 callback
->callback(target
, event
, callback
->priv
);
641 callback
= next_callback
;
647 static int target_call_timer_callbacks_check_time(int checktime
)
649 target_timer_callback_t
*callback
= target_timer_callbacks
;
650 target_timer_callback_t
*next_callback
;
655 gettimeofday(&now
, NULL
);
659 next_callback
= callback
->next
;
661 if ((!checktime
&&callback
->periodic
)||
662 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
663 || (now
.tv_sec
> callback
->when
.tv_sec
)))
665 if(callback
->callback
!= NULL
)
667 callback
->callback(callback
->priv
);
668 if (callback
->periodic
)
670 int time_ms
= callback
->time_ms
;
671 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
672 time_ms
-= (time_ms
% 1000);
673 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
674 if (callback
->when
.tv_usec
> 1000000)
676 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
677 callback
->when
.tv_sec
+= 1;
681 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
685 callback
= next_callback
;
691 int target_call_timer_callbacks()
693 return target_call_timer_callbacks_check_time(1);
696 /* invoke periodic callbacks immediately */
697 int target_call_timer_callbacks_now()
699 return target_call_timer_callbacks(0);
702 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
704 working_area_t
*c
= target
->working_areas
;
705 working_area_t
*new_wa
= NULL
;
707 /* Reevaluate working area address based on MMU state*/
708 if (target
->working_areas
== NULL
)
712 retval
= target
->type
->mmu(target
, &enabled
);
713 if (retval
!= ERROR_OK
)
719 target
->working_area
= target
->working_area_virt
;
723 target
->working_area
= target
->working_area_phys
;
727 /* only allocate multiples of 4 byte */
730 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
731 size
= CEIL(size
, 4);
734 /* see if there's already a matching working area */
737 if ((c
->free
) && (c
->size
== size
))
745 /* if not, allocate a new one */
748 working_area_t
**p
= &target
->working_areas
;
749 u32 first_free
= target
->working_area
;
750 u32 free_size
= target
->working_area_size
;
752 LOG_DEBUG("allocating new working area");
754 c
= target
->working_areas
;
757 first_free
+= c
->size
;
758 free_size
-= c
->size
;
763 if (free_size
< size
)
765 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
766 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
769 new_wa
= malloc(sizeof(working_area_t
));
772 new_wa
->address
= first_free
;
774 if (target
->backup_working_area
)
776 new_wa
->backup
= malloc(new_wa
->size
);
777 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
781 new_wa
->backup
= NULL
;
784 /* put new entry in list */
788 /* mark as used, and return the new (reused) area */
798 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
803 if (restore
&&target
->backup_working_area
)
804 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
808 /* mark user pointer invalid */
815 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
817 return target_free_working_area_restore(target
, area
, 1);
820 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
822 working_area_t
*c
= target
->working_areas
;
826 working_area_t
*next
= c
->next
;
827 target_free_working_area_restore(target
, c
, restore
);
837 target
->working_areas
= NULL
;
842 int target_free_all_working_areas(struct target_s
*target
)
844 return target_free_all_working_areas_restore(target
, 1);
847 int target_register_commands(struct command_context_s
*cmd_ctx
)
849 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
850 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
851 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
852 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
853 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
856 /* script procedures */
857 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
858 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
862 int target_arch_state(struct target_s
*target
)
867 LOG_USER("No target has been configured");
871 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
873 if (target
->state
!=TARGET_HALTED
)
876 retval
=target
->type
->arch_state(target
);
880 /* Single aligned words are guaranteed to use 16 or 32 bit access
881 * mode respectively, otherwise data is handled as quickly as
884 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
887 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
889 if (!target
->type
->examined
)
891 LOG_ERROR("Target not examined yet");
895 if (address
+size
<address
)
897 /* GDB can request this when e.g. PC is 0xfffffffc*/
898 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
902 if (((address
% 2) == 0) && (size
== 2))
904 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
907 /* handle unaligned head bytes */
910 int unaligned
= 4 - (address
% 4);
912 if (unaligned
> size
)
915 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
919 address
+= unaligned
;
923 /* handle aligned words */
926 int aligned
= size
- (size
% 4);
928 /* use bulk writes above a certain limit. This may have to be changed */
931 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
936 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
945 /* handle tail writes of less than 4 bytes */
948 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
956 /* Single aligned words are guaranteed to use 16 or 32 bit access
957 * mode respectively, otherwise data is handled as quickly as
960 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
963 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
965 if (!target
->type
->examined
)
967 LOG_ERROR("Target not examined yet");
971 if (address
+size
<address
)
973 /* GDB can request this when e.g. PC is 0xfffffffc*/
974 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
978 if (((address
% 2) == 0) && (size
== 2))
980 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
983 /* handle unaligned head bytes */
986 int unaligned
= 4 - (address
% 4);
988 if (unaligned
> size
)
991 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
995 address
+= unaligned
;
999 /* handle aligned words */
1002 int aligned
= size
- (size
% 4);
1004 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1012 /* handle tail writes of less than 4 bytes */
1015 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1022 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1028 if (!target
->type
->examined
)
1030 LOG_ERROR("Target not examined yet");
1034 if ((retval
= target
->type
->checksum_memory(target
, address
,
1035 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1037 buffer
= malloc(size
);
1040 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1041 return ERROR_INVALID_ARGUMENTS
;
1043 retval
= target_read_buffer(target
, address
, size
, buffer
);
1044 if (retval
!= ERROR_OK
)
1050 /* convert to target endianess */
1051 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1054 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1055 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1058 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1067 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1070 if (!target
->type
->examined
)
1072 LOG_ERROR("Target not examined yet");
1076 if (target
->type
->blank_check_memory
== 0)
1077 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1079 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1084 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1087 if (!target
->type
->examined
)
1089 LOG_ERROR("Target not examined yet");
1093 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1095 if (retval
== ERROR_OK
)
1097 *value
= target_buffer_get_u32(target
, value_buf
);
1098 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1103 LOG_DEBUG("address: 0x%8.8x failed", address
);
1109 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1112 if (!target
->type
->examined
)
1114 LOG_ERROR("Target not examined yet");
1118 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1120 if (retval
== ERROR_OK
)
1122 *value
= target_buffer_get_u16(target
, value_buf
);
1123 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1128 LOG_DEBUG("address: 0x%8.8x failed", address
);
1134 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1136 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1137 if (!target
->type
->examined
)
1139 LOG_ERROR("Target not examined yet");
1143 if (retval
== ERROR_OK
)
1145 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1150 LOG_DEBUG("address: 0x%8.8x failed", address
);
1156 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1160 if (!target
->type
->examined
)
1162 LOG_ERROR("Target not examined yet");
1166 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1168 target_buffer_set_u32(target
, value_buf
, value
);
1169 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1171 LOG_DEBUG("failed: %i", retval
);
1177 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1181 if (!target
->type
->examined
)
1183 LOG_ERROR("Target not examined yet");
1187 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1189 target_buffer_set_u16(target
, value_buf
, value
);
1190 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1192 LOG_DEBUG("failed: %i", retval
);
1198 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1201 if (!target
->type
->examined
)
1203 LOG_ERROR("Target not examined yet");
1207 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1209 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1211 LOG_DEBUG("failed: %i", retval
);
1217 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1219 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1220 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1221 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1222 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1223 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1224 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1225 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init]");
1226 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1228 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1229 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1230 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1232 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1233 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1234 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1236 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1237 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1238 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1239 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1241 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]");
1242 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1243 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1245 target_request_register_commands(cmd_ctx
);
1246 trace_register_commands(cmd_ctx
);
1251 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1253 target_t
*target
= targets
;
1258 int num
= strtoul(args
[0], NULL
, 0);
1263 target
= target
->next
;
1267 cmd_ctx
->current_target
= num
;
1269 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1276 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1277 target
= target
->next
;
1283 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1290 return ERROR_COMMAND_SYNTAX_ERROR
;
1293 /* search for the specified target */
1294 if (args
[0] && (args
[0][0] != 0))
1296 for (i
= 0; target_types
[i
]; i
++)
1298 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1300 target_t
**last_target_p
= &targets
;
1302 /* register target specific commands */
1303 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1305 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1311 while ((*last_target_p
)->next
)
1312 last_target_p
= &((*last_target_p
)->next
);
1313 last_target_p
= &((*last_target_p
)->next
);
1316 *last_target_p
= malloc(sizeof(target_t
));
1318 /* allocate memory for each unique target type */
1319 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1320 *((*last_target_p
)->type
) = *target_types
[i
];
1322 if (strcmp(args
[1], "big") == 0)
1323 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1324 else if (strcmp(args
[1], "little") == 0)
1325 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1328 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1329 return ERROR_COMMAND_SYNTAX_ERROR
;
1332 if (strcmp(args
[2], "reset_halt") == 0)
1334 LOG_WARNING("reset_mode argument is obsolete.");
1335 return ERROR_COMMAND_SYNTAX_ERROR
;
1337 else if (strcmp(args
[2], "reset_run") == 0)
1339 LOG_WARNING("reset_mode argument is obsolete.");
1340 return ERROR_COMMAND_SYNTAX_ERROR
;
1342 else if (strcmp(args
[2], "reset_init") == 0)
1344 LOG_WARNING("reset_mode argument is obsolete.");
1345 return ERROR_COMMAND_SYNTAX_ERROR
;
1347 else if (strcmp(args
[2], "run_and_halt") == 0)
1349 LOG_WARNING("reset_mode argument is obsolete.");
1350 return ERROR_COMMAND_SYNTAX_ERROR
;
1352 else if (strcmp(args
[2], "run_and_init") == 0)
1354 LOG_WARNING("reset_mode argument is obsolete.");
1355 return ERROR_COMMAND_SYNTAX_ERROR
;
1359 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1364 (*last_target_p
)->working_area
= 0x0;
1365 (*last_target_p
)->working_area_size
= 0x0;
1366 (*last_target_p
)->working_areas
= NULL
;
1367 (*last_target_p
)->backup_working_area
= 0;
1369 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1370 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1371 (*last_target_p
)->reg_cache
= NULL
;
1372 (*last_target_p
)->breakpoints
= NULL
;
1373 (*last_target_p
)->watchpoints
= NULL
;
1374 (*last_target_p
)->next
= NULL
;
1375 (*last_target_p
)->arch_info
= NULL
;
1377 /* initialize trace information */
1378 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1379 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1380 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1381 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1382 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1383 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1384 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1385 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1387 (*last_target_p
)->dbgmsg
= NULL
;
1388 (*last_target_p
)->dbg_msg_enabled
= 0;
1390 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1398 /* no matching target found */
1401 LOG_ERROR("target '%s' not found", args
[0]);
1402 return ERROR_COMMAND_SYNTAX_ERROR
;
1408 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1410 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
1411 get_num_by_target(target
), name
,
1412 get_num_by_target(target
), name
);
1415 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1417 target_t
*target
= NULL
;
1419 if ((argc
< 4) || (argc
> 5))
1421 return ERROR_COMMAND_SYNTAX_ERROR
;
1424 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1427 return ERROR_COMMAND_SYNTAX_ERROR
;
1429 target_free_all_working_areas(target
);
1431 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1434 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1436 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1438 if (strcmp(args
[3], "backup") == 0)
1440 target
->backup_working_area
= 1;
1442 else if (strcmp(args
[3], "nobackup") == 0)
1444 target
->backup_working_area
= 0;
1448 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1449 return ERROR_COMMAND_SYNTAX_ERROR
;
1456 /* process target state changes */
1457 int handle_target(void *priv
)
1459 target_t
*target
= targets
;
1463 if (target_continous_poll
)
1465 /* polling may fail silently until the target has been examined */
1466 target_poll(target
);
1469 target
= target
->next
;
1475 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1484 target
= get_current_target(cmd_ctx
);
1486 /* list all available registers for the current target */
1489 reg_cache_t
*cache
= target
->reg_cache
;
1495 for (i
= 0; i
< cache
->num_regs
; i
++)
1497 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1498 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
);
1501 cache
= cache
->next
;
1507 /* access a single register by its ordinal number */
1508 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1510 int num
= strtoul(args
[0], NULL
, 0);
1511 reg_cache_t
*cache
= target
->reg_cache
;
1517 for (i
= 0; i
< cache
->num_regs
; i
++)
1521 reg
= &cache
->reg_list
[i
];
1527 cache
= cache
->next
;
1532 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1535 } else /* access a single register by its name */
1537 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1541 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1546 /* display a register */
1547 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1549 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1552 if (reg
->valid
== 0)
1554 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1555 if (arch_type
== NULL
)
1557 LOG_ERROR("BUG: encountered unregistered arch type");
1560 arch_type
->get(reg
);
1562 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1563 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1568 /* set register value */
1571 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1572 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1574 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1575 if (arch_type
== NULL
)
1577 LOG_ERROR("BUG: encountered unregistered arch type");
1581 arch_type
->set(reg
, buf
);
1583 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1584 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1592 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1598 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1600 target_t
*target
= get_current_target(cmd_ctx
);
1604 target_poll(target
);
1605 target_arch_state(target
);
1609 if (strcmp(args
[0], "on") == 0)
1611 target_continous_poll
= 1;
1613 else if (strcmp(args
[0], "off") == 0)
1615 target_continous_poll
= 0;
1619 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1627 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1635 ms
= strtoul(args
[0], &end
, 0) * 1000;
1638 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1642 target_t
*target
= get_current_target(cmd_ctx
);
1644 return target_wait_state(target
, TARGET_HALTED
, ms
);
1647 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1650 struct timeval timeout
, now
;
1652 gettimeofday(&timeout
, NULL
);
1653 timeval_add_time(&timeout
, 0, ms
* 1000);
1657 if ((retval
=target_poll(target
))!=ERROR_OK
)
1659 target_call_timer_callbacks_now();
1660 if (target
->state
== state
)
1667 LOG_USER("waiting for target %s...", target_state_strings
[state
]);
1670 gettimeofday(&now
, NULL
);
1671 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1673 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1681 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1684 target_t
*target
= get_current_target(cmd_ctx
);
1688 if ((retval
= target_halt(target
)) != ERROR_OK
)
1693 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1696 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1698 target_t
*target
= get_current_target(cmd_ctx
);
1700 LOG_USER("requesting target halt and executing a soft reset");
1702 target
->type
->soft_reset_halt(target
);
1707 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1709 enum target_reset_mode reset_mode
= RESET_RUN
;
1713 if (strcmp("run", args
[0]) == 0)
1714 reset_mode
= RESET_RUN
;
1715 else if (strcmp("halt", args
[0]) == 0)
1716 reset_mode
= RESET_HALT
;
1717 else if (strcmp("init", args
[0]) == 0)
1718 reset_mode
= RESET_INIT
;
1721 return ERROR_COMMAND_SYNTAX_ERROR
;
1725 /* reset *all* targets */
1726 target_process_reset(cmd_ctx
, reset_mode
);
1731 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1734 target_t
*target
= get_current_target(cmd_ctx
);
1736 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1739 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1741 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1744 return ERROR_COMMAND_SYNTAX_ERROR
;
1750 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1752 target_t
*target
= get_current_target(cmd_ctx
);
1757 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1760 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1765 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1767 const int line_bytecnt
= 32;
1780 target_t
*target
= get_current_target(cmd_ctx
);
1786 count
= strtoul(args
[1], NULL
, 0);
1788 address
= strtoul(args
[0], NULL
, 0);
1794 size
= 4; line_modulo
= line_bytecnt
/ 4;
1797 size
= 2; line_modulo
= line_bytecnt
/ 2;
1800 size
= 1; line_modulo
= line_bytecnt
/ 1;
1806 buffer
= calloc(count
, size
);
1807 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1808 if (retval
== ERROR_OK
)
1812 for (i
= 0; i
< count
; i
++)
1814 if (i
%line_modulo
== 0)
1815 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1820 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1823 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1826 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1830 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1832 command_print(cmd_ctx
, output
);
1843 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1850 target_t
*target
= get_current_target(cmd_ctx
);
1853 if ((argc
< 2) || (argc
> 3))
1854 return ERROR_COMMAND_SYNTAX_ERROR
;
1856 address
= strtoul(args
[0], NULL
, 0);
1857 value
= strtoul(args
[1], NULL
, 0);
1859 count
= strtoul(args
[2], NULL
, 0);
1865 target_buffer_set_u32(target
, value_buf
, value
);
1869 target_buffer_set_u16(target
, value_buf
, value
);
1873 value_buf
[0] = value
;
1876 return ERROR_COMMAND_SYNTAX_ERROR
;
1878 for (i
=0; i
<count
; i
++)
1884 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1887 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1890 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1895 if (retval
!=ERROR_OK
)
1905 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1911 u32 max_address
=0xffffffff;
1917 duration_t duration
;
1918 char *duration_text
;
1920 target_t
*target
= get_current_target(cmd_ctx
);
1922 if ((argc
< 1)||(argc
> 5))
1924 return ERROR_COMMAND_SYNTAX_ERROR
;
1927 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1930 image
.base_address_set
= 1;
1931 image
.base_address
= strtoul(args
[1], NULL
, 0);
1935 image
.base_address_set
= 0;
1939 image
.start_address_set
= 0;
1943 min_address
=strtoul(args
[3], NULL
, 0);
1947 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
1950 if (min_address
>max_address
)
1952 return ERROR_COMMAND_SYNTAX_ERROR
;
1956 duration_start_measure(&duration
);
1958 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1965 for (i
= 0; i
< image
.num_sections
; i
++)
1967 buffer
= malloc(image
.sections
[i
].size
);
1970 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1974 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1984 /* DANGER!!! beware of unsigned comparision here!!! */
1986 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
1987 (image
.sections
[i
].base_address
<max_address
))
1989 if (image
.sections
[i
].base_address
<min_address
)
1991 /* clip addresses below */
1992 offset
+=min_address
-image
.sections
[i
].base_address
;
1996 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
1998 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2001 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2006 image_size
+= length
;
2007 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2013 duration_stop_measure(&duration
, &duration_text
);
2014 if (retval
==ERROR_OK
)
2016 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2018 free(duration_text
);
2020 image_close(&image
);
2026 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2033 int retval
=ERROR_OK
;
2035 duration_t duration
;
2036 char *duration_text
;
2038 target_t
*target
= get_current_target(cmd_ctx
);
2042 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2046 address
= strtoul(args
[1], NULL
, 0);
2047 size
= strtoul(args
[2], NULL
, 0);
2049 if ((address
& 3) || (size
& 3))
2051 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2055 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2060 duration_start_measure(&duration
);
2065 u32 this_run_size
= (size
> 560) ? 560 : size
;
2067 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2068 if (retval
!= ERROR_OK
)
2073 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2074 if (retval
!= ERROR_OK
)
2079 size
-= this_run_size
;
2080 address
+= this_run_size
;
2083 fileio_close(&fileio
);
2085 duration_stop_measure(&duration
, &duration_text
);
2086 if (retval
==ERROR_OK
)
2088 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2090 free(duration_text
);
2095 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2103 u32 mem_checksum
= 0;
2107 duration_t duration
;
2108 char *duration_text
;
2110 target_t
*target
= get_current_target(cmd_ctx
);
2114 return ERROR_COMMAND_SYNTAX_ERROR
;
2119 LOG_ERROR("no target selected");
2123 duration_start_measure(&duration
);
2127 image
.base_address_set
= 1;
2128 image
.base_address
= strtoul(args
[1], NULL
, 0);
2132 image
.base_address_set
= 0;
2133 image
.base_address
= 0x0;
2136 image
.start_address_set
= 0;
2138 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2145 for (i
= 0; i
< image
.num_sections
; i
++)
2147 buffer
= malloc(image
.sections
[i
].size
);
2150 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2153 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2159 /* calculate checksum of image */
2160 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2162 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2163 if( retval
!= ERROR_OK
)
2169 if( checksum
!= mem_checksum
)
2171 /* failed crc checksum, fall back to a binary compare */
2174 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2176 data
= (u8
*)malloc(buf_cnt
);
2178 /* Can we use 32bit word accesses? */
2180 int count
= buf_cnt
;
2181 if ((count
% 4) == 0)
2186 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2187 if (retval
== ERROR_OK
)
2190 for (t
= 0; t
< buf_cnt
; t
++)
2192 if (data
[t
] != buffer
[t
])
2194 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
]);
2207 image_size
+= buf_cnt
;
2210 duration_stop_measure(&duration
, &duration_text
);
2211 if (retval
==ERROR_OK
)
2213 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2215 free(duration_text
);
2217 image_close(&image
);
2222 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2225 target_t
*target
= get_current_target(cmd_ctx
);
2229 breakpoint_t
*breakpoint
= target
->breakpoints
;
2233 if (breakpoint
->type
== BKPT_SOFT
)
2235 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2236 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2241 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2243 breakpoint
= breakpoint
->next
;
2251 length
= strtoul(args
[1], NULL
, 0);
2254 if (strcmp(args
[2], "hw") == 0)
2257 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2259 LOG_ERROR("Failure setting breakpoints");
2263 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2268 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2274 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2276 target_t
*target
= get_current_target(cmd_ctx
);
2279 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2284 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2286 target_t
*target
= get_current_target(cmd_ctx
);
2291 watchpoint_t
*watchpoint
= target
->watchpoints
;
2295 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
);
2296 watchpoint
= watchpoint
->next
;
2301 enum watchpoint_rw type
= WPT_ACCESS
;
2302 u32 data_value
= 0x0;
2303 u32 data_mask
= 0xffffffff;
2319 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2325 data_value
= strtoul(args
[3], NULL
, 0);
2329 data_mask
= strtoul(args
[4], NULL
, 0);
2332 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2333 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2335 LOG_ERROR("Failure setting breakpoints");
2340 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2346 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2348 target_t
*target
= get_current_target(cmd_ctx
);
2351 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2356 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2359 target_t
*target
= get_current_target(cmd_ctx
);
2365 return ERROR_COMMAND_SYNTAX_ERROR
;
2367 va
= strtoul(args
[0], NULL
, 0);
2369 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2370 if (retval
== ERROR_OK
)
2372 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2376 /* lower levels will have logged a detailed error which is
2377 * forwarded to telnet/GDB session.
2382 static void writeLong(FILE *f
, int l
)
2387 char c
=(l
>>(i
*8))&0xff;
2388 fwrite(&c
, 1, 1, f
);
2392 static void writeString(FILE *f
, char *s
)
2394 fwrite(s
, 1, strlen(s
), f
);
2399 // Dump a gmon.out histogram file.
2400 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2403 FILE *f
=fopen(filename
, "w");
2406 fwrite("gmon", 1, 4, f
);
2407 writeLong(f
, 0x00000001); // Version
2408 writeLong(f
, 0); // padding
2409 writeLong(f
, 0); // padding
2410 writeLong(f
, 0); // padding
2412 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2414 // figure out bucket size
2417 for (i
=0; i
<sampleNum
; i
++)
2429 int addressSpace
=(max
-min
+1);
2431 static int const maxBuckets
=256*1024; // maximum buckets.
2432 int length
=addressSpace
;
2433 if (length
> maxBuckets
)
2437 int *buckets
=malloc(sizeof(int)*length
);
2443 memset(buckets
, 0, sizeof(int)*length
);
2444 for (i
=0; i
<sampleNum
;i
++)
2446 u32 address
=samples
[i
];
2447 long long a
=address
-min
;
2448 long long b
=length
-1;
2449 long long c
=addressSpace
-1;
2450 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2454 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2455 writeLong(f
, min
); // low_pc
2456 writeLong(f
, max
); // high_pc
2457 writeLong(f
, length
); // # of samples
2458 writeLong(f
, 64000000); // 64MHz
2459 writeString(f
, "seconds");
2460 for (i
=0; i
<(15-strlen("seconds")); i
++)
2462 fwrite("", 1, 1, f
); // padding
2464 writeString(f
, "s");
2466 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2468 char *data
=malloc(2*length
);
2471 for (i
=0; i
<length
;i
++)
2480 data
[i
*2+1]=(val
>>8)&0xff;
2483 fwrite(data
, 1, length
*2, f
);
2493 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2494 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2496 target_t
*target
= get_current_target(cmd_ctx
);
2497 struct timeval timeout
, now
;
2499 gettimeofday(&timeout
, NULL
);
2502 return ERROR_COMMAND_SYNTAX_ERROR
;
2505 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2511 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2513 static const int maxSample
=10000;
2514 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2519 int retval
=ERROR_OK
;
2520 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2521 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2525 target_poll(target
);
2526 if (target
->state
== TARGET_HALTED
)
2528 u32 t
=*((u32
*)reg
->value
);
2529 samples
[numSamples
++]=t
;
2530 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2531 target_poll(target
);
2532 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2533 } else if (target
->state
== TARGET_RUNNING
)
2535 // We want to quickly sample the PC.
2536 target_halt(target
);
2539 command_print(cmd_ctx
, "Target not halted or running");
2543 if (retval
!=ERROR_OK
)
2548 gettimeofday(&now
, NULL
);
2549 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2551 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2552 target_poll(target
);
2553 if (target
->state
== TARGET_HALTED
)
2555 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2557 target_poll(target
);
2558 writeGmon(samples
, numSamples
, args
[1]);
2559 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2568 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2571 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2574 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2578 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2579 valObjPtr
= Jim_NewIntObj(interp
, val
);
2580 if (!nameObjPtr
|| !valObjPtr
)
2586 Jim_IncrRefCount(nameObjPtr
);
2587 Jim_IncrRefCount(valObjPtr
);
2588 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2589 Jim_DecrRefCount(interp
, nameObjPtr
);
2590 Jim_DecrRefCount(interp
, valObjPtr
);
2592 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2596 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2599 command_context_t
*context
;
2606 const char *varname
;
2608 int i
, n
, e
, retval
;
2610 /* argv[1] = name of array to receive the data
2611 * argv[2] = desired width
2612 * argv[3] = memory address
2613 * argv[4] = count of times to read
2616 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2619 varname
= Jim_GetString(argv
[1], &len
);
2620 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2622 e
= Jim_GetLong(interp
, argv
[2], &l
);
2628 e
= Jim_GetLong(interp
, argv
[3], &l
);
2633 e
= Jim_GetLong(interp
, argv
[4], &l
);
2649 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2650 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2654 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2655 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2658 if ((addr
+ (len
* width
)) < addr
) {
2659 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2660 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2663 /* absurd transfer size? */
2665 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2666 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2671 ((width
== 2) && ((addr
& 1) == 0)) ||
2672 ((width
== 4) && ((addr
& 3) == 0))) {
2676 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2677 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2678 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2682 context
= Jim_GetAssocData(interp
, "context");
2683 if (context
== NULL
)
2685 LOG_ERROR("mem2array: no command context");
2688 target
= get_current_target(context
);
2691 LOG_ERROR("mem2array: no current target");
2702 /* Slurp... in buffer size chunks */
2704 count
= len
; /* in objects.. */
2705 if (count
> (sizeof(buffer
)/width
)) {
2706 count
= (sizeof(buffer
)/width
);
2709 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2710 if (retval
!= ERROR_OK
) {
2712 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2713 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2714 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2718 v
= 0; /* shut up gcc */
2719 for (i
= 0 ;i
< count
;i
++, n
++) {
2722 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2725 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2728 v
= buffer
[i
] & 0x0ff;
2731 new_int_array_element(interp
, varname
, n
, v
);
2737 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2742 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2745 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2749 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2753 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2760 Jim_IncrRefCount(nameObjPtr
);
2761 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2762 Jim_DecrRefCount(interp
, nameObjPtr
);
2764 if (valObjPtr
== NULL
)
2767 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2768 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2773 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2776 command_context_t
*context
;
2783 const char *varname
;
2785 int i
, n
, e
, retval
;
2787 /* argv[1] = name of array to get the data
2788 * argv[2] = desired width
2789 * argv[3] = memory address
2790 * argv[4] = count to write
2793 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2796 varname
= Jim_GetString(argv
[1], &len
);
2797 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2799 e
= Jim_GetLong(interp
, argv
[2], &l
);
2805 e
= Jim_GetLong(interp
, argv
[3], &l
);
2810 e
= Jim_GetLong(interp
, argv
[4], &l
);
2826 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2827 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2831 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2832 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2835 if ((addr
+ (len
* width
)) < addr
) {
2836 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2837 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2840 /* absurd transfer size? */
2842 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2843 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2848 ((width
== 2) && ((addr
& 1) == 0)) ||
2849 ((width
== 4) && ((addr
& 3) == 0))) {
2853 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2854 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2855 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2859 context
= Jim_GetAssocData(interp
, "context");
2860 if (context
== NULL
)
2862 LOG_ERROR("array2mem: no command context");
2865 target
= get_current_target(context
);
2868 LOG_ERROR("array2mem: no current target");
2879 /* Slurp... in buffer size chunks */
2881 count
= len
; /* in objects.. */
2882 if (count
> (sizeof(buffer
)/width
)) {
2883 count
= (sizeof(buffer
)/width
);
2886 v
= 0; /* shut up gcc */
2887 for (i
= 0 ;i
< count
;i
++, n
++) {
2888 get_int_array_element(interp
, varname
, n
, &v
);
2891 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2894 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2897 buffer
[i
] = v
& 0x0ff;
2903 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2904 if (retval
!= ERROR_OK
) {
2906 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2907 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2908 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2914 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)