1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "target_request.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
37 #include <sys/types.h>
45 #include <time_support.h>
50 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
53 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 extern target_type_t arm7tdmi_target
;
83 extern target_type_t arm720t_target
;
84 extern target_type_t arm9tdmi_target
;
85 extern target_type_t arm920t_target
;
86 extern target_type_t arm966e_target
;
87 extern target_type_t arm926ejs_target
;
88 extern target_type_t feroceon_target
;
89 extern target_type_t xscale_target
;
90 extern target_type_t cortexm3_target
;
91 extern target_type_t arm11_target
;
93 target_type_t
*target_types
[] =
108 target_t
*targets
= NULL
;
109 target_event_callback_t
*target_event_callbacks
= NULL
;
110 target_timer_callback_t
*target_timer_callbacks
= NULL
;
112 char *target_state_strings
[] =
121 char *target_debug_reason_strings
[] =
123 "debug request", "breakpoint", "watchpoint",
124 "watchpoint and breakpoint", "single step",
125 "target not halted", "undefined"
128 char *target_endianess_strings
[] =
134 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
136 static int target_continous_poll
= 1;
138 /* read a u32 from a buffer in target memory endianness */
139 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
141 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
142 return le_to_h_u32(buffer
);
144 return be_to_h_u32(buffer
);
147 /* read a u16 from a buffer in target memory endianness */
148 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
150 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
151 return le_to_h_u16(buffer
);
153 return be_to_h_u16(buffer
);
156 /* write a u32 to a buffer in target memory endianness */
157 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
159 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
160 h_u32_to_le(buffer
, value
);
162 h_u32_to_be(buffer
, value
);
165 /* write a u16 to a buffer in target memory endianness */
166 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
168 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
169 h_u16_to_le(buffer
, value
);
171 h_u16_to_be(buffer
, value
);
174 /* returns a pointer to the n-th configured target */
175 target_t
* get_target_by_num(int num
)
177 target_t
*target
= targets
;
184 target
= target
->next
;
191 int get_num_by_target(target_t
*query_target
)
193 target_t
*target
= targets
;
198 if (target
== query_target
)
200 target
= target
->next
;
207 target_t
* get_current_target(command_context_t
*cmd_ctx
)
209 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
213 ERROR("BUG: current_target out of bounds");
220 /* Process target initialization, when target entered debug out of reset
221 * the handler is unregistered at the end of this function, so it's only called once
223 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
226 struct command_context_s
*cmd_ctx
= priv
;
228 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
230 target_unregister_event_callback(target_init_handler
, priv
);
232 script
= open_file_from_path(target
->reset_script
, "r");
235 ERROR("couldn't open script file %s", target
->reset_script
);
239 INFO("executing reset script '%s'", target
->reset_script
);
240 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
243 jtag_execute_queue();
249 int target_run_and_halt_handler(void *priv
)
251 target_t
*target
= priv
;
253 target
->type
->halt(target
);
258 int target_process_reset(struct command_context_s
*cmd_ctx
)
260 int retval
= ERROR_OK
;
262 struct timeval timeout
, now
;
264 /* prepare reset_halt where necessary */
268 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
270 switch (target
->reset_mode
)
273 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
274 target
->reset_mode
= RESET_RUN_AND_HALT
;
277 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
278 target
->reset_mode
= RESET_RUN_AND_INIT
;
284 switch (target
->reset_mode
)
288 target
->type
->prepare_reset_halt(target
);
293 target
= target
->next
;
299 target
->type
->assert_reset(target
);
300 target
= target
->next
;
302 jtag_execute_queue();
304 /* request target halt if necessary, and schedule further action */
308 switch (target
->reset_mode
)
311 /* nothing to do if target just wants to be run */
313 case RESET_RUN_AND_HALT
:
315 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
317 case RESET_RUN_AND_INIT
:
319 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
320 target_register_event_callback(target_init_handler
, cmd_ctx
);
323 target
->type
->halt(target
);
326 target
->type
->halt(target
);
327 target_register_event_callback(target_init_handler
, cmd_ctx
);
330 ERROR("BUG: unknown target->reset_mode");
332 target
= target
->next
;
338 target
->type
->deassert_reset(target
);
339 target
= target
->next
;
341 jtag_execute_queue();
343 /* Wait for reset to complete, maximum 5 seconds. */
344 gettimeofday(&timeout
, NULL
);
345 timeval_add_time(&timeout
, 5, 0);
348 gettimeofday(&now
, NULL
);
350 target_call_timer_callbacks();
355 target
->type
->poll(target
);
356 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) || (target
->reset_mode
== RESET_RUN_AND_HALT
))
358 if (target
->state
!= TARGET_HALTED
)
360 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
362 command_print(cmd_ctx
, "Timed out waiting for reset");
365 /* this will send alive messages on e.g. GDB remote protocol. */
367 USER_N("%s", ""); /* avoid warning about zero length formatting message*/
371 target
= target
->next
;
373 /* All targets we're waiting for are halted */
381 /* We want any events to be processed before the prompt */
382 target_call_timer_callbacks();
387 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
393 static int default_mmu(struct target_s
*target
, int *enabled
)
399 int target_init(struct command_context_s
*cmd_ctx
)
401 target_t
*target
= targets
;
405 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
407 ERROR("target '%s' init failed", target
->type
->name
);
411 /* Set up default functions if none are provided by target */
412 if (target
->type
->virt2phys
== NULL
)
414 target
->type
->virt2phys
= default_virt2phys
;
416 if (target
->type
->mmu
== NULL
)
418 target
->type
->mmu
= default_mmu
;
420 target
= target
->next
;
425 target_register_user_commands(cmd_ctx
);
426 target_register_timer_callback(handle_target
, 100, 1, NULL
);
432 int target_init_reset(struct command_context_s
*cmd_ctx
)
434 if (startup_mode
== DAEMON_RESET
)
435 target_process_reset(cmd_ctx
);
440 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
442 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
444 if (callback
== NULL
)
446 return ERROR_INVALID_ARGUMENTS
;
451 while ((*callbacks_p
)->next
)
452 callbacks_p
= &((*callbacks_p
)->next
);
453 callbacks_p
= &((*callbacks_p
)->next
);
456 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
457 (*callbacks_p
)->callback
= callback
;
458 (*callbacks_p
)->priv
= priv
;
459 (*callbacks_p
)->next
= NULL
;
464 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
466 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
469 if (callback
== NULL
)
471 return ERROR_INVALID_ARGUMENTS
;
476 while ((*callbacks_p
)->next
)
477 callbacks_p
= &((*callbacks_p
)->next
);
478 callbacks_p
= &((*callbacks_p
)->next
);
481 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
482 (*callbacks_p
)->callback
= callback
;
483 (*callbacks_p
)->periodic
= periodic
;
484 (*callbacks_p
)->time_ms
= time_ms
;
486 gettimeofday(&now
, NULL
);
487 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
488 time_ms
-= (time_ms
% 1000);
489 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
490 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
492 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
493 (*callbacks_p
)->when
.tv_sec
+= 1;
496 (*callbacks_p
)->priv
= priv
;
497 (*callbacks_p
)->next
= NULL
;
502 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
504 target_event_callback_t
**p
= &target_event_callbacks
;
505 target_event_callback_t
*c
= target_event_callbacks
;
507 if (callback
== NULL
)
509 return ERROR_INVALID_ARGUMENTS
;
514 target_event_callback_t
*next
= c
->next
;
515 if ((c
->callback
== callback
) && (c
->priv
== priv
))
529 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
531 target_timer_callback_t
**p
= &target_timer_callbacks
;
532 target_timer_callback_t
*c
= target_timer_callbacks
;
534 if (callback
== NULL
)
536 return ERROR_INVALID_ARGUMENTS
;
541 target_timer_callback_t
*next
= c
->next
;
542 if ((c
->callback
== callback
) && (c
->priv
== priv
))
556 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
558 target_event_callback_t
*callback
= target_event_callbacks
;
559 target_event_callback_t
*next_callback
;
561 DEBUG("target event %i", event
);
565 next_callback
= callback
->next
;
566 callback
->callback(target
, event
, callback
->priv
);
567 callback
= next_callback
;
573 int target_call_timer_callbacks()
575 target_timer_callback_t
*callback
= target_timer_callbacks
;
576 target_timer_callback_t
*next_callback
;
579 gettimeofday(&now
, NULL
);
583 next_callback
= callback
->next
;
585 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
586 || (now
.tv_sec
> callback
->when
.tv_sec
))
588 callback
->callback(callback
->priv
);
589 if (callback
->periodic
)
591 int time_ms
= callback
->time_ms
;
592 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
593 time_ms
-= (time_ms
% 1000);
594 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
595 if (callback
->when
.tv_usec
> 1000000)
597 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
598 callback
->when
.tv_sec
+= 1;
602 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
605 callback
= next_callback
;
611 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
613 working_area_t
*c
= target
->working_areas
;
614 working_area_t
*new_wa
= NULL
;
616 /* Reevaluate working area address based on MMU state*/
617 if (target
->working_areas
== NULL
)
621 retval
= target
->type
->mmu(target
, &enabled
);
622 if (retval
!= ERROR_OK
)
628 target
->working_area
= target
->working_area_virt
;
632 target
->working_area
= target
->working_area_phys
;
636 /* only allocate multiples of 4 byte */
639 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
640 size
= CEIL(size
, 4);
643 /* see if there's already a matching working area */
646 if ((c
->free
) && (c
->size
== size
))
654 /* if not, allocate a new one */
657 working_area_t
**p
= &target
->working_areas
;
658 u32 first_free
= target
->working_area
;
659 u32 free_size
= target
->working_area_size
;
661 DEBUG("allocating new working area");
663 c
= target
->working_areas
;
666 first_free
+= c
->size
;
667 free_size
-= c
->size
;
672 if (free_size
< size
)
674 WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
675 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
678 new_wa
= malloc(sizeof(working_area_t
));
681 new_wa
->address
= first_free
;
683 if (target
->backup_working_area
)
685 new_wa
->backup
= malloc(new_wa
->size
);
686 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
690 new_wa
->backup
= NULL
;
693 /* put new entry in list */
697 /* mark as used, and return the new (reused) area */
707 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
712 if (target
->backup_working_area
)
713 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
717 /* mark user pointer invalid */
724 int target_free_all_working_areas(struct target_s
*target
)
726 working_area_t
*c
= target
->working_areas
;
730 working_area_t
*next
= c
->next
;
731 target_free_working_area(target
, c
);
741 target
->working_areas
= NULL
;
746 int target_register_commands(struct command_context_s
*cmd_ctx
)
748 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
749 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
750 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
751 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
752 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
753 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
754 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
759 int target_arch_state(struct target_s
*target
)
764 USER("No target has been configured");
768 USER("target state: %s", target_state_strings
[target
->state
]);
770 if (target
->state
!=TARGET_HALTED
)
773 retval
=target
->type
->arch_state(target
);
777 /* Single aligned words are guaranteed to use 16 or 32 bit access
778 * mode respectively, otherwise data is handled as quickly as
781 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
785 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
787 if (((address
% 2) == 0) && (size
== 2))
789 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
792 /* handle unaligned head bytes */
795 int unaligned
= 4 - (address
% 4);
797 if (unaligned
> size
)
800 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
804 address
+= unaligned
;
808 /* handle aligned words */
811 int aligned
= size
- (size
% 4);
813 /* use bulk writes above a certain limit. This may have to be changed */
816 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
821 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
830 /* handle tail writes of less than 4 bytes */
833 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
841 /* Single aligned words are guaranteed to use 16 or 32 bit access
842 * mode respectively, otherwise data is handled as quickly as
845 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
849 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
851 if (((address
% 2) == 0) && (size
== 2))
853 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
856 /* handle unaligned head bytes */
859 int unaligned
= 4 - (address
% 4);
861 if (unaligned
> size
)
864 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
868 address
+= unaligned
;
872 /* handle aligned words */
875 int aligned
= size
- (size
% 4);
877 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
885 /* handle tail writes of less than 4 bytes */
888 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
895 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
902 if ((retval
= target
->type
->checksum_memory(target
, address
,
903 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
905 buffer
= malloc(size
);
908 ERROR("error allocating buffer for section (%d bytes)", size
);
909 return ERROR_INVALID_ARGUMENTS
;
911 retval
= target_read_buffer(target
, address
, size
, buffer
);
912 if (retval
!= ERROR_OK
)
918 /* convert to target endianess */
919 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
922 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
923 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
926 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
935 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
939 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
941 if (retval
== ERROR_OK
)
943 *value
= target_buffer_get_u32(target
, value_buf
);
944 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
949 DEBUG("address: 0x%8.8x failed", address
);
955 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
959 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
961 if (retval
== ERROR_OK
)
963 *value
= target_buffer_get_u16(target
, value_buf
);
964 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
969 DEBUG("address: 0x%8.8x failed", address
);
975 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
977 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
979 if (retval
== ERROR_OK
)
981 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
986 DEBUG("address: 0x%8.8x failed", address
);
992 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
997 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
999 target_buffer_set_u32(target
, value_buf
, value
);
1000 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1002 DEBUG("failed: %i", retval
);
1008 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1013 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1015 target_buffer_set_u16(target
, value_buf
, value
);
1016 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1018 DEBUG("failed: %i", retval
);
1024 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1028 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1030 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1032 DEBUG("failed: %i", retval
);
1038 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1040 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1041 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1042 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1043 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1044 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1045 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1046 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1047 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1049 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1050 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1051 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1053 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
1054 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
1055 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
1057 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1058 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1059 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1060 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1062 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1063 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1064 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1065 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1066 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1068 target_request_register_commands(cmd_ctx
);
1069 trace_register_commands(cmd_ctx
);
1074 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1076 target_t
*target
= targets
;
1081 int num
= strtoul(args
[0], NULL
, 0);
1086 target
= target
->next
;
1090 cmd_ctx
->current_target
= num
;
1092 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1099 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1100 target
= target
->next
;
1106 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1113 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1117 /* search for the specified target */
1118 if (args
[0] && (args
[0][0] != 0))
1120 for (i
= 0; target_types
[i
]; i
++)
1122 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1124 target_t
**last_target_p
= &targets
;
1126 /* register target specific commands */
1127 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1129 ERROR("couldn't register '%s' commands", args
[0]);
1135 while ((*last_target_p
)->next
)
1136 last_target_p
= &((*last_target_p
)->next
);
1137 last_target_p
= &((*last_target_p
)->next
);
1140 *last_target_p
= malloc(sizeof(target_t
));
1142 (*last_target_p
)->type
= target_types
[i
];
1144 if (strcmp(args
[1], "big") == 0)
1145 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1146 else if (strcmp(args
[1], "little") == 0)
1147 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1150 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1154 /* what to do on a target reset */
1155 if (strcmp(args
[2], "reset_halt") == 0)
1156 (*last_target_p
)->reset_mode
= RESET_HALT
;
1157 else if (strcmp(args
[2], "reset_run") == 0)
1158 (*last_target_p
)->reset_mode
= RESET_RUN
;
1159 else if (strcmp(args
[2], "reset_init") == 0)
1160 (*last_target_p
)->reset_mode
= RESET_INIT
;
1161 else if (strcmp(args
[2], "run_and_halt") == 0)
1162 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1163 else if (strcmp(args
[2], "run_and_init") == 0)
1164 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1167 ERROR("unknown target startup mode %s", args
[2]);
1170 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1172 (*last_target_p
)->reset_script
= NULL
;
1173 (*last_target_p
)->post_halt_script
= NULL
;
1174 (*last_target_p
)->pre_resume_script
= NULL
;
1175 (*last_target_p
)->gdb_program_script
= NULL
;
1177 (*last_target_p
)->working_area
= 0x0;
1178 (*last_target_p
)->working_area_size
= 0x0;
1179 (*last_target_p
)->working_areas
= NULL
;
1180 (*last_target_p
)->backup_working_area
= 0;
1182 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1183 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1184 (*last_target_p
)->reg_cache
= NULL
;
1185 (*last_target_p
)->breakpoints
= NULL
;
1186 (*last_target_p
)->watchpoints
= NULL
;
1187 (*last_target_p
)->next
= NULL
;
1188 (*last_target_p
)->arch_info
= NULL
;
1190 /* initialize trace information */
1191 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1192 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1193 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1194 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1195 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1196 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1197 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1198 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1200 (*last_target_p
)->dbgmsg
= NULL
;
1201 (*last_target_p
)->dbg_msg_enabled
= 0;
1203 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1211 /* no matching target found */
1214 ERROR("target '%s' not found", args
[0]);
1221 /* usage: target_script <target#> <event> <script_file> */
1222 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1224 target_t
*target
= NULL
;
1228 ERROR("incomplete target_script command");
1232 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1236 ERROR("target number '%s' not defined", args
[0]);
1240 if (strcmp(args
[1], "reset") == 0)
1242 if (target
->reset_script
)
1243 free(target
->reset_script
);
1244 target
->reset_script
= strdup(args
[2]);
1246 else if (strcmp(args
[1], "post_halt") == 0)
1248 if (target
->post_halt_script
)
1249 free(target
->post_halt_script
);
1250 target
->post_halt_script
= strdup(args
[2]);
1252 else if (strcmp(args
[1], "pre_resume") == 0)
1254 if (target
->pre_resume_script
)
1255 free(target
->pre_resume_script
);
1256 target
->pre_resume_script
= strdup(args
[2]);
1258 else if (strcmp(args
[1], "gdb_program_config") == 0)
1260 if (target
->gdb_program_script
)
1261 free(target
->gdb_program_script
);
1262 target
->gdb_program_script
= strdup(args
[2]);
1266 ERROR("unknown event type: '%s", args
[1]);
1273 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1275 target_t
*target
= NULL
;
1279 ERROR("incomplete run_and_halt_time command");
1283 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1287 ERROR("target number '%s' not defined", args
[0]);
1291 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1296 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1298 target_t
*target
= NULL
;
1300 if ((argc
< 4) || (argc
> 5))
1302 return ERROR_COMMAND_SYNTAX_ERROR
;
1305 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1309 ERROR("target number '%s' not defined", args
[0]);
1312 target_free_all_working_areas(target
);
1314 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1317 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1319 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1321 if (strcmp(args
[3], "backup") == 0)
1323 target
->backup_working_area
= 1;
1325 else if (strcmp(args
[3], "nobackup") == 0)
1327 target
->backup_working_area
= 0;
1331 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1332 return ERROR_COMMAND_SYNTAX_ERROR
;
1339 /* process target state changes */
1340 int handle_target(void *priv
)
1343 target_t
*target
= targets
;
1347 /* only poll if target isn't already halted */
1348 if (target
->state
!= TARGET_HALTED
)
1350 if (target_continous_poll
)
1351 if ((retval
= target
->type
->poll(target
)) != ERROR_OK
)
1353 ERROR("couldn't poll target(%d). It's due for a reset.", retval
);
1357 target
= target
->next
;
1363 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1372 target
= get_current_target(cmd_ctx
);
1374 /* list all available registers for the current target */
1377 reg_cache_t
*cache
= target
->reg_cache
;
1383 for (i
= 0; i
< cache
->num_regs
; i
++)
1385 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1386 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
);
1389 cache
= cache
->next
;
1395 /* access a single register by its ordinal number */
1396 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1398 int num
= strtoul(args
[0], NULL
, 0);
1399 reg_cache_t
*cache
= target
->reg_cache
;
1405 for (i
= 0; i
< cache
->num_regs
; i
++)
1409 reg
= &cache
->reg_list
[i
];
1415 cache
= cache
->next
;
1420 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1423 } else /* access a single register by its name */
1425 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1429 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1434 /* display a register */
1435 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1437 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1440 if (reg
->valid
== 0)
1442 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1443 if (arch_type
== NULL
)
1445 ERROR("BUG: encountered unregistered arch type");
1448 arch_type
->get(reg
);
1450 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1451 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1456 /* set register value */
1459 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1460 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1462 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1463 if (arch_type
== NULL
)
1465 ERROR("BUG: encountered unregistered arch type");
1469 arch_type
->set(reg
, buf
);
1471 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1472 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1480 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1485 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1487 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1489 target_t
*target
= get_current_target(cmd_ctx
);
1493 target
->type
->poll(target
);
1494 target_arch_state(target
);
1498 if (strcmp(args
[0], "on") == 0)
1500 target_continous_poll
= 1;
1502 else if (strcmp(args
[0], "off") == 0)
1504 target_continous_poll
= 0;
1508 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1516 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1524 ms
= strtoul(args
[0], &end
, 0) * 1000;
1527 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1532 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1535 static void target_process_events(struct command_context_s
*cmd_ctx
)
1537 target_t
*target
= get_current_target(cmd_ctx
);
1538 target
->type
->poll(target
);
1539 target_call_timer_callbacks();
1542 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1545 struct timeval timeout
, now
;
1547 gettimeofday(&timeout
, NULL
);
1548 timeval_add_time(&timeout
, 0, ms
* 1000);
1550 target_t
*target
= get_current_target(cmd_ctx
);
1553 if ((retval
=target
->type
->poll(target
))!=ERROR_OK
)
1555 target_call_timer_callbacks();
1556 if (target
->state
== state
)
1563 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1566 gettimeofday(&now
, NULL
);
1567 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1569 ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1577 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1580 target_t
*target
= get_current_target(cmd_ctx
);
1584 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1589 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1592 /* what to do on daemon startup */
1593 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1597 if (strcmp(args
[0], "attach") == 0)
1599 startup_mode
= DAEMON_ATTACH
;
1602 else if (strcmp(args
[0], "reset") == 0)
1604 startup_mode
= DAEMON_RESET
;
1609 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1614 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1616 target_t
*target
= get_current_target(cmd_ctx
);
1619 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1621 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1625 case ERROR_TARGET_TIMEOUT
:
1626 command_print(cmd_ctx
, "target timed out... shutting down");
1629 command_print(cmd_ctx
, "unknown error... shutting down");
1637 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1639 target_t
*target
= get_current_target(cmd_ctx
);
1640 enum target_reset_mode reset_mode
= target
->reset_mode
;
1641 enum target_reset_mode save
= target
->reset_mode
;
1647 if (strcmp("run", args
[0]) == 0)
1648 reset_mode
= RESET_RUN
;
1649 else if (strcmp("halt", args
[0]) == 0)
1650 reset_mode
= RESET_HALT
;
1651 else if (strcmp("init", args
[0]) == 0)
1652 reset_mode
= RESET_INIT
;
1653 else if (strcmp("run_and_halt", args
[0]) == 0)
1655 reset_mode
= RESET_RUN_AND_HALT
;
1658 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1661 else if (strcmp("run_and_init", args
[0]) == 0)
1663 reset_mode
= RESET_RUN_AND_INIT
;
1666 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1671 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1676 /* temporarily modify mode of current reset target */
1677 target
->reset_mode
= reset_mode
;
1679 /* reset *all* targets */
1680 target_process_reset(cmd_ctx
);
1682 /* Restore default reset mode for this target */
1683 target
->reset_mode
= save
;
1688 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1691 target_t
*target
= get_current_target(cmd_ctx
);
1694 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1696 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1699 return ERROR_COMMAND_SYNTAX_ERROR
;
1702 target_process_events(cmd_ctx
);
1707 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1709 target_t
*target
= get_current_target(cmd_ctx
);
1714 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1717 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1722 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1724 const int line_bytecnt
= 32;
1737 target_t
*target
= get_current_target(cmd_ctx
);
1743 count
= strtoul(args
[1], NULL
, 0);
1745 address
= strtoul(args
[0], NULL
, 0);
1751 size
= 4; line_modulo
= line_bytecnt
/ 4;
1754 size
= 2; line_modulo
= line_bytecnt
/ 2;
1757 size
= 1; line_modulo
= line_bytecnt
/ 1;
1763 buffer
= calloc(count
, size
);
1764 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1765 if (retval
!= ERROR_OK
)
1769 case ERROR_TARGET_UNALIGNED_ACCESS
:
1770 command_print(cmd_ctx
, "error: address not aligned");
1772 case ERROR_TARGET_NOT_HALTED
:
1773 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1775 case ERROR_TARGET_DATA_ABORT
:
1776 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1779 command_print(cmd_ctx
, "error: unknown error");
1787 for (i
= 0; i
< count
; i
++)
1789 if (i
%line_modulo
== 0)
1790 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1795 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1798 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1801 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1805 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1807 command_print(cmd_ctx
, output
);
1817 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1822 target_t
*target
= get_current_target(cmd_ctx
);
1828 address
= strtoul(args
[0], NULL
, 0);
1829 value
= strtoul(args
[1], NULL
, 0);
1834 target_buffer_set_u32(target
, value_buf
, value
);
1835 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1838 target_buffer_set_u16(target
, value_buf
, value
);
1839 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1842 value_buf
[0] = value
;
1843 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1851 case ERROR_TARGET_UNALIGNED_ACCESS
:
1852 command_print(cmd_ctx
, "error: address not aligned");
1854 case ERROR_TARGET_DATA_ABORT
:
1855 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1857 case ERROR_TARGET_NOT_HALTED
:
1858 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1863 command_print(cmd_ctx
, "error: unknown error");
1871 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1881 duration_t duration
;
1882 char *duration_text
;
1884 target_t
*target
= get_current_target(cmd_ctx
);
1888 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1892 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1895 image
.base_address_set
= 1;
1896 image
.base_address
= strtoul(args
[1], NULL
, 0);
1900 image
.base_address_set
= 0;
1903 image
.start_address_set
= 0;
1905 duration_start_measure(&duration
);
1907 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
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
)
1981 duration_start_measure(&duration
);
1986 u32 this_run_size
= (size
> 560) ? 560 : size
;
1988 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1989 if (retval
!= ERROR_OK
)
1991 command_print(cmd_ctx
, "Reading memory failed %d", retval
);
1995 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1997 size
-= this_run_size
;
1998 address
+= this_run_size
;
2001 fileio_close(&fileio
);
2003 duration_stop_measure(&duration
, &duration_text
);
2004 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2005 free(duration_text
);
2010 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2018 u32 mem_checksum
= 0;
2022 duration_t duration
;
2023 char *duration_text
;
2025 target_t
*target
= get_current_target(cmd_ctx
);
2029 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
2035 ERROR("no target selected");
2039 duration_start_measure(&duration
);
2043 image
.base_address_set
= 1;
2044 image
.base_address
= strtoul(args
[1], NULL
, 0);
2048 image
.base_address_set
= 0;
2049 image
.base_address
= 0x0;
2052 image
.start_address_set
= 0;
2054 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
2060 for (i
= 0; i
< image
.num_sections
; i
++)
2062 buffer
= malloc(image
.sections
[i
].size
);
2065 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2068 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2070 ERROR("image_read_section failed with error code: %i", retval
);
2071 command_print(cmd_ctx
, "image reading failed, verify aborted");
2073 image_close(&image
);
2077 /* calculate checksum of image */
2078 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2080 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2082 if( retval
!= ERROR_OK
)
2084 command_print(cmd_ctx
, "could not calculate checksum, verify aborted");
2086 image_close(&image
);
2090 if( checksum
!= mem_checksum
)
2092 /* failed crc checksum, fall back to a binary compare */
2095 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2097 data
= (u8
*)malloc(buf_cnt
);
2099 /* Can we use 32bit word accesses? */
2101 int count
= buf_cnt
;
2102 if ((count
% 4) == 0)
2107 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2109 if (retval
== ERROR_OK
)
2112 for (t
= 0; t
< buf_cnt
; t
++)
2114 if (data
[t
] != buffer
[t
])
2116 command_print(cmd_ctx
, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", t
+ image
.sections
[i
].base_address
, data
[t
], buffer
[t
]);
2119 image_close(&image
);
2129 image_size
+= buf_cnt
;
2132 duration_stop_measure(&duration
, &duration_text
);
2133 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2134 free(duration_text
);
2136 image_close(&image
);
2141 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2144 target_t
*target
= get_current_target(cmd_ctx
);
2148 breakpoint_t
*breakpoint
= target
->breakpoints
;
2152 if (breakpoint
->type
== BKPT_SOFT
)
2154 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2155 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2160 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2162 breakpoint
= breakpoint
->next
;
2170 length
= strtoul(args
[1], NULL
, 0);
2173 if (strcmp(args
[2], "hw") == 0)
2176 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2180 case ERROR_TARGET_NOT_HALTED
:
2181 command_print(cmd_ctx
, "target must be halted to set breakpoints");
2183 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2184 command_print(cmd_ctx
, "no more breakpoints available");
2187 command_print(cmd_ctx
, "unknown error, breakpoint not set");
2193 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2198 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2204 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2206 target_t
*target
= get_current_target(cmd_ctx
);
2209 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2214 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2216 target_t
*target
= get_current_target(cmd_ctx
);
2221 watchpoint_t
*watchpoint
= target
->watchpoints
;
2225 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
);
2226 watchpoint
= watchpoint
->next
;
2231 enum watchpoint_rw type
= WPT_ACCESS
;
2232 u32 data_value
= 0x0;
2233 u32 data_mask
= 0xffffffff;
2249 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2255 data_value
= strtoul(args
[3], NULL
, 0);
2259 data_mask
= strtoul(args
[4], NULL
, 0);
2262 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2263 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2267 case ERROR_TARGET_NOT_HALTED
:
2268 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2270 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2271 command_print(cmd_ctx
, "no more watchpoints available");
2274 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2281 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2287 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2289 target_t
*target
= get_current_target(cmd_ctx
);
2292 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2297 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2300 target_t
*target
= get_current_target(cmd_ctx
);
2306 return ERROR_COMMAND_SYNTAX_ERROR
;
2308 va
= strtoul(args
[0], NULL
, 0);
2310 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2311 if (retval
== ERROR_OK
)
2313 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2317 /* lower levels will have logged a detailed error which is
2318 * 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)