1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "target_request.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
37 #include <sys/types.h>
45 #include <time_support.h>
50 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
52 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
78 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
82 extern target_type_t arm7tdmi_target
;
83 extern target_type_t arm720t_target
;
84 extern target_type_t arm9tdmi_target
;
85 extern target_type_t arm920t_target
;
86 extern target_type_t arm966e_target
;
87 extern target_type_t arm926ejs_target
;
88 extern target_type_t feroceon_target
;
89 extern target_type_t xscale_target
;
90 extern target_type_t cortexm3_target
;
91 extern target_type_t arm11_target
;
93 target_type_t
*target_types
[] =
108 target_t
*targets
= NULL
;
109 target_event_callback_t
*target_event_callbacks
= NULL
;
110 target_timer_callback_t
*target_timer_callbacks
= NULL
;
112 char *target_state_strings
[] =
121 char *target_debug_reason_strings
[] =
123 "debug request", "breakpoint", "watchpoint",
124 "watchpoint and breakpoint", "single step",
125 "target not halted", "undefined"
128 char *target_endianess_strings
[] =
134 static int target_continous_poll
= 1;
136 /* read a u32 from a buffer in target memory endianness */
137 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
139 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
140 return le_to_h_u32(buffer
);
142 return be_to_h_u32(buffer
);
145 /* read a u16 from a buffer in target memory endianness */
146 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
148 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
149 return le_to_h_u16(buffer
);
151 return be_to_h_u16(buffer
);
154 /* write a u32 to a buffer in target memory endianness */
155 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
157 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
158 h_u32_to_le(buffer
, value
);
160 h_u32_to_be(buffer
, value
);
163 /* write a u16 to a buffer in target memory endianness */
164 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
166 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
167 h_u16_to_le(buffer
, value
);
169 h_u16_to_be(buffer
, value
);
172 /* returns a pointer to the n-th configured target */
173 target_t
* get_target_by_num(int num
)
175 target_t
*target
= targets
;
182 target
= target
->next
;
189 int get_num_by_target(target_t
*query_target
)
191 target_t
*target
= targets
;
196 if (target
== query_target
)
198 target
= target
->next
;
205 target_t
* get_current_target(command_context_t
*cmd_ctx
)
207 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
211 LOG_ERROR("BUG: current_target out of bounds");
218 /* Process target initialization, when target entered debug out of reset
219 * the handler is unregistered at the end of this function, so it's only called once
221 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
223 struct command_context_s
*cmd_ctx
= priv
;
225 if (event
== TARGET_EVENT_HALTED
)
227 target_unregister_event_callback(target_init_handler
, priv
);
228 target_invoke_script(cmd_ctx
, target
, "post_reset");
229 jtag_execute_queue();
235 int target_run_and_halt_handler(void *priv
)
237 target_t
*target
= priv
;
244 int target_poll(struct target_s
*target
)
246 /* We can't poll until after examine */
247 if (!target
->type
->examined
)
249 /* Fail silently lest we pollute the log */
252 return target
->type
->poll(target
);
255 int target_halt(struct target_s
*target
)
257 /* We can't poll until after examine */
258 if (!target
->type
->examined
)
260 LOG_ERROR("Target not examined yet");
263 return target
->type
->halt(target
);
266 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
270 /* We can't poll until after examine */
271 if (!target
->type
->examined
)
273 LOG_ERROR("Target not examined yet");
277 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
278 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
281 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
287 int target_process_reset(struct command_context_s
*cmd_ctx
, enum target_reset_mode reset_mode
)
289 int retval
= ERROR_OK
;
291 struct timeval timeout
, now
;
296 target_invoke_script(cmd_ctx
, target
, "pre_reset");
297 target
= target
->next
;
300 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
303 keep_alive(); /* we might be running on a very slow JTAG clk */
305 /* First time this is executed after launching OpenOCD, it will read out
306 * the type of CPU, etc. and init Embedded ICE registers in host
309 * It will also set up ICE registers in the target.
311 * However, if we assert TRST later, we need to set up the registers again.
313 * For the "reset halt/init" case we must only set up the registers here.
315 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
318 keep_alive(); /* we might be running on a very slow JTAG clk */
323 /* we have no idea what state the target is in, so we
324 * have to drop working areas
326 target_free_all_working_areas_restore(target
, 0);
327 target
->reset_halt
=((reset_mode
==RESET_HALT
)||(reset_mode
==RESET_INIT
));
328 target
->type
->assert_reset(target
);
329 target
= target
->next
;
331 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
333 LOG_WARNING("JTAG communication failed asserting reset.");
337 /* request target halt if necessary, and schedule further action */
344 /* nothing to do if target just wants to be run */
346 case RESET_RUN_AND_HALT
:
348 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
350 case RESET_RUN_AND_INIT
:
352 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
353 target_register_event_callback(target_init_handler
, cmd_ctx
);
356 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
360 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
362 target_register_event_callback(target_init_handler
, cmd_ctx
);
365 LOG_ERROR("BUG: unknown target->reset_mode");
367 target
= target
->next
;
370 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
372 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
379 target
->type
->deassert_reset(target
);
380 /* We can fail to bring the target into the halted state */
382 if (target
->reset_halt
&&((target
->state
!= TARGET_HALTED
)))
384 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
385 target
->type
->halt(target
);
388 target
= target
->next
;
391 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
393 LOG_WARNING("JTAG communication failed while deasserting reset.");
397 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
399 /* If TRST was asserted we need to set up registers again */
400 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
404 LOG_DEBUG("Waiting for halted stated as approperiate");
406 /* Wait for reset to complete, maximum 5 seconds. */
407 gettimeofday(&timeout
, NULL
);
408 timeval_add_time(&timeout
, 5, 0);
411 gettimeofday(&now
, NULL
);
413 target_call_timer_callbacks_now();
418 LOG_DEBUG("Polling target");
420 if ((reset_mode
== RESET_RUN_AND_INIT
) ||
421 (reset_mode
== RESET_RUN_AND_HALT
) ||
422 (reset_mode
== RESET_HALT
) ||
423 (reset_mode
== RESET_INIT
))
425 if (target
->state
!= TARGET_HALTED
)
427 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
429 LOG_USER("Timed out waiting for halt after reset");
432 /* this will send alive messages on e.g. GDB remote protocol. */
434 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
438 target
= target
->next
;
440 /* All targets we're waiting for are halted */
448 /* We want any events to be processed before the prompt */
449 target_call_timer_callbacks_now();
451 /* if we timed out we need to unregister these handlers */
455 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
456 target
= target
->next
;
458 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
463 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
469 static int default_mmu(struct target_s
*target
, int *enabled
)
475 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
477 target
->type
->examined
= 1;
482 /* Targets that correctly implement init+examine, i.e.
483 * no communication with target during init:
487 int target_examine(struct command_context_s
*cmd_ctx
)
489 int retval
= ERROR_OK
;
490 target_t
*target
= targets
;
493 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
495 target
= target
->next
;
500 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
502 if (!target
->type
->examined
)
504 LOG_ERROR("Target not examined yet");
507 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
510 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
512 if (!target
->type
->examined
)
514 LOG_ERROR("Target not examined yet");
517 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
520 static int target_soft_reset_halt_imp(struct target_s
*target
)
522 if (!target
->type
->examined
)
524 LOG_ERROR("Target not examined yet");
527 return target
->type
->soft_reset_halt_imp(target
);
530 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
)
532 if (!target
->type
->examined
)
534 LOG_ERROR("Target not examined yet");
537 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
);
540 int target_init(struct command_context_s
*cmd_ctx
)
542 target_t
*target
= targets
;
546 target
->type
->examined
= 0;
547 if (target
->type
->examine
== NULL
)
549 target
->type
->examine
= default_examine
;
552 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
554 LOG_ERROR("target '%s' init failed", target
->type
->name
);
558 /* Set up default functions if none are provided by target */
559 if (target
->type
->virt2phys
== NULL
)
561 target
->type
->virt2phys
= default_virt2phys
;
563 target
->type
->virt2phys
= default_virt2phys
;
564 /* a non-invasive way(in terms of patches) to add some code that
565 * runs before the type->write/read_memory implementation
567 target
->type
->write_memory_imp
= target
->type
->write_memory
;
568 target
->type
->write_memory
= target_write_memory_imp
;
569 target
->type
->read_memory_imp
= target
->type
->read_memory
;
570 target
->type
->read_memory
= target_read_memory_imp
;
571 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
572 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
573 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
574 target
->type
->run_algorithm
= target_run_algorithm_imp
;
577 if (target
->type
->mmu
== NULL
)
579 target
->type
->mmu
= default_mmu
;
581 target
= target
->next
;
586 target_register_user_commands(cmd_ctx
);
587 target_register_timer_callback(handle_target
, 100, 1, NULL
);
593 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
595 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
597 if (callback
== NULL
)
599 return ERROR_INVALID_ARGUMENTS
;
604 while ((*callbacks_p
)->next
)
605 callbacks_p
= &((*callbacks_p
)->next
);
606 callbacks_p
= &((*callbacks_p
)->next
);
609 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
610 (*callbacks_p
)->callback
= callback
;
611 (*callbacks_p
)->priv
= priv
;
612 (*callbacks_p
)->next
= NULL
;
617 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
619 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
622 if (callback
== NULL
)
624 return ERROR_INVALID_ARGUMENTS
;
629 while ((*callbacks_p
)->next
)
630 callbacks_p
= &((*callbacks_p
)->next
);
631 callbacks_p
= &((*callbacks_p
)->next
);
634 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
635 (*callbacks_p
)->callback
= callback
;
636 (*callbacks_p
)->periodic
= periodic
;
637 (*callbacks_p
)->time_ms
= time_ms
;
639 gettimeofday(&now
, NULL
);
640 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
641 time_ms
-= (time_ms
% 1000);
642 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
643 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
645 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
646 (*callbacks_p
)->when
.tv_sec
+= 1;
649 (*callbacks_p
)->priv
= priv
;
650 (*callbacks_p
)->next
= NULL
;
655 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
657 target_event_callback_t
**p
= &target_event_callbacks
;
658 target_event_callback_t
*c
= target_event_callbacks
;
660 if (callback
== NULL
)
662 return ERROR_INVALID_ARGUMENTS
;
667 target_event_callback_t
*next
= c
->next
;
668 if ((c
->callback
== callback
) && (c
->priv
== priv
))
682 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
684 target_timer_callback_t
**p
= &target_timer_callbacks
;
685 target_timer_callback_t
*c
= target_timer_callbacks
;
687 if (callback
== NULL
)
689 return ERROR_INVALID_ARGUMENTS
;
694 target_timer_callback_t
*next
= c
->next
;
695 if ((c
->callback
== callback
) && (c
->priv
== priv
))
709 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
711 target_event_callback_t
*callback
= target_event_callbacks
;
712 target_event_callback_t
*next_callback
;
714 LOG_DEBUG("target event %i", event
);
718 next_callback
= callback
->next
;
719 callback
->callback(target
, event
, callback
->priv
);
720 callback
= next_callback
;
726 static int target_call_timer_callbacks_check_time(int checktime
)
728 target_timer_callback_t
*callback
= target_timer_callbacks
;
729 target_timer_callback_t
*next_callback
;
734 gettimeofday(&now
, NULL
);
738 next_callback
= callback
->next
;
740 if ((!checktime
&&callback
->periodic
)||
741 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
742 || (now
.tv_sec
> callback
->when
.tv_sec
)))
744 if(callback
->callback
!= NULL
)
746 callback
->callback(callback
->priv
);
747 if (callback
->periodic
)
749 int time_ms
= callback
->time_ms
;
750 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
751 time_ms
-= (time_ms
% 1000);
752 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
753 if (callback
->when
.tv_usec
> 1000000)
755 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
756 callback
->when
.tv_sec
+= 1;
760 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
764 callback
= next_callback
;
770 int target_call_timer_callbacks()
772 return target_call_timer_callbacks_check_time(1);
775 /* invoke periodic callbacks immediately */
776 int target_call_timer_callbacks_now()
778 return target_call_timer_callbacks(0);
781 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
783 working_area_t
*c
= target
->working_areas
;
784 working_area_t
*new_wa
= NULL
;
786 /* Reevaluate working area address based on MMU state*/
787 if (target
->working_areas
== NULL
)
791 retval
= target
->type
->mmu(target
, &enabled
);
792 if (retval
!= ERROR_OK
)
798 target
->working_area
= target
->working_area_virt
;
802 target
->working_area
= target
->working_area_phys
;
806 /* only allocate multiples of 4 byte */
809 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
810 size
= CEIL(size
, 4);
813 /* see if there's already a matching working area */
816 if ((c
->free
) && (c
->size
== size
))
824 /* if not, allocate a new one */
827 working_area_t
**p
= &target
->working_areas
;
828 u32 first_free
= target
->working_area
;
829 u32 free_size
= target
->working_area_size
;
831 LOG_DEBUG("allocating new working area");
833 c
= target
->working_areas
;
836 first_free
+= c
->size
;
837 free_size
-= c
->size
;
842 if (free_size
< size
)
844 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
845 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
848 new_wa
= malloc(sizeof(working_area_t
));
851 new_wa
->address
= first_free
;
853 if (target
->backup_working_area
)
855 new_wa
->backup
= malloc(new_wa
->size
);
856 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
860 new_wa
->backup
= NULL
;
863 /* put new entry in list */
867 /* mark as used, and return the new (reused) area */
877 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
882 if (restore
&&target
->backup_working_area
)
883 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
887 /* mark user pointer invalid */
894 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
896 return target_free_working_area_restore(target
, area
, 1);
899 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
901 working_area_t
*c
= target
->working_areas
;
905 working_area_t
*next
= c
->next
;
906 target_free_working_area_restore(target
, c
, restore
);
916 target
->working_areas
= NULL
;
921 int target_free_all_working_areas(struct target_s
*target
)
923 return target_free_all_working_areas_restore(target
, 1);
926 int target_register_commands(struct command_context_s
*cmd_ctx
)
928 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
929 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
930 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
931 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
932 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
933 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
936 /* script procedures */
937 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
938 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
942 int target_arch_state(struct target_s
*target
)
947 LOG_USER("No target has been configured");
951 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
953 if (target
->state
!=TARGET_HALTED
)
956 retval
=target
->type
->arch_state(target
);
960 /* Single aligned words are guaranteed to use 16 or 32 bit access
961 * mode respectively, otherwise data is handled as quickly as
964 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
967 if (!target
->type
->examined
)
969 LOG_ERROR("Target not examined yet");
973 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
975 if (((address
% 2) == 0) && (size
== 2))
977 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
980 /* handle unaligned head bytes */
983 int unaligned
= 4 - (address
% 4);
985 if (unaligned
> size
)
988 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
992 address
+= unaligned
;
996 /* handle aligned words */
999 int aligned
= size
- (size
% 4);
1001 /* use bulk writes above a certain limit. This may have to be changed */
1004 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1009 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1018 /* handle tail writes of less than 4 bytes */
1021 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1029 /* Single aligned words are guaranteed to use 16 or 32 bit access
1030 * mode respectively, otherwise data is handled as quickly as
1033 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1036 if (!target
->type
->examined
)
1038 LOG_ERROR("Target not examined yet");
1042 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1044 if (((address
% 2) == 0) && (size
== 2))
1046 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1049 /* handle unaligned head bytes */
1052 int unaligned
= 4 - (address
% 4);
1054 if (unaligned
> size
)
1057 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1060 buffer
+= unaligned
;
1061 address
+= unaligned
;
1065 /* handle aligned words */
1068 int aligned
= size
- (size
% 4);
1070 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1078 /* handle tail writes of less than 4 bytes */
1081 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1088 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1094 if (!target
->type
->examined
)
1096 LOG_ERROR("Target not examined yet");
1100 if ((retval
= target
->type
->checksum_memory(target
, address
,
1101 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1103 buffer
= malloc(size
);
1106 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1107 return ERROR_INVALID_ARGUMENTS
;
1109 retval
= target_read_buffer(target
, address
, size
, buffer
);
1110 if (retval
!= ERROR_OK
)
1116 /* convert to target endianess */
1117 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1120 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1121 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1124 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1133 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1136 if (!target
->type
->examined
)
1138 LOG_ERROR("Target not examined yet");
1142 if (target
->type
->blank_check_memory
== 0)
1143 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1145 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1150 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1153 if (!target
->type
->examined
)
1155 LOG_ERROR("Target not examined yet");
1159 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1161 if (retval
== ERROR_OK
)
1163 *value
= target_buffer_get_u32(target
, value_buf
);
1164 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1169 LOG_DEBUG("address: 0x%8.8x failed", address
);
1175 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1178 if (!target
->type
->examined
)
1180 LOG_ERROR("Target not examined yet");
1184 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1186 if (retval
== ERROR_OK
)
1188 *value
= target_buffer_get_u16(target
, value_buf
);
1189 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1194 LOG_DEBUG("address: 0x%8.8x failed", address
);
1200 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1202 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1203 if (!target
->type
->examined
)
1205 LOG_ERROR("Target not examined yet");
1209 if (retval
== ERROR_OK
)
1211 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1216 LOG_DEBUG("address: 0x%8.8x failed", address
);
1222 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1226 if (!target
->type
->examined
)
1228 LOG_ERROR("Target not examined yet");
1232 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1234 target_buffer_set_u32(target
, value_buf
, value
);
1235 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1237 LOG_DEBUG("failed: %i", retval
);
1243 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1247 if (!target
->type
->examined
)
1249 LOG_ERROR("Target not examined yet");
1253 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1255 target_buffer_set_u16(target
, value_buf
, value
);
1256 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1258 LOG_DEBUG("failed: %i", retval
);
1264 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1267 if (!target
->type
->examined
)
1269 LOG_ERROR("Target not examined yet");
1273 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1275 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1277 LOG_DEBUG("failed: %i", retval
);
1283 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1285 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1286 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1287 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1288 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1289 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1290 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1291 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1292 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1294 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1295 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1296 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1298 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1299 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1300 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1302 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1303 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1304 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1305 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1307 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1308 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1309 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1310 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1311 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1313 target_request_register_commands(cmd_ctx
);
1314 trace_register_commands(cmd_ctx
);
1319 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1321 target_t
*target
= targets
;
1326 int num
= strtoul(args
[0], NULL
, 0);
1331 target
= target
->next
;
1335 cmd_ctx
->current_target
= num
;
1337 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1344 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1345 target
= target
->next
;
1351 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1358 return ERROR_COMMAND_SYNTAX_ERROR
;
1361 /* search for the specified target */
1362 if (args
[0] && (args
[0][0] != 0))
1364 for (i
= 0; target_types
[i
]; i
++)
1366 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1368 target_t
**last_target_p
= &targets
;
1370 /* register target specific commands */
1371 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1373 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1379 while ((*last_target_p
)->next
)
1380 last_target_p
= &((*last_target_p
)->next
);
1381 last_target_p
= &((*last_target_p
)->next
);
1384 *last_target_p
= malloc(sizeof(target_t
));
1386 /* allocate memory for each unique target type */
1387 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1388 *((*last_target_p
)->type
) = *target_types
[i
];
1390 if (strcmp(args
[1], "big") == 0)
1391 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1392 else if (strcmp(args
[1], "little") == 0)
1393 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1396 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1397 return ERROR_COMMAND_SYNTAX_ERROR
;
1400 if (strcmp(args
[2], "reset_halt") == 0)
1402 LOG_WARNING("reset_mode argument is obsolete.");
1403 return ERROR_COMMAND_SYNTAX_ERROR
;
1405 else if (strcmp(args
[2], "reset_run") == 0)
1407 LOG_WARNING("reset_mode argument is obsolete.");
1408 return ERROR_COMMAND_SYNTAX_ERROR
;
1410 else if (strcmp(args
[2], "reset_init") == 0)
1412 LOG_WARNING("reset_mode argument is obsolete.");
1413 return ERROR_COMMAND_SYNTAX_ERROR
;
1415 else if (strcmp(args
[2], "run_and_halt") == 0)
1417 LOG_WARNING("reset_mode argument is obsolete.");
1418 return ERROR_COMMAND_SYNTAX_ERROR
;
1420 else if (strcmp(args
[2], "run_and_init") == 0)
1422 LOG_WARNING("reset_mode argument is obsolete.");
1423 return ERROR_COMMAND_SYNTAX_ERROR
;
1427 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1431 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1433 (*last_target_p
)->working_area
= 0x0;
1434 (*last_target_p
)->working_area_size
= 0x0;
1435 (*last_target_p
)->working_areas
= NULL
;
1436 (*last_target_p
)->backup_working_area
= 0;
1438 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1439 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1440 (*last_target_p
)->reg_cache
= NULL
;
1441 (*last_target_p
)->breakpoints
= NULL
;
1442 (*last_target_p
)->watchpoints
= NULL
;
1443 (*last_target_p
)->next
= NULL
;
1444 (*last_target_p
)->arch_info
= NULL
;
1446 /* initialize trace information */
1447 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1448 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1449 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1450 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1451 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1452 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1453 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1454 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1456 (*last_target_p
)->dbgmsg
= NULL
;
1457 (*last_target_p
)->dbg_msg_enabled
= 0;
1459 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1467 /* no matching target found */
1470 LOG_ERROR("target '%s' not found", args
[0]);
1471 return ERROR_COMMAND_SYNTAX_ERROR
;
1477 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1479 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
1480 get_num_by_target(target
), name
,
1481 get_num_by_target(target
), name
);
1484 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1486 target_t
*target
= NULL
;
1490 return ERROR_COMMAND_SYNTAX_ERROR
;
1493 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1496 return ERROR_COMMAND_SYNTAX_ERROR
;
1499 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1504 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1506 target_t
*target
= NULL
;
1508 if ((argc
< 4) || (argc
> 5))
1510 return ERROR_COMMAND_SYNTAX_ERROR
;
1513 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1516 return ERROR_COMMAND_SYNTAX_ERROR
;
1518 target_free_all_working_areas(target
);
1520 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1523 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1525 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1527 if (strcmp(args
[3], "backup") == 0)
1529 target
->backup_working_area
= 1;
1531 else if (strcmp(args
[3], "nobackup") == 0)
1533 target
->backup_working_area
= 0;
1537 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1538 return ERROR_COMMAND_SYNTAX_ERROR
;
1545 /* process target state changes */
1546 int handle_target(void *priv
)
1548 target_t
*target
= targets
;
1552 if (target_continous_poll
)
1554 /* polling may fail silently until the target has been examined */
1555 target_poll(target
);
1558 target
= target
->next
;
1564 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1573 target
= get_current_target(cmd_ctx
);
1575 /* list all available registers for the current target */
1578 reg_cache_t
*cache
= target
->reg_cache
;
1584 for (i
= 0; i
< cache
->num_regs
; i
++)
1586 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1587 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
);
1590 cache
= cache
->next
;
1596 /* access a single register by its ordinal number */
1597 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1599 int num
= strtoul(args
[0], NULL
, 0);
1600 reg_cache_t
*cache
= target
->reg_cache
;
1606 for (i
= 0; i
< cache
->num_regs
; i
++)
1610 reg
= &cache
->reg_list
[i
];
1616 cache
= cache
->next
;
1621 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1624 } else /* access a single register by its name */
1626 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1630 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1635 /* display a register */
1636 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1638 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1641 if (reg
->valid
== 0)
1643 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1644 if (arch_type
== NULL
)
1646 LOG_ERROR("BUG: encountered unregistered arch type");
1649 arch_type
->get(reg
);
1651 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1652 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1657 /* set register value */
1660 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1661 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1663 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1664 if (arch_type
== NULL
)
1666 LOG_ERROR("BUG: encountered unregistered arch type");
1670 arch_type
->set(reg
, buf
);
1672 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1673 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1681 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1686 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1688 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1690 target_t
*target
= get_current_target(cmd_ctx
);
1694 target_poll(target
);
1695 target_arch_state(target
);
1699 if (strcmp(args
[0], "on") == 0)
1701 target_continous_poll
= 1;
1703 else if (strcmp(args
[0], "off") == 0)
1705 target_continous_poll
= 0;
1709 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1717 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1725 ms
= strtoul(args
[0], &end
, 0) * 1000;
1728 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1733 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1736 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1739 struct timeval timeout
, now
;
1741 gettimeofday(&timeout
, NULL
);
1742 timeval_add_time(&timeout
, 0, ms
* 1000);
1744 target_t
*target
= get_current_target(cmd_ctx
);
1747 if ((retval
=target_poll(target
))!=ERROR_OK
)
1749 target_call_timer_callbacks_now();
1750 if (target
->state
== state
)
1757 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1760 gettimeofday(&now
, NULL
);
1761 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1763 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1771 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1774 target_t
*target
= get_current_target(cmd_ctx
);
1778 if ((retval
= target_halt(target
)) != ERROR_OK
)
1783 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1786 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1788 target_t
*target
= get_current_target(cmd_ctx
);
1790 LOG_USER("requesting target halt and executing a soft reset");
1792 target
->type
->soft_reset_halt(target
);
1797 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1799 target_t
*target
= get_current_target(cmd_ctx
);
1800 enum target_reset_mode reset_mode
= RESET_RUN
;
1806 if (strcmp("run", args
[0]) == 0)
1807 reset_mode
= RESET_RUN
;
1808 else if (strcmp("halt", args
[0]) == 0)
1809 reset_mode
= RESET_HALT
;
1810 else if (strcmp("init", args
[0]) == 0)
1811 reset_mode
= RESET_INIT
;
1812 else if (strcmp("run_and_halt", args
[0]) == 0)
1814 reset_mode
= RESET_RUN_AND_HALT
;
1817 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1820 else if (strcmp("run_and_init", args
[0]) == 0)
1822 reset_mode
= RESET_RUN_AND_INIT
;
1825 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1830 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1835 /* reset *all* targets */
1836 target_process_reset(cmd_ctx
, reset_mode
);
1841 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1844 target_t
*target
= get_current_target(cmd_ctx
);
1846 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1849 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1851 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1854 return ERROR_COMMAND_SYNTAX_ERROR
;
1860 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1862 target_t
*target
= get_current_target(cmd_ctx
);
1867 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1870 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1875 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1877 const int line_bytecnt
= 32;
1890 target_t
*target
= get_current_target(cmd_ctx
);
1896 count
= strtoul(args
[1], NULL
, 0);
1898 address
= strtoul(args
[0], NULL
, 0);
1904 size
= 4; line_modulo
= line_bytecnt
/ 4;
1907 size
= 2; line_modulo
= line_bytecnt
/ 2;
1910 size
= 1; line_modulo
= line_bytecnt
/ 1;
1916 buffer
= calloc(count
, size
);
1917 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1918 if (retval
== ERROR_OK
)
1922 for (i
= 0; i
< count
; i
++)
1924 if (i
%line_modulo
== 0)
1925 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1930 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1933 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1936 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1940 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1942 command_print(cmd_ctx
, output
);
1953 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1960 target_t
*target
= get_current_target(cmd_ctx
);
1963 if ((argc
< 2) || (argc
> 3))
1964 return ERROR_COMMAND_SYNTAX_ERROR
;
1966 address
= strtoul(args
[0], NULL
, 0);
1967 value
= strtoul(args
[1], NULL
, 0);
1969 count
= strtoul(args
[2], NULL
, 0);
1975 target_buffer_set_u32(target
, value_buf
, value
);
1979 target_buffer_set_u16(target
, value_buf
, value
);
1983 value_buf
[0] = value
;
1986 return ERROR_COMMAND_SYNTAX_ERROR
;
1988 for (i
=0; i
<count
; i
++)
1994 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1997 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2000 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2005 if (retval
!=ERROR_OK
)
2015 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2025 duration_t duration
;
2026 char *duration_text
;
2028 target_t
*target
= get_current_target(cmd_ctx
);
2032 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2036 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2039 image
.base_address_set
= 1;
2040 image
.base_address
= strtoul(args
[1], NULL
, 0);
2044 image
.base_address_set
= 0;
2047 image
.start_address_set
= 0;
2049 duration_start_measure(&duration
);
2051 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2058 for (i
= 0; i
< image
.num_sections
; i
++)
2060 buffer
= malloc(image
.sections
[i
].size
);
2063 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2067 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2072 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2077 image_size
+= buf_cnt
;
2078 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2083 duration_stop_measure(&duration
, &duration_text
);
2084 if (retval
==ERROR_OK
)
2086 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2088 free(duration_text
);
2090 image_close(&image
);
2096 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2103 int retval
=ERROR_OK
;
2105 duration_t duration
;
2106 char *duration_text
;
2108 target_t
*target
= get_current_target(cmd_ctx
);
2112 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2116 address
= strtoul(args
[1], NULL
, 0);
2117 size
= strtoul(args
[2], NULL
, 0);
2119 if ((address
& 3) || (size
& 3))
2121 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2125 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2130 duration_start_measure(&duration
);
2135 u32 this_run_size
= (size
> 560) ? 560 : size
;
2137 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2138 if (retval
!= ERROR_OK
)
2143 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2144 if (retval
!= ERROR_OK
)
2149 size
-= this_run_size
;
2150 address
+= this_run_size
;
2153 fileio_close(&fileio
);
2155 duration_stop_measure(&duration
, &duration_text
);
2156 if (retval
==ERROR_OK
)
2158 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2160 free(duration_text
);
2165 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2173 u32 mem_checksum
= 0;
2177 duration_t duration
;
2178 char *duration_text
;
2180 target_t
*target
= get_current_target(cmd_ctx
);
2184 return ERROR_COMMAND_SYNTAX_ERROR
;
2189 LOG_ERROR("no target selected");
2193 duration_start_measure(&duration
);
2197 image
.base_address_set
= 1;
2198 image
.base_address
= strtoul(args
[1], NULL
, 0);
2202 image
.base_address_set
= 0;
2203 image
.base_address
= 0x0;
2206 image
.start_address_set
= 0;
2208 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2215 for (i
= 0; i
< image
.num_sections
; i
++)
2217 buffer
= malloc(image
.sections
[i
].size
);
2220 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2223 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2229 /* calculate checksum of image */
2230 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2232 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2233 if( retval
!= ERROR_OK
)
2239 if( checksum
!= mem_checksum
)
2241 /* failed crc checksum, fall back to a binary compare */
2244 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2246 data
= (u8
*)malloc(buf_cnt
);
2248 /* Can we use 32bit word accesses? */
2250 int count
= buf_cnt
;
2251 if ((count
% 4) == 0)
2256 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2257 if (retval
== ERROR_OK
)
2260 for (t
= 0; t
< buf_cnt
; t
++)
2262 if (data
[t
] != buffer
[t
])
2264 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
]);
2277 image_size
+= buf_cnt
;
2280 duration_stop_measure(&duration
, &duration_text
);
2281 if (retval
==ERROR_OK
)
2283 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2285 free(duration_text
);
2287 image_close(&image
);
2292 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2295 target_t
*target
= get_current_target(cmd_ctx
);
2299 breakpoint_t
*breakpoint
= target
->breakpoints
;
2303 if (breakpoint
->type
== BKPT_SOFT
)
2305 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2306 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2311 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2313 breakpoint
= breakpoint
->next
;
2321 length
= strtoul(args
[1], NULL
, 0);
2324 if (strcmp(args
[2], "hw") == 0)
2327 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2329 LOG_ERROR("Failure setting breakpoints");
2333 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2338 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2344 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2346 target_t
*target
= get_current_target(cmd_ctx
);
2349 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2354 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2356 target_t
*target
= get_current_target(cmd_ctx
);
2361 watchpoint_t
*watchpoint
= target
->watchpoints
;
2365 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
);
2366 watchpoint
= watchpoint
->next
;
2371 enum watchpoint_rw type
= WPT_ACCESS
;
2372 u32 data_value
= 0x0;
2373 u32 data_mask
= 0xffffffff;
2389 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2395 data_value
= strtoul(args
[3], NULL
, 0);
2399 data_mask
= strtoul(args
[4], NULL
, 0);
2402 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2403 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2405 LOG_ERROR("Failure setting breakpoints");
2410 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2416 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2418 target_t
*target
= get_current_target(cmd_ctx
);
2421 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2426 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2429 target_t
*target
= get_current_target(cmd_ctx
);
2435 return ERROR_COMMAND_SYNTAX_ERROR
;
2437 va
= strtoul(args
[0], NULL
, 0);
2439 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2440 if (retval
== ERROR_OK
)
2442 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2446 /* lower levels will have logged a detailed error which is
2447 * forwarded to telnet/GDB session.
2452 static void writeLong(FILE *f
, int l
)
2457 char c
=(l
>>(i
*8))&0xff;
2458 fwrite(&c
, 1, 1, f
);
2462 static void writeString(FILE *f
, char *s
)
2464 fwrite(s
, 1, strlen(s
), f
);
2469 // Dump a gmon.out histogram file.
2470 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2473 FILE *f
=fopen(filename
, "w");
2476 fwrite("gmon", 1, 4, f
);
2477 writeLong(f
, 0x00000001); // Version
2478 writeLong(f
, 0); // padding
2479 writeLong(f
, 0); // padding
2480 writeLong(f
, 0); // padding
2482 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2484 // figure out bucket size
2487 for (i
=0; i
<sampleNum
; i
++)
2499 int addressSpace
=(max
-min
+1);
2501 static int const maxBuckets
=256*1024; // maximum buckets.
2502 int length
=addressSpace
;
2503 if (length
> maxBuckets
)
2507 int *buckets
=malloc(sizeof(int)*length
);
2513 memset(buckets
, 0, sizeof(int)*length
);
2514 for (i
=0; i
<sampleNum
;i
++)
2516 u32 address
=samples
[i
];
2517 long long a
=address
-min
;
2518 long long b
=length
-1;
2519 long long c
=addressSpace
-1;
2520 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2524 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2525 writeLong(f
, min
); // low_pc
2526 writeLong(f
, max
); // high_pc
2527 writeLong(f
, length
); // # of samples
2528 writeLong(f
, 64000000); // 64MHz
2529 writeString(f
, "seconds");
2530 for (i
=0; i
<(15-strlen("seconds")); i
++)
2532 fwrite("", 1, 1, f
); // padding
2534 writeString(f
, "s");
2536 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2538 char *data
=malloc(2*length
);
2541 for (i
=0; i
<length
;i
++)
2550 data
[i
*2+1]=(val
>>8)&0xff;
2553 fwrite(data
, 1, length
*2, f
);
2563 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2564 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2566 target_t
*target
= get_current_target(cmd_ctx
);
2567 struct timeval timeout
, now
;
2569 gettimeofday(&timeout
, NULL
);
2572 return ERROR_COMMAND_SYNTAX_ERROR
;
2575 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2581 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2583 static const int maxSample
=10000;
2584 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2589 int retval
=ERROR_OK
;
2590 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2591 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2595 target_poll(target
);
2596 if (target
->state
== TARGET_HALTED
)
2598 u32 t
=*((u32
*)reg
->value
);
2599 samples
[numSamples
++]=t
;
2600 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2601 target_poll(target
);
2602 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2603 } else if (target
->state
== TARGET_RUNNING
)
2605 // We want to quickly sample the PC.
2606 target_halt(target
);
2609 command_print(cmd_ctx
, "Target not halted or running");
2613 if (retval
!=ERROR_OK
)
2618 gettimeofday(&now
, NULL
);
2619 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2621 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2622 target_poll(target
);
2623 if (target
->state
== TARGET_HALTED
)
2625 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2627 target_poll(target
);
2628 writeGmon(samples
, numSamples
, args
[1]);
2629 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2638 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2641 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2644 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2648 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2649 valObjPtr
= Jim_NewIntObj(interp
, val
);
2650 if (!nameObjPtr
|| !valObjPtr
)
2656 Jim_IncrRefCount(nameObjPtr
);
2657 Jim_IncrRefCount(valObjPtr
);
2658 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2659 Jim_DecrRefCount(interp
, nameObjPtr
);
2660 Jim_DecrRefCount(interp
, valObjPtr
);
2662 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2666 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2669 command_context_t
*context
;
2676 const char *varname
;
2678 int i
, n
, e
, retval
;
2680 /* argv[1] = name of array to receive the data
2681 * argv[2] = desired width
2682 * argv[3] = memory address
2683 * argv[4] = count of times to read
2686 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2689 varname
= Jim_GetString(argv
[1], &len
);
2690 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2692 e
= Jim_GetLong(interp
, argv
[2], &l
);
2698 e
= Jim_GetLong(interp
, argv
[3], &l
);
2703 e
= Jim_GetLong(interp
, argv
[4], &l
);
2719 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2720 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2724 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2725 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2728 if ((addr
+ (len
* width
)) < addr
) {
2729 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2730 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2733 /* absurd transfer size? */
2735 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2736 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2741 ((width
== 2) && ((addr
& 1) == 0)) ||
2742 ((width
== 4) && ((addr
& 3) == 0))) {
2746 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2747 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2748 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2752 context
= Jim_GetAssocData(interp
, "context");
2753 if (context
== NULL
)
2755 LOG_ERROR("mem2array: no command context");
2758 target
= get_current_target(context
);
2761 LOG_ERROR("mem2array: no current target");
2772 /* Slurp... in buffer size chunks */
2774 count
= len
; /* in objects.. */
2775 if (count
> (sizeof(buffer
)/width
)) {
2776 count
= (sizeof(buffer
)/width
);
2779 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2780 if (retval
!= ERROR_OK
) {
2782 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2783 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2784 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2788 v
= 0; /* shut up gcc */
2789 for (i
= 0 ;i
< count
;i
++, n
++) {
2792 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2795 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2798 v
= buffer
[i
] & 0x0ff;
2801 new_int_array_element(interp
, varname
, n
, v
);
2807 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2812 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2815 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2819 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2823 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2830 Jim_IncrRefCount(nameObjPtr
);
2831 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2832 Jim_DecrRefCount(interp
, nameObjPtr
);
2834 if (valObjPtr
== NULL
)
2837 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2838 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2843 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2846 command_context_t
*context
;
2853 const char *varname
;
2855 int i
, n
, e
, retval
;
2857 /* argv[1] = name of array to get the data
2858 * argv[2] = desired width
2859 * argv[3] = memory address
2860 * argv[4] = count to write
2863 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2866 varname
= Jim_GetString(argv
[1], &len
);
2867 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2869 e
= Jim_GetLong(interp
, argv
[2], &l
);
2875 e
= Jim_GetLong(interp
, argv
[3], &l
);
2880 e
= Jim_GetLong(interp
, argv
[4], &l
);
2896 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2897 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2901 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2902 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2905 if ((addr
+ (len
* width
)) < addr
) {
2906 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2907 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2910 /* absurd transfer size? */
2912 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2913 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2918 ((width
== 2) && ((addr
& 1) == 0)) ||
2919 ((width
== 4) && ((addr
& 3) == 0))) {
2923 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2924 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2925 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2929 context
= Jim_GetAssocData(interp
, "context");
2930 if (context
== NULL
)
2932 LOG_ERROR("array2mem: no command context");
2935 target
= get_current_target(context
);
2938 LOG_ERROR("array2mem: no current target");
2949 /* Slurp... in buffer size chunks */
2951 count
= len
; /* in objects.. */
2952 if (count
> (sizeof(buffer
)/width
)) {
2953 count
= (sizeof(buffer
)/width
);
2956 v
= 0; /* shut up gcc */
2957 for (i
= 0 ;i
< count
;i
++, n
++) {
2958 get_int_array_element(interp
, varname
, n
, &v
);
2961 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2964 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2967 buffer
[i
] = v
& 0x0ff;
2973 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2974 if (retval
!= ERROR_OK
) {
2976 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2977 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2978 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2984 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)