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
, "post_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 const char *event
=args
[1];
1494 if (strcmp("reset", event
)==0)
1500 /* Define a tcl procedure which we'll invoke upon some event */
1501 command_run_linef(cmd_ctx
,
1502 "proc target_%s_%d {} {"
1503 "openocd {script %s}"
1506 get_num_by_target(target
),
1512 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1514 target_t
*target
= NULL
;
1518 return ERROR_COMMAND_SYNTAX_ERROR
;
1521 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1524 return ERROR_COMMAND_SYNTAX_ERROR
;
1527 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1532 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1534 target_t
*target
= NULL
;
1536 if ((argc
< 4) || (argc
> 5))
1538 return ERROR_COMMAND_SYNTAX_ERROR
;
1541 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1544 return ERROR_COMMAND_SYNTAX_ERROR
;
1546 target_free_all_working_areas(target
);
1548 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1551 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1553 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1555 if (strcmp(args
[3], "backup") == 0)
1557 target
->backup_working_area
= 1;
1559 else if (strcmp(args
[3], "nobackup") == 0)
1561 target
->backup_working_area
= 0;
1565 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1566 return ERROR_COMMAND_SYNTAX_ERROR
;
1573 /* process target state changes */
1574 int handle_target(void *priv
)
1576 target_t
*target
= targets
;
1580 if (target_continous_poll
)
1582 /* polling may fail silently until the target has been examined */
1583 target_poll(target
);
1586 target
= target
->next
;
1592 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1601 target
= get_current_target(cmd_ctx
);
1603 /* list all available registers for the current target */
1606 reg_cache_t
*cache
= target
->reg_cache
;
1612 for (i
= 0; i
< cache
->num_regs
; i
++)
1614 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1615 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
);
1618 cache
= cache
->next
;
1624 /* access a single register by its ordinal number */
1625 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1627 int num
= strtoul(args
[0], NULL
, 0);
1628 reg_cache_t
*cache
= target
->reg_cache
;
1634 for (i
= 0; i
< cache
->num_regs
; i
++)
1638 reg
= &cache
->reg_list
[i
];
1644 cache
= cache
->next
;
1649 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1652 } else /* access a single register by its name */
1654 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1658 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1663 /* display a register */
1664 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1666 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1669 if (reg
->valid
== 0)
1671 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1672 if (arch_type
== NULL
)
1674 LOG_ERROR("BUG: encountered unregistered arch type");
1677 arch_type
->get(reg
);
1679 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1680 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1685 /* set register value */
1688 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1689 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1691 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1692 if (arch_type
== NULL
)
1694 LOG_ERROR("BUG: encountered unregistered arch type");
1698 arch_type
->set(reg
, buf
);
1700 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1701 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1709 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1714 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1716 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1718 target_t
*target
= get_current_target(cmd_ctx
);
1722 target_poll(target
);
1723 target_arch_state(target
);
1727 if (strcmp(args
[0], "on") == 0)
1729 target_continous_poll
= 1;
1731 else if (strcmp(args
[0], "off") == 0)
1733 target_continous_poll
= 0;
1737 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1745 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1753 ms
= strtoul(args
[0], &end
, 0) * 1000;
1756 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1761 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1764 static void target_process_events(struct command_context_s
*cmd_ctx
)
1766 target_t
*target
= get_current_target(cmd_ctx
);
1767 target_poll(target
);
1768 target_call_timer_callbacks_now();
1771 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1774 struct timeval timeout
, now
;
1776 gettimeofday(&timeout
, NULL
);
1777 timeval_add_time(&timeout
, 0, ms
* 1000);
1779 target_t
*target
= get_current_target(cmd_ctx
);
1782 if ((retval
=target_poll(target
))!=ERROR_OK
)
1784 target_call_timer_callbacks_now();
1785 if (target
->state
== state
)
1792 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1795 gettimeofday(&now
, NULL
);
1796 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1798 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1806 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1809 target_t
*target
= get_current_target(cmd_ctx
);
1813 if ((retval
= target_halt(target
)) != ERROR_OK
)
1818 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1822 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1824 target_t
*target
= get_current_target(cmd_ctx
);
1826 LOG_USER("requesting target halt and executing a soft reset");
1828 target
->type
->soft_reset_halt(target
);
1833 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1835 target_t
*target
= get_current_target(cmd_ctx
);
1836 enum target_reset_mode reset_mode
= target
->reset_mode
;
1837 enum target_reset_mode save
= target
->reset_mode
;
1843 if (strcmp("run", args
[0]) == 0)
1844 reset_mode
= RESET_RUN
;
1845 else if (strcmp("halt", args
[0]) == 0)
1846 reset_mode
= RESET_HALT
;
1847 else if (strcmp("init", args
[0]) == 0)
1848 reset_mode
= RESET_INIT
;
1849 else if (strcmp("run_and_halt", args
[0]) == 0)
1851 reset_mode
= RESET_RUN_AND_HALT
;
1854 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1857 else if (strcmp("run_and_init", args
[0]) == 0)
1859 reset_mode
= RESET_RUN_AND_INIT
;
1862 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1867 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1872 /* temporarily modify mode of current reset target */
1873 target
->reset_mode
= reset_mode
;
1875 /* reset *all* targets */
1876 target_process_reset(cmd_ctx
);
1878 /* Restore default reset mode for this target */
1879 target
->reset_mode
= save
;
1884 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1887 target_t
*target
= get_current_target(cmd_ctx
);
1890 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1892 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1895 return ERROR_COMMAND_SYNTAX_ERROR
;
1898 target_process_events(cmd_ctx
);
1903 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1905 target_t
*target
= get_current_target(cmd_ctx
);
1910 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1913 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1918 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1920 const int line_bytecnt
= 32;
1933 target_t
*target
= get_current_target(cmd_ctx
);
1939 count
= strtoul(args
[1], NULL
, 0);
1941 address
= strtoul(args
[0], NULL
, 0);
1947 size
= 4; line_modulo
= line_bytecnt
/ 4;
1950 size
= 2; line_modulo
= line_bytecnt
/ 2;
1953 size
= 1; line_modulo
= line_bytecnt
/ 1;
1959 buffer
= calloc(count
, size
);
1960 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1961 if (retval
== ERROR_OK
)
1965 for (i
= 0; i
< count
; i
++)
1967 if (i
%line_modulo
== 0)
1968 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1973 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1976 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1979 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1983 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1985 command_print(cmd_ctx
, output
);
1996 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2003 target_t
*target
= get_current_target(cmd_ctx
);
2006 if ((argc
< 2) || (argc
> 3))
2007 return ERROR_COMMAND_SYNTAX_ERROR
;
2009 address
= strtoul(args
[0], NULL
, 0);
2010 value
= strtoul(args
[1], NULL
, 0);
2012 count
= strtoul(args
[2], NULL
, 0);
2019 target_buffer_set_u32(target
, value_buf
, value
);
2023 target_buffer_set_u16(target
, value_buf
, value
);
2027 value_buf
[0] = value
;
2030 return ERROR_COMMAND_SYNTAX_ERROR
;
2032 for (i
=0; i
<count
; i
++)
2038 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2041 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2044 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2049 if (retval
!=ERROR_OK
)
2059 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2069 duration_t duration
;
2070 char *duration_text
;
2072 target_t
*target
= get_current_target(cmd_ctx
);
2076 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2080 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2083 image
.base_address_set
= 1;
2084 image
.base_address
= strtoul(args
[1], NULL
, 0);
2088 image
.base_address_set
= 0;
2091 image
.start_address_set
= 0;
2093 duration_start_measure(&duration
);
2095 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2102 for (i
= 0; i
< image
.num_sections
; i
++)
2104 buffer
= malloc(image
.sections
[i
].size
);
2107 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2111 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2116 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2121 image_size
+= buf_cnt
;
2122 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2127 duration_stop_measure(&duration
, &duration_text
);
2128 if (retval
==ERROR_OK
)
2130 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2132 free(duration_text
);
2134 image_close(&image
);
2140 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2147 int retval
=ERROR_OK
;
2149 duration_t duration
;
2150 char *duration_text
;
2152 target_t
*target
= get_current_target(cmd_ctx
);
2156 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2160 address
= strtoul(args
[1], NULL
, 0);
2161 size
= strtoul(args
[2], NULL
, 0);
2163 if ((address
& 3) || (size
& 3))
2165 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2169 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2174 duration_start_measure(&duration
);
2179 u32 this_run_size
= (size
> 560) ? 560 : size
;
2181 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2182 if (retval
!= ERROR_OK
)
2187 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2188 if (retval
!= ERROR_OK
)
2193 size
-= this_run_size
;
2194 address
+= this_run_size
;
2197 fileio_close(&fileio
);
2199 duration_stop_measure(&duration
, &duration_text
);
2200 if (retval
==ERROR_OK
)
2202 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2204 free(duration_text
);
2209 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2217 u32 mem_checksum
= 0;
2221 duration_t duration
;
2222 char *duration_text
;
2224 target_t
*target
= get_current_target(cmd_ctx
);
2228 return ERROR_COMMAND_SYNTAX_ERROR
;
2233 LOG_ERROR("no target selected");
2237 duration_start_measure(&duration
);
2241 image
.base_address_set
= 1;
2242 image
.base_address
= strtoul(args
[1], NULL
, 0);
2246 image
.base_address_set
= 0;
2247 image
.base_address
= 0x0;
2250 image
.start_address_set
= 0;
2252 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2259 for (i
= 0; i
< image
.num_sections
; i
++)
2261 buffer
= malloc(image
.sections
[i
].size
);
2264 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2267 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2273 /* calculate checksum of image */
2274 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2276 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2277 if( retval
!= ERROR_OK
)
2283 if( checksum
!= mem_checksum
)
2285 /* failed crc checksum, fall back to a binary compare */
2288 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2290 data
= (u8
*)malloc(buf_cnt
);
2292 /* Can we use 32bit word accesses? */
2294 int count
= buf_cnt
;
2295 if ((count
% 4) == 0)
2300 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2301 if (retval
== ERROR_OK
)
2304 for (t
= 0; t
< buf_cnt
; t
++)
2306 if (data
[t
] != buffer
[t
])
2308 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
]);
2321 image_size
+= buf_cnt
;
2324 duration_stop_measure(&duration
, &duration_text
);
2325 if (retval
==ERROR_OK
)
2327 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2329 free(duration_text
);
2331 image_close(&image
);
2336 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2339 target_t
*target
= get_current_target(cmd_ctx
);
2343 breakpoint_t
*breakpoint
= target
->breakpoints
;
2347 if (breakpoint
->type
== BKPT_SOFT
)
2349 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2350 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2355 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2357 breakpoint
= breakpoint
->next
;
2365 length
= strtoul(args
[1], NULL
, 0);
2368 if (strcmp(args
[2], "hw") == 0)
2371 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2373 LOG_ERROR("Failure setting breakpoints");
2377 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2382 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2388 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2390 target_t
*target
= get_current_target(cmd_ctx
);
2393 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2398 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2400 target_t
*target
= get_current_target(cmd_ctx
);
2405 watchpoint_t
*watchpoint
= target
->watchpoints
;
2409 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
);
2410 watchpoint
= watchpoint
->next
;
2415 enum watchpoint_rw type
= WPT_ACCESS
;
2416 u32 data_value
= 0x0;
2417 u32 data_mask
= 0xffffffff;
2433 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2439 data_value
= strtoul(args
[3], NULL
, 0);
2443 data_mask
= strtoul(args
[4], NULL
, 0);
2446 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2447 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2449 LOG_ERROR("Failure setting breakpoints");
2454 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2460 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2462 target_t
*target
= get_current_target(cmd_ctx
);
2465 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2470 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2473 target_t
*target
= get_current_target(cmd_ctx
);
2479 return ERROR_COMMAND_SYNTAX_ERROR
;
2481 va
= strtoul(args
[0], NULL
, 0);
2483 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2484 if (retval
== ERROR_OK
)
2486 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2490 /* lower levels will have logged a detailed error which is
2491 * forwarded to telnet/GDB session.
2496 static void writeLong(FILE *f
, int l
)
2501 char c
=(l
>>(i
*8))&0xff;
2502 fwrite(&c
, 1, 1, f
);
2506 static void writeString(FILE *f
, char *s
)
2508 fwrite(s
, 1, strlen(s
), f
);
2513 // Dump a gmon.out histogram file.
2514 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2517 FILE *f
=fopen(filename
, "w");
2520 fwrite("gmon", 1, 4, f
);
2521 writeLong(f
, 0x00000001); // Version
2522 writeLong(f
, 0); // padding
2523 writeLong(f
, 0); // padding
2524 writeLong(f
, 0); // padding
2526 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2528 // figure out bucket size
2531 for (i
=0; i
<sampleNum
; i
++)
2543 int addressSpace
=(max
-min
+1);
2545 static int const maxBuckets
=256*1024; // maximum buckets.
2546 int length
=addressSpace
;
2547 if (length
> maxBuckets
)
2551 int *buckets
=malloc(sizeof(int)*length
);
2557 memset(buckets
, 0, sizeof(int)*length
);
2558 for (i
=0; i
<sampleNum
;i
++)
2560 u32 address
=samples
[i
];
2561 long long a
=address
-min
;
2562 long long b
=length
-1;
2563 long long c
=addressSpace
-1;
2564 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2568 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2569 writeLong(f
, min
); // low_pc
2570 writeLong(f
, max
); // high_pc
2571 writeLong(f
, length
); // # of samples
2572 writeLong(f
, 64000000); // 64MHz
2573 writeString(f
, "seconds");
2574 for (i
=0; i
<(15-strlen("seconds")); i
++)
2576 fwrite("", 1, 1, f
); // padding
2578 writeString(f
, "s");
2580 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2582 char *data
=malloc(2*length
);
2585 for (i
=0; i
<length
;i
++)
2594 data
[i
*2+1]=(val
>>8)&0xff;
2597 fwrite(data
, 1, length
*2, f
);
2607 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2608 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2610 target_t
*target
= get_current_target(cmd_ctx
);
2611 struct timeval timeout
, now
;
2613 gettimeofday(&timeout
, NULL
);
2616 return ERROR_COMMAND_SYNTAX_ERROR
;
2619 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2625 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2627 static const int maxSample
=10000;
2628 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2633 int retval
=ERROR_OK
;
2634 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2635 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2639 target_poll(target
);
2640 if (target
->state
== TARGET_HALTED
)
2642 u32 t
=*((u32
*)reg
->value
);
2643 samples
[numSamples
++]=t
;
2644 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2645 target_poll(target
);
2646 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2647 } else if (target
->state
== TARGET_RUNNING
)
2649 // We want to quickly sample the PC.
2650 target_halt(target
);
2653 command_print(cmd_ctx
, "Target not halted or running");
2657 if (retval
!=ERROR_OK
)
2662 gettimeofday(&now
, NULL
);
2663 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2665 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2666 target_poll(target
);
2667 if (target
->state
== TARGET_HALTED
)
2669 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2671 target_poll(target
);
2672 writeGmon(samples
, numSamples
, args
[1]);
2673 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)