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
);
53 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
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
)
224 struct command_context_s
*cmd_ctx
= priv
;
226 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
228 target_unregister_event_callback(target_init_handler
, priv
);
230 script
= open_file_from_path(target
->reset_script
, "r");
233 LOG_ERROR("couldn't open script file %s", target
->reset_script
);
237 LOG_INFO("executing reset script '%s'", target
->reset_script
);
238 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
241 jtag_execute_queue();
247 int target_run_and_halt_handler(void *priv
)
249 target_t
*target
= priv
;
256 int target_poll(struct target_s
*target
)
258 /* We can't poll until after examine */
259 if (!target
->type
->examined
)
261 /* Fail silently lest we pollute the log */
264 return target
->type
->poll(target
);
267 int target_halt(struct target_s
*target
)
269 /* We can't poll until after examine */
270 if (!target
->type
->examined
)
272 LOG_ERROR("Target not examined yet");
275 return target
->type
->halt(target
);
278 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
280 /* We can't poll until after examine */
281 if (!target
->type
->examined
)
283 LOG_ERROR("Target not examined yet");
286 return target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
);
290 int target_process_reset(struct command_context_s
*cmd_ctx
)
292 int retval
= ERROR_OK
;
294 struct timeval timeout
, now
;
296 jtag
->speed(jtag_speed
);
298 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
301 /* First time this is executed after launching OpenOCD, it will read out
302 * the type of CPU, etc. and init Embedded ICE registers in host
305 * It will also set up ICE registers in the target.
307 * However, if we assert TRST later, we need to set up the registers again.
309 * For the "reset halt/init" case we must only set up the registers here.
311 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
314 /* prepare reset_halt where necessary */
318 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
320 switch (target
->reset_mode
)
323 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
324 target
->reset_mode
= RESET_RUN_AND_HALT
;
327 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
328 target
->reset_mode
= RESET_RUN_AND_INIT
;
334 target
= target
->next
;
340 /* we have no idea what state the target is in, so we
341 * have to drop working areas
343 target_free_all_working_areas_restore(target
, 0);
344 target
->type
->assert_reset(target
);
345 target
= target
->next
;
347 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
349 LOG_WARNING("JTAG communication failed asserting reset.");
353 /* request target halt if necessary, and schedule further action */
357 switch (target
->reset_mode
)
360 /* nothing to do if target just wants to be run */
362 case RESET_RUN_AND_HALT
:
364 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
366 case RESET_RUN_AND_INIT
:
368 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
369 target_register_event_callback(target_init_handler
, cmd_ctx
);
376 target_register_event_callback(target_init_handler
, cmd_ctx
);
379 LOG_ERROR("BUG: unknown target->reset_mode");
381 target
= target
->next
;
384 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
386 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
393 target
->type
->deassert_reset(target
);
394 target
= target
->next
;
397 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
399 LOG_WARNING("JTAG communication failed while deasserting reset.");
403 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
405 /* If TRST was asserted we need to set up registers again */
406 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
411 LOG_DEBUG("Waiting for halted stated as approperiate");
413 /* Wait for reset to complete, maximum 5 seconds. */
414 gettimeofday(&timeout
, NULL
);
415 timeval_add_time(&timeout
, 5, 0);
418 gettimeofday(&now
, NULL
);
420 target_call_timer_callbacks_now();
425 LOG_DEBUG("Polling target");
427 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
428 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
429 (target
->reset_mode
== RESET_HALT
) ||
430 (target
->reset_mode
== RESET_INIT
))
432 if (target
->state
!= TARGET_HALTED
)
434 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
436 LOG_USER("Timed out waiting for halt after reset");
439 /* this will send alive messages on e.g. GDB remote protocol. */
441 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
445 target
= target
->next
;
447 /* All targets we're waiting for are halted */
455 /* We want any events to be processed before the prompt */
456 target_call_timer_callbacks_now();
458 /* if we timed out we need to unregister these handlers */
462 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
463 target
= target
->next
;
465 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
468 jtag
->speed(jtag_speed_post_reset
);
473 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
479 static int default_mmu(struct target_s
*target
, int *enabled
)
485 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
487 target
->type
->examined
= 1;
492 /* Targets that correctly implement init+examine, i.e.
493 * no communication with target during init:
497 int target_examine(struct command_context_s
*cmd_ctx
)
499 int retval
= ERROR_OK
;
500 target_t
*target
= targets
;
503 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
505 target
= target
->next
;
510 static int target_write_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
->write_memory_imp(target
, address
, size
, count
, buffer
);
520 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
522 if (!target
->type
->examined
)
524 LOG_ERROR("Target not examined yet");
527 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
530 static int target_soft_reset_halt_imp(struct target_s
*target
)
532 if (!target
->type
->examined
)
534 LOG_ERROR("Target not examined yet");
537 return target
->type
->soft_reset_halt_imp(target
);
540 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
)
542 if (!target
->type
->examined
)
544 LOG_ERROR("Target not examined yet");
547 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
);
550 int target_init(struct command_context_s
*cmd_ctx
)
552 target_t
*target
= targets
;
556 target
->type
->examined
= 0;
557 if (target
->type
->examine
== NULL
)
559 target
->type
->examine
= default_examine
;
562 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
564 LOG_ERROR("target '%s' init failed", target
->type
->name
);
568 /* Set up default functions if none are provided by target */
569 if (target
->type
->virt2phys
== NULL
)
571 target
->type
->virt2phys
= default_virt2phys
;
573 target
->type
->virt2phys
= default_virt2phys
;
574 /* a non-invasive way(in terms of patches) to add some code that
575 * runs before the type->write/read_memory implementation
577 target
->type
->write_memory_imp
= target
->type
->write_memory
;
578 target
->type
->write_memory
= target_write_memory_imp
;
579 target
->type
->read_memory_imp
= target
->type
->read_memory
;
580 target
->type
->read_memory
= target_read_memory_imp
;
581 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
582 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
583 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
584 target
->type
->run_algorithm
= target_run_algorithm_imp
;
587 if (target
->type
->mmu
== NULL
)
589 target
->type
->mmu
= default_mmu
;
591 target
= target
->next
;
596 target_register_user_commands(cmd_ctx
);
597 target_register_timer_callback(handle_target
, 100, 1, NULL
);
603 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
605 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
607 if (callback
== NULL
)
609 return ERROR_INVALID_ARGUMENTS
;
614 while ((*callbacks_p
)->next
)
615 callbacks_p
= &((*callbacks_p
)->next
);
616 callbacks_p
= &((*callbacks_p
)->next
);
619 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
620 (*callbacks_p
)->callback
= callback
;
621 (*callbacks_p
)->priv
= priv
;
622 (*callbacks_p
)->next
= NULL
;
627 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
629 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
632 if (callback
== NULL
)
634 return ERROR_INVALID_ARGUMENTS
;
639 while ((*callbacks_p
)->next
)
640 callbacks_p
= &((*callbacks_p
)->next
);
641 callbacks_p
= &((*callbacks_p
)->next
);
644 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
645 (*callbacks_p
)->callback
= callback
;
646 (*callbacks_p
)->periodic
= periodic
;
647 (*callbacks_p
)->time_ms
= time_ms
;
649 gettimeofday(&now
, NULL
);
650 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
651 time_ms
-= (time_ms
% 1000);
652 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
653 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
655 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
656 (*callbacks_p
)->when
.tv_sec
+= 1;
659 (*callbacks_p
)->priv
= priv
;
660 (*callbacks_p
)->next
= NULL
;
665 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
667 target_event_callback_t
**p
= &target_event_callbacks
;
668 target_event_callback_t
*c
= target_event_callbacks
;
670 if (callback
== NULL
)
672 return ERROR_INVALID_ARGUMENTS
;
677 target_event_callback_t
*next
= c
->next
;
678 if ((c
->callback
== callback
) && (c
->priv
== priv
))
692 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
694 target_timer_callback_t
**p
= &target_timer_callbacks
;
695 target_timer_callback_t
*c
= target_timer_callbacks
;
697 if (callback
== NULL
)
699 return ERROR_INVALID_ARGUMENTS
;
704 target_timer_callback_t
*next
= c
->next
;
705 if ((c
->callback
== callback
) && (c
->priv
== priv
))
719 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
721 target_event_callback_t
*callback
= target_event_callbacks
;
722 target_event_callback_t
*next_callback
;
724 LOG_DEBUG("target event %i", event
);
728 next_callback
= callback
->next
;
729 callback
->callback(target
, event
, callback
->priv
);
730 callback
= next_callback
;
736 static int target_call_timer_callbacks_check_time(int checktime
)
738 target_timer_callback_t
*callback
= target_timer_callbacks
;
739 target_timer_callback_t
*next_callback
;
742 gettimeofday(&now
, NULL
);
746 next_callback
= callback
->next
;
748 if ((!checktime
&&callback
->periodic
)||
749 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
750 || (now
.tv_sec
> callback
->when
.tv_sec
)))
752 if(callback
->callback
!= NULL
)
754 callback
->callback(callback
->priv
);
755 if (callback
->periodic
)
757 int time_ms
= callback
->time_ms
;
758 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
759 time_ms
-= (time_ms
% 1000);
760 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
761 if (callback
->when
.tv_usec
> 1000000)
763 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
764 callback
->when
.tv_sec
+= 1;
768 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
772 callback
= next_callback
;
778 int target_call_timer_callbacks()
780 return target_call_timer_callbacks_check_time(1);
783 /* invoke periodic callbacks immediately */
784 int target_call_timer_callbacks_now()
786 return target_call_timer_callbacks(0);
790 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
792 working_area_t
*c
= target
->working_areas
;
793 working_area_t
*new_wa
= NULL
;
795 /* Reevaluate working area address based on MMU state*/
796 if (target
->working_areas
== NULL
)
800 retval
= target
->type
->mmu(target
, &enabled
);
801 if (retval
!= ERROR_OK
)
807 target
->working_area
= target
->working_area_virt
;
811 target
->working_area
= target
->working_area_phys
;
815 /* only allocate multiples of 4 byte */
818 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
819 size
= CEIL(size
, 4);
822 /* see if there's already a matching working area */
825 if ((c
->free
) && (c
->size
== size
))
833 /* if not, allocate a new one */
836 working_area_t
**p
= &target
->working_areas
;
837 u32 first_free
= target
->working_area
;
838 u32 free_size
= target
->working_area_size
;
840 LOG_DEBUG("allocating new working area");
842 c
= target
->working_areas
;
845 first_free
+= c
->size
;
846 free_size
-= c
->size
;
851 if (free_size
< size
)
853 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
854 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
857 new_wa
= malloc(sizeof(working_area_t
));
860 new_wa
->address
= first_free
;
862 if (target
->backup_working_area
)
864 new_wa
->backup
= malloc(new_wa
->size
);
865 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
869 new_wa
->backup
= NULL
;
872 /* put new entry in list */
876 /* mark as used, and return the new (reused) area */
886 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
891 if (restore
&&target
->backup_working_area
)
892 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
896 /* mark user pointer invalid */
903 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
905 return target_free_working_area_restore(target
, area
, 1);
908 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
910 working_area_t
*c
= target
->working_areas
;
914 working_area_t
*next
= c
->next
;
915 target_free_working_area_restore(target
, c
, restore
);
925 target
->working_areas
= NULL
;
930 int target_free_all_working_areas(struct target_s
*target
)
932 return target_free_all_working_areas_restore(target
, 1);
935 int target_register_commands(struct command_context_s
*cmd_ctx
)
937 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
938 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
939 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
940 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
941 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
942 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
943 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
948 int target_arch_state(struct target_s
*target
)
953 LOG_USER("No target has been configured");
957 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
959 if (target
->state
!=TARGET_HALTED
)
962 retval
=target
->type
->arch_state(target
);
966 /* Single aligned words are guaranteed to use 16 or 32 bit access
967 * mode respectively, otherwise data is handled as quickly as
970 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
973 if (!target
->type
->examined
)
975 LOG_ERROR("Target not examined yet");
979 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
981 if (((address
% 2) == 0) && (size
== 2))
983 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
986 /* handle unaligned head bytes */
989 int unaligned
= 4 - (address
% 4);
991 if (unaligned
> size
)
994 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
998 address
+= unaligned
;
1002 /* handle aligned words */
1005 int aligned
= size
- (size
% 4);
1007 /* use bulk writes above a certain limit. This may have to be changed */
1010 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1015 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1024 /* handle tail writes of less than 4 bytes */
1027 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1035 /* Single aligned words are guaranteed to use 16 or 32 bit access
1036 * mode respectively, otherwise data is handled as quickly as
1039 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1042 if (!target
->type
->examined
)
1044 LOG_ERROR("Target not examined yet");
1048 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1050 if (((address
% 2) == 0) && (size
== 2))
1052 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1055 /* handle unaligned head bytes */
1058 int unaligned
= 4 - (address
% 4);
1060 if (unaligned
> size
)
1063 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1066 buffer
+= unaligned
;
1067 address
+= unaligned
;
1071 /* handle aligned words */
1074 int aligned
= size
- (size
% 4);
1076 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1084 /* handle tail writes of less than 4 bytes */
1087 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1094 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1100 if (!target
->type
->examined
)
1102 LOG_ERROR("Target not examined yet");
1106 if ((retval
= target
->type
->checksum_memory(target
, address
,
1107 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1109 buffer
= malloc(size
);
1112 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1113 return ERROR_INVALID_ARGUMENTS
;
1115 retval
= target_read_buffer(target
, address
, size
, buffer
);
1116 if (retval
!= ERROR_OK
)
1122 /* convert to target endianess */
1123 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1126 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1127 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1130 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1139 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1142 if (!target
->type
->examined
)
1144 LOG_ERROR("Target not examined yet");
1148 if (target
->type
->blank_check_memory
== 0)
1149 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1151 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1156 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1159 if (!target
->type
->examined
)
1161 LOG_ERROR("Target not examined yet");
1165 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1167 if (retval
== ERROR_OK
)
1169 *value
= target_buffer_get_u32(target
, value_buf
);
1170 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1175 LOG_DEBUG("address: 0x%8.8x failed", address
);
1181 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1184 if (!target
->type
->examined
)
1186 LOG_ERROR("Target not examined yet");
1190 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1192 if (retval
== ERROR_OK
)
1194 *value
= target_buffer_get_u16(target
, value_buf
);
1195 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1200 LOG_DEBUG("address: 0x%8.8x failed", address
);
1206 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1208 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1209 if (!target
->type
->examined
)
1211 LOG_ERROR("Target not examined yet");
1215 if (retval
== ERROR_OK
)
1217 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1222 LOG_DEBUG("address: 0x%8.8x failed", address
);
1228 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1232 if (!target
->type
->examined
)
1234 LOG_ERROR("Target not examined yet");
1238 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1240 target_buffer_set_u32(target
, value_buf
, value
);
1241 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1243 LOG_DEBUG("failed: %i", retval
);
1249 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1253 if (!target
->type
->examined
)
1255 LOG_ERROR("Target not examined yet");
1259 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1261 target_buffer_set_u16(target
, value_buf
, value
);
1262 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1264 LOG_DEBUG("failed: %i", retval
);
1270 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1273 if (!target
->type
->examined
)
1275 LOG_ERROR("Target not examined yet");
1279 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1281 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1283 LOG_DEBUG("failed: %i", retval
);
1289 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1291 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1292 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1293 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1294 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1295 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1296 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1297 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1298 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1300 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1301 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1302 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1304 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1305 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1306 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1308 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1309 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1310 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1311 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1313 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1314 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1315 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1316 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1317 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1319 target_request_register_commands(cmd_ctx
);
1320 trace_register_commands(cmd_ctx
);
1325 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1327 target_t
*target
= targets
;
1332 int num
= strtoul(args
[0], NULL
, 0);
1337 target
= target
->next
;
1341 cmd_ctx
->current_target
= num
;
1343 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1350 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1351 target
= target
->next
;
1357 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1364 return ERROR_COMMAND_SYNTAX_ERROR
;
1367 /* search for the specified target */
1368 if (args
[0] && (args
[0][0] != 0))
1370 for (i
= 0; target_types
[i
]; i
++)
1372 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1374 target_t
**last_target_p
= &targets
;
1376 /* register target specific commands */
1377 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1379 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1385 while ((*last_target_p
)->next
)
1386 last_target_p
= &((*last_target_p
)->next
);
1387 last_target_p
= &((*last_target_p
)->next
);
1390 *last_target_p
= malloc(sizeof(target_t
));
1392 (*last_target_p
)->type
= target_types
[i
];
1394 if (strcmp(args
[1], "big") == 0)
1395 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1396 else if (strcmp(args
[1], "little") == 0)
1397 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1400 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1401 return ERROR_COMMAND_SYNTAX_ERROR
;
1404 /* what to do on a target reset */
1405 (*last_target_p
)->reset_mode
= RESET_INIT
; /* default */
1406 if (strcmp(args
[2], "reset_halt") == 0)
1407 (*last_target_p
)->reset_mode
= RESET_HALT
;
1408 else if (strcmp(args
[2], "reset_run") == 0)
1409 (*last_target_p
)->reset_mode
= RESET_RUN
;
1410 else if (strcmp(args
[2], "reset_init") == 0)
1411 (*last_target_p
)->reset_mode
= RESET_INIT
;
1412 else if (strcmp(args
[2], "run_and_halt") == 0)
1413 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1414 else if (strcmp(args
[2], "run_and_init") == 0)
1415 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1418 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1422 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1424 (*last_target_p
)->reset_script
= NULL
;
1425 (*last_target_p
)->post_halt_script
= NULL
;
1426 (*last_target_p
)->pre_resume_script
= NULL
;
1427 (*last_target_p
)->gdb_program_script
= NULL
;
1429 (*last_target_p
)->working_area
= 0x0;
1430 (*last_target_p
)->working_area_size
= 0x0;
1431 (*last_target_p
)->working_areas
= NULL
;
1432 (*last_target_p
)->backup_working_area
= 0;
1434 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1435 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1436 (*last_target_p
)->reg_cache
= NULL
;
1437 (*last_target_p
)->breakpoints
= NULL
;
1438 (*last_target_p
)->watchpoints
= NULL
;
1439 (*last_target_p
)->next
= NULL
;
1440 (*last_target_p
)->arch_info
= NULL
;
1442 /* initialize trace information */
1443 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1444 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1445 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1446 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1447 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1448 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1449 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1450 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1452 (*last_target_p
)->dbgmsg
= NULL
;
1453 (*last_target_p
)->dbg_msg_enabled
= 0;
1455 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1463 /* no matching target found */
1466 LOG_ERROR("target '%s' not found", args
[0]);
1467 return ERROR_COMMAND_SYNTAX_ERROR
;
1473 /* usage: target_script <target#> <event> <script_file> */
1474 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1476 target_t
*target
= NULL
;
1480 LOG_ERROR("incomplete target_script command");
1481 return ERROR_COMMAND_SYNTAX_ERROR
;
1484 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1488 return ERROR_COMMAND_SYNTAX_ERROR
;
1491 if (strcmp(args
[1], "reset") == 0)
1493 if (target
->reset_script
)
1494 free(target
->reset_script
);
1495 target
->reset_script
= strdup(args
[2]);
1497 else if (strcmp(args
[1], "post_halt") == 0)
1499 if (target
->post_halt_script
)
1500 free(target
->post_halt_script
);
1501 target
->post_halt_script
= strdup(args
[2]);
1503 else if (strcmp(args
[1], "pre_resume") == 0)
1505 if (target
->pre_resume_script
)
1506 free(target
->pre_resume_script
);
1507 target
->pre_resume_script
= strdup(args
[2]);
1509 else if (strcmp(args
[1], "gdb_program_config") == 0)
1511 if (target
->gdb_program_script
)
1512 free(target
->gdb_program_script
);
1513 target
->gdb_program_script
= strdup(args
[2]);
1517 LOG_ERROR("unknown event type: '%s", args
[1]);
1518 return ERROR_COMMAND_SYNTAX_ERROR
;
1524 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1526 target_t
*target
= NULL
;
1530 return ERROR_COMMAND_SYNTAX_ERROR
;
1533 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1536 return ERROR_COMMAND_SYNTAX_ERROR
;
1539 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1544 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1546 target_t
*target
= NULL
;
1548 if ((argc
< 4) || (argc
> 5))
1550 return ERROR_COMMAND_SYNTAX_ERROR
;
1553 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1556 return ERROR_COMMAND_SYNTAX_ERROR
;
1558 target_free_all_working_areas(target
);
1560 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1563 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1565 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1567 if (strcmp(args
[3], "backup") == 0)
1569 target
->backup_working_area
= 1;
1571 else if (strcmp(args
[3], "nobackup") == 0)
1573 target
->backup_working_area
= 0;
1577 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1578 return ERROR_COMMAND_SYNTAX_ERROR
;
1585 /* process target state changes */
1586 int handle_target(void *priv
)
1588 target_t
*target
= targets
;
1592 if (target_continous_poll
)
1594 /* polling may fail silently until the target has been examined */
1595 target_poll(target
);
1598 target
= target
->next
;
1604 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1613 target
= get_current_target(cmd_ctx
);
1615 /* list all available registers for the current target */
1618 reg_cache_t
*cache
= target
->reg_cache
;
1624 for (i
= 0; i
< cache
->num_regs
; i
++)
1626 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1627 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
);
1630 cache
= cache
->next
;
1636 /* access a single register by its ordinal number */
1637 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1639 int num
= strtoul(args
[0], NULL
, 0);
1640 reg_cache_t
*cache
= target
->reg_cache
;
1646 for (i
= 0; i
< cache
->num_regs
; i
++)
1650 reg
= &cache
->reg_list
[i
];
1656 cache
= cache
->next
;
1661 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1664 } else /* access a single register by its name */
1666 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1670 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1675 /* display a register */
1676 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1678 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1681 if (reg
->valid
== 0)
1683 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1684 if (arch_type
== NULL
)
1686 LOG_ERROR("BUG: encountered unregistered arch type");
1689 arch_type
->get(reg
);
1691 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1692 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1697 /* set register value */
1700 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1701 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1703 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1704 if (arch_type
== NULL
)
1706 LOG_ERROR("BUG: encountered unregistered arch type");
1710 arch_type
->set(reg
, buf
);
1712 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1713 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1721 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1726 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1728 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1730 target_t
*target
= get_current_target(cmd_ctx
);
1734 target_poll(target
);
1735 target_arch_state(target
);
1739 if (strcmp(args
[0], "on") == 0)
1741 target_continous_poll
= 1;
1743 else if (strcmp(args
[0], "off") == 0)
1745 target_continous_poll
= 0;
1749 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1757 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1765 ms
= strtoul(args
[0], &end
, 0) * 1000;
1768 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1773 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1776 static void target_process_events(struct command_context_s
*cmd_ctx
)
1778 target_t
*target
= get_current_target(cmd_ctx
);
1779 target_poll(target
);
1780 target_call_timer_callbacks_now();
1783 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1786 struct timeval timeout
, now
;
1788 gettimeofday(&timeout
, NULL
);
1789 timeval_add_time(&timeout
, 0, ms
* 1000);
1791 target_t
*target
= get_current_target(cmd_ctx
);
1794 if ((retval
=target_poll(target
))!=ERROR_OK
)
1796 target_call_timer_callbacks_now();
1797 if (target
->state
== state
)
1804 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1807 gettimeofday(&now
, NULL
);
1808 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1810 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1818 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1821 target_t
*target
= get_current_target(cmd_ctx
);
1825 if ((retval
= target_halt(target
)) != ERROR_OK
)
1830 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1834 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1836 target_t
*target
= get_current_target(cmd_ctx
);
1838 LOG_USER("requesting target halt and executing a soft reset");
1840 target
->type
->soft_reset_halt(target
);
1845 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1847 target_t
*target
= get_current_target(cmd_ctx
);
1848 enum target_reset_mode reset_mode
= target
->reset_mode
;
1849 enum target_reset_mode save
= target
->reset_mode
;
1855 if (strcmp("run", args
[0]) == 0)
1856 reset_mode
= RESET_RUN
;
1857 else if (strcmp("halt", args
[0]) == 0)
1858 reset_mode
= RESET_HALT
;
1859 else if (strcmp("init", args
[0]) == 0)
1860 reset_mode
= RESET_INIT
;
1861 else if (strcmp("run_and_halt", args
[0]) == 0)
1863 reset_mode
= RESET_RUN_AND_HALT
;
1866 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1869 else if (strcmp("run_and_init", args
[0]) == 0)
1871 reset_mode
= RESET_RUN_AND_INIT
;
1874 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1879 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1884 /* temporarily modify mode of current reset target */
1885 target
->reset_mode
= reset_mode
;
1887 /* reset *all* targets */
1888 target_process_reset(cmd_ctx
);
1890 /* Restore default reset mode for this target */
1891 target
->reset_mode
= save
;
1896 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1899 target_t
*target
= get_current_target(cmd_ctx
);
1902 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1904 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1907 return ERROR_COMMAND_SYNTAX_ERROR
;
1910 target_process_events(cmd_ctx
);
1915 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1917 target_t
*target
= get_current_target(cmd_ctx
);
1922 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1925 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1930 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1932 const int line_bytecnt
= 32;
1945 target_t
*target
= get_current_target(cmd_ctx
);
1951 count
= strtoul(args
[1], NULL
, 0);
1953 address
= strtoul(args
[0], NULL
, 0);
1959 size
= 4; line_modulo
= line_bytecnt
/ 4;
1962 size
= 2; line_modulo
= line_bytecnt
/ 2;
1965 size
= 1; line_modulo
= line_bytecnt
/ 1;
1971 buffer
= calloc(count
, size
);
1972 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1973 if (retval
== ERROR_OK
)
1977 for (i
= 0; i
< count
; i
++)
1979 if (i
%line_modulo
== 0)
1980 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1985 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1988 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1991 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1995 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1997 command_print(cmd_ctx
, output
);
2003 LOG_ERROR("Failure examining memory");
2011 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2018 target_t
*target
= get_current_target(cmd_ctx
);
2021 if ((argc
< 2) || (argc
> 3))
2022 return ERROR_COMMAND_SYNTAX_ERROR
;
2024 address
= strtoul(args
[0], NULL
, 0);
2025 value
= strtoul(args
[1], NULL
, 0);
2027 count
= strtoul(args
[2], NULL
, 0);
2034 target_buffer_set_u32(target
, value_buf
, value
);
2038 target_buffer_set_u16(target
, value_buf
, value
);
2042 value_buf
[0] = value
;
2045 return ERROR_COMMAND_SYNTAX_ERROR
;
2047 for (i
=0; i
<count
; i
++)
2053 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2056 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2059 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2064 if (retval
!=ERROR_OK
)
2074 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2084 duration_t duration
;
2085 char *duration_text
;
2087 target_t
*target
= get_current_target(cmd_ctx
);
2091 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2095 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2098 image
.base_address_set
= 1;
2099 image
.base_address
= strtoul(args
[1], NULL
, 0);
2103 image
.base_address_set
= 0;
2106 image
.start_address_set
= 0;
2108 duration_start_measure(&duration
);
2110 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2117 for (i
= 0; i
< image
.num_sections
; i
++)
2119 buffer
= malloc(image
.sections
[i
].size
);
2122 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2126 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2131 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2136 image_size
+= buf_cnt
;
2137 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2142 duration_stop_measure(&duration
, &duration_text
);
2143 if (retval
==ERROR_OK
)
2145 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2147 free(duration_text
);
2149 image_close(&image
);
2155 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2162 int retval
=ERROR_OK
;
2164 duration_t duration
;
2165 char *duration_text
;
2167 target_t
*target
= get_current_target(cmd_ctx
);
2171 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2175 address
= strtoul(args
[1], NULL
, 0);
2176 size
= strtoul(args
[2], NULL
, 0);
2178 if ((address
& 3) || (size
& 3))
2180 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2184 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2189 duration_start_measure(&duration
);
2194 u32 this_run_size
= (size
> 560) ? 560 : size
;
2196 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2197 if (retval
!= ERROR_OK
)
2202 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2203 if (retval
!= ERROR_OK
)
2208 size
-= this_run_size
;
2209 address
+= this_run_size
;
2212 fileio_close(&fileio
);
2214 duration_stop_measure(&duration
, &duration_text
);
2215 if (retval
==ERROR_OK
)
2217 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2219 free(duration_text
);
2224 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2232 u32 mem_checksum
= 0;
2236 duration_t duration
;
2237 char *duration_text
;
2239 target_t
*target
= get_current_target(cmd_ctx
);
2243 return ERROR_COMMAND_SYNTAX_ERROR
;
2248 LOG_ERROR("no target selected");
2252 duration_start_measure(&duration
);
2256 image
.base_address_set
= 1;
2257 image
.base_address
= strtoul(args
[1], NULL
, 0);
2261 image
.base_address_set
= 0;
2262 image
.base_address
= 0x0;
2265 image
.start_address_set
= 0;
2267 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2274 for (i
= 0; i
< image
.num_sections
; i
++)
2276 buffer
= malloc(image
.sections
[i
].size
);
2279 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2282 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2288 /* calculate checksum of image */
2289 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2291 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2292 if( retval
!= ERROR_OK
)
2298 if( checksum
!= mem_checksum
)
2300 /* failed crc checksum, fall back to a binary compare */
2303 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2305 data
= (u8
*)malloc(buf_cnt
);
2307 /* Can we use 32bit word accesses? */
2309 int count
= buf_cnt
;
2310 if ((count
% 4) == 0)
2315 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2316 if (retval
== ERROR_OK
)
2319 for (t
= 0; t
< buf_cnt
; t
++)
2321 if (data
[t
] != buffer
[t
])
2323 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
]);
2336 image_size
+= buf_cnt
;
2339 duration_stop_measure(&duration
, &duration_text
);
2340 if (retval
==ERROR_OK
)
2342 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2344 free(duration_text
);
2346 image_close(&image
);
2351 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2354 target_t
*target
= get_current_target(cmd_ctx
);
2358 breakpoint_t
*breakpoint
= target
->breakpoints
;
2362 if (breakpoint
->type
== BKPT_SOFT
)
2364 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2365 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2370 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2372 breakpoint
= breakpoint
->next
;
2380 length
= strtoul(args
[1], NULL
, 0);
2383 if (strcmp(args
[2], "hw") == 0)
2386 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2388 LOG_ERROR("Failure setting breakpoints");
2392 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2397 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2403 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2405 target_t
*target
= get_current_target(cmd_ctx
);
2408 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2413 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2415 target_t
*target
= get_current_target(cmd_ctx
);
2420 watchpoint_t
*watchpoint
= target
->watchpoints
;
2424 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
);
2425 watchpoint
= watchpoint
->next
;
2430 enum watchpoint_rw type
= WPT_ACCESS
;
2431 u32 data_value
= 0x0;
2432 u32 data_mask
= 0xffffffff;
2448 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2454 data_value
= strtoul(args
[3], NULL
, 0);
2458 data_mask
= strtoul(args
[4], NULL
, 0);
2461 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2462 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2464 LOG_ERROR("Failure setting breakpoints");
2469 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2475 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2477 target_t
*target
= get_current_target(cmd_ctx
);
2480 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2485 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2488 target_t
*target
= get_current_target(cmd_ctx
);
2494 return ERROR_COMMAND_SYNTAX_ERROR
;
2496 va
= strtoul(args
[0], NULL
, 0);
2498 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2499 if (retval
== ERROR_OK
)
2501 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2505 /* lower levels will have logged a detailed error which is
2506 * forwarded to telnet/GDB session.
2511 static void writeLong(FILE *f
, int l
)
2516 char c
=(l
>>(i
*8))&0xff;
2517 fwrite(&c
, 1, 1, f
);
2521 static void writeString(FILE *f
, char *s
)
2523 fwrite(s
, 1, strlen(s
), f
);
2528 // Dump a gmon.out histogram file.
2529 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2532 FILE *f
=fopen(filename
, "w");
2535 fwrite("gmon", 1, 4, f
);
2536 writeLong(f
, 0x00000001); // Version
2537 writeLong(f
, 0); // padding
2538 writeLong(f
, 0); // padding
2539 writeLong(f
, 0); // padding
2541 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2543 // figure out bucket size
2546 for (i
=0; i
<sampleNum
; i
++)
2558 int addressSpace
=(max
-min
+1);
2560 static int const maxBuckets
=256*1024; // maximum buckets.
2561 int length
=addressSpace
;
2562 if (length
> maxBuckets
)
2566 int *buckets
=malloc(sizeof(int)*length
);
2572 memset(buckets
, 0, sizeof(int)*length
);
2573 for (i
=0; i
<sampleNum
;i
++)
2575 u32 address
=samples
[i
];
2576 long long a
=address
-min
;
2577 long long b
=length
-1;
2578 long long c
=addressSpace
-1;
2579 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2583 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2584 writeLong(f
, min
); // low_pc
2585 writeLong(f
, max
); // high_pc
2586 writeLong(f
, length
); // # of samples
2587 writeLong(f
, 64000000); // 64MHz
2588 writeString(f
, "seconds");
2589 for (i
=0; i
<(15-strlen("seconds")); i
++)
2591 fwrite("", 1, 1, f
); // padding
2593 writeString(f
, "s");
2595 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2597 char *data
=malloc(2*length
);
2600 for (i
=0; i
<length
;i
++)
2609 data
[i
*2+1]=(val
>>8)&0xff;
2612 fwrite(data
, 1, length
*2, f
);
2622 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2623 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2625 target_t
*target
= get_current_target(cmd_ctx
);
2626 struct timeval timeout
, now
;
2628 gettimeofday(&timeout
, NULL
);
2631 return ERROR_COMMAND_SYNTAX_ERROR
;
2634 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2640 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2642 static const int maxSample
=10000;
2643 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2648 int retval
=ERROR_OK
;
2649 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2650 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2654 target_poll(target
);
2655 if (target
->state
== TARGET_HALTED
)
2657 u32 t
=*((u32
*)reg
->value
);
2658 samples
[numSamples
++]=t
;
2659 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2660 target_poll(target
);
2661 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2662 } else if (target
->state
== TARGET_RUNNING
)
2664 // We want to quickly sample the PC.
2665 target_halt(target
);
2668 command_print(cmd_ctx
, "Target not halted or running");
2672 if (retval
!=ERROR_OK
)
2677 gettimeofday(&now
, NULL
);
2678 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2680 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2681 target_poll(target
);
2682 if (target
->state
== TARGET_HALTED
)
2684 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2686 target_poll(target
);
2687 writeGmon(samples
, numSamples
, args
[1]);
2688 command_print(cmd_ctx
, "Wrote %s", args
[1]);
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)