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
;
91 extern target_type_t arm11_target
;
93 target_type_t
*target_types
[] =
108 target_t
*targets
= NULL
;
109 target_event_callback_t
*target_event_callbacks
= NULL
;
110 target_timer_callback_t
*target_timer_callbacks
= NULL
;
112 char *target_state_strings
[] =
121 char *target_debug_reason_strings
[] =
123 "debug request", "breakpoint", "watchpoint",
124 "watchpoint and breakpoint", "single step",
128 char *target_endianess_strings
[] =
134 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
136 static int target_continous_poll
= 1;
138 /* read a u32 from a buffer in target memory endianness */
139 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
141 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
142 return le_to_h_u32(buffer
);
144 return be_to_h_u32(buffer
);
147 /* read a u16 from a buffer in target memory endianness */
148 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
150 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
151 return le_to_h_u16(buffer
);
153 return be_to_h_u16(buffer
);
156 /* write a u32 to a buffer in target memory endianness */
157 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
159 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
160 h_u32_to_le(buffer
, value
);
162 h_u32_to_be(buffer
, value
);
165 /* write a u16 to a buffer in target memory endianness */
166 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
168 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
169 h_u16_to_le(buffer
, value
);
171 h_u16_to_be(buffer
, value
);
174 /* returns a pointer to the n-th configured target */
175 target_t
* get_target_by_num(int num
)
177 target_t
*target
= targets
;
184 target
= target
->next
;
191 int get_num_by_target(target_t
*query_target
)
193 target_t
*target
= targets
;
198 if (target
== query_target
)
200 target
= target
->next
;
207 target_t
* get_current_target(command_context_t
*cmd_ctx
)
209 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
213 ERROR("BUG: current_target out of bounds");
220 /* Process target initialization, when target entered debug out of reset
221 * the handler is unregistered at the end of this function, so it's only called once
223 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
226 struct command_context_s
*cmd_ctx
= priv
;
228 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
230 target_unregister_event_callback(target_init_handler
, priv
);
232 script
= open_file_from_path(target
->reset_script
, "r");
235 ERROR("couldn't open script file %s", target
->reset_script
);
239 INFO("executing reset script '%s'", target
->reset_script
);
240 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
243 jtag_execute_queue();
249 int target_run_and_halt_handler(void *priv
)
251 target_t
*target
= priv
;
253 target
->type
->halt(target
);
258 int target_process_reset(struct command_context_s
*cmd_ctx
)
260 int retval
= ERROR_OK
;
262 struct timeval timeout
, now
;
264 /* prepare reset_halt where necessary */
268 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
270 switch (target
->reset_mode
)
273 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
274 target
->reset_mode
= RESET_RUN_AND_HALT
;
277 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
278 target
->reset_mode
= RESET_RUN_AND_INIT
;
284 switch (target
->reset_mode
)
288 target
->type
->prepare_reset_halt(target
);
293 target
= target
->next
;
299 target
->type
->assert_reset(target
);
300 target
= target
->next
;
302 jtag_execute_queue();
304 /* request target halt if necessary, and schedule further action */
308 switch (target
->reset_mode
)
311 /* nothing to do if target just wants to be run */
313 case RESET_RUN_AND_HALT
:
315 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
317 case RESET_RUN_AND_INIT
:
319 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
320 target_register_event_callback(target_init_handler
, cmd_ctx
);
323 target
->type
->halt(target
);
326 target
->type
->halt(target
);
327 target_register_event_callback(target_init_handler
, cmd_ctx
);
330 ERROR("BUG: unknown target->reset_mode");
332 target
= target
->next
;
338 target
->type
->deassert_reset(target
);
339 target
= target
->next
;
341 jtag_execute_queue();
343 /* Wait for reset to complete, maximum 5 seconds. */
344 gettimeofday(&timeout
, NULL
);
345 timeval_add_time(&timeout
, 5, 0);
348 gettimeofday(&now
, NULL
);
350 target_call_timer_callbacks();
355 target
->type
->poll(target
);
356 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) || (target
->reset_mode
== RESET_RUN_AND_HALT
))
358 if (target
->state
!= TARGET_HALTED
)
360 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
362 command_print(cmd_ctx
, "Timed out waiting for reset");
365 usleep(100*1000); /* Do not eat all cpu */
369 target
= target
->next
;
371 /* All targets we're waiting for are halted */
379 /* We want any events to be processed before the prompt */
380 target_call_timer_callbacks();
385 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
391 static int default_mmu(struct target_s
*target
, int *enabled
)
397 int target_init(struct command_context_s
*cmd_ctx
)
399 target_t
*target
= targets
;
403 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
405 ERROR("target '%s' init failed", target
->type
->name
);
409 /* Set up default functions if none are provided by target */
410 if (target
->type
->virt2phys
== NULL
)
412 target
->type
->virt2phys
= default_virt2phys
;
414 if (target
->type
->mmu
== NULL
)
416 target
->type
->mmu
= default_mmu
;
418 target
= target
->next
;
423 target_register_user_commands(cmd_ctx
);
424 target_register_timer_callback(handle_target
, 100, 1, NULL
);
430 int target_init_reset(struct command_context_s
*cmd_ctx
)
432 if (startup_mode
== DAEMON_RESET
)
433 target_process_reset(cmd_ctx
);
438 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
440 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
442 if (callback
== NULL
)
444 return ERROR_INVALID_ARGUMENTS
;
449 while ((*callbacks_p
)->next
)
450 callbacks_p
= &((*callbacks_p
)->next
);
451 callbacks_p
= &((*callbacks_p
)->next
);
454 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
455 (*callbacks_p
)->callback
= callback
;
456 (*callbacks_p
)->priv
= priv
;
457 (*callbacks_p
)->next
= NULL
;
462 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
464 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
467 if (callback
== NULL
)
469 return ERROR_INVALID_ARGUMENTS
;
474 while ((*callbacks_p
)->next
)
475 callbacks_p
= &((*callbacks_p
)->next
);
476 callbacks_p
= &((*callbacks_p
)->next
);
479 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
480 (*callbacks_p
)->callback
= callback
;
481 (*callbacks_p
)->periodic
= periodic
;
482 (*callbacks_p
)->time_ms
= time_ms
;
484 gettimeofday(&now
, NULL
);
485 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
486 time_ms
-= (time_ms
% 1000);
487 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
488 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
490 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
491 (*callbacks_p
)->when
.tv_sec
+= 1;
494 (*callbacks_p
)->priv
= priv
;
495 (*callbacks_p
)->next
= NULL
;
500 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
502 target_event_callback_t
**p
= &target_event_callbacks
;
503 target_event_callback_t
*c
= target_event_callbacks
;
505 if (callback
== NULL
)
507 return ERROR_INVALID_ARGUMENTS
;
512 target_event_callback_t
*next
= c
->next
;
513 if ((c
->callback
== callback
) && (c
->priv
== priv
))
527 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
529 target_timer_callback_t
**p
= &target_timer_callbacks
;
530 target_timer_callback_t
*c
= target_timer_callbacks
;
532 if (callback
== NULL
)
534 return ERROR_INVALID_ARGUMENTS
;
539 target_timer_callback_t
*next
= c
->next
;
540 if ((c
->callback
== callback
) && (c
->priv
== priv
))
554 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
556 target_event_callback_t
*callback
= target_event_callbacks
;
557 target_event_callback_t
*next_callback
;
559 DEBUG("target event %i", event
);
563 next_callback
= callback
->next
;
564 callback
->callback(target
, event
, callback
->priv
);
565 callback
= next_callback
;
571 int target_call_timer_callbacks()
573 target_timer_callback_t
*callback
= target_timer_callbacks
;
574 target_timer_callback_t
*next_callback
;
577 gettimeofday(&now
, NULL
);
581 next_callback
= callback
->next
;
583 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
584 || (now
.tv_sec
> callback
->when
.tv_sec
))
586 callback
->callback(callback
->priv
);
587 if (callback
->periodic
)
589 int time_ms
= callback
->time_ms
;
590 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
591 time_ms
-= (time_ms
% 1000);
592 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
593 if (callback
->when
.tv_usec
> 1000000)
595 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
596 callback
->when
.tv_sec
+= 1;
600 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
603 callback
= next_callback
;
609 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
611 working_area_t
*c
= target
->working_areas
;
612 working_area_t
*new_wa
= NULL
;
614 /* Reevaluate working area address based on MMU state*/
615 if (target
->working_areas
== NULL
)
619 retval
= target
->type
->mmu(target
, &enabled
);
620 if (retval
!= ERROR_OK
)
626 target
->working_area
= target
->working_area_virt
;
630 target
->working_area
= target
->working_area_phys
;
634 /* only allocate multiples of 4 byte */
637 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
638 size
= CEIL(size
, 4);
641 /* see if there's already a matching working area */
644 if ((c
->free
) && (c
->size
== size
))
652 /* if not, allocate a new one */
655 working_area_t
**p
= &target
->working_areas
;
656 u32 first_free
= target
->working_area
;
657 u32 free_size
= target
->working_area_size
;
659 DEBUG("allocating new working area");
661 c
= target
->working_areas
;
664 first_free
+= c
->size
;
665 free_size
-= c
->size
;
670 if (free_size
< size
)
672 WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
673 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
676 new_wa
= malloc(sizeof(working_area_t
));
679 new_wa
->address
= first_free
;
681 if (target
->backup_working_area
)
683 new_wa
->backup
= malloc(new_wa
->size
);
684 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
688 new_wa
->backup
= NULL
;
691 /* put new entry in list */
695 /* mark as used, and return the new (reused) area */
705 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
710 if (target
->backup_working_area
)
711 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
715 /* mark user pointer invalid */
722 int target_free_all_working_areas(struct target_s
*target
)
724 working_area_t
*c
= target
->working_areas
;
728 working_area_t
*next
= c
->next
;
729 target_free_working_area(target
, c
);
739 target
->working_areas
= NULL
;
744 int target_register_commands(struct command_context_s
*cmd_ctx
)
746 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
747 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
748 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
749 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
750 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
751 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
752 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
757 int target_arch_state(struct target_s
*target
)
762 USER("No target has been configured");
766 USER("target state: %s", target_state_strings
[target
->state
]);
768 if (target
->state
!=TARGET_HALTED
)
771 retval
=target
->type
->arch_state(target
);
775 /* Single aligned words are guaranteed to use 16 or 32 bit access
776 * mode respectively, otherwise data is handled as quickly as
779 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
783 DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
785 if (((address
% 2) == 0) && (size
== 2))
787 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
790 /* handle unaligned head bytes */
793 int unaligned
= 4 - (address
% 4);
795 if (unaligned
> size
)
798 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
802 address
+= unaligned
;
806 /* handle aligned words */
809 int aligned
= size
- (size
% 4);
811 /* use bulk writes above a certain limit. This may have to be changed */
814 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
819 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
828 /* handle tail writes of less than 4 bytes */
831 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
839 /* Single aligned words are guaranteed to use 16 or 32 bit access
840 * mode respectively, otherwise data is handled as quickly as
843 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
847 DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
849 if (((address
% 2) == 0) && (size
== 2))
851 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
854 /* handle unaligned head bytes */
857 int unaligned
= 4 - (address
% 4);
859 if (unaligned
> size
)
862 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
866 address
+= unaligned
;
870 /* handle aligned words */
873 int aligned
= size
- (size
% 4);
875 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
883 /* handle tail writes of less than 4 bytes */
886 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
893 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
900 if ((retval
= target
->type
->checksum_memory(target
, address
,
901 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
903 buffer
= malloc(size
);
906 ERROR("error allocating buffer for section (%d bytes)", size
);
907 return ERROR_INVALID_ARGUMENTS
;
909 retval
= target_read_buffer(target
, address
, size
, buffer
);
910 if (retval
!= ERROR_OK
)
916 /* convert to target endianess */
917 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
920 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
921 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
924 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
933 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
937 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
939 if (retval
== ERROR_OK
)
941 *value
= target_buffer_get_u32(target
, value_buf
);
942 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
947 DEBUG("address: 0x%8.8x failed", address
);
953 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
957 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
959 if (retval
== ERROR_OK
)
961 *value
= target_buffer_get_u16(target
, value_buf
);
962 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
967 DEBUG("address: 0x%8.8x failed", address
);
973 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
975 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
977 if (retval
== ERROR_OK
)
979 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
984 DEBUG("address: 0x%8.8x failed", address
);
990 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
995 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
997 target_buffer_set_u32(target
, value_buf
, value
);
998 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1000 DEBUG("failed: %i", retval
);
1006 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1011 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1013 target_buffer_set_u16(target
, value_buf
, value
);
1014 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1016 DEBUG("failed: %i", retval
);
1022 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1026 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1028 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1030 DEBUG("failed: %i", retval
);
1036 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1038 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1039 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1040 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1041 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1042 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1043 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1044 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1045 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1047 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1048 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1049 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1051 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value>");
1052 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value>");
1053 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value>");
1055 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1056 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1057 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1058 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1060 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1061 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1062 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1063 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1064 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1066 target_request_register_commands(cmd_ctx
);
1067 trace_register_commands(cmd_ctx
);
1072 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1074 target_t
*target
= targets
;
1079 int num
= strtoul(args
[0], NULL
, 0);
1084 target
= target
->next
;
1088 cmd_ctx
->current_target
= num
;
1090 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1097 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1098 target
= target
->next
;
1104 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1111 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1115 /* search for the specified target */
1116 if (args
[0] && (args
[0][0] != 0))
1118 for (i
= 0; target_types
[i
]; i
++)
1120 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1122 target_t
**last_target_p
= &targets
;
1124 /* register target specific commands */
1125 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1127 ERROR("couldn't register '%s' commands", args
[0]);
1133 while ((*last_target_p
)->next
)
1134 last_target_p
= &((*last_target_p
)->next
);
1135 last_target_p
= &((*last_target_p
)->next
);
1138 *last_target_p
= malloc(sizeof(target_t
));
1140 (*last_target_p
)->type
= target_types
[i
];
1142 if (strcmp(args
[1], "big") == 0)
1143 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1144 else if (strcmp(args
[1], "little") == 0)
1145 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1148 ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1152 /* what to do on a target reset */
1153 if (strcmp(args
[2], "reset_halt") == 0)
1154 (*last_target_p
)->reset_mode
= RESET_HALT
;
1155 else if (strcmp(args
[2], "reset_run") == 0)
1156 (*last_target_p
)->reset_mode
= RESET_RUN
;
1157 else if (strcmp(args
[2], "reset_init") == 0)
1158 (*last_target_p
)->reset_mode
= RESET_INIT
;
1159 else if (strcmp(args
[2], "run_and_halt") == 0)
1160 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1161 else if (strcmp(args
[2], "run_and_init") == 0)
1162 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1165 ERROR("unknown target startup mode %s", args
[2]);
1168 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1170 (*last_target_p
)->reset_script
= NULL
;
1171 (*last_target_p
)->post_halt_script
= NULL
;
1172 (*last_target_p
)->pre_resume_script
= NULL
;
1173 (*last_target_p
)->gdb_program_script
= NULL
;
1175 (*last_target_p
)->working_area
= 0x0;
1176 (*last_target_p
)->working_area_size
= 0x0;
1177 (*last_target_p
)->working_areas
= NULL
;
1178 (*last_target_p
)->backup_working_area
= 0;
1180 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1181 (*last_target_p
)->reg_cache
= NULL
;
1182 (*last_target_p
)->breakpoints
= NULL
;
1183 (*last_target_p
)->watchpoints
= NULL
;
1184 (*last_target_p
)->next
= NULL
;
1185 (*last_target_p
)->arch_info
= NULL
;
1187 /* initialize trace information */
1188 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1189 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1190 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1191 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1192 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1193 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1194 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1195 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1197 (*last_target_p
)->dbgmsg
= NULL
;
1198 (*last_target_p
)->dbg_msg_enabled
= 0;
1200 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1208 /* no matching target found */
1211 ERROR("target '%s' not found", args
[0]);
1218 /* usage: target_script <target#> <event> <script_file> */
1219 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1221 target_t
*target
= NULL
;
1225 ERROR("incomplete target_script command");
1229 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1233 ERROR("target number '%s' not defined", args
[0]);
1237 if (strcmp(args
[1], "reset") == 0)
1239 if (target
->reset_script
)
1240 free(target
->reset_script
);
1241 target
->reset_script
= strdup(args
[2]);
1243 else if (strcmp(args
[1], "post_halt") == 0)
1245 if (target
->post_halt_script
)
1246 free(target
->post_halt_script
);
1247 target
->post_halt_script
= strdup(args
[2]);
1249 else if (strcmp(args
[1], "pre_resume") == 0)
1251 if (target
->pre_resume_script
)
1252 free(target
->pre_resume_script
);
1253 target
->pre_resume_script
= strdup(args
[2]);
1255 else if (strcmp(args
[1], "gdb_program_config") == 0)
1257 if (target
->gdb_program_script
)
1258 free(target
->gdb_program_script
);
1259 target
->gdb_program_script
= strdup(args
[2]);
1263 ERROR("unknown event type: '%s", args
[1]);
1270 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1272 target_t
*target
= NULL
;
1276 ERROR("incomplete run_and_halt_time command");
1280 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1284 ERROR("target number '%s' not defined", args
[0]);
1288 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1293 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1295 target_t
*target
= NULL
;
1297 if ((argc
< 4) || (argc
> 5))
1299 return ERROR_COMMAND_SYNTAX_ERROR
;
1302 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1306 ERROR("target number '%s' not defined", args
[0]);
1309 target_free_all_working_areas(target
);
1311 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1314 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1316 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1318 if (strcmp(args
[3], "backup") == 0)
1320 target
->backup_working_area
= 1;
1322 else if (strcmp(args
[3], "nobackup") == 0)
1324 target
->backup_working_area
= 0;
1328 ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1329 return ERROR_COMMAND_SYNTAX_ERROR
;
1336 /* process target state changes */
1337 int handle_target(void *priv
)
1340 target_t
*target
= targets
;
1344 /* only poll if target isn't already halted */
1345 if (target
->state
!= TARGET_HALTED
)
1347 if (target_continous_poll
)
1348 if ((retval
= target
->type
->poll(target
)) != ERROR_OK
)
1350 ERROR("couldn't poll target(%d). It's due for a reset.", retval
);
1354 target
= target
->next
;
1360 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1369 target
= get_current_target(cmd_ctx
);
1371 /* list all available registers for the current target */
1374 reg_cache_t
*cache
= target
->reg_cache
;
1380 for (i
= 0; i
< cache
->num_regs
; i
++)
1382 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1383 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
);
1386 cache
= cache
->next
;
1392 /* access a single register by its ordinal number */
1393 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1395 int num
= strtoul(args
[0], NULL
, 0);
1396 reg_cache_t
*cache
= target
->reg_cache
;
1402 for (i
= 0; i
< cache
->num_regs
; i
++)
1406 reg
= &cache
->reg_list
[i
];
1412 cache
= cache
->next
;
1417 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1420 } else /* access a single register by its name */
1422 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1426 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1431 /* display a register */
1432 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1434 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1437 if (reg
->valid
== 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");
1445 arch_type
->get(reg
);
1447 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1448 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1453 /* set register value */
1456 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1457 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1459 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1460 if (arch_type
== NULL
)
1462 ERROR("BUG: encountered unregistered arch type");
1466 arch_type
->set(reg
, buf
);
1468 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1469 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1477 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1482 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1484 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1486 target_t
*target
= get_current_target(cmd_ctx
);
1490 target
->type
->poll(target
);
1491 target_arch_state(target
);
1495 if (strcmp(args
[0], "on") == 0)
1497 target_continous_poll
= 1;
1499 else if (strcmp(args
[0], "off") == 0)
1501 target_continous_poll
= 0;
1505 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1513 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1521 ms
= strtoul(args
[0], &end
, 0) * 1000;
1524 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1529 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1532 static void target_process_events(struct command_context_s
*cmd_ctx
)
1534 target_t
*target
= get_current_target(cmd_ctx
);
1535 target
->type
->poll(target
);
1536 target_call_timer_callbacks();
1539 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1542 struct timeval timeout
, now
;
1544 gettimeofday(&timeout
, NULL
);
1545 timeval_add_time(&timeout
, 0, ms
* 1000);
1547 target_t
*target
= get_current_target(cmd_ctx
);
1550 if ((retval
=target
->type
->poll(target
))!=ERROR_OK
)
1552 target_call_timer_callbacks();
1553 if (target
->state
== state
)
1560 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1563 gettimeofday(&now
, NULL
);
1564 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1566 ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1574 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1577 target_t
*target
= get_current_target(cmd_ctx
);
1581 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1586 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1589 /* what to do on daemon startup */
1590 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1594 if (strcmp(args
[0], "attach") == 0)
1596 startup_mode
= DAEMON_ATTACH
;
1599 else if (strcmp(args
[0], "reset") == 0)
1601 startup_mode
= DAEMON_RESET
;
1606 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1611 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1613 target_t
*target
= get_current_target(cmd_ctx
);
1616 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1618 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1622 case ERROR_TARGET_TIMEOUT
:
1623 command_print(cmd_ctx
, "target timed out... shutting down");
1626 command_print(cmd_ctx
, "unknown error... shutting down");
1634 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1636 target_t
*target
= get_current_target(cmd_ctx
);
1637 enum target_reset_mode reset_mode
= target
->reset_mode
;
1638 enum target_reset_mode save
= target
->reset_mode
;
1644 if (strcmp("run", args
[0]) == 0)
1645 reset_mode
= RESET_RUN
;
1646 else if (strcmp("halt", args
[0]) == 0)
1647 reset_mode
= RESET_HALT
;
1648 else if (strcmp("init", args
[0]) == 0)
1649 reset_mode
= RESET_INIT
;
1650 else if (strcmp("run_and_halt", args
[0]) == 0)
1652 reset_mode
= RESET_RUN_AND_HALT
;
1655 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1658 else if (strcmp("run_and_init", args
[0]) == 0)
1660 reset_mode
= RESET_RUN_AND_INIT
;
1663 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1668 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1673 /* temporarily modify mode of current reset target */
1674 target
->reset_mode
= reset_mode
;
1676 /* reset *all* targets */
1677 target_process_reset(cmd_ctx
);
1679 /* Restore default reset mode for this target */
1680 target
->reset_mode
= save
;
1685 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1688 target_t
*target
= get_current_target(cmd_ctx
);
1691 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1693 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1696 return ERROR_COMMAND_SYNTAX_ERROR
;
1699 target_process_events(cmd_ctx
);
1704 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1706 target_t
*target
= get_current_target(cmd_ctx
);
1711 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1714 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1719 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1721 const int line_bytecnt
= 32;
1734 target_t
*target
= get_current_target(cmd_ctx
);
1740 count
= strtoul(args
[1], NULL
, 0);
1742 address
= strtoul(args
[0], NULL
, 0);
1748 size
= 4; line_modulo
= line_bytecnt
/ 4;
1751 size
= 2; line_modulo
= line_bytecnt
/ 2;
1754 size
= 1; line_modulo
= line_bytecnt
/ 1;
1760 buffer
= calloc(count
, size
);
1761 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1762 if (retval
!= ERROR_OK
)
1766 case ERROR_TARGET_UNALIGNED_ACCESS
:
1767 command_print(cmd_ctx
, "error: address not aligned");
1769 case ERROR_TARGET_NOT_HALTED
:
1770 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1772 case ERROR_TARGET_DATA_ABORT
:
1773 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1776 command_print(cmd_ctx
, "error: unknown error");
1784 for (i
= 0; i
< count
; i
++)
1786 if (i
%line_modulo
== 0)
1787 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1792 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1795 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1798 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1802 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1804 command_print(cmd_ctx
, output
);
1814 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1819 target_t
*target
= get_current_target(cmd_ctx
);
1825 address
= strtoul(args
[0], NULL
, 0);
1826 value
= strtoul(args
[1], NULL
, 0);
1831 target_buffer_set_u32(target
, value_buf
, value
);
1832 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1835 target_buffer_set_u16(target
, value_buf
, value
);
1836 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1839 value_buf
[0] = value
;
1840 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1848 case ERROR_TARGET_UNALIGNED_ACCESS
:
1849 command_print(cmd_ctx
, "error: address not aligned");
1851 case ERROR_TARGET_DATA_ABORT
:
1852 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1854 case ERROR_TARGET_NOT_HALTED
:
1855 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1860 command_print(cmd_ctx
, "error: unknown error");
1868 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1878 duration_t duration
;
1879 char *duration_text
;
1881 target_t
*target
= get_current_target(cmd_ctx
);
1885 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1889 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1892 image
.base_address_set
= 1;
1893 image
.base_address
= strtoul(args
[1], NULL
, 0);
1897 image
.base_address_set
= 0;
1900 image
.start_address_set
= 0;
1902 duration_start_measure(&duration
);
1904 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1910 for (i
= 0; i
< image
.num_sections
; i
++)
1912 buffer
= malloc(image
.sections
[i
].size
);
1915 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1919 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1921 ERROR("image_read_section failed with error code: %i", retval
);
1922 command_print(cmd_ctx
, "image reading failed, download aborted");
1924 image_close(&image
);
1927 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1928 image_size
+= buf_cnt
;
1929 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1934 duration_stop_measure(&duration
, &duration_text
);
1935 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1936 free(duration_text
);
1938 image_close(&image
);
1944 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1953 duration_t duration
;
1954 char *duration_text
;
1956 target_t
*target
= get_current_target(cmd_ctx
);
1960 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1964 address
= strtoul(args
[1], NULL
, 0);
1965 size
= strtoul(args
[2], NULL
, 0);
1967 if ((address
& 3) || (size
& 3))
1969 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
1973 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1978 duration_start_measure(&duration
);
1983 u32 this_run_size
= (size
> 560) ? 560 : size
;
1985 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
1986 if (retval
!= ERROR_OK
)
1988 command_print(cmd_ctx
, "Reading memory failed %d", retval
);
1992 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
1994 size
-= this_run_size
;
1995 address
+= this_run_size
;
1998 fileio_close(&fileio
);
2000 duration_stop_measure(&duration
, &duration_text
);
2001 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2002 free(duration_text
);
2007 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2015 u32 mem_checksum
= 0;
2019 duration_t duration
;
2020 char *duration_text
;
2022 target_t
*target
= get_current_target(cmd_ctx
);
2026 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
2032 ERROR("no target selected");
2036 duration_start_measure(&duration
);
2040 image
.base_address_set
= 1;
2041 image
.base_address
= strtoul(args
[1], NULL
, 0);
2045 image
.base_address_set
= 0;
2046 image
.base_address
= 0x0;
2049 image
.start_address_set
= 0;
2051 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
2057 for (i
= 0; i
< image
.num_sections
; i
++)
2059 buffer
= malloc(image
.sections
[i
].size
);
2062 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2065 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2067 ERROR("image_read_section failed with error code: %i", retval
);
2068 command_print(cmd_ctx
, "image reading failed, verify aborted");
2070 image_close(&image
);
2074 /* calculate checksum of image */
2075 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2077 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2079 if( retval
!= ERROR_OK
)
2081 command_print(cmd_ctx
, "could not calculate checksum, verify aborted");
2083 image_close(&image
);
2087 if( checksum
!= mem_checksum
)
2089 /* failed crc checksum, fall back to a binary compare */
2092 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2094 data
= (u8
*)malloc(buf_cnt
);
2096 /* Can we use 32bit word accesses? */
2098 int count
= buf_cnt
;
2099 if ((count
% 4) == 0)
2104 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2106 if (retval
== ERROR_OK
)
2109 for (t
= 0; t
< buf_cnt
; t
++)
2111 if (data
[t
] != buffer
[t
])
2113 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
]);
2116 image_close(&image
);
2126 image_size
+= buf_cnt
;
2129 duration_stop_measure(&duration
, &duration_text
);
2130 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2131 free(duration_text
);
2133 image_close(&image
);
2138 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2141 target_t
*target
= get_current_target(cmd_ctx
);
2145 breakpoint_t
*breakpoint
= target
->breakpoints
;
2149 if (breakpoint
->type
== BKPT_SOFT
)
2151 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2152 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2157 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2159 breakpoint
= breakpoint
->next
;
2167 length
= strtoul(args
[1], NULL
, 0);
2170 if (strcmp(args
[2], "hw") == 0)
2173 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2177 case ERROR_TARGET_NOT_HALTED
:
2178 command_print(cmd_ctx
, "target must be halted to set breakpoints");
2180 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2181 command_print(cmd_ctx
, "no more breakpoints available");
2184 command_print(cmd_ctx
, "unknown error, breakpoint not set");
2190 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2195 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2201 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2203 target_t
*target
= get_current_target(cmd_ctx
);
2206 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2211 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2213 target_t
*target
= get_current_target(cmd_ctx
);
2218 watchpoint_t
*watchpoint
= target
->watchpoints
;
2222 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
);
2223 watchpoint
= watchpoint
->next
;
2228 enum watchpoint_rw type
= WPT_ACCESS
;
2229 u32 data_value
= 0x0;
2230 u32 data_mask
= 0xffffffff;
2246 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2252 data_value
= strtoul(args
[3], NULL
, 0);
2256 data_mask
= strtoul(args
[4], NULL
, 0);
2259 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2260 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2264 case ERROR_TARGET_NOT_HALTED
:
2265 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2267 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2268 command_print(cmd_ctx
, "no more watchpoints available");
2271 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2278 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2284 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2286 target_t
*target
= get_current_target(cmd_ctx
);
2289 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2294 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2297 target_t
*target
= get_current_target(cmd_ctx
);
2303 return ERROR_COMMAND_SYNTAX_ERROR
;
2305 va
= strtoul(args
[0], NULL
, 0);
2307 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2308 if (retval
== ERROR_OK
)
2310 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2314 /* lower levels will have logged a detailed error which is
2315 * 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)