1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "target_request.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
37 #include <sys/types.h>
45 #include <time_support.h>
50 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
52 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
81 extern target_type_t arm7tdmi_target
;
82 extern target_type_t arm720t_target
;
83 extern target_type_t arm9tdmi_target
;
84 extern target_type_t arm920t_target
;
85 extern target_type_t arm966e_target
;
86 extern target_type_t arm926ejs_target
;
87 extern target_type_t feroceon_target
;
88 extern target_type_t xscale_target
;
89 extern target_type_t cortexm3_target
;
91 target_type_t
*target_types
[] =
105 target_t
*targets
= NULL
;
106 target_event_callback_t
*target_event_callbacks
= NULL
;
107 target_timer_callback_t
*target_timer_callbacks
= NULL
;
109 char *target_state_strings
[] =
118 char *target_debug_reason_strings
[] =
120 "debug request", "breakpoint", "watchpoint",
121 "watchpoint and breakpoint", "single step",
125 char *target_endianess_strings
[] =
131 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
133 static int target_continous_poll
= 1;
135 /* read a u32 from a buffer in target memory endianness */
136 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
138 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
139 return le_to_h_u32(buffer
);
141 return be_to_h_u32(buffer
);
144 /* read a u16 from a buffer in target memory endianness */
145 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
147 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
148 return le_to_h_u16(buffer
);
150 return be_to_h_u16(buffer
);
153 /* write a u32 to a buffer in target memory endianness */
154 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
156 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
157 h_u32_to_le(buffer
, value
);
159 h_u32_to_be(buffer
, value
);
162 /* write a u16 to a buffer in target memory endianness */
163 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
165 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
166 h_u16_to_le(buffer
, value
);
168 h_u16_to_be(buffer
, value
);
171 /* returns a pointer to the n-th configured target */
172 target_t
* get_target_by_num(int num
)
174 target_t
*target
= targets
;
181 target
= target
->next
;
188 int get_num_by_target(target_t
*query_target
)
190 target_t
*target
= targets
;
195 if (target
== query_target
)
197 target
= target
->next
;
204 target_t
* get_current_target(command_context_t
*cmd_ctx
)
206 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
210 ERROR("BUG: current_target out of bounds");
217 /* Process target initialization, when target entered debug out of reset
218 * the handler is unregistered at the end of this function, so it's only called once
220 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
223 struct command_context_s
*cmd_ctx
= priv
;
225 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
227 target_unregister_event_callback(target_init_handler
, priv
);
229 script
= open_file_from_path(cmd_ctx
, target
->reset_script
, "r");
232 ERROR("couldn't open script file %s", target
->reset_script
);
236 INFO("executing reset script '%s'", target
->reset_script
);
237 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
240 jtag_execute_queue();
246 int target_run_and_halt_handler(void *priv
)
248 target_t
*target
= priv
;
250 target
->type
->halt(target
);
255 int target_process_reset(struct command_context_s
*cmd_ctx
)
257 int retval
= ERROR_OK
;
259 struct timeval timeout
, now
;
261 /* prepare reset_halt where necessary */
265 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
267 switch (target
->reset_mode
)
270 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
271 target
->reset_mode
= RESET_RUN_AND_HALT
;
274 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
275 target
->reset_mode
= RESET_RUN_AND_INIT
;
281 switch (target
->reset_mode
)
285 target
->type
->prepare_reset_halt(target
);
290 target
= target
->next
;
296 target
->type
->assert_reset(target
);
297 target
= target
->next
;
299 jtag_execute_queue();
301 /* request target halt if necessary, and schedule further action */
305 switch (target
->reset_mode
)
308 /* nothing to do if target just wants to be run */
310 case RESET_RUN_AND_HALT
:
312 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
314 case RESET_RUN_AND_INIT
:
316 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
317 target_register_event_callback(target_init_handler
, cmd_ctx
);
320 target
->type
->halt(target
);
323 target
->type
->halt(target
);
324 target_register_event_callback(target_init_handler
, cmd_ctx
);
327 ERROR("BUG: unknown target->reset_mode");
329 target
= target
->next
;
335 target
->type
->deassert_reset(target
);
336 target
= target
->next
;
338 jtag_execute_queue();
340 /* Wait for reset to complete, maximum 5 seconds. */
341 gettimeofday(&timeout
, NULL
);
342 timeval_add_time(&timeout
, 5, 0);
345 gettimeofday(&now
, NULL
);
347 target_call_timer_callbacks();
352 target
->type
->poll(target
);
353 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) || (target
->reset_mode
== RESET_RUN_AND_HALT
))
355 if (target
->state
!= TARGET_HALTED
)
357 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
359 command_print(cmd_ctx
, "Timed out waiting for reset");
362 usleep(100*1000); /* Do not eat all cpu */
366 target
= target
->next
;
368 /* All targets we're waiting for are halted */
376 /* We want any events to be processed before the prompt */
377 target_call_timer_callbacks();
382 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
388 static int default_mmu(struct target_s
*target
, int *enabled
)
390 USER("No MMU present");
395 int target_init(struct command_context_s
*cmd_ctx
)
397 target_t
*target
= targets
;
401 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
403 ERROR("target '%s' init failed", target
->type
->name
);
407 /* Set up default functions if none are provided by target */
408 if (target
->type
->virt2phys
== NULL
)
410 target
->type
->virt2phys
= default_virt2phys
;
412 if (target
->type
->mmu
== NULL
)
414 target
->type
->mmu
= default_mmu
;
416 target
= target
->next
;
421 target_register_user_commands(cmd_ctx
);
422 target_register_timer_callback(handle_target
, 100, 1, NULL
);
428 int target_init_reset(struct command_context_s
*cmd_ctx
)
430 if (startup_mode
== DAEMON_RESET
)
431 target_process_reset(cmd_ctx
);
436 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
438 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
440 if (callback
== NULL
)
442 return ERROR_INVALID_ARGUMENTS
;
447 while ((*callbacks_p
)->next
)
448 callbacks_p
= &((*callbacks_p
)->next
);
449 callbacks_p
= &((*callbacks_p
)->next
);
452 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
453 (*callbacks_p
)->callback
= callback
;
454 (*callbacks_p
)->priv
= priv
;
455 (*callbacks_p
)->next
= NULL
;
460 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
462 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
465 if (callback
== NULL
)
467 return ERROR_INVALID_ARGUMENTS
;
472 while ((*callbacks_p
)->next
)
473 callbacks_p
= &((*callbacks_p
)->next
);
474 callbacks_p
= &((*callbacks_p
)->next
);
477 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
478 (*callbacks_p
)->callback
= callback
;
479 (*callbacks_p
)->periodic
= periodic
;
480 (*callbacks_p
)->time_ms
= time_ms
;
482 gettimeofday(&now
, NULL
);
483 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
484 time_ms
-= (time_ms
% 1000);
485 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
486 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
488 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
489 (*callbacks_p
)->when
.tv_sec
+= 1;
492 (*callbacks_p
)->priv
= priv
;
493 (*callbacks_p
)->next
= NULL
;
498 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
500 target_event_callback_t
**p
= &target_event_callbacks
;
501 target_event_callback_t
*c
= target_event_callbacks
;
503 if (callback
== NULL
)
505 return ERROR_INVALID_ARGUMENTS
;
510 target_event_callback_t
*next
= c
->next
;
511 if ((c
->callback
== callback
) && (c
->priv
== priv
))
525 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
527 target_timer_callback_t
**p
= &target_timer_callbacks
;
528 target_timer_callback_t
*c
= target_timer_callbacks
;
530 if (callback
== NULL
)
532 return ERROR_INVALID_ARGUMENTS
;
537 target_timer_callback_t
*next
= c
->next
;
538 if ((c
->callback
== callback
) && (c
->priv
== priv
))
552 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
554 target_event_callback_t
*callback
= target_event_callbacks
;
555 target_event_callback_t
*next_callback
;
557 DEBUG("target event %i", event
);
561 next_callback
= callback
->next
;
562 callback
->callback(target
, event
, callback
->priv
);
563 callback
= next_callback
;
569 int target_call_timer_callbacks()
571 target_timer_callback_t
*callback
= target_timer_callbacks
;
572 target_timer_callback_t
*next_callback
;
575 gettimeofday(&now
, NULL
);
579 next_callback
= callback
->next
;
581 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
582 || (now
.tv_sec
> callback
->when
.tv_sec
))
584 callback
->callback(callback
->priv
);
585 if (callback
->periodic
)
587 int time_ms
= callback
->time_ms
;
588 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
589 time_ms
-= (time_ms
% 1000);
590 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
591 if (callback
->when
.tv_usec
> 1000000)
593 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
594 callback
->when
.tv_sec
+= 1;
598 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
601 callback
= next_callback
;
607 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
609 working_area_t
*c
= target
->working_areas
;
610 working_area_t
*new_wa
= NULL
;
612 /* Reevaluate working area address based on MMU state*/
613 if (target
->working_areas
== NULL
)
617 retval
= target
->type
->mmu(target
, &enabled
);
618 if (retval
!= ERROR_OK
)
624 target
->working_area
= target
->working_area_virt
;
628 target
->working_area
= target
->working_area_phys
;
632 /* only allocate multiples of 4 byte */
635 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
636 size
= CEIL(size
, 4);
639 /* see if there's already a matching working area */
642 if ((c
->free
) && (c
->size
== size
))
650 /* if not, allocate a new one */
653 working_area_t
**p
= &target
->working_areas
;
654 u32 first_free
= target
->working_area
;
655 u32 free_size
= target
->working_area_size
;
657 DEBUG("allocating new working area");
659 c
= target
->working_areas
;
662 first_free
+= c
->size
;
663 free_size
-= c
->size
;
668 if (free_size
< size
)
670 WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
671 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
674 new_wa
= malloc(sizeof(working_area_t
));
677 new_wa
->address
= first_free
;
679 if (target
->backup_working_area
)
681 new_wa
->backup
= malloc(new_wa
->size
);
682 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
686 new_wa
->backup
= NULL
;
689 /* put new entry in list */
693 /* mark as used, and return the new (reused) area */
703 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
708 if (target
->backup_working_area
)
709 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
713 /* mark user pointer invalid */
720 int target_free_all_working_areas(struct target_s
*target
)
722 working_area_t
*c
= target
->working_areas
;
726 working_area_t
*next
= c
->next
;
727 target_free_working_area(target
, c
);
737 target
->working_areas
= NULL
;
742 int target_register_commands(struct command_context_s
*cmd_ctx
)
744 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
745 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
746 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
747 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
748 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
749 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
750 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
755 /* Single aligned words are guaranteed to use 16 or 32 bit access
756 * mode respectively, otherwise data is handled as quickly as
759 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
763 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
765 if (((address
% 2) == 0) && (size
== 2))
767 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
770 /* handle unaligned head bytes */
773 int unaligned
= 4 - (address
% 4);
775 if (unaligned
> size
)
778 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
782 address
+= unaligned
;
786 /* handle aligned words */
789 int aligned
= size
- (size
% 4);
791 /* use bulk writes above a certain limit. This may have to be changed */
794 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
799 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
808 /* handle tail writes of less than 4 bytes */
811 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
819 /* Single aligned words are guaranteed to use 16 or 32 bit access
820 * mode respectively, otherwise data is handled as quickly as
823 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
827 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
829 if (((address
% 2) == 0) && (size
== 2))
831 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
834 /* handle unaligned head bytes */
837 int unaligned
= 4 - (address
% 4);
839 if (unaligned
> size
)
842 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
846 address
+= unaligned
;
850 /* handle aligned words */
853 int aligned
= size
- (size
% 4);
855 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
863 /* handle tail writes of less than 4 bytes */
866 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
873 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
880 if ((retval
= target
->type
->checksum_memory(target
, address
,
881 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
883 buffer
= malloc(size
);
886 ERROR("error allocating buffer for section (%d bytes)", size
);
887 return ERROR_INVALID_ARGUMENTS
;
889 retval
= target_read_buffer(target
, address
, size
, buffer
);
890 if (retval
!= ERROR_OK
)
896 /* convert to target endianess */
897 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
900 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
901 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
904 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
913 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
917 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
919 if (retval
== ERROR_OK
)
921 *value
= target_buffer_get_u32(target
, value_buf
);
922 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
927 DEBUG("address: 0x%8.8x failed", address
);
933 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
937 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
939 if (retval
== ERROR_OK
)
941 *value
= target_buffer_get_u16(target
, value_buf
);
942 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
947 DEBUG("address: 0x%8.8x failed", address
);
953 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
955 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
957 if (retval
== ERROR_OK
)
959 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
964 DEBUG("address: 0x%8.8x failed", address
);
970 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
975 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
977 target_buffer_set_u32(target
, value_buf
, value
);
978 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
980 DEBUG("failed: %i", retval
);
986 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
991 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
993 target_buffer_set_u16(target
, value_buf
, value
);
994 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
996 DEBUG("failed: %i", retval
);
1002 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1006 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1008 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1010 DEBUG("failed: %i", retval
);
1016 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1018 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1019 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1020 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1021 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1022 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1023 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1024 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1025 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1027 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1028 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1029 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1031 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
1032 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
1033 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
1035 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1036 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1037 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1038 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1040 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1041 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1042 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1043 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1044 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1046 target_request_register_commands(cmd_ctx
);
1047 trace_register_commands(cmd_ctx
);
1052 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1054 target_t
*target
= targets
;
1059 int num
= strtoul(args
[0], NULL
, 0);
1064 target
= target
->next
;
1068 cmd_ctx
->current_target
= num
;
1070 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1077 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1078 target
= target
->next
;
1084 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1091 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1095 /* search for the specified target */
1096 if (args
[0] && (args
[0][0] != 0))
1098 for (i
= 0; target_types
[i
]; i
++)
1100 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1102 target_t
**last_target_p
= &targets
;
1104 /* register target specific commands */
1105 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1107 ERROR("couldn't register '%s' commands", args
[0]);
1113 while ((*last_target_p
)->next
)
1114 last_target_p
= &((*last_target_p
)->next
);
1115 last_target_p
= &((*last_target_p
)->next
);
1118 *last_target_p
= malloc(sizeof(target_t
));
1120 (*last_target_p
)->type
= target_types
[i
];
1122 if (strcmp(args
[1], "big") == 0)
1123 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1124 else if (strcmp(args
[1], "little") == 0)
1125 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1128 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1132 /* what to do on a target reset */
1133 if (strcmp(args
[2], "reset_halt") == 0)
1134 (*last_target_p
)->reset_mode
= RESET_HALT
;
1135 else if (strcmp(args
[2], "reset_run") == 0)
1136 (*last_target_p
)->reset_mode
= RESET_RUN
;
1137 else if (strcmp(args
[2], "reset_init") == 0)
1138 (*last_target_p
)->reset_mode
= RESET_INIT
;
1139 else if (strcmp(args
[2], "run_and_halt") == 0)
1140 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1141 else if (strcmp(args
[2], "run_and_init") == 0)
1142 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1145 ERROR("unknown target startup mode %s", args
[2]);
1148 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1150 (*last_target_p
)->reset_script
= NULL
;
1151 (*last_target_p
)->post_halt_script
= NULL
;
1152 (*last_target_p
)->pre_resume_script
= NULL
;
1153 (*last_target_p
)->gdb_program_script
= NULL
;
1155 (*last_target_p
)->working_area
= 0x0;
1156 (*last_target_p
)->working_area_size
= 0x0;
1157 (*last_target_p
)->working_areas
= NULL
;
1158 (*last_target_p
)->backup_working_area
= 0;
1160 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1161 (*last_target_p
)->reg_cache
= NULL
;
1162 (*last_target_p
)->breakpoints
= NULL
;
1163 (*last_target_p
)->watchpoints
= NULL
;
1164 (*last_target_p
)->next
= NULL
;
1165 (*last_target_p
)->arch_info
= NULL
;
1167 /* initialize trace information */
1168 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1169 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1170 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1171 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1172 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1173 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1174 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1175 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1177 (*last_target_p
)->dbgmsg
= NULL
;
1178 (*last_target_p
)->dbg_msg_enabled
= 0;
1180 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1188 /* no matching target found */
1191 ERROR("target '%s' not found", args
[0]);
1198 /* usage: target_script <target#> <event> <script_file> */
1199 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1201 target_t
*target
= NULL
;
1205 ERROR("incomplete target_script command");
1209 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1213 ERROR("target number '%s' not defined", args
[0]);
1217 if (strcmp(args
[1], "reset") == 0)
1219 if (target
->reset_script
)
1220 free(target
->reset_script
);
1221 target
->reset_script
= strdup(args
[2]);
1223 else if (strcmp(args
[1], "post_halt") == 0)
1225 if (target
->post_halt_script
)
1226 free(target
->post_halt_script
);
1227 target
->post_halt_script
= strdup(args
[2]);
1229 else if (strcmp(args
[1], "pre_resume") == 0)
1231 if (target
->pre_resume_script
)
1232 free(target
->pre_resume_script
);
1233 target
->pre_resume_script
= strdup(args
[2]);
1235 else if (strcmp(args
[1], "gdb_program_config") == 0)
1237 if (target
->gdb_program_script
)
1238 free(target
->gdb_program_script
);
1239 target
->gdb_program_script
= strdup(args
[2]);
1243 ERROR("unknown event type: '%s", args
[1]);
1250 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1252 target_t
*target
= NULL
;
1256 ERROR("incomplete run_and_halt_time command");
1260 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1264 ERROR("target number '%s' not defined", args
[0]);
1268 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1273 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1275 target_t
*target
= NULL
;
1277 if ((argc
< 4) || (argc
> 5))
1279 return ERROR_COMMAND_SYNTAX_ERROR
;
1282 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1286 ERROR("target number '%s' not defined", args
[0]);
1289 target_free_all_working_areas(target
);
1291 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1294 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1296 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1298 if (strcmp(args
[3], "backup") == 0)
1300 target
->backup_working_area
= 1;
1302 else if (strcmp(args
[3], "nobackup") == 0)
1304 target
->backup_working_area
= 0;
1308 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1309 return ERROR_COMMAND_SYNTAX_ERROR
;
1316 /* process target state changes */
1317 int handle_target(void *priv
)
1320 target_t
*target
= targets
;
1324 /* only poll if target isn't already halted */
1325 if (target
->state
!= TARGET_HALTED
)
1327 if (target_continous_poll
)
1328 if ((retval
= target
->type
->poll(target
)) < 0)
1330 ERROR("couldn't poll target. It's due for a reset.");
1334 target
= target
->next
;
1340 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1349 target
= get_current_target(cmd_ctx
);
1351 /* list all available registers for the current target */
1354 reg_cache_t
*cache
= target
->reg_cache
;
1360 for (i
= 0; i
< cache
->num_regs
; i
++)
1362 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1363 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
);
1366 cache
= cache
->next
;
1372 /* access a single register by its ordinal number */
1373 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1375 int num
= strtoul(args
[0], NULL
, 0);
1376 reg_cache_t
*cache
= target
->reg_cache
;
1382 for (i
= 0; i
< cache
->num_regs
; i
++)
1386 reg
= &cache
->reg_list
[i
];
1392 cache
= cache
->next
;
1397 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1400 } else /* access a single register by its name */
1402 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1406 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1411 /* display a register */
1412 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1414 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1417 if (reg
->valid
== 0)
1419 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1420 if (arch_type
== NULL
)
1422 ERROR("BUG: encountered unregistered arch type");
1425 arch_type
->get(reg
);
1427 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1428 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1433 /* set register value */
1436 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1437 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1439 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1440 if (arch_type
== NULL
)
1442 ERROR("BUG: encountered unregistered arch type");
1446 arch_type
->set(reg
, buf
);
1448 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1449 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1457 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1462 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1464 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1466 target_t
*target
= get_current_target(cmd_ctx
);
1471 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->type
->poll(target
)]);
1472 if (target
->state
== TARGET_HALTED
)
1474 target
->type
->arch_state(target
, buffer
, 512);
1476 command_print(cmd_ctx
, "%s", buffer
);
1481 if (strcmp(args
[0], "on") == 0)
1483 target_continous_poll
= 1;
1485 else if (strcmp(args
[0], "off") == 0)
1487 target_continous_poll
= 0;
1491 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1499 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1507 ms
= strtoul(args
[0], &end
, 0) * 1000;
1510 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1515 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1518 static void target_process_events(struct command_context_s
*cmd_ctx
)
1520 target_t
*target
= get_current_target(cmd_ctx
);
1521 target
->type
->poll(target
);
1522 target_call_timer_callbacks();
1525 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1527 struct timeval timeout
, now
;
1529 gettimeofday(&timeout
, NULL
);
1530 timeval_add_time(&timeout
, 0, ms
* 1000);
1531 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1533 target_t
*target
= get_current_target(cmd_ctx
);
1534 while (target
->type
->poll(target
))
1536 target_call_timer_callbacks();
1537 if (target
->state
== state
)
1539 command_print(cmd_ctx
, "target %s", target_state_strings
[state
]);
1543 gettimeofday(&now
, NULL
);
1544 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1546 command_print(cmd_ctx
, "timed out while waiting for target %s", target_state_strings
[state
]);
1547 ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1555 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1558 target_t
*target
= get_current_target(cmd_ctx
);
1562 command_print(cmd_ctx
, "requesting target halt...");
1564 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1568 case ERROR_TARGET_ALREADY_HALTED
:
1569 command_print(cmd_ctx
, "target already halted");
1571 case ERROR_TARGET_TIMEOUT
:
1572 command_print(cmd_ctx
, "target timed out... shutting down");
1575 command_print(cmd_ctx
, "unknown error... shutting down");
1580 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1583 /* what to do on daemon startup */
1584 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1588 if (strcmp(args
[0], "attach") == 0)
1590 startup_mode
= DAEMON_ATTACH
;
1593 else if (strcmp(args
[0], "reset") == 0)
1595 startup_mode
= DAEMON_RESET
;
1600 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1605 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1607 target_t
*target
= get_current_target(cmd_ctx
);
1610 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1612 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1616 case ERROR_TARGET_TIMEOUT
:
1617 command_print(cmd_ctx
, "target timed out... shutting down");
1620 command_print(cmd_ctx
, "unknown error... shutting down");
1628 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1630 target_t
*target
= get_current_target(cmd_ctx
);
1631 enum target_reset_mode reset_mode
= target
->reset_mode
;
1632 enum target_reset_mode save
= target
->reset_mode
;
1638 if (strcmp("run", args
[0]) == 0)
1639 reset_mode
= RESET_RUN
;
1640 else if (strcmp("halt", args
[0]) == 0)
1641 reset_mode
= RESET_HALT
;
1642 else if (strcmp("init", args
[0]) == 0)
1643 reset_mode
= RESET_INIT
;
1644 else if (strcmp("run_and_halt", args
[0]) == 0)
1646 reset_mode
= RESET_RUN_AND_HALT
;
1649 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1652 else if (strcmp("run_and_init", args
[0]) == 0)
1654 reset_mode
= RESET_RUN_AND_INIT
;
1657 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1662 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1667 /* temporarily modify mode of current reset target */
1668 target
->reset_mode
= reset_mode
;
1670 /* reset *all* targets */
1671 target_process_reset(cmd_ctx
);
1673 /* Restore default reset mode for this target */
1674 target
->reset_mode
= save
;
1679 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1682 target_t
*target
= get_current_target(cmd_ctx
);
1687 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1689 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1692 command_print(cmd_ctx
, "usage: resume [address]");
1696 if (retval
!= ERROR_OK
)
1700 case ERROR_TARGET_NOT_HALTED
:
1701 command_print(cmd_ctx
, "target not halted");
1704 command_print(cmd_ctx
, "unknown error... shutting down");
1709 target_process_events(cmd_ctx
);
1714 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1716 target_t
*target
= get_current_target(cmd_ctx
);
1721 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1724 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1729 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1731 const int line_bytecnt
= 32;
1744 target_t
*target
= get_current_target(cmd_ctx
);
1750 count
= strtoul(args
[1], NULL
, 0);
1752 address
= strtoul(args
[0], NULL
, 0);
1758 size
= 4; line_modulo
= line_bytecnt
/ 4;
1761 size
= 2; line_modulo
= line_bytecnt
/ 2;
1764 size
= 1; line_modulo
= line_bytecnt
/ 1;
1770 buffer
= calloc(count
, size
);
1771 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1772 if (retval
!= ERROR_OK
)
1776 case ERROR_TARGET_UNALIGNED_ACCESS
:
1777 command_print(cmd_ctx
, "error: address not aligned");
1779 case ERROR_TARGET_NOT_HALTED
:
1780 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1782 case ERROR_TARGET_DATA_ABORT
:
1783 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1786 command_print(cmd_ctx
, "error: unknown error");
1794 for (i
= 0; i
< count
; i
++)
1796 if (i
%line_modulo
== 0)
1797 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1802 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1805 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1808 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1812 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1814 command_print(cmd_ctx
, output
);
1824 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1829 target_t
*target
= get_current_target(cmd_ctx
);
1835 address
= strtoul(args
[0], NULL
, 0);
1836 value
= strtoul(args
[1], NULL
, 0);
1841 target_buffer_set_u32(target
, value_buf
, value
);
1842 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1845 target_buffer_set_u16(target
, value_buf
, value
);
1846 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1849 value_buf
[0] = value
;
1850 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1858 case ERROR_TARGET_UNALIGNED_ACCESS
:
1859 command_print(cmd_ctx
, "error: address not aligned");
1861 case ERROR_TARGET_DATA_ABORT
:
1862 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1864 case ERROR_TARGET_NOT_HALTED
:
1865 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1870 command_print(cmd_ctx
, "error: unknown error");
1878 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1888 duration_t duration
;
1889 char *duration_text
;
1891 target_t
*target
= get_current_target(cmd_ctx
);
1895 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1899 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1902 image
.base_address_set
= 1;
1903 image
.base_address
= strtoul(args
[1], NULL
, 0);
1907 image
.base_address_set
= 0;
1910 image
.start_address_set
= 0;
1912 duration_start_measure(&duration
);
1914 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1916 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1921 for (i
= 0; i
< image
.num_sections
; i
++)
1923 buffer
= malloc(image
.sections
[i
].size
);
1926 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1930 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1932 ERROR("image_read_section failed with error code: %i", retval
);
1933 command_print(cmd_ctx
, "image reading failed, download aborted");
1935 image_close(&image
);
1938 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1939 image_size
+= buf_cnt
;
1940 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1945 duration_stop_measure(&duration
, &duration_text
);
1946 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1947 free(duration_text
);
1949 image_close(&image
);
1955 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1964 duration_t duration
;
1965 char *duration_text
;
1967 target_t
*target
= get_current_target(cmd_ctx
);
1971 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1975 address
= strtoul(args
[1], NULL
, 0);
1976 size
= strtoul(args
[2], NULL
, 0);
1978 if ((address
& 3) || (size
& 3))
1980 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1984 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1986 command_print(cmd_ctx
, "dump_image error: %s", fileio
.error_str
);
1990 duration_start_measure(&duration
);
1995 u32 this_run_size
= (size
> 560) ? 560 : size
;
1997 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1998 if (retval
!= ERROR_OK
)
2000 command_print(cmd_ctx
, "Reading memory failed %d", retval
);
2004 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2006 size
-= this_run_size
;
2007 address
+= this_run_size
;
2010 fileio_close(&fileio
);
2012 duration_stop_measure(&duration
, &duration_text
);
2013 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2014 free(duration_text
);
2019 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2027 u32 mem_checksum
= 0;
2031 duration_t duration
;
2032 char *duration_text
;
2034 target_t
*target
= get_current_target(cmd_ctx
);
2038 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
2044 ERROR("no target selected");
2048 duration_start_measure(&duration
);
2052 image
.base_address_set
= 1;
2053 image
.base_address
= strtoul(args
[1], NULL
, 0);
2057 image
.base_address_set
= 0;
2058 image
.base_address
= 0x0;
2061 image
.start_address_set
= 0;
2063 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
2065 command_print(cmd_ctx
, "verify_image error: %s", image
.error_str
);
2070 for (i
= 0; i
< image
.num_sections
; i
++)
2072 buffer
= malloc(image
.sections
[i
].size
);
2075 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2078 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2080 ERROR("image_read_section failed with error code: %i", retval
);
2081 command_print(cmd_ctx
, "image reading failed, verify aborted");
2083 image_close(&image
);
2087 /* calculate checksum of image */
2088 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2090 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2092 if( retval
!= ERROR_OK
)
2094 command_print(cmd_ctx
, "could not calculate checksum, verify aborted");
2096 image_close(&image
);
2100 if( checksum
!= mem_checksum
)
2102 /* failed crc checksum, fall back to a binary compare */
2105 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2107 data
= (u8
*)malloc(buf_cnt
);
2109 /* Can we use 32bit word accesses? */
2111 int count
= buf_cnt
;
2112 if ((count
% 4) == 0)
2117 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2119 if (retval
== ERROR_OK
)
2122 for (t
= 0; t
< buf_cnt
; t
++)
2124 if (data
[t
] != buffer
[t
])
2126 command_print(cmd_ctx
, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", t
+ image
.sections
[i
].base_address
, data
[t
], buffer
[t
]);
2129 image_close(&image
);
2139 image_size
+= buf_cnt
;
2142 duration_stop_measure(&duration
, &duration_text
);
2143 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2144 free(duration_text
);
2146 image_close(&image
);
2151 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2154 target_t
*target
= get_current_target(cmd_ctx
);
2158 breakpoint_t
*breakpoint
= target
->breakpoints
;
2162 if (breakpoint
->type
== BKPT_SOFT
)
2164 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2165 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2170 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2172 breakpoint
= breakpoint
->next
;
2180 length
= strtoul(args
[1], NULL
, 0);
2183 if (strcmp(args
[2], "hw") == 0)
2186 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2190 case ERROR_TARGET_NOT_HALTED
:
2191 command_print(cmd_ctx
, "target must be halted to set breakpoints");
2193 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2194 command_print(cmd_ctx
, "no more breakpoints available");
2197 command_print(cmd_ctx
, "unknown error, breakpoint not set");
2203 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2208 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2214 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2216 target_t
*target
= get_current_target(cmd_ctx
);
2219 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2224 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2226 target_t
*target
= get_current_target(cmd_ctx
);
2231 watchpoint_t
*watchpoint
= target
->watchpoints
;
2235 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
);
2236 watchpoint
= watchpoint
->next
;
2241 enum watchpoint_rw type
= WPT_ACCESS
;
2242 u32 data_value
= 0x0;
2243 u32 data_mask
= 0xffffffff;
2259 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2265 data_value
= strtoul(args
[3], NULL
, 0);
2269 data_mask
= strtoul(args
[4], NULL
, 0);
2272 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2273 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2277 case ERROR_TARGET_NOT_HALTED
:
2278 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2280 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2281 command_print(cmd_ctx
, "no more watchpoints available");
2284 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2291 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2297 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2299 target_t
*target
= get_current_target(cmd_ctx
);
2302 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2307 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2310 target_t
*target
= get_current_target(cmd_ctx
);
2316 return ERROR_COMMAND_SYNTAX_ERROR
;
2318 va
= strtoul(args
[0], NULL
, 0);
2320 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2321 if (retval
== ERROR_OK
)
2323 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2327 /* lower levels will have logged a detailed error which is
2328 * forwarded to telnet/GDB session.
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)