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
);
80 extern target_type_t arm7tdmi_target
;
81 extern target_type_t arm720t_target
;
82 extern target_type_t arm9tdmi_target
;
83 extern target_type_t arm920t_target
;
84 extern target_type_t arm966e_target
;
85 extern target_type_t arm926ejs_target
;
86 extern target_type_t feroceon_target
;
87 extern target_type_t xscale_target
;
88 extern target_type_t cortexm3_target
;
89 extern target_type_t arm11_target
;
91 target_type_t
*target_types
[] =
106 target_t
*targets
= NULL
;
107 target_event_callback_t
*target_event_callbacks
= NULL
;
108 target_timer_callback_t
*target_timer_callbacks
= NULL
;
110 char *target_state_strings
[] =
119 char *target_debug_reason_strings
[] =
121 "debug request", "breakpoint", "watchpoint",
122 "watchpoint and breakpoint", "single step",
123 "target not halted", "undefined"
126 char *target_endianess_strings
[] =
132 static int target_continous_poll
= 1;
134 /* read a u32 from a buffer in target memory endianness */
135 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
137 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
138 return le_to_h_u32(buffer
);
140 return be_to_h_u32(buffer
);
143 /* read a u16 from a buffer in target memory endianness */
144 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
146 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
147 return le_to_h_u16(buffer
);
149 return be_to_h_u16(buffer
);
152 /* write a u32 to a buffer in target memory endianness */
153 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
155 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
156 h_u32_to_le(buffer
, value
);
158 h_u32_to_be(buffer
, value
);
161 /* write a u16 to a buffer in target memory endianness */
162 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
164 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
165 h_u16_to_le(buffer
, value
);
167 h_u16_to_be(buffer
, value
);
170 /* returns a pointer to the n-th configured target */
171 target_t
* get_target_by_num(int num
)
173 target_t
*target
= targets
;
180 target
= target
->next
;
187 int get_num_by_target(target_t
*query_target
)
189 target_t
*target
= targets
;
194 if (target
== query_target
)
196 target
= target
->next
;
203 target_t
* get_current_target(command_context_t
*cmd_ctx
)
205 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
209 LOG_ERROR("BUG: current_target out of bounds");
216 /* Process target initialization, when target entered debug out of reset
217 * the handler is unregistered at the end of this function, so it's only called once
219 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
221 struct command_context_s
*cmd_ctx
= priv
;
223 if (event
== TARGET_EVENT_HALTED
)
225 target_unregister_event_callback(target_init_handler
, priv
);
226 target_invoke_script(cmd_ctx
, target
, "post_reset");
227 jtag_execute_queue();
233 int target_run_and_halt_handler(void *priv
)
235 target_t
*target
= priv
;
242 int target_poll(struct target_s
*target
)
244 /* We can't poll until after examine */
245 if (!target
->type
->examined
)
247 /* Fail silently lest we pollute the log */
250 return target
->type
->poll(target
);
253 int target_halt(struct target_s
*target
)
255 /* We can't poll until after examine */
256 if (!target
->type
->examined
)
258 LOG_ERROR("Target not examined yet");
261 return target
->type
->halt(target
);
264 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
268 /* We can't poll until after examine */
269 if (!target
->type
->examined
)
271 LOG_ERROR("Target not examined yet");
275 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
281 int target_process_reset(struct command_context_s
*cmd_ctx
)
283 int retval
= ERROR_OK
;
285 struct timeval timeout
, now
;
287 jtag
->speed(jtag_speed
);
292 target_invoke_script(cmd_ctx
, target
, "pre_reset");
293 target
= target
->next
;
296 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
299 /* First time this is executed after launching OpenOCD, it will read out
300 * the type of CPU, etc. and init Embedded ICE registers in host
303 * It will also set up ICE registers in the target.
305 * However, if we assert TRST later, we need to set up the registers again.
307 * For the "reset halt/init" case we must only set up the registers here.
309 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
312 /* prepare reset_halt where necessary */
316 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
318 switch (target
->reset_mode
)
321 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
322 target
->reset_mode
= RESET_RUN_AND_HALT
;
325 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
326 target
->reset_mode
= RESET_RUN_AND_INIT
;
332 target
= target
->next
;
338 /* we have no idea what state the target is in, so we
339 * have to drop working areas
341 target_free_all_working_areas_restore(target
, 0);
342 target
->type
->assert_reset(target
);
343 target
= target
->next
;
345 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
347 LOG_WARNING("JTAG communication failed asserting reset.");
351 /* request target halt if necessary, and schedule further action */
355 switch (target
->reset_mode
)
358 /* nothing to do if target just wants to be run */
360 case RESET_RUN_AND_HALT
:
362 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
364 case RESET_RUN_AND_INIT
:
366 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
367 target_register_event_callback(target_init_handler
, cmd_ctx
);
374 target_register_event_callback(target_init_handler
, cmd_ctx
);
377 LOG_ERROR("BUG: unknown target->reset_mode");
379 target
= target
->next
;
382 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
384 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
391 target
->type
->deassert_reset(target
);
392 target
= target
->next
;
395 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
397 LOG_WARNING("JTAG communication failed while deasserting reset.");
401 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
403 /* If TRST was asserted we need to set up registers again */
404 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
409 LOG_DEBUG("Waiting for halted stated as approperiate");
411 /* Wait for reset to complete, maximum 5 seconds. */
412 gettimeofday(&timeout
, NULL
);
413 timeval_add_time(&timeout
, 5, 0);
416 gettimeofday(&now
, NULL
);
418 target_call_timer_callbacks_now();
423 LOG_DEBUG("Polling target");
425 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
426 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
427 (target
->reset_mode
== RESET_HALT
) ||
428 (target
->reset_mode
== RESET_INIT
))
430 if (target
->state
!= TARGET_HALTED
)
432 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
434 LOG_USER("Timed out waiting for halt after reset");
437 /* this will send alive messages on e.g. GDB remote protocol. */
439 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
443 target
= target
->next
;
445 /* All targets we're waiting for are halted */
453 /* We want any events to be processed before the prompt */
454 target_call_timer_callbacks_now();
456 /* if we timed out we need to unregister these handlers */
460 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
461 target
= target
->next
;
463 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
465 jtag
->speed(jtag_speed_post_reset
);
470 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
476 static int default_mmu(struct target_s
*target
, int *enabled
)
482 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
484 target
->type
->examined
= 1;
489 /* Targets that correctly implement init+examine, i.e.
490 * no communication with target during init:
494 int target_examine(struct command_context_s
*cmd_ctx
)
496 int retval
= ERROR_OK
;
497 target_t
*target
= targets
;
500 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
502 target
= target
->next
;
507 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
509 if (!target
->type
->examined
)
511 LOG_ERROR("Target not examined yet");
514 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
517 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
519 if (!target
->type
->examined
)
521 LOG_ERROR("Target not examined yet");
524 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
527 static int target_soft_reset_halt_imp(struct target_s
*target
)
529 if (!target
->type
->examined
)
531 LOG_ERROR("Target not examined yet");
534 return target
->type
->soft_reset_halt_imp(target
);
537 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
)
539 if (!target
->type
->examined
)
541 LOG_ERROR("Target not examined yet");
544 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
);
547 int target_init(struct command_context_s
*cmd_ctx
)
549 target_t
*target
= targets
;
553 target
->type
->examined
= 0;
554 if (target
->type
->examine
== NULL
)
556 target
->type
->examine
= default_examine
;
559 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
561 LOG_ERROR("target '%s' init failed", target
->type
->name
);
565 /* Set up default functions if none are provided by target */
566 if (target
->type
->virt2phys
== NULL
)
568 target
->type
->virt2phys
= default_virt2phys
;
570 target
->type
->virt2phys
= default_virt2phys
;
571 /* a non-invasive way(in terms of patches) to add some code that
572 * runs before the type->write/read_memory implementation
574 target
->type
->write_memory_imp
= target
->type
->write_memory
;
575 target
->type
->write_memory
= target_write_memory_imp
;
576 target
->type
->read_memory_imp
= target
->type
->read_memory
;
577 target
->type
->read_memory
= target_read_memory_imp
;
578 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
579 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
580 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
581 target
->type
->run_algorithm
= target_run_algorithm_imp
;
584 if (target
->type
->mmu
== NULL
)
586 target
->type
->mmu
= default_mmu
;
588 target
= target
->next
;
593 target_register_user_commands(cmd_ctx
);
594 target_register_timer_callback(handle_target
, 100, 1, NULL
);
600 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
602 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
604 if (callback
== NULL
)
606 return ERROR_INVALID_ARGUMENTS
;
611 while ((*callbacks_p
)->next
)
612 callbacks_p
= &((*callbacks_p
)->next
);
613 callbacks_p
= &((*callbacks_p
)->next
);
616 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
617 (*callbacks_p
)->callback
= callback
;
618 (*callbacks_p
)->priv
= priv
;
619 (*callbacks_p
)->next
= NULL
;
624 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
626 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
629 if (callback
== NULL
)
631 return ERROR_INVALID_ARGUMENTS
;
636 while ((*callbacks_p
)->next
)
637 callbacks_p
= &((*callbacks_p
)->next
);
638 callbacks_p
= &((*callbacks_p
)->next
);
641 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
642 (*callbacks_p
)->callback
= callback
;
643 (*callbacks_p
)->periodic
= periodic
;
644 (*callbacks_p
)->time_ms
= time_ms
;
646 gettimeofday(&now
, NULL
);
647 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
648 time_ms
-= (time_ms
% 1000);
649 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
650 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
652 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
653 (*callbacks_p
)->when
.tv_sec
+= 1;
656 (*callbacks_p
)->priv
= priv
;
657 (*callbacks_p
)->next
= NULL
;
662 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
664 target_event_callback_t
**p
= &target_event_callbacks
;
665 target_event_callback_t
*c
= target_event_callbacks
;
667 if (callback
== NULL
)
669 return ERROR_INVALID_ARGUMENTS
;
674 target_event_callback_t
*next
= c
->next
;
675 if ((c
->callback
== callback
) && (c
->priv
== priv
))
689 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
691 target_timer_callback_t
**p
= &target_timer_callbacks
;
692 target_timer_callback_t
*c
= target_timer_callbacks
;
694 if (callback
== NULL
)
696 return ERROR_INVALID_ARGUMENTS
;
701 target_timer_callback_t
*next
= c
->next
;
702 if ((c
->callback
== callback
) && (c
->priv
== priv
))
716 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
718 target_event_callback_t
*callback
= target_event_callbacks
;
719 target_event_callback_t
*next_callback
;
721 LOG_DEBUG("target event %i", event
);
725 next_callback
= callback
->next
;
726 callback
->callback(target
, event
, callback
->priv
);
727 callback
= next_callback
;
733 static int target_call_timer_callbacks_check_time(int checktime
)
735 target_timer_callback_t
*callback
= target_timer_callbacks
;
736 target_timer_callback_t
*next_callback
;
739 gettimeofday(&now
, NULL
);
743 next_callback
= callback
->next
;
745 if ((!checktime
&&callback
->periodic
)||
746 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
747 || (now
.tv_sec
> callback
->when
.tv_sec
)))
749 if(callback
->callback
!= NULL
)
751 callback
->callback(callback
->priv
);
752 if (callback
->periodic
)
754 int time_ms
= callback
->time_ms
;
755 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
756 time_ms
-= (time_ms
% 1000);
757 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
758 if (callback
->when
.tv_usec
> 1000000)
760 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
761 callback
->when
.tv_sec
+= 1;
765 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
769 callback
= next_callback
;
775 int target_call_timer_callbacks()
777 return target_call_timer_callbacks_check_time(1);
780 /* invoke periodic callbacks immediately */
781 int target_call_timer_callbacks_now()
783 return target_call_timer_callbacks(0);
786 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
788 working_area_t
*c
= target
->working_areas
;
789 working_area_t
*new_wa
= NULL
;
791 /* Reevaluate working area address based on MMU state*/
792 if (target
->working_areas
== NULL
)
796 retval
= target
->type
->mmu(target
, &enabled
);
797 if (retval
!= ERROR_OK
)
803 target
->working_area
= target
->working_area_virt
;
807 target
->working_area
= target
->working_area_phys
;
811 /* only allocate multiples of 4 byte */
814 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
815 size
= CEIL(size
, 4);
818 /* see if there's already a matching working area */
821 if ((c
->free
) && (c
->size
== size
))
829 /* if not, allocate a new one */
832 working_area_t
**p
= &target
->working_areas
;
833 u32 first_free
= target
->working_area
;
834 u32 free_size
= target
->working_area_size
;
836 LOG_DEBUG("allocating new working area");
838 c
= target
->working_areas
;
841 first_free
+= c
->size
;
842 free_size
-= c
->size
;
847 if (free_size
< size
)
849 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
850 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
853 new_wa
= malloc(sizeof(working_area_t
));
856 new_wa
->address
= first_free
;
858 if (target
->backup_working_area
)
860 new_wa
->backup
= malloc(new_wa
->size
);
861 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
865 new_wa
->backup
= NULL
;
868 /* put new entry in list */
872 /* mark as used, and return the new (reused) area */
882 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
887 if (restore
&&target
->backup_working_area
)
888 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
892 /* mark user pointer invalid */
899 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
901 return target_free_working_area_restore(target
, area
, 1);
904 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
906 working_area_t
*c
= target
->working_areas
;
910 working_area_t
*next
= c
->next
;
911 target_free_working_area_restore(target
, c
, restore
);
921 target
->working_areas
= NULL
;
926 int target_free_all_working_areas(struct target_s
*target
)
928 return target_free_all_working_areas_restore(target
, 1);
931 int target_register_commands(struct command_context_s
*cmd_ctx
)
933 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
934 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
935 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
936 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
937 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
938 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
943 int target_arch_state(struct target_s
*target
)
948 LOG_USER("No target has been configured");
952 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
954 if (target
->state
!=TARGET_HALTED
)
957 retval
=target
->type
->arch_state(target
);
961 /* Single aligned words are guaranteed to use 16 or 32 bit access
962 * mode respectively, otherwise data is handled as quickly as
965 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
968 if (!target
->type
->examined
)
970 LOG_ERROR("Target not examined yet");
974 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
976 if (((address
% 2) == 0) && (size
== 2))
978 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
981 /* handle unaligned head bytes */
984 int unaligned
= 4 - (address
% 4);
986 if (unaligned
> size
)
989 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
993 address
+= unaligned
;
997 /* handle aligned words */
1000 int aligned
= size
- (size
% 4);
1002 /* use bulk writes above a certain limit. This may have to be changed */
1005 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1010 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1019 /* handle tail writes of less than 4 bytes */
1022 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1030 /* Single aligned words are guaranteed to use 16 or 32 bit access
1031 * mode respectively, otherwise data is handled as quickly as
1034 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1037 if (!target
->type
->examined
)
1039 LOG_ERROR("Target not examined yet");
1043 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1045 if (((address
% 2) == 0) && (size
== 2))
1047 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1050 /* handle unaligned head bytes */
1053 int unaligned
= 4 - (address
% 4);
1055 if (unaligned
> size
)
1058 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1061 buffer
+= unaligned
;
1062 address
+= unaligned
;
1066 /* handle aligned words */
1069 int aligned
= size
- (size
% 4);
1071 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1079 /* handle tail writes of less than 4 bytes */
1082 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1089 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1095 if (!target
->type
->examined
)
1097 LOG_ERROR("Target not examined yet");
1101 if ((retval
= target
->type
->checksum_memory(target
, address
,
1102 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1104 buffer
= malloc(size
);
1107 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1108 return ERROR_INVALID_ARGUMENTS
;
1110 retval
= target_read_buffer(target
, address
, size
, buffer
);
1111 if (retval
!= ERROR_OK
)
1117 /* convert to target endianess */
1118 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1121 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1122 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1125 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1134 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1137 if (!target
->type
->examined
)
1139 LOG_ERROR("Target not examined yet");
1143 if (target
->type
->blank_check_memory
== 0)
1144 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1146 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1151 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1154 if (!target
->type
->examined
)
1156 LOG_ERROR("Target not examined yet");
1160 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1162 if (retval
== ERROR_OK
)
1164 *value
= target_buffer_get_u32(target
, value_buf
);
1165 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1170 LOG_DEBUG("address: 0x%8.8x failed", address
);
1176 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1179 if (!target
->type
->examined
)
1181 LOG_ERROR("Target not examined yet");
1185 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1187 if (retval
== ERROR_OK
)
1189 *value
= target_buffer_get_u16(target
, value_buf
);
1190 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1195 LOG_DEBUG("address: 0x%8.8x failed", address
);
1201 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1203 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1204 if (!target
->type
->examined
)
1206 LOG_ERROR("Target not examined yet");
1210 if (retval
== ERROR_OK
)
1212 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1217 LOG_DEBUG("address: 0x%8.8x failed", address
);
1223 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1227 if (!target
->type
->examined
)
1229 LOG_ERROR("Target not examined yet");
1233 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1235 target_buffer_set_u32(target
, value_buf
, value
);
1236 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1238 LOG_DEBUG("failed: %i", retval
);
1244 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1248 if (!target
->type
->examined
)
1250 LOG_ERROR("Target not examined yet");
1254 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1256 target_buffer_set_u16(target
, value_buf
, value
);
1257 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1259 LOG_DEBUG("failed: %i", retval
);
1265 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1268 if (!target
->type
->examined
)
1270 LOG_ERROR("Target not examined yet");
1274 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1276 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1278 LOG_DEBUG("failed: %i", retval
);
1284 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1286 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1287 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1288 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1289 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1290 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1291 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1292 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1293 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1295 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1296 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1297 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1299 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1300 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1301 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1303 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1304 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1305 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1306 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1308 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1309 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1310 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1311 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1312 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1314 target_request_register_commands(cmd_ctx
);
1315 trace_register_commands(cmd_ctx
);
1320 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1322 target_t
*target
= targets
;
1327 int num
= strtoul(args
[0], NULL
, 0);
1332 target
= target
->next
;
1336 cmd_ctx
->current_target
= num
;
1338 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1345 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1346 target
= target
->next
;
1352 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1359 return ERROR_COMMAND_SYNTAX_ERROR
;
1362 /* search for the specified target */
1363 if (args
[0] && (args
[0][0] != 0))
1365 for (i
= 0; target_types
[i
]; i
++)
1367 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1369 target_t
**last_target_p
= &targets
;
1371 /* register target specific commands */
1372 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1374 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1380 while ((*last_target_p
)->next
)
1381 last_target_p
= &((*last_target_p
)->next
);
1382 last_target_p
= &((*last_target_p
)->next
);
1385 *last_target_p
= malloc(sizeof(target_t
));
1387 /* allocate memory for each unique target type */
1388 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1389 *((*last_target_p
)->type
) = *target_types
[i
];
1391 if (strcmp(args
[1], "big") == 0)
1392 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1393 else if (strcmp(args
[1], "little") == 0)
1394 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1397 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1398 return ERROR_COMMAND_SYNTAX_ERROR
;
1401 /* what to do on a target reset */
1402 (*last_target_p
)->reset_mode
= RESET_INIT
; /* default */
1403 if (strcmp(args
[2], "reset_halt") == 0)
1404 (*last_target_p
)->reset_mode
= RESET_HALT
;
1405 else if (strcmp(args
[2], "reset_run") == 0)
1406 (*last_target_p
)->reset_mode
= RESET_RUN
;
1407 else if (strcmp(args
[2], "reset_init") == 0)
1408 (*last_target_p
)->reset_mode
= RESET_INIT
;
1409 else if (strcmp(args
[2], "run_and_halt") == 0)
1410 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1411 else if (strcmp(args
[2], "run_and_init") == 0)
1412 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1415 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1419 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1421 (*last_target_p
)->working_area
= 0x0;
1422 (*last_target_p
)->working_area_size
= 0x0;
1423 (*last_target_p
)->working_areas
= NULL
;
1424 (*last_target_p
)->backup_working_area
= 0;
1426 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1427 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1428 (*last_target_p
)->reg_cache
= NULL
;
1429 (*last_target_p
)->breakpoints
= NULL
;
1430 (*last_target_p
)->watchpoints
= NULL
;
1431 (*last_target_p
)->next
= NULL
;
1432 (*last_target_p
)->arch_info
= NULL
;
1434 /* initialize trace information */
1435 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1436 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1437 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1438 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1439 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1440 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1441 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1442 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1444 (*last_target_p
)->dbgmsg
= NULL
;
1445 (*last_target_p
)->dbg_msg_enabled
= 0;
1447 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1455 /* no matching target found */
1458 LOG_ERROR("target '%s' not found", args
[0]);
1459 return ERROR_COMMAND_SYNTAX_ERROR
;
1465 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1467 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
1468 name
, get_num_by_target(target
),
1469 name
, get_num_by_target(target
));
1472 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1474 target_t
*target
= NULL
;
1478 return ERROR_COMMAND_SYNTAX_ERROR
;
1481 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1484 return ERROR_COMMAND_SYNTAX_ERROR
;
1487 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1492 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1494 target_t
*target
= NULL
;
1496 if ((argc
< 4) || (argc
> 5))
1498 return ERROR_COMMAND_SYNTAX_ERROR
;
1501 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1504 return ERROR_COMMAND_SYNTAX_ERROR
;
1506 target_free_all_working_areas(target
);
1508 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1511 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1513 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1515 if (strcmp(args
[3], "backup") == 0)
1517 target
->backup_working_area
= 1;
1519 else if (strcmp(args
[3], "nobackup") == 0)
1521 target
->backup_working_area
= 0;
1525 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1526 return ERROR_COMMAND_SYNTAX_ERROR
;
1533 /* process target state changes */
1534 int handle_target(void *priv
)
1536 target_t
*target
= targets
;
1540 if (target_continous_poll
)
1542 /* polling may fail silently until the target has been examined */
1543 target_poll(target
);
1546 target
= target
->next
;
1552 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1561 target
= get_current_target(cmd_ctx
);
1563 /* list all available registers for the current target */
1566 reg_cache_t
*cache
= target
->reg_cache
;
1572 for (i
= 0; i
< cache
->num_regs
; i
++)
1574 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1575 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
);
1578 cache
= cache
->next
;
1584 /* access a single register by its ordinal number */
1585 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1587 int num
= strtoul(args
[0], NULL
, 0);
1588 reg_cache_t
*cache
= target
->reg_cache
;
1594 for (i
= 0; i
< cache
->num_regs
; i
++)
1598 reg
= &cache
->reg_list
[i
];
1604 cache
= cache
->next
;
1609 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1612 } else /* access a single register by its name */
1614 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1618 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1623 /* display a register */
1624 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1626 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1629 if (reg
->valid
== 0)
1631 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1632 if (arch_type
== NULL
)
1634 LOG_ERROR("BUG: encountered unregistered arch type");
1637 arch_type
->get(reg
);
1639 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1640 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1645 /* set register value */
1648 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1649 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1651 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1652 if (arch_type
== NULL
)
1654 LOG_ERROR("BUG: encountered unregistered arch type");
1658 arch_type
->set(reg
, buf
);
1660 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1661 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1669 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1674 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1676 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1678 target_t
*target
= get_current_target(cmd_ctx
);
1682 target_poll(target
);
1683 target_arch_state(target
);
1687 if (strcmp(args
[0], "on") == 0)
1689 target_continous_poll
= 1;
1691 else if (strcmp(args
[0], "off") == 0)
1693 target_continous_poll
= 0;
1697 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1705 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1713 ms
= strtoul(args
[0], &end
, 0) * 1000;
1716 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1721 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1724 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1727 struct timeval timeout
, now
;
1729 gettimeofday(&timeout
, NULL
);
1730 timeval_add_time(&timeout
, 0, ms
* 1000);
1732 target_t
*target
= get_current_target(cmd_ctx
);
1735 if ((retval
=target_poll(target
))!=ERROR_OK
)
1737 target_call_timer_callbacks_now();
1738 if (target
->state
== state
)
1745 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1748 gettimeofday(&now
, NULL
);
1749 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1751 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1759 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1762 target_t
*target
= get_current_target(cmd_ctx
);
1766 if ((retval
= target_halt(target
)) != ERROR_OK
)
1771 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1774 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1776 target_t
*target
= get_current_target(cmd_ctx
);
1778 LOG_USER("requesting target halt and executing a soft reset");
1780 target
->type
->soft_reset_halt(target
);
1785 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1787 target_t
*target
= get_current_target(cmd_ctx
);
1788 enum target_reset_mode reset_mode
= target
->reset_mode
;
1789 enum target_reset_mode save
= target
->reset_mode
;
1795 if (strcmp("run", args
[0]) == 0)
1796 reset_mode
= RESET_RUN
;
1797 else if (strcmp("halt", args
[0]) == 0)
1798 reset_mode
= RESET_HALT
;
1799 else if (strcmp("init", args
[0]) == 0)
1800 reset_mode
= RESET_INIT
;
1801 else if (strcmp("run_and_halt", args
[0]) == 0)
1803 reset_mode
= RESET_RUN_AND_HALT
;
1806 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1809 else if (strcmp("run_and_init", args
[0]) == 0)
1811 reset_mode
= RESET_RUN_AND_INIT
;
1814 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1819 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1824 /* temporarily modify mode of current reset target */
1825 target
->reset_mode
= reset_mode
;
1827 /* reset *all* targets */
1828 target_process_reset(cmd_ctx
);
1830 /* Restore default reset mode for this target */
1831 target
->reset_mode
= save
;
1836 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1839 target_t
*target
= get_current_target(cmd_ctx
);
1841 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1844 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1846 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1849 return ERROR_COMMAND_SYNTAX_ERROR
;
1855 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1857 target_t
*target
= get_current_target(cmd_ctx
);
1862 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1865 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1870 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1872 const int line_bytecnt
= 32;
1885 target_t
*target
= get_current_target(cmd_ctx
);
1891 count
= strtoul(args
[1], NULL
, 0);
1893 address
= strtoul(args
[0], NULL
, 0);
1899 size
= 4; line_modulo
= line_bytecnt
/ 4;
1902 size
= 2; line_modulo
= line_bytecnt
/ 2;
1905 size
= 1; line_modulo
= line_bytecnt
/ 1;
1911 buffer
= calloc(count
, size
);
1912 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1913 if (retval
== ERROR_OK
)
1917 for (i
= 0; i
< count
; i
++)
1919 if (i
%line_modulo
== 0)
1920 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1925 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1928 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1931 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1935 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1937 command_print(cmd_ctx
, output
);
1948 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1955 target_t
*target
= get_current_target(cmd_ctx
);
1958 if ((argc
< 2) || (argc
> 3))
1959 return ERROR_COMMAND_SYNTAX_ERROR
;
1961 address
= strtoul(args
[0], NULL
, 0);
1962 value
= strtoul(args
[1], NULL
, 0);
1964 count
= strtoul(args
[2], NULL
, 0);
1970 target_buffer_set_u32(target
, value_buf
, value
);
1974 target_buffer_set_u16(target
, value_buf
, value
);
1978 value_buf
[0] = value
;
1981 return ERROR_COMMAND_SYNTAX_ERROR
;
1983 for (i
=0; i
<count
; i
++)
1989 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1992 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1995 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2000 if (retval
!=ERROR_OK
)
2010 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2020 duration_t duration
;
2021 char *duration_text
;
2023 target_t
*target
= get_current_target(cmd_ctx
);
2027 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2031 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2034 image
.base_address_set
= 1;
2035 image
.base_address
= strtoul(args
[1], NULL
, 0);
2039 image
.base_address_set
= 0;
2042 image
.start_address_set
= 0;
2044 duration_start_measure(&duration
);
2046 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2053 for (i
= 0; i
< image
.num_sections
; i
++)
2055 buffer
= malloc(image
.sections
[i
].size
);
2058 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2062 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2067 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2072 image_size
+= buf_cnt
;
2073 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2078 duration_stop_measure(&duration
, &duration_text
);
2079 if (retval
==ERROR_OK
)
2081 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2083 free(duration_text
);
2085 image_close(&image
);
2091 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2098 int retval
=ERROR_OK
;
2100 duration_t duration
;
2101 char *duration_text
;
2103 target_t
*target
= get_current_target(cmd_ctx
);
2107 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2111 address
= strtoul(args
[1], NULL
, 0);
2112 size
= strtoul(args
[2], NULL
, 0);
2114 if ((address
& 3) || (size
& 3))
2116 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2120 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2125 duration_start_measure(&duration
);
2130 u32 this_run_size
= (size
> 560) ? 560 : size
;
2132 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2133 if (retval
!= ERROR_OK
)
2138 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2139 if (retval
!= ERROR_OK
)
2144 size
-= this_run_size
;
2145 address
+= this_run_size
;
2148 fileio_close(&fileio
);
2150 duration_stop_measure(&duration
, &duration_text
);
2151 if (retval
==ERROR_OK
)
2153 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2155 free(duration_text
);
2160 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2168 u32 mem_checksum
= 0;
2172 duration_t duration
;
2173 char *duration_text
;
2175 target_t
*target
= get_current_target(cmd_ctx
);
2179 return ERROR_COMMAND_SYNTAX_ERROR
;
2184 LOG_ERROR("no target selected");
2188 duration_start_measure(&duration
);
2192 image
.base_address_set
= 1;
2193 image
.base_address
= strtoul(args
[1], NULL
, 0);
2197 image
.base_address_set
= 0;
2198 image
.base_address
= 0x0;
2201 image
.start_address_set
= 0;
2203 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2210 for (i
= 0; i
< image
.num_sections
; i
++)
2212 buffer
= malloc(image
.sections
[i
].size
);
2215 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2218 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2224 /* calculate checksum of image */
2225 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2227 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2228 if( retval
!= ERROR_OK
)
2234 if( checksum
!= mem_checksum
)
2236 /* failed crc checksum, fall back to a binary compare */
2239 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2241 data
= (u8
*)malloc(buf_cnt
);
2243 /* Can we use 32bit word accesses? */
2245 int count
= buf_cnt
;
2246 if ((count
% 4) == 0)
2251 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2252 if (retval
== ERROR_OK
)
2255 for (t
= 0; t
< buf_cnt
; t
++)
2257 if (data
[t
] != buffer
[t
])
2259 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
]);
2272 image_size
+= buf_cnt
;
2275 duration_stop_measure(&duration
, &duration_text
);
2276 if (retval
==ERROR_OK
)
2278 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2280 free(duration_text
);
2282 image_close(&image
);
2287 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2290 target_t
*target
= get_current_target(cmd_ctx
);
2294 breakpoint_t
*breakpoint
= target
->breakpoints
;
2298 if (breakpoint
->type
== BKPT_SOFT
)
2300 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2301 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2306 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2308 breakpoint
= breakpoint
->next
;
2316 length
= strtoul(args
[1], NULL
, 0);
2319 if (strcmp(args
[2], "hw") == 0)
2322 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2324 LOG_ERROR("Failure setting breakpoints");
2328 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2333 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2339 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2341 target_t
*target
= get_current_target(cmd_ctx
);
2344 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2349 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2351 target_t
*target
= get_current_target(cmd_ctx
);
2356 watchpoint_t
*watchpoint
= target
->watchpoints
;
2360 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
);
2361 watchpoint
= watchpoint
->next
;
2366 enum watchpoint_rw type
= WPT_ACCESS
;
2367 u32 data_value
= 0x0;
2368 u32 data_mask
= 0xffffffff;
2384 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2390 data_value
= strtoul(args
[3], NULL
, 0);
2394 data_mask
= strtoul(args
[4], NULL
, 0);
2397 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2398 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2400 LOG_ERROR("Failure setting breakpoints");
2405 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2411 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2413 target_t
*target
= get_current_target(cmd_ctx
);
2416 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2421 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2424 target_t
*target
= get_current_target(cmd_ctx
);
2430 return ERROR_COMMAND_SYNTAX_ERROR
;
2432 va
= strtoul(args
[0], NULL
, 0);
2434 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2435 if (retval
== ERROR_OK
)
2437 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2441 /* lower levels will have logged a detailed error which is
2442 * forwarded to telnet/GDB session.
2447 static void writeLong(FILE *f
, int l
)
2452 char c
=(l
>>(i
*8))&0xff;
2453 fwrite(&c
, 1, 1, f
);
2457 static void writeString(FILE *f
, char *s
)
2459 fwrite(s
, 1, strlen(s
), f
);
2464 // Dump a gmon.out histogram file.
2465 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2468 FILE *f
=fopen(filename
, "w");
2471 fwrite("gmon", 1, 4, f
);
2472 writeLong(f
, 0x00000001); // Version
2473 writeLong(f
, 0); // padding
2474 writeLong(f
, 0); // padding
2475 writeLong(f
, 0); // padding
2477 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2479 // figure out bucket size
2482 for (i
=0; i
<sampleNum
; i
++)
2494 int addressSpace
=(max
-min
+1);
2496 static int const maxBuckets
=256*1024; // maximum buckets.
2497 int length
=addressSpace
;
2498 if (length
> maxBuckets
)
2502 int *buckets
=malloc(sizeof(int)*length
);
2508 memset(buckets
, 0, sizeof(int)*length
);
2509 for (i
=0; i
<sampleNum
;i
++)
2511 u32 address
=samples
[i
];
2512 long long a
=address
-min
;
2513 long long b
=length
-1;
2514 long long c
=addressSpace
-1;
2515 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2519 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2520 writeLong(f
, min
); // low_pc
2521 writeLong(f
, max
); // high_pc
2522 writeLong(f
, length
); // # of samples
2523 writeLong(f
, 64000000); // 64MHz
2524 writeString(f
, "seconds");
2525 for (i
=0; i
<(15-strlen("seconds")); i
++)
2527 fwrite("", 1, 1, f
); // padding
2529 writeString(f
, "s");
2531 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2533 char *data
=malloc(2*length
);
2536 for (i
=0; i
<length
;i
++)
2545 data
[i
*2+1]=(val
>>8)&0xff;
2548 fwrite(data
, 1, length
*2, f
);
2558 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2559 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2561 target_t
*target
= get_current_target(cmd_ctx
);
2562 struct timeval timeout
, now
;
2564 gettimeofday(&timeout
, NULL
);
2567 return ERROR_COMMAND_SYNTAX_ERROR
;
2570 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2576 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2578 static const int maxSample
=10000;
2579 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2584 int retval
=ERROR_OK
;
2585 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2586 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2590 target_poll(target
);
2591 if (target
->state
== TARGET_HALTED
)
2593 u32 t
=*((u32
*)reg
->value
);
2594 samples
[numSamples
++]=t
;
2595 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2596 target_poll(target
);
2597 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2598 } else if (target
->state
== TARGET_RUNNING
)
2600 // We want to quickly sample the PC.
2601 target_halt(target
);
2604 command_print(cmd_ctx
, "Target not halted or running");
2608 if (retval
!=ERROR_OK
)
2613 gettimeofday(&now
, NULL
);
2614 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2616 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2617 target_poll(target
);
2618 if (target
->state
== TARGET_HALTED
)
2620 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2622 target_poll(target
);
2623 writeGmon(samples
, numSamples
, args
[1]);
2624 command_print(cmd_ctx
, "Wrote %s", args
[1]);