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 void target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
730 target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
732 *value
= target_buffer_get_u32(target
, value_buf
);
735 void target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
739 target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
741 *value
= target_buffer_get_u16(target
, value_buf
);
744 void target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
746 target
->type
->read_memory(target
, address
, 1, 1, value
);
749 void target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
753 target_buffer_set_u32(target
, value_buf
, value
);
754 target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
757 void target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
761 target_buffer_set_u16(target
, value_buf
, value
);
762 target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
765 void target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
767 target
->type
->read_memory(target
, address
, 1, 1, &value
);
770 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
772 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
773 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
774 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt");
775 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
776 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
777 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction");
778 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
779 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
781 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
782 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
783 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
785 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
786 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
787 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
789 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
790 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
791 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
792 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
794 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_binary_command
, COMMAND_EXEC
, "load binary <file> <address>");
795 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_binary_command
, COMMAND_EXEC
, "dump binary <file> <address> <size>");
800 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
802 target_t
*target
= targets
;
807 int num
= strtoul(args
[0], NULL
, 0);
812 target
= target
->next
;
816 cmd_ctx
->current_target
= num
;
818 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
825 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
826 target
= target
->next
;
832 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
839 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
843 /* search for the specified target */
844 if (args
[0] && (args
[0][0] != 0))
846 for (i
= 0; target_types
[i
]; i
++)
848 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
850 target_t
**last_target_p
= &targets
;
852 /* register target specific commands */
853 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
855 ERROR("couldn't register '%s' commands", args
[0]);
861 while ((*last_target_p
)->next
)
862 last_target_p
= &((*last_target_p
)->next
);
863 last_target_p
= &((*last_target_p
)->next
);
866 *last_target_p
= malloc(sizeof(target_t
));
868 (*last_target_p
)->type
= target_types
[i
];
870 if (strcmp(args
[1], "big") == 0)
871 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
872 else if (strcmp(args
[1], "little") == 0)
873 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
876 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
880 /* what to do on a target reset */
881 if (strcmp(args
[2], "reset_halt") == 0)
882 (*last_target_p
)->reset_mode
= RESET_HALT
;
883 else if (strcmp(args
[2], "reset_run") == 0)
884 (*last_target_p
)->reset_mode
= RESET_RUN
;
885 else if (strcmp(args
[2], "reset_init") == 0)
886 (*last_target_p
)->reset_mode
= RESET_INIT
;
887 else if (strcmp(args
[2], "run_and_halt") == 0)
888 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
889 else if (strcmp(args
[2], "run_and_init") == 0)
890 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
893 ERROR("unknown target startup mode %s", args
[2]);
896 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
898 (*last_target_p
)->reset_script
= NULL
;
899 (*last_target_p
)->post_halt_script
= NULL
;
900 (*last_target_p
)->pre_resume_script
= NULL
;
902 (*last_target_p
)->working_area
= 0x0;
903 (*last_target_p
)->working_area_size
= 0x0;
904 (*last_target_p
)->working_areas
= NULL
;
905 (*last_target_p
)->backup_working_area
= 0;
907 (*last_target_p
)->state
= TARGET_UNKNOWN
;
908 (*last_target_p
)->reg_cache
= NULL
;
909 (*last_target_p
)->breakpoints
= NULL
;
910 (*last_target_p
)->watchpoints
= NULL
;
911 (*last_target_p
)->next
= NULL
;
912 (*last_target_p
)->arch_info
= NULL
;
914 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
922 /* no matching target found */
925 ERROR("target '%s' not found", args
[0]);
932 /* usage: target_script <target#> <event> <script_file> */
933 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
935 target_t
*target
= NULL
;
939 ERROR("incomplete target_script command");
943 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
947 ERROR("target number '%s' not defined", args
[0]);
951 if (strcmp(args
[1], "reset") == 0)
953 if (target
->reset_script
)
954 free(target
->reset_script
);
955 target
->reset_script
= strdup(args
[2]);
957 else if (strcmp(args
[1], "post_halt") == 0)
959 if (target
->post_halt_script
)
960 free(target
->post_halt_script
);
961 target
->post_halt_script
= strdup(args
[2]);
963 else if (strcmp(args
[1], "pre_resume") == 0)
965 if (target
->pre_resume_script
)
966 free(target
->pre_resume_script
);
967 target
->pre_resume_script
= strdup(args
[2]);
971 ERROR("unknown event type: '%s", args
[1]);
978 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
980 target_t
*target
= NULL
;
984 ERROR("incomplete run_and_halt_time command");
988 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
992 ERROR("target number '%s' not defined", args
[0]);
996 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1001 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1003 target_t
*target
= NULL
;
1007 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1011 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1015 ERROR("target number '%s' not defined", args
[0]);
1019 target
->working_area
= strtoul(args
[1], NULL
, 0);
1020 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1022 if (strcmp(args
[3], "backup") == 0)
1024 target
->backup_working_area
= 1;
1026 else if (strcmp(args
[3], "nobackup") == 0)
1028 target
->backup_working_area
= 0;
1032 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1040 /* process target state changes */
1041 int handle_target(void *priv
)
1044 target_t
*target
= targets
;
1048 /* only poll if target isn't already halted */
1049 if (target
->state
!= TARGET_HALTED
)
1051 if (target_continous_poll
)
1052 if ((retval
= target
->type
->poll(target
)) < 0)
1054 ERROR("couldn't poll target, exiting");
1059 target
= target
->next
;
1065 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1074 target
= get_current_target(cmd_ctx
);
1076 /* list all available registers for the current target */
1079 reg_cache_t
*cache
= target
->reg_cache
;
1085 for (i
= 0; i
< cache
->num_regs
; i
++)
1087 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1088 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
);
1091 cache
= cache
->next
;
1097 /* access a single register by its ordinal number */
1098 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1100 int num
= strtoul(args
[0], NULL
, 0);
1101 reg_cache_t
*cache
= target
->reg_cache
;
1107 for (i
= 0; i
< cache
->num_regs
; i
++)
1111 reg
= &cache
->reg_list
[i
];
1117 cache
= cache
->next
;
1122 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1125 } else /* access a single register by its name */
1127 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1131 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1136 /* display a register */
1137 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1139 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1142 if (reg
->valid
== 0)
1144 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1145 if (arch_type
== NULL
)
1147 ERROR("BUG: encountered unregistered arch type");
1150 arch_type
->get(reg
);
1152 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1153 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1158 /* set register value */
1161 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1162 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1164 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1165 if (arch_type
== NULL
)
1167 ERROR("BUG: encountered unregistered arch type");
1171 arch_type
->set(reg
, buf
);
1173 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1174 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1182 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1187 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1189 target_t
*target
= get_current_target(cmd_ctx
);
1194 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1195 if (target
->state
== TARGET_HALTED
)
1197 target
->type
->arch_state(target
, buffer
, 512);
1199 command_print(cmd_ctx
, "%s", buffer
);
1204 if (strcmp(args
[0], "on") == 0)
1206 target_continous_poll
= 1;
1208 else if (strcmp(args
[0], "off") == 0)
1210 target_continous_poll
= 0;
1218 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1220 target_t
*target
= get_current_target(cmd_ctx
);
1221 struct timeval timeout
, now
;
1223 gettimeofday(&timeout
, NULL
);
1224 timeval_add_time(&timeout
, 5, 0);
1226 command_print(cmd_ctx
, "waiting for target halted...");
1228 while(target
->type
->poll(target
))
1230 if (target
->state
== TARGET_HALTED
)
1232 command_print(cmd_ctx
, "target halted");
1235 target_call_timer_callbacks();
1237 gettimeofday(&now
, NULL
);
1238 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1240 command_print(cmd_ctx
, "timed out while waiting for target halt");
1241 ERROR("timed out while waiting for target halt");
1249 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1252 target_t
*target
= get_current_target(cmd_ctx
);
1256 command_print(cmd_ctx
, "requesting target halt...");
1258 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1262 case ERROR_TARGET_ALREADY_HALTED
:
1263 command_print(cmd_ctx
, "target already halted");
1265 case ERROR_TARGET_TIMEOUT
:
1266 command_print(cmd_ctx
, "target timed out... shutting down");
1269 command_print(cmd_ctx
, "unknown error... shutting down");
1278 /* what to do on daemon startup */
1279 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1283 if (strcmp(args
[0], "attach") == 0)
1285 startup_mode
= DAEMON_ATTACH
;
1288 else if (strcmp(args
[0], "reset") == 0)
1290 startup_mode
= DAEMON_RESET
;
1295 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1300 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1302 target_t
*target
= get_current_target(cmd_ctx
);
1305 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1307 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1311 case ERROR_TARGET_TIMEOUT
:
1312 command_print(cmd_ctx
, "target timed out... shutting down");
1315 command_print(cmd_ctx
, "unknown error... shutting down");
1323 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1325 target_t
*target
= get_current_target(cmd_ctx
);
1326 enum target_reset_mode reset_mode
= RESET_RUN
;
1332 if (strcmp("run", args
[0]) == 0)
1333 reset_mode
= RESET_RUN
;
1334 else if (strcmp("halt", args
[0]) == 0)
1335 reset_mode
= RESET_HALT
;
1336 else if (strcmp("init", args
[0]) == 0)
1337 reset_mode
= RESET_INIT
;
1338 else if (strcmp("run_and_halt", args
[0]) == 0)
1340 reset_mode
= RESET_RUN_AND_HALT
;
1343 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1346 else if (strcmp("run_and_init", args
[0]) == 0)
1348 reset_mode
= RESET_RUN_AND_INIT
;
1351 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1356 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1359 target
->reset_mode
= reset_mode
;
1362 target_process_reset(cmd_ctx
);
1367 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1370 target_t
*target
= get_current_target(cmd_ctx
);
1375 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1377 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1380 command_print(cmd_ctx
, "usage: resume [address]");
1384 if (retval
!= ERROR_OK
)
1388 case ERROR_TARGET_NOT_HALTED
:
1389 command_print(cmd_ctx
, "target not halted");
1392 command_print(cmd_ctx
, "unknown error... shutting down");
1400 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1402 target_t
*target
= get_current_target(cmd_ctx
);
1407 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1410 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1415 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1428 target_t
*target
= get_current_target(cmd_ctx
);
1434 count
= strtoul(args
[1], NULL
, 0);
1436 address
= strtoul(args
[0], NULL
, 0);
1454 buffer
= calloc(count
, size
);
1455 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1459 case ERROR_TARGET_UNALIGNED_ACCESS
:
1460 command_print(cmd_ctx
, "error: address not aligned");
1462 case ERROR_TARGET_NOT_HALTED
:
1463 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1465 case ERROR_TARGET_DATA_ABORT
:
1466 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1469 command_print(cmd_ctx
, "error: unknown error");
1477 for (i
= 0; i
< count
; i
++)
1480 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1485 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1488 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1491 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1495 if ((i
%8 == 7) || (i
== count
- 1))
1497 command_print(cmd_ctx
, output
);
1507 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1512 target_t
*target
= get_current_target(cmd_ctx
);
1518 address
= strtoul(args
[0], NULL
, 0);
1519 value
= strtoul(args
[1], NULL
, 0);
1524 target_buffer_set_u32(target
, value_buf
, value
);
1525 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1528 target_buffer_set_u16(target
, value_buf
, value
);
1529 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1532 value_buf
[0] = value
;
1533 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1541 case ERROR_TARGET_UNALIGNED_ACCESS
:
1542 command_print(cmd_ctx
, "error: address not aligned");
1544 case ERROR_TARGET_DATA_ABORT
:
1545 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1547 case ERROR_TARGET_NOT_HALTED
:
1548 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1553 command_print(cmd_ctx
, "error: unknown error");
1561 int handle_load_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1565 struct stat binary_stat
;
1571 struct timeval start
, end
, duration
;
1573 target_t
*target
= get_current_target(cmd_ctx
);
1577 command_print(cmd_ctx
, "usage: load_binary <filename> <address>");
1581 address
= strtoul(args
[1], NULL
, 0);
1583 if (stat(args
[0], &binary_stat
) == -1)
1585 ERROR("couldn't stat() %s: %s", args
[0], strerror(errno
));
1586 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1590 if (!(binary
= fopen(args
[0], "rb")))
1592 ERROR("couldn't open %s: %s", args
[0], strerror(errno
));
1593 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1597 buffer
= malloc(128 * 1024);
1599 gettimeofday(&start
, NULL
);
1601 binary_size
= binary_stat
.st_size
;
1602 while (binary_size
> 0)
1604 buf_cnt
= fread(buffer
, 1, 128*1024, binary
);
1605 target_write_buffer(target
, address
, buf_cnt
, buffer
);
1607 binary_size
-= buf_cnt
;
1610 gettimeofday(&end
, NULL
);
1614 timeval_subtract(&duration
, &end
, &start
);
1615 command_print(cmd_ctx
, "downloaded %lli byte in %is %ius", (long long) binary_stat
.st_size
, duration
.tv_sec
, duration
.tv_usec
);
1623 int handle_dump_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1630 struct timeval start
, end
, duration
;
1632 target_t
*target
= get_current_target(cmd_ctx
);
1636 command_print(cmd_ctx
, "usage: dump_binary <filename> <address> <size>");
1640 address
= strtoul(args
[1], NULL
, 0);
1641 size
= strtoul(args
[2], NULL
, 0);
1643 if (!(binary
= fopen(args
[0], "wb")))
1645 ERROR("couldn't open %s for writing: %s", args
[0], strerror(errno
));
1646 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1650 if ((address
& 3) || (size
& 3))
1652 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1656 gettimeofday(&start
, NULL
);
1660 u32 this_run_size
= (size
> 560) ? 560 : size
;
1661 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1662 fwrite(buffer
, 1, this_run_size
, binary
);
1663 size
-= this_run_size
;
1664 address
+= this_run_size
;
1669 gettimeofday(&end
, NULL
);
1671 timeval_subtract(&duration
, &end
, &start
);
1672 command_print(cmd_ctx
, "dumped %i byte in %is %ius", strtoul(args
[2], NULL
, 0), duration
.tv_sec
, duration
.tv_usec
);
1678 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1681 target_t
*target
= get_current_target(cmd_ctx
);
1685 breakpoint_t
*breakpoint
= target
->breakpoints
;
1689 if (breakpoint
->type
== BKPT_SOFT
)
1691 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
1692 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
1697 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
1699 breakpoint
= breakpoint
->next
;
1707 length
= strtoul(args
[1], NULL
, 0);
1710 if (strcmp(args
[2], "hw") == 0)
1713 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
1717 case ERROR_TARGET_NOT_HALTED
:
1718 command_print(cmd_ctx
, "target must be halted to set breakpoints");
1720 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1721 command_print(cmd_ctx
, "no more breakpoints available");
1724 command_print(cmd_ctx
, "unknown error, breakpoint not set");
1730 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
1735 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
1741 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1743 target_t
*target
= get_current_target(cmd_ctx
);
1746 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
1751 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1753 target_t
*target
= get_current_target(cmd_ctx
);
1757 watchpoint_t
*watchpoint
= target
->watchpoints
;
1761 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
);
1762 watchpoint
= watchpoint
->next
;
1767 enum watchpoint_rw type
= WPT_ACCESS
;
1768 u32 data_value
= 0x0;
1769 u32 data_mask
= 0xffffffff;
1785 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1791 data_value
= strtoul(args
[3], NULL
, 0);
1795 data_mask
= strtoul(args
[4], NULL
, 0);
1797 watchpoint_add(target
, strtoul(args
[0], NULL
, 0), strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
);
1801 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1807 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1809 target_t
*target
= get_current_target(cmd_ctx
);
1812 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)