1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "target_request.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
37 #include <sys/types.h>
45 #include <time_support.h>
50 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
52 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 extern target_type_t arm7tdmi_target
;
80 extern target_type_t arm720t_target
;
81 extern target_type_t arm9tdmi_target
;
82 extern target_type_t arm920t_target
;
83 extern target_type_t arm966e_target
;
84 extern target_type_t arm926ejs_target
;
85 extern target_type_t xscale_target
;
86 extern target_type_t cortexm3_target
;
88 target_type_t
*target_types
[] =
101 target_t
*targets
= NULL
;
102 target_event_callback_t
*target_event_callbacks
= NULL
;
103 target_timer_callback_t
*target_timer_callbacks
= NULL
;
105 char *target_state_strings
[] =
114 char *target_debug_reason_strings
[] =
116 "debug request", "breakpoint", "watchpoint",
117 "watchpoint and breakpoint", "single step",
121 char *target_endianess_strings
[] =
127 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
129 static int target_continous_poll
= 1;
131 /* read a u32 from a buffer in target memory endianness */
132 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
134 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
135 return le_to_h_u32(buffer
);
137 return be_to_h_u32(buffer
);
140 /* read a u16 from a buffer in target memory endianness */
141 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
143 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
144 return le_to_h_u16(buffer
);
146 return be_to_h_u16(buffer
);
149 /* write a u32 to a buffer in target memory endianness */
150 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
152 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
153 h_u32_to_le(buffer
, value
);
155 h_u32_to_be(buffer
, value
);
158 /* write a u16 to a buffer in target memory endianness */
159 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
161 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
162 h_u16_to_le(buffer
, value
);
164 h_u16_to_be(buffer
, value
);
167 /* returns a pointer to the n-th configured target */
168 target_t
* get_target_by_num(int num
)
170 target_t
*target
= targets
;
177 target
= target
->next
;
184 int get_num_by_target(target_t
*query_target
)
186 target_t
*target
= targets
;
191 if (target
== query_target
)
193 target
= target
->next
;
200 target_t
* get_current_target(command_context_t
*cmd_ctx
)
202 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
206 ERROR("BUG: current_target out of bounds");
213 /* Process target initialization, when target entered debug out of reset
214 * the handler is unregistered at the end of this function, so it's only called once
216 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
219 struct command_context_s
*cmd_ctx
= priv
;
221 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
223 target_unregister_event_callback(target_init_handler
, priv
);
225 script
= fopen(target
->reset_script
, "r");
228 ERROR("couldn't open script file %s", target
->reset_script
);
232 INFO("executing reset script '%s'", target
->reset_script
);
233 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
236 jtag_execute_queue();
242 int target_run_and_halt_handler(void *priv
)
244 target_t
*target
= priv
;
246 target
->type
->halt(target
);
251 int target_process_reset(struct command_context_s
*cmd_ctx
)
253 int retval
= ERROR_OK
;
256 /* prepare reset_halt where necessary */
260 switch (target
->reset_mode
)
264 target
->type
->prepare_reset_halt(target
);
269 target
= target
->next
;
275 target
->type
->assert_reset(target
);
276 target
= target
->next
;
278 jtag_execute_queue();
280 /* request target halt if necessary, and schedule further action */
284 switch (target
->reset_mode
)
287 /* nothing to do if target just wants to be run */
289 case RESET_RUN_AND_HALT
:
291 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
293 case RESET_RUN_AND_INIT
:
295 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
296 target_register_event_callback(target_init_handler
, cmd_ctx
);
299 target
->type
->halt(target
);
302 target
->type
->halt(target
);
303 target_register_event_callback(target_init_handler
, cmd_ctx
);
306 ERROR("BUG: unknown target->reset_mode");
308 target
= target
->next
;
314 target
->type
->deassert_reset(target
);
315 target
= target
->next
;
317 jtag_execute_queue();
322 int target_init(struct command_context_s
*cmd_ctx
)
324 target_t
*target
= targets
;
328 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
330 ERROR("target '%s' init failed", target
->type
->name
);
333 target
= target
->next
;
338 target_register_user_commands(cmd_ctx
);
339 target_register_timer_callback(handle_target
, 100, 1, NULL
);
342 if (startup_mode
== DAEMON_RESET
)
343 target_process_reset(cmd_ctx
);
348 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
350 target_event_callback_t
**callbacks_p
= &target_event_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_event_callback_t
));
365 (*callbacks_p
)->callback
= callback
;
366 (*callbacks_p
)->priv
= priv
;
367 (*callbacks_p
)->next
= NULL
;
372 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
374 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
377 if (callback
== NULL
)
379 return ERROR_INVALID_ARGUMENTS
;
384 while ((*callbacks_p
)->next
)
385 callbacks_p
= &((*callbacks_p
)->next
);
386 callbacks_p
= &((*callbacks_p
)->next
);
389 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
390 (*callbacks_p
)->callback
= callback
;
391 (*callbacks_p
)->periodic
= periodic
;
392 (*callbacks_p
)->time_ms
= time_ms
;
394 gettimeofday(&now
, NULL
);
395 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
396 time_ms
-= (time_ms
% 1000);
397 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
398 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
400 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
401 (*callbacks_p
)->when
.tv_sec
+= 1;
404 (*callbacks_p
)->priv
= priv
;
405 (*callbacks_p
)->next
= NULL
;
410 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
412 target_event_callback_t
**p
= &target_event_callbacks
;
413 target_event_callback_t
*c
= target_event_callbacks
;
415 if (callback
== NULL
)
417 return ERROR_INVALID_ARGUMENTS
;
422 target_event_callback_t
*next
= c
->next
;
423 if ((c
->callback
== callback
) && (c
->priv
== priv
))
437 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
439 target_timer_callback_t
**p
= &target_timer_callbacks
;
440 target_timer_callback_t
*c
= target_timer_callbacks
;
442 if (callback
== NULL
)
444 return ERROR_INVALID_ARGUMENTS
;
449 target_timer_callback_t
*next
= c
->next
;
450 if ((c
->callback
== callback
) && (c
->priv
== priv
))
464 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
466 target_event_callback_t
*callback
= target_event_callbacks
;
467 target_event_callback_t
*next_callback
;
469 DEBUG("target event %i", event
);
473 next_callback
= callback
->next
;
474 callback
->callback(target
, event
, callback
->priv
);
475 callback
= next_callback
;
481 int target_call_timer_callbacks()
483 target_timer_callback_t
*callback
= target_timer_callbacks
;
484 target_timer_callback_t
*next_callback
;
487 gettimeofday(&now
, NULL
);
491 next_callback
= callback
->next
;
493 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
494 || (now
.tv_sec
> callback
->when
.tv_sec
))
496 callback
->callback(callback
->priv
);
497 if (callback
->periodic
)
499 int time_ms
= callback
->time_ms
;
500 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
501 time_ms
-= (time_ms
% 1000);
502 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
503 if (callback
->when
.tv_usec
> 1000000)
505 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
506 callback
->when
.tv_sec
+= 1;
510 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
513 callback
= next_callback
;
519 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
521 working_area_t
*c
= target
->working_areas
;
522 working_area_t
*new_wa
= NULL
;
524 /* only allocate multiples of 4 byte */
527 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
528 size
= CEIL(size
, 4);
531 /* see if there's already a matching working area */
534 if ((c
->free
) && (c
->size
== size
))
542 /* if not, allocate a new one */
545 working_area_t
**p
= &target
->working_areas
;
546 u32 first_free
= target
->working_area
;
547 u32 free_size
= target
->working_area_size
;
549 DEBUG("allocating new working area");
551 c
= target
->working_areas
;
554 first_free
+= c
->size
;
555 free_size
-= c
->size
;
560 if (free_size
< size
)
562 WARNING("not enough working area available");
563 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
566 new_wa
= malloc(sizeof(working_area_t
));
569 new_wa
->address
= first_free
;
571 if (target
->backup_working_area
)
573 new_wa
->backup
= malloc(new_wa
->size
);
574 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
578 new_wa
->backup
= NULL
;
581 /* put new entry in list */
585 /* mark as used, and return the new (reused) area */
595 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
600 if (target
->backup_working_area
)
601 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
605 /* mark user pointer invalid */
612 int target_free_all_working_areas(struct target_s
*target
)
614 working_area_t
*c
= target
->working_areas
;
618 working_area_t
*next
= c
->next
;
619 target_free_working_area(target
, c
);
629 target
->working_areas
= NULL
;
634 int target_register_commands(struct command_context_s
*cmd_ctx
)
636 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
637 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
638 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
639 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
640 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
641 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_CONFIG
, NULL
);
646 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
650 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
652 /* handle writes of less than 4 byte */
655 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
660 /* handle unaligned head bytes */
663 int unaligned
= 4 - (address
% 4);
665 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
669 address
+= unaligned
;
673 /* handle aligned words */
676 int aligned
= size
- (size
% 4);
678 /* use bulk writes above a certain limit. This may have to be changed */
681 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
686 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
695 /* handle tail writes of less than 4 bytes */
698 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
705 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
709 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
711 /* handle reads of less than 4 byte */
714 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
719 /* handle unaligned head bytes */
722 int unaligned
= 4 - (address
% 4);
724 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
728 address
+= unaligned
;
732 /* handle aligned words */
735 int aligned
= size
- (size
% 4);
737 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
745 /* handle tail writes of less than 4 bytes */
748 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
755 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
759 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
761 if (retval
== ERROR_OK
)
763 *value
= target_buffer_get_u32(target
, value_buf
);
764 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
769 DEBUG("address: 0x%8.8x failed", address
);
775 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
779 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
781 if (retval
== ERROR_OK
)
783 *value
= target_buffer_get_u16(target
, value_buf
);
784 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
789 DEBUG("address: 0x%8.8x failed", address
);
795 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
797 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
799 if (retval
== ERROR_OK
)
801 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
806 DEBUG("address: 0x%8.8x failed", address
);
812 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
817 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
819 target_buffer_set_u32(target
, value_buf
, value
);
820 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
822 DEBUG("failed: %i", retval
);
828 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
833 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
835 target_buffer_set_u16(target
, value_buf
, value
);
836 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
838 DEBUG("failed: %i", retval
);
844 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
848 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
850 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
852 DEBUG("failed: %i", retval
);
858 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
860 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
861 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
862 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
863 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
864 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
865 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
866 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
867 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
869 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
870 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
871 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
873 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
874 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
875 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
877 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
878 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
879 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
880 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
882 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
883 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
884 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
885 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
887 target_request_register_commands(cmd_ctx
);
888 trace_register_commands(cmd_ctx
);
893 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
895 target_t
*target
= targets
;
900 int num
= strtoul(args
[0], NULL
, 0);
905 target
= target
->next
;
909 cmd_ctx
->current_target
= num
;
911 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
918 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
919 target
= target
->next
;
925 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
932 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
936 /* search for the specified target */
937 if (args
[0] && (args
[0][0] != 0))
939 for (i
= 0; target_types
[i
]; i
++)
941 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
943 target_t
**last_target_p
= &targets
;
945 /* register target specific commands */
946 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
948 ERROR("couldn't register '%s' commands", args
[0]);
954 while ((*last_target_p
)->next
)
955 last_target_p
= &((*last_target_p
)->next
);
956 last_target_p
= &((*last_target_p
)->next
);
959 *last_target_p
= malloc(sizeof(target_t
));
961 (*last_target_p
)->type
= target_types
[i
];
963 if (strcmp(args
[1], "big") == 0)
964 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
965 else if (strcmp(args
[1], "little") == 0)
966 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
969 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
973 /* what to do on a target reset */
974 if (strcmp(args
[2], "reset_halt") == 0)
975 (*last_target_p
)->reset_mode
= RESET_HALT
;
976 else if (strcmp(args
[2], "reset_run") == 0)
977 (*last_target_p
)->reset_mode
= RESET_RUN
;
978 else if (strcmp(args
[2], "reset_init") == 0)
979 (*last_target_p
)->reset_mode
= RESET_INIT
;
980 else if (strcmp(args
[2], "run_and_halt") == 0)
981 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
982 else if (strcmp(args
[2], "run_and_init") == 0)
983 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
986 ERROR("unknown target startup mode %s", args
[2]);
989 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
991 (*last_target_p
)->reset_script
= NULL
;
992 (*last_target_p
)->post_halt_script
= NULL
;
993 (*last_target_p
)->pre_resume_script
= NULL
;
995 (*last_target_p
)->working_area
= 0x0;
996 (*last_target_p
)->working_area_size
= 0x0;
997 (*last_target_p
)->working_areas
= NULL
;
998 (*last_target_p
)->backup_working_area
= 0;
1000 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1001 (*last_target_p
)->reg_cache
= NULL
;
1002 (*last_target_p
)->breakpoints
= NULL
;
1003 (*last_target_p
)->watchpoints
= NULL
;
1004 (*last_target_p
)->next
= NULL
;
1005 (*last_target_p
)->arch_info
= NULL
;
1007 /* initialize trace information */
1008 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1009 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1010 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1011 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1012 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1013 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1014 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1015 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1017 (*last_target_p
)->dbgmsg
= NULL
;
1019 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1027 /* no matching target found */
1030 ERROR("target '%s' not found", args
[0]);
1037 /* usage: target_script <target#> <event> <script_file> */
1038 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1040 target_t
*target
= NULL
;
1044 ERROR("incomplete target_script command");
1048 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1052 ERROR("target number '%s' not defined", args
[0]);
1056 if (strcmp(args
[1], "reset") == 0)
1058 if (target
->reset_script
)
1059 free(target
->reset_script
);
1060 target
->reset_script
= strdup(args
[2]);
1062 else if (strcmp(args
[1], "post_halt") == 0)
1064 if (target
->post_halt_script
)
1065 free(target
->post_halt_script
);
1066 target
->post_halt_script
= strdup(args
[2]);
1068 else if (strcmp(args
[1], "pre_resume") == 0)
1070 if (target
->pre_resume_script
)
1071 free(target
->pre_resume_script
);
1072 target
->pre_resume_script
= strdup(args
[2]);
1076 ERROR("unknown event type: '%s", args
[1]);
1083 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1085 target_t
*target
= NULL
;
1089 ERROR("incomplete run_and_halt_time command");
1093 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1097 ERROR("target number '%s' not defined", args
[0]);
1101 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1106 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1108 target_t
*target
= NULL
;
1112 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1116 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1120 ERROR("target number '%s' not defined", args
[0]);
1124 target
->working_area
= strtoul(args
[1], NULL
, 0);
1125 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1127 if (strcmp(args
[3], "backup") == 0)
1129 target
->backup_working_area
= 1;
1131 else if (strcmp(args
[3], "nobackup") == 0)
1133 target
->backup_working_area
= 0;
1137 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1145 /* process target state changes */
1146 int handle_target(void *priv
)
1149 target_t
*target
= targets
;
1153 /* only poll if target isn't already halted */
1154 if (target
->state
!= TARGET_HALTED
)
1156 if (target_continous_poll
)
1157 if ((retval
= target
->type
->poll(target
)) < 0)
1159 ERROR("couldn't poll target, exiting");
1164 target
= target
->next
;
1170 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1179 target
= get_current_target(cmd_ctx
);
1181 /* list all available registers for the current target */
1184 reg_cache_t
*cache
= target
->reg_cache
;
1190 for (i
= 0; i
< cache
->num_regs
; i
++)
1192 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1193 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
);
1196 cache
= cache
->next
;
1202 /* access a single register by its ordinal number */
1203 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1205 int num
= strtoul(args
[0], NULL
, 0);
1206 reg_cache_t
*cache
= target
->reg_cache
;
1212 for (i
= 0; i
< cache
->num_regs
; i
++)
1216 reg
= &cache
->reg_list
[i
];
1222 cache
= cache
->next
;
1227 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1230 } else /* access a single register by its name */
1232 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1236 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1241 /* display a register */
1242 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1244 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1247 if (reg
->valid
== 0)
1249 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1250 if (arch_type
== NULL
)
1252 ERROR("BUG: encountered unregistered arch type");
1255 arch_type
->get(reg
);
1257 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1258 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1263 /* set register value */
1266 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1267 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1269 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1270 if (arch_type
== NULL
)
1272 ERROR("BUG: encountered unregistered arch type");
1276 arch_type
->set(reg
, buf
);
1278 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1279 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1287 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1292 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1294 target_t
*target
= get_current_target(cmd_ctx
);
1299 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1300 if (target
->state
== TARGET_HALTED
)
1302 target
->type
->arch_state(target
, buffer
, 512);
1304 command_print(cmd_ctx
, "%s", buffer
);
1309 if (strcmp(args
[0], "on") == 0)
1311 target_continous_poll
= 1;
1313 else if (strcmp(args
[0], "off") == 0)
1315 target_continous_poll
= 0;
1323 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1325 target_t
*target
= get_current_target(cmd_ctx
);
1326 struct timeval timeout
, now
;
1328 gettimeofday(&timeout
, NULL
);
1330 timeval_add_time(&timeout
, 5, 0);
1334 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
1336 command_print(cmd_ctx
, "usage: wait_halt [seconds]");
1341 command_print(cmd_ctx
, "waiting for target halted...");
1343 while(target
->type
->poll(target
))
1345 if (target
->state
== TARGET_HALTED
)
1347 command_print(cmd_ctx
, "target halted");
1350 target_call_timer_callbacks();
1352 gettimeofday(&now
, NULL
);
1353 if ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
))
1355 command_print(cmd_ctx
, "timed out while waiting for target halt");
1356 ERROR("timed out while waiting for target halt");
1364 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1367 target_t
*target
= get_current_target(cmd_ctx
);
1371 command_print(cmd_ctx
, "requesting target halt...");
1373 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1377 case ERROR_TARGET_ALREADY_HALTED
:
1378 command_print(cmd_ctx
, "target already halted");
1380 case ERROR_TARGET_TIMEOUT
:
1381 command_print(cmd_ctx
, "target timed out... shutting down");
1384 command_print(cmd_ctx
, "unknown error... shutting down");
1393 /* what to do on daemon startup */
1394 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1398 if (strcmp(args
[0], "attach") == 0)
1400 startup_mode
= DAEMON_ATTACH
;
1403 else if (strcmp(args
[0], "reset") == 0)
1405 startup_mode
= DAEMON_RESET
;
1410 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1415 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1417 target_t
*target
= get_current_target(cmd_ctx
);
1420 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1422 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1426 case ERROR_TARGET_TIMEOUT
:
1427 command_print(cmd_ctx
, "target timed out... shutting down");
1430 command_print(cmd_ctx
, "unknown error... shutting down");
1438 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1440 target_t
*target
= get_current_target(cmd_ctx
);
1441 enum target_reset_mode reset_mode
= RESET_RUN
;
1447 if (strcmp("run", args
[0]) == 0)
1448 reset_mode
= RESET_RUN
;
1449 else if (strcmp("halt", args
[0]) == 0)
1450 reset_mode
= RESET_HALT
;
1451 else if (strcmp("init", args
[0]) == 0)
1452 reset_mode
= RESET_INIT
;
1453 else if (strcmp("run_and_halt", args
[0]) == 0)
1455 reset_mode
= RESET_RUN_AND_HALT
;
1458 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1461 else if (strcmp("run_and_init", args
[0]) == 0)
1463 reset_mode
= RESET_RUN_AND_INIT
;
1466 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1471 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1474 target
->reset_mode
= reset_mode
;
1477 target_process_reset(cmd_ctx
);
1482 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1485 target_t
*target
= get_current_target(cmd_ctx
);
1490 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1492 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1495 command_print(cmd_ctx
, "usage: resume [address]");
1499 if (retval
!= ERROR_OK
)
1503 case ERROR_TARGET_NOT_HALTED
:
1504 command_print(cmd_ctx
, "target not halted");
1507 command_print(cmd_ctx
, "unknown error... shutting down");
1515 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1517 target_t
*target
= get_current_target(cmd_ctx
);
1522 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1525 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1530 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1543 target_t
*target
= get_current_target(cmd_ctx
);
1549 count
= strtoul(args
[1], NULL
, 0);
1551 address
= strtoul(args
[0], NULL
, 0);
1569 buffer
= calloc(count
, size
);
1570 if ((retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
)) != ERROR_OK
)
1574 case ERROR_TARGET_UNALIGNED_ACCESS
:
1575 command_print(cmd_ctx
, "error: address not aligned");
1577 case ERROR_TARGET_NOT_HALTED
:
1578 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1580 case ERROR_TARGET_DATA_ABORT
:
1581 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1584 command_print(cmd_ctx
, "error: unknown error");
1592 for (i
= 0; i
< count
; i
++)
1595 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1600 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1603 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1606 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1610 if ((i
%8 == 7) || (i
== count
- 1))
1612 command_print(cmd_ctx
, output
);
1622 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1627 target_t
*target
= get_current_target(cmd_ctx
);
1633 address
= strtoul(args
[0], NULL
, 0);
1634 value
= strtoul(args
[1], NULL
, 0);
1639 target_buffer_set_u32(target
, value_buf
, value
);
1640 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1643 target_buffer_set_u16(target
, value_buf
, value
);
1644 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1647 value_buf
[0] = value
;
1648 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1656 case ERROR_TARGET_UNALIGNED_ACCESS
:
1657 command_print(cmd_ctx
, "error: address not aligned");
1659 case ERROR_TARGET_DATA_ABORT
:
1660 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1662 case ERROR_TARGET_NOT_HALTED
:
1663 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1668 command_print(cmd_ctx
, "error: unknown error");
1676 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1686 duration_t duration
;
1687 char *duration_text
;
1689 target_t
*target
= get_current_target(cmd_ctx
);
1693 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1697 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1700 image
.base_address_set
= 1;
1701 image
.base_address
= strtoul(args
[1], NULL
, 0);
1705 image
.base_address_set
= 0;
1708 image
.start_address_set
= 0;
1710 duration_start_measure(&duration
);
1712 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1714 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1719 for (i
= 0; i
< image
.num_sections
; i
++)
1721 buffer
= malloc(image
.sections
[i
].size
);
1722 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1724 ERROR("image_read_section failed with error code: %i", retval
);
1725 command_print(cmd_ctx
, "image reading failed, download aborted");
1727 image_close(&image
);
1730 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1731 image_size
+= buf_cnt
;
1732 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1737 duration_stop_measure(&duration
, &duration_text
);
1738 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1739 free(duration_text
);
1741 image_close(&image
);
1747 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1755 duration_t duration
;
1756 char *duration_text
;
1758 target_t
*target
= get_current_target(cmd_ctx
);
1762 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1766 address
= strtoul(args
[1], NULL
, 0);
1767 size
= strtoul(args
[2], NULL
, 0);
1769 if ((address
& 3) || (size
& 3))
1771 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1775 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1777 command_print(cmd_ctx
, "dump_image error: %s", fileio
.error_str
);
1781 duration_start_measure(&duration
);
1786 u32 this_run_size
= (size
> 560) ? 560 : size
;
1788 target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1789 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1791 size
-= this_run_size
;
1792 address
+= this_run_size
;
1795 fileio_close(&fileio
);
1797 duration_stop_measure(&duration
, &duration_text
);
1798 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
1799 free(duration_text
);
1805 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1808 target_t
*target
= get_current_target(cmd_ctx
);
1812 breakpoint_t
*breakpoint
= target
->breakpoints
;
1816 if (breakpoint
->type
== BKPT_SOFT
)
1818 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
1819 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
1824 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
1826 breakpoint
= breakpoint
->next
;
1834 length
= strtoul(args
[1], NULL
, 0);
1837 if (strcmp(args
[2], "hw") == 0)
1840 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
1844 case ERROR_TARGET_NOT_HALTED
:
1845 command_print(cmd_ctx
, "target must be halted to set breakpoints");
1847 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1848 command_print(cmd_ctx
, "no more breakpoints available");
1851 command_print(cmd_ctx
, "unknown error, breakpoint not set");
1857 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
1862 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
1868 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1870 target_t
*target
= get_current_target(cmd_ctx
);
1873 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
1878 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1880 target_t
*target
= get_current_target(cmd_ctx
);
1885 watchpoint_t
*watchpoint
= target
->watchpoints
;
1889 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
);
1890 watchpoint
= watchpoint
->next
;
1895 enum watchpoint_rw type
= WPT_ACCESS
;
1896 u32 data_value
= 0x0;
1897 u32 data_mask
= 0xffffffff;
1913 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1919 data_value
= strtoul(args
[3], NULL
, 0);
1923 data_mask
= strtoul(args
[4], NULL
, 0);
1926 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
1927 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
1931 case ERROR_TARGET_NOT_HALTED
:
1932 command_print(cmd_ctx
, "target must be halted to set watchpoints");
1934 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1935 command_print(cmd_ctx
, "no more watchpoints available");
1938 command_print(cmd_ctx
, "unknown error, watchpoint not set");
1945 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1951 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1953 target_t
*target
= get_current_target(cmd_ctx
);
1956 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)