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
;
257 /* prepare reset_halt where necessary */
261 switch (target
->reset_mode
)
265 target
->type
->prepare_reset_halt(target
);
270 target
= target
->next
;
276 target
->type
->assert_reset(target
);
277 target
= target
->next
;
279 jtag_execute_queue();
281 /* request target halt if necessary, and schedule further action */
285 switch (target
->reset_mode
)
288 /* nothing to do if target just wants to be run */
290 case RESET_RUN_AND_HALT
:
292 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
294 case RESET_RUN_AND_INIT
:
296 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
297 target_register_event_callback(target_init_handler
, cmd_ctx
);
300 target
->type
->halt(target
);
303 target
->type
->halt(target
);
304 target_register_event_callback(target_init_handler
, cmd_ctx
);
307 ERROR("BUG: unknown target->reset_mode");
309 target
= target
->next
;
315 target
->type
->deassert_reset(target
);
317 switch (target
->reset_mode
)
321 // If we're already halted, then this is harmless(reducing # of execution paths here)
322 // If nSRST & nTRST are tied together then the halt during reset failed(logged) and
323 // we use this as fallback(there is no other output to tell the user that reset halt
325 target
->type
->poll(target
);
326 target
->type
->halt(target
);
333 target
= target
->next
;
335 jtag_execute_queue();
340 int target_init(struct command_context_s
*cmd_ctx
)
342 target_t
*target
= targets
;
346 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
348 ERROR("target '%s' init failed", target
->type
->name
);
351 target
= target
->next
;
356 target_register_user_commands(cmd_ctx
);
357 target_register_timer_callback(handle_target
, 100, 1, NULL
);
360 if (startup_mode
== DAEMON_RESET
)
361 target_process_reset(cmd_ctx
);
366 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
368 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
370 if (callback
== NULL
)
372 return ERROR_INVALID_ARGUMENTS
;
377 while ((*callbacks_p
)->next
)
378 callbacks_p
= &((*callbacks_p
)->next
);
379 callbacks_p
= &((*callbacks_p
)->next
);
382 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
383 (*callbacks_p
)->callback
= callback
;
384 (*callbacks_p
)->priv
= priv
;
385 (*callbacks_p
)->next
= NULL
;
390 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
392 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
395 if (callback
== NULL
)
397 return ERROR_INVALID_ARGUMENTS
;
402 while ((*callbacks_p
)->next
)
403 callbacks_p
= &((*callbacks_p
)->next
);
404 callbacks_p
= &((*callbacks_p
)->next
);
407 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
408 (*callbacks_p
)->callback
= callback
;
409 (*callbacks_p
)->periodic
= periodic
;
410 (*callbacks_p
)->time_ms
= time_ms
;
412 gettimeofday(&now
, NULL
);
413 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
414 time_ms
-= (time_ms
% 1000);
415 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
416 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
418 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
419 (*callbacks_p
)->when
.tv_sec
+= 1;
422 (*callbacks_p
)->priv
= priv
;
423 (*callbacks_p
)->next
= NULL
;
428 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
430 target_event_callback_t
**p
= &target_event_callbacks
;
431 target_event_callback_t
*c
= target_event_callbacks
;
433 if (callback
== NULL
)
435 return ERROR_INVALID_ARGUMENTS
;
440 target_event_callback_t
*next
= c
->next
;
441 if ((c
->callback
== callback
) && (c
->priv
== priv
))
455 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
457 target_timer_callback_t
**p
= &target_timer_callbacks
;
458 target_timer_callback_t
*c
= target_timer_callbacks
;
460 if (callback
== NULL
)
462 return ERROR_INVALID_ARGUMENTS
;
467 target_timer_callback_t
*next
= c
->next
;
468 if ((c
->callback
== callback
) && (c
->priv
== priv
))
482 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
484 target_event_callback_t
*callback
= target_event_callbacks
;
485 target_event_callback_t
*next_callback
;
487 DEBUG("target event %i", event
);
491 next_callback
= callback
->next
;
492 callback
->callback(target
, event
, callback
->priv
);
493 callback
= next_callback
;
499 int target_call_timer_callbacks()
501 target_timer_callback_t
*callback
= target_timer_callbacks
;
502 target_timer_callback_t
*next_callback
;
505 gettimeofday(&now
, NULL
);
509 next_callback
= callback
->next
;
511 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
512 || (now
.tv_sec
> callback
->when
.tv_sec
))
514 callback
->callback(callback
->priv
);
515 if (callback
->periodic
)
517 int time_ms
= callback
->time_ms
;
518 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
519 time_ms
-= (time_ms
% 1000);
520 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
521 if (callback
->when
.tv_usec
> 1000000)
523 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
524 callback
->when
.tv_sec
+= 1;
528 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
531 callback
= next_callback
;
537 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
539 working_area_t
*c
= target
->working_areas
;
540 working_area_t
*new_wa
= NULL
;
542 /* only allocate multiples of 4 byte */
545 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
546 size
= CEIL(size
, 4);
549 /* see if there's already a matching working area */
552 if ((c
->free
) && (c
->size
== size
))
560 /* if not, allocate a new one */
563 working_area_t
**p
= &target
->working_areas
;
564 u32 first_free
= target
->working_area
;
565 u32 free_size
= target
->working_area_size
;
567 DEBUG("allocating new working area");
569 c
= target
->working_areas
;
572 first_free
+= c
->size
;
573 free_size
-= c
->size
;
578 if (free_size
< size
)
580 WARNING("not enough working area available");
581 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
584 new_wa
= malloc(sizeof(working_area_t
));
587 new_wa
->address
= first_free
;
589 if (target
->backup_working_area
)
591 new_wa
->backup
= malloc(new_wa
->size
);
592 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
596 new_wa
->backup
= NULL
;
599 /* put new entry in list */
603 /* mark as used, and return the new (reused) area */
613 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
618 if (target
->backup_working_area
)
619 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
623 /* mark user pointer invalid */
630 int target_free_all_working_areas(struct target_s
*target
)
632 working_area_t
*c
= target
->working_areas
;
636 working_area_t
*next
= c
->next
;
637 target_free_working_area(target
, c
);
647 target
->working_areas
= NULL
;
652 int target_register_commands(struct command_context_s
*cmd_ctx
)
654 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
655 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
656 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
657 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
658 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
659 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
664 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
668 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
670 /* handle writes of less than 4 byte */
673 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
678 /* handle unaligned head bytes */
681 int unaligned
= 4 - (address
% 4);
683 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
687 address
+= unaligned
;
691 /* handle aligned words */
694 int aligned
= size
- (size
% 4);
696 /* use bulk writes above a certain limit. This may have to be changed */
699 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
704 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
713 /* handle tail writes of less than 4 bytes */
716 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
723 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
727 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
729 /* handle reads of less than 4 byte */
732 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
737 /* handle unaligned head bytes */
740 int unaligned
= 4 - (address
% 4);
742 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
746 address
+= unaligned
;
750 /* handle aligned words */
753 int aligned
= size
- (size
% 4);
755 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
763 /* handle tail writes of less than 4 bytes */
766 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
773 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
780 if ((retval
= target
->type
->checksum_memory(target
, address
,
781 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
783 buffer
= malloc(size
);
784 target_read_buffer(target
, address
, size
, buffer
);
786 /* convert to target endianess */
787 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
790 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
791 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
794 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
803 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
807 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
809 if (retval
== ERROR_OK
)
811 *value
= target_buffer_get_u32(target
, value_buf
);
812 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
817 DEBUG("address: 0x%8.8x failed", address
);
823 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
827 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
829 if (retval
== ERROR_OK
)
831 *value
= target_buffer_get_u16(target
, value_buf
);
832 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
837 DEBUG("address: 0x%8.8x failed", address
);
843 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
845 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
847 if (retval
== ERROR_OK
)
849 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
854 DEBUG("address: 0x%8.8x failed", address
);
860 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
865 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
867 target_buffer_set_u32(target
, value_buf
, value
);
868 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
870 DEBUG("failed: %i", retval
);
876 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
881 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
883 target_buffer_set_u16(target
, value_buf
, value
);
884 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
886 DEBUG("failed: %i", retval
);
892 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
896 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
898 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
900 DEBUG("failed: %i", retval
);
906 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
908 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
909 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
910 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
911 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
912 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
913 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
914 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
915 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
917 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
918 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
919 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
921 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
922 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
923 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
925 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
926 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
927 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
928 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
930 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
931 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
932 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
933 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
934 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
936 target_request_register_commands(cmd_ctx
);
937 trace_register_commands(cmd_ctx
);
942 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
944 target_t
*target
= targets
;
949 int num
= strtoul(args
[0], NULL
, 0);
954 target
= target
->next
;
958 cmd_ctx
->current_target
= num
;
960 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
967 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
968 target
= target
->next
;
974 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
981 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
985 /* search for the specified target */
986 if (args
[0] && (args
[0][0] != 0))
988 for (i
= 0; target_types
[i
]; i
++)
990 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
992 target_t
**last_target_p
= &targets
;
994 /* register target specific commands */
995 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
997 ERROR("couldn't register '%s' commands", args
[0]);
1003 while ((*last_target_p
)->next
)
1004 last_target_p
= &((*last_target_p
)->next
);
1005 last_target_p
= &((*last_target_p
)->next
);
1008 *last_target_p
= malloc(sizeof(target_t
));
1010 (*last_target_p
)->type
= target_types
[i
];
1012 if (strcmp(args
[1], "big") == 0)
1013 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1014 else if (strcmp(args
[1], "little") == 0)
1015 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1018 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1022 /* what to do on a target reset */
1023 if (strcmp(args
[2], "reset_halt") == 0)
1024 (*last_target_p
)->reset_mode
= RESET_HALT
;
1025 else if (strcmp(args
[2], "reset_run") == 0)
1026 (*last_target_p
)->reset_mode
= RESET_RUN
;
1027 else if (strcmp(args
[2], "reset_init") == 0)
1028 (*last_target_p
)->reset_mode
= RESET_INIT
;
1029 else if (strcmp(args
[2], "run_and_halt") == 0)
1030 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1031 else if (strcmp(args
[2], "run_and_init") == 0)
1032 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1035 ERROR("unknown target startup mode %s", args
[2]);
1038 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1040 (*last_target_p
)->reset_script
= NULL
;
1041 (*last_target_p
)->post_halt_script
= NULL
;
1042 (*last_target_p
)->pre_resume_script
= NULL
;
1043 (*last_target_p
)->gdb_program_script
= NULL
;
1045 (*last_target_p
)->working_area
= 0x0;
1046 (*last_target_p
)->working_area_size
= 0x0;
1047 (*last_target_p
)->working_areas
= NULL
;
1048 (*last_target_p
)->backup_working_area
= 0;
1050 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1051 (*last_target_p
)->reg_cache
= NULL
;
1052 (*last_target_p
)->breakpoints
= NULL
;
1053 (*last_target_p
)->watchpoints
= NULL
;
1054 (*last_target_p
)->next
= NULL
;
1055 (*last_target_p
)->arch_info
= NULL
;
1057 /* initialize trace information */
1058 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1059 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1060 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1061 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1062 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1063 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1064 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1065 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1067 (*last_target_p
)->dbgmsg
= NULL
;
1068 (*last_target_p
)->dbg_msg_enabled
= 0;
1070 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1078 /* no matching target found */
1081 ERROR("target '%s' not found", args
[0]);
1088 /* usage: target_script <target#> <event> <script_file> */
1089 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1091 target_t
*target
= NULL
;
1095 ERROR("incomplete target_script command");
1099 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1103 ERROR("target number '%s' not defined", args
[0]);
1107 if (strcmp(args
[1], "reset") == 0)
1109 if (target
->reset_script
)
1110 free(target
->reset_script
);
1111 target
->reset_script
= strdup(args
[2]);
1113 else if (strcmp(args
[1], "post_halt") == 0)
1115 if (target
->post_halt_script
)
1116 free(target
->post_halt_script
);
1117 target
->post_halt_script
= strdup(args
[2]);
1119 else if (strcmp(args
[1], "pre_resume") == 0)
1121 if (target
->pre_resume_script
)
1122 free(target
->pre_resume_script
);
1123 target
->pre_resume_script
= strdup(args
[2]);
1125 else if (strcmp(args
[1], "gdb_program_config") == 0)
1127 if (target
->gdb_program_script
)
1128 free(target
->gdb_program_script
);
1129 target
->gdb_program_script
= strdup(args
[2]);
1133 ERROR("unknown event type: '%s", args
[1]);
1140 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1142 target_t
*target
= NULL
;
1146 ERROR("incomplete run_and_halt_time command");
1150 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1154 ERROR("target number '%s' not defined", args
[0]);
1158 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1163 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1165 target_t
*target
= NULL
;
1169 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1173 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1177 ERROR("target number '%s' not defined", args
[0]);
1181 target
->working_area
= strtoul(args
[1], NULL
, 0);
1182 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1184 if (strcmp(args
[3], "backup") == 0)
1186 target
->backup_working_area
= 1;
1188 else if (strcmp(args
[3], "nobackup") == 0)
1190 target
->backup_working_area
= 0;
1194 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1202 /* process target state changes */
1203 int handle_target(void *priv
)
1206 target_t
*target
= targets
;
1210 /* only poll if target isn't already halted */
1211 if (target
->state
!= TARGET_HALTED
)
1213 if (target_continous_poll
)
1214 if ((retval
= target
->type
->poll(target
)) < 0)
1216 ERROR("couldn't poll target. It's due for a reset.");
1220 target
= target
->next
;
1226 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1235 target
= get_current_target(cmd_ctx
);
1237 /* list all available registers for the current target */
1240 reg_cache_t
*cache
= target
->reg_cache
;
1246 for (i
= 0; i
< cache
->num_regs
; i
++)
1248 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1249 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
);
1252 cache
= cache
->next
;
1258 /* access a single register by its ordinal number */
1259 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1261 int num
= strtoul(args
[0], NULL
, 0);
1262 reg_cache_t
*cache
= target
->reg_cache
;
1268 for (i
= 0; i
< cache
->num_regs
; i
++)
1272 reg
= &cache
->reg_list
[i
];
1278 cache
= cache
->next
;
1283 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1286 } else /* access a single register by its name */
1288 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1292 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1297 /* display a register */
1298 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1300 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1303 if (reg
->valid
== 0)
1305 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1306 if (arch_type
== NULL
)
1308 ERROR("BUG: encountered unregistered arch type");
1311 arch_type
->get(reg
);
1313 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1314 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1319 /* set register value */
1322 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1323 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1325 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1326 if (arch_type
== NULL
)
1328 ERROR("BUG: encountered unregistered arch type");
1332 arch_type
->set(reg
, buf
);
1334 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1335 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1343 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1348 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1350 target_t
*target
= get_current_target(cmd_ctx
);
1355 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1356 if (target
->state
== TARGET_HALTED
)
1358 target
->type
->arch_state(target
, buffer
, 512);
1360 command_print(cmd_ctx
, "%s", buffer
);
1365 if (strcmp(args
[0], "on") == 0)
1367 target_continous_poll
= 1;
1369 else if (strcmp(args
[0], "off") == 0)
1371 target_continous_poll
= 0;
1379 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1381 target_t
*target
= get_current_target(cmd_ctx
);
1382 struct timeval timeout
, now
;
1384 gettimeofday(&timeout
, NULL
);
1386 timeval_add_time(&timeout
, 5, 0);
1390 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
1392 command_print(cmd_ctx
, "usage: wait_halt [seconds]");
1397 command_print(cmd_ctx
, "waiting for target halted...");
1399 while(target
->type
->poll(target
))
1401 if (target
->state
== TARGET_HALTED
)
1403 command_print(cmd_ctx
, "target halted");
1406 target_call_timer_callbacks();
1408 gettimeofday(&now
, NULL
);
1409 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1411 command_print(cmd_ctx
, "timed out while waiting for target halt");
1412 ERROR("timed out while waiting for target halt");
1420 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1423 target_t
*target
= get_current_target(cmd_ctx
);
1427 command_print(cmd_ctx
, "requesting target halt...");
1429 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1433 case ERROR_TARGET_ALREADY_HALTED
:
1434 command_print(cmd_ctx
, "target already halted");
1436 case ERROR_TARGET_TIMEOUT
:
1437 command_print(cmd_ctx
, "target timed out... shutting down");
1440 command_print(cmd_ctx
, "unknown error... shutting down");
1449 /* what to do on daemon startup */
1450 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1454 if (strcmp(args
[0], "attach") == 0)
1456 startup_mode
= DAEMON_ATTACH
;
1459 else if (strcmp(args
[0], "reset") == 0)
1461 startup_mode
= DAEMON_RESET
;
1466 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1471 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1473 target_t
*target
= get_current_target(cmd_ctx
);
1476 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1478 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1482 case ERROR_TARGET_TIMEOUT
:
1483 command_print(cmd_ctx
, "target timed out... shutting down");
1486 command_print(cmd_ctx
, "unknown error... shutting down");
1494 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1496 target_t
*target
= get_current_target(cmd_ctx
);
1497 enum target_reset_mode reset_mode
= RESET_RUN
;
1503 if (strcmp("run", args
[0]) == 0)
1504 reset_mode
= RESET_RUN
;
1505 else if (strcmp("halt", args
[0]) == 0)
1506 reset_mode
= RESET_HALT
;
1507 else if (strcmp("init", args
[0]) == 0)
1508 reset_mode
= RESET_INIT
;
1509 else if (strcmp("run_and_halt", args
[0]) == 0)
1511 reset_mode
= RESET_RUN_AND_HALT
;
1514 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1517 else if (strcmp("run_and_init", args
[0]) == 0)
1519 reset_mode
= RESET_RUN_AND_INIT
;
1522 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1527 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1530 target
->reset_mode
= reset_mode
;
1533 target_process_reset(cmd_ctx
);
1538 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1541 target_t
*target
= get_current_target(cmd_ctx
);
1546 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1548 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1551 command_print(cmd_ctx
, "usage: resume [address]");
1555 if (retval
!= ERROR_OK
)
1559 case ERROR_TARGET_NOT_HALTED
:
1560 command_print(cmd_ctx
, "target not halted");
1563 command_print(cmd_ctx
, "unknown error... shutting down");
1571 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1573 target_t
*target
= get_current_target(cmd_ctx
);
1578 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1581 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1586 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1588 const int line_bytecnt
= 32;
1601 target_t
*target
= get_current_target(cmd_ctx
);
1607 count
= strtoul(args
[1], NULL
, 0);
1609 address
= strtoul(args
[0], NULL
, 0);
1615 size
= 4; line_modulo
= line_bytecnt
/ 4;
1618 size
= 2; line_modulo
= line_bytecnt
/ 2;
1621 size
= 1; line_modulo
= line_bytecnt
/ 1;
1627 buffer
= calloc(count
, size
);
1628 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1629 if (retval
!= ERROR_OK
)
1633 case ERROR_TARGET_UNALIGNED_ACCESS
:
1634 command_print(cmd_ctx
, "error: address not aligned");
1636 case ERROR_TARGET_NOT_HALTED
:
1637 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1639 case ERROR_TARGET_DATA_ABORT
:
1640 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1643 command_print(cmd_ctx
, "error: unknown error");
1651 for (i
= 0; i
< count
; i
++)
1653 if (i
%line_modulo
== 0)
1654 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1659 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1662 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1665 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1669 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1671 command_print(cmd_ctx
, output
);
1681 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1686 target_t
*target
= get_current_target(cmd_ctx
);
1692 address
= strtoul(args
[0], NULL
, 0);
1693 value
= strtoul(args
[1], NULL
, 0);
1698 target_buffer_set_u32(target
, value_buf
, value
);
1699 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1702 target_buffer_set_u16(target
, value_buf
, value
);
1703 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1706 value_buf
[0] = value
;
1707 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1715 case ERROR_TARGET_UNALIGNED_ACCESS
:
1716 command_print(cmd_ctx
, "error: address not aligned");
1718 case ERROR_TARGET_DATA_ABORT
:
1719 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1721 case ERROR_TARGET_NOT_HALTED
:
1722 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1727 command_print(cmd_ctx
, "error: unknown error");
1735 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1745 duration_t duration
;
1746 char *duration_text
;
1748 target_t
*target
= get_current_target(cmd_ctx
);
1752 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1756 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1759 image
.base_address_set
= 1;
1760 image
.base_address
= strtoul(args
[1], NULL
, 0);
1764 image
.base_address_set
= 0;
1767 image
.start_address_set
= 0;
1769 duration_start_measure(&duration
);
1771 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1773 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1778 for (i
= 0; i
< image
.num_sections
; i
++)
1780 buffer
= malloc(image
.sections
[i
].size
);
1781 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1783 ERROR("image_read_section failed with error code: %i", retval
);
1784 command_print(cmd_ctx
, "image reading failed, download aborted");
1786 image_close(&image
);
1789 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1790 image_size
+= buf_cnt
;
1791 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1796 duration_stop_measure(&duration
, &duration_text
);
1797 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1798 free(duration_text
);
1800 image_close(&image
);
1806 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1814 duration_t duration
;
1815 char *duration_text
;
1817 target_t
*target
= get_current_target(cmd_ctx
);
1821 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1825 address
= strtoul(args
[1], NULL
, 0);
1826 size
= strtoul(args
[2], NULL
, 0);
1828 if ((address
& 3) || (size
& 3))
1830 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1834 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1836 command_print(cmd_ctx
, "dump_image error: %s", fileio
.error_str
);
1840 duration_start_measure(&duration
);
1845 u32 this_run_size
= (size
> 560) ? 560 : size
;
1847 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1848 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1850 size
-= this_run_size
;
1851 address
+= this_run_size
;
1854 fileio_close(&fileio
);
1856 duration_stop_measure(&duration
, &duration_text
);
1857 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
1858 free(duration_text
);
1864 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1872 u32 mem_checksum
= 0;
1876 duration_t duration
;
1877 char *duration_text
;
1879 target_t
*target
= get_current_target(cmd_ctx
);
1883 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
1889 ERROR("no target selected");
1893 duration_start_measure(&duration
);
1897 image
.base_address_set
= 1;
1898 image
.base_address
= strtoul(args
[1], NULL
, 0);
1902 image
.base_address_set
= 0;
1903 image
.base_address
= 0x0;
1906 image
.start_address_set
= 0;
1908 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
1910 command_print(cmd_ctx
, "verify_image error: %s", image
.error_str
);
1915 for (i
= 0; i
< image
.num_sections
; i
++)
1917 buffer
= malloc(image
.sections
[i
].size
);
1918 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1920 ERROR("image_read_section failed with error code: %i", retval
);
1921 command_print(cmd_ctx
, "image reading failed, verify aborted");
1923 image_close(&image
);
1927 /* calculate checksum of image */
1928 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
1930 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
1932 if( retval
!= ERROR_OK
)
1934 command_print(cmd_ctx
, "image verify failed, verify aborted");
1936 image_close(&image
);
1940 if( checksum
!= mem_checksum
)
1942 /* failed crc checksum, fall back to a binary compare */
1945 command_print(cmd_ctx
, "image verify checksum failed - attempting binary compare");
1947 data
= (u8
*)malloc(buf_cnt
);
1949 /* Can we use 32bit word accesses? */
1951 int count
= buf_cnt
;
1952 if ((count
% 4) == 0)
1957 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
1959 if (retval
== ERROR_OK
)
1962 for (t
= 0; t
< buf_cnt
; t
++)
1964 if (data
[t
] != buffer
[t
])
1966 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
]);
1969 image_close(&image
);
1979 image_size
+= buf_cnt
;
1982 duration_stop_measure(&duration
, &duration_text
);
1983 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
1984 free(duration_text
);
1986 image_close(&image
);
1991 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1994 target_t
*target
= get_current_target(cmd_ctx
);
1998 breakpoint_t
*breakpoint
= target
->breakpoints
;
2002 if (breakpoint
->type
== BKPT_SOFT
)
2004 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2005 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2010 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2012 breakpoint
= breakpoint
->next
;
2020 length
= strtoul(args
[1], NULL
, 0);
2023 if (strcmp(args
[2], "hw") == 0)
2026 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2030 case ERROR_TARGET_NOT_HALTED
:
2031 command_print(cmd_ctx
, "target must be halted to set breakpoints");
2033 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2034 command_print(cmd_ctx
, "no more breakpoints available");
2037 command_print(cmd_ctx
, "unknown error, breakpoint not set");
2043 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2048 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2054 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2056 target_t
*target
= get_current_target(cmd_ctx
);
2059 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2064 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2066 target_t
*target
= get_current_target(cmd_ctx
);
2071 watchpoint_t
*watchpoint
= target
->watchpoints
;
2075 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
);
2076 watchpoint
= watchpoint
->next
;
2081 enum watchpoint_rw type
= WPT_ACCESS
;
2082 u32 data_value
= 0x0;
2083 u32 data_mask
= 0xffffffff;
2099 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2105 data_value
= strtoul(args
[3], NULL
, 0);
2109 data_mask
= strtoul(args
[4], NULL
, 0);
2112 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2113 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2117 case ERROR_TARGET_NOT_HALTED
:
2118 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2120 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2121 command_print(cmd_ctx
, "no more watchpoints available");
2124 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2131 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2137 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2139 target_t
*target
= get_current_target(cmd_ctx
);
2142 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)