1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "target_request.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
37 #include <sys/types.h>
45 #include <time_support.h>
50 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
53 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 extern target_type_t arm7tdmi_target
;
83 extern target_type_t arm720t_target
;
84 extern target_type_t arm9tdmi_target
;
85 extern target_type_t arm920t_target
;
86 extern target_type_t arm966e_target
;
87 extern target_type_t arm926ejs_target
;
88 extern target_type_t feroceon_target
;
89 extern target_type_t xscale_target
;
90 extern target_type_t cortexm3_target
;
91 extern target_type_t arm11_target
;
93 target_type_t
*target_types
[] =
108 target_t
*targets
= NULL
;
109 target_event_callback_t
*target_event_callbacks
= NULL
;
110 target_timer_callback_t
*target_timer_callbacks
= NULL
;
112 char *target_state_strings
[] =
121 char *target_debug_reason_strings
[] =
123 "debug request", "breakpoint", "watchpoint",
124 "watchpoint and breakpoint", "single step",
125 "target not halted", "undefined"
128 char *target_endianess_strings
[] =
134 static int target_continous_poll
= 1;
136 /* read a u32 from a buffer in target memory endianness */
137 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
139 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
140 return le_to_h_u32(buffer
);
142 return be_to_h_u32(buffer
);
145 /* read a u16 from a buffer in target memory endianness */
146 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
148 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
149 return le_to_h_u16(buffer
);
151 return be_to_h_u16(buffer
);
154 /* write a u32 to a buffer in target memory endianness */
155 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
157 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
158 h_u32_to_le(buffer
, value
);
160 h_u32_to_be(buffer
, value
);
163 /* write a u16 to a buffer in target memory endianness */
164 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
166 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
167 h_u16_to_le(buffer
, value
);
169 h_u16_to_be(buffer
, value
);
172 /* returns a pointer to the n-th configured target */
173 target_t
* get_target_by_num(int num
)
175 target_t
*target
= targets
;
182 target
= target
->next
;
189 int get_num_by_target(target_t
*query_target
)
191 target_t
*target
= targets
;
196 if (target
== query_target
)
198 target
= target
->next
;
205 target_t
* get_current_target(command_context_t
*cmd_ctx
)
207 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
211 LOG_ERROR("BUG: current_target out of bounds");
218 /* Process target initialization, when target entered debug out of reset
219 * the handler is unregistered at the end of this function, so it's only called once
221 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
224 struct command_context_s
*cmd_ctx
= priv
;
226 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
228 target_unregister_event_callback(target_init_handler
, priv
);
230 script
= open_file_from_path(target
->reset_script
, "r");
233 LOG_ERROR("couldn't open script file %s", target
->reset_script
);
237 LOG_INFO("executing reset script '%s'", target
->reset_script
);
238 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
241 jtag_execute_queue();
247 int target_run_and_halt_handler(void *priv
)
249 target_t
*target
= priv
;
256 int target_poll(struct target_s
*target
)
258 /* We can't poll until after examine */
259 if (!target
->type
->examined
)
261 /* Fail silently lest we pollute the log */
264 return target
->type
->poll(target
);
267 int target_halt(struct target_s
*target
)
269 /* We can't poll until after examine */
270 if (!target
->type
->examined
)
272 LOG_ERROR("Target not examined yet");
275 return target
->type
->halt(target
);
278 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
280 /* We can't poll until after examine */
281 if (!target
->type
->examined
)
283 LOG_ERROR("Target not examined yet");
286 return target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
);
290 int target_process_reset(struct command_context_s
*cmd_ctx
)
292 int retval
= ERROR_OK
;
294 struct timeval timeout
, now
;
296 jtag
->speed(jtag_speed
);
298 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
301 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
304 /* prepare reset_halt where necessary */
308 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
310 switch (target
->reset_mode
)
313 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
314 target
->reset_mode
= RESET_RUN_AND_HALT
;
317 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
318 target
->reset_mode
= RESET_RUN_AND_INIT
;
324 target
= target
->next
;
330 /* we have no idea what state the target is in, so we
331 * have to drop working areas
333 target_free_all_working_areas_restore(target
, 0);
334 target
->type
->assert_reset(target
);
335 target
= target
->next
;
337 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
339 LOG_WARNING("JTAG communication failed asserting reset.");
343 /* request target halt if necessary, and schedule further action */
347 switch (target
->reset_mode
)
350 /* nothing to do if target just wants to be run */
352 case RESET_RUN_AND_HALT
:
354 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
356 case RESET_RUN_AND_INIT
:
358 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
359 target_register_event_callback(target_init_handler
, cmd_ctx
);
366 target_register_event_callback(target_init_handler
, cmd_ctx
);
369 LOG_ERROR("BUG: unknown target->reset_mode");
371 target
= target
->next
;
374 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
376 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
383 target
->type
->deassert_reset(target
);
384 target
= target
->next
;
387 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
389 LOG_WARNING("JTAG communication failed while deasserting reset.");
393 LOG_DEBUG("Waiting for halted stated as approperiate");
395 /* Wait for reset to complete, maximum 5 seconds. */
396 gettimeofday(&timeout
, NULL
);
397 timeval_add_time(&timeout
, 5, 0);
400 gettimeofday(&now
, NULL
);
402 target_call_timer_callbacks_now();
407 LOG_DEBUG("Polling target");
409 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
410 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
411 (target
->reset_mode
== RESET_HALT
) ||
412 (target
->reset_mode
== RESET_INIT
))
414 if (target
->state
!= TARGET_HALTED
)
416 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
418 LOG_USER("Timed out waiting for halt after reset");
421 /* this will send alive messages on e.g. GDB remote protocol. */
423 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
427 target
= target
->next
;
429 /* All targets we're waiting for are halted */
437 /* We want any events to be processed before the prompt */
438 target_call_timer_callbacks_now();
440 /* if we timed out we need to unregister these handlers */
444 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
445 target
= target
->next
;
447 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
450 jtag
->speed(jtag_speed_post_reset
);
455 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
461 static int default_mmu(struct target_s
*target
, int *enabled
)
467 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
469 target
->type
->examined
= 1;
474 /* Targets that correctly implement init+examine, i.e.
475 * no communication with target during init:
479 int target_examine(struct command_context_s
*cmd_ctx
)
481 int retval
= ERROR_OK
;
482 target_t
*target
= targets
;
485 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
487 target
= target
->next
;
493 int target_init(struct command_context_s
*cmd_ctx
)
495 target_t
*target
= targets
;
499 target
->type
->examined
= 0;
500 if (target
->type
->examine
== NULL
)
502 target
->type
->examine
= default_examine
;
505 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
507 LOG_ERROR("target '%s' init failed", target
->type
->name
);
511 /* Set up default functions if none are provided by target */
512 if (target
->type
->virt2phys
== NULL
)
514 target
->type
->virt2phys
= default_virt2phys
;
516 if (target
->type
->mmu
== NULL
)
518 target
->type
->mmu
= default_mmu
;
520 target
= target
->next
;
525 target_register_user_commands(cmd_ctx
);
526 target_register_timer_callback(handle_target
, 100, 1, NULL
);
532 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
534 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
536 if (callback
== NULL
)
538 return ERROR_INVALID_ARGUMENTS
;
543 while ((*callbacks_p
)->next
)
544 callbacks_p
= &((*callbacks_p
)->next
);
545 callbacks_p
= &((*callbacks_p
)->next
);
548 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
549 (*callbacks_p
)->callback
= callback
;
550 (*callbacks_p
)->priv
= priv
;
551 (*callbacks_p
)->next
= NULL
;
556 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
558 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
561 if (callback
== NULL
)
563 return ERROR_INVALID_ARGUMENTS
;
568 while ((*callbacks_p
)->next
)
569 callbacks_p
= &((*callbacks_p
)->next
);
570 callbacks_p
= &((*callbacks_p
)->next
);
573 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
574 (*callbacks_p
)->callback
= callback
;
575 (*callbacks_p
)->periodic
= periodic
;
576 (*callbacks_p
)->time_ms
= time_ms
;
578 gettimeofday(&now
, NULL
);
579 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
580 time_ms
-= (time_ms
% 1000);
581 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
582 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
584 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
585 (*callbacks_p
)->when
.tv_sec
+= 1;
588 (*callbacks_p
)->priv
= priv
;
589 (*callbacks_p
)->next
= NULL
;
594 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
596 target_event_callback_t
**p
= &target_event_callbacks
;
597 target_event_callback_t
*c
= target_event_callbacks
;
599 if (callback
== NULL
)
601 return ERROR_INVALID_ARGUMENTS
;
606 target_event_callback_t
*next
= c
->next
;
607 if ((c
->callback
== callback
) && (c
->priv
== priv
))
621 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
623 target_timer_callback_t
**p
= &target_timer_callbacks
;
624 target_timer_callback_t
*c
= target_timer_callbacks
;
626 if (callback
== NULL
)
628 return ERROR_INVALID_ARGUMENTS
;
633 target_timer_callback_t
*next
= c
->next
;
634 if ((c
->callback
== callback
) && (c
->priv
== priv
))
648 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
650 target_event_callback_t
*callback
= target_event_callbacks
;
651 target_event_callback_t
*next_callback
;
653 LOG_DEBUG("target event %i", event
);
657 next_callback
= callback
->next
;
658 callback
->callback(target
, event
, callback
->priv
);
659 callback
= next_callback
;
665 static int target_call_timer_callbacks_check_time(int checktime
)
667 target_timer_callback_t
*callback
= target_timer_callbacks
;
668 target_timer_callback_t
*next_callback
;
671 gettimeofday(&now
, NULL
);
675 next_callback
= callback
->next
;
677 if ((!checktime
&&callback
->periodic
)||
678 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
679 || (now
.tv_sec
> callback
->when
.tv_sec
)))
681 callback
->callback(callback
->priv
);
682 if (callback
->periodic
)
684 int time_ms
= callback
->time_ms
;
685 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
686 time_ms
-= (time_ms
% 1000);
687 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
688 if (callback
->when
.tv_usec
> 1000000)
690 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
691 callback
->when
.tv_sec
+= 1;
695 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
698 callback
= next_callback
;
704 int target_call_timer_callbacks()
706 return target_call_timer_callbacks_check_time(1);
709 /* invoke periodic callbacks immediately */
710 int target_call_timer_callbacks_now()
712 return target_call_timer_callbacks(0);
716 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
718 working_area_t
*c
= target
->working_areas
;
719 working_area_t
*new_wa
= NULL
;
721 /* Reevaluate working area address based on MMU state*/
722 if (target
->working_areas
== NULL
)
726 retval
= target
->type
->mmu(target
, &enabled
);
727 if (retval
!= ERROR_OK
)
733 target
->working_area
= target
->working_area_virt
;
737 target
->working_area
= target
->working_area_phys
;
741 /* only allocate multiples of 4 byte */
744 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
745 size
= CEIL(size
, 4);
748 /* see if there's already a matching working area */
751 if ((c
->free
) && (c
->size
== size
))
759 /* if not, allocate a new one */
762 working_area_t
**p
= &target
->working_areas
;
763 u32 first_free
= target
->working_area
;
764 u32 free_size
= target
->working_area_size
;
766 LOG_DEBUG("allocating new working area");
768 c
= target
->working_areas
;
771 first_free
+= c
->size
;
772 free_size
-= c
->size
;
777 if (free_size
< size
)
779 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
780 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
783 new_wa
= malloc(sizeof(working_area_t
));
786 new_wa
->address
= first_free
;
788 if (target
->backup_working_area
)
790 new_wa
->backup
= malloc(new_wa
->size
);
791 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
795 new_wa
->backup
= NULL
;
798 /* put new entry in list */
802 /* mark as used, and return the new (reused) area */
812 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
817 if (restore
&&target
->backup_working_area
)
818 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
822 /* mark user pointer invalid */
829 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
831 return target_free_working_area_restore(target
, area
, 1);
834 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
836 working_area_t
*c
= target
->working_areas
;
840 working_area_t
*next
= c
->next
;
841 target_free_working_area_restore(target
, c
, restore
);
851 target
->working_areas
= NULL
;
856 int target_free_all_working_areas(struct target_s
*target
)
858 return target_free_all_working_areas_restore(target
, 1);
861 int target_register_commands(struct command_context_s
*cmd_ctx
)
863 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
864 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
865 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
866 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
867 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
868 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
869 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
874 int target_arch_state(struct target_s
*target
)
879 LOG_USER("No target has been configured");
883 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
885 if (target
->state
!=TARGET_HALTED
)
888 retval
=target
->type
->arch_state(target
);
892 /* Single aligned words are guaranteed to use 16 or 32 bit access
893 * mode respectively, otherwise data is handled as quickly as
896 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
899 if (!target
->type
->examined
)
901 LOG_ERROR("Target not examined yet");
905 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
907 if (((address
% 2) == 0) && (size
== 2))
909 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
912 /* handle unaligned head bytes */
915 int unaligned
= 4 - (address
% 4);
917 if (unaligned
> size
)
920 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
924 address
+= unaligned
;
928 /* handle aligned words */
931 int aligned
= size
- (size
% 4);
933 /* use bulk writes above a certain limit. This may have to be changed */
936 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
941 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
950 /* handle tail writes of less than 4 bytes */
953 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
961 /* Single aligned words are guaranteed to use 16 or 32 bit access
962 * mode respectively, otherwise data is handled as quickly as
965 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
968 if (!target
->type
->examined
)
970 LOG_ERROR("Target not examined yet");
974 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
976 if (((address
% 2) == 0) && (size
== 2))
978 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
981 /* handle unaligned head bytes */
984 int unaligned
= 4 - (address
% 4);
986 if (unaligned
> size
)
989 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
993 address
+= unaligned
;
997 /* handle aligned words */
1000 int aligned
= size
- (size
% 4);
1002 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1010 /* handle tail writes of less than 4 bytes */
1013 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1020 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1026 if (!target
->type
->examined
)
1028 LOG_ERROR("Target not examined yet");
1032 if ((retval
= target
->type
->checksum_memory(target
, address
,
1033 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1035 buffer
= malloc(size
);
1038 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1039 return ERROR_INVALID_ARGUMENTS
;
1041 retval
= target_read_buffer(target
, address
, size
, buffer
);
1042 if (retval
!= ERROR_OK
)
1048 /* convert to target endianess */
1049 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1052 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1053 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1056 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1065 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1068 if (!target
->type
->examined
)
1070 LOG_ERROR("Target not examined yet");
1074 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1076 if (retval
== ERROR_OK
)
1078 *value
= target_buffer_get_u32(target
, value_buf
);
1079 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1084 LOG_DEBUG("address: 0x%8.8x failed", address
);
1090 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1093 if (!target
->type
->examined
)
1095 LOG_ERROR("Target not examined yet");
1099 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1101 if (retval
== ERROR_OK
)
1103 *value
= target_buffer_get_u16(target
, value_buf
);
1104 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1109 LOG_DEBUG("address: 0x%8.8x failed", address
);
1115 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1117 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1118 if (!target
->type
->examined
)
1120 LOG_ERROR("Target not examined yet");
1124 if (retval
== ERROR_OK
)
1126 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1131 LOG_DEBUG("address: 0x%8.8x failed", address
);
1137 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1141 if (!target
->type
->examined
)
1143 LOG_ERROR("Target not examined yet");
1147 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1149 target_buffer_set_u32(target
, value_buf
, value
);
1150 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1152 LOG_DEBUG("failed: %i", retval
);
1158 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1162 if (!target
->type
->examined
)
1164 LOG_ERROR("Target not examined yet");
1168 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1170 target_buffer_set_u16(target
, value_buf
, value
);
1171 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1173 LOG_DEBUG("failed: %i", retval
);
1179 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1182 if (!target
->type
->examined
)
1184 LOG_ERROR("Target not examined yet");
1188 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1190 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1192 LOG_DEBUG("failed: %i", retval
);
1198 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1200 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1201 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1202 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1203 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1204 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1205 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1206 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1207 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1209 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1210 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1211 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1213 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1214 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1215 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1217 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1218 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1219 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1220 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1222 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1223 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1224 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1225 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1226 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1228 target_request_register_commands(cmd_ctx
);
1229 trace_register_commands(cmd_ctx
);
1234 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1236 target_t
*target
= targets
;
1241 int num
= strtoul(args
[0], NULL
, 0);
1246 target
= target
->next
;
1250 cmd_ctx
->current_target
= num
;
1252 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1259 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1260 target
= target
->next
;
1266 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1273 return ERROR_COMMAND_SYNTAX_ERROR
;
1276 /* search for the specified target */
1277 if (args
[0] && (args
[0][0] != 0))
1279 for (i
= 0; target_types
[i
]; i
++)
1281 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1283 target_t
**last_target_p
= &targets
;
1285 /* register target specific commands */
1286 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1288 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1294 while ((*last_target_p
)->next
)
1295 last_target_p
= &((*last_target_p
)->next
);
1296 last_target_p
= &((*last_target_p
)->next
);
1299 *last_target_p
= malloc(sizeof(target_t
));
1301 (*last_target_p
)->type
= target_types
[i
];
1303 if (strcmp(args
[1], "big") == 0)
1304 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1305 else if (strcmp(args
[1], "little") == 0)
1306 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1309 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1310 return ERROR_COMMAND_SYNTAX_ERROR
;
1313 /* what to do on a target reset */
1314 (*last_target_p
)->reset_mode
= RESET_INIT
; /* default */
1315 if (strcmp(args
[2], "reset_halt") == 0)
1316 (*last_target_p
)->reset_mode
= RESET_HALT
;
1317 else if (strcmp(args
[2], "reset_run") == 0)
1318 (*last_target_p
)->reset_mode
= RESET_RUN
;
1319 else if (strcmp(args
[2], "reset_init") == 0)
1320 (*last_target_p
)->reset_mode
= RESET_INIT
;
1321 else if (strcmp(args
[2], "run_and_halt") == 0)
1322 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1323 else if (strcmp(args
[2], "run_and_init") == 0)
1324 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1327 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1331 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1333 (*last_target_p
)->reset_script
= NULL
;
1334 (*last_target_p
)->post_halt_script
= NULL
;
1335 (*last_target_p
)->pre_resume_script
= NULL
;
1336 (*last_target_p
)->gdb_program_script
= NULL
;
1338 (*last_target_p
)->working_area
= 0x0;
1339 (*last_target_p
)->working_area_size
= 0x0;
1340 (*last_target_p
)->working_areas
= NULL
;
1341 (*last_target_p
)->backup_working_area
= 0;
1343 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1344 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1345 (*last_target_p
)->reg_cache
= NULL
;
1346 (*last_target_p
)->breakpoints
= NULL
;
1347 (*last_target_p
)->watchpoints
= NULL
;
1348 (*last_target_p
)->next
= NULL
;
1349 (*last_target_p
)->arch_info
= NULL
;
1351 /* initialize trace information */
1352 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1353 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1354 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1355 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1356 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1357 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1358 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1359 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1361 (*last_target_p
)->dbgmsg
= NULL
;
1362 (*last_target_p
)->dbg_msg_enabled
= 0;
1364 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1372 /* no matching target found */
1375 LOG_ERROR("target '%s' not found", args
[0]);
1376 return ERROR_COMMAND_SYNTAX_ERROR
;
1382 /* usage: target_script <target#> <event> <script_file> */
1383 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1385 target_t
*target
= NULL
;
1389 LOG_ERROR("incomplete target_script command");
1390 return ERROR_COMMAND_SYNTAX_ERROR
;
1393 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1397 return ERROR_COMMAND_SYNTAX_ERROR
;
1400 if (strcmp(args
[1], "reset") == 0)
1402 if (target
->reset_script
)
1403 free(target
->reset_script
);
1404 target
->reset_script
= strdup(args
[2]);
1406 else if (strcmp(args
[1], "post_halt") == 0)
1408 if (target
->post_halt_script
)
1409 free(target
->post_halt_script
);
1410 target
->post_halt_script
= strdup(args
[2]);
1412 else if (strcmp(args
[1], "pre_resume") == 0)
1414 if (target
->pre_resume_script
)
1415 free(target
->pre_resume_script
);
1416 target
->pre_resume_script
= strdup(args
[2]);
1418 else if (strcmp(args
[1], "gdb_program_config") == 0)
1420 if (target
->gdb_program_script
)
1421 free(target
->gdb_program_script
);
1422 target
->gdb_program_script
= strdup(args
[2]);
1426 LOG_ERROR("unknown event type: '%s", args
[1]);
1427 return ERROR_COMMAND_SYNTAX_ERROR
;
1433 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1435 target_t
*target
= NULL
;
1439 return ERROR_COMMAND_SYNTAX_ERROR
;
1442 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1445 return ERROR_COMMAND_SYNTAX_ERROR
;
1448 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1453 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1455 target_t
*target
= NULL
;
1457 if ((argc
< 4) || (argc
> 5))
1459 return ERROR_COMMAND_SYNTAX_ERROR
;
1462 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1465 return ERROR_COMMAND_SYNTAX_ERROR
;
1467 target_free_all_working_areas(target
);
1469 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1472 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1474 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1476 if (strcmp(args
[3], "backup") == 0)
1478 target
->backup_working_area
= 1;
1480 else if (strcmp(args
[3], "nobackup") == 0)
1482 target
->backup_working_area
= 0;
1486 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1487 return ERROR_COMMAND_SYNTAX_ERROR
;
1494 /* process target state changes */
1495 int handle_target(void *priv
)
1497 target_t
*target
= targets
;
1501 if (target_continous_poll
)
1503 /* polling may fail silently until the target has been examined */
1504 target_poll(target
);
1507 target
= target
->next
;
1513 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1522 target
= get_current_target(cmd_ctx
);
1524 /* list all available registers for the current target */
1527 reg_cache_t
*cache
= target
->reg_cache
;
1533 for (i
= 0; i
< cache
->num_regs
; i
++)
1535 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1536 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
);
1539 cache
= cache
->next
;
1545 /* access a single register by its ordinal number */
1546 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1548 int num
= strtoul(args
[0], NULL
, 0);
1549 reg_cache_t
*cache
= target
->reg_cache
;
1555 for (i
= 0; i
< cache
->num_regs
; i
++)
1559 reg
= &cache
->reg_list
[i
];
1565 cache
= cache
->next
;
1570 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1573 } else /* access a single register by its name */
1575 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1579 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1584 /* display a register */
1585 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1587 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1590 if (reg
->valid
== 0)
1592 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1593 if (arch_type
== NULL
)
1595 LOG_ERROR("BUG: encountered unregistered arch type");
1598 arch_type
->get(reg
);
1600 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1601 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1606 /* set register value */
1609 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1610 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1612 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1613 if (arch_type
== NULL
)
1615 LOG_ERROR("BUG: encountered unregistered arch type");
1619 arch_type
->set(reg
, buf
);
1621 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1622 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1630 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1635 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1637 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1639 target_t
*target
= get_current_target(cmd_ctx
);
1643 target_poll(target
);
1644 target_arch_state(target
);
1648 if (strcmp(args
[0], "on") == 0)
1650 target_continous_poll
= 1;
1652 else if (strcmp(args
[0], "off") == 0)
1654 target_continous_poll
= 0;
1658 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1666 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1674 ms
= strtoul(args
[0], &end
, 0) * 1000;
1677 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1682 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1685 static void target_process_events(struct command_context_s
*cmd_ctx
)
1687 target_t
*target
= get_current_target(cmd_ctx
);
1688 target_poll(target
);
1689 target_call_timer_callbacks_now();
1692 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1695 struct timeval timeout
, now
;
1697 gettimeofday(&timeout
, NULL
);
1698 timeval_add_time(&timeout
, 0, ms
* 1000);
1700 target_t
*target
= get_current_target(cmd_ctx
);
1703 if ((retval
=target_poll(target
))!=ERROR_OK
)
1705 target_call_timer_callbacks_now();
1706 if (target
->state
== state
)
1713 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1716 gettimeofday(&now
, NULL
);
1717 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1719 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1727 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1730 target_t
*target
= get_current_target(cmd_ctx
);
1734 if ((retval
= target_halt(target
)) != ERROR_OK
)
1739 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1743 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1745 target_t
*target
= get_current_target(cmd_ctx
);
1747 LOG_USER("requesting target halt and executing a soft reset");
1749 target
->type
->soft_reset_halt(target
);
1754 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1756 target_t
*target
= get_current_target(cmd_ctx
);
1757 enum target_reset_mode reset_mode
= target
->reset_mode
;
1758 enum target_reset_mode save
= target
->reset_mode
;
1764 if (strcmp("run", args
[0]) == 0)
1765 reset_mode
= RESET_RUN
;
1766 else if (strcmp("halt", args
[0]) == 0)
1767 reset_mode
= RESET_HALT
;
1768 else if (strcmp("init", args
[0]) == 0)
1769 reset_mode
= RESET_INIT
;
1770 else if (strcmp("run_and_halt", args
[0]) == 0)
1772 reset_mode
= RESET_RUN_AND_HALT
;
1775 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1778 else if (strcmp("run_and_init", args
[0]) == 0)
1780 reset_mode
= RESET_RUN_AND_INIT
;
1783 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1788 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1793 /* temporarily modify mode of current reset target */
1794 target
->reset_mode
= reset_mode
;
1796 /* reset *all* targets */
1797 target_process_reset(cmd_ctx
);
1799 /* Restore default reset mode for this target */
1800 target
->reset_mode
= save
;
1805 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1808 target_t
*target
= get_current_target(cmd_ctx
);
1811 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1813 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1816 return ERROR_COMMAND_SYNTAX_ERROR
;
1819 target_process_events(cmd_ctx
);
1824 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1826 target_t
*target
= get_current_target(cmd_ctx
);
1831 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1834 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1839 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1841 const int line_bytecnt
= 32;
1854 target_t
*target
= get_current_target(cmd_ctx
);
1860 count
= strtoul(args
[1], NULL
, 0);
1862 address
= strtoul(args
[0], NULL
, 0);
1868 size
= 4; line_modulo
= line_bytecnt
/ 4;
1871 size
= 2; line_modulo
= line_bytecnt
/ 2;
1874 size
= 1; line_modulo
= line_bytecnt
/ 1;
1880 buffer
= calloc(count
, size
);
1881 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1882 if (retval
== ERROR_OK
)
1886 for (i
= 0; i
< count
; i
++)
1888 if (i
%line_modulo
== 0)
1889 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1894 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1897 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1900 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1904 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1906 command_print(cmd_ctx
, output
);
1912 LOG_ERROR("Failure examining memory");
1920 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1927 target_t
*target
= get_current_target(cmd_ctx
);
1930 if ((argc
< 2) || (argc
> 3))
1931 return ERROR_COMMAND_SYNTAX_ERROR
;
1933 address
= strtoul(args
[0], NULL
, 0);
1934 value
= strtoul(args
[1], NULL
, 0);
1936 count
= strtoul(args
[2], NULL
, 0);
1943 target_buffer_set_u32(target
, value_buf
, value
);
1947 target_buffer_set_u16(target
, value_buf
, value
);
1951 value_buf
[0] = value
;
1954 return ERROR_COMMAND_SYNTAX_ERROR
;
1956 for (i
=0; i
<count
; i
++)
1962 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1965 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1968 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1973 if (retval
!=ERROR_OK
)
1983 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1993 duration_t duration
;
1994 char *duration_text
;
1996 target_t
*target
= get_current_target(cmd_ctx
);
2000 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2004 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2007 image
.base_address_set
= 1;
2008 image
.base_address
= strtoul(args
[1], NULL
, 0);
2012 image
.base_address_set
= 0;
2015 image
.start_address_set
= 0;
2017 duration_start_measure(&duration
);
2019 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2026 for (i
= 0; i
< image
.num_sections
; i
++)
2028 buffer
= malloc(image
.sections
[i
].size
);
2031 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2035 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2040 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2045 image_size
+= buf_cnt
;
2046 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2051 duration_stop_measure(&duration
, &duration_text
);
2052 if (retval
==ERROR_OK
)
2054 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2056 free(duration_text
);
2058 image_close(&image
);
2064 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2071 int retval
=ERROR_OK
;
2073 duration_t duration
;
2074 char *duration_text
;
2076 target_t
*target
= get_current_target(cmd_ctx
);
2080 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2084 address
= strtoul(args
[1], NULL
, 0);
2085 size
= strtoul(args
[2], NULL
, 0);
2087 if ((address
& 3) || (size
& 3))
2089 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2093 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2098 duration_start_measure(&duration
);
2103 u32 this_run_size
= (size
> 560) ? 560 : size
;
2105 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2106 if (retval
!= ERROR_OK
)
2111 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2112 if (retval
!= ERROR_OK
)
2117 size
-= this_run_size
;
2118 address
+= this_run_size
;
2121 fileio_close(&fileio
);
2123 duration_stop_measure(&duration
, &duration_text
);
2124 if (retval
==ERROR_OK
)
2126 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2128 free(duration_text
);
2133 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2141 u32 mem_checksum
= 0;
2145 duration_t duration
;
2146 char *duration_text
;
2148 target_t
*target
= get_current_target(cmd_ctx
);
2152 return ERROR_COMMAND_SYNTAX_ERROR
;
2157 LOG_ERROR("no target selected");
2161 duration_start_measure(&duration
);
2165 image
.base_address_set
= 1;
2166 image
.base_address
= strtoul(args
[1], NULL
, 0);
2170 image
.base_address_set
= 0;
2171 image
.base_address
= 0x0;
2174 image
.start_address_set
= 0;
2176 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2183 for (i
= 0; i
< image
.num_sections
; i
++)
2185 buffer
= malloc(image
.sections
[i
].size
);
2188 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2191 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2197 /* calculate checksum of image */
2198 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2200 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2201 if( retval
!= ERROR_OK
)
2207 if( checksum
!= mem_checksum
)
2209 /* failed crc checksum, fall back to a binary compare */
2212 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2214 data
= (u8
*)malloc(buf_cnt
);
2216 /* Can we use 32bit word accesses? */
2218 int count
= buf_cnt
;
2219 if ((count
% 4) == 0)
2224 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2225 if (retval
== ERROR_OK
)
2228 for (t
= 0; t
< buf_cnt
; t
++)
2230 if (data
[t
] != buffer
[t
])
2232 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
]);
2245 image_size
+= buf_cnt
;
2248 duration_stop_measure(&duration
, &duration_text
);
2249 if (retval
==ERROR_OK
)
2251 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2253 free(duration_text
);
2255 image_close(&image
);
2260 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2263 target_t
*target
= get_current_target(cmd_ctx
);
2267 breakpoint_t
*breakpoint
= target
->breakpoints
;
2271 if (breakpoint
->type
== BKPT_SOFT
)
2273 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2274 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2279 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2281 breakpoint
= breakpoint
->next
;
2289 length
= strtoul(args
[1], NULL
, 0);
2292 if (strcmp(args
[2], "hw") == 0)
2295 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2297 LOG_ERROR("Failure setting breakpoints");
2301 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2306 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2312 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2314 target_t
*target
= get_current_target(cmd_ctx
);
2317 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2322 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2324 target_t
*target
= get_current_target(cmd_ctx
);
2329 watchpoint_t
*watchpoint
= target
->watchpoints
;
2333 command_print(cmd_ctx
, "address: 0x%8.8x, mask: 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
);
2334 watchpoint
= watchpoint
->next
;
2339 enum watchpoint_rw type
= WPT_ACCESS
;
2340 u32 data_value
= 0x0;
2341 u32 data_mask
= 0xffffffff;
2357 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2363 data_value
= strtoul(args
[3], NULL
, 0);
2367 data_mask
= strtoul(args
[4], NULL
, 0);
2370 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2371 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2373 LOG_ERROR("Failure setting breakpoints");
2378 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2384 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2386 target_t
*target
= get_current_target(cmd_ctx
);
2389 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2394 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2397 target_t
*target
= get_current_target(cmd_ctx
);
2403 return ERROR_COMMAND_SYNTAX_ERROR
;
2405 va
= strtoul(args
[0], NULL
, 0);
2407 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2408 if (retval
== ERROR_OK
)
2410 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2414 /* lower levels will have logged a detailed error which is
2415 * forwarded to telnet/GDB session.
2420 static void writeLong(FILE *f
, int l
)
2425 char c
=(l
>>(i
*8))&0xff;
2426 fwrite(&c
, 1, 1, f
);
2430 static void writeString(FILE *f
, char *s
)
2432 fwrite(s
, 1, strlen(s
), f
);
2437 // Dump a gmon.out histogram file.
2438 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2441 FILE *f
=fopen(filename
, "w");
2444 fwrite("gmon", 1, 4, f
);
2445 writeLong(f
, 0x00000001); // Version
2446 writeLong(f
, 0); // padding
2447 writeLong(f
, 0); // padding
2448 writeLong(f
, 0); // padding
2450 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2452 // figure out bucket size
2455 for (i
=0; i
<sampleNum
; i
++)
2467 int addressSpace
=(max
-min
+1);
2469 static int const maxBuckets
=256*1024; // maximum buckets.
2470 int length
=addressSpace
;
2471 if (length
> maxBuckets
)
2475 int *buckets
=malloc(sizeof(int)*length
);
2481 memset(buckets
, 0, sizeof(int)*length
);
2482 for (i
=0; i
<sampleNum
;i
++)
2484 u32 address
=samples
[i
];
2485 long long a
=address
-min
;
2486 long long b
=length
-1;
2487 long long c
=addressSpace
-1;
2488 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2492 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2493 writeLong(f
, min
); // low_pc
2494 writeLong(f
, max
); // high_pc
2495 writeLong(f
, length
); // # of samples
2496 writeLong(f
, 64000000); // 64MHz
2497 writeString(f
, "seconds");
2498 for (i
=0; i
<(15-strlen("seconds")); i
++)
2500 fwrite("", 1, 1, f
); // padding
2502 writeString(f
, "s");
2504 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2506 char *data
=malloc(2*length
);
2509 for (i
=0; i
<length
;i
++)
2518 data
[i
*2+1]=(val
>>8)&0xff;
2521 fwrite(data
, 1, length
*2, f
);
2531 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2532 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2534 target_t
*target
= get_current_target(cmd_ctx
);
2535 struct timeval timeout
, now
;
2537 gettimeofday(&timeout
, NULL
);
2540 return ERROR_COMMAND_SYNTAX_ERROR
;
2543 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2549 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2551 static const int maxSample
=10000;
2552 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2557 int retval
=ERROR_OK
;
2558 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2559 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2563 target_poll(target
);
2564 if (target
->state
== TARGET_HALTED
)
2566 u32 t
=*((u32
*)reg
->value
);
2567 samples
[numSamples
++]=t
;
2568 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2569 target_poll(target
);
2570 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2571 } else if (target
->state
== TARGET_RUNNING
)
2573 // We want to quickly sample the PC.
2574 target_halt(target
);
2577 command_print(cmd_ctx
, "Target not halted or running");
2581 if (retval
!=ERROR_OK
)
2586 gettimeofday(&now
, NULL
);
2587 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2589 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2590 target_poll(target
);
2591 if (target
->state
== TARGET_HALTED
)
2593 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2595 target_poll(target
);
2596 writeGmon(samples
, numSamples
, args
[1]);
2597 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)