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"
28 #include "configuration.h"
29 #include "binarybuffer.h"
35 #include <sys/types.h>
43 #include <time_support.h>
45 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
47 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
48 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_load_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_dump_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 extern target_type_t arm7tdmi_target
;
75 extern target_type_t arm720t_target
;
76 extern target_type_t arm9tdmi_target
;
77 extern target_type_t arm920t_target
;
78 extern target_type_t arm966e_target
;
80 target_type_t
*target_types
[] =
90 target_t
*targets
= NULL
;
91 target_event_callback_t
*target_event_callbacks
= NULL
;
92 target_timer_callback_t
*target_timer_callbacks
= NULL
;
94 char *target_state_strings
[] =
103 char *target_debug_reason_strings
[] =
105 "debug request", "breakpoint", "watchpoint",
106 "watchpoint and breakpoint", "single step",
110 char *target_endianess_strings
[] =
116 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
118 static int target_continous_poll
= 1;
120 /* read a u32 from a buffer in target memory endianness */
121 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
123 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
124 return le_to_h_u32(buffer
);
126 return be_to_h_u32(buffer
);
129 /* read a u16 from a buffer in target memory endianness */
130 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
132 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
133 return le_to_h_u16(buffer
);
135 return be_to_h_u16(buffer
);
138 /* write a u32 to a buffer in target memory endianness */
139 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
141 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
142 h_u32_to_le(buffer
, value
);
144 h_u32_to_be(buffer
, value
);
147 /* write a u16 to a buffer in target memory endianness */
148 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
150 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
151 h_u16_to_le(buffer
, value
);
153 h_u16_to_be(buffer
, value
);
156 /* returns a pointer to the n-th configured target */
157 target_t
* get_target_by_num(int num
)
159 target_t
*target
= targets
;
166 target
= target
->next
;
173 int get_num_by_target(target_t
*query_target
)
175 target_t
*target
= targets
;
180 if (target
== query_target
)
182 target
= target
->next
;
189 target_t
* get_current_target(command_context_t
*cmd_ctx
)
191 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
195 ERROR("BUG: current_target out of bounds");
202 /* Process target initialization, when target entered debug out of reset
203 * the handler is unregistered at the end of this function, so it's only called once
205 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
208 struct command_context_s
*cmd_ctx
= priv
;
210 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
212 script
= fopen(target
->reset_script
, "r");
215 ERROR("couldn't open script file %s", target
->reset_script
);
219 INFO("executing reset script '%s'", target
->reset_script
);
220 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
223 jtag_execute_queue();
225 target_unregister_event_callback(target_init_handler
, priv
);
231 int target_run_and_halt_handler(void *priv
)
233 target_t
*target
= priv
;
235 target
->type
->halt(target
);
240 int target_process_reset(struct command_context_s
*cmd_ctx
)
242 int retval
= ERROR_OK
;
248 target
->type
->assert_reset(target
);
249 target
= target
->next
;
251 jtag_execute_queue();
253 /* request target halt if necessary, and schedule further action */
257 switch (target
->reset_mode
)
260 /* nothing to do if target just wants to be run */
262 case RESET_RUN_AND_HALT
:
264 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
266 case RESET_RUN_AND_INIT
:
268 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
269 target_register_event_callback(target_init_handler
, cmd_ctx
);
272 target
->type
->halt(target
);
275 target
->type
->halt(target
);
276 target_register_event_callback(target_init_handler
, cmd_ctx
);
279 ERROR("BUG: unknown target->reset_mode");
281 target
= target
->next
;
287 target
->type
->deassert_reset(target
);
288 target
= target
->next
;
290 jtag_execute_queue();
295 int target_init(struct command_context_s
*cmd_ctx
)
297 target_t
*target
= targets
;
301 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
303 ERROR("target '%s' init failed", target
->type
->name
);
306 target
= target
->next
;
311 target_register_user_commands(cmd_ctx
);
312 target_register_timer_callback(handle_target
, 100, 1, NULL
);
315 if (startup_mode
== DAEMON_RESET
)
316 target_process_reset(cmd_ctx
);
321 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
323 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
325 if (callback
== NULL
)
327 return ERROR_INVALID_ARGUMENTS
;
332 while ((*callbacks_p
)->next
)
333 callbacks_p
= &((*callbacks_p
)->next
);
334 callbacks_p
= &((*callbacks_p
)->next
);
337 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
338 (*callbacks_p
)->callback
= callback
;
339 (*callbacks_p
)->priv
= priv
;
340 (*callbacks_p
)->next
= NULL
;
345 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
347 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
350 if (callback
== NULL
)
352 return ERROR_INVALID_ARGUMENTS
;
357 while ((*callbacks_p
)->next
)
358 callbacks_p
= &((*callbacks_p
)->next
);
359 callbacks_p
= &((*callbacks_p
)->next
);
362 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
363 (*callbacks_p
)->callback
= callback
;
364 (*callbacks_p
)->periodic
= periodic
;
365 (*callbacks_p
)->time_ms
= time_ms
;
367 gettimeofday(&now
, NULL
);
368 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
369 time_ms
-= (time_ms
% 1000);
370 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
371 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
373 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
374 (*callbacks_p
)->when
.tv_sec
+= 1;
377 (*callbacks_p
)->priv
= priv
;
378 (*callbacks_p
)->next
= NULL
;
383 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
385 target_event_callback_t
**p
= &target_event_callbacks
;
386 target_event_callback_t
*c
= target_event_callbacks
;
388 if (callback
== NULL
)
390 return ERROR_INVALID_ARGUMENTS
;
395 target_event_callback_t
*next
= c
->next
;
396 if ((c
->callback
== callback
) && (c
->priv
== priv
))
410 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
412 target_timer_callback_t
**p
= &target_timer_callbacks
;
413 target_timer_callback_t
*c
= target_timer_callbacks
;
415 if (callback
== NULL
)
417 return ERROR_INVALID_ARGUMENTS
;
422 target_timer_callback_t
*next
= c
->next
;
423 if ((c
->callback
== callback
) && (c
->priv
== priv
))
437 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
439 target_event_callback_t
*callback
= target_event_callbacks
;
440 target_event_callback_t
*next_callback
;
442 DEBUG("target event %i", event
);
446 next_callback
= callback
->next
;
447 callback
->callback(target
, event
, callback
->priv
);
448 callback
= next_callback
;
454 int target_call_timer_callbacks()
456 target_timer_callback_t
*callback
= target_timer_callbacks
;
457 target_timer_callback_t
*next_callback
;
460 gettimeofday(&now
, NULL
);
464 next_callback
= callback
->next
;
466 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
467 || (now
.tv_sec
> callback
->when
.tv_sec
))
469 callback
->callback(callback
->priv
);
470 if (callback
->periodic
)
472 int time_ms
= callback
->time_ms
;
473 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
474 time_ms
-= (time_ms
% 1000);
475 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
476 if (callback
->when
.tv_usec
> 1000000)
478 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
479 callback
->when
.tv_sec
+= 1;
483 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
486 callback
= next_callback
;
492 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
494 working_area_t
*c
= target
->working_areas
;
495 working_area_t
*new_wa
= NULL
;
497 /* only allocate multiples of 4 byte */
500 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
501 size
= CEIL(size
, 4);
504 /* see if there's already a matching working area */
507 if ((c
->free
) && (c
->size
== size
))
515 /* if not, allocate a new one */
518 working_area_t
**p
= &target
->working_areas
;
519 u32 first_free
= target
->working_area
;
520 u32 free_size
= target
->working_area_size
;
522 DEBUG("allocating new working area");
524 c
= target
->working_areas
;
527 first_free
+= c
->size
;
528 free_size
-= c
->size
;
533 if (free_size
< size
)
535 WARNING("not enough working area available");
536 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
539 new_wa
= malloc(sizeof(working_area_t
));
542 new_wa
->address
= first_free
;
544 if (target
->backup_working_area
)
546 new_wa
->backup
= malloc(new_wa
->size
);
547 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
551 new_wa
->backup
= NULL
;
554 /* put new entry in list */
558 /* mark as used, and return the new (reused) area */
568 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
573 if (target
->backup_working_area
)
574 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
578 /* mark user pointer invalid */
585 int target_free_all_working_areas(struct target_s
*target
)
587 working_area_t
*c
= target
->working_areas
;
591 working_area_t
*next
= c
->next
;
592 target_free_working_area(target
, c
);
602 target
->working_areas
= NULL
;
607 int target_register_commands(struct command_context_s
*cmd_ctx
)
609 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
610 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
611 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
612 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
613 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
614 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
619 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
623 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
625 /* handle writes of less than 4 byte */
628 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
632 /* handle unaligned head bytes */
635 int unaligned
= 4 - (address
% 4);
637 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
641 address
+= unaligned
;
645 /* handle aligned words */
648 int aligned
= size
- (size
% 4);
650 /* use bulk writes above a certain limit. This may have to be changed */
653 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
658 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
667 /* handle tail writes of less than 4 bytes */
670 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
677 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
681 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
683 /* handle reads of less than 4 byte */
686 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
690 /* handle unaligned head bytes */
693 int unaligned
= 4 - (address
% 4);
695 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
699 address
+= unaligned
;
703 /* handle aligned words */
706 int aligned
= size
- (size
% 4);
708 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
716 /* handle tail writes of less than 4 bytes */
719 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
726 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
728 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
729 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
730 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt");
731 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
732 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
733 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction");
734 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
735 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
737 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
738 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
739 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
741 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
742 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
743 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
745 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
746 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
747 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
748 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
750 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_binary_command
, COMMAND_EXEC
, "load binary <file> <address>");
751 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_binary_command
, COMMAND_EXEC
, "dump binary <file> <address> <size>");
756 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
758 target_t
*target
= targets
;
763 int num
= strtoul(args
[0], NULL
, 0);
768 target
= target
->next
;
772 cmd_ctx
->current_target
= num
;
774 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
781 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
782 target
= target
->next
;
788 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
795 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
799 /* search for the specified target */
800 if (args
[0] && (args
[0][0] != 0))
802 for (i
= 0; target_types
[i
]; i
++)
804 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
806 target_t
**last_target_p
= &targets
;
808 /* register target specific commands */
809 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
811 ERROR("couldn't register '%s' commands", args
[0]);
817 while ((*last_target_p
)->next
)
818 last_target_p
= &((*last_target_p
)->next
);
819 last_target_p
= &((*last_target_p
)->next
);
822 *last_target_p
= malloc(sizeof(target_t
));
824 (*last_target_p
)->type
= target_types
[i
];
826 if (strcmp(args
[1], "big") == 0)
827 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
828 else if (strcmp(args
[1], "little") == 0)
829 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
832 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
836 /* what to do on a target reset */
837 if (strcmp(args
[2], "reset_halt") == 0)
838 (*last_target_p
)->reset_mode
= RESET_HALT
;
839 else if (strcmp(args
[2], "reset_run") == 0)
840 (*last_target_p
)->reset_mode
= RESET_RUN
;
841 else if (strcmp(args
[2], "reset_init") == 0)
842 (*last_target_p
)->reset_mode
= RESET_INIT
;
843 else if (strcmp(args
[2], "run_and_halt") == 0)
844 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
845 else if (strcmp(args
[2], "run_and_init") == 0)
846 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
849 ERROR("unknown target startup mode %s", args
[2]);
852 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
854 (*last_target_p
)->reset_script
= NULL
;
855 (*last_target_p
)->post_halt_script
= NULL
;
856 (*last_target_p
)->pre_resume_script
= NULL
;
858 (*last_target_p
)->working_area
= 0x0;
859 (*last_target_p
)->working_area_size
= 0x0;
860 (*last_target_p
)->working_areas
= NULL
;
861 (*last_target_p
)->backup_working_area
= 0;
863 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
864 (*last_target_p
)->state
= TARGET_UNKNOWN
;
865 (*last_target_p
)->reg_cache
= NULL
;
866 (*last_target_p
)->breakpoints
= NULL
;
867 (*last_target_p
)->watchpoints
= NULL
;
868 (*last_target_p
)->next
= NULL
;
869 (*last_target_p
)->arch_info
= NULL
;
871 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
879 /* no matching target found */
882 ERROR("target '%s' not found", args
[0]);
889 /* usage: target_script <target#> <event> <script_file> */
890 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
892 target_t
*target
= NULL
;
896 ERROR("incomplete target_script command");
900 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
904 ERROR("target number '%s' not defined", args
[0]);
908 if (strcmp(args
[1], "reset") == 0)
910 if (target
->reset_script
)
911 free(target
->reset_script
);
912 target
->reset_script
= strdup(args
[2]);
914 else if (strcmp(args
[1], "post_halt") == 0)
916 if (target
->post_halt_script
)
917 free(target
->post_halt_script
);
918 target
->post_halt_script
= strdup(args
[2]);
920 else if (strcmp(args
[1], "pre_resume") == 0)
922 if (target
->pre_resume_script
)
923 free(target
->pre_resume_script
);
924 target
->pre_resume_script
= strdup(args
[2]);
928 ERROR("unknown event type: '%s", args
[1]);
935 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
937 target_t
*target
= NULL
;
941 ERROR("incomplete run_and_halt_time command");
945 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
949 ERROR("target number '%s' not defined", args
[0]);
953 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
958 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
960 target_t
*target
= NULL
;
964 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
968 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
972 ERROR("target number '%s' not defined", args
[0]);
976 target
->working_area
= strtoul(args
[1], NULL
, 0);
977 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
979 if (strcmp(args
[3], "backup") == 0)
981 target
->backup_working_area
= 1;
983 else if (strcmp(args
[3], "nobackup") == 0)
985 target
->backup_working_area
= 0;
989 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
997 /* process target state changes */
998 int handle_target(void *priv
)
1001 target_t
*target
= targets
;
1005 /* only poll if target isn't already halted */
1006 if (target
->state
!= TARGET_HALTED
)
1008 if (target_continous_poll
)
1009 if ((retval
= target
->type
->poll(target
)) < 0)
1011 ERROR("couldn't poll target, exiting");
1016 target
= target
->next
;
1022 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1031 target
= get_current_target(cmd_ctx
);
1033 /* list all available registers for the current target */
1036 reg_cache_t
*cache
= target
->reg_cache
;
1042 for (i
= 0; i
< cache
->num_regs
; i
++)
1044 value
= buf_to_char(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
);
1045 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
);
1048 cache
= cache
->next
;
1054 /* access a single register by its ordinal number */
1055 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1057 int num
= strtoul(args
[0], NULL
, 0);
1058 reg_cache_t
*cache
= target
->reg_cache
;
1064 for (i
= 0; i
< cache
->num_regs
; i
++)
1068 reg
= &cache
->reg_list
[i
];
1074 cache
= cache
->next
;
1079 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1082 } else /* access a single register by its name */
1084 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1088 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1093 /* display a register */
1094 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1096 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1099 if (reg
->valid
== 0)
1101 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1102 if (arch_type
== NULL
)
1104 ERROR("BUG: encountered unregistered arch type");
1107 arch_type
->get(reg
);
1109 value
= buf_to_char(reg
->value
, reg
->size
);
1110 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1115 /* set register value */
1118 u32 new_value
= strtoul(args
[1], NULL
, 0);
1119 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1120 if (arch_type
== NULL
)
1122 ERROR("BUG: encountered unregistered arch type");
1126 arch_type
->set(reg
, new_value
);
1127 value
= buf_to_char(reg
->value
, reg
->size
);
1128 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1134 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1139 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1141 target_t
*target
= get_current_target(cmd_ctx
);
1146 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1147 if (target
->state
== TARGET_HALTED
)
1149 target
->type
->arch_state(target
, buffer
, 512);
1151 command_print(cmd_ctx
, "%s", buffer
);
1156 if (strcmp(args
[0], "on") == 0)
1158 target_continous_poll
= 1;
1160 else if (strcmp(args
[0], "off") == 0)
1162 target_continous_poll
= 0;
1170 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1172 target_t
*target
= get_current_target(cmd_ctx
);
1173 struct timeval timeout
, now
;
1175 gettimeofday(&timeout
, NULL
);
1176 timeval_add_time(&timeout
, 5, 0);
1178 command_print(cmd_ctx
, "waiting for target halted...");
1180 while(target
->type
->poll(target
))
1182 if (target
->state
== TARGET_HALTED
)
1184 command_print(cmd_ctx
, "target halted");
1187 target_call_timer_callbacks();
1189 gettimeofday(&now
, NULL
);
1190 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1192 command_print(cmd_ctx
, "timed out while waiting for target halt");
1193 ERROR("timed out while waiting for target halt");
1201 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1204 target_t
*target
= get_current_target(cmd_ctx
);
1208 command_print(cmd_ctx
, "requesting target halt...");
1210 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1214 case ERROR_TARGET_ALREADY_HALTED
:
1215 command_print(cmd_ctx
, "target already halted");
1217 case ERROR_TARGET_TIMEOUT
:
1218 command_print(cmd_ctx
, "target timed out... shutting down");
1221 command_print(cmd_ctx
, "unknown error... shutting down");
1230 /* what to do on daemon startup */
1231 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1235 if (strcmp(args
[0], "attach") == 0)
1237 startup_mode
= DAEMON_ATTACH
;
1240 else if (strcmp(args
[0], "reset") == 0)
1242 startup_mode
= DAEMON_RESET
;
1247 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1252 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1254 target_t
*target
= get_current_target(cmd_ctx
);
1257 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1259 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1263 case ERROR_TARGET_TIMEOUT
:
1264 command_print(cmd_ctx
, "target timed out... shutting down");
1267 command_print(cmd_ctx
, "unknown error... shutting down");
1275 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1277 target_t
*target
= get_current_target(cmd_ctx
);
1278 enum target_reset_mode reset_mode
= RESET_RUN
;
1284 if (strcmp("run", args
[0]) == 0)
1285 reset_mode
= RESET_RUN
;
1286 else if (strcmp("halt", args
[0]) == 0)
1287 reset_mode
= RESET_HALT
;
1288 else if (strcmp("init", args
[0]) == 0)
1289 reset_mode
= RESET_INIT
;
1290 else if (strcmp("run_and_halt", args
[0]) == 0)
1292 reset_mode
= RESET_RUN_AND_HALT
;
1295 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1298 else if (strcmp("run_and_init", args
[0]) == 0)
1300 reset_mode
= RESET_RUN_AND_INIT
;
1303 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1308 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1311 target
->reset_mode
= reset_mode
;
1314 target_process_reset(cmd_ctx
);
1319 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1322 target_t
*target
= get_current_target(cmd_ctx
);
1327 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1329 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1332 command_print(cmd_ctx
, "usage: resume [address]");
1336 if (retval
!= ERROR_OK
)
1340 case ERROR_TARGET_NOT_HALTED
:
1341 command_print(cmd_ctx
, "target not halted");
1344 command_print(cmd_ctx
, "unknown error... shutting down");
1352 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1354 target_t
*target
= get_current_target(cmd_ctx
);
1359 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1362 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1367 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1380 target_t
*target
= get_current_target(cmd_ctx
);
1386 count
= strtoul(args
[1], NULL
, 0);
1388 address
= strtoul(args
[0], NULL
, 0);
1406 buffer
= calloc(count
, size
);
1407 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1411 case ERROR_TARGET_UNALIGNED_ACCESS
:
1412 command_print(cmd_ctx
, "error: address not aligned");
1414 case ERROR_TARGET_NOT_HALTED
:
1415 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1417 case ERROR_TARGET_DATA_ABORT
:
1418 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1421 command_print(cmd_ctx
, "error: unknown error");
1428 for (i
= 0; i
< count
; i
++)
1431 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1436 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", ((u32
*)buffer
)[i
]);
1439 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", ((u16
*)buffer
)[i
]);
1442 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", ((u8
*)buffer
)[i
]);
1446 if ((i
%8 == 7) || (i
== count
- 1))
1448 command_print(cmd_ctx
, output
);
1458 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1463 target_t
*target
= get_current_target(cmd_ctx
);
1468 address
= strtoul(args
[0], NULL
, 0);
1469 value
= strtoul(args
[1], NULL
, 0);
1474 retval
= target
->type
->write_memory(target
, address
, 4, 1, (u8
*)&value
);
1477 retval
= target
->type
->write_memory(target
, address
, 2, 1, (u8
*)&value
);
1480 retval
= target
->type
->write_memory(target
, address
, 1, 1, (u8
*)&value
);
1488 case ERROR_TARGET_UNALIGNED_ACCESS
:
1489 command_print(cmd_ctx
, "error: address not aligned");
1491 case ERROR_TARGET_DATA_ABORT
:
1492 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1494 case ERROR_TARGET_NOT_HALTED
:
1495 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1500 command_print(cmd_ctx
, "error: unknown error");
1508 int handle_load_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1512 struct stat binary_stat
;
1518 struct timeval start
, end
, duration
;
1520 target_t
*target
= get_current_target(cmd_ctx
);
1524 command_print(cmd_ctx
, "usage: load_binary <filename> <address>");
1528 address
= strtoul(args
[1], NULL
, 0);
1530 if (stat(args
[0], &binary_stat
) == -1)
1532 ERROR("couldn't stat() %s: %s", args
[0], strerror(errno
));
1533 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1537 if (!(binary
= fopen(args
[0], "rb")))
1539 ERROR("couldn't open %s: %s", args
[0], strerror(errno
));
1540 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1544 buffer
= malloc(128 * 1024);
1546 gettimeofday(&start
, NULL
);
1548 binary_size
= binary_stat
.st_size
;
1549 while (binary_size
> 0)
1551 buf_cnt
= fread(buffer
, 1, 128*1024, binary
);
1552 target_write_buffer(target
, address
, buf_cnt
, buffer
);
1554 binary_size
-= buf_cnt
;
1557 gettimeofday(&end
, NULL
);
1561 timeval_subtract(&duration
, &end
, &start
);
1562 command_print(cmd_ctx
, "downloaded %lli byte in %is %ius", (long long) binary_stat
.st_size
, duration
.tv_sec
, duration
.tv_usec
);
1570 int handle_dump_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1577 target_t
*target
= get_current_target(cmd_ctx
);
1581 command_print(cmd_ctx
, "usage: dump_binary <filename> <address> <size>");
1585 address
= strtoul(args
[1], NULL
, 0);
1586 size
= strtoul(args
[2], NULL
, 0);
1588 if (!(binary
= fopen(args
[0], "wb")))
1590 ERROR("couldn't open %s for writing: %s", args
[0], strerror(errno
));
1591 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1595 if ((address
& 3) || (size
& 3))
1597 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1603 u32 this_run_size
= (size
> 560) ? 560 : size
;
1604 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1605 fwrite(buffer
, 1, this_run_size
, binary
);
1606 size
-= this_run_size
;
1607 address
+= this_run_size
;
1616 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1619 target_t
*target
= get_current_target(cmd_ctx
);
1623 breakpoint_t
*breakpoint
= target
->breakpoints
;
1627 if (breakpoint
->type
== BKPT_SOFT
)
1629 char* buf
= buf_to_char(breakpoint
->orig_instr
, breakpoint
->length
);
1630 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
1635 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
1637 breakpoint
= breakpoint
->next
;
1645 length
= strtoul(args
[1], NULL
, 0);
1648 if (strcmp(args
[2], "hw") == 0)
1651 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
1655 case ERROR_TARGET_NOT_HALTED
:
1656 command_print(cmd_ctx
, "target must be halted to set breakpoints");
1658 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1659 command_print(cmd_ctx
, "no more breakpoints available");
1662 command_print(cmd_ctx
, "unknown error, breakpoint not set");
1671 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1673 target_t
*target
= get_current_target(cmd_ctx
);
1676 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
1681 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1683 target_t
*target
= get_current_target(cmd_ctx
);
1687 watchpoint_t
*watchpoint
= target
->watchpoints
;
1691 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
);
1692 watchpoint
= watchpoint
->next
;
1697 enum watchpoint_rw type
= WPT_ACCESS
;
1698 u32 data_value
= 0x0;
1699 u32 data_mask
= 0xffffffff;
1715 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1721 data_value
= strtoul(args
[3], NULL
, 0);
1725 data_mask
= strtoul(args
[4], NULL
, 0);
1727 watchpoint_add(target
, strtoul(args
[0], NULL
, 0), strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
);
1731 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1737 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1739 target_t
*target
= get_current_target(cmd_ctx
);
1742 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)