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
)
223 struct command_context_s
*cmd_ctx
= priv
;
225 if (event
== TARGET_EVENT_HALTED
)
227 target_unregister_event_callback(target_init_handler
, priv
);
229 target_invoke_script(cmd_ctx
, target
, "reset");
231 jtag_execute_queue();
237 int target_run_and_halt_handler(void *priv
)
239 target_t
*target
= priv
;
246 int target_poll(struct target_s
*target
)
248 /* We can't poll until after examine */
249 if (!target
->type
->examined
)
251 /* Fail silently lest we pollute the log */
254 return target
->type
->poll(target
);
257 int target_halt(struct target_s
*target
)
259 /* We can't poll until after examine */
260 if (!target
->type
->examined
)
262 LOG_ERROR("Target not examined yet");
265 return target
->type
->halt(target
);
268 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
270 /* We can't poll until after examine */
271 if (!target
->type
->examined
)
273 LOG_ERROR("Target not examined yet");
276 return target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
);
280 int target_process_reset(struct command_context_s
*cmd_ctx
)
282 int retval
= ERROR_OK
;
284 struct timeval timeout
, now
;
286 jtag
->speed(jtag_speed
);
291 target_invoke_script(cmd_ctx
, target
, "pre_reset");
292 target
= target
->next
;
295 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
298 /* First time this is executed after launching OpenOCD, it will read out
299 * the type of CPU, etc. and init Embedded ICE registers in host
302 * It will also set up ICE registers in the target.
304 * However, if we assert TRST later, we need to set up the registers again.
306 * For the "reset halt/init" case we must only set up the registers here.
308 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
311 /* prepare reset_halt where necessary */
315 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
317 switch (target
->reset_mode
)
320 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
321 target
->reset_mode
= RESET_RUN_AND_HALT
;
324 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
325 target
->reset_mode
= RESET_RUN_AND_INIT
;
331 target
= target
->next
;
337 /* we have no idea what state the target is in, so we
338 * have to drop working areas
340 target_free_all_working_areas_restore(target
, 0);
341 target
->type
->assert_reset(target
);
342 target
= target
->next
;
344 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
346 LOG_WARNING("JTAG communication failed asserting reset.");
350 /* request target halt if necessary, and schedule further action */
354 switch (target
->reset_mode
)
357 /* nothing to do if target just wants to be run */
359 case RESET_RUN_AND_HALT
:
361 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
363 case RESET_RUN_AND_INIT
:
365 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
366 target_register_event_callback(target_init_handler
, cmd_ctx
);
373 target_register_event_callback(target_init_handler
, cmd_ctx
);
376 LOG_ERROR("BUG: unknown target->reset_mode");
378 target
= target
->next
;
381 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
383 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
390 target
->type
->deassert_reset(target
);
391 target
= target
->next
;
394 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
396 LOG_WARNING("JTAG communication failed while deasserting reset.");
400 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
402 /* If TRST was asserted we need to set up registers again */
403 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
408 LOG_DEBUG("Waiting for halted stated as approperiate");
410 /* Wait for reset to complete, maximum 5 seconds. */
411 gettimeofday(&timeout
, NULL
);
412 timeval_add_time(&timeout
, 5, 0);
415 gettimeofday(&now
, NULL
);
417 target_call_timer_callbacks_now();
422 LOG_DEBUG("Polling target");
424 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
425 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
426 (target
->reset_mode
== RESET_HALT
) ||
427 (target
->reset_mode
== RESET_INIT
))
429 if (target
->state
!= TARGET_HALTED
)
431 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
433 LOG_USER("Timed out waiting for halt after reset");
436 /* this will send alive messages on e.g. GDB remote protocol. */
438 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
442 target
= target
->next
;
444 /* All targets we're waiting for are halted */
452 /* We want any events to be processed before the prompt */
453 target_call_timer_callbacks_now();
455 /* if we timed out we need to unregister these handlers */
459 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
460 target
= target
->next
;
462 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
465 jtag
->speed(jtag_speed_post_reset
);
470 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
476 static int default_mmu(struct target_s
*target
, int *enabled
)
482 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
484 target
->type
->examined
= 1;
489 /* Targets that correctly implement init+examine, i.e.
490 * no communication with target during init:
494 int target_examine(struct command_context_s
*cmd_ctx
)
496 int retval
= ERROR_OK
;
497 target_t
*target
= targets
;
500 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
502 target
= target
->next
;
507 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
509 if (!target
->type
->examined
)
511 LOG_ERROR("Target not examined yet");
514 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
517 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
519 if (!target
->type
->examined
)
521 LOG_ERROR("Target not examined yet");
524 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
527 static int target_soft_reset_halt_imp(struct target_s
*target
)
529 if (!target
->type
->examined
)
531 LOG_ERROR("Target not examined yet");
534 return target
->type
->soft_reset_halt_imp(target
);
537 static int target_run_algorithm_imp(struct target_s
*target
, int num_mem_params
, mem_param_t
*mem_params
, int num_reg_params
, reg_param_t
*reg_param
, u32 entry_point
, u32 exit_point
, int timeout_ms
, void *arch_info
)
539 if (!target
->type
->examined
)
541 LOG_ERROR("Target not examined yet");
544 return target
->type
->run_algorithm_imp(target
, num_mem_params
, mem_params
, num_reg_params
, reg_param
, entry_point
, exit_point
, timeout_ms
, arch_info
);
547 int target_init(struct command_context_s
*cmd_ctx
)
549 target_t
*target
= targets
;
553 target
->type
->examined
= 0;
554 if (target
->type
->examine
== NULL
)
556 target
->type
->examine
= default_examine
;
559 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
561 LOG_ERROR("target '%s' init failed", target
->type
->name
);
565 /* Set up default functions if none are provided by target */
566 if (target
->type
->virt2phys
== NULL
)
568 target
->type
->virt2phys
= default_virt2phys
;
570 target
->type
->virt2phys
= default_virt2phys
;
571 /* a non-invasive way(in terms of patches) to add some code that
572 * runs before the type->write/read_memory implementation
574 target
->type
->write_memory_imp
= target
->type
->write_memory
;
575 target
->type
->write_memory
= target_write_memory_imp
;
576 target
->type
->read_memory_imp
= target
->type
->read_memory
;
577 target
->type
->read_memory
= target_read_memory_imp
;
578 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
579 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
580 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
581 target
->type
->run_algorithm
= target_run_algorithm_imp
;
584 if (target
->type
->mmu
== NULL
)
586 target
->type
->mmu
= default_mmu
;
588 target
= target
->next
;
593 target_register_user_commands(cmd_ctx
);
594 target_register_timer_callback(handle_target
, 100, 1, NULL
);
600 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
602 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
604 if (callback
== NULL
)
606 return ERROR_INVALID_ARGUMENTS
;
611 while ((*callbacks_p
)->next
)
612 callbacks_p
= &((*callbacks_p
)->next
);
613 callbacks_p
= &((*callbacks_p
)->next
);
616 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
617 (*callbacks_p
)->callback
= callback
;
618 (*callbacks_p
)->priv
= priv
;
619 (*callbacks_p
)->next
= NULL
;
624 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
626 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
629 if (callback
== NULL
)
631 return ERROR_INVALID_ARGUMENTS
;
636 while ((*callbacks_p
)->next
)
637 callbacks_p
= &((*callbacks_p
)->next
);
638 callbacks_p
= &((*callbacks_p
)->next
);
641 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
642 (*callbacks_p
)->callback
= callback
;
643 (*callbacks_p
)->periodic
= periodic
;
644 (*callbacks_p
)->time_ms
= time_ms
;
646 gettimeofday(&now
, NULL
);
647 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
648 time_ms
-= (time_ms
% 1000);
649 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
650 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
652 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
653 (*callbacks_p
)->when
.tv_sec
+= 1;
656 (*callbacks_p
)->priv
= priv
;
657 (*callbacks_p
)->next
= NULL
;
662 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
664 target_event_callback_t
**p
= &target_event_callbacks
;
665 target_event_callback_t
*c
= target_event_callbacks
;
667 if (callback
== NULL
)
669 return ERROR_INVALID_ARGUMENTS
;
674 target_event_callback_t
*next
= c
->next
;
675 if ((c
->callback
== callback
) && (c
->priv
== priv
))
689 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
691 target_timer_callback_t
**p
= &target_timer_callbacks
;
692 target_timer_callback_t
*c
= target_timer_callbacks
;
694 if (callback
== NULL
)
696 return ERROR_INVALID_ARGUMENTS
;
701 target_timer_callback_t
*next
= c
->next
;
702 if ((c
->callback
== callback
) && (c
->priv
== priv
))
716 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
718 target_event_callback_t
*callback
= target_event_callbacks
;
719 target_event_callback_t
*next_callback
;
721 LOG_DEBUG("target event %i", event
);
725 next_callback
= callback
->next
;
726 callback
->callback(target
, event
, callback
->priv
);
727 callback
= next_callback
;
733 static int target_call_timer_callbacks_check_time(int checktime
)
735 target_timer_callback_t
*callback
= target_timer_callbacks
;
736 target_timer_callback_t
*next_callback
;
739 gettimeofday(&now
, NULL
);
743 next_callback
= callback
->next
;
745 if ((!checktime
&&callback
->periodic
)||
746 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
747 || (now
.tv_sec
> callback
->when
.tv_sec
)))
749 if(callback
->callback
!= NULL
)
751 callback
->callback(callback
->priv
);
752 if (callback
->periodic
)
754 int time_ms
= callback
->time_ms
;
755 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
756 time_ms
-= (time_ms
% 1000);
757 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
758 if (callback
->when
.tv_usec
> 1000000)
760 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
761 callback
->when
.tv_sec
+= 1;
765 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
769 callback
= next_callback
;
775 int target_call_timer_callbacks()
777 return target_call_timer_callbacks_check_time(1);
780 /* invoke periodic callbacks immediately */
781 int target_call_timer_callbacks_now()
783 return target_call_timer_callbacks(0);
787 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
789 working_area_t
*c
= target
->working_areas
;
790 working_area_t
*new_wa
= NULL
;
792 /* Reevaluate working area address based on MMU state*/
793 if (target
->working_areas
== NULL
)
797 retval
= target
->type
->mmu(target
, &enabled
);
798 if (retval
!= ERROR_OK
)
804 target
->working_area
= target
->working_area_virt
;
808 target
->working_area
= target
->working_area_phys
;
812 /* only allocate multiples of 4 byte */
815 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
816 size
= CEIL(size
, 4);
819 /* see if there's already a matching working area */
822 if ((c
->free
) && (c
->size
== size
))
830 /* if not, allocate a new one */
833 working_area_t
**p
= &target
->working_areas
;
834 u32 first_free
= target
->working_area
;
835 u32 free_size
= target
->working_area_size
;
837 LOG_DEBUG("allocating new working area");
839 c
= target
->working_areas
;
842 first_free
+= c
->size
;
843 free_size
-= c
->size
;
848 if (free_size
< size
)
850 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
851 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
854 new_wa
= malloc(sizeof(working_area_t
));
857 new_wa
->address
= first_free
;
859 if (target
->backup_working_area
)
861 new_wa
->backup
= malloc(new_wa
->size
);
862 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
866 new_wa
->backup
= NULL
;
869 /* put new entry in list */
873 /* mark as used, and return the new (reused) area */
883 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
888 if (restore
&&target
->backup_working_area
)
889 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
893 /* mark user pointer invalid */
900 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
902 return target_free_working_area_restore(target
, area
, 1);
905 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
907 working_area_t
*c
= target
->working_areas
;
911 working_area_t
*next
= c
->next
;
912 target_free_working_area_restore(target
, c
, restore
);
922 target
->working_areas
= NULL
;
927 int target_free_all_working_areas(struct target_s
*target
)
929 return target_free_all_working_areas_restore(target
, 1);
932 int target_register_commands(struct command_context_s
*cmd_ctx
)
934 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
935 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
936 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
,
937 "target_script <target#> <event=reset/pre_reset/post_halt/pre_resume/gdb_program_config> <script_file>");
938 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
939 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
940 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
941 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
946 int target_arch_state(struct target_s
*target
)
951 LOG_USER("No target has been configured");
955 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
957 if (target
->state
!=TARGET_HALTED
)
960 retval
=target
->type
->arch_state(target
);
964 /* Single aligned words are guaranteed to use 16 or 32 bit access
965 * mode respectively, otherwise data is handled as quickly as
968 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
971 if (!target
->type
->examined
)
973 LOG_ERROR("Target not examined yet");
977 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
979 if (((address
% 2) == 0) && (size
== 2))
981 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
984 /* handle unaligned head bytes */
987 int unaligned
= 4 - (address
% 4);
989 if (unaligned
> size
)
992 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
996 address
+= unaligned
;
1000 /* handle aligned words */
1003 int aligned
= size
- (size
% 4);
1005 /* use bulk writes above a certain limit. This may have to be changed */
1008 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1013 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1022 /* handle tail writes of less than 4 bytes */
1025 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1033 /* Single aligned words are guaranteed to use 16 or 32 bit access
1034 * mode respectively, otherwise data is handled as quickly as
1037 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1040 if (!target
->type
->examined
)
1042 LOG_ERROR("Target not examined yet");
1046 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1048 if (((address
% 2) == 0) && (size
== 2))
1050 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1053 /* handle unaligned head bytes */
1056 int unaligned
= 4 - (address
% 4);
1058 if (unaligned
> size
)
1061 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1064 buffer
+= unaligned
;
1065 address
+= unaligned
;
1069 /* handle aligned words */
1072 int aligned
= size
- (size
% 4);
1074 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1082 /* handle tail writes of less than 4 bytes */
1085 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1092 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1098 if (!target
->type
->examined
)
1100 LOG_ERROR("Target not examined yet");
1104 if ((retval
= target
->type
->checksum_memory(target
, address
,
1105 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1107 buffer
= malloc(size
);
1110 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1111 return ERROR_INVALID_ARGUMENTS
;
1113 retval
= target_read_buffer(target
, address
, size
, buffer
);
1114 if (retval
!= ERROR_OK
)
1120 /* convert to target endianess */
1121 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1124 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1125 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1128 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1137 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1140 if (!target
->type
->examined
)
1142 LOG_ERROR("Target not examined yet");
1146 if (target
->type
->blank_check_memory
== 0)
1147 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1149 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1154 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1157 if (!target
->type
->examined
)
1159 LOG_ERROR("Target not examined yet");
1163 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1165 if (retval
== ERROR_OK
)
1167 *value
= target_buffer_get_u32(target
, value_buf
);
1168 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1173 LOG_DEBUG("address: 0x%8.8x failed", address
);
1179 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1182 if (!target
->type
->examined
)
1184 LOG_ERROR("Target not examined yet");
1188 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1190 if (retval
== ERROR_OK
)
1192 *value
= target_buffer_get_u16(target
, value_buf
);
1193 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1198 LOG_DEBUG("address: 0x%8.8x failed", address
);
1204 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1206 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1207 if (!target
->type
->examined
)
1209 LOG_ERROR("Target not examined yet");
1213 if (retval
== ERROR_OK
)
1215 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1220 LOG_DEBUG("address: 0x%8.8x failed", address
);
1226 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1230 if (!target
->type
->examined
)
1232 LOG_ERROR("Target not examined yet");
1236 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1238 target_buffer_set_u32(target
, value_buf
, value
);
1239 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1241 LOG_DEBUG("failed: %i", retval
);
1247 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1251 if (!target
->type
->examined
)
1253 LOG_ERROR("Target not examined yet");
1257 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1259 target_buffer_set_u16(target
, value_buf
, value
);
1260 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1262 LOG_DEBUG("failed: %i", retval
);
1268 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1271 if (!target
->type
->examined
)
1273 LOG_ERROR("Target not examined yet");
1277 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1279 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1281 LOG_DEBUG("failed: %i", retval
);
1287 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1289 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1290 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1291 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1292 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1293 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1294 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1295 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1296 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1298 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1299 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1300 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1302 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1303 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1304 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1306 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1307 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1308 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1309 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1311 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1312 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1313 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1314 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1315 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1317 target_request_register_commands(cmd_ctx
);
1318 trace_register_commands(cmd_ctx
);
1323 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1325 target_t
*target
= targets
;
1330 int num
= strtoul(args
[0], NULL
, 0);
1335 target
= target
->next
;
1339 cmd_ctx
->current_target
= num
;
1341 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1348 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1349 target
= target
->next
;
1355 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1362 return ERROR_COMMAND_SYNTAX_ERROR
;
1365 /* search for the specified target */
1366 if (args
[0] && (args
[0][0] != 0))
1368 for (i
= 0; target_types
[i
]; i
++)
1370 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1372 target_t
**last_target_p
= &targets
;
1374 /* register target specific commands */
1375 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1377 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1383 while ((*last_target_p
)->next
)
1384 last_target_p
= &((*last_target_p
)->next
);
1385 last_target_p
= &((*last_target_p
)->next
);
1388 *last_target_p
= malloc(sizeof(target_t
));
1390 /* allocate memory for each unique target type */
1391 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_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
)->working_area
= 0x0;
1425 (*last_target_p
)->working_area_size
= 0x0;
1426 (*last_target_p
)->working_areas
= NULL
;
1427 (*last_target_p
)->backup_working_area
= 0;
1429 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1430 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1431 (*last_target_p
)->reg_cache
= NULL
;
1432 (*last_target_p
)->breakpoints
= NULL
;
1433 (*last_target_p
)->watchpoints
= NULL
;
1434 (*last_target_p
)->next
= NULL
;
1435 (*last_target_p
)->arch_info
= NULL
;
1437 /* initialize trace information */
1438 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1439 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1440 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1441 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1442 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1443 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1444 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1445 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1447 (*last_target_p
)->dbgmsg
= NULL
;
1448 (*last_target_p
)->dbg_msg_enabled
= 0;
1450 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1458 /* no matching target found */
1461 LOG_ERROR("target '%s' not found", args
[0]);
1462 return ERROR_COMMAND_SYNTAX_ERROR
;
1468 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1470 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
1471 name
, get_num_by_target(target
),
1472 name
, get_num_by_target(target
));
1476 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1478 target_t
*target
= NULL
;
1482 LOG_ERROR("incomplete target_script command");
1483 return ERROR_COMMAND_SYNTAX_ERROR
;
1486 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1490 return ERROR_COMMAND_SYNTAX_ERROR
;
1493 /* Define a tcl procedure which we'll invoke upon some event */
1494 command_run_linef(cmd_ctx
,
1495 "proc target_%s_%d {} {"
1496 "openocd {script %s}"
1499 get_num_by_target(target
),
1505 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1507 target_t
*target
= NULL
;
1511 return ERROR_COMMAND_SYNTAX_ERROR
;
1514 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1517 return ERROR_COMMAND_SYNTAX_ERROR
;
1520 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1525 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1527 target_t
*target
= NULL
;
1529 if ((argc
< 4) || (argc
> 5))
1531 return ERROR_COMMAND_SYNTAX_ERROR
;
1534 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1537 return ERROR_COMMAND_SYNTAX_ERROR
;
1539 target_free_all_working_areas(target
);
1541 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1544 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1546 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1548 if (strcmp(args
[3], "backup") == 0)
1550 target
->backup_working_area
= 1;
1552 else if (strcmp(args
[3], "nobackup") == 0)
1554 target
->backup_working_area
= 0;
1558 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1559 return ERROR_COMMAND_SYNTAX_ERROR
;
1566 /* process target state changes */
1567 int handle_target(void *priv
)
1569 target_t
*target
= targets
;
1573 if (target_continous_poll
)
1575 /* polling may fail silently until the target has been examined */
1576 target_poll(target
);
1579 target
= target
->next
;
1585 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1594 target
= get_current_target(cmd_ctx
);
1596 /* list all available registers for the current target */
1599 reg_cache_t
*cache
= target
->reg_cache
;
1605 for (i
= 0; i
< cache
->num_regs
; i
++)
1607 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1608 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
);
1611 cache
= cache
->next
;
1617 /* access a single register by its ordinal number */
1618 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1620 int num
= strtoul(args
[0], NULL
, 0);
1621 reg_cache_t
*cache
= target
->reg_cache
;
1627 for (i
= 0; i
< cache
->num_regs
; i
++)
1631 reg
= &cache
->reg_list
[i
];
1637 cache
= cache
->next
;
1642 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1645 } else /* access a single register by its name */
1647 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1651 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1656 /* display a register */
1657 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1659 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1662 if (reg
->valid
== 0)
1664 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1665 if (arch_type
== NULL
)
1667 LOG_ERROR("BUG: encountered unregistered arch type");
1670 arch_type
->get(reg
);
1672 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1673 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1678 /* set register value */
1681 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1682 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1684 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1685 if (arch_type
== NULL
)
1687 LOG_ERROR("BUG: encountered unregistered arch type");
1691 arch_type
->set(reg
, buf
);
1693 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1694 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1702 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1707 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1709 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1711 target_t
*target
= get_current_target(cmd_ctx
);
1715 target_poll(target
);
1716 target_arch_state(target
);
1720 if (strcmp(args
[0], "on") == 0)
1722 target_continous_poll
= 1;
1724 else if (strcmp(args
[0], "off") == 0)
1726 target_continous_poll
= 0;
1730 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1738 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1746 ms
= strtoul(args
[0], &end
, 0) * 1000;
1749 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1754 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1757 static void target_process_events(struct command_context_s
*cmd_ctx
)
1759 target_t
*target
= get_current_target(cmd_ctx
);
1760 target_poll(target
);
1761 target_call_timer_callbacks_now();
1764 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1767 struct timeval timeout
, now
;
1769 gettimeofday(&timeout
, NULL
);
1770 timeval_add_time(&timeout
, 0, ms
* 1000);
1772 target_t
*target
= get_current_target(cmd_ctx
);
1775 if ((retval
=target_poll(target
))!=ERROR_OK
)
1777 target_call_timer_callbacks_now();
1778 if (target
->state
== state
)
1785 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1788 gettimeofday(&now
, NULL
);
1789 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1791 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1799 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1802 target_t
*target
= get_current_target(cmd_ctx
);
1806 if ((retval
= target_halt(target
)) != ERROR_OK
)
1811 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1815 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1817 target_t
*target
= get_current_target(cmd_ctx
);
1819 LOG_USER("requesting target halt and executing a soft reset");
1821 target
->type
->soft_reset_halt(target
);
1826 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1828 target_t
*target
= get_current_target(cmd_ctx
);
1829 enum target_reset_mode reset_mode
= target
->reset_mode
;
1830 enum target_reset_mode save
= target
->reset_mode
;
1836 if (strcmp("run", args
[0]) == 0)
1837 reset_mode
= RESET_RUN
;
1838 else if (strcmp("halt", args
[0]) == 0)
1839 reset_mode
= RESET_HALT
;
1840 else if (strcmp("init", args
[0]) == 0)
1841 reset_mode
= RESET_INIT
;
1842 else if (strcmp("run_and_halt", args
[0]) == 0)
1844 reset_mode
= RESET_RUN_AND_HALT
;
1847 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1850 else if (strcmp("run_and_init", args
[0]) == 0)
1852 reset_mode
= RESET_RUN_AND_INIT
;
1855 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1860 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1865 /* temporarily modify mode of current reset target */
1866 target
->reset_mode
= reset_mode
;
1868 /* reset *all* targets */
1869 target_process_reset(cmd_ctx
);
1871 /* Restore default reset mode for this target */
1872 target
->reset_mode
= save
;
1877 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1880 target_t
*target
= get_current_target(cmd_ctx
);
1883 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1885 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1888 return ERROR_COMMAND_SYNTAX_ERROR
;
1891 target_process_events(cmd_ctx
);
1896 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1898 target_t
*target
= get_current_target(cmd_ctx
);
1903 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1906 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1911 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1913 const int line_bytecnt
= 32;
1926 target_t
*target
= get_current_target(cmd_ctx
);
1932 count
= strtoul(args
[1], NULL
, 0);
1934 address
= strtoul(args
[0], NULL
, 0);
1940 size
= 4; line_modulo
= line_bytecnt
/ 4;
1943 size
= 2; line_modulo
= line_bytecnt
/ 2;
1946 size
= 1; line_modulo
= line_bytecnt
/ 1;
1952 buffer
= calloc(count
, size
);
1953 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1954 if (retval
== ERROR_OK
)
1958 for (i
= 0; i
< count
; i
++)
1960 if (i
%line_modulo
== 0)
1961 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1966 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1969 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1972 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1976 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1978 command_print(cmd_ctx
, output
);
1989 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1996 target_t
*target
= get_current_target(cmd_ctx
);
1999 if ((argc
< 2) || (argc
> 3))
2000 return ERROR_COMMAND_SYNTAX_ERROR
;
2002 address
= strtoul(args
[0], NULL
, 0);
2003 value
= strtoul(args
[1], NULL
, 0);
2005 count
= strtoul(args
[2], NULL
, 0);
2012 target_buffer_set_u32(target
, value_buf
, value
);
2016 target_buffer_set_u16(target
, value_buf
, value
);
2020 value_buf
[0] = value
;
2023 return ERROR_COMMAND_SYNTAX_ERROR
;
2025 for (i
=0; i
<count
; i
++)
2031 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2034 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2037 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2042 if (retval
!=ERROR_OK
)
2052 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2062 duration_t duration
;
2063 char *duration_text
;
2065 target_t
*target
= get_current_target(cmd_ctx
);
2069 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2073 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2076 image
.base_address_set
= 1;
2077 image
.base_address
= strtoul(args
[1], NULL
, 0);
2081 image
.base_address_set
= 0;
2084 image
.start_address_set
= 0;
2086 duration_start_measure(&duration
);
2088 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2095 for (i
= 0; i
< image
.num_sections
; i
++)
2097 buffer
= malloc(image
.sections
[i
].size
);
2100 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2104 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2109 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2114 image_size
+= buf_cnt
;
2115 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2120 duration_stop_measure(&duration
, &duration_text
);
2121 if (retval
==ERROR_OK
)
2123 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2125 free(duration_text
);
2127 image_close(&image
);
2133 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2140 int retval
=ERROR_OK
;
2142 duration_t duration
;
2143 char *duration_text
;
2145 target_t
*target
= get_current_target(cmd_ctx
);
2149 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2153 address
= strtoul(args
[1], NULL
, 0);
2154 size
= strtoul(args
[2], NULL
, 0);
2156 if ((address
& 3) || (size
& 3))
2158 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2162 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2167 duration_start_measure(&duration
);
2172 u32 this_run_size
= (size
> 560) ? 560 : size
;
2174 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2175 if (retval
!= ERROR_OK
)
2180 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2181 if (retval
!= ERROR_OK
)
2186 size
-= this_run_size
;
2187 address
+= this_run_size
;
2190 fileio_close(&fileio
);
2192 duration_stop_measure(&duration
, &duration_text
);
2193 if (retval
==ERROR_OK
)
2195 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2197 free(duration_text
);
2202 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2210 u32 mem_checksum
= 0;
2214 duration_t duration
;
2215 char *duration_text
;
2217 target_t
*target
= get_current_target(cmd_ctx
);
2221 return ERROR_COMMAND_SYNTAX_ERROR
;
2226 LOG_ERROR("no target selected");
2230 duration_start_measure(&duration
);
2234 image
.base_address_set
= 1;
2235 image
.base_address
= strtoul(args
[1], NULL
, 0);
2239 image
.base_address_set
= 0;
2240 image
.base_address
= 0x0;
2243 image
.start_address_set
= 0;
2245 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2252 for (i
= 0; i
< image
.num_sections
; i
++)
2254 buffer
= malloc(image
.sections
[i
].size
);
2257 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2260 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2266 /* calculate checksum of image */
2267 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2269 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2270 if( retval
!= ERROR_OK
)
2276 if( checksum
!= mem_checksum
)
2278 /* failed crc checksum, fall back to a binary compare */
2281 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2283 data
= (u8
*)malloc(buf_cnt
);
2285 /* Can we use 32bit word accesses? */
2287 int count
= buf_cnt
;
2288 if ((count
% 4) == 0)
2293 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2294 if (retval
== ERROR_OK
)
2297 for (t
= 0; t
< buf_cnt
; t
++)
2299 if (data
[t
] != buffer
[t
])
2301 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
]);
2314 image_size
+= buf_cnt
;
2317 duration_stop_measure(&duration
, &duration_text
);
2318 if (retval
==ERROR_OK
)
2320 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2322 free(duration_text
);
2324 image_close(&image
);
2329 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2332 target_t
*target
= get_current_target(cmd_ctx
);
2336 breakpoint_t
*breakpoint
= target
->breakpoints
;
2340 if (breakpoint
->type
== BKPT_SOFT
)
2342 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2343 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2348 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2350 breakpoint
= breakpoint
->next
;
2358 length
= strtoul(args
[1], NULL
, 0);
2361 if (strcmp(args
[2], "hw") == 0)
2364 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2366 LOG_ERROR("Failure setting breakpoints");
2370 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2375 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2381 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2383 target_t
*target
= get_current_target(cmd_ctx
);
2386 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2391 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2393 target_t
*target
= get_current_target(cmd_ctx
);
2398 watchpoint_t
*watchpoint
= target
->watchpoints
;
2402 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
);
2403 watchpoint
= watchpoint
->next
;
2408 enum watchpoint_rw type
= WPT_ACCESS
;
2409 u32 data_value
= 0x0;
2410 u32 data_mask
= 0xffffffff;
2426 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2432 data_value
= strtoul(args
[3], NULL
, 0);
2436 data_mask
= strtoul(args
[4], NULL
, 0);
2439 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2440 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2442 LOG_ERROR("Failure setting breakpoints");
2447 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2453 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2455 target_t
*target
= get_current_target(cmd_ctx
);
2458 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2463 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2466 target_t
*target
= get_current_target(cmd_ctx
);
2472 return ERROR_COMMAND_SYNTAX_ERROR
;
2474 va
= strtoul(args
[0], NULL
, 0);
2476 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2477 if (retval
== ERROR_OK
)
2479 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2483 /* lower levels will have logged a detailed error which is
2484 * forwarded to telnet/GDB session.
2489 static void writeLong(FILE *f
, int l
)
2494 char c
=(l
>>(i
*8))&0xff;
2495 fwrite(&c
, 1, 1, f
);
2499 static void writeString(FILE *f
, char *s
)
2501 fwrite(s
, 1, strlen(s
), f
);
2506 // Dump a gmon.out histogram file.
2507 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2510 FILE *f
=fopen(filename
, "w");
2513 fwrite("gmon", 1, 4, f
);
2514 writeLong(f
, 0x00000001); // Version
2515 writeLong(f
, 0); // padding
2516 writeLong(f
, 0); // padding
2517 writeLong(f
, 0); // padding
2519 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2521 // figure out bucket size
2524 for (i
=0; i
<sampleNum
; i
++)
2536 int addressSpace
=(max
-min
+1);
2538 static int const maxBuckets
=256*1024; // maximum buckets.
2539 int length
=addressSpace
;
2540 if (length
> maxBuckets
)
2544 int *buckets
=malloc(sizeof(int)*length
);
2550 memset(buckets
, 0, sizeof(int)*length
);
2551 for (i
=0; i
<sampleNum
;i
++)
2553 u32 address
=samples
[i
];
2554 long long a
=address
-min
;
2555 long long b
=length
-1;
2556 long long c
=addressSpace
-1;
2557 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2561 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2562 writeLong(f
, min
); // low_pc
2563 writeLong(f
, max
); // high_pc
2564 writeLong(f
, length
); // # of samples
2565 writeLong(f
, 64000000); // 64MHz
2566 writeString(f
, "seconds");
2567 for (i
=0; i
<(15-strlen("seconds")); i
++)
2569 fwrite("", 1, 1, f
); // padding
2571 writeString(f
, "s");
2573 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2575 char *data
=malloc(2*length
);
2578 for (i
=0; i
<length
;i
++)
2587 data
[i
*2+1]=(val
>>8)&0xff;
2590 fwrite(data
, 1, length
*2, f
);
2600 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2601 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2603 target_t
*target
= get_current_target(cmd_ctx
);
2604 struct timeval timeout
, now
;
2606 gettimeofday(&timeout
, NULL
);
2609 return ERROR_COMMAND_SYNTAX_ERROR
;
2612 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2618 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2620 static const int maxSample
=10000;
2621 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2626 int retval
=ERROR_OK
;
2627 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2628 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2632 target_poll(target
);
2633 if (target
->state
== TARGET_HALTED
)
2635 u32 t
=*((u32
*)reg
->value
);
2636 samples
[numSamples
++]=t
;
2637 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2638 target_poll(target
);
2639 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2640 } else if (target
->state
== TARGET_RUNNING
)
2642 // We want to quickly sample the PC.
2643 target_halt(target
);
2646 command_print(cmd_ctx
, "Target not halted or running");
2650 if (retval
!=ERROR_OK
)
2655 gettimeofday(&now
, NULL
);
2656 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2658 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2659 target_poll(target
);
2660 if (target
->state
== TARGET_HALTED
)
2662 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2664 target_poll(target
);
2665 writeGmon(samples
, numSamples
, args
[1]);
2666 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)