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
);
316 target
= target
->next
;
318 jtag_execute_queue();
323 int target_init(struct command_context_s
*cmd_ctx
)
325 target_t
*target
= targets
;
329 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
331 ERROR("target '%s' init failed", target
->type
->name
);
334 target
= target
->next
;
339 target_register_user_commands(cmd_ctx
);
340 target_register_timer_callback(handle_target
, 100, 1, NULL
);
343 if (startup_mode
== DAEMON_RESET
)
344 target_process_reset(cmd_ctx
);
349 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
351 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
353 if (callback
== NULL
)
355 return ERROR_INVALID_ARGUMENTS
;
360 while ((*callbacks_p
)->next
)
361 callbacks_p
= &((*callbacks_p
)->next
);
362 callbacks_p
= &((*callbacks_p
)->next
);
365 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
366 (*callbacks_p
)->callback
= callback
;
367 (*callbacks_p
)->priv
= priv
;
368 (*callbacks_p
)->next
= NULL
;
373 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
375 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
378 if (callback
== NULL
)
380 return ERROR_INVALID_ARGUMENTS
;
385 while ((*callbacks_p
)->next
)
386 callbacks_p
= &((*callbacks_p
)->next
);
387 callbacks_p
= &((*callbacks_p
)->next
);
390 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
391 (*callbacks_p
)->callback
= callback
;
392 (*callbacks_p
)->periodic
= periodic
;
393 (*callbacks_p
)->time_ms
= time_ms
;
395 gettimeofday(&now
, NULL
);
396 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
397 time_ms
-= (time_ms
% 1000);
398 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
399 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
401 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
402 (*callbacks_p
)->when
.tv_sec
+= 1;
405 (*callbacks_p
)->priv
= priv
;
406 (*callbacks_p
)->next
= NULL
;
411 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
413 target_event_callback_t
**p
= &target_event_callbacks
;
414 target_event_callback_t
*c
= target_event_callbacks
;
416 if (callback
== NULL
)
418 return ERROR_INVALID_ARGUMENTS
;
423 target_event_callback_t
*next
= c
->next
;
424 if ((c
->callback
== callback
) && (c
->priv
== priv
))
438 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
440 target_timer_callback_t
**p
= &target_timer_callbacks
;
441 target_timer_callback_t
*c
= target_timer_callbacks
;
443 if (callback
== NULL
)
445 return ERROR_INVALID_ARGUMENTS
;
450 target_timer_callback_t
*next
= c
->next
;
451 if ((c
->callback
== callback
) && (c
->priv
== priv
))
465 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
467 target_event_callback_t
*callback
= target_event_callbacks
;
468 target_event_callback_t
*next_callback
;
470 DEBUG("target event %i", event
);
474 next_callback
= callback
->next
;
475 callback
->callback(target
, event
, callback
->priv
);
476 callback
= next_callback
;
482 int target_call_timer_callbacks()
484 target_timer_callback_t
*callback
= target_timer_callbacks
;
485 target_timer_callback_t
*next_callback
;
488 gettimeofday(&now
, NULL
);
492 next_callback
= callback
->next
;
494 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
495 || (now
.tv_sec
> callback
->when
.tv_sec
))
497 callback
->callback(callback
->priv
);
498 if (callback
->periodic
)
500 int time_ms
= callback
->time_ms
;
501 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
502 time_ms
-= (time_ms
% 1000);
503 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
504 if (callback
->when
.tv_usec
> 1000000)
506 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
507 callback
->when
.tv_sec
+= 1;
511 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
514 callback
= next_callback
;
520 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
522 working_area_t
*c
= target
->working_areas
;
523 working_area_t
*new_wa
= NULL
;
525 /* only allocate multiples of 4 byte */
528 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
529 size
= CEIL(size
, 4);
532 /* see if there's already a matching working area */
535 if ((c
->free
) && (c
->size
== size
))
543 /* if not, allocate a new one */
546 working_area_t
**p
= &target
->working_areas
;
547 u32 first_free
= target
->working_area
;
548 u32 free_size
= target
->working_area_size
;
550 DEBUG("allocating new working area");
552 c
= target
->working_areas
;
555 first_free
+= c
->size
;
556 free_size
-= c
->size
;
561 if (free_size
< size
)
563 WARNING("not enough working area available");
564 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
567 new_wa
= malloc(sizeof(working_area_t
));
570 new_wa
->address
= first_free
;
572 if (target
->backup_working_area
)
574 new_wa
->backup
= malloc(new_wa
->size
);
575 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
579 new_wa
->backup
= NULL
;
582 /* put new entry in list */
586 /* mark as used, and return the new (reused) area */
596 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
601 if (target
->backup_working_area
)
602 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
606 /* mark user pointer invalid */
613 int target_free_all_working_areas(struct target_s
*target
)
615 working_area_t
*c
= target
->working_areas
;
619 working_area_t
*next
= c
->next
;
620 target_free_working_area(target
, c
);
630 target
->working_areas
= NULL
;
635 int target_register_commands(struct command_context_s
*cmd_ctx
)
637 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
638 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
639 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
640 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
641 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
642 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
647 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
651 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
653 /* handle writes of less than 4 byte */
656 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
661 /* handle unaligned head bytes */
664 int unaligned
= 4 - (address
% 4);
666 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
670 address
+= unaligned
;
674 /* handle aligned words */
677 int aligned
= size
- (size
% 4);
679 /* use bulk writes above a certain limit. This may have to be changed */
682 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
687 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
696 /* handle tail writes of less than 4 bytes */
699 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
706 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
710 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
712 /* handle reads of less than 4 byte */
715 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
720 /* handle unaligned head bytes */
723 int unaligned
= 4 - (address
% 4);
725 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
729 address
+= unaligned
;
733 /* handle aligned words */
736 int aligned
= size
- (size
% 4);
738 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
746 /* handle tail writes of less than 4 bytes */
749 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
756 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
763 if ((retval
= target
->type
->checksum_memory(target
, address
,
764 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
766 buffer
= malloc(size
);
767 target_read_buffer(target
, address
, size
, buffer
);
769 /* convert to target endianess */
770 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
773 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
774 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
777 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
786 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
790 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
792 if (retval
== ERROR_OK
)
794 *value
= target_buffer_get_u32(target
, value_buf
);
795 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
800 DEBUG("address: 0x%8.8x failed", address
);
806 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
810 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
812 if (retval
== ERROR_OK
)
814 *value
= target_buffer_get_u16(target
, value_buf
);
815 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
820 DEBUG("address: 0x%8.8x failed", address
);
826 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
828 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
830 if (retval
== ERROR_OK
)
832 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
837 DEBUG("address: 0x%8.8x failed", address
);
843 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
848 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
850 target_buffer_set_u32(target
, value_buf
, value
);
851 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
853 DEBUG("failed: %i", retval
);
859 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
864 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
866 target_buffer_set_u16(target
, value_buf
, value
);
867 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
869 DEBUG("failed: %i", retval
);
875 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
879 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
881 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
883 DEBUG("failed: %i", retval
);
889 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
891 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
892 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
893 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
894 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
895 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
896 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
897 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
898 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
900 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
901 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
902 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
904 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
905 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
906 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
908 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
909 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
910 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
911 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
913 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
914 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
915 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
916 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
917 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
919 target_request_register_commands(cmd_ctx
);
920 trace_register_commands(cmd_ctx
);
925 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
927 target_t
*target
= targets
;
932 int num
= strtoul(args
[0], NULL
, 0);
937 target
= target
->next
;
941 cmd_ctx
->current_target
= num
;
943 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
950 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
951 target
= target
->next
;
957 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
964 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
968 /* search for the specified target */
969 if (args
[0] && (args
[0][0] != 0))
971 for (i
= 0; target_types
[i
]; i
++)
973 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
975 target_t
**last_target_p
= &targets
;
977 /* register target specific commands */
978 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
980 ERROR("couldn't register '%s' commands", args
[0]);
986 while ((*last_target_p
)->next
)
987 last_target_p
= &((*last_target_p
)->next
);
988 last_target_p
= &((*last_target_p
)->next
);
991 *last_target_p
= malloc(sizeof(target_t
));
993 (*last_target_p
)->type
= target_types
[i
];
995 if (strcmp(args
[1], "big") == 0)
996 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
997 else if (strcmp(args
[1], "little") == 0)
998 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1001 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1005 /* what to do on a target reset */
1006 if (strcmp(args
[2], "reset_halt") == 0)
1007 (*last_target_p
)->reset_mode
= RESET_HALT
;
1008 else if (strcmp(args
[2], "reset_run") == 0)
1009 (*last_target_p
)->reset_mode
= RESET_RUN
;
1010 else if (strcmp(args
[2], "reset_init") == 0)
1011 (*last_target_p
)->reset_mode
= RESET_INIT
;
1012 else if (strcmp(args
[2], "run_and_halt") == 0)
1013 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1014 else if (strcmp(args
[2], "run_and_init") == 0)
1015 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1018 ERROR("unknown target startup mode %s", args
[2]);
1021 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1023 (*last_target_p
)->reset_script
= NULL
;
1024 (*last_target_p
)->post_halt_script
= NULL
;
1025 (*last_target_p
)->pre_resume_script
= NULL
;
1027 (*last_target_p
)->working_area
= 0x0;
1028 (*last_target_p
)->working_area_size
= 0x0;
1029 (*last_target_p
)->working_areas
= NULL
;
1030 (*last_target_p
)->backup_working_area
= 0;
1032 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1033 (*last_target_p
)->reg_cache
= NULL
;
1034 (*last_target_p
)->breakpoints
= NULL
;
1035 (*last_target_p
)->watchpoints
= NULL
;
1036 (*last_target_p
)->next
= NULL
;
1037 (*last_target_p
)->arch_info
= NULL
;
1039 /* initialize trace information */
1040 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1041 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1042 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1043 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1044 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1045 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1046 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1047 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1049 (*last_target_p
)->dbgmsg
= NULL
;
1051 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1059 /* no matching target found */
1062 ERROR("target '%s' not found", args
[0]);
1069 /* usage: target_script <target#> <event> <script_file> */
1070 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1072 target_t
*target
= NULL
;
1076 ERROR("incomplete target_script command");
1080 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1084 ERROR("target number '%s' not defined", args
[0]);
1088 if (strcmp(args
[1], "reset") == 0)
1090 if (target
->reset_script
)
1091 free(target
->reset_script
);
1092 target
->reset_script
= strdup(args
[2]);
1094 else if (strcmp(args
[1], "post_halt") == 0)
1096 if (target
->post_halt_script
)
1097 free(target
->post_halt_script
);
1098 target
->post_halt_script
= strdup(args
[2]);
1100 else if (strcmp(args
[1], "pre_resume") == 0)
1102 if (target
->pre_resume_script
)
1103 free(target
->pre_resume_script
);
1104 target
->pre_resume_script
= strdup(args
[2]);
1108 ERROR("unknown event type: '%s", args
[1]);
1115 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1117 target_t
*target
= NULL
;
1121 ERROR("incomplete run_and_halt_time command");
1125 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1129 ERROR("target number '%s' not defined", args
[0]);
1133 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1138 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1140 target_t
*target
= NULL
;
1144 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1148 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1152 ERROR("target number '%s' not defined", args
[0]);
1156 target
->working_area
= strtoul(args
[1], NULL
, 0);
1157 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1159 if (strcmp(args
[3], "backup") == 0)
1161 target
->backup_working_area
= 1;
1163 else if (strcmp(args
[3], "nobackup") == 0)
1165 target
->backup_working_area
= 0;
1169 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1177 /* process target state changes */
1178 int handle_target(void *priv
)
1181 target_t
*target
= targets
;
1185 /* only poll if target isn't already halted */
1186 if (target
->state
!= TARGET_HALTED
)
1188 if (target_continous_poll
)
1189 if ((retval
= target
->type
->poll(target
)) < 0)
1191 ERROR("couldn't poll target, exiting");
1196 target
= target
->next
;
1202 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1211 target
= get_current_target(cmd_ctx
);
1213 /* list all available registers for the current target */
1216 reg_cache_t
*cache
= target
->reg_cache
;
1222 for (i
= 0; i
< cache
->num_regs
; i
++)
1224 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1225 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
);
1228 cache
= cache
->next
;
1234 /* access a single register by its ordinal number */
1235 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1237 int num
= strtoul(args
[0], NULL
, 0);
1238 reg_cache_t
*cache
= target
->reg_cache
;
1244 for (i
= 0; i
< cache
->num_regs
; i
++)
1248 reg
= &cache
->reg_list
[i
];
1254 cache
= cache
->next
;
1259 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1262 } else /* access a single register by its name */
1264 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1268 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1273 /* display a register */
1274 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1276 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1279 if (reg
->valid
== 0)
1281 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1282 if (arch_type
== NULL
)
1284 ERROR("BUG: encountered unregistered arch type");
1287 arch_type
->get(reg
);
1289 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1290 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1295 /* set register value */
1298 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1299 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1301 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1302 if (arch_type
== NULL
)
1304 ERROR("BUG: encountered unregistered arch type");
1308 arch_type
->set(reg
, buf
);
1310 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1311 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1319 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1324 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1326 target_t
*target
= get_current_target(cmd_ctx
);
1331 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1332 if (target
->state
== TARGET_HALTED
)
1334 target
->type
->arch_state(target
, buffer
, 512);
1336 command_print(cmd_ctx
, "%s", buffer
);
1341 if (strcmp(args
[0], "on") == 0)
1343 target_continous_poll
= 1;
1345 else if (strcmp(args
[0], "off") == 0)
1347 target_continous_poll
= 0;
1355 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1357 target_t
*target
= get_current_target(cmd_ctx
);
1358 struct timeval timeout
, now
;
1360 gettimeofday(&timeout
, NULL
);
1362 timeval_add_time(&timeout
, 5, 0);
1366 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
1368 command_print(cmd_ctx
, "usage: wait_halt [seconds]");
1373 command_print(cmd_ctx
, "waiting for target halted...");
1375 while(target
->type
->poll(target
))
1377 if (target
->state
== TARGET_HALTED
)
1379 command_print(cmd_ctx
, "target halted");
1382 target_call_timer_callbacks();
1384 gettimeofday(&now
, NULL
);
1385 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1387 command_print(cmd_ctx
, "timed out while waiting for target halt");
1388 ERROR("timed out while waiting for target halt");
1396 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1399 target_t
*target
= get_current_target(cmd_ctx
);
1403 command_print(cmd_ctx
, "requesting target halt...");
1405 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1409 case ERROR_TARGET_ALREADY_HALTED
:
1410 command_print(cmd_ctx
, "target already halted");
1412 case ERROR_TARGET_TIMEOUT
:
1413 command_print(cmd_ctx
, "target timed out... shutting down");
1416 command_print(cmd_ctx
, "unknown error... shutting down");
1425 /* what to do on daemon startup */
1426 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1430 if (strcmp(args
[0], "attach") == 0)
1432 startup_mode
= DAEMON_ATTACH
;
1435 else if (strcmp(args
[0], "reset") == 0)
1437 startup_mode
= DAEMON_RESET
;
1442 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1447 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1449 target_t
*target
= get_current_target(cmd_ctx
);
1452 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1454 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1458 case ERROR_TARGET_TIMEOUT
:
1459 command_print(cmd_ctx
, "target timed out... shutting down");
1462 command_print(cmd_ctx
, "unknown error... shutting down");
1470 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1472 target_t
*target
= get_current_target(cmd_ctx
);
1473 enum target_reset_mode reset_mode
= RESET_RUN
;
1479 if (strcmp("run", args
[0]) == 0)
1480 reset_mode
= RESET_RUN
;
1481 else if (strcmp("halt", args
[0]) == 0)
1482 reset_mode
= RESET_HALT
;
1483 else if (strcmp("init", args
[0]) == 0)
1484 reset_mode
= RESET_INIT
;
1485 else if (strcmp("run_and_halt", args
[0]) == 0)
1487 reset_mode
= RESET_RUN_AND_HALT
;
1490 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1493 else if (strcmp("run_and_init", args
[0]) == 0)
1495 reset_mode
= RESET_RUN_AND_INIT
;
1498 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1503 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1506 target
->reset_mode
= reset_mode
;
1509 target_process_reset(cmd_ctx
);
1514 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1517 target_t
*target
= get_current_target(cmd_ctx
);
1522 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1524 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1527 command_print(cmd_ctx
, "usage: resume [address]");
1531 if (retval
!= ERROR_OK
)
1535 case ERROR_TARGET_NOT_HALTED
:
1536 command_print(cmd_ctx
, "target not halted");
1539 command_print(cmd_ctx
, "unknown error... shutting down");
1547 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1549 target_t
*target
= get_current_target(cmd_ctx
);
1554 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1557 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1562 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1575 target_t
*target
= get_current_target(cmd_ctx
);
1581 count
= strtoul(args
[1], NULL
, 0);
1583 address
= strtoul(args
[0], NULL
, 0);
1601 buffer
= calloc(count
, size
);
1602 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1606 case ERROR_TARGET_UNALIGNED_ACCESS
:
1607 command_print(cmd_ctx
, "error: address not aligned");
1609 case ERROR_TARGET_NOT_HALTED
:
1610 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1612 case ERROR_TARGET_DATA_ABORT
:
1613 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1616 command_print(cmd_ctx
, "error: unknown error");
1624 for (i
= 0; i
< count
; i
++)
1627 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1632 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1635 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1638 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1642 if ((i
%8 == 7) || (i
== count
- 1))
1644 command_print(cmd_ctx
, output
);
1654 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1659 target_t
*target
= get_current_target(cmd_ctx
);
1665 address
= strtoul(args
[0], NULL
, 0);
1666 value
= strtoul(args
[1], NULL
, 0);
1671 target_buffer_set_u32(target
, value_buf
, value
);
1672 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1675 target_buffer_set_u16(target
, value_buf
, value
);
1676 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1679 value_buf
[0] = value
;
1680 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1688 case ERROR_TARGET_UNALIGNED_ACCESS
:
1689 command_print(cmd_ctx
, "error: address not aligned");
1691 case ERROR_TARGET_DATA_ABORT
:
1692 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1694 case ERROR_TARGET_NOT_HALTED
:
1695 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1700 command_print(cmd_ctx
, "error: unknown error");
1708 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1718 duration_t duration
;
1719 char *duration_text
;
1721 target_t
*target
= get_current_target(cmd_ctx
);
1725 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1729 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1732 image
.base_address_set
= 1;
1733 image
.base_address
= strtoul(args
[1], NULL
, 0);
1737 image
.base_address_set
= 0;
1740 image
.start_address_set
= 0;
1742 duration_start_measure(&duration
);
1744 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1746 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1751 for (i
= 0; i
< image
.num_sections
; i
++)
1753 buffer
= malloc(image
.sections
[i
].size
);
1754 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1756 ERROR("image_read_section failed with error code: %i", retval
);
1757 command_print(cmd_ctx
, "image reading failed, download aborted");
1759 image_close(&image
);
1762 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1763 image_size
+= buf_cnt
;
1764 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1769 duration_stop_measure(&duration
, &duration_text
);
1770 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1771 free(duration_text
);
1773 image_close(&image
);
1779 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1787 duration_t duration
;
1788 char *duration_text
;
1790 target_t
*target
= get_current_target(cmd_ctx
);
1794 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1798 address
= strtoul(args
[1], NULL
, 0);
1799 size
= strtoul(args
[2], NULL
, 0);
1801 if ((address
& 3) || (size
& 3))
1803 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1807 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1809 command_print(cmd_ctx
, "dump_image error: %s", fileio
.error_str
);
1813 duration_start_measure(&duration
);
1818 u32 this_run_size
= (size
> 560) ? 560 : size
;
1820 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1821 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1823 size
-= this_run_size
;
1824 address
+= this_run_size
;
1827 fileio_close(&fileio
);
1829 duration_stop_measure(&duration
, &duration_text
);
1830 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
1831 free(duration_text
);
1837 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1845 u32 mem_checksum
= 0;
1849 duration_t duration
;
1850 char *duration_text
;
1852 target_t
*target
= get_current_target(cmd_ctx
);
1856 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
1862 ERROR("no target selected");
1866 duration_start_measure(&duration
);
1870 image
.base_address_set
= 1;
1871 image
.base_address
= strtoul(args
[1], NULL
, 0);
1875 image
.base_address_set
= 0;
1876 image
.base_address
= 0x0;
1879 image
.start_address_set
= 0;
1881 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
1883 command_print(cmd_ctx
, "verify_image error: %s", image
.error_str
);
1888 for (i
= 0; i
< image
.num_sections
; i
++)
1890 buffer
= malloc(image
.sections
[i
].size
);
1891 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1893 ERROR("image_read_section failed with error code: %i", retval
);
1894 command_print(cmd_ctx
, "image reading failed, verify aborted");
1896 image_close(&image
);
1900 /* calculate checksum of image */
1901 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
1904 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
1906 if( retval
!= ERROR_OK
)
1908 command_print(cmd_ctx
, "image verify failed, verify aborted");
1909 image_close(&image
);
1913 if( checksum
!= mem_checksum
)
1915 command_print(cmd_ctx
, "image verify failed, verify aborted");
1916 image_close(&image
);
1920 image_size
+= buf_cnt
;
1923 duration_stop_measure(&duration
, &duration_text
);
1924 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
1925 free(duration_text
);
1927 image_close(&image
);
1932 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1935 target_t
*target
= get_current_target(cmd_ctx
);
1939 breakpoint_t
*breakpoint
= target
->breakpoints
;
1943 if (breakpoint
->type
== BKPT_SOFT
)
1945 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
1946 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
1951 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
1953 breakpoint
= breakpoint
->next
;
1961 length
= strtoul(args
[1], NULL
, 0);
1964 if (strcmp(args
[2], "hw") == 0)
1967 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
1971 case ERROR_TARGET_NOT_HALTED
:
1972 command_print(cmd_ctx
, "target must be halted to set breakpoints");
1974 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1975 command_print(cmd_ctx
, "no more breakpoints available");
1978 command_print(cmd_ctx
, "unknown error, breakpoint not set");
1984 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
1989 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
1995 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1997 target_t
*target
= get_current_target(cmd_ctx
);
2000 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2005 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2007 target_t
*target
= get_current_target(cmd_ctx
);
2012 watchpoint_t
*watchpoint
= target
->watchpoints
;
2016 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
);
2017 watchpoint
= watchpoint
->next
;
2022 enum watchpoint_rw type
= WPT_ACCESS
;
2023 u32 data_value
= 0x0;
2024 u32 data_mask
= 0xffffffff;
2040 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2046 data_value
= strtoul(args
[3], NULL
, 0);
2050 data_mask
= strtoul(args
[4], NULL
, 0);
2053 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2054 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2058 case ERROR_TARGET_NOT_HALTED
:
2059 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2061 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2062 command_print(cmd_ctx
, "no more watchpoints available");
2065 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2072 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2078 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2080 target_t
*target
= get_current_target(cmd_ctx
);
2083 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)