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
);
80 extern target_type_t arm7tdmi_target
;
81 extern target_type_t arm720t_target
;
82 extern target_type_t arm9tdmi_target
;
83 extern target_type_t arm920t_target
;
84 extern target_type_t arm966e_target
;
85 extern target_type_t arm926ejs_target
;
86 extern target_type_t xscale_target
;
87 extern target_type_t cortexm3_target
;
89 target_type_t
*target_types
[] =
102 target_t
*targets
= NULL
;
103 target_event_callback_t
*target_event_callbacks
= NULL
;
104 target_timer_callback_t
*target_timer_callbacks
= NULL
;
106 char *target_state_strings
[] =
115 char *target_debug_reason_strings
[] =
117 "debug request", "breakpoint", "watchpoint",
118 "watchpoint and breakpoint", "single step",
122 char *target_endianess_strings
[] =
128 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
130 static int target_continous_poll
= 1;
132 /* read a u32 from a buffer in target memory endianness */
133 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
135 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
136 return le_to_h_u32(buffer
);
138 return be_to_h_u32(buffer
);
141 /* read a u16 from a buffer in target memory endianness */
142 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
144 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
145 return le_to_h_u16(buffer
);
147 return be_to_h_u16(buffer
);
150 /* write a u32 to a buffer in target memory endianness */
151 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
153 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
154 h_u32_to_le(buffer
, value
);
156 h_u32_to_be(buffer
, value
);
159 /* write a u16 to a buffer in target memory endianness */
160 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
162 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
163 h_u16_to_le(buffer
, value
);
165 h_u16_to_be(buffer
, value
);
168 /* returns a pointer to the n-th configured target */
169 target_t
* get_target_by_num(int num
)
171 target_t
*target
= targets
;
178 target
= target
->next
;
185 int get_num_by_target(target_t
*query_target
)
187 target_t
*target
= targets
;
192 if (target
== query_target
)
194 target
= target
->next
;
201 target_t
* get_current_target(command_context_t
*cmd_ctx
)
203 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
207 ERROR("BUG: current_target out of bounds");
214 /* Process target initialization, when target entered debug out of reset
215 * the handler is unregistered at the end of this function, so it's only called once
217 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
220 struct command_context_s
*cmd_ctx
= priv
;
222 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
224 target_unregister_event_callback(target_init_handler
, priv
);
226 script
= fopen(target
->reset_script
, "r");
229 ERROR("couldn't open script file %s", target
->reset_script
);
233 INFO("executing reset script '%s'", target
->reset_script
);
234 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
237 jtag_execute_queue();
243 int target_run_and_halt_handler(void *priv
)
245 target_t
*target
= priv
;
247 target
->type
->halt(target
);
252 int target_process_reset(struct command_context_s
*cmd_ctx
)
254 int retval
= ERROR_OK
;
256 struct timeval timeout
, now
;
258 /* prepare reset_halt where necessary */
262 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
264 switch (target
->reset_mode
)
267 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
268 target
->reset_mode
= RESET_RUN_AND_HALT
;
271 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
272 target
->reset_mode
= RESET_RUN_AND_INIT
;
278 switch (target
->reset_mode
)
282 target
->type
->prepare_reset_halt(target
);
287 target
= target
->next
;
293 target
->type
->assert_reset(target
);
294 target
= target
->next
;
296 jtag_execute_queue();
298 /* request target halt if necessary, and schedule further action */
302 switch (target
->reset_mode
)
305 /* nothing to do if target just wants to be run */
307 case RESET_RUN_AND_HALT
:
309 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
311 case RESET_RUN_AND_INIT
:
313 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
314 target_register_event_callback(target_init_handler
, cmd_ctx
);
317 target
->type
->halt(target
);
320 target
->type
->halt(target
);
321 target_register_event_callback(target_init_handler
, cmd_ctx
);
324 ERROR("BUG: unknown target->reset_mode");
326 target
= target
->next
;
332 target
->type
->deassert_reset(target
);
333 target
= target
->next
;
335 jtag_execute_queue();
337 /* Wait for reset to complete, maximum 5 seconds. */
338 gettimeofday(&timeout
, NULL
);
339 timeval_add_time(&timeout
, 5, 0);
342 gettimeofday(&now
, NULL
);
344 target_call_timer_callbacks();
349 target
->type
->poll(target
);
350 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) || (target
->reset_mode
== RESET_RUN_AND_HALT
))
352 if (target
->state
!= TARGET_HALTED
)
354 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
356 command_print(cmd_ctx
, "Timed out waiting for reset");
359 usleep(100*1000); /* Do not eat all cpu */
363 target
= target
->next
;
365 /* All targets we're waiting for are halted */
376 int target_init(struct command_context_s
*cmd_ctx
)
378 target_t
*target
= targets
;
382 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
384 ERROR("target '%s' init failed", target
->type
->name
);
387 target
= target
->next
;
392 target_register_user_commands(cmd_ctx
);
393 target_register_timer_callback(handle_target
, 100, 1, NULL
);
399 int target_init_reset(struct command_context_s
*cmd_ctx
)
401 if (startup_mode
== DAEMON_RESET
)
402 target_process_reset(cmd_ctx
);
407 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
409 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
411 if (callback
== NULL
)
413 return ERROR_INVALID_ARGUMENTS
;
418 while ((*callbacks_p
)->next
)
419 callbacks_p
= &((*callbacks_p
)->next
);
420 callbacks_p
= &((*callbacks_p
)->next
);
423 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
424 (*callbacks_p
)->callback
= callback
;
425 (*callbacks_p
)->priv
= priv
;
426 (*callbacks_p
)->next
= NULL
;
431 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
433 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
436 if (callback
== NULL
)
438 return ERROR_INVALID_ARGUMENTS
;
443 while ((*callbacks_p
)->next
)
444 callbacks_p
= &((*callbacks_p
)->next
);
445 callbacks_p
= &((*callbacks_p
)->next
);
448 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
449 (*callbacks_p
)->callback
= callback
;
450 (*callbacks_p
)->periodic
= periodic
;
451 (*callbacks_p
)->time_ms
= time_ms
;
453 gettimeofday(&now
, NULL
);
454 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
455 time_ms
-= (time_ms
% 1000);
456 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
457 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
459 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
460 (*callbacks_p
)->when
.tv_sec
+= 1;
463 (*callbacks_p
)->priv
= priv
;
464 (*callbacks_p
)->next
= NULL
;
469 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
471 target_event_callback_t
**p
= &target_event_callbacks
;
472 target_event_callback_t
*c
= target_event_callbacks
;
474 if (callback
== NULL
)
476 return ERROR_INVALID_ARGUMENTS
;
481 target_event_callback_t
*next
= c
->next
;
482 if ((c
->callback
== callback
) && (c
->priv
== priv
))
496 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
498 target_timer_callback_t
**p
= &target_timer_callbacks
;
499 target_timer_callback_t
*c
= target_timer_callbacks
;
501 if (callback
== NULL
)
503 return ERROR_INVALID_ARGUMENTS
;
508 target_timer_callback_t
*next
= c
->next
;
509 if ((c
->callback
== callback
) && (c
->priv
== priv
))
523 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
525 target_event_callback_t
*callback
= target_event_callbacks
;
526 target_event_callback_t
*next_callback
;
528 DEBUG("target event %i", event
);
532 next_callback
= callback
->next
;
533 callback
->callback(target
, event
, callback
->priv
);
534 callback
= next_callback
;
540 int target_call_timer_callbacks()
542 target_timer_callback_t
*callback
= target_timer_callbacks
;
543 target_timer_callback_t
*next_callback
;
546 gettimeofday(&now
, NULL
);
550 next_callback
= callback
->next
;
552 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
553 || (now
.tv_sec
> callback
->when
.tv_sec
))
555 callback
->callback(callback
->priv
);
556 if (callback
->periodic
)
558 int time_ms
= callback
->time_ms
;
559 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
560 time_ms
-= (time_ms
% 1000);
561 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
562 if (callback
->when
.tv_usec
> 1000000)
564 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
565 callback
->when
.tv_sec
+= 1;
569 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
572 callback
= next_callback
;
578 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
580 working_area_t
*c
= target
->working_areas
;
581 working_area_t
*new_wa
= NULL
;
583 /* only allocate multiples of 4 byte */
586 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
587 size
= CEIL(size
, 4);
590 /* see if there's already a matching working area */
593 if ((c
->free
) && (c
->size
== size
))
601 /* if not, allocate a new one */
604 working_area_t
**p
= &target
->working_areas
;
605 u32 first_free
= target
->working_area
;
606 u32 free_size
= target
->working_area_size
;
608 DEBUG("allocating new working area");
610 c
= target
->working_areas
;
613 first_free
+= c
->size
;
614 free_size
-= c
->size
;
619 if (free_size
< size
)
621 WARNING("not enough working area available");
622 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
625 new_wa
= malloc(sizeof(working_area_t
));
628 new_wa
->address
= first_free
;
630 if (target
->backup_working_area
)
632 new_wa
->backup
= malloc(new_wa
->size
);
633 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
637 new_wa
->backup
= NULL
;
640 /* put new entry in list */
644 /* mark as used, and return the new (reused) area */
654 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
659 if (target
->backup_working_area
)
660 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
664 /* mark user pointer invalid */
671 int target_free_all_working_areas(struct target_s
*target
)
673 working_area_t
*c
= target
->working_areas
;
677 working_area_t
*next
= c
->next
;
678 target_free_working_area(target
, c
);
688 target
->working_areas
= NULL
;
693 int target_register_commands(struct command_context_s
*cmd_ctx
)
695 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
696 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
697 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
698 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
699 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
700 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
705 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
709 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
711 /* handle writes of less than 4 byte */
714 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
719 /* handle unaligned head bytes */
722 int unaligned
= 4 - (address
% 4);
724 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
728 address
+= unaligned
;
732 /* handle aligned words */
735 int aligned
= size
- (size
% 4);
737 /* use bulk writes above a certain limit. This may have to be changed */
740 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
745 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
754 /* handle tail writes of less than 4 bytes */
757 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
764 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
768 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
770 /* handle reads of less than 4 byte */
773 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
778 /* handle unaligned head bytes */
781 int unaligned
= 4 - (address
% 4);
783 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
787 address
+= unaligned
;
791 /* handle aligned words */
794 int aligned
= size
- (size
% 4);
796 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
804 /* handle tail writes of less than 4 bytes */
807 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
814 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
821 if ((retval
= target
->type
->checksum_memory(target
, address
,
822 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
824 buffer
= malloc(size
);
827 ERROR("error allocating buffer for section (%d bytes)", size
);
830 target_read_buffer(target
, address
, size
, buffer
);
832 /* convert to target endianess */
833 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
836 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
837 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
840 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
849 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
853 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
855 if (retval
== ERROR_OK
)
857 *value
= target_buffer_get_u32(target
, value_buf
);
858 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
863 DEBUG("address: 0x%8.8x failed", address
);
869 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
873 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
875 if (retval
== ERROR_OK
)
877 *value
= target_buffer_get_u16(target
, value_buf
);
878 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
883 DEBUG("address: 0x%8.8x failed", address
);
889 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
891 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
893 if (retval
== ERROR_OK
)
895 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
900 DEBUG("address: 0x%8.8x failed", address
);
906 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
911 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
913 target_buffer_set_u32(target
, value_buf
, value
);
914 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
916 DEBUG("failed: %i", retval
);
922 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
927 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
929 target_buffer_set_u16(target
, value_buf
, value
);
930 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
932 DEBUG("failed: %i", retval
);
938 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
942 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
944 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
946 DEBUG("failed: %i", retval
);
952 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
954 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
955 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
956 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
957 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
958 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
959 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
960 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
961 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
963 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
964 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
965 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
967 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
968 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
969 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
971 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
972 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
973 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
974 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
976 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
977 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
978 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
979 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
980 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
982 target_request_register_commands(cmd_ctx
);
983 trace_register_commands(cmd_ctx
);
988 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
990 target_t
*target
= targets
;
995 int num
= strtoul(args
[0], NULL
, 0);
1000 target
= target
->next
;
1004 cmd_ctx
->current_target
= num
;
1006 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1013 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1014 target
= target
->next
;
1020 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1027 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1031 /* search for the specified target */
1032 if (args
[0] && (args
[0][0] != 0))
1034 for (i
= 0; target_types
[i
]; i
++)
1036 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1038 target_t
**last_target_p
= &targets
;
1040 /* register target specific commands */
1041 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1043 ERROR("couldn't register '%s' commands", args
[0]);
1049 while ((*last_target_p
)->next
)
1050 last_target_p
= &((*last_target_p
)->next
);
1051 last_target_p
= &((*last_target_p
)->next
);
1054 *last_target_p
= malloc(sizeof(target_t
));
1056 (*last_target_p
)->type
= target_types
[i
];
1058 if (strcmp(args
[1], "big") == 0)
1059 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1060 else if (strcmp(args
[1], "little") == 0)
1061 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1064 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1068 /* what to do on a target reset */
1069 if (strcmp(args
[2], "reset_halt") == 0)
1070 (*last_target_p
)->reset_mode
= RESET_HALT
;
1071 else if (strcmp(args
[2], "reset_run") == 0)
1072 (*last_target_p
)->reset_mode
= RESET_RUN
;
1073 else if (strcmp(args
[2], "reset_init") == 0)
1074 (*last_target_p
)->reset_mode
= RESET_INIT
;
1075 else if (strcmp(args
[2], "run_and_halt") == 0)
1076 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1077 else if (strcmp(args
[2], "run_and_init") == 0)
1078 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1081 ERROR("unknown target startup mode %s", args
[2]);
1084 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1086 (*last_target_p
)->reset_script
= NULL
;
1087 (*last_target_p
)->post_halt_script
= NULL
;
1088 (*last_target_p
)->pre_resume_script
= NULL
;
1089 (*last_target_p
)->gdb_program_script
= NULL
;
1091 (*last_target_p
)->working_area
= 0x0;
1092 (*last_target_p
)->working_area_size
= 0x0;
1093 (*last_target_p
)->working_areas
= NULL
;
1094 (*last_target_p
)->backup_working_area
= 0;
1096 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1097 (*last_target_p
)->reg_cache
= NULL
;
1098 (*last_target_p
)->breakpoints
= NULL
;
1099 (*last_target_p
)->watchpoints
= NULL
;
1100 (*last_target_p
)->next
= NULL
;
1101 (*last_target_p
)->arch_info
= NULL
;
1103 /* initialize trace information */
1104 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1105 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1106 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1107 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1108 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1109 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1110 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1111 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1113 (*last_target_p
)->dbgmsg
= NULL
;
1114 (*last_target_p
)->dbg_msg_enabled
= 0;
1116 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1124 /* no matching target found */
1127 ERROR("target '%s' not found", args
[0]);
1134 /* usage: target_script <target#> <event> <script_file> */
1135 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1137 target_t
*target
= NULL
;
1141 ERROR("incomplete target_script command");
1145 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1149 ERROR("target number '%s' not defined", args
[0]);
1153 if (strcmp(args
[1], "reset") == 0)
1155 if (target
->reset_script
)
1156 free(target
->reset_script
);
1157 target
->reset_script
= strdup(args
[2]);
1159 else if (strcmp(args
[1], "post_halt") == 0)
1161 if (target
->post_halt_script
)
1162 free(target
->post_halt_script
);
1163 target
->post_halt_script
= strdup(args
[2]);
1165 else if (strcmp(args
[1], "pre_resume") == 0)
1167 if (target
->pre_resume_script
)
1168 free(target
->pre_resume_script
);
1169 target
->pre_resume_script
= strdup(args
[2]);
1171 else if (strcmp(args
[1], "gdb_program_config") == 0)
1173 if (target
->gdb_program_script
)
1174 free(target
->gdb_program_script
);
1175 target
->gdb_program_script
= strdup(args
[2]);
1179 ERROR("unknown event type: '%s", args
[1]);
1186 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1188 target_t
*target
= NULL
;
1192 ERROR("incomplete run_and_halt_time command");
1196 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1200 ERROR("target number '%s' not defined", args
[0]);
1204 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1209 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1211 target_t
*target
= NULL
;
1215 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1219 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1223 ERROR("target number '%s' not defined", args
[0]);
1227 target
->working_area
= strtoul(args
[1], NULL
, 0);
1228 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1230 if (strcmp(args
[3], "backup") == 0)
1232 target
->backup_working_area
= 1;
1234 else if (strcmp(args
[3], "nobackup") == 0)
1236 target
->backup_working_area
= 0;
1240 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1248 /* process target state changes */
1249 int handle_target(void *priv
)
1252 target_t
*target
= targets
;
1256 /* only poll if target isn't already halted */
1257 if (target
->state
!= TARGET_HALTED
)
1259 if (target_continous_poll
)
1260 if ((retval
= target
->type
->poll(target
)) < 0)
1262 ERROR("couldn't poll target. It's due for a reset.");
1266 target
= target
->next
;
1272 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1281 target
= get_current_target(cmd_ctx
);
1283 /* list all available registers for the current target */
1286 reg_cache_t
*cache
= target
->reg_cache
;
1292 for (i
= 0; i
< cache
->num_regs
; i
++)
1294 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1295 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
);
1298 cache
= cache
->next
;
1304 /* access a single register by its ordinal number */
1305 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1307 int num
= strtoul(args
[0], NULL
, 0);
1308 reg_cache_t
*cache
= target
->reg_cache
;
1314 for (i
= 0; i
< cache
->num_regs
; i
++)
1318 reg
= &cache
->reg_list
[i
];
1324 cache
= cache
->next
;
1329 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1332 } else /* access a single register by its name */
1334 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1338 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1343 /* display a register */
1344 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1346 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1349 if (reg
->valid
== 0)
1351 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1352 if (arch_type
== NULL
)
1354 ERROR("BUG: encountered unregistered arch type");
1357 arch_type
->get(reg
);
1359 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1360 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1365 /* set register value */
1368 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1369 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1371 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1372 if (arch_type
== NULL
)
1374 ERROR("BUG: encountered unregistered arch type");
1378 arch_type
->set(reg
, buf
);
1380 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1381 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1389 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1394 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1396 target_t
*target
= get_current_target(cmd_ctx
);
1401 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1402 if (target
->state
== TARGET_HALTED
)
1404 target
->type
->arch_state(target
, buffer
, 512);
1406 command_print(cmd_ctx
, "%s", buffer
);
1411 if (strcmp(args
[0], "on") == 0)
1413 target_continous_poll
= 1;
1415 else if (strcmp(args
[0], "off") == 0)
1417 target_continous_poll
= 0;
1421 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1429 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1431 target_t
*target
= get_current_target(cmd_ctx
);
1432 struct timeval timeout
, now
;
1434 gettimeofday(&timeout
, NULL
);
1436 timeval_add_time(&timeout
, 5, 0);
1440 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
1442 command_print(cmd_ctx
, "usage: wait_halt [seconds]");
1447 command_print(cmd_ctx
, "waiting for target halted...");
1449 while(target
->type
->poll(target
))
1451 if (target
->state
== TARGET_HALTED
)
1453 command_print(cmd_ctx
, "target halted");
1456 target_call_timer_callbacks();
1458 gettimeofday(&now
, NULL
);
1459 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1461 command_print(cmd_ctx
, "timed out while waiting for target halt");
1462 ERROR("timed out while waiting for target halt");
1470 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1473 target_t
*target
= get_current_target(cmd_ctx
);
1477 command_print(cmd_ctx
, "requesting target halt...");
1479 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1483 case ERROR_TARGET_ALREADY_HALTED
:
1484 command_print(cmd_ctx
, "target already halted");
1486 case ERROR_TARGET_TIMEOUT
:
1487 command_print(cmd_ctx
, "target timed out... shutting down");
1490 command_print(cmd_ctx
, "unknown error... shutting down");
1499 /* what to do on daemon startup */
1500 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1504 if (strcmp(args
[0], "attach") == 0)
1506 startup_mode
= DAEMON_ATTACH
;
1509 else if (strcmp(args
[0], "reset") == 0)
1511 startup_mode
= DAEMON_RESET
;
1516 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1521 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1523 target_t
*target
= get_current_target(cmd_ctx
);
1526 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1528 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1532 case ERROR_TARGET_TIMEOUT
:
1533 command_print(cmd_ctx
, "target timed out... shutting down");
1536 command_print(cmd_ctx
, "unknown error... shutting down");
1544 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1546 target_t
*target
= get_current_target(cmd_ctx
);
1547 enum target_reset_mode reset_mode
= target
->reset_mode
;
1548 enum target_reset_mode save
= target
->reset_mode
;
1554 if (strcmp("run", args
[0]) == 0)
1555 reset_mode
= RESET_RUN
;
1556 else if (strcmp("halt", args
[0]) == 0)
1557 reset_mode
= RESET_HALT
;
1558 else if (strcmp("init", args
[0]) == 0)
1559 reset_mode
= RESET_INIT
;
1560 else if (strcmp("run_and_halt", args
[0]) == 0)
1562 reset_mode
= RESET_RUN_AND_HALT
;
1565 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1568 else if (strcmp("run_and_init", args
[0]) == 0)
1570 reset_mode
= RESET_RUN_AND_INIT
;
1573 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1578 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1583 /* temporarily modify mode of current reset target */
1584 target
->reset_mode
= reset_mode
;
1586 /* reset *all* targets */
1587 target_process_reset(cmd_ctx
);
1589 /* Restore default reset mode for this target */
1590 target
->reset_mode
= save
;
1595 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1598 target_t
*target
= get_current_target(cmd_ctx
);
1603 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1605 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1608 command_print(cmd_ctx
, "usage: resume [address]");
1612 if (retval
!= ERROR_OK
)
1616 case ERROR_TARGET_NOT_HALTED
:
1617 command_print(cmd_ctx
, "target not halted");
1620 command_print(cmd_ctx
, "unknown error... shutting down");
1628 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1630 target_t
*target
= get_current_target(cmd_ctx
);
1635 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1638 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1643 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1645 const int line_bytecnt
= 32;
1658 target_t
*target
= get_current_target(cmd_ctx
);
1664 count
= strtoul(args
[1], NULL
, 0);
1666 address
= strtoul(args
[0], NULL
, 0);
1672 size
= 4; line_modulo
= line_bytecnt
/ 4;
1675 size
= 2; line_modulo
= line_bytecnt
/ 2;
1678 size
= 1; line_modulo
= line_bytecnt
/ 1;
1684 buffer
= calloc(count
, size
);
1685 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1686 if (retval
!= ERROR_OK
)
1690 case ERROR_TARGET_UNALIGNED_ACCESS
:
1691 command_print(cmd_ctx
, "error: address not aligned");
1693 case ERROR_TARGET_NOT_HALTED
:
1694 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1696 case ERROR_TARGET_DATA_ABORT
:
1697 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1700 command_print(cmd_ctx
, "error: unknown error");
1708 for (i
= 0; i
< count
; i
++)
1710 if (i
%line_modulo
== 0)
1711 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1716 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1719 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1722 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1726 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1728 command_print(cmd_ctx
, output
);
1738 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1743 target_t
*target
= get_current_target(cmd_ctx
);
1749 address
= strtoul(args
[0], NULL
, 0);
1750 value
= strtoul(args
[1], NULL
, 0);
1755 target_buffer_set_u32(target
, value_buf
, value
);
1756 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1759 target_buffer_set_u16(target
, value_buf
, value
);
1760 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1763 value_buf
[0] = value
;
1764 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1772 case ERROR_TARGET_UNALIGNED_ACCESS
:
1773 command_print(cmd_ctx
, "error: address not aligned");
1775 case ERROR_TARGET_DATA_ABORT
:
1776 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1778 case ERROR_TARGET_NOT_HALTED
:
1779 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1784 command_print(cmd_ctx
, "error: unknown error");
1792 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1802 duration_t duration
;
1803 char *duration_text
;
1805 target_t
*target
= get_current_target(cmd_ctx
);
1809 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1813 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1816 image
.base_address_set
= 1;
1817 image
.base_address
= strtoul(args
[1], NULL
, 0);
1821 image
.base_address_set
= 0;
1824 image
.start_address_set
= 0;
1826 duration_start_measure(&duration
);
1828 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1830 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1835 for (i
= 0; i
< image
.num_sections
; i
++)
1837 buffer
= malloc(image
.sections
[i
].size
);
1840 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1843 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1845 ERROR("image_read_section failed with error code: %i", retval
);
1846 command_print(cmd_ctx
, "image reading failed, download aborted");
1848 image_close(&image
);
1851 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1852 image_size
+= buf_cnt
;
1853 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1858 duration_stop_measure(&duration
, &duration_text
);
1859 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1860 free(duration_text
);
1862 image_close(&image
);
1868 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1877 duration_t duration
;
1878 char *duration_text
;
1880 target_t
*target
= get_current_target(cmd_ctx
);
1884 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1888 address
= strtoul(args
[1], NULL
, 0);
1889 size
= strtoul(args
[2], NULL
, 0);
1891 if ((address
& 3) || (size
& 3))
1893 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1897 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1899 command_print(cmd_ctx
, "dump_image error: %s", fileio
.error_str
);
1903 duration_start_measure(&duration
);
1908 u32 this_run_size
= (size
> 560) ? 560 : size
;
1910 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1911 if (retval
!= ERROR_OK
)
1913 command_print(cmd_ctx
, "Reading memory failed %d", retval
);
1917 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1919 size
-= this_run_size
;
1920 address
+= this_run_size
;
1923 fileio_close(&fileio
);
1925 duration_stop_measure(&duration
, &duration_text
);
1926 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
1927 free(duration_text
);
1932 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1940 u32 mem_checksum
= 0;
1944 duration_t duration
;
1945 char *duration_text
;
1947 target_t
*target
= get_current_target(cmd_ctx
);
1951 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
1957 ERROR("no target selected");
1961 duration_start_measure(&duration
);
1965 image
.base_address_set
= 1;
1966 image
.base_address
= strtoul(args
[1], NULL
, 0);
1970 image
.base_address_set
= 0;
1971 image
.base_address
= 0x0;
1974 image
.start_address_set
= 0;
1976 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
1978 command_print(cmd_ctx
, "verify_image error: %s", image
.error_str
);
1983 for (i
= 0; i
< image
.num_sections
; i
++)
1985 buffer
= malloc(image
.sections
[i
].size
);
1988 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1991 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1993 ERROR("image_read_section failed with error code: %i", retval
);
1994 command_print(cmd_ctx
, "image reading failed, verify aborted");
1996 image_close(&image
);
2000 /* calculate checksum of image */
2001 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2003 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2005 if( retval
!= ERROR_OK
)
2007 command_print(cmd_ctx
, "image verify failed, verify aborted");
2009 image_close(&image
);
2013 if( checksum
!= mem_checksum
)
2015 /* failed crc checksum, fall back to a binary compare */
2018 command_print(cmd_ctx
, "image verify checksum failed - attempting binary compare");
2020 data
= (u8
*)malloc(buf_cnt
);
2022 /* Can we use 32bit word accesses? */
2024 int count
= buf_cnt
;
2025 if ((count
% 4) == 0)
2030 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2032 if (retval
== ERROR_OK
)
2035 for (t
= 0; t
< buf_cnt
; t
++)
2037 if (data
[t
] != buffer
[t
])
2039 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
]);
2042 image_close(&image
);
2052 image_size
+= buf_cnt
;
2055 duration_stop_measure(&duration
, &duration_text
);
2056 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2057 free(duration_text
);
2059 image_close(&image
);
2064 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2067 target_t
*target
= get_current_target(cmd_ctx
);
2071 breakpoint_t
*breakpoint
= target
->breakpoints
;
2075 if (breakpoint
->type
== BKPT_SOFT
)
2077 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2078 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2083 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2085 breakpoint
= breakpoint
->next
;
2093 length
= strtoul(args
[1], NULL
, 0);
2096 if (strcmp(args
[2], "hw") == 0)
2099 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2103 case ERROR_TARGET_NOT_HALTED
:
2104 command_print(cmd_ctx
, "target must be halted to set breakpoints");
2106 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2107 command_print(cmd_ctx
, "no more breakpoints available");
2110 command_print(cmd_ctx
, "unknown error, breakpoint not set");
2116 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2121 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2127 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2129 target_t
*target
= get_current_target(cmd_ctx
);
2132 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2137 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2139 target_t
*target
= get_current_target(cmd_ctx
);
2144 watchpoint_t
*watchpoint
= target
->watchpoints
;
2148 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
);
2149 watchpoint
= watchpoint
->next
;
2154 enum watchpoint_rw type
= WPT_ACCESS
;
2155 u32 data_value
= 0x0;
2156 u32 data_mask
= 0xffffffff;
2172 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2178 data_value
= strtoul(args
[3], NULL
, 0);
2182 data_mask
= strtoul(args
[4], NULL
, 0);
2185 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2186 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2190 case ERROR_TARGET_NOT_HALTED
:
2191 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2193 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2194 command_print(cmd_ctx
, "no more watchpoints available");
2197 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2204 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2210 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2212 target_t
*target
= get_current_target(cmd_ctx
);
2215 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
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)