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_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
81 extern target_type_t arm7tdmi_target
;
82 extern target_type_t arm720t_target
;
83 extern target_type_t arm9tdmi_target
;
84 extern target_type_t arm920t_target
;
85 extern target_type_t arm966e_target
;
86 extern target_type_t arm926ejs_target
;
87 extern target_type_t feroceon_target
;
88 extern target_type_t xscale_target
;
89 extern target_type_t cortexm3_target
;
90 extern target_type_t arm11_target
;
92 target_type_t
*target_types
[] =
107 target_t
*targets
= NULL
;
108 target_event_callback_t
*target_event_callbacks
= NULL
;
109 target_timer_callback_t
*target_timer_callbacks
= NULL
;
111 char *target_state_strings
[] =
120 char *target_debug_reason_strings
[] =
122 "debug request", "breakpoint", "watchpoint",
123 "watchpoint and breakpoint", "single step",
124 "target not halted", "undefined"
127 char *target_endianess_strings
[] =
133 static int target_continous_poll
= 1;
135 /* read a u32 from a buffer in target memory endianness */
136 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
138 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
139 return le_to_h_u32(buffer
);
141 return be_to_h_u32(buffer
);
144 /* read a u16 from a buffer in target memory endianness */
145 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
147 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
148 return le_to_h_u16(buffer
);
150 return be_to_h_u16(buffer
);
153 /* write a u32 to a buffer in target memory endianness */
154 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
156 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
157 h_u32_to_le(buffer
, value
);
159 h_u32_to_be(buffer
, value
);
162 /* write a u16 to a buffer in target memory endianness */
163 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
165 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
166 h_u16_to_le(buffer
, value
);
168 h_u16_to_be(buffer
, value
);
171 /* returns a pointer to the n-th configured target */
172 target_t
* get_target_by_num(int num
)
174 target_t
*target
= targets
;
181 target
= target
->next
;
188 int get_num_by_target(target_t
*query_target
)
190 target_t
*target
= targets
;
195 if (target
== query_target
)
197 target
= target
->next
;
204 target_t
* get_current_target(command_context_t
*cmd_ctx
)
206 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
210 LOG_ERROR("BUG: current_target out of bounds");
217 /* Process target initialization, when target entered debug out of reset
218 * the handler is unregistered at the end of this function, so it's only called once
220 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
222 struct command_context_s
*cmd_ctx
= priv
;
224 if (event
== TARGET_EVENT_HALTED
)
226 target_unregister_event_callback(target_init_handler
, priv
);
227 target_invoke_script(cmd_ctx
, target
, "post_reset");
228 jtag_execute_queue();
234 int target_run_and_halt_handler(void *priv
)
236 target_t
*target
= priv
;
243 int target_poll(struct target_s
*target
)
245 /* We can't poll until after examine */
246 if (!target
->type
->examined
)
248 /* Fail silently lest we pollute the log */
251 return target
->type
->poll(target
);
254 int target_halt(struct target_s
*target
)
256 /* We can't poll until after examine */
257 if (!target
->type
->examined
)
259 LOG_ERROR("Target not examined yet");
262 return target
->type
->halt(target
);
265 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
268 int timeout_ms
= 5000;
270 /* We can't poll until after examine */
271 if (!target
->type
->examined
)
273 LOG_ERROR("Target not examined yet");
277 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
280 /* only check for resume event if normal resume */
281 if (!debug_execution
)
283 /* wait for target to exit halted mode - not debug resume*/
286 while (target
->state
!= TARGET_RUNNING
)
290 if ((timeout_ms
-= 10) <= 0)
292 LOG_ERROR("timeout waiting for target resume");
293 return ERROR_TARGET_TIMEOUT
;
301 int target_process_reset(struct command_context_s
*cmd_ctx
)
303 int retval
= ERROR_OK
;
305 struct timeval timeout
, now
;
307 jtag
->speed(jtag_speed
);
312 target_invoke_script(cmd_ctx
, target
, "pre_reset");
313 target
= target
->next
;
316 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
319 /* First time this is executed after launching OpenOCD, it will read out
320 * the type of CPU, etc. and init Embedded ICE registers in host
323 * It will also set up ICE registers in the target.
325 * However, if we assert TRST later, we need to set up the registers again.
327 * For the "reset halt/init" case we must only set up the registers here.
329 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
332 /* prepare reset_halt where necessary */
336 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
338 switch (target
->reset_mode
)
341 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
342 target
->reset_mode
= RESET_RUN_AND_HALT
;
345 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
346 target
->reset_mode
= RESET_RUN_AND_INIT
;
352 target
= target
->next
;
358 /* we have no idea what state the target is in, so we
359 * have to drop working areas
361 target_free_all_working_areas_restore(target
, 0);
362 target
->type
->assert_reset(target
);
363 target
= target
->next
;
365 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
367 LOG_WARNING("JTAG communication failed asserting reset.");
371 /* request target halt if necessary, and schedule further action */
375 switch (target
->reset_mode
)
378 /* nothing to do if target just wants to be run */
380 case RESET_RUN_AND_HALT
:
382 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
384 case RESET_RUN_AND_INIT
:
386 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
387 target_register_event_callback(target_init_handler
, cmd_ctx
);
394 target_register_event_callback(target_init_handler
, cmd_ctx
);
397 LOG_ERROR("BUG: unknown target->reset_mode");
399 target
= target
->next
;
402 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
404 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
411 target
->type
->deassert_reset(target
);
412 target
= target
->next
;
415 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
417 LOG_WARNING("JTAG communication failed while deasserting reset.");
421 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
423 /* If TRST was asserted we need to set up registers again */
424 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
429 LOG_DEBUG("Waiting for halted stated as approperiate");
431 /* Wait for reset to complete, maximum 5 seconds. */
432 gettimeofday(&timeout
, NULL
);
433 timeval_add_time(&timeout
, 5, 0);
436 gettimeofday(&now
, NULL
);
438 target_call_timer_callbacks_now();
443 LOG_DEBUG("Polling target");
445 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
446 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
447 (target
->reset_mode
== RESET_HALT
) ||
448 (target
->reset_mode
== RESET_INIT
))
450 if (target
->state
!= TARGET_HALTED
)
452 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
454 LOG_USER("Timed out waiting for halt after reset");
457 /* this will send alive messages on e.g. GDB remote protocol. */
459 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
463 target
= target
->next
;
465 /* All targets we're waiting for are halted */
473 /* We want any events to be processed before the prompt */
474 target_call_timer_callbacks_now();
476 /* if we timed out we need to unregister these handlers */
480 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
481 target
= target
->next
;
483 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
485 jtag
->speed(jtag_speed_post_reset
);
490 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
496 static int default_mmu(struct target_s
*target
, int *enabled
)
502 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
504 target
->type
->examined
= 1;
509 /* Targets that correctly implement init+examine, i.e.
510 * no communication with target during init:
514 int target_examine(struct command_context_s
*cmd_ctx
)
516 int retval
= ERROR_OK
;
517 target_t
*target
= targets
;
520 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
522 target
= target
->next
;
527 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
529 if (!target
->type
->examined
)
531 LOG_ERROR("Target not examined yet");
534 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
537 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
539 if (!target
->type
->examined
)
541 LOG_ERROR("Target not examined yet");
544 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
547 static int target_soft_reset_halt_imp(struct target_s
*target
)
549 if (!target
->type
->examined
)
551 LOG_ERROR("Target not examined yet");
554 return target
->type
->soft_reset_halt_imp(target
);
557 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
)
559 if (!target
->type
->examined
)
561 LOG_ERROR("Target not examined yet");
564 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
);
567 int target_init(struct command_context_s
*cmd_ctx
)
569 target_t
*target
= targets
;
573 target
->type
->examined
= 0;
574 if (target
->type
->examine
== NULL
)
576 target
->type
->examine
= default_examine
;
579 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
581 LOG_ERROR("target '%s' init failed", target
->type
->name
);
585 /* Set up default functions if none are provided by target */
586 if (target
->type
->virt2phys
== NULL
)
588 target
->type
->virt2phys
= default_virt2phys
;
590 target
->type
->virt2phys
= default_virt2phys
;
591 /* a non-invasive way(in terms of patches) to add some code that
592 * runs before the type->write/read_memory implementation
594 target
->type
->write_memory_imp
= target
->type
->write_memory
;
595 target
->type
->write_memory
= target_write_memory_imp
;
596 target
->type
->read_memory_imp
= target
->type
->read_memory
;
597 target
->type
->read_memory
= target_read_memory_imp
;
598 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
599 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
600 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
601 target
->type
->run_algorithm
= target_run_algorithm_imp
;
604 if (target
->type
->mmu
== NULL
)
606 target
->type
->mmu
= default_mmu
;
608 target
= target
->next
;
613 target_register_user_commands(cmd_ctx
);
614 target_register_timer_callback(handle_target
, 100, 1, NULL
);
620 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
622 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
624 if (callback
== NULL
)
626 return ERROR_INVALID_ARGUMENTS
;
631 while ((*callbacks_p
)->next
)
632 callbacks_p
= &((*callbacks_p
)->next
);
633 callbacks_p
= &((*callbacks_p
)->next
);
636 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
637 (*callbacks_p
)->callback
= callback
;
638 (*callbacks_p
)->priv
= priv
;
639 (*callbacks_p
)->next
= NULL
;
644 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
646 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
649 if (callback
== NULL
)
651 return ERROR_INVALID_ARGUMENTS
;
656 while ((*callbacks_p
)->next
)
657 callbacks_p
= &((*callbacks_p
)->next
);
658 callbacks_p
= &((*callbacks_p
)->next
);
661 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
662 (*callbacks_p
)->callback
= callback
;
663 (*callbacks_p
)->periodic
= periodic
;
664 (*callbacks_p
)->time_ms
= time_ms
;
666 gettimeofday(&now
, NULL
);
667 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
668 time_ms
-= (time_ms
% 1000);
669 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
670 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
672 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
673 (*callbacks_p
)->when
.tv_sec
+= 1;
676 (*callbacks_p
)->priv
= priv
;
677 (*callbacks_p
)->next
= NULL
;
682 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
684 target_event_callback_t
**p
= &target_event_callbacks
;
685 target_event_callback_t
*c
= target_event_callbacks
;
687 if (callback
== NULL
)
689 return ERROR_INVALID_ARGUMENTS
;
694 target_event_callback_t
*next
= c
->next
;
695 if ((c
->callback
== callback
) && (c
->priv
== priv
))
709 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
711 target_timer_callback_t
**p
= &target_timer_callbacks
;
712 target_timer_callback_t
*c
= target_timer_callbacks
;
714 if (callback
== NULL
)
716 return ERROR_INVALID_ARGUMENTS
;
721 target_timer_callback_t
*next
= c
->next
;
722 if ((c
->callback
== callback
) && (c
->priv
== priv
))
736 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
738 target_event_callback_t
*callback
= target_event_callbacks
;
739 target_event_callback_t
*next_callback
;
741 LOG_DEBUG("target event %i", event
);
745 next_callback
= callback
->next
;
746 callback
->callback(target
, event
, callback
->priv
);
747 callback
= next_callback
;
753 static int target_call_timer_callbacks_check_time(int checktime
)
755 target_timer_callback_t
*callback
= target_timer_callbacks
;
756 target_timer_callback_t
*next_callback
;
759 gettimeofday(&now
, NULL
);
763 next_callback
= callback
->next
;
765 if ((!checktime
&&callback
->periodic
)||
766 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
767 || (now
.tv_sec
> callback
->when
.tv_sec
)))
769 if(callback
->callback
!= NULL
)
771 callback
->callback(callback
->priv
);
772 if (callback
->periodic
)
774 int time_ms
= callback
->time_ms
;
775 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
776 time_ms
-= (time_ms
% 1000);
777 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
778 if (callback
->when
.tv_usec
> 1000000)
780 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
781 callback
->when
.tv_sec
+= 1;
785 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
789 callback
= next_callback
;
795 int target_call_timer_callbacks()
797 return target_call_timer_callbacks_check_time(1);
800 /* invoke periodic callbacks immediately */
801 int target_call_timer_callbacks_now()
803 return target_call_timer_callbacks(0);
806 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
808 working_area_t
*c
= target
->working_areas
;
809 working_area_t
*new_wa
= NULL
;
811 /* Reevaluate working area address based on MMU state*/
812 if (target
->working_areas
== NULL
)
816 retval
= target
->type
->mmu(target
, &enabled
);
817 if (retval
!= ERROR_OK
)
823 target
->working_area
= target
->working_area_virt
;
827 target
->working_area
= target
->working_area_phys
;
831 /* only allocate multiples of 4 byte */
834 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
835 size
= CEIL(size
, 4);
838 /* see if there's already a matching working area */
841 if ((c
->free
) && (c
->size
== size
))
849 /* if not, allocate a new one */
852 working_area_t
**p
= &target
->working_areas
;
853 u32 first_free
= target
->working_area
;
854 u32 free_size
= target
->working_area_size
;
856 LOG_DEBUG("allocating new working area");
858 c
= target
->working_areas
;
861 first_free
+= c
->size
;
862 free_size
-= c
->size
;
867 if (free_size
< size
)
869 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
870 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
873 new_wa
= malloc(sizeof(working_area_t
));
876 new_wa
->address
= first_free
;
878 if (target
->backup_working_area
)
880 new_wa
->backup
= malloc(new_wa
->size
);
881 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
885 new_wa
->backup
= NULL
;
888 /* put new entry in list */
892 /* mark as used, and return the new (reused) area */
902 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
907 if (restore
&&target
->backup_working_area
)
908 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
912 /* mark user pointer invalid */
919 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
921 return target_free_working_area_restore(target
, area
, 1);
924 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
926 working_area_t
*c
= target
->working_areas
;
930 working_area_t
*next
= c
->next
;
931 target_free_working_area_restore(target
, c
, restore
);
941 target
->working_areas
= NULL
;
946 int target_free_all_working_areas(struct target_s
*target
)
948 return target_free_all_working_areas_restore(target
, 1);
951 int target_register_commands(struct command_context_s
*cmd_ctx
)
953 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
954 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
955 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
,
956 "target_script <target#> <event=reset/pre_reset/post_halt/pre_resume/gdb_program_config> <script_file>");
957 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
958 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
959 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
960 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
965 int target_arch_state(struct target_s
*target
)
970 LOG_USER("No target has been configured");
974 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
976 if (target
->state
!=TARGET_HALTED
)
979 retval
=target
->type
->arch_state(target
);
983 /* Single aligned words are guaranteed to use 16 or 32 bit access
984 * mode respectively, otherwise data is handled as quickly as
987 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
990 if (!target
->type
->examined
)
992 LOG_ERROR("Target not examined yet");
996 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
998 if (((address
% 2) == 0) && (size
== 2))
1000 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
1003 /* handle unaligned head bytes */
1006 int unaligned
= 4 - (address
% 4);
1008 if (unaligned
> size
)
1011 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1014 buffer
+= unaligned
;
1015 address
+= unaligned
;
1019 /* handle aligned words */
1022 int aligned
= size
- (size
% 4);
1024 /* use bulk writes above a certain limit. This may have to be changed */
1027 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1032 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1041 /* handle tail writes of less than 4 bytes */
1044 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1052 /* Single aligned words are guaranteed to use 16 or 32 bit access
1053 * mode respectively, otherwise data is handled as quickly as
1056 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1059 if (!target
->type
->examined
)
1061 LOG_ERROR("Target not examined yet");
1065 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1067 if (((address
% 2) == 0) && (size
== 2))
1069 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1072 /* handle unaligned head bytes */
1075 int unaligned
= 4 - (address
% 4);
1077 if (unaligned
> size
)
1080 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1083 buffer
+= unaligned
;
1084 address
+= unaligned
;
1088 /* handle aligned words */
1091 int aligned
= size
- (size
% 4);
1093 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1101 /* handle tail writes of less than 4 bytes */
1104 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1111 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1117 if (!target
->type
->examined
)
1119 LOG_ERROR("Target not examined yet");
1123 if ((retval
= target
->type
->checksum_memory(target
, address
,
1124 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1126 buffer
= malloc(size
);
1129 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1130 return ERROR_INVALID_ARGUMENTS
;
1132 retval
= target_read_buffer(target
, address
, size
, buffer
);
1133 if (retval
!= ERROR_OK
)
1139 /* convert to target endianess */
1140 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1143 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1144 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1147 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1156 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1159 if (!target
->type
->examined
)
1161 LOG_ERROR("Target not examined yet");
1165 if (target
->type
->blank_check_memory
== 0)
1166 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1168 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1173 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1176 if (!target
->type
->examined
)
1178 LOG_ERROR("Target not examined yet");
1182 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1184 if (retval
== ERROR_OK
)
1186 *value
= target_buffer_get_u32(target
, value_buf
);
1187 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1192 LOG_DEBUG("address: 0x%8.8x failed", address
);
1198 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1201 if (!target
->type
->examined
)
1203 LOG_ERROR("Target not examined yet");
1207 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1209 if (retval
== ERROR_OK
)
1211 *value
= target_buffer_get_u16(target
, value_buf
);
1212 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1217 LOG_DEBUG("address: 0x%8.8x failed", address
);
1223 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1225 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1226 if (!target
->type
->examined
)
1228 LOG_ERROR("Target not examined yet");
1232 if (retval
== ERROR_OK
)
1234 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1239 LOG_DEBUG("address: 0x%8.8x failed", address
);
1245 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1249 if (!target
->type
->examined
)
1251 LOG_ERROR("Target not examined yet");
1255 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1257 target_buffer_set_u32(target
, value_buf
, value
);
1258 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1260 LOG_DEBUG("failed: %i", retval
);
1266 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1270 if (!target
->type
->examined
)
1272 LOG_ERROR("Target not examined yet");
1276 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1278 target_buffer_set_u16(target
, value_buf
, value
);
1279 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1281 LOG_DEBUG("failed: %i", retval
);
1287 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1290 if (!target
->type
->examined
)
1292 LOG_ERROR("Target not examined yet");
1296 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1298 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1300 LOG_DEBUG("failed: %i", retval
);
1306 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1308 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1309 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1310 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1311 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1312 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1313 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1314 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1315 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1317 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1318 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1319 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1321 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1322 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1323 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1325 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1326 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1327 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1328 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1330 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1331 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1332 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1333 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1334 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1336 target_request_register_commands(cmd_ctx
);
1337 trace_register_commands(cmd_ctx
);
1342 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1344 target_t
*target
= targets
;
1349 int num
= strtoul(args
[0], NULL
, 0);
1354 target
= target
->next
;
1358 cmd_ctx
->current_target
= num
;
1360 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1367 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1368 target
= target
->next
;
1374 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1381 return ERROR_COMMAND_SYNTAX_ERROR
;
1384 /* search for the specified target */
1385 if (args
[0] && (args
[0][0] != 0))
1387 for (i
= 0; target_types
[i
]; i
++)
1389 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1391 target_t
**last_target_p
= &targets
;
1393 /* register target specific commands */
1394 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1396 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1402 while ((*last_target_p
)->next
)
1403 last_target_p
= &((*last_target_p
)->next
);
1404 last_target_p
= &((*last_target_p
)->next
);
1407 *last_target_p
= malloc(sizeof(target_t
));
1409 /* allocate memory for each unique target type */
1410 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1411 *((*last_target_p
)->type
) = *target_types
[i
];
1413 if (strcmp(args
[1], "big") == 0)
1414 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1415 else if (strcmp(args
[1], "little") == 0)
1416 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1419 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1420 return ERROR_COMMAND_SYNTAX_ERROR
;
1423 /* what to do on a target reset */
1424 (*last_target_p
)->reset_mode
= RESET_INIT
; /* default */
1425 if (strcmp(args
[2], "reset_halt") == 0)
1426 (*last_target_p
)->reset_mode
= RESET_HALT
;
1427 else if (strcmp(args
[2], "reset_run") == 0)
1428 (*last_target_p
)->reset_mode
= RESET_RUN
;
1429 else if (strcmp(args
[2], "reset_init") == 0)
1430 (*last_target_p
)->reset_mode
= RESET_INIT
;
1431 else if (strcmp(args
[2], "run_and_halt") == 0)
1432 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1433 else if (strcmp(args
[2], "run_and_init") == 0)
1434 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1437 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1441 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1443 (*last_target_p
)->working_area
= 0x0;
1444 (*last_target_p
)->working_area_size
= 0x0;
1445 (*last_target_p
)->working_areas
= NULL
;
1446 (*last_target_p
)->backup_working_area
= 0;
1448 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1449 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1450 (*last_target_p
)->reg_cache
= NULL
;
1451 (*last_target_p
)->breakpoints
= NULL
;
1452 (*last_target_p
)->watchpoints
= NULL
;
1453 (*last_target_p
)->next
= NULL
;
1454 (*last_target_p
)->arch_info
= NULL
;
1456 /* initialize trace information */
1457 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1458 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1459 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1460 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1461 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1462 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1463 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1464 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1466 (*last_target_p
)->dbgmsg
= NULL
;
1467 (*last_target_p
)->dbg_msg_enabled
= 0;
1469 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1477 /* no matching target found */
1480 LOG_ERROR("target '%s' not found", args
[0]);
1481 return ERROR_COMMAND_SYNTAX_ERROR
;
1487 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1489 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
1490 name
, get_num_by_target(target
),
1491 name
, get_num_by_target(target
));
1494 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1496 target_t
*target
= NULL
;
1500 LOG_ERROR("incomplete target_script command");
1501 return ERROR_COMMAND_SYNTAX_ERROR
;
1504 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1508 return ERROR_COMMAND_SYNTAX_ERROR
;
1511 const char *event
=args
[1];
1512 if (strcmp("reset", event
)==0)
1518 /* Define a tcl procedure which we'll invoke upon some event */
1519 command_run_linef(cmd_ctx
,
1520 "proc target_%s_%d {} {"
1521 "openocd {script %s} ; return \"\""
1524 get_num_by_target(target
),
1530 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1532 target_t
*target
= NULL
;
1536 return ERROR_COMMAND_SYNTAX_ERROR
;
1539 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1542 return ERROR_COMMAND_SYNTAX_ERROR
;
1545 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1550 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1552 target_t
*target
= NULL
;
1554 if ((argc
< 4) || (argc
> 5))
1556 return ERROR_COMMAND_SYNTAX_ERROR
;
1559 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1562 return ERROR_COMMAND_SYNTAX_ERROR
;
1564 target_free_all_working_areas(target
);
1566 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1569 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1571 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1573 if (strcmp(args
[3], "backup") == 0)
1575 target
->backup_working_area
= 1;
1577 else if (strcmp(args
[3], "nobackup") == 0)
1579 target
->backup_working_area
= 0;
1583 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1584 return ERROR_COMMAND_SYNTAX_ERROR
;
1591 /* process target state changes */
1592 int handle_target(void *priv
)
1594 target_t
*target
= targets
;
1598 if (target_continous_poll
)
1600 /* polling may fail silently until the target has been examined */
1601 target_poll(target
);
1604 target
= target
->next
;
1610 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1619 target
= get_current_target(cmd_ctx
);
1621 /* list all available registers for the current target */
1624 reg_cache_t
*cache
= target
->reg_cache
;
1630 for (i
= 0; i
< cache
->num_regs
; i
++)
1632 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1633 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
);
1636 cache
= cache
->next
;
1642 /* access a single register by its ordinal number */
1643 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1645 int num
= strtoul(args
[0], NULL
, 0);
1646 reg_cache_t
*cache
= target
->reg_cache
;
1652 for (i
= 0; i
< cache
->num_regs
; i
++)
1656 reg
= &cache
->reg_list
[i
];
1662 cache
= cache
->next
;
1667 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1670 } else /* access a single register by its name */
1672 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1676 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1681 /* display a register */
1682 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1684 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1687 if (reg
->valid
== 0)
1689 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1690 if (arch_type
== NULL
)
1692 LOG_ERROR("BUG: encountered unregistered arch type");
1695 arch_type
->get(reg
);
1697 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1698 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1703 /* set register value */
1706 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1707 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1709 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1710 if (arch_type
== NULL
)
1712 LOG_ERROR("BUG: encountered unregistered arch type");
1716 arch_type
->set(reg
, buf
);
1718 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1719 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1727 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1732 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1734 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1736 target_t
*target
= get_current_target(cmd_ctx
);
1740 target_poll(target
);
1741 target_arch_state(target
);
1745 if (strcmp(args
[0], "on") == 0)
1747 target_continous_poll
= 1;
1749 else if (strcmp(args
[0], "off") == 0)
1751 target_continous_poll
= 0;
1755 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1763 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1771 ms
= strtoul(args
[0], &end
, 0) * 1000;
1774 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1779 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1782 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1785 struct timeval timeout
, now
;
1787 gettimeofday(&timeout
, NULL
);
1788 timeval_add_time(&timeout
, 0, ms
* 1000);
1790 target_t
*target
= get_current_target(cmd_ctx
);
1793 if ((retval
=target_poll(target
))!=ERROR_OK
)
1795 target_call_timer_callbacks_now();
1796 if (target
->state
== state
)
1803 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1806 gettimeofday(&now
, NULL
);
1807 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1809 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1817 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1820 target_t
*target
= get_current_target(cmd_ctx
);
1824 if ((retval
= target_halt(target
)) != ERROR_OK
)
1829 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1832 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1834 target_t
*target
= get_current_target(cmd_ctx
);
1836 LOG_USER("requesting target halt and executing a soft reset");
1838 target
->type
->soft_reset_halt(target
);
1843 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1845 target_t
*target
= get_current_target(cmd_ctx
);
1846 enum target_reset_mode reset_mode
= target
->reset_mode
;
1847 enum target_reset_mode save
= target
->reset_mode
;
1853 if (strcmp("run", args
[0]) == 0)
1854 reset_mode
= RESET_RUN
;
1855 else if (strcmp("halt", args
[0]) == 0)
1856 reset_mode
= RESET_HALT
;
1857 else if (strcmp("init", args
[0]) == 0)
1858 reset_mode
= RESET_INIT
;
1859 else if (strcmp("run_and_halt", args
[0]) == 0)
1861 reset_mode
= RESET_RUN_AND_HALT
;
1864 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1867 else if (strcmp("run_and_init", args
[0]) == 0)
1869 reset_mode
= RESET_RUN_AND_INIT
;
1872 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1877 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1882 /* temporarily modify mode of current reset target */
1883 target
->reset_mode
= reset_mode
;
1885 /* reset *all* targets */
1886 target_process_reset(cmd_ctx
);
1888 /* Restore default reset mode for this target */
1889 target
->reset_mode
= save
;
1894 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1897 target_t
*target
= get_current_target(cmd_ctx
);
1899 target_invoke_script(cmd_ctx
, target
, "pre_resume");
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
;
1913 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1915 target_t
*target
= get_current_target(cmd_ctx
);
1920 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1923 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1928 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1930 const int line_bytecnt
= 32;
1943 target_t
*target
= get_current_target(cmd_ctx
);
1949 count
= strtoul(args
[1], NULL
, 0);
1951 address
= strtoul(args
[0], NULL
, 0);
1957 size
= 4; line_modulo
= line_bytecnt
/ 4;
1960 size
= 2; line_modulo
= line_bytecnt
/ 2;
1963 size
= 1; line_modulo
= line_bytecnt
/ 1;
1969 buffer
= calloc(count
, size
);
1970 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1971 if (retval
== ERROR_OK
)
1975 for (i
= 0; i
< count
; i
++)
1977 if (i
%line_modulo
== 0)
1978 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1983 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1986 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1989 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1993 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1995 command_print(cmd_ctx
, output
);
2006 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2013 target_t
*target
= get_current_target(cmd_ctx
);
2016 if ((argc
< 2) || (argc
> 3))
2017 return ERROR_COMMAND_SYNTAX_ERROR
;
2019 address
= strtoul(args
[0], NULL
, 0);
2020 value
= strtoul(args
[1], NULL
, 0);
2022 count
= strtoul(args
[2], NULL
, 0);
2028 target_buffer_set_u32(target
, value_buf
, value
);
2032 target_buffer_set_u16(target
, value_buf
, value
);
2036 value_buf
[0] = value
;
2039 return ERROR_COMMAND_SYNTAX_ERROR
;
2041 for (i
=0; i
<count
; i
++)
2047 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2050 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2053 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2058 if (retval
!=ERROR_OK
)
2068 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2078 duration_t duration
;
2079 char *duration_text
;
2081 target_t
*target
= get_current_target(cmd_ctx
);
2085 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2089 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2092 image
.base_address_set
= 1;
2093 image
.base_address
= strtoul(args
[1], NULL
, 0);
2097 image
.base_address_set
= 0;
2100 image
.start_address_set
= 0;
2102 duration_start_measure(&duration
);
2104 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2111 for (i
= 0; i
< image
.num_sections
; i
++)
2113 buffer
= malloc(image
.sections
[i
].size
);
2116 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2120 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2125 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2130 image_size
+= buf_cnt
;
2131 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2136 duration_stop_measure(&duration
, &duration_text
);
2137 if (retval
==ERROR_OK
)
2139 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2141 free(duration_text
);
2143 image_close(&image
);
2149 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2156 int retval
=ERROR_OK
;
2158 duration_t duration
;
2159 char *duration_text
;
2161 target_t
*target
= get_current_target(cmd_ctx
);
2165 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2169 address
= strtoul(args
[1], NULL
, 0);
2170 size
= strtoul(args
[2], NULL
, 0);
2172 if ((address
& 3) || (size
& 3))
2174 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2178 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2183 duration_start_measure(&duration
);
2188 u32 this_run_size
= (size
> 560) ? 560 : size
;
2190 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2191 if (retval
!= ERROR_OK
)
2196 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2197 if (retval
!= ERROR_OK
)
2202 size
-= this_run_size
;
2203 address
+= this_run_size
;
2206 fileio_close(&fileio
);
2208 duration_stop_measure(&duration
, &duration_text
);
2209 if (retval
==ERROR_OK
)
2211 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2213 free(duration_text
);
2218 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2226 u32 mem_checksum
= 0;
2230 duration_t duration
;
2231 char *duration_text
;
2233 target_t
*target
= get_current_target(cmd_ctx
);
2237 return ERROR_COMMAND_SYNTAX_ERROR
;
2242 LOG_ERROR("no target selected");
2246 duration_start_measure(&duration
);
2250 image
.base_address_set
= 1;
2251 image
.base_address
= strtoul(args
[1], NULL
, 0);
2255 image
.base_address_set
= 0;
2256 image
.base_address
= 0x0;
2259 image
.start_address_set
= 0;
2261 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2268 for (i
= 0; i
< image
.num_sections
; i
++)
2270 buffer
= malloc(image
.sections
[i
].size
);
2273 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2276 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2282 /* calculate checksum of image */
2283 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2285 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2286 if( retval
!= ERROR_OK
)
2292 if( checksum
!= mem_checksum
)
2294 /* failed crc checksum, fall back to a binary compare */
2297 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2299 data
= (u8
*)malloc(buf_cnt
);
2301 /* Can we use 32bit word accesses? */
2303 int count
= buf_cnt
;
2304 if ((count
% 4) == 0)
2309 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2310 if (retval
== ERROR_OK
)
2313 for (t
= 0; t
< buf_cnt
; t
++)
2315 if (data
[t
] != buffer
[t
])
2317 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
]);
2330 image_size
+= buf_cnt
;
2333 duration_stop_measure(&duration
, &duration_text
);
2334 if (retval
==ERROR_OK
)
2336 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2338 free(duration_text
);
2340 image_close(&image
);
2345 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2348 target_t
*target
= get_current_target(cmd_ctx
);
2352 breakpoint_t
*breakpoint
= target
->breakpoints
;
2356 if (breakpoint
->type
== BKPT_SOFT
)
2358 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2359 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2364 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2366 breakpoint
= breakpoint
->next
;
2374 length
= strtoul(args
[1], NULL
, 0);
2377 if (strcmp(args
[2], "hw") == 0)
2380 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2382 LOG_ERROR("Failure setting breakpoints");
2386 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2391 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2397 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2399 target_t
*target
= get_current_target(cmd_ctx
);
2402 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2407 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2409 target_t
*target
= get_current_target(cmd_ctx
);
2414 watchpoint_t
*watchpoint
= target
->watchpoints
;
2418 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
);
2419 watchpoint
= watchpoint
->next
;
2424 enum watchpoint_rw type
= WPT_ACCESS
;
2425 u32 data_value
= 0x0;
2426 u32 data_mask
= 0xffffffff;
2442 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2448 data_value
= strtoul(args
[3], NULL
, 0);
2452 data_mask
= strtoul(args
[4], NULL
, 0);
2455 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2456 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2458 LOG_ERROR("Failure setting breakpoints");
2463 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2469 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2471 target_t
*target
= get_current_target(cmd_ctx
);
2474 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2479 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2482 target_t
*target
= get_current_target(cmd_ctx
);
2488 return ERROR_COMMAND_SYNTAX_ERROR
;
2490 va
= strtoul(args
[0], NULL
, 0);
2492 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2493 if (retval
== ERROR_OK
)
2495 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2499 /* lower levels will have logged a detailed error which is
2500 * forwarded to telnet/GDB session.
2505 static void writeLong(FILE *f
, int l
)
2510 char c
=(l
>>(i
*8))&0xff;
2511 fwrite(&c
, 1, 1, f
);
2515 static void writeString(FILE *f
, char *s
)
2517 fwrite(s
, 1, strlen(s
), f
);
2522 // Dump a gmon.out histogram file.
2523 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2526 FILE *f
=fopen(filename
, "w");
2529 fwrite("gmon", 1, 4, f
);
2530 writeLong(f
, 0x00000001); // Version
2531 writeLong(f
, 0); // padding
2532 writeLong(f
, 0); // padding
2533 writeLong(f
, 0); // padding
2535 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2537 // figure out bucket size
2540 for (i
=0; i
<sampleNum
; i
++)
2552 int addressSpace
=(max
-min
+1);
2554 static int const maxBuckets
=256*1024; // maximum buckets.
2555 int length
=addressSpace
;
2556 if (length
> maxBuckets
)
2560 int *buckets
=malloc(sizeof(int)*length
);
2566 memset(buckets
, 0, sizeof(int)*length
);
2567 for (i
=0; i
<sampleNum
;i
++)
2569 u32 address
=samples
[i
];
2570 long long a
=address
-min
;
2571 long long b
=length
-1;
2572 long long c
=addressSpace
-1;
2573 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2577 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2578 writeLong(f
, min
); // low_pc
2579 writeLong(f
, max
); // high_pc
2580 writeLong(f
, length
); // # of samples
2581 writeLong(f
, 64000000); // 64MHz
2582 writeString(f
, "seconds");
2583 for (i
=0; i
<(15-strlen("seconds")); i
++)
2585 fwrite("", 1, 1, f
); // padding
2587 writeString(f
, "s");
2589 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2591 char *data
=malloc(2*length
);
2594 for (i
=0; i
<length
;i
++)
2603 data
[i
*2+1]=(val
>>8)&0xff;
2606 fwrite(data
, 1, length
*2, f
);
2616 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2617 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2619 target_t
*target
= get_current_target(cmd_ctx
);
2620 struct timeval timeout
, now
;
2622 gettimeofday(&timeout
, NULL
);
2625 return ERROR_COMMAND_SYNTAX_ERROR
;
2628 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2634 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2636 static const int maxSample
=10000;
2637 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2642 int retval
=ERROR_OK
;
2643 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2644 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2648 target_poll(target
);
2649 if (target
->state
== TARGET_HALTED
)
2651 u32 t
=*((u32
*)reg
->value
);
2652 samples
[numSamples
++]=t
;
2653 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2654 target_poll(target
);
2655 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2656 } else if (target
->state
== TARGET_RUNNING
)
2658 // We want to quickly sample the PC.
2659 target_halt(target
);
2662 command_print(cmd_ctx
, "Target not halted or running");
2666 if (retval
!=ERROR_OK
)
2671 gettimeofday(&now
, NULL
);
2672 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2674 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2675 target_poll(target
);
2676 if (target
->state
== TARGET_HALTED
)
2678 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2680 target_poll(target
);
2681 writeGmon(samples
, numSamples
, args
[1]);
2682 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)