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
));