1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "target_request.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
37 #include <sys/types.h>
45 #include <time_support.h>
50 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
52 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_daemon_startup_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
);
81 extern target_type_t arm7tdmi_target
;
82 extern target_type_t arm720t_target
;
83 extern target_type_t arm9tdmi_target
;
84 extern target_type_t arm920t_target
;
85 extern target_type_t arm966e_target
;
86 extern target_type_t arm926ejs_target
;
87 extern target_type_t xscale_target
;
88 extern target_type_t cortexm3_target
;
90 target_type_t
*target_types
[] =
103 target_t
*targets
= NULL
;
104 target_event_callback_t
*target_event_callbacks
= NULL
;
105 target_timer_callback_t
*target_timer_callbacks
= NULL
;
107 char *target_state_strings
[] =
116 char *target_debug_reason_strings
[] =
118 "debug request", "breakpoint", "watchpoint",
119 "watchpoint and breakpoint", "single step",
123 char *target_endianess_strings
[] =
129 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
131 static int target_continous_poll
= 1;
133 /* read a u32 from a buffer in target memory endianness */
134 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
136 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
137 return le_to_h_u32(buffer
);
139 return be_to_h_u32(buffer
);
142 /* read a u16 from a buffer in target memory endianness */
143 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
145 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
146 return le_to_h_u16(buffer
);
148 return be_to_h_u16(buffer
);
151 /* write a u32 to a buffer in target memory endianness */
152 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
154 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
155 h_u32_to_le(buffer
, value
);
157 h_u32_to_be(buffer
, value
);
160 /* write a u16 to a buffer in target memory endianness */
161 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
163 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
164 h_u16_to_le(buffer
, value
);
166 h_u16_to_be(buffer
, value
);
169 /* returns a pointer to the n-th configured target */
170 target_t
* get_target_by_num(int num
)
172 target_t
*target
= targets
;
179 target
= target
->next
;
186 int get_num_by_target(target_t
*query_target
)
188 target_t
*target
= targets
;
193 if (target
== query_target
)
195 target
= target
->next
;
202 target_t
* get_current_target(command_context_t
*cmd_ctx
)
204 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
208 ERROR("BUG: current_target out of bounds");
215 /* Process target initialization, when target entered debug out of reset
216 * the handler is unregistered at the end of this function, so it's only called once
218 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
221 struct command_context_s
*cmd_ctx
= priv
;
223 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
225 target_unregister_event_callback(target_init_handler
, priv
);
227 script
= open_file_from_path(cmd_ctx
, target
->reset_script
, "r");
230 ERROR("couldn't open script file %s", target
->reset_script
);
234 INFO("executing reset script '%s'", target
->reset_script
);
235 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
238 jtag_execute_queue();
244 int target_run_and_halt_handler(void *priv
)
246 target_t
*target
= priv
;
248 target
->type
->halt(target
);
253 int target_process_reset(struct command_context_s
*cmd_ctx
)
255 int retval
= ERROR_OK
;
257 struct timeval timeout
, now
;
259 /* prepare reset_halt where necessary */
263 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
265 switch (target
->reset_mode
)
268 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
269 target
->reset_mode
= RESET_RUN_AND_HALT
;
272 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
273 target
->reset_mode
= RESET_RUN_AND_INIT
;
279 switch (target
->reset_mode
)
283 target
->type
->prepare_reset_halt(target
);
288 target
= target
->next
;
294 target
->type
->assert_reset(target
);
295 target
= target
->next
;
297 jtag_execute_queue();
299 /* request target halt if necessary, and schedule further action */
303 switch (target
->reset_mode
)
306 /* nothing to do if target just wants to be run */
308 case RESET_RUN_AND_HALT
:
310 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
312 case RESET_RUN_AND_INIT
:
314 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
315 target_register_event_callback(target_init_handler
, cmd_ctx
);
318 target
->type
->halt(target
);
321 target
->type
->halt(target
);
322 target_register_event_callback(target_init_handler
, cmd_ctx
);
325 ERROR("BUG: unknown target->reset_mode");
327 target
= target
->next
;
333 target
->type
->deassert_reset(target
);
334 target
= target
->next
;
336 jtag_execute_queue();
338 /* Wait for reset to complete, maximum 5 seconds. */
339 gettimeofday(&timeout
, NULL
);
340 timeval_add_time(&timeout
, 5, 0);
343 gettimeofday(&now
, NULL
);
345 target_call_timer_callbacks();
350 target
->type
->poll(target
);
351 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) || (target
->reset_mode
== RESET_RUN_AND_HALT
))
353 if (target
->state
!= TARGET_HALTED
)
355 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
357 command_print(cmd_ctx
, "Timed out waiting for reset");
360 usleep(100*1000); /* Do not eat all cpu */
364 target
= target
->next
;
366 /* All targets we're waiting for are halted */
374 /* We want any events to be processed before the prompt */
375 target_call_timer_callbacks();
380 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
386 static int default_mmu(struct target_s
*target
, int *enabled
)
388 USER("No MMU present");
393 int target_init(struct command_context_s
*cmd_ctx
)
395 target_t
*target
= targets
;
399 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
401 ERROR("target '%s' init failed", target
->type
->name
);
405 /* Set up default functions if none are provided by target */
406 if (target
->type
->virt2phys
== NULL
)
408 target
->type
->virt2phys
= default_virt2phys
;
410 if (target
->type
->mmu
== NULL
)
412 target
->type
->mmu
= default_mmu
;
414 target
= target
->next
;
419 target_register_user_commands(cmd_ctx
);
420 target_register_timer_callback(handle_target
, 100, 1, NULL
);
426 int target_init_reset(struct command_context_s
*cmd_ctx
)
428 if (startup_mode
== DAEMON_RESET
)
429 target_process_reset(cmd_ctx
);
434 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
436 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
438 if (callback
== NULL
)
440 return ERROR_INVALID_ARGUMENTS
;
445 while ((*callbacks_p
)->next
)
446 callbacks_p
= &((*callbacks_p
)->next
);
447 callbacks_p
= &((*callbacks_p
)->next
);
450 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
451 (*callbacks_p
)->callback
= callback
;
452 (*callbacks_p
)->priv
= priv
;
453 (*callbacks_p
)->next
= NULL
;
458 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
460 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
463 if (callback
== NULL
)
465 return ERROR_INVALID_ARGUMENTS
;
470 while ((*callbacks_p
)->next
)
471 callbacks_p
= &((*callbacks_p
)->next
);
472 callbacks_p
= &((*callbacks_p
)->next
);
475 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
476 (*callbacks_p
)->callback
= callback
;
477 (*callbacks_p
)->periodic
= periodic
;
478 (*callbacks_p
)->time_ms
= time_ms
;
480 gettimeofday(&now
, NULL
);
481 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
482 time_ms
-= (time_ms
% 1000);
483 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
484 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
486 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
487 (*callbacks_p
)->when
.tv_sec
+= 1;
490 (*callbacks_p
)->priv
= priv
;
491 (*callbacks_p
)->next
= NULL
;
496 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
498 target_event_callback_t
**p
= &target_event_callbacks
;
499 target_event_callback_t
*c
= target_event_callbacks
;
501 if (callback
== NULL
)
503 return ERROR_INVALID_ARGUMENTS
;
508 target_event_callback_t
*next
= c
->next
;
509 if ((c
->callback
== callback
) && (c
->priv
== priv
))
523 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
525 target_timer_callback_t
**p
= &target_timer_callbacks
;
526 target_timer_callback_t
*c
= target_timer_callbacks
;
528 if (callback
== NULL
)
530 return ERROR_INVALID_ARGUMENTS
;
535 target_timer_callback_t
*next
= c
->next
;
536 if ((c
->callback
== callback
) && (c
->priv
== priv
))
550 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
552 target_event_callback_t
*callback
= target_event_callbacks
;
553 target_event_callback_t
*next_callback
;
555 DEBUG("target event %i", event
);
559 next_callback
= callback
->next
;
560 callback
->callback(target
, event
, callback
->priv
);
561 callback
= next_callback
;
567 int target_call_timer_callbacks()
569 target_timer_callback_t
*callback
= target_timer_callbacks
;
570 target_timer_callback_t
*next_callback
;
573 gettimeofday(&now
, NULL
);
577 next_callback
= callback
->next
;
579 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
580 || (now
.tv_sec
> callback
->when
.tv_sec
))
582 callback
->callback(callback
->priv
);
583 if (callback
->periodic
)
585 int time_ms
= callback
->time_ms
;
586 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
587 time_ms
-= (time_ms
% 1000);
588 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
589 if (callback
->when
.tv_usec
> 1000000)
591 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
592 callback
->when
.tv_sec
+= 1;
596 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
599 callback
= next_callback
;
605 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
607 working_area_t
*c
= target
->working_areas
;
608 working_area_t
*new_wa
= NULL
;
610 /* Reevaluate working area address based on MMU state*/
611 if (target
->working_areas
== NULL
)
615 retval
= target
->type
->mmu(target
, &enabled
);
616 if (retval
!= ERROR_OK
)
622 target
->working_area
= target
->working_area_virt
;
626 target
->working_area
= target
->working_area_phys
;
630 /* only allocate multiples of 4 byte */
633 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
634 size
= CEIL(size
, 4);
637 /* see if there's already a matching working area */
640 if ((c
->free
) && (c
->size
== size
))
648 /* if not, allocate a new one */
651 working_area_t
**p
= &target
->working_areas
;
652 u32 first_free
= target
->working_area
;
653 u32 free_size
= target
->working_area_size
;
655 DEBUG("allocating new working area");
657 c
= target
->working_areas
;
660 first_free
+= c
->size
;
661 free_size
-= c
->size
;
666 if (free_size
< size
)
668 WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
669 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
672 new_wa
= malloc(sizeof(working_area_t
));
675 new_wa
->address
= first_free
;
677 if (target
->backup_working_area
)
679 new_wa
->backup
= malloc(new_wa
->size
);
680 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
684 new_wa
->backup
= NULL
;
687 /* put new entry in list */
691 /* mark as used, and return the new (reused) area */
701 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
706 if (target
->backup_working_area
)
707 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
711 /* mark user pointer invalid */
718 int target_free_all_working_areas(struct target_s
*target
)
720 working_area_t
*c
= target
->working_areas
;
724 working_area_t
*next
= c
->next
;
725 target_free_working_area(target
, c
);
735 target
->working_areas
= NULL
;
740 int target_register_commands(struct command_context_s
*cmd_ctx
)
742 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
743 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
744 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
745 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
746 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
747 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
748 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
753 /* Single aligned words are guaranteed to use 16 or 32 bit access
754 * mode respectively, otherwise data is handled as quickly as
757 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
761 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
763 if (((address
% 2) == 0) && (size
== 2))
765 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
768 /* handle unaligned head bytes */
771 int unaligned
= 4 - (address
% 4);
773 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
777 address
+= unaligned
;
781 /* handle aligned words */
784 int aligned
= size
- (size
% 4);
786 /* use bulk writes above a certain limit. This may have to be changed */
789 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
794 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
803 /* handle tail writes of less than 4 bytes */
806 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
814 /* Single aligned words are guaranteed to use 16 or 32 bit access
815 * mode respectively, otherwise data is handled as quickly as
818 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
822 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
824 if (((address
% 2) == 0) && (size
== 2))
826 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
829 /* handle unaligned head bytes */
832 int unaligned
= 4 - (address
% 4);
834 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
838 address
+= unaligned
;
842 /* handle aligned words */
845 int aligned
= size
- (size
% 4);
847 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
855 /* handle tail writes of less than 4 bytes */
858 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
865 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
872 if ((retval
= target
->type
->checksum_memory(target
, address
,
873 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
875 buffer
= malloc(size
);
878 ERROR("error allocating buffer for section (%d bytes)", size
);
879 return ERROR_INVALID_ARGUMENTS
;
881 retval
= target_read_buffer(target
, address
, size
, buffer
);
882 if (retval
!= ERROR_OK
)
888 /* convert to target endianess */
889 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
892 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
893 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
896 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
905 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
909 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
911 if (retval
== ERROR_OK
)
913 *value
= target_buffer_get_u32(target
, value_buf
);
914 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
919 DEBUG("address: 0x%8.8x failed", address
);
925 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
929 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
931 if (retval
== ERROR_OK
)
933 *value
= target_buffer_get_u16(target
, value_buf
);
934 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
939 DEBUG("address: 0x%8.8x failed", address
);
945 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
947 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
949 if (retval
== ERROR_OK
)
951 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
956 DEBUG("address: 0x%8.8x failed", address
);
962 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
967 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
969 target_buffer_set_u32(target
, value_buf
, value
);
970 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
972 DEBUG("failed: %i", retval
);
978 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
983 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
985 target_buffer_set_u16(target
, value_buf
, value
);
986 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
988 DEBUG("failed: %i", retval
);
994 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
998 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1000 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1002 DEBUG("failed: %i", retval
);
1008 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1010 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1011 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1012 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1013 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1014 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1015 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1016 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1017 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1019 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1020 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1021 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1023 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
1024 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
1025 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
1027 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1028 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1029 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1030 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1032 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1033 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1034 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1035 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1036 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1038 target_request_register_commands(cmd_ctx
);
1039 trace_register_commands(cmd_ctx
);
1044 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1046 target_t
*target
= targets
;
1051 int num
= strtoul(args
[0], NULL
, 0);
1056 target
= target
->next
;
1060 cmd_ctx
->current_target
= num
;
1062 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1069 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1070 target
= target
->next
;
1076 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1083 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1087 /* search for the specified target */
1088 if (args
[0] && (args
[0][0] != 0))
1090 for (i
= 0; target_types
[i
]; i
++)
1092 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1094 target_t
**last_target_p
= &targets
;
1096 /* register target specific commands */
1097 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1099 ERROR("couldn't register '%s' commands", args
[0]);
1105 while ((*last_target_p
)->next
)
1106 last_target_p
= &((*last_target_p
)->next
);
1107 last_target_p
= &((*last_target_p
)->next
);
1110 *last_target_p
= malloc(sizeof(target_t
));
1112 (*last_target_p
)->type
= target_types
[i
];
1114 if (strcmp(args
[1], "big") == 0)
1115 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1116 else if (strcmp(args
[1], "little") == 0)
1117 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1120 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1124 /* what to do on a target reset */
1125 if (strcmp(args
[2], "reset_halt") == 0)
1126 (*last_target_p
)->reset_mode
= RESET_HALT
;
1127 else if (strcmp(args
[2], "reset_run") == 0)
1128 (*last_target_p
)->reset_mode
= RESET_RUN
;
1129 else if (strcmp(args
[2], "reset_init") == 0)
1130 (*last_target_p
)->reset_mode
= RESET_INIT
;
1131 else if (strcmp(args
[2], "run_and_halt") == 0)
1132 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1133 else if (strcmp(args
[2], "run_and_init") == 0)
1134 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1137 ERROR("unknown target startup mode %s", args
[2]);
1140 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1142 (*last_target_p
)->reset_script
= NULL
;
1143 (*last_target_p
)->post_halt_script
= NULL
;
1144 (*last_target_p
)->pre_resume_script
= NULL
;
1145 (*last_target_p
)->gdb_program_script
= NULL
;
1147 (*last_target_p
)->working_area
= 0x0;
1148 (*last_target_p
)->working_area_size
= 0x0;
1149 (*last_target_p
)->working_areas
= NULL
;
1150 (*last_target_p
)->backup_working_area
= 0;
1152 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1153 (*last_target_p
)->reg_cache
= NULL
;
1154 (*last_target_p
)->breakpoints
= NULL
;
1155 (*last_target_p
)->watchpoints
= NULL
;
1156 (*last_target_p
)->next
= NULL
;
1157 (*last_target_p
)->arch_info
= NULL
;
1159 /* initialize trace information */
1160 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1161 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1162 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1163 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1164 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1165 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1166 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1167 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1169 (*last_target_p
)->dbgmsg
= NULL
;
1170 (*last_target_p
)->dbg_msg_enabled
= 0;
1172 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1180 /* no matching target found */
1183 ERROR("target '%s' not found", args
[0]);
1190 /* usage: target_script <target#> <event> <script_file> */
1191 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1193 target_t
*target
= NULL
;
1197 ERROR("incomplete target_script command");
1201 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1205 ERROR("target number '%s' not defined", args
[0]);
1209 if (strcmp(args
[1], "reset") == 0)
1211 if (target
->reset_script
)
1212 free(target
->reset_script
);
1213 target
->reset_script
= strdup(args
[2]);
1215 else if (strcmp(args
[1], "post_halt") == 0)
1217 if (target
->post_halt_script
)
1218 free(target
->post_halt_script
);
1219 target
->post_halt_script
= strdup(args
[2]);
1221 else if (strcmp(args
[1], "pre_resume") == 0)
1223 if (target
->pre_resume_script
)
1224 free(target
->pre_resume_script
);
1225 target
->pre_resume_script
= strdup(args
[2]);
1227 else if (strcmp(args
[1], "gdb_program_config") == 0)
1229 if (target
->gdb_program_script
)
1230 free(target
->gdb_program_script
);
1231 target
->gdb_program_script
= strdup(args
[2]);
1235 ERROR("unknown event type: '%s", args
[1]);
1242 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1244 target_t
*target
= NULL
;
1248 ERROR("incomplete run_and_halt_time command");
1252 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1256 ERROR("target number '%s' not defined", args
[0]);
1260 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1265 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1267 target_t
*target
= NULL
;
1269 if ((argc
< 4) || (argc
> 5))
1271 return ERROR_COMMAND_SYNTAX_ERROR
;
1274 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1278 ERROR("target number '%s' not defined", args
[0]);
1281 target_free_all_working_areas(target
);
1283 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1286 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1288 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1290 if (strcmp(args
[3], "backup") == 0)
1292 target
->backup_working_area
= 1;
1294 else if (strcmp(args
[3], "nobackup") == 0)
1296 target
->backup_working_area
= 0;
1300 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1301 return ERROR_COMMAND_SYNTAX_ERROR
;
1308 /* process target state changes */
1309 int handle_target(void *priv
)
1312 target_t
*target
= targets
;
1316 /* only poll if target isn't already halted */
1317 if (target
->state
!= TARGET_HALTED
)
1319 if (target_continous_poll
)
1320 if ((retval
= target
->type
->poll(target
)) < 0)
1322 ERROR("couldn't poll target. It's due for a reset.");
1326 target
= target
->next
;
1332 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1341 target
= get_current_target(cmd_ctx
);
1343 /* list all available registers for the current target */
1346 reg_cache_t
*cache
= target
->reg_cache
;
1352 for (i
= 0; i
< cache
->num_regs
; i
++)
1354 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1355 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
);
1358 cache
= cache
->next
;
1364 /* access a single register by its ordinal number */
1365 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1367 int num
= strtoul(args
[0], NULL
, 0);
1368 reg_cache_t
*cache
= target
->reg_cache
;
1374 for (i
= 0; i
< cache
->num_regs
; i
++)
1378 reg
= &cache
->reg_list
[i
];
1384 cache
= cache
->next
;
1389 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1392 } else /* access a single register by its name */
1394 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1398 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1403 /* display a register */
1404 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1406 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1409 if (reg
->valid
== 0)
1411 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1412 if (arch_type
== NULL
)
1414 ERROR("BUG: encountered unregistered arch type");
1417 arch_type
->get(reg
);
1419 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1420 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1425 /* set register value */
1428 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1429 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1431 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1432 if (arch_type
== NULL
)
1434 ERROR("BUG: encountered unregistered arch type");
1438 arch_type
->set(reg
, buf
);
1440 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1441 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1449 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1454 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1456 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1458 target_t
*target
= get_current_target(cmd_ctx
);
1463 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1464 if (target
->state
== TARGET_HALTED
)
1466 target
->type
->arch_state(target
, buffer
, 512);
1468 command_print(cmd_ctx
, "%s", buffer
);
1473 if (strcmp(args
[0], "on") == 0)
1475 target_continous_poll
= 1;
1477 else if (strcmp(args
[0], "off") == 0)
1479 target_continous_poll
= 0;
1483 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1491 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1499 ms
= strtoul(args
[0], &end
, 0) * 1000;
1502 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1507 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1510 static void target_process_events(struct command_context_s
*cmd_ctx
)
1512 target_t
*target
= get_current_target(cmd_ctx
);
1513 target
->type
->poll(target
);
1514 target_call_timer_callbacks();
1517 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1519 struct timeval timeout
, now
;
1521 gettimeofday(&timeout
, NULL
);
1522 timeval_add_time(&timeout
, 0, ms
* 1000);
1523 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1525 target_t
*target
= get_current_target(cmd_ctx
);
1526 while (target
->type
->poll(target
))
1528 target_call_timer_callbacks();
1529 if (target
->state
== state
)
1531 command_print(cmd_ctx
, "target %s", target_state_strings
[state
]);
1535 gettimeofday(&now
, NULL
);
1536 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1538 command_print(cmd_ctx
, "timed out while waiting for target %s", target_state_strings
[state
]);
1539 ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1547 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1550 target_t
*target
= get_current_target(cmd_ctx
);
1554 command_print(cmd_ctx
, "requesting target halt...");
1556 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1560 case ERROR_TARGET_ALREADY_HALTED
:
1561 command_print(cmd_ctx
, "target already halted");
1563 case ERROR_TARGET_TIMEOUT
:
1564 command_print(cmd_ctx
, "target timed out... shutting down");
1567 command_print(cmd_ctx
, "unknown error... shutting down");
1572 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1575 /* what to do on daemon startup */
1576 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1580 if (strcmp(args
[0], "attach") == 0)
1582 startup_mode
= DAEMON_ATTACH
;
1585 else if (strcmp(args
[0], "reset") == 0)
1587 startup_mode
= DAEMON_RESET
;
1592 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1597 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1599 target_t
*target
= get_current_target(cmd_ctx
);
1602 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1604 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1608 case ERROR_TARGET_TIMEOUT
:
1609 command_print(cmd_ctx
, "target timed out... shutting down");
1612 command_print(cmd_ctx
, "unknown error... shutting down");
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
);
1679 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1681 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1684 command_print(cmd_ctx
, "usage: resume [address]");
1688 if (retval
!= ERROR_OK
)
1692 case ERROR_TARGET_NOT_HALTED
:
1693 command_print(cmd_ctx
, "target not halted");
1696 command_print(cmd_ctx
, "unknown error... shutting down");
1701 target_process_events(cmd_ctx
);
1706 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1708 target_t
*target
= get_current_target(cmd_ctx
);
1713 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1716 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1721 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1723 const int line_bytecnt
= 32;
1736 target_t
*target
= get_current_target(cmd_ctx
);
1742 count
= strtoul(args
[1], NULL
, 0);
1744 address
= strtoul(args
[0], NULL
, 0);
1750 size
= 4; line_modulo
= line_bytecnt
/ 4;
1753 size
= 2; line_modulo
= line_bytecnt
/ 2;
1756 size
= 1; line_modulo
= line_bytecnt
/ 1;
1762 buffer
= calloc(count
, size
);
1763 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1764 if (retval
!= ERROR_OK
)
1768 case ERROR_TARGET_UNALIGNED_ACCESS
:
1769 command_print(cmd_ctx
, "error: address not aligned");
1771 case ERROR_TARGET_NOT_HALTED
:
1772 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1774 case ERROR_TARGET_DATA_ABORT
:
1775 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1778 command_print(cmd_ctx
, "error: unknown error");
1786 for (i
= 0; i
< count
; i
++)
1788 if (i
%line_modulo
== 0)
1789 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1794 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1797 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1800 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1804 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1806 command_print(cmd_ctx
, output
);
1816 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1821 target_t
*target
= get_current_target(cmd_ctx
);
1827 address
= strtoul(args
[0], NULL
, 0);
1828 value
= strtoul(args
[1], NULL
, 0);
1833 target_buffer_set_u32(target
, value_buf
, value
);
1834 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1837 target_buffer_set_u16(target
, value_buf
, value
);
1838 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1841 value_buf
[0] = value
;
1842 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1850 case ERROR_TARGET_UNALIGNED_ACCESS
:
1851 command_print(cmd_ctx
, "error: address not aligned");
1853 case ERROR_TARGET_DATA_ABORT
:
1854 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1856 case ERROR_TARGET_NOT_HALTED
:
1857 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1862 command_print(cmd_ctx
, "error: unknown error");
1870 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1880 duration_t duration
;
1881 char *duration_text
;
1883 target_t
*target
= get_current_target(cmd_ctx
);
1887 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1891 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1894 image
.base_address_set
= 1;
1895 image
.base_address
= strtoul(args
[1], NULL
, 0);
1899 image
.base_address_set
= 0;
1902 image
.start_address_set
= 0;
1904 duration_start_measure(&duration
);
1906 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1908 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1913 for (i
= 0; i
< image
.num_sections
; i
++)
1915 buffer
= malloc(image
.sections
[i
].size
);
1918 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1922 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1924 ERROR("image_read_section failed with error code: %i", retval
);
1925 command_print(cmd_ctx
, "image reading failed, download aborted");
1927 image_close(&image
);
1930 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1931 image_size
+= buf_cnt
;
1932 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1937 duration_stop_measure(&duration
, &duration_text
);
1938 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1939 free(duration_text
);
1941 image_close(&image
);
1947 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1956 duration_t duration
;
1957 char *duration_text
;
1959 target_t
*target
= get_current_target(cmd_ctx
);
1963 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1967 address
= strtoul(args
[1], NULL
, 0);
1968 size
= strtoul(args
[2], NULL
, 0);
1970 if ((address
& 3) || (size
& 3))
1972 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1976 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1978 command_print(cmd_ctx
, "dump_image error: %s", fileio
.error_str
);
1982 duration_start_measure(&duration
);
1987 u32 this_run_size
= (size
> 560) ? 560 : size
;
1989 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1990 if (retval
!= ERROR_OK
)
1992 command_print(cmd_ctx
, "Reading memory failed %d", retval
);
1996 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1998 size
-= this_run_size
;
1999 address
+= this_run_size
;
2002 fileio_close(&fileio
);
2004 duration_stop_measure(&duration
, &duration_text
);
2005 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2006 free(duration_text
);
2011 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2019 u32 mem_checksum
= 0;
2023 duration_t duration
;
2024 char *duration_text
;
2026 target_t
*target
= get_current_target(cmd_ctx
);
2030 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
2036 ERROR("no target selected");
2040 duration_start_measure(&duration
);
2044 image
.base_address_set
= 1;
2045 image
.base_address
= strtoul(args
[1], NULL
, 0);
2049 image
.base_address_set
= 0;
2050 image
.base_address
= 0x0;
2053 image
.start_address_set
= 0;
2055 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
2057 command_print(cmd_ctx
, "verify_image error: %s", image
.error_str
);
2062 for (i
= 0; i
< image
.num_sections
; i
++)
2064 buffer
= malloc(image
.sections
[i
].size
);
2067 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2070 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2072 ERROR("image_read_section failed with error code: %i", retval
);
2073 command_print(cmd_ctx
, "image reading failed, verify aborted");
2075 image_close(&image
);
2079 /* calculate checksum of image */
2080 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2082 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2084 if( retval
!= ERROR_OK
)
2086 command_print(cmd_ctx
, "could not calculate checksum, verify aborted");
2088 image_close(&image
);
2092 if( checksum
!= mem_checksum
)
2094 /* failed crc checksum, fall back to a binary compare */
2097 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2099 data
= (u8
*)malloc(buf_cnt
);
2101 /* Can we use 32bit word accesses? */
2103 int count
= buf_cnt
;
2104 if ((count
% 4) == 0)
2109 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2111 if (retval
== ERROR_OK
)
2114 for (t
= 0; t
< buf_cnt
; t
++)
2116 if (data
[t
] != buffer
[t
])
2118 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
]);
2121 image_close(&image
);
2131 image_size
+= buf_cnt
;
2134 duration_stop_measure(&duration
, &duration_text
);
2135 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2136 free(duration_text
);
2138 image_close(&image
);
2143 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2146 target_t
*target
= get_current_target(cmd_ctx
);
2150 breakpoint_t
*breakpoint
= target
->breakpoints
;
2154 if (breakpoint
->type
== BKPT_SOFT
)
2156 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2157 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2162 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2164 breakpoint
= breakpoint
->next
;
2172 length
= strtoul(args
[1], NULL
, 0);
2175 if (strcmp(args
[2], "hw") == 0)
2178 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2182 case ERROR_TARGET_NOT_HALTED
:
2183 command_print(cmd_ctx
, "target must be halted to set breakpoints");
2185 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2186 command_print(cmd_ctx
, "no more breakpoints available");
2189 command_print(cmd_ctx
, "unknown error, breakpoint not set");
2195 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2200 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2206 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2208 target_t
*target
= get_current_target(cmd_ctx
);
2211 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2216 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2218 target_t
*target
= get_current_target(cmd_ctx
);
2223 watchpoint_t
*watchpoint
= target
->watchpoints
;
2227 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
);
2228 watchpoint
= watchpoint
->next
;
2233 enum watchpoint_rw type
= WPT_ACCESS
;
2234 u32 data_value
= 0x0;
2235 u32 data_mask
= 0xffffffff;
2251 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2257 data_value
= strtoul(args
[3], NULL
, 0);
2261 data_mask
= strtoul(args
[4], NULL
, 0);
2264 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2265 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2269 case ERROR_TARGET_NOT_HALTED
:
2270 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2272 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2273 command_print(cmd_ctx
, "no more watchpoints available");
2276 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2283 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2289 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2291 target_t
*target
= get_current_target(cmd_ctx
);
2294 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2299 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2302 target_t
*target
= get_current_target(cmd_ctx
);
2308 return ERROR_COMMAND_SYNTAX_ERROR
;
2310 va
= strtoul(args
[0], NULL
, 0);
2312 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2313 if (retval
== ERROR_OK
)
2315 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2319 /* lower levels will have logged a detailed error which is
2320 * forwarded to telnet/GDB session.