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_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_virt2phys_command(command_context_t
*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 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
136 static int target_continous_poll
= 1;
138 /* read a u32 from a buffer in target memory endianness */
139 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
141 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
142 return le_to_h_u32(buffer
);
144 return be_to_h_u32(buffer
);
147 /* read a u16 from a buffer in target memory endianness */
148 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
150 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
151 return le_to_h_u16(buffer
);
153 return be_to_h_u16(buffer
);
156 /* write a u32 to a buffer in target memory endianness */
157 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
159 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
160 h_u32_to_le(buffer
, value
);
162 h_u32_to_be(buffer
, value
);
165 /* write a u16 to a buffer in target memory endianness */
166 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
168 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
169 h_u16_to_le(buffer
, value
);
171 h_u16_to_be(buffer
, value
);
174 /* returns a pointer to the n-th configured target */
175 target_t
* get_target_by_num(int num
)
177 target_t
*target
= targets
;
184 target
= target
->next
;
191 int get_num_by_target(target_t
*query_target
)
193 target_t
*target
= targets
;
198 if (target
== query_target
)
200 target
= target
->next
;
207 target_t
* get_current_target(command_context_t
*cmd_ctx
)
209 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
213 ERROR("BUG: current_target out of bounds");
220 /* Process target initialization, when target entered debug out of reset
221 * the handler is unregistered at the end of this function, so it's only called once
223 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
226 struct command_context_s
*cmd_ctx
= priv
;
228 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
230 target_unregister_event_callback(target_init_handler
, priv
);
232 script
= open_file_from_path(target
->reset_script
, "r");
235 ERROR("couldn't open script file %s", target
->reset_script
);
239 INFO("executing reset script '%s'", target
->reset_script
);
240 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
243 jtag_execute_queue();
249 int target_run_and_halt_handler(void *priv
)
251 target_t
*target
= priv
;
253 target
->type
->halt(target
);
258 int target_process_reset(struct command_context_s
*cmd_ctx
)
260 int retval
= ERROR_OK
;
262 struct timeval timeout
, now
;
264 /* prepare reset_halt where necessary */
268 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
270 switch (target
->reset_mode
)
273 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
274 target
->reset_mode
= RESET_RUN_AND_HALT
;
277 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
278 target
->reset_mode
= RESET_RUN_AND_INIT
;
284 switch (target
->reset_mode
)
288 target
->type
->prepare_reset_halt(target
);
293 target
= target
->next
;
299 target
->type
->assert_reset(target
);
300 target
= target
->next
;
302 jtag_execute_queue();
304 /* request target halt if necessary, and schedule further action */
308 switch (target
->reset_mode
)
311 /* nothing to do if target just wants to be run */
313 case RESET_RUN_AND_HALT
:
315 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
317 case RESET_RUN_AND_INIT
:
319 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
320 target_register_event_callback(target_init_handler
, cmd_ctx
);
323 target
->type
->halt(target
);
326 target
->type
->halt(target
);
327 target_register_event_callback(target_init_handler
, cmd_ctx
);
330 ERROR("BUG: unknown target->reset_mode");
332 target
= target
->next
;
338 target
->type
->deassert_reset(target
);
339 target
= target
->next
;
341 jtag_execute_queue();
343 /* Wait for reset to complete, maximum 5 seconds. */
344 gettimeofday(&timeout
, NULL
);
345 timeval_add_time(&timeout
, 5, 0);
348 gettimeofday(&now
, NULL
);
350 target_call_timer_callbacks();
355 target
->type
->poll(target
);
356 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) || (target
->reset_mode
== RESET_RUN_AND_HALT
))
358 if (target
->state
!= TARGET_HALTED
)
360 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
362 USER("Timed out waiting for reset");
365 /* this will send alive messages on e.g. GDB remote protocol. */
367 USER_N("%s", ""); /* avoid warning about zero length formatting message*/
371 target
= target
->next
;
373 /* All targets we're waiting for are halted */
381 /* We want any events to be processed before the prompt */
382 target_call_timer_callbacks();
387 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
393 static int default_mmu(struct target_s
*target
, int *enabled
)
399 int target_init(struct command_context_s
*cmd_ctx
)
401 target_t
*target
= targets
;
405 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
407 ERROR("target '%s' init failed", target
->type
->name
);
411 /* Set up default functions if none are provided by target */
412 if (target
->type
->virt2phys
== NULL
)
414 target
->type
->virt2phys
= default_virt2phys
;
416 if (target
->type
->mmu
== NULL
)
418 target
->type
->mmu
= default_mmu
;
420 target
= target
->next
;
425 target_register_user_commands(cmd_ctx
);
426 target_register_timer_callback(handle_target
, 100, 1, NULL
);
432 int target_init_reset(struct command_context_s
*cmd_ctx
)
434 if (startup_mode
== DAEMON_RESET
)
435 target_process_reset(cmd_ctx
);
440 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
442 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
444 if (callback
== NULL
)
446 return ERROR_INVALID_ARGUMENTS
;
451 while ((*callbacks_p
)->next
)
452 callbacks_p
= &((*callbacks_p
)->next
);
453 callbacks_p
= &((*callbacks_p
)->next
);
456 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
457 (*callbacks_p
)->callback
= callback
;
458 (*callbacks_p
)->priv
= priv
;
459 (*callbacks_p
)->next
= NULL
;
464 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
466 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
469 if (callback
== NULL
)
471 return ERROR_INVALID_ARGUMENTS
;
476 while ((*callbacks_p
)->next
)
477 callbacks_p
= &((*callbacks_p
)->next
);
478 callbacks_p
= &((*callbacks_p
)->next
);
481 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
482 (*callbacks_p
)->callback
= callback
;
483 (*callbacks_p
)->periodic
= periodic
;
484 (*callbacks_p
)->time_ms
= time_ms
;
486 gettimeofday(&now
, NULL
);
487 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
488 time_ms
-= (time_ms
% 1000);
489 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
490 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
492 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
493 (*callbacks_p
)->when
.tv_sec
+= 1;
496 (*callbacks_p
)->priv
= priv
;
497 (*callbacks_p
)->next
= NULL
;
502 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
504 target_event_callback_t
**p
= &target_event_callbacks
;
505 target_event_callback_t
*c
= target_event_callbacks
;
507 if (callback
== NULL
)
509 return ERROR_INVALID_ARGUMENTS
;
514 target_event_callback_t
*next
= c
->next
;
515 if ((c
->callback
== callback
) && (c
->priv
== priv
))
529 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
531 target_timer_callback_t
**p
= &target_timer_callbacks
;
532 target_timer_callback_t
*c
= target_timer_callbacks
;
534 if (callback
== NULL
)
536 return ERROR_INVALID_ARGUMENTS
;
541 target_timer_callback_t
*next
= c
->next
;
542 if ((c
->callback
== callback
) && (c
->priv
== priv
))
556 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
558 target_event_callback_t
*callback
= target_event_callbacks
;
559 target_event_callback_t
*next_callback
;
561 DEBUG("target event %i", event
);
565 next_callback
= callback
->next
;
566 callback
->callback(target
, event
, callback
->priv
);
567 callback
= next_callback
;
573 int target_call_timer_callbacks()
575 target_timer_callback_t
*callback
= target_timer_callbacks
;
576 target_timer_callback_t
*next_callback
;
579 gettimeofday(&now
, NULL
);
583 next_callback
= callback
->next
;
585 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
586 || (now
.tv_sec
> callback
->when
.tv_sec
))
588 callback
->callback(callback
->priv
);
589 if (callback
->periodic
)
591 int time_ms
= callback
->time_ms
;
592 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
593 time_ms
-= (time_ms
% 1000);
594 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
595 if (callback
->when
.tv_usec
> 1000000)
597 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
598 callback
->when
.tv_sec
+= 1;
602 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
605 callback
= next_callback
;
611 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
613 working_area_t
*c
= target
->working_areas
;
614 working_area_t
*new_wa
= NULL
;
616 /* Reevaluate working area address based on MMU state*/
617 if (target
->working_areas
== NULL
)
621 retval
= target
->type
->mmu(target
, &enabled
);
622 if (retval
!= ERROR_OK
)
628 target
->working_area
= target
->working_area_virt
;
632 target
->working_area
= target
->working_area_phys
;
636 /* only allocate multiples of 4 byte */
639 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
640 size
= CEIL(size
, 4);
643 /* see if there's already a matching working area */
646 if ((c
->free
) && (c
->size
== size
))
654 /* if not, allocate a new one */
657 working_area_t
**p
= &target
->working_areas
;
658 u32 first_free
= target
->working_area
;
659 u32 free_size
= target
->working_area_size
;
661 DEBUG("allocating new working area");
663 c
= target
->working_areas
;
666 first_free
+= c
->size
;
667 free_size
-= c
->size
;
672 if (free_size
< size
)
674 WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
675 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
678 new_wa
= malloc(sizeof(working_area_t
));
681 new_wa
->address
= first_free
;
683 if (target
->backup_working_area
)
685 new_wa
->backup
= malloc(new_wa
->size
);
686 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
690 new_wa
->backup
= NULL
;
693 /* put new entry in list */
697 /* mark as used, and return the new (reused) area */
707 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
712 if (target
->backup_working_area
)
713 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
717 /* mark user pointer invalid */
724 int target_free_all_working_areas(struct target_s
*target
)
726 working_area_t
*c
= target
->working_areas
;
730 working_area_t
*next
= c
->next
;
731 target_free_working_area(target
, c
);
741 target
->working_areas
= NULL
;
746 int target_register_commands(struct command_context_s
*cmd_ctx
)
748 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
749 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
750 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
751 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
752 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
753 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
754 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
759 int target_arch_state(struct target_s
*target
)
764 USER("No target has been configured");
768 USER("target state: %s", target_state_strings
[target
->state
]);
770 if (target
->state
!=TARGET_HALTED
)
773 retval
=target
->type
->arch_state(target
);
777 /* Single aligned words are guaranteed to use 16 or 32 bit access
778 * mode respectively, otherwise data is handled as quickly as
781 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
785 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
787 if (((address
% 2) == 0) && (size
== 2))
789 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
792 /* handle unaligned head bytes */
795 int unaligned
= 4 - (address
% 4);
797 if (unaligned
> size
)
800 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
804 address
+= unaligned
;
808 /* handle aligned words */
811 int aligned
= size
- (size
% 4);
813 /* use bulk writes above a certain limit. This may have to be changed */
816 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
821 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
830 /* handle tail writes of less than 4 bytes */
833 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
841 /* Single aligned words are guaranteed to use 16 or 32 bit access
842 * mode respectively, otherwise data is handled as quickly as
845 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
849 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
851 if (((address
% 2) == 0) && (size
== 2))
853 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
856 /* handle unaligned head bytes */
859 int unaligned
= 4 - (address
% 4);
861 if (unaligned
> size
)
864 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
868 address
+= unaligned
;
872 /* handle aligned words */
875 int aligned
= size
- (size
% 4);
877 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
885 /* handle tail writes of less than 4 bytes */
888 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
895 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
902 if ((retval
= target
->type
->checksum_memory(target
, address
,
903 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
905 buffer
= malloc(size
);
908 ERROR("error allocating buffer for section (%d bytes)", size
);
909 return ERROR_INVALID_ARGUMENTS
;
911 retval
= target_read_buffer(target
, address
, size
, buffer
);
912 if (retval
!= ERROR_OK
)
918 /* convert to target endianess */
919 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
922 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
923 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
926 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
935 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
939 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
941 if (retval
== ERROR_OK
)
943 *value
= target_buffer_get_u32(target
, value_buf
);
944 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
949 DEBUG("address: 0x%8.8x failed", address
);
955 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
959 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
961 if (retval
== ERROR_OK
)
963 *value
= target_buffer_get_u16(target
, value_buf
);
964 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
969 DEBUG("address: 0x%8.8x failed", address
);
975 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
977 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
979 if (retval
== ERROR_OK
)
981 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
986 DEBUG("address: 0x%8.8x failed", address
);
992 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
997 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
999 target_buffer_set_u32(target
, value_buf
, value
);
1000 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1002 DEBUG("failed: %i", retval
);
1008 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1013 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1015 target_buffer_set_u16(target
, value_buf
, value
);
1016 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1018 DEBUG("failed: %i", retval
);
1024 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1028 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1030 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1032 DEBUG("failed: %i", retval
);
1038 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1040 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1041 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1042 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1043 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1044 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1045 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1046 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1047 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1049 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1050 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1051 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1053 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
1054 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
1055 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
1057 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1058 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1059 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1060 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1062 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1063 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1064 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1065 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1066 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1068 target_request_register_commands(cmd_ctx
);
1069 trace_register_commands(cmd_ctx
);
1074 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1076 target_t
*target
= targets
;
1081 int num
= strtoul(args
[0], NULL
, 0);
1086 target
= target
->next
;
1090 cmd_ctx
->current_target
= num
;
1092 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1099 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1100 target
= target
->next
;
1106 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1113 return ERROR_COMMAND_SYNTAX_ERROR
;
1116 /* search for the specified target */
1117 if (args
[0] && (args
[0][0] != 0))
1119 for (i
= 0; target_types
[i
]; i
++)
1121 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1123 target_t
**last_target_p
= &targets
;
1125 /* register target specific commands */
1126 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1128 ERROR("couldn't register '%s' commands", args
[0]);
1134 while ((*last_target_p
)->next
)
1135 last_target_p
= &((*last_target_p
)->next
);
1136 last_target_p
= &((*last_target_p
)->next
);
1139 *last_target_p
= malloc(sizeof(target_t
));
1141 (*last_target_p
)->type
= target_types
[i
];
1143 if (strcmp(args
[1], "big") == 0)
1144 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1145 else if (strcmp(args
[1], "little") == 0)
1146 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1149 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1150 return ERROR_COMMAND_SYNTAX_ERROR
;
1153 /* what to do on a target reset */
1154 if (strcmp(args
[2], "reset_halt") == 0)
1155 (*last_target_p
)->reset_mode
= RESET_HALT
;
1156 else if (strcmp(args
[2], "reset_run") == 0)
1157 (*last_target_p
)->reset_mode
= RESET_RUN
;
1158 else if (strcmp(args
[2], "reset_init") == 0)
1159 (*last_target_p
)->reset_mode
= RESET_INIT
;
1160 else if (strcmp(args
[2], "run_and_halt") == 0)
1161 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1162 else if (strcmp(args
[2], "run_and_init") == 0)
1163 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1166 ERROR("unknown target startup mode %s", args
[2]);
1167 return ERROR_COMMAND_SYNTAX_ERROR
;
1169 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1171 (*last_target_p
)->reset_script
= NULL
;
1172 (*last_target_p
)->post_halt_script
= NULL
;
1173 (*last_target_p
)->pre_resume_script
= NULL
;
1174 (*last_target_p
)->gdb_program_script
= NULL
;
1176 (*last_target_p
)->working_area
= 0x0;
1177 (*last_target_p
)->working_area_size
= 0x0;
1178 (*last_target_p
)->working_areas
= NULL
;
1179 (*last_target_p
)->backup_working_area
= 0;
1181 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1182 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1183 (*last_target_p
)->reg_cache
= NULL
;
1184 (*last_target_p
)->breakpoints
= NULL
;
1185 (*last_target_p
)->watchpoints
= NULL
;
1186 (*last_target_p
)->next
= NULL
;
1187 (*last_target_p
)->arch_info
= NULL
;
1189 /* initialize trace information */
1190 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1191 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1192 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1193 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1194 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1195 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1196 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1197 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1199 (*last_target_p
)->dbgmsg
= NULL
;
1200 (*last_target_p
)->dbg_msg_enabled
= 0;
1202 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1210 /* no matching target found */
1213 ERROR("target '%s' not found", args
[0]);
1214 return ERROR_COMMAND_SYNTAX_ERROR
;
1220 /* usage: target_script <target#> <event> <script_file> */
1221 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1223 target_t
*target
= NULL
;
1227 ERROR("incomplete target_script command");
1228 return ERROR_COMMAND_SYNTAX_ERROR
;
1231 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1235 return ERROR_COMMAND_SYNTAX_ERROR
;
1238 if (strcmp(args
[1], "reset") == 0)
1240 if (target
->reset_script
)
1241 free(target
->reset_script
);
1242 target
->reset_script
= strdup(args
[2]);
1244 else if (strcmp(args
[1], "post_halt") == 0)
1246 if (target
->post_halt_script
)
1247 free(target
->post_halt_script
);
1248 target
->post_halt_script
= strdup(args
[2]);
1250 else if (strcmp(args
[1], "pre_resume") == 0)
1252 if (target
->pre_resume_script
)
1253 free(target
->pre_resume_script
);
1254 target
->pre_resume_script
= strdup(args
[2]);
1256 else if (strcmp(args
[1], "gdb_program_config") == 0)
1258 if (target
->gdb_program_script
)
1259 free(target
->gdb_program_script
);
1260 target
->gdb_program_script
= strdup(args
[2]);
1264 ERROR("unknown event type: '%s", args
[1]);
1265 return ERROR_COMMAND_SYNTAX_ERROR
;
1271 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1273 target_t
*target
= NULL
;
1277 return ERROR_COMMAND_SYNTAX_ERROR
;
1280 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1284 return ERROR_COMMAND_SYNTAX_ERROR
;
1287 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1292 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1294 target_t
*target
= NULL
;
1296 if ((argc
< 4) || (argc
> 5))
1298 return ERROR_COMMAND_SYNTAX_ERROR
;
1301 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1305 return ERROR_COMMAND_SYNTAX_ERROR
;
1307 target_free_all_working_areas(target
);
1309 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1312 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1314 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1316 if (strcmp(args
[3], "backup") == 0)
1318 target
->backup_working_area
= 1;
1320 else if (strcmp(args
[3], "nobackup") == 0)
1322 target
->backup_working_area
= 0;
1326 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1327 return ERROR_COMMAND_SYNTAX_ERROR
;
1334 /* process target state changes */
1335 int handle_target(void *priv
)
1338 target_t
*target
= targets
;
1342 /* only poll if target isn't already halted */
1343 if (target
->state
!= TARGET_HALTED
)
1345 if (target_continous_poll
)
1346 if ((retval
= target
->type
->poll(target
)) != ERROR_OK
)
1348 ERROR("couldn't poll target(%d). It's due for a reset.", retval
);
1352 target
= target
->next
;
1358 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1367 target
= get_current_target(cmd_ctx
);
1369 /* list all available registers for the current target */
1372 reg_cache_t
*cache
= target
->reg_cache
;
1378 for (i
= 0; i
< cache
->num_regs
; i
++)
1380 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1381 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
);
1384 cache
= cache
->next
;
1390 /* access a single register by its ordinal number */
1391 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1393 int num
= strtoul(args
[0], NULL
, 0);
1394 reg_cache_t
*cache
= target
->reg_cache
;
1400 for (i
= 0; i
< cache
->num_regs
; i
++)
1404 reg
= &cache
->reg_list
[i
];
1410 cache
= cache
->next
;
1415 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1418 } else /* access a single register by its name */
1420 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1424 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1429 /* display a register */
1430 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1432 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1435 if (reg
->valid
== 0)
1437 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1438 if (arch_type
== NULL
)
1440 ERROR("BUG: encountered unregistered arch type");
1443 arch_type
->get(reg
);
1445 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1446 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1451 /* set register value */
1454 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1455 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1457 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1458 if (arch_type
== NULL
)
1460 ERROR("BUG: encountered unregistered arch type");
1464 arch_type
->set(reg
, buf
);
1466 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1467 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1475 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1480 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1482 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1484 target_t
*target
= get_current_target(cmd_ctx
);
1488 target
->type
->poll(target
);
1489 target_arch_state(target
);
1493 if (strcmp(args
[0], "on") == 0)
1495 target_continous_poll
= 1;
1497 else if (strcmp(args
[0], "off") == 0)
1499 target_continous_poll
= 0;
1503 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1511 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1519 ms
= strtoul(args
[0], &end
, 0) * 1000;
1522 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1527 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1530 static void target_process_events(struct command_context_s
*cmd_ctx
)
1532 target_t
*target
= get_current_target(cmd_ctx
);
1533 target
->type
->poll(target
);
1534 target_call_timer_callbacks();
1537 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1540 struct timeval timeout
, now
;
1542 gettimeofday(&timeout
, NULL
);
1543 timeval_add_time(&timeout
, 0, ms
* 1000);
1545 target_t
*target
= get_current_target(cmd_ctx
);
1548 if ((retval
=target
->type
->poll(target
))!=ERROR_OK
)
1550 target_call_timer_callbacks();
1551 if (target
->state
== state
)
1558 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1561 gettimeofday(&now
, NULL
);
1562 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1564 ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1572 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1575 target_t
*target
= get_current_target(cmd_ctx
);
1579 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1584 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1587 /* what to do on daemon startup */
1588 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1592 if (strcmp(args
[0], "attach") == 0)
1594 startup_mode
= DAEMON_ATTACH
;
1597 else if (strcmp(args
[0], "reset") == 0)
1599 startup_mode
= DAEMON_RESET
;
1604 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1609 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1611 target_t
*target
= get_current_target(cmd_ctx
);
1613 USER("requesting target halt and executing a soft reset");
1615 target
->type
->soft_reset_halt(target
);
1620 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1622 target_t
*target
= get_current_target(cmd_ctx
);
1623 enum target_reset_mode reset_mode
= target
->reset_mode
;
1624 enum target_reset_mode save
= target
->reset_mode
;
1630 if (strcmp("run", args
[0]) == 0)
1631 reset_mode
= RESET_RUN
;
1632 else if (strcmp("halt", args
[0]) == 0)
1633 reset_mode
= RESET_HALT
;
1634 else if (strcmp("init", args
[0]) == 0)
1635 reset_mode
= RESET_INIT
;
1636 else if (strcmp("run_and_halt", args
[0]) == 0)
1638 reset_mode
= RESET_RUN_AND_HALT
;
1641 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1644 else if (strcmp("run_and_init", args
[0]) == 0)
1646 reset_mode
= RESET_RUN_AND_INIT
;
1649 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1654 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1659 /* temporarily modify mode of current reset target */
1660 target
->reset_mode
= reset_mode
;
1662 /* reset *all* targets */
1663 target_process_reset(cmd_ctx
);
1665 /* Restore default reset mode for this target */
1666 target
->reset_mode
= save
;
1671 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1674 target_t
*target
= get_current_target(cmd_ctx
);
1677 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1679 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1682 return ERROR_COMMAND_SYNTAX_ERROR
;
1685 target_process_events(cmd_ctx
);
1690 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1692 target_t
*target
= get_current_target(cmd_ctx
);
1697 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1700 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1705 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1707 const int line_bytecnt
= 32;
1720 target_t
*target
= get_current_target(cmd_ctx
);
1726 count
= strtoul(args
[1], NULL
, 0);
1728 address
= strtoul(args
[0], NULL
, 0);
1734 size
= 4; line_modulo
= line_bytecnt
/ 4;
1737 size
= 2; line_modulo
= line_bytecnt
/ 2;
1740 size
= 1; line_modulo
= line_bytecnt
/ 1;
1746 buffer
= calloc(count
, size
);
1747 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1748 if (retval
!= ERROR_OK
)
1752 case ERROR_TARGET_UNALIGNED_ACCESS
:
1753 command_print(cmd_ctx
, "error: address not aligned");
1755 case ERROR_TARGET_NOT_HALTED
:
1756 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1758 case ERROR_TARGET_DATA_ABORT
:
1759 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1762 command_print(cmd_ctx
, "error: unknown error");
1770 for (i
= 0; i
< count
; i
++)
1772 if (i
%line_modulo
== 0)
1773 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1778 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1781 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1784 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1788 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1790 command_print(cmd_ctx
, output
);
1800 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1805 target_t
*target
= get_current_target(cmd_ctx
);
1811 address
= strtoul(args
[0], NULL
, 0);
1812 value
= strtoul(args
[1], NULL
, 0);
1817 target_buffer_set_u32(target
, value_buf
, value
);
1818 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1821 target_buffer_set_u16(target
, value_buf
, value
);
1822 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1825 value_buf
[0] = value
;
1826 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1834 case ERROR_TARGET_UNALIGNED_ACCESS
:
1835 command_print(cmd_ctx
, "error: address not aligned");
1837 case ERROR_TARGET_DATA_ABORT
:
1838 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1840 case ERROR_TARGET_NOT_HALTED
:
1841 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1846 command_print(cmd_ctx
, "error: unknown error");
1854 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1864 duration_t duration
;
1865 char *duration_text
;
1867 target_t
*target
= get_current_target(cmd_ctx
);
1871 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1875 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1878 image
.base_address_set
= 1;
1879 image
.base_address
= strtoul(args
[1], NULL
, 0);
1883 image
.base_address_set
= 0;
1886 image
.start_address_set
= 0;
1888 duration_start_measure(&duration
);
1890 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1897 for (i
= 0; i
< image
.num_sections
; i
++)
1899 buffer
= malloc(image
.sections
[i
].size
);
1902 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1906 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1911 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
1916 image_size
+= buf_cnt
;
1917 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1922 duration_stop_measure(&duration
, &duration_text
);
1923 if (retval
==ERROR_OK
)
1925 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1927 free(duration_text
);
1929 image_close(&image
);
1935 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1942 int retval
=ERROR_OK
;
1944 duration_t duration
;
1945 char *duration_text
;
1947 target_t
*target
= get_current_target(cmd_ctx
);
1951 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1955 address
= strtoul(args
[1], NULL
, 0);
1956 size
= strtoul(args
[2], NULL
, 0);
1958 if ((address
& 3) || (size
& 3))
1960 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1964 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1969 duration_start_measure(&duration
);
1974 u32 this_run_size
= (size
> 560) ? 560 : size
;
1976 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1977 if (retval
!= ERROR_OK
)
1982 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1983 if (retval
!= ERROR_OK
)
1988 size
-= this_run_size
;
1989 address
+= this_run_size
;
1992 fileio_close(&fileio
);
1994 duration_stop_measure(&duration
, &duration_text
);
1995 if (retval
==ERROR_OK
)
1997 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
1999 free(duration_text
);
2004 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2012 u32 mem_checksum
= 0;
2016 duration_t duration
;
2017 char *duration_text
;
2019 target_t
*target
= get_current_target(cmd_ctx
);
2023 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
2029 ERROR("no target selected");
2033 duration_start_measure(&duration
);
2037 image
.base_address_set
= 1;
2038 image
.base_address
= strtoul(args
[1], NULL
, 0);
2042 image
.base_address_set
= 0;
2043 image
.base_address
= 0x0;
2046 image
.start_address_set
= 0;
2048 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
2055 for (i
= 0; i
< image
.num_sections
; i
++)
2057 buffer
= malloc(image
.sections
[i
].size
);
2060 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2063 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2069 /* calculate checksum of image */
2070 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2072 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2074 if( retval
!= ERROR_OK
)
2080 if( checksum
!= mem_checksum
)
2082 /* failed crc checksum, fall back to a binary compare */
2085 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2087 data
= (u8
*)malloc(buf_cnt
);
2089 /* Can we use 32bit word accesses? */
2091 int count
= buf_cnt
;
2092 if ((count
% 4) == 0)
2097 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2099 if (retval
== ERROR_OK
)
2102 for (t
= 0; t
< buf_cnt
; t
++)
2104 if (data
[t
] != buffer
[t
])
2106 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
]);
2119 image_size
+= buf_cnt
;
2122 duration_stop_measure(&duration
, &duration_text
);
2123 if (retval
==ERROR_OK
)
2125 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2127 free(duration_text
);
2129 image_close(&image
);
2134 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2137 target_t
*target
= get_current_target(cmd_ctx
);
2141 breakpoint_t
*breakpoint
= target
->breakpoints
;
2145 if (breakpoint
->type
== BKPT_SOFT
)
2147 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2148 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2153 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2155 breakpoint
= breakpoint
->next
;
2163 length
= strtoul(args
[1], NULL
, 0);
2166 if (strcmp(args
[2], "hw") == 0)
2169 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2173 case ERROR_TARGET_NOT_HALTED
:
2174 command_print(cmd_ctx
, "target must be halted to set breakpoints");
2176 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2177 command_print(cmd_ctx
, "no more breakpoints available");
2180 command_print(cmd_ctx
, "unknown error, breakpoint not set");
2186 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2191 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2197 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2199 target_t
*target
= get_current_target(cmd_ctx
);
2202 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2207 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2209 target_t
*target
= get_current_target(cmd_ctx
);
2214 watchpoint_t
*watchpoint
= target
->watchpoints
;
2218 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
);
2219 watchpoint
= watchpoint
->next
;
2224 enum watchpoint_rw type
= WPT_ACCESS
;
2225 u32 data_value
= 0x0;
2226 u32 data_mask
= 0xffffffff;
2242 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2248 data_value
= strtoul(args
[3], NULL
, 0);
2252 data_mask
= strtoul(args
[4], NULL
, 0);
2255 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2256 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2260 case ERROR_TARGET_NOT_HALTED
:
2261 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2263 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2264 command_print(cmd_ctx
, "no more watchpoints available");
2267 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2274 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2280 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2282 target_t
*target
= get_current_target(cmd_ctx
);
2285 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2290 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2293 target_t
*target
= get_current_target(cmd_ctx
);
2299 return ERROR_COMMAND_SYNTAX_ERROR
;
2301 va
= strtoul(args
[0], NULL
, 0);
2303 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2304 if (retval
== ERROR_OK
)
2306 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2310 /* lower levels will have logged a detailed error which is
2311 * forwarded to telnet/GDB session.
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)