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
);
53 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 extern target_type_t arm7tdmi_target
;
83 extern target_type_t arm720t_target
;
84 extern target_type_t arm9tdmi_target
;
85 extern target_type_t arm920t_target
;
86 extern target_type_t arm966e_target
;
87 extern target_type_t arm926ejs_target
;
88 extern target_type_t feroceon_target
;
89 extern target_type_t xscale_target
;
90 extern target_type_t cortexm3_target
;
92 target_type_t
*target_types
[] =
106 target_t
*targets
= NULL
;
107 target_event_callback_t
*target_event_callbacks
= NULL
;
108 target_timer_callback_t
*target_timer_callbacks
= NULL
;
110 char *target_state_strings
[] =
119 char *target_debug_reason_strings
[] =
121 "debug request", "breakpoint", "watchpoint",
122 "watchpoint and breakpoint", "single step",
126 char *target_endianess_strings
[] =
132 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
134 static int target_continous_poll
= 1;
136 /* read a u32 from a buffer in target memory endianness */
137 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
139 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
140 return le_to_h_u32(buffer
);
142 return be_to_h_u32(buffer
);
145 /* read a u16 from a buffer in target memory endianness */
146 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
148 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
149 return le_to_h_u16(buffer
);
151 return be_to_h_u16(buffer
);
154 /* write a u32 to a buffer in target memory endianness */
155 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
157 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
158 h_u32_to_le(buffer
, value
);
160 h_u32_to_be(buffer
, value
);
163 /* write a u16 to a buffer in target memory endianness */
164 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
166 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
167 h_u16_to_le(buffer
, value
);
169 h_u16_to_be(buffer
, value
);
172 /* returns a pointer to the n-th configured target */
173 target_t
* get_target_by_num(int num
)
175 target_t
*target
= targets
;
182 target
= target
->next
;
189 int get_num_by_target(target_t
*query_target
)
191 target_t
*target
= targets
;
196 if (target
== query_target
)
198 target
= target
->next
;
205 target_t
* get_current_target(command_context_t
*cmd_ctx
)
207 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
211 ERROR("BUG: current_target out of bounds");
218 /* Process target initialization, when target entered debug out of reset
219 * the handler is unregistered at the end of this function, so it's only called once
221 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
224 struct command_context_s
*cmd_ctx
= priv
;
226 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
228 target_unregister_event_callback(target_init_handler
, priv
);
230 script
= open_file_from_path(cmd_ctx
, target
->reset_script
, "r");
233 ERROR("couldn't open script file %s", target
->reset_script
);
237 INFO("executing reset script '%s'", target
->reset_script
);
238 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
241 jtag_execute_queue();
247 int target_run_and_halt_handler(void *priv
)
249 target_t
*target
= priv
;
251 target
->type
->halt(target
);
256 int target_process_reset(struct command_context_s
*cmd_ctx
)
258 int retval
= ERROR_OK
;
260 struct timeval timeout
, now
;
262 /* prepare reset_halt where necessary */
266 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
268 switch (target
->reset_mode
)
271 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
272 target
->reset_mode
= RESET_RUN_AND_HALT
;
275 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
276 target
->reset_mode
= RESET_RUN_AND_INIT
;
282 switch (target
->reset_mode
)
286 target
->type
->prepare_reset_halt(target
);
291 target
= target
->next
;
297 target
->type
->assert_reset(target
);
298 target
= target
->next
;
300 jtag_execute_queue();
302 /* request target halt if necessary, and schedule further action */
306 switch (target
->reset_mode
)
309 /* nothing to do if target just wants to be run */
311 case RESET_RUN_AND_HALT
:
313 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
315 case RESET_RUN_AND_INIT
:
317 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
318 target_register_event_callback(target_init_handler
, cmd_ctx
);
321 target
->type
->halt(target
);
324 target
->type
->halt(target
);
325 target_register_event_callback(target_init_handler
, cmd_ctx
);
328 ERROR("BUG: unknown target->reset_mode");
330 target
= target
->next
;
336 target
->type
->deassert_reset(target
);
337 target
= target
->next
;
339 jtag_execute_queue();
341 /* Wait for reset to complete, maximum 5 seconds. */
342 gettimeofday(&timeout
, NULL
);
343 timeval_add_time(&timeout
, 5, 0);
346 gettimeofday(&now
, NULL
);
348 target_call_timer_callbacks();
353 target
->type
->poll(target
);
354 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) || (target
->reset_mode
== RESET_RUN_AND_HALT
))
356 if (target
->state
!= TARGET_HALTED
)
358 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
360 command_print(cmd_ctx
, "Timed out waiting for reset");
363 usleep(100*1000); /* Do not eat all cpu */
367 target
= target
->next
;
369 /* All targets we're waiting for are halted */
377 /* We want any events to be processed before the prompt */
378 target_call_timer_callbacks();
383 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
389 static int default_mmu(struct target_s
*target
, int *enabled
)
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 int target_arch_state(struct target_s
*target
)
760 USER("No target has been configured");
764 USER("target state: %s", target_state_strings
[target
->state
]);
766 if (target
->state
!=TARGET_HALTED
)
769 retval
=target
->type
->arch_state(target
);
773 /* Single aligned words are guaranteed to use 16 or 32 bit access
774 * mode respectively, otherwise data is handled as quickly as
777 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
781 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
783 if (((address
% 2) == 0) && (size
== 2))
785 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
788 /* handle unaligned head bytes */
791 int unaligned
= 4 - (address
% 4);
793 if (unaligned
> size
)
796 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
800 address
+= unaligned
;
804 /* handle aligned words */
807 int aligned
= size
- (size
% 4);
809 /* use bulk writes above a certain limit. This may have to be changed */
812 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
817 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
826 /* handle tail writes of less than 4 bytes */
829 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
837 /* Single aligned words are guaranteed to use 16 or 32 bit access
838 * mode respectively, otherwise data is handled as quickly as
841 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
845 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
847 if (((address
% 2) == 0) && (size
== 2))
849 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
852 /* handle unaligned head bytes */
855 int unaligned
= 4 - (address
% 4);
857 if (unaligned
> size
)
860 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
864 address
+= unaligned
;
868 /* handle aligned words */
871 int aligned
= size
- (size
% 4);
873 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
881 /* handle tail writes of less than 4 bytes */
884 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
891 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
898 if ((retval
= target
->type
->checksum_memory(target
, address
,
899 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
901 buffer
= malloc(size
);
904 ERROR("error allocating buffer for section (%d bytes)", size
);
905 return ERROR_INVALID_ARGUMENTS
;
907 retval
= target_read_buffer(target
, address
, size
, buffer
);
908 if (retval
!= ERROR_OK
)
914 /* convert to target endianess */
915 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
918 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
919 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
922 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
931 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
935 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
937 if (retval
== ERROR_OK
)
939 *value
= target_buffer_get_u32(target
, value_buf
);
940 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
945 DEBUG("address: 0x%8.8x failed", address
);
951 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
955 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
957 if (retval
== ERROR_OK
)
959 *value
= target_buffer_get_u16(target
, value_buf
);
960 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
965 DEBUG("address: 0x%8.8x failed", address
);
971 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
973 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
975 if (retval
== ERROR_OK
)
977 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
982 DEBUG("address: 0x%8.8x failed", address
);
988 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
993 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
995 target_buffer_set_u32(target
, value_buf
, value
);
996 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
998 DEBUG("failed: %i", retval
);
1004 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1009 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1011 target_buffer_set_u16(target
, value_buf
, value
);
1012 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1014 DEBUG("failed: %i", retval
);
1020 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1024 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1026 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1028 DEBUG("failed: %i", retval
);
1034 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1036 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1037 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1038 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1039 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1040 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1041 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1042 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1043 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1045 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1046 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1047 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1049 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
1050 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
1051 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
1053 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1054 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1055 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1056 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1058 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1059 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1060 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1061 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1062 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1064 target_request_register_commands(cmd_ctx
);
1065 trace_register_commands(cmd_ctx
);
1070 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1072 target_t
*target
= targets
;
1077 int num
= strtoul(args
[0], NULL
, 0);
1082 target
= target
->next
;
1086 cmd_ctx
->current_target
= num
;
1088 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1095 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1096 target
= target
->next
;
1102 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1109 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1113 /* search for the specified target */
1114 if (args
[0] && (args
[0][0] != 0))
1116 for (i
= 0; target_types
[i
]; i
++)
1118 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1120 target_t
**last_target_p
= &targets
;
1122 /* register target specific commands */
1123 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1125 ERROR("couldn't register '%s' commands", args
[0]);
1131 while ((*last_target_p
)->next
)
1132 last_target_p
= &((*last_target_p
)->next
);
1133 last_target_p
= &((*last_target_p
)->next
);
1136 *last_target_p
= malloc(sizeof(target_t
));
1138 (*last_target_p
)->type
= target_types
[i
];
1140 if (strcmp(args
[1], "big") == 0)
1141 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1142 else if (strcmp(args
[1], "little") == 0)
1143 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1146 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1150 /* what to do on a target reset */
1151 if (strcmp(args
[2], "reset_halt") == 0)
1152 (*last_target_p
)->reset_mode
= RESET_HALT
;
1153 else if (strcmp(args
[2], "reset_run") == 0)
1154 (*last_target_p
)->reset_mode
= RESET_RUN
;
1155 else if (strcmp(args
[2], "reset_init") == 0)
1156 (*last_target_p
)->reset_mode
= RESET_INIT
;
1157 else if (strcmp(args
[2], "run_and_halt") == 0)
1158 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1159 else if (strcmp(args
[2], "run_and_init") == 0)
1160 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1163 ERROR("unknown target startup mode %s", args
[2]);
1166 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1168 (*last_target_p
)->reset_script
= NULL
;
1169 (*last_target_p
)->post_halt_script
= NULL
;
1170 (*last_target_p
)->pre_resume_script
= NULL
;
1171 (*last_target_p
)->gdb_program_script
= NULL
;
1173 (*last_target_p
)->working_area
= 0x0;
1174 (*last_target_p
)->working_area_size
= 0x0;
1175 (*last_target_p
)->working_areas
= NULL
;
1176 (*last_target_p
)->backup_working_area
= 0;
1178 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1179 (*last_target_p
)->reg_cache
= NULL
;
1180 (*last_target_p
)->breakpoints
= NULL
;
1181 (*last_target_p
)->watchpoints
= NULL
;
1182 (*last_target_p
)->next
= NULL
;
1183 (*last_target_p
)->arch_info
= NULL
;
1185 /* initialize trace information */
1186 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1187 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1188 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1189 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1190 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1191 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1192 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1193 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1195 (*last_target_p
)->dbgmsg
= NULL
;
1196 (*last_target_p
)->dbg_msg_enabled
= 0;
1198 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1206 /* no matching target found */
1209 ERROR("target '%s' not found", args
[0]);
1216 /* usage: target_script <target#> <event> <script_file> */
1217 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1219 target_t
*target
= NULL
;
1223 ERROR("incomplete target_script command");
1227 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1231 ERROR("target number '%s' not defined", args
[0]);
1235 if (strcmp(args
[1], "reset") == 0)
1237 if (target
->reset_script
)
1238 free(target
->reset_script
);
1239 target
->reset_script
= strdup(args
[2]);
1241 else if (strcmp(args
[1], "post_halt") == 0)
1243 if (target
->post_halt_script
)
1244 free(target
->post_halt_script
);
1245 target
->post_halt_script
= strdup(args
[2]);
1247 else if (strcmp(args
[1], "pre_resume") == 0)
1249 if (target
->pre_resume_script
)
1250 free(target
->pre_resume_script
);
1251 target
->pre_resume_script
= strdup(args
[2]);
1253 else if (strcmp(args
[1], "gdb_program_config") == 0)
1255 if (target
->gdb_program_script
)
1256 free(target
->gdb_program_script
);
1257 target
->gdb_program_script
= strdup(args
[2]);
1261 ERROR("unknown event type: '%s", args
[1]);
1268 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1270 target_t
*target
= NULL
;
1274 ERROR("incomplete run_and_halt_time command");
1278 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1282 ERROR("target number '%s' not defined", args
[0]);
1286 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1291 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1293 target_t
*target
= NULL
;
1295 if ((argc
< 4) || (argc
> 5))
1297 return ERROR_COMMAND_SYNTAX_ERROR
;
1300 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1304 ERROR("target number '%s' not defined", args
[0]);
1307 target_free_all_working_areas(target
);
1309 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1312 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1314 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1316 if (strcmp(args
[3], "backup") == 0)
1318 target
->backup_working_area
= 1;
1320 else if (strcmp(args
[3], "nobackup") == 0)
1322 target
->backup_working_area
= 0;
1326 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1327 return ERROR_COMMAND_SYNTAX_ERROR
;
1334 /* process target state changes */
1335 int handle_target(void *priv
)
1338 target_t
*target
= targets
;
1342 /* only poll if target isn't already halted */
1343 if (target
->state
!= TARGET_HALTED
)
1345 if (target_continous_poll
)
1346 if ((retval
= target
->type
->poll(target
)) != ERROR_OK
)
1348 ERROR("couldn't poll target(%d). It's due for a reset.", retval
);
1352 target
= target
->next
;
1358 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1367 target
= get_current_target(cmd_ctx
);
1369 /* list all available registers for the current target */
1372 reg_cache_t
*cache
= target
->reg_cache
;
1378 for (i
= 0; i
< cache
->num_regs
; i
++)
1380 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1381 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
);
1384 cache
= cache
->next
;
1390 /* access a single register by its ordinal number */
1391 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1393 int num
= strtoul(args
[0], NULL
, 0);
1394 reg_cache_t
*cache
= target
->reg_cache
;
1400 for (i
= 0; i
< cache
->num_regs
; i
++)
1404 reg
= &cache
->reg_list
[i
];
1410 cache
= cache
->next
;
1415 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1418 } else /* access a single register by its name */
1420 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1424 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1429 /* display a register */
1430 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1432 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1435 if (reg
->valid
== 0)
1437 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1438 if (arch_type
== NULL
)
1440 ERROR("BUG: encountered unregistered arch type");
1443 arch_type
->get(reg
);
1445 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1446 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1451 /* set register value */
1454 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1455 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1457 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1458 if (arch_type
== NULL
)
1460 ERROR("BUG: encountered unregistered arch type");
1464 arch_type
->set(reg
, buf
);
1466 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1467 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1475 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1480 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1482 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1484 target_t
*target
= get_current_target(cmd_ctx
);
1488 target
->type
->poll(target
);
1489 target_arch_state(target
);
1493 if (strcmp(args
[0], "on") == 0)
1495 target_continous_poll
= 1;
1497 else if (strcmp(args
[0], "off") == 0)
1499 target_continous_poll
= 0;
1503 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1511 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1519 ms
= strtoul(args
[0], &end
, 0) * 1000;
1522 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1527 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1530 static void target_process_events(struct command_context_s
*cmd_ctx
)
1532 target_t
*target
= get_current_target(cmd_ctx
);
1533 target
->type
->poll(target
);
1534 target_call_timer_callbacks();
1537 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1540 struct timeval timeout
, now
;
1542 gettimeofday(&timeout
, NULL
);
1543 timeval_add_time(&timeout
, 0, ms
* 1000);
1545 target_t
*target
= get_current_target(cmd_ctx
);
1548 if ((retval
=target
->type
->poll(target
))!=ERROR_OK
)
1550 target_call_timer_callbacks();
1551 if (target
->state
== state
)
1555 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1557 gettimeofday(&now
, NULL
);
1558 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1560 command_print(cmd_ctx
, "timed out while waiting for target %s", target_state_strings
[state
]);
1561 ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1569 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1572 target_t
*target
= get_current_target(cmd_ctx
);
1576 command_print(cmd_ctx
, "requesting target halt...");
1578 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1582 case ERROR_TARGET_ALREADY_HALTED
:
1583 command_print(cmd_ctx
, "target already halted");
1585 case ERROR_TARGET_TIMEOUT
:
1586 command_print(cmd_ctx
, "target timed out... shutting down");
1589 command_print(cmd_ctx
, "unknown error... shutting down");
1594 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1597 /* what to do on daemon startup */
1598 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1602 if (strcmp(args
[0], "attach") == 0)
1604 startup_mode
= DAEMON_ATTACH
;
1607 else if (strcmp(args
[0], "reset") == 0)
1609 startup_mode
= DAEMON_RESET
;
1614 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1619 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1621 target_t
*target
= get_current_target(cmd_ctx
);
1624 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1626 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1630 case ERROR_TARGET_TIMEOUT
:
1631 command_print(cmd_ctx
, "target timed out... shutting down");
1634 command_print(cmd_ctx
, "unknown error... shutting down");
1642 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1644 target_t
*target
= get_current_target(cmd_ctx
);
1645 enum target_reset_mode reset_mode
= target
->reset_mode
;
1646 enum target_reset_mode save
= target
->reset_mode
;
1652 if (strcmp("run", args
[0]) == 0)
1653 reset_mode
= RESET_RUN
;
1654 else if (strcmp("halt", args
[0]) == 0)
1655 reset_mode
= RESET_HALT
;
1656 else if (strcmp("init", args
[0]) == 0)
1657 reset_mode
= RESET_INIT
;
1658 else if (strcmp("run_and_halt", args
[0]) == 0)
1660 reset_mode
= RESET_RUN_AND_HALT
;
1663 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1666 else if (strcmp("run_and_init", args
[0]) == 0)
1668 reset_mode
= RESET_RUN_AND_INIT
;
1671 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1676 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1681 /* temporarily modify mode of current reset target */
1682 target
->reset_mode
= reset_mode
;
1684 /* reset *all* targets */
1685 target_process_reset(cmd_ctx
);
1687 /* Restore default reset mode for this target */
1688 target
->reset_mode
= save
;
1693 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1696 target_t
*target
= get_current_target(cmd_ctx
);
1699 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1701 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1704 return ERROR_COMMAND_SYNTAX_ERROR
;
1707 target_process_events(cmd_ctx
);
1709 target_arch_state(target
);
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)