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
;
79 extern target_type_t arm926ejs_target
;
81 target_type_t
*target_types
[] =
92 target_t
*targets
= NULL
;
93 target_event_callback_t
*target_event_callbacks
= NULL
;
94 target_timer_callback_t
*target_timer_callbacks
= NULL
;
96 char *target_state_strings
[] =
105 char *target_debug_reason_strings
[] =
107 "debug request", "breakpoint", "watchpoint",
108 "watchpoint and breakpoint", "single step",
112 char *target_endianess_strings
[] =
118 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
120 static int target_continous_poll
= 1;
122 /* read a u32 from a buffer in target memory endianness */
123 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
125 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
126 return le_to_h_u32(buffer
);
128 return be_to_h_u32(buffer
);
131 /* read a u16 from a buffer in target memory endianness */
132 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
134 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
135 return le_to_h_u16(buffer
);
137 return be_to_h_u16(buffer
);
140 /* write a u32 to a buffer in target memory endianness */
141 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
143 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
144 h_u32_to_le(buffer
, value
);
146 h_u32_to_be(buffer
, value
);
149 /* write a u16 to a buffer in target memory endianness */
150 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
152 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
153 h_u16_to_le(buffer
, value
);
155 h_u16_to_be(buffer
, value
);
158 /* returns a pointer to the n-th configured target */
159 target_t
* get_target_by_num(int num
)
161 target_t
*target
= targets
;
168 target
= target
->next
;
175 int get_num_by_target(target_t
*query_target
)
177 target_t
*target
= targets
;
182 if (target
== query_target
)
184 target
= target
->next
;
191 target_t
* get_current_target(command_context_t
*cmd_ctx
)
193 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
197 ERROR("BUG: current_target out of bounds");
204 /* Process target initialization, when target entered debug out of reset
205 * the handler is unregistered at the end of this function, so it's only called once
207 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
210 struct command_context_s
*cmd_ctx
= priv
;
212 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
214 target_unregister_event_callback(target_init_handler
, priv
);
216 script
= fopen(target
->reset_script
, "r");
219 ERROR("couldn't open script file %s", target
->reset_script
);
223 INFO("executing reset script '%s'", target
->reset_script
);
224 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
227 jtag_execute_queue();
233 int target_run_and_halt_handler(void *priv
)
235 target_t
*target
= priv
;
237 target
->type
->halt(target
);
242 int target_process_reset(struct command_context_s
*cmd_ctx
)
244 int retval
= ERROR_OK
;
250 target
->type
->assert_reset(target
);
251 target
= target
->next
;
253 jtag_execute_queue();
255 /* request target halt if necessary, and schedule further action */
259 switch (target
->reset_mode
)
262 /* nothing to do if target just wants to be run */
264 case RESET_RUN_AND_HALT
:
266 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
268 case RESET_RUN_AND_INIT
:
270 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
271 target_register_event_callback(target_init_handler
, cmd_ctx
);
274 target
->type
->halt(target
);
277 target
->type
->halt(target
);
278 target_register_event_callback(target_init_handler
, cmd_ctx
);
281 ERROR("BUG: unknown target->reset_mode");
283 target
= target
->next
;
289 target
->type
->deassert_reset(target
);
290 target
= target
->next
;
292 jtag_execute_queue();
297 int target_init(struct command_context_s
*cmd_ctx
)
299 target_t
*target
= targets
;
303 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
305 ERROR("target '%s' init failed", target
->type
->name
);
308 target
= target
->next
;
313 target_register_user_commands(cmd_ctx
);
314 target_register_timer_callback(handle_target
, 100, 1, NULL
);
317 if (startup_mode
== DAEMON_RESET
)
318 target_process_reset(cmd_ctx
);
323 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
325 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
327 if (callback
== NULL
)
329 return ERROR_INVALID_ARGUMENTS
;
334 while ((*callbacks_p
)->next
)
335 callbacks_p
= &((*callbacks_p
)->next
);
336 callbacks_p
= &((*callbacks_p
)->next
);
339 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
340 (*callbacks_p
)->callback
= callback
;
341 (*callbacks_p
)->priv
= priv
;
342 (*callbacks_p
)->next
= NULL
;
347 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
349 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
352 if (callback
== NULL
)
354 return ERROR_INVALID_ARGUMENTS
;
359 while ((*callbacks_p
)->next
)
360 callbacks_p
= &((*callbacks_p
)->next
);
361 callbacks_p
= &((*callbacks_p
)->next
);
364 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
365 (*callbacks_p
)->callback
= callback
;
366 (*callbacks_p
)->periodic
= periodic
;
367 (*callbacks_p
)->time_ms
= time_ms
;
369 gettimeofday(&now
, NULL
);
370 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
371 time_ms
-= (time_ms
% 1000);
372 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
373 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
375 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
376 (*callbacks_p
)->when
.tv_sec
+= 1;
379 (*callbacks_p
)->priv
= priv
;
380 (*callbacks_p
)->next
= NULL
;
385 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
387 target_event_callback_t
**p
= &target_event_callbacks
;
388 target_event_callback_t
*c
= target_event_callbacks
;
390 if (callback
== NULL
)
392 return ERROR_INVALID_ARGUMENTS
;
397 target_event_callback_t
*next
= c
->next
;
398 if ((c
->callback
== callback
) && (c
->priv
== priv
))
412 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
414 target_timer_callback_t
**p
= &target_timer_callbacks
;
415 target_timer_callback_t
*c
= target_timer_callbacks
;
417 if (callback
== NULL
)
419 return ERROR_INVALID_ARGUMENTS
;
424 target_timer_callback_t
*next
= c
->next
;
425 if ((c
->callback
== callback
) && (c
->priv
== priv
))
439 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
441 target_event_callback_t
*callback
= target_event_callbacks
;
442 target_event_callback_t
*next_callback
;
444 DEBUG("target event %i", event
);
448 next_callback
= callback
->next
;
449 callback
->callback(target
, event
, callback
->priv
);
450 callback
= next_callback
;
456 int target_call_timer_callbacks()
458 target_timer_callback_t
*callback
= target_timer_callbacks
;
459 target_timer_callback_t
*next_callback
;
462 gettimeofday(&now
, NULL
);
466 next_callback
= callback
->next
;
468 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
469 || (now
.tv_sec
> callback
->when
.tv_sec
))
471 callback
->callback(callback
->priv
);
472 if (callback
->periodic
)
474 int time_ms
= callback
->time_ms
;
475 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
476 time_ms
-= (time_ms
% 1000);
477 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
478 if (callback
->when
.tv_usec
> 1000000)
480 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
481 callback
->when
.tv_sec
+= 1;
485 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
488 callback
= next_callback
;
494 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
496 working_area_t
*c
= target
->working_areas
;
497 working_area_t
*new_wa
= NULL
;
499 /* only allocate multiples of 4 byte */
502 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
503 size
= CEIL(size
, 4);
506 /* see if there's already a matching working area */
509 if ((c
->free
) && (c
->size
== size
))
517 /* if not, allocate a new one */
520 working_area_t
**p
= &target
->working_areas
;
521 u32 first_free
= target
->working_area
;
522 u32 free_size
= target
->working_area_size
;
524 DEBUG("allocating new working area");
526 c
= target
->working_areas
;
529 first_free
+= c
->size
;
530 free_size
-= c
->size
;
535 if (free_size
< size
)
537 WARNING("not enough working area available");
538 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
541 new_wa
= malloc(sizeof(working_area_t
));
544 new_wa
->address
= first_free
;
546 if (target
->backup_working_area
)
548 new_wa
->backup
= malloc(new_wa
->size
);
549 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
553 new_wa
->backup
= NULL
;
556 /* put new entry in list */
560 /* mark as used, and return the new (reused) area */
570 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
575 if (target
->backup_working_area
)
576 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
580 /* mark user pointer invalid */
587 int target_free_all_working_areas(struct target_s
*target
)
589 working_area_t
*c
= target
->working_areas
;
593 working_area_t
*next
= c
->next
;
594 target_free_working_area(target
, c
);
604 target
->working_areas
= NULL
;
609 int target_register_commands(struct command_context_s
*cmd_ctx
)
611 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
612 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
613 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
614 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
615 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
616 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
621 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
625 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
627 /* handle writes of less than 4 byte */
630 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
634 /* handle unaligned head bytes */
637 int unaligned
= 4 - (address
% 4);
639 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
643 address
+= unaligned
;
647 /* handle aligned words */
650 int aligned
= size
- (size
% 4);
652 /* use bulk writes above a certain limit. This may have to be changed */
655 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
660 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
669 /* handle tail writes of less than 4 bytes */
672 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
679 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
683 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
685 /* handle reads of less than 4 byte */
688 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
692 /* handle unaligned head bytes */
695 int unaligned
= 4 - (address
% 4);
697 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
701 address
+= unaligned
;
705 /* handle aligned words */
708 int aligned
= size
- (size
% 4);
710 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
718 /* handle tail writes of less than 4 bytes */
721 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
728 void target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
732 target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
734 *value
= target_buffer_get_u32(target
, value_buf
);
737 void target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
741 target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
743 *value
= target_buffer_get_u16(target
, value_buf
);
746 void target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
748 target
->type
->read_memory(target
, address
, 1, 1, value
);
751 void target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
755 target_buffer_set_u32(target
, value_buf
, value
);
756 target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
759 void target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
763 target_buffer_set_u16(target
, value_buf
, value
);
764 target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
767 void target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
769 target
->type
->read_memory(target
, address
, 1, 1, &value
);
772 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
774 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
775 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
776 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt");
777 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
778 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
779 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction");
780 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
781 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
783 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
784 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
785 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
787 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
788 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
789 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
791 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
792 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
793 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
794 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
796 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_binary_command
, COMMAND_EXEC
, "load binary <file> <address>");
797 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_binary_command
, COMMAND_EXEC
, "dump binary <file> <address> <size>");
802 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
804 target_t
*target
= targets
;
809 int num
= strtoul(args
[0], NULL
, 0);
814 target
= target
->next
;
818 cmd_ctx
->current_target
= num
;
820 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
827 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
828 target
= target
->next
;
834 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
841 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
845 /* search for the specified target */
846 if (args
[0] && (args
[0][0] != 0))
848 for (i
= 0; target_types
[i
]; i
++)
850 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
852 target_t
**last_target_p
= &targets
;
854 /* register target specific commands */
855 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
857 ERROR("couldn't register '%s' commands", args
[0]);
863 while ((*last_target_p
)->next
)
864 last_target_p
= &((*last_target_p
)->next
);
865 last_target_p
= &((*last_target_p
)->next
);
868 *last_target_p
= malloc(sizeof(target_t
));
870 (*last_target_p
)->type
= target_types
[i
];
872 if (strcmp(args
[1], "big") == 0)
873 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
874 else if (strcmp(args
[1], "little") == 0)
875 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
878 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
882 /* what to do on a target reset */
883 if (strcmp(args
[2], "reset_halt") == 0)
884 (*last_target_p
)->reset_mode
= RESET_HALT
;
885 else if (strcmp(args
[2], "reset_run") == 0)
886 (*last_target_p
)->reset_mode
= RESET_RUN
;
887 else if (strcmp(args
[2], "reset_init") == 0)
888 (*last_target_p
)->reset_mode
= RESET_INIT
;
889 else if (strcmp(args
[2], "run_and_halt") == 0)
890 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
891 else if (strcmp(args
[2], "run_and_init") == 0)
892 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
895 ERROR("unknown target startup mode %s", args
[2]);
898 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
900 (*last_target_p
)->reset_script
= NULL
;
901 (*last_target_p
)->post_halt_script
= NULL
;
902 (*last_target_p
)->pre_resume_script
= NULL
;
904 (*last_target_p
)->working_area
= 0x0;
905 (*last_target_p
)->working_area_size
= 0x0;
906 (*last_target_p
)->working_areas
= NULL
;
907 (*last_target_p
)->backup_working_area
= 0;
909 (*last_target_p
)->state
= TARGET_UNKNOWN
;
910 (*last_target_p
)->reg_cache
= NULL
;
911 (*last_target_p
)->breakpoints
= NULL
;
912 (*last_target_p
)->watchpoints
= NULL
;
913 (*last_target_p
)->next
= NULL
;
914 (*last_target_p
)->arch_info
= NULL
;
916 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
924 /* no matching target found */
927 ERROR("target '%s' not found", args
[0]);
934 /* usage: target_script <target#> <event> <script_file> */
935 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
937 target_t
*target
= NULL
;
941 ERROR("incomplete target_script command");
945 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
949 ERROR("target number '%s' not defined", args
[0]);
953 if (strcmp(args
[1], "reset") == 0)
955 if (target
->reset_script
)
956 free(target
->reset_script
);
957 target
->reset_script
= strdup(args
[2]);
959 else if (strcmp(args
[1], "post_halt") == 0)
961 if (target
->post_halt_script
)
962 free(target
->post_halt_script
);
963 target
->post_halt_script
= strdup(args
[2]);
965 else if (strcmp(args
[1], "pre_resume") == 0)
967 if (target
->pre_resume_script
)
968 free(target
->pre_resume_script
);
969 target
->pre_resume_script
= strdup(args
[2]);
973 ERROR("unknown event type: '%s", args
[1]);
980 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
982 target_t
*target
= NULL
;
986 ERROR("incomplete run_and_halt_time command");
990 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
994 ERROR("target number '%s' not defined", args
[0]);
998 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1003 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1005 target_t
*target
= NULL
;
1009 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1013 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1017 ERROR("target number '%s' not defined", args
[0]);
1021 target
->working_area
= strtoul(args
[1], NULL
, 0);
1022 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1024 if (strcmp(args
[3], "backup") == 0)
1026 target
->backup_working_area
= 1;
1028 else if (strcmp(args
[3], "nobackup") == 0)
1030 target
->backup_working_area
= 0;
1034 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1042 /* process target state changes */
1043 int handle_target(void *priv
)
1046 target_t
*target
= targets
;
1050 /* only poll if target isn't already halted */
1051 if (target
->state
!= TARGET_HALTED
)
1053 if (target_continous_poll
)
1054 if ((retval
= target
->type
->poll(target
)) < 0)
1056 ERROR("couldn't poll target, exiting");
1061 target
= target
->next
;
1067 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1076 target
= get_current_target(cmd_ctx
);
1078 /* list all available registers for the current target */
1081 reg_cache_t
*cache
= target
->reg_cache
;
1087 for (i
= 0; i
< cache
->num_regs
; i
++)
1089 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1090 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
);
1093 cache
= cache
->next
;
1099 /* access a single register by its ordinal number */
1100 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1102 int num
= strtoul(args
[0], NULL
, 0);
1103 reg_cache_t
*cache
= target
->reg_cache
;
1109 for (i
= 0; i
< cache
->num_regs
; i
++)
1113 reg
= &cache
->reg_list
[i
];
1119 cache
= cache
->next
;
1124 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1127 } else /* access a single register by its name */
1129 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1133 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1138 /* display a register */
1139 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1141 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1144 if (reg
->valid
== 0)
1146 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1147 if (arch_type
== NULL
)
1149 ERROR("BUG: encountered unregistered arch type");
1152 arch_type
->get(reg
);
1154 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1155 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1160 /* set register value */
1163 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1164 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1166 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1167 if (arch_type
== NULL
)
1169 ERROR("BUG: encountered unregistered arch type");
1173 arch_type
->set(reg
, buf
);
1175 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1176 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1184 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1189 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1191 target_t
*target
= get_current_target(cmd_ctx
);
1196 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1197 if (target
->state
== TARGET_HALTED
)
1199 target
->type
->arch_state(target
, buffer
, 512);
1201 command_print(cmd_ctx
, "%s", buffer
);
1206 if (strcmp(args
[0], "on") == 0)
1208 target_continous_poll
= 1;
1210 else if (strcmp(args
[0], "off") == 0)
1212 target_continous_poll
= 0;
1220 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1222 target_t
*target
= get_current_target(cmd_ctx
);
1223 struct timeval timeout
, now
;
1225 gettimeofday(&timeout
, NULL
);
1226 timeval_add_time(&timeout
, 5, 0);
1228 command_print(cmd_ctx
, "waiting for target halted...");
1230 while(target
->type
->poll(target
))
1232 if (target
->state
== TARGET_HALTED
)
1234 command_print(cmd_ctx
, "target halted");
1237 target_call_timer_callbacks();
1239 gettimeofday(&now
, NULL
);
1240 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1242 command_print(cmd_ctx
, "timed out while waiting for target halt");
1243 ERROR("timed out while waiting for target halt");
1251 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1254 target_t
*target
= get_current_target(cmd_ctx
);
1258 command_print(cmd_ctx
, "requesting target halt...");
1260 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1264 case ERROR_TARGET_ALREADY_HALTED
:
1265 command_print(cmd_ctx
, "target already halted");
1267 case ERROR_TARGET_TIMEOUT
:
1268 command_print(cmd_ctx
, "target timed out... shutting down");
1271 command_print(cmd_ctx
, "unknown error... shutting down");
1280 /* what to do on daemon startup */
1281 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1285 if (strcmp(args
[0], "attach") == 0)
1287 startup_mode
= DAEMON_ATTACH
;
1290 else if (strcmp(args
[0], "reset") == 0)
1292 startup_mode
= DAEMON_RESET
;
1297 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1302 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1304 target_t
*target
= get_current_target(cmd_ctx
);
1307 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1309 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1313 case ERROR_TARGET_TIMEOUT
:
1314 command_print(cmd_ctx
, "target timed out... shutting down");
1317 command_print(cmd_ctx
, "unknown error... shutting down");
1325 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1327 target_t
*target
= get_current_target(cmd_ctx
);
1328 enum target_reset_mode reset_mode
= RESET_RUN
;
1334 if (strcmp("run", args
[0]) == 0)
1335 reset_mode
= RESET_RUN
;
1336 else if (strcmp("halt", args
[0]) == 0)
1337 reset_mode
= RESET_HALT
;
1338 else if (strcmp("init", args
[0]) == 0)
1339 reset_mode
= RESET_INIT
;
1340 else if (strcmp("run_and_halt", args
[0]) == 0)
1342 reset_mode
= RESET_RUN_AND_HALT
;
1345 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1348 else if (strcmp("run_and_init", args
[0]) == 0)
1350 reset_mode
= RESET_RUN_AND_INIT
;
1353 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1358 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1361 target
->reset_mode
= reset_mode
;
1364 target_process_reset(cmd_ctx
);
1369 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1372 target_t
*target
= get_current_target(cmd_ctx
);
1377 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1379 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1382 command_print(cmd_ctx
, "usage: resume [address]");
1386 if (retval
!= ERROR_OK
)
1390 case ERROR_TARGET_NOT_HALTED
:
1391 command_print(cmd_ctx
, "target not halted");
1394 command_print(cmd_ctx
, "unknown error... shutting down");
1402 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1404 target_t
*target
= get_current_target(cmd_ctx
);
1409 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1412 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1417 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1430 target_t
*target
= get_current_target(cmd_ctx
);
1436 count
= strtoul(args
[1], NULL
, 0);
1438 address
= strtoul(args
[0], NULL
, 0);
1456 buffer
= calloc(count
, size
);
1457 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1461 case ERROR_TARGET_UNALIGNED_ACCESS
:
1462 command_print(cmd_ctx
, "error: address not aligned");
1464 case ERROR_TARGET_NOT_HALTED
:
1465 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1467 case ERROR_TARGET_DATA_ABORT
:
1468 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1471 command_print(cmd_ctx
, "error: unknown error");
1479 for (i
= 0; i
< count
; i
++)
1482 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1487 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1490 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1493 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1497 if ((i
%8 == 7) || (i
== count
- 1))
1499 command_print(cmd_ctx
, output
);
1509 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1514 target_t
*target
= get_current_target(cmd_ctx
);
1520 address
= strtoul(args
[0], NULL
, 0);
1521 value
= strtoul(args
[1], NULL
, 0);
1526 target_buffer_set_u32(target
, value_buf
, value
);
1527 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1530 target_buffer_set_u16(target
, value_buf
, value
);
1531 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1534 value_buf
[0] = value
;
1535 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1543 case ERROR_TARGET_UNALIGNED_ACCESS
:
1544 command_print(cmd_ctx
, "error: address not aligned");
1546 case ERROR_TARGET_DATA_ABORT
:
1547 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1549 case ERROR_TARGET_NOT_HALTED
:
1550 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1555 command_print(cmd_ctx
, "error: unknown error");
1563 int handle_load_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1567 struct stat binary_stat
;
1573 struct timeval start
, end
, duration
;
1575 target_t
*target
= get_current_target(cmd_ctx
);
1579 command_print(cmd_ctx
, "usage: load_binary <filename> <address>");
1583 address
= strtoul(args
[1], NULL
, 0);
1585 if (stat(args
[0], &binary_stat
) == -1)
1587 ERROR("couldn't stat() %s: %s", args
[0], strerror(errno
));
1588 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1592 if (!(binary
= fopen(args
[0], "rb")))
1594 ERROR("couldn't open %s: %s", args
[0], strerror(errno
));
1595 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1599 buffer
= malloc(128 * 1024);
1601 gettimeofday(&start
, NULL
);
1603 binary_size
= binary_stat
.st_size
;
1604 while (binary_size
> 0)
1606 buf_cnt
= fread(buffer
, 1, 128*1024, binary
);
1607 target_write_buffer(target
, address
, buf_cnt
, buffer
);
1609 binary_size
-= buf_cnt
;
1612 gettimeofday(&end
, NULL
);
1616 timeval_subtract(&duration
, &end
, &start
);
1617 command_print(cmd_ctx
, "downloaded %lli byte in %is %ius", (long long) binary_stat
.st_size
, duration
.tv_sec
, duration
.tv_usec
);
1625 int handle_dump_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1632 struct timeval start
, end
, duration
;
1634 target_t
*target
= get_current_target(cmd_ctx
);
1638 command_print(cmd_ctx
, "usage: dump_binary <filename> <address> <size>");
1642 address
= strtoul(args
[1], NULL
, 0);
1643 size
= strtoul(args
[2], NULL
, 0);
1645 if (!(binary
= fopen(args
[0], "wb")))
1647 ERROR("couldn't open %s for writing: %s", args
[0], strerror(errno
));
1648 command_print(cmd_ctx
, "error accessing file %s", args
[0]);
1652 if ((address
& 3) || (size
& 3))
1654 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1658 gettimeofday(&start
, NULL
);
1662 u32 this_run_size
= (size
> 560) ? 560 : size
;
1663 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1664 fwrite(buffer
, 1, this_run_size
, binary
);
1665 size
-= this_run_size
;
1666 address
+= this_run_size
;
1671 gettimeofday(&end
, NULL
);
1673 timeval_subtract(&duration
, &end
, &start
);
1674 command_print(cmd_ctx
, "dumped %i byte in %is %ius", strtoul(args
[2], NULL
, 0), duration
.tv_sec
, duration
.tv_usec
);
1680 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1683 target_t
*target
= get_current_target(cmd_ctx
);
1687 breakpoint_t
*breakpoint
= target
->breakpoints
;
1691 if (breakpoint
->type
== BKPT_SOFT
)
1693 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
1694 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
1699 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
1701 breakpoint
= breakpoint
->next
;
1709 length
= strtoul(args
[1], NULL
, 0);
1712 if (strcmp(args
[2], "hw") == 0)
1715 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
1719 case ERROR_TARGET_NOT_HALTED
:
1720 command_print(cmd_ctx
, "target must be halted to set breakpoints");
1722 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1723 command_print(cmd_ctx
, "no more breakpoints available");
1726 command_print(cmd_ctx
, "unknown error, breakpoint not set");
1732 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
1737 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
1743 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1745 target_t
*target
= get_current_target(cmd_ctx
);
1748 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
1753 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1755 target_t
*target
= get_current_target(cmd_ctx
);
1759 watchpoint_t
*watchpoint
= target
->watchpoints
;
1763 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
);
1764 watchpoint
= watchpoint
->next
;
1769 enum watchpoint_rw type
= WPT_ACCESS
;
1770 u32 data_value
= 0x0;
1771 u32 data_mask
= 0xffffffff;
1787 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1793 data_value
= strtoul(args
[3], NULL
, 0);
1797 data_mask
= strtoul(args
[4], NULL
, 0);
1799 watchpoint_add(target
, strtoul(args
[0], NULL
, 0), strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
);
1803 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1809 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1811 target_t
*target
= get_current_target(cmd_ctx
);
1814 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)