1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "target_request.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
37 #include <sys/types.h>
45 #include <time_support.h>
50 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
52 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
81 extern target_type_t arm7tdmi_target
;
82 extern target_type_t arm720t_target
;
83 extern target_type_t arm9tdmi_target
;
84 extern target_type_t arm920t_target
;
85 extern target_type_t arm966e_target
;
86 extern target_type_t arm926ejs_target
;
87 extern target_type_t feroceon_target
;
88 extern target_type_t xscale_target
;
89 extern target_type_t cortexm3_target
;
90 extern target_type_t arm11_target
;
92 target_type_t
*target_types
[] =
107 target_t
*targets
= NULL
;
108 target_event_callback_t
*target_event_callbacks
= NULL
;
109 target_timer_callback_t
*target_timer_callbacks
= NULL
;
111 char *target_state_strings
[] =
120 char *target_debug_reason_strings
[] =
122 "debug request", "breakpoint", "watchpoint",
123 "watchpoint and breakpoint", "single step",
124 "target not halted", "undefined"
127 char *target_endianess_strings
[] =
133 static int target_continous_poll
= 1;
135 /* read a u32 from a buffer in target memory endianness */
136 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
138 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
139 return le_to_h_u32(buffer
);
141 return be_to_h_u32(buffer
);
144 /* read a u16 from a buffer in target memory endianness */
145 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
147 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
148 return le_to_h_u16(buffer
);
150 return be_to_h_u16(buffer
);
153 /* write a u32 to a buffer in target memory endianness */
154 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
156 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
157 h_u32_to_le(buffer
, value
);
159 h_u32_to_be(buffer
, value
);
162 /* write a u16 to a buffer in target memory endianness */
163 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
165 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
166 h_u16_to_le(buffer
, value
);
168 h_u16_to_be(buffer
, value
);
171 /* returns a pointer to the n-th configured target */
172 target_t
* get_target_by_num(int num
)
174 target_t
*target
= targets
;
181 target
= target
->next
;
188 int get_num_by_target(target_t
*query_target
)
190 target_t
*target
= targets
;
195 if (target
== query_target
)
197 target
= target
->next
;
204 target_t
* get_current_target(command_context_t
*cmd_ctx
)
206 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
210 LOG_ERROR("BUG: current_target out of bounds");
217 /* Process target initialization, when target entered debug out of reset
218 * the handler is unregistered at the end of this function, so it's only called once
220 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
222 struct command_context_s
*cmd_ctx
= priv
;
224 if (event
== TARGET_EVENT_HALTED
)
226 target_unregister_event_callback(target_init_handler
, priv
);
227 target_invoke_script(cmd_ctx
, target
, "post_reset");
228 jtag_execute_queue();
234 int target_run_and_halt_handler(void *priv
)
236 target_t
*target
= priv
;
243 int target_poll(struct target_s
*target
)
245 /* We can't poll until after examine */
246 if (!target
->type
->examined
)
248 /* Fail silently lest we pollute the log */
251 return target
->type
->poll(target
);
254 int target_halt(struct target_s
*target
)
256 /* We can't poll until after examine */
257 if (!target
->type
->examined
)
259 LOG_ERROR("Target not examined yet");
262 return target
->type
->halt(target
);
265 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
268 int timeout_ms
= 5000;
270 enum target_state resume_state
= debug_execution
? TARGET_DEBUG_RUNNING
: TARGET_RUNNING
;
272 /* We can't poll until after examine */
273 if (!target
->type
->examined
)
275 LOG_ERROR("Target not examined yet");
279 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
282 /* wait for target to exit halted mode */
285 while (target
->state
!= resume_state
)
289 if ((timeout_ms
-= 10) <= 0)
291 LOG_ERROR("timeout waiting for target resume");
292 return ERROR_TARGET_TIMEOUT
;
299 int target_process_reset(struct command_context_s
*cmd_ctx
)
301 int retval
= ERROR_OK
;
303 struct timeval timeout
, now
;
305 jtag
->speed(jtag_speed
);
310 target_invoke_script(cmd_ctx
, target
, "pre_reset");
311 target
= target
->next
;
314 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
317 /* First time this is executed after launching OpenOCD, it will read out
318 * the type of CPU, etc. and init Embedded ICE registers in host
321 * It will also set up ICE registers in the target.
323 * However, if we assert TRST later, we need to set up the registers again.
325 * For the "reset halt/init" case we must only set up the registers here.
327 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
330 /* prepare reset_halt where necessary */
334 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
336 switch (target
->reset_mode
)
339 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
340 target
->reset_mode
= RESET_RUN_AND_HALT
;
343 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
344 target
->reset_mode
= RESET_RUN_AND_INIT
;
350 target
= target
->next
;
356 /* we have no idea what state the target is in, so we
357 * have to drop working areas
359 target_free_all_working_areas_restore(target
, 0);
360 target
->type
->assert_reset(target
);
361 target
= target
->next
;
363 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
365 LOG_WARNING("JTAG communication failed asserting reset.");
369 /* request target halt if necessary, and schedule further action */
373 switch (target
->reset_mode
)
376 /* nothing to do if target just wants to be run */
378 case RESET_RUN_AND_HALT
:
380 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
382 case RESET_RUN_AND_INIT
:
384 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
385 target_register_event_callback(target_init_handler
, cmd_ctx
);
392 target_register_event_callback(target_init_handler
, cmd_ctx
);
395 LOG_ERROR("BUG: unknown target->reset_mode");
397 target
= target
->next
;
400 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
402 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
409 target
->type
->deassert_reset(target
);
410 target
= target
->next
;
413 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
415 LOG_WARNING("JTAG communication failed while deasserting reset.");
419 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
421 /* If TRST was asserted we need to set up registers again */
422 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
427 LOG_DEBUG("Waiting for halted stated as approperiate");
429 /* Wait for reset to complete, maximum 5 seconds. */
430 gettimeofday(&timeout
, NULL
);
431 timeval_add_time(&timeout
, 5, 0);
434 gettimeofday(&now
, NULL
);
436 target_call_timer_callbacks_now();
441 LOG_DEBUG("Polling target");
443 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
444 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
445 (target
->reset_mode
== RESET_HALT
) ||
446 (target
->reset_mode
== RESET_INIT
))
448 if (target
->state
!= TARGET_HALTED
)
450 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
452 LOG_USER("Timed out waiting for halt after reset");
455 /* this will send alive messages on e.g. GDB remote protocol. */
457 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
461 target
= target
->next
;
463 /* All targets we're waiting for are halted */
471 /* We want any events to be processed before the prompt */
472 target_call_timer_callbacks_now();
474 /* if we timed out we need to unregister these handlers */
478 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
479 target
= target
->next
;
481 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
483 jtag
->speed(jtag_speed_post_reset
);
488 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
494 static int default_mmu(struct target_s
*target
, int *enabled
)
500 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
502 target
->type
->examined
= 1;
507 /* Targets that correctly implement init+examine, i.e.
508 * no communication with target during init:
512 int target_examine(struct command_context_s
*cmd_ctx
)
514 int retval
= ERROR_OK
;
515 target_t
*target
= targets
;
518 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
520 target
= target
->next
;
525 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
527 if (!target
->type
->examined
)
529 LOG_ERROR("Target not examined yet");
532 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
535 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
537 if (!target
->type
->examined
)
539 LOG_ERROR("Target not examined yet");
542 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
545 static int target_soft_reset_halt_imp(struct target_s
*target
)
547 if (!target
->type
->examined
)
549 LOG_ERROR("Target not examined yet");
552 return target
->type
->soft_reset_halt_imp(target
);
555 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
)
557 if (!target
->type
->examined
)
559 LOG_ERROR("Target not examined yet");
562 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
);
565 int target_init(struct command_context_s
*cmd_ctx
)
567 target_t
*target
= targets
;
571 target
->type
->examined
= 0;
572 if (target
->type
->examine
== NULL
)
574 target
->type
->examine
= default_examine
;
577 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
579 LOG_ERROR("target '%s' init failed", target
->type
->name
);
583 /* Set up default functions if none are provided by target */
584 if (target
->type
->virt2phys
== NULL
)
586 target
->type
->virt2phys
= default_virt2phys
;
588 target
->type
->virt2phys
= default_virt2phys
;
589 /* a non-invasive way(in terms of patches) to add some code that
590 * runs before the type->write/read_memory implementation
592 target
->type
->write_memory_imp
= target
->type
->write_memory
;
593 target
->type
->write_memory
= target_write_memory_imp
;
594 target
->type
->read_memory_imp
= target
->type
->read_memory
;
595 target
->type
->read_memory
= target_read_memory_imp
;
596 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
597 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
598 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
599 target
->type
->run_algorithm
= target_run_algorithm_imp
;
602 if (target
->type
->mmu
== NULL
)
604 target
->type
->mmu
= default_mmu
;
606 target
= target
->next
;
611 target_register_user_commands(cmd_ctx
);
612 target_register_timer_callback(handle_target
, 100, 1, NULL
);
618 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
620 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
622 if (callback
== NULL
)
624 return ERROR_INVALID_ARGUMENTS
;
629 while ((*callbacks_p
)->next
)
630 callbacks_p
= &((*callbacks_p
)->next
);
631 callbacks_p
= &((*callbacks_p
)->next
);
634 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
635 (*callbacks_p
)->callback
= callback
;
636 (*callbacks_p
)->priv
= priv
;
637 (*callbacks_p
)->next
= NULL
;
642 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
644 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
647 if (callback
== NULL
)
649 return ERROR_INVALID_ARGUMENTS
;
654 while ((*callbacks_p
)->next
)
655 callbacks_p
= &((*callbacks_p
)->next
);
656 callbacks_p
= &((*callbacks_p
)->next
);
659 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
660 (*callbacks_p
)->callback
= callback
;
661 (*callbacks_p
)->periodic
= periodic
;
662 (*callbacks_p
)->time_ms
= time_ms
;
664 gettimeofday(&now
, NULL
);
665 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
666 time_ms
-= (time_ms
% 1000);
667 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
668 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
670 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
671 (*callbacks_p
)->when
.tv_sec
+= 1;
674 (*callbacks_p
)->priv
= priv
;
675 (*callbacks_p
)->next
= NULL
;
680 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
682 target_event_callback_t
**p
= &target_event_callbacks
;
683 target_event_callback_t
*c
= target_event_callbacks
;
685 if (callback
== NULL
)
687 return ERROR_INVALID_ARGUMENTS
;
692 target_event_callback_t
*next
= c
->next
;
693 if ((c
->callback
== callback
) && (c
->priv
== priv
))
707 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
709 target_timer_callback_t
**p
= &target_timer_callbacks
;
710 target_timer_callback_t
*c
= target_timer_callbacks
;
712 if (callback
== NULL
)
714 return ERROR_INVALID_ARGUMENTS
;
719 target_timer_callback_t
*next
= c
->next
;
720 if ((c
->callback
== callback
) && (c
->priv
== priv
))
734 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
736 target_event_callback_t
*callback
= target_event_callbacks
;
737 target_event_callback_t
*next_callback
;
739 LOG_DEBUG("target event %i", event
);
743 next_callback
= callback
->next
;
744 callback
->callback(target
, event
, callback
->priv
);
745 callback
= next_callback
;
751 static int target_call_timer_callbacks_check_time(int checktime
)
753 target_timer_callback_t
*callback
= target_timer_callbacks
;
754 target_timer_callback_t
*next_callback
;
757 gettimeofday(&now
, NULL
);
761 next_callback
= callback
->next
;
763 if ((!checktime
&&callback
->periodic
)||
764 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
765 || (now
.tv_sec
> callback
->when
.tv_sec
)))
767 if(callback
->callback
!= NULL
)
769 callback
->callback(callback
->priv
);
770 if (callback
->periodic
)
772 int time_ms
= callback
->time_ms
;
773 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
774 time_ms
-= (time_ms
% 1000);
775 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
776 if (callback
->when
.tv_usec
> 1000000)
778 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
779 callback
->when
.tv_sec
+= 1;
783 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
787 callback
= next_callback
;
793 int target_call_timer_callbacks()
795 return target_call_timer_callbacks_check_time(1);
798 /* invoke periodic callbacks immediately */
799 int target_call_timer_callbacks_now()
801 return target_call_timer_callbacks(0);
804 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
806 working_area_t
*c
= target
->working_areas
;
807 working_area_t
*new_wa
= NULL
;
809 /* Reevaluate working area address based on MMU state*/
810 if (target
->working_areas
== NULL
)
814 retval
= target
->type
->mmu(target
, &enabled
);
815 if (retval
!= ERROR_OK
)
821 target
->working_area
= target
->working_area_virt
;
825 target
->working_area
= target
->working_area_phys
;
829 /* only allocate multiples of 4 byte */
832 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
833 size
= CEIL(size
, 4);
836 /* see if there's already a matching working area */
839 if ((c
->free
) && (c
->size
== size
))
847 /* if not, allocate a new one */
850 working_area_t
**p
= &target
->working_areas
;
851 u32 first_free
= target
->working_area
;
852 u32 free_size
= target
->working_area_size
;
854 LOG_DEBUG("allocating new working area");
856 c
= target
->working_areas
;
859 first_free
+= c
->size
;
860 free_size
-= c
->size
;
865 if (free_size
< size
)
867 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
868 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
871 new_wa
= malloc(sizeof(working_area_t
));
874 new_wa
->address
= first_free
;
876 if (target
->backup_working_area
)
878 new_wa
->backup
= malloc(new_wa
->size
);
879 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
883 new_wa
->backup
= NULL
;
886 /* put new entry in list */
890 /* mark as used, and return the new (reused) area */
900 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
905 if (restore
&&target
->backup_working_area
)
906 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
910 /* mark user pointer invalid */
917 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
919 return target_free_working_area_restore(target
, area
, 1);
922 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
924 working_area_t
*c
= target
->working_areas
;
928 working_area_t
*next
= c
->next
;
929 target_free_working_area_restore(target
, c
, restore
);
939 target
->working_areas
= NULL
;
944 int target_free_all_working_areas(struct target_s
*target
)
946 return target_free_all_working_areas_restore(target
, 1);
949 int target_register_commands(struct command_context_s
*cmd_ctx
)
951 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
952 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
953 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
,
954 "target_script <target#> <event=reset/pre_reset/post_halt/pre_resume/gdb_program_config> <script_file>");
955 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
956 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
957 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
958 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
963 int target_arch_state(struct target_s
*target
)
968 LOG_USER("No target has been configured");
972 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
974 if (target
->state
!=TARGET_HALTED
)
977 retval
=target
->type
->arch_state(target
);
981 /* Single aligned words are guaranteed to use 16 or 32 bit access
982 * mode respectively, otherwise data is handled as quickly as
985 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
988 if (!target
->type
->examined
)
990 LOG_ERROR("Target not examined yet");
994 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
996 if (((address
% 2) == 0) && (size
== 2))
998 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
1001 /* handle unaligned head bytes */
1004 int unaligned
= 4 - (address
% 4);
1006 if (unaligned
> size
)
1009 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1012 buffer
+= unaligned
;
1013 address
+= unaligned
;
1017 /* handle aligned words */
1020 int aligned
= size
- (size
% 4);
1022 /* use bulk writes above a certain limit. This may have to be changed */
1025 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1030 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1039 /* handle tail writes of less than 4 bytes */
1042 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1050 /* Single aligned words are guaranteed to use 16 or 32 bit access
1051 * mode respectively, otherwise data is handled as quickly as
1054 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1057 if (!target
->type
->examined
)
1059 LOG_ERROR("Target not examined yet");
1063 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1065 if (((address
% 2) == 0) && (size
== 2))
1067 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1070 /* handle unaligned head bytes */
1073 int unaligned
= 4 - (address
% 4);
1075 if (unaligned
> size
)
1078 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1081 buffer
+= unaligned
;
1082 address
+= unaligned
;
1086 /* handle aligned words */
1089 int aligned
= size
- (size
% 4);
1091 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1099 /* handle tail writes of less than 4 bytes */
1102 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1109 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1115 if (!target
->type
->examined
)
1117 LOG_ERROR("Target not examined yet");
1121 if ((retval
= target
->type
->checksum_memory(target
, address
,
1122 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1124 buffer
= malloc(size
);
1127 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1128 return ERROR_INVALID_ARGUMENTS
;
1130 retval
= target_read_buffer(target
, address
, size
, buffer
);
1131 if (retval
!= ERROR_OK
)
1137 /* convert to target endianess */
1138 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1141 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1142 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1145 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1154 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1157 if (!target
->type
->examined
)
1159 LOG_ERROR("Target not examined yet");
1163 if (target
->type
->blank_check_memory
== 0)
1164 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1166 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1171 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1174 if (!target
->type
->examined
)
1176 LOG_ERROR("Target not examined yet");
1180 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1182 if (retval
== ERROR_OK
)
1184 *value
= target_buffer_get_u32(target
, value_buf
);
1185 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1190 LOG_DEBUG("address: 0x%8.8x failed", address
);
1196 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1199 if (!target
->type
->examined
)
1201 LOG_ERROR("Target not examined yet");
1205 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1207 if (retval
== ERROR_OK
)
1209 *value
= target_buffer_get_u16(target
, value_buf
);
1210 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1215 LOG_DEBUG("address: 0x%8.8x failed", address
);
1221 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1223 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1224 if (!target
->type
->examined
)
1226 LOG_ERROR("Target not examined yet");
1230 if (retval
== ERROR_OK
)
1232 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1237 LOG_DEBUG("address: 0x%8.8x failed", address
);
1243 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1247 if (!target
->type
->examined
)
1249 LOG_ERROR("Target not examined yet");
1253 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1255 target_buffer_set_u32(target
, value_buf
, value
);
1256 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1258 LOG_DEBUG("failed: %i", retval
);
1264 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1268 if (!target
->type
->examined
)
1270 LOG_ERROR("Target not examined yet");
1274 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1276 target_buffer_set_u16(target
, value_buf
, value
);
1277 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1279 LOG_DEBUG("failed: %i", retval
);
1285 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1288 if (!target
->type
->examined
)
1290 LOG_ERROR("Target not examined yet");
1294 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1296 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1298 LOG_DEBUG("failed: %i", retval
);
1304 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1306 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1307 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1308 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1309 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1310 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1311 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1312 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1313 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1315 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1316 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1317 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1319 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1320 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1321 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1323 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1324 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1325 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1326 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1328 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1329 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1330 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1331 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1332 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1334 target_request_register_commands(cmd_ctx
);
1335 trace_register_commands(cmd_ctx
);
1340 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1342 target_t
*target
= targets
;
1347 int num
= strtoul(args
[0], NULL
, 0);
1352 target
= target
->next
;
1356 cmd_ctx
->current_target
= num
;
1358 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1365 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1366 target
= target
->next
;
1372 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1379 return ERROR_COMMAND_SYNTAX_ERROR
;
1382 /* search for the specified target */
1383 if (args
[0] && (args
[0][0] != 0))
1385 for (i
= 0; target_types
[i
]; i
++)
1387 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1389 target_t
**last_target_p
= &targets
;
1391 /* register target specific commands */
1392 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1394 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1400 while ((*last_target_p
)->next
)
1401 last_target_p
= &((*last_target_p
)->next
);
1402 last_target_p
= &((*last_target_p
)->next
);
1405 *last_target_p
= malloc(sizeof(target_t
));
1407 /* allocate memory for each unique target type */
1408 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1409 *((*last_target_p
)->type
) = *target_types
[i
];
1411 if (strcmp(args
[1], "big") == 0)
1412 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1413 else if (strcmp(args
[1], "little") == 0)
1414 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1417 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1418 return ERROR_COMMAND_SYNTAX_ERROR
;
1421 /* what to do on a target reset */
1422 (*last_target_p
)->reset_mode
= RESET_INIT
; /* default */
1423 if (strcmp(args
[2], "reset_halt") == 0)
1424 (*last_target_p
)->reset_mode
= RESET_HALT
;
1425 else if (strcmp(args
[2], "reset_run") == 0)
1426 (*last_target_p
)->reset_mode
= RESET_RUN
;
1427 else if (strcmp(args
[2], "reset_init") == 0)
1428 (*last_target_p
)->reset_mode
= RESET_INIT
;
1429 else if (strcmp(args
[2], "run_and_halt") == 0)
1430 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1431 else if (strcmp(args
[2], "run_and_init") == 0)
1432 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1435 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1439 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1441 (*last_target_p
)->working_area
= 0x0;
1442 (*last_target_p
)->working_area_size
= 0x0;
1443 (*last_target_p
)->working_areas
= NULL
;
1444 (*last_target_p
)->backup_working_area
= 0;
1446 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1447 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1448 (*last_target_p
)->reg_cache
= NULL
;
1449 (*last_target_p
)->breakpoints
= NULL
;
1450 (*last_target_p
)->watchpoints
= NULL
;
1451 (*last_target_p
)->next
= NULL
;
1452 (*last_target_p
)->arch_info
= NULL
;
1454 /* initialize trace information */
1455 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1456 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1457 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1458 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1459 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1460 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1461 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1462 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1464 (*last_target_p
)->dbgmsg
= NULL
;
1465 (*last_target_p
)->dbg_msg_enabled
= 0;
1467 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1475 /* no matching target found */
1478 LOG_ERROR("target '%s' not found", args
[0]);
1479 return ERROR_COMMAND_SYNTAX_ERROR
;
1485 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1487 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
1488 name
, get_num_by_target(target
),
1489 name
, get_num_by_target(target
));
1492 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1494 target_t
*target
= NULL
;
1498 LOG_ERROR("incomplete target_script command");
1499 return ERROR_COMMAND_SYNTAX_ERROR
;
1502 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1506 return ERROR_COMMAND_SYNTAX_ERROR
;
1509 const char *event
=args
[1];
1510 if (strcmp("reset", event
)==0)
1516 /* Define a tcl procedure which we'll invoke upon some event */
1517 command_run_linef(cmd_ctx
,
1518 "proc target_%s_%d {} {"
1519 "openocd {script %s} ; return \"\""
1522 get_num_by_target(target
),
1528 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1530 target_t
*target
= NULL
;
1534 return ERROR_COMMAND_SYNTAX_ERROR
;
1537 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1540 return ERROR_COMMAND_SYNTAX_ERROR
;
1543 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1548 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1550 target_t
*target
= NULL
;
1552 if ((argc
< 4) || (argc
> 5))
1554 return ERROR_COMMAND_SYNTAX_ERROR
;
1557 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1560 return ERROR_COMMAND_SYNTAX_ERROR
;
1562 target_free_all_working_areas(target
);
1564 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1567 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1569 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1571 if (strcmp(args
[3], "backup") == 0)
1573 target
->backup_working_area
= 1;
1575 else if (strcmp(args
[3], "nobackup") == 0)
1577 target
->backup_working_area
= 0;
1581 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1582 return ERROR_COMMAND_SYNTAX_ERROR
;
1589 /* process target state changes */
1590 int handle_target(void *priv
)
1592 target_t
*target
= targets
;
1596 if (target_continous_poll
)
1598 /* polling may fail silently until the target has been examined */
1599 target_poll(target
);
1602 target
= target
->next
;
1608 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1617 target
= get_current_target(cmd_ctx
);
1619 /* list all available registers for the current target */
1622 reg_cache_t
*cache
= target
->reg_cache
;
1628 for (i
= 0; i
< cache
->num_regs
; i
++)
1630 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1631 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
);
1634 cache
= cache
->next
;
1640 /* access a single register by its ordinal number */
1641 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1643 int num
= strtoul(args
[0], NULL
, 0);
1644 reg_cache_t
*cache
= target
->reg_cache
;
1650 for (i
= 0; i
< cache
->num_regs
; i
++)
1654 reg
= &cache
->reg_list
[i
];
1660 cache
= cache
->next
;
1665 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1668 } else /* access a single register by its name */
1670 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1674 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1679 /* display a register */
1680 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1682 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1685 if (reg
->valid
== 0)
1687 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1688 if (arch_type
== NULL
)
1690 LOG_ERROR("BUG: encountered unregistered arch type");
1693 arch_type
->get(reg
);
1695 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1696 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1701 /* set register value */
1704 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1705 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1707 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1708 if (arch_type
== NULL
)
1710 LOG_ERROR("BUG: encountered unregistered arch type");
1714 arch_type
->set(reg
, buf
);
1716 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1717 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1725 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1730 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1732 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1734 target_t
*target
= get_current_target(cmd_ctx
);
1738 target_poll(target
);
1739 target_arch_state(target
);
1743 if (strcmp(args
[0], "on") == 0)
1745 target_continous_poll
= 1;
1747 else if (strcmp(args
[0], "off") == 0)
1749 target_continous_poll
= 0;
1753 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1761 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1769 ms
= strtoul(args
[0], &end
, 0) * 1000;
1772 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1777 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1780 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1783 struct timeval timeout
, now
;
1785 gettimeofday(&timeout
, NULL
);
1786 timeval_add_time(&timeout
, 0, ms
* 1000);
1788 target_t
*target
= get_current_target(cmd_ctx
);
1791 if ((retval
=target_poll(target
))!=ERROR_OK
)
1793 target_call_timer_callbacks_now();
1794 if (target
->state
== state
)
1801 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1804 gettimeofday(&now
, NULL
);
1805 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1807 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1815 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1818 target_t
*target
= get_current_target(cmd_ctx
);
1822 if ((retval
= target_halt(target
)) != ERROR_OK
)
1827 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1830 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1832 target_t
*target
= get_current_target(cmd_ctx
);
1834 LOG_USER("requesting target halt and executing a soft reset");
1836 target
->type
->soft_reset_halt(target
);
1841 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1843 target_t
*target
= get_current_target(cmd_ctx
);
1844 enum target_reset_mode reset_mode
= target
->reset_mode
;
1845 enum target_reset_mode save
= target
->reset_mode
;
1851 if (strcmp("run", args
[0]) == 0)
1852 reset_mode
= RESET_RUN
;
1853 else if (strcmp("halt", args
[0]) == 0)
1854 reset_mode
= RESET_HALT
;
1855 else if (strcmp("init", args
[0]) == 0)
1856 reset_mode
= RESET_INIT
;
1857 else if (strcmp("run_and_halt", args
[0]) == 0)
1859 reset_mode
= RESET_RUN_AND_HALT
;
1862 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1865 else if (strcmp("run_and_init", args
[0]) == 0)
1867 reset_mode
= RESET_RUN_AND_INIT
;
1870 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1875 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1880 /* temporarily modify mode of current reset target */
1881 target
->reset_mode
= reset_mode
;
1883 /* reset *all* targets */
1884 target_process_reset(cmd_ctx
);
1886 /* Restore default reset mode for this target */
1887 target
->reset_mode
= save
;
1892 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1895 target_t
*target
= get_current_target(cmd_ctx
);
1897 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1900 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1902 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1905 return ERROR_COMMAND_SYNTAX_ERROR
;
1911 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1913 target_t
*target
= get_current_target(cmd_ctx
);
1918 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1921 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1926 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1928 const int line_bytecnt
= 32;
1941 target_t
*target
= get_current_target(cmd_ctx
);
1947 count
= strtoul(args
[1], NULL
, 0);
1949 address
= strtoul(args
[0], NULL
, 0);
1955 size
= 4; line_modulo
= line_bytecnt
/ 4;
1958 size
= 2; line_modulo
= line_bytecnt
/ 2;
1961 size
= 1; line_modulo
= line_bytecnt
/ 1;
1967 buffer
= calloc(count
, size
);
1968 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1969 if (retval
== ERROR_OK
)
1973 for (i
= 0; i
< count
; i
++)
1975 if (i
%line_modulo
== 0)
1976 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1981 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1984 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1987 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1991 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1993 command_print(cmd_ctx
, output
);
2004 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2011 target_t
*target
= get_current_target(cmd_ctx
);
2014 if ((argc
< 2) || (argc
> 3))
2015 return ERROR_COMMAND_SYNTAX_ERROR
;
2017 address
= strtoul(args
[0], NULL
, 0);
2018 value
= strtoul(args
[1], NULL
, 0);
2020 count
= strtoul(args
[2], NULL
, 0);
2026 target_buffer_set_u32(target
, value_buf
, value
);
2030 target_buffer_set_u16(target
, value_buf
, value
);
2034 value_buf
[0] = value
;
2037 return ERROR_COMMAND_SYNTAX_ERROR
;
2039 for (i
=0; i
<count
; i
++)
2045 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2048 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2051 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2056 if (retval
!=ERROR_OK
)
2066 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2076 duration_t duration
;
2077 char *duration_text
;
2079 target_t
*target
= get_current_target(cmd_ctx
);
2083 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2087 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2090 image
.base_address_set
= 1;
2091 image
.base_address
= strtoul(args
[1], NULL
, 0);
2095 image
.base_address_set
= 0;
2098 image
.start_address_set
= 0;
2100 duration_start_measure(&duration
);
2102 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2109 for (i
= 0; i
< image
.num_sections
; i
++)
2111 buffer
= malloc(image
.sections
[i
].size
);
2114 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2118 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2123 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2128 image_size
+= buf_cnt
;
2129 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2134 duration_stop_measure(&duration
, &duration_text
);
2135 if (retval
==ERROR_OK
)
2137 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2139 free(duration_text
);
2141 image_close(&image
);
2147 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2154 int retval
=ERROR_OK
;
2156 duration_t duration
;
2157 char *duration_text
;
2159 target_t
*target
= get_current_target(cmd_ctx
);
2163 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2167 address
= strtoul(args
[1], NULL
, 0);
2168 size
= strtoul(args
[2], NULL
, 0);
2170 if ((address
& 3) || (size
& 3))
2172 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2176 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2181 duration_start_measure(&duration
);
2186 u32 this_run_size
= (size
> 560) ? 560 : size
;
2188 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2189 if (retval
!= ERROR_OK
)
2194 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2195 if (retval
!= ERROR_OK
)
2200 size
-= this_run_size
;
2201 address
+= this_run_size
;
2204 fileio_close(&fileio
);
2206 duration_stop_measure(&duration
, &duration_text
);
2207 if (retval
==ERROR_OK
)
2209 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2211 free(duration_text
);
2216 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2224 u32 mem_checksum
= 0;
2228 duration_t duration
;
2229 char *duration_text
;
2231 target_t
*target
= get_current_target(cmd_ctx
);
2235 return ERROR_COMMAND_SYNTAX_ERROR
;
2240 LOG_ERROR("no target selected");
2244 duration_start_measure(&duration
);
2248 image
.base_address_set
= 1;
2249 image
.base_address
= strtoul(args
[1], NULL
, 0);
2253 image
.base_address_set
= 0;
2254 image
.base_address
= 0x0;
2257 image
.start_address_set
= 0;
2259 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2266 for (i
= 0; i
< image
.num_sections
; i
++)
2268 buffer
= malloc(image
.sections
[i
].size
);
2271 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2274 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2280 /* calculate checksum of image */
2281 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2283 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2284 if( retval
!= ERROR_OK
)
2290 if( checksum
!= mem_checksum
)
2292 /* failed crc checksum, fall back to a binary compare */
2295 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2297 data
= (u8
*)malloc(buf_cnt
);
2299 /* Can we use 32bit word accesses? */
2301 int count
= buf_cnt
;
2302 if ((count
% 4) == 0)
2307 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2308 if (retval
== ERROR_OK
)
2311 for (t
= 0; t
< buf_cnt
; t
++)
2313 if (data
[t
] != buffer
[t
])
2315 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
]);
2328 image_size
+= buf_cnt
;
2331 duration_stop_measure(&duration
, &duration_text
);
2332 if (retval
==ERROR_OK
)
2334 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2336 free(duration_text
);
2338 image_close(&image
);
2343 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2346 target_t
*target
= get_current_target(cmd_ctx
);
2350 breakpoint_t
*breakpoint
= target
->breakpoints
;
2354 if (breakpoint
->type
== BKPT_SOFT
)
2356 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2357 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2362 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2364 breakpoint
= breakpoint
->next
;
2372 length
= strtoul(args
[1], NULL
, 0);
2375 if (strcmp(args
[2], "hw") == 0)
2378 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2380 LOG_ERROR("Failure setting breakpoints");
2384 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2389 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2395 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2397 target_t
*target
= get_current_target(cmd_ctx
);
2400 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2405 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2407 target_t
*target
= get_current_target(cmd_ctx
);
2412 watchpoint_t
*watchpoint
= target
->watchpoints
;
2416 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
);
2417 watchpoint
= watchpoint
->next
;
2422 enum watchpoint_rw type
= WPT_ACCESS
;
2423 u32 data_value
= 0x0;
2424 u32 data_mask
= 0xffffffff;
2440 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2446 data_value
= strtoul(args
[3], NULL
, 0);
2450 data_mask
= strtoul(args
[4], NULL
, 0);
2453 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2454 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2456 LOG_ERROR("Failure setting breakpoints");
2461 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2467 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2469 target_t
*target
= get_current_target(cmd_ctx
);
2472 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2477 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2480 target_t
*target
= get_current_target(cmd_ctx
);
2486 return ERROR_COMMAND_SYNTAX_ERROR
;
2488 va
= strtoul(args
[0], NULL
, 0);
2490 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2491 if (retval
== ERROR_OK
)
2493 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2497 /* lower levels will have logged a detailed error which is
2498 * forwarded to telnet/GDB session.
2503 static void writeLong(FILE *f
, int l
)
2508 char c
=(l
>>(i
*8))&0xff;
2509 fwrite(&c
, 1, 1, f
);
2513 static void writeString(FILE *f
, char *s
)
2515 fwrite(s
, 1, strlen(s
), f
);
2520 // Dump a gmon.out histogram file.
2521 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2524 FILE *f
=fopen(filename
, "w");
2527 fwrite("gmon", 1, 4, f
);
2528 writeLong(f
, 0x00000001); // Version
2529 writeLong(f
, 0); // padding
2530 writeLong(f
, 0); // padding
2531 writeLong(f
, 0); // padding
2533 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2535 // figure out bucket size
2538 for (i
=0; i
<sampleNum
; i
++)
2550 int addressSpace
=(max
-min
+1);
2552 static int const maxBuckets
=256*1024; // maximum buckets.
2553 int length
=addressSpace
;
2554 if (length
> maxBuckets
)
2558 int *buckets
=malloc(sizeof(int)*length
);
2564 memset(buckets
, 0, sizeof(int)*length
);
2565 for (i
=0; i
<sampleNum
;i
++)
2567 u32 address
=samples
[i
];
2568 long long a
=address
-min
;
2569 long long b
=length
-1;
2570 long long c
=addressSpace
-1;
2571 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2575 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2576 writeLong(f
, min
); // low_pc
2577 writeLong(f
, max
); // high_pc
2578 writeLong(f
, length
); // # of samples
2579 writeLong(f
, 64000000); // 64MHz
2580 writeString(f
, "seconds");
2581 for (i
=0; i
<(15-strlen("seconds")); i
++)
2583 fwrite("", 1, 1, f
); // padding
2585 writeString(f
, "s");
2587 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2589 char *data
=malloc(2*length
);
2592 for (i
=0; i
<length
;i
++)
2601 data
[i
*2+1]=(val
>>8)&0xff;
2604 fwrite(data
, 1, length
*2, f
);
2614 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2615 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2617 target_t
*target
= get_current_target(cmd_ctx
);
2618 struct timeval timeout
, now
;
2620 gettimeofday(&timeout
, NULL
);
2623 return ERROR_COMMAND_SYNTAX_ERROR
;
2626 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2632 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2634 static const int maxSample
=10000;
2635 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2640 int retval
=ERROR_OK
;
2641 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2642 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2646 target_poll(target
);
2647 if (target
->state
== TARGET_HALTED
)
2649 u32 t
=*((u32
*)reg
->value
);
2650 samples
[numSamples
++]=t
;
2651 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2652 target_poll(target
);
2653 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2654 } else if (target
->state
== TARGET_RUNNING
)
2656 // We want to quickly sample the PC.
2657 target_halt(target
);
2660 command_print(cmd_ctx
, "Target not halted or running");
2664 if (retval
!=ERROR_OK
)
2669 gettimeofday(&now
, NULL
);
2670 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2672 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2673 target_poll(target
);
2674 if (target
->state
== TARGET_HALTED
)
2676 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2678 target_poll(target
);
2679 writeGmon(samples
, numSamples
, args
[1]);
2680 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)