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
= fopen(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.
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)