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_arch_state_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_target_script_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
83 extern target_type_t arm7tdmi_target
;
84 extern target_type_t arm720t_target
;
85 extern target_type_t arm9tdmi_target
;
86 extern target_type_t arm920t_target
;
87 extern target_type_t arm966e_target
;
88 extern target_type_t arm926ejs_target
;
89 extern target_type_t feroceon_target
;
90 extern target_type_t xscale_target
;
91 extern target_type_t cortexm3_target
;
93 target_type_t
*target_types
[] =
107 target_t
*targets
= NULL
;
108 target_event_callback_t
*target_event_callbacks
= NULL
;
109 target_timer_callback_t
*target_timer_callbacks
= NULL
;
111 char *target_state_strings
[] =
120 char *target_debug_reason_strings
[] =
122 "debug request", "breakpoint", "watchpoint",
123 "watchpoint and breakpoint", "single step",
127 char *target_endianess_strings
[] =
133 enum daemon_startup_mode startup_mode
= DAEMON_ATTACH
;
135 static int target_continous_poll
= 1;
137 /* read a u32 from a buffer in target memory endianness */
138 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
140 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
141 return le_to_h_u32(buffer
);
143 return be_to_h_u32(buffer
);
146 /* read a u16 from a buffer in target memory endianness */
147 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
149 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
150 return le_to_h_u16(buffer
);
152 return be_to_h_u16(buffer
);
155 /* write a u32 to a buffer in target memory endianness */
156 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
158 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
159 h_u32_to_le(buffer
, value
);
161 h_u32_to_be(buffer
, value
);
164 /* write a u16 to a buffer in target memory endianness */
165 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
167 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
168 h_u16_to_le(buffer
, value
);
170 h_u16_to_be(buffer
, value
);
173 /* returns a pointer to the n-th configured target */
174 target_t
* get_target_by_num(int num
)
176 target_t
*target
= targets
;
183 target
= target
->next
;
190 int get_num_by_target(target_t
*query_target
)
192 target_t
*target
= targets
;
197 if (target
== query_target
)
199 target
= target
->next
;
206 target_t
* get_current_target(command_context_t
*cmd_ctx
)
208 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
212 ERROR("BUG: current_target out of bounds");
219 /* Process target initialization, when target entered debug out of reset
220 * the handler is unregistered at the end of this function, so it's only called once
222 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
225 struct command_context_s
*cmd_ctx
= priv
;
227 if ((event
== TARGET_EVENT_HALTED
) && (target
->reset_script
))
229 target_unregister_event_callback(target_init_handler
, priv
);
231 script
= open_file_from_path(cmd_ctx
, target
->reset_script
, "r");
234 ERROR("couldn't open script file %s", target
->reset_script
);
238 INFO("executing reset script '%s'", target
->reset_script
);
239 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
242 jtag_execute_queue();
248 int target_run_and_halt_handler(void *priv
)
250 target_t
*target
= priv
;
252 target
->type
->halt(target
);
257 int target_process_reset(struct command_context_s
*cmd_ctx
)
259 int retval
= ERROR_OK
;
261 struct timeval timeout
, now
;
263 /* prepare reset_halt where necessary */
267 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
269 switch (target
->reset_mode
)
272 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
273 target
->reset_mode
= RESET_RUN_AND_HALT
;
276 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
277 target
->reset_mode
= RESET_RUN_AND_INIT
;
283 switch (target
->reset_mode
)
287 target
->type
->prepare_reset_halt(target
);
292 target
= target
->next
;
298 target
->type
->assert_reset(target
);
299 target
= target
->next
;
301 jtag_execute_queue();
303 /* request target halt if necessary, and schedule further action */
307 switch (target
->reset_mode
)
310 /* nothing to do if target just wants to be run */
312 case RESET_RUN_AND_HALT
:
314 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
316 case RESET_RUN_AND_INIT
:
318 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
319 target_register_event_callback(target_init_handler
, cmd_ctx
);
322 target
->type
->halt(target
);
325 target
->type
->halt(target
);
326 target_register_event_callback(target_init_handler
, cmd_ctx
);
329 ERROR("BUG: unknown target->reset_mode");
331 target
= target
->next
;
337 target
->type
->deassert_reset(target
);
338 target
= target
->next
;
340 jtag_execute_queue();
342 /* Wait for reset to complete, maximum 5 seconds. */
343 gettimeofday(&timeout
, NULL
);
344 timeval_add_time(&timeout
, 5, 0);
347 gettimeofday(&now
, NULL
);
349 target_call_timer_callbacks();
354 target
->type
->poll(target
);
355 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) || (target
->reset_mode
== RESET_RUN_AND_HALT
))
357 if (target
->state
!= TARGET_HALTED
)
359 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
361 command_print(cmd_ctx
, "Timed out waiting for reset");
364 usleep(100*1000); /* Do not eat all cpu */
368 target
= target
->next
;
370 /* All targets we're waiting for are halted */
378 /* We want any events to be processed before the prompt */
379 target_call_timer_callbacks();
384 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
390 static int default_mmu(struct target_s
*target
, int *enabled
)
396 int target_init(struct command_context_s
*cmd_ctx
)
398 target_t
*target
= targets
;
402 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
404 ERROR("target '%s' init failed", target
->type
->name
);
408 /* Set up default functions if none are provided by target */
409 if (target
->type
->virt2phys
== NULL
)
411 target
->type
->virt2phys
= default_virt2phys
;
413 if (target
->type
->mmu
== NULL
)
415 target
->type
->mmu
= default_mmu
;
417 target
= target
->next
;
422 target_register_user_commands(cmd_ctx
);
423 target_register_timer_callback(handle_target
, 100, 1, NULL
);
429 int target_init_reset(struct command_context_s
*cmd_ctx
)
431 if (startup_mode
== DAEMON_RESET
)
432 target_process_reset(cmd_ctx
);
437 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
439 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
441 if (callback
== NULL
)
443 return ERROR_INVALID_ARGUMENTS
;
448 while ((*callbacks_p
)->next
)
449 callbacks_p
= &((*callbacks_p
)->next
);
450 callbacks_p
= &((*callbacks_p
)->next
);
453 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
454 (*callbacks_p
)->callback
= callback
;
455 (*callbacks_p
)->priv
= priv
;
456 (*callbacks_p
)->next
= NULL
;
461 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
463 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
466 if (callback
== NULL
)
468 return ERROR_INVALID_ARGUMENTS
;
473 while ((*callbacks_p
)->next
)
474 callbacks_p
= &((*callbacks_p
)->next
);
475 callbacks_p
= &((*callbacks_p
)->next
);
478 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
479 (*callbacks_p
)->callback
= callback
;
480 (*callbacks_p
)->periodic
= periodic
;
481 (*callbacks_p
)->time_ms
= time_ms
;
483 gettimeofday(&now
, NULL
);
484 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
485 time_ms
-= (time_ms
% 1000);
486 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
487 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
489 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
490 (*callbacks_p
)->when
.tv_sec
+= 1;
493 (*callbacks_p
)->priv
= priv
;
494 (*callbacks_p
)->next
= NULL
;
499 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
501 target_event_callback_t
**p
= &target_event_callbacks
;
502 target_event_callback_t
*c
= target_event_callbacks
;
504 if (callback
== NULL
)
506 return ERROR_INVALID_ARGUMENTS
;
511 target_event_callback_t
*next
= c
->next
;
512 if ((c
->callback
== callback
) && (c
->priv
== priv
))
526 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
528 target_timer_callback_t
**p
= &target_timer_callbacks
;
529 target_timer_callback_t
*c
= target_timer_callbacks
;
531 if (callback
== NULL
)
533 return ERROR_INVALID_ARGUMENTS
;
538 target_timer_callback_t
*next
= c
->next
;
539 if ((c
->callback
== callback
) && (c
->priv
== priv
))
553 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
555 target_event_callback_t
*callback
= target_event_callbacks
;
556 target_event_callback_t
*next_callback
;
558 DEBUG("target event %i", event
);
562 next_callback
= callback
->next
;
563 callback
->callback(target
, event
, callback
->priv
);
564 callback
= next_callback
;
570 int target_call_timer_callbacks()
572 target_timer_callback_t
*callback
= target_timer_callbacks
;
573 target_timer_callback_t
*next_callback
;
576 gettimeofday(&now
, NULL
);
580 next_callback
= callback
->next
;
582 if (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
583 || (now
.tv_sec
> callback
->when
.tv_sec
))
585 callback
->callback(callback
->priv
);
586 if (callback
->periodic
)
588 int time_ms
= callback
->time_ms
;
589 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
590 time_ms
-= (time_ms
% 1000);
591 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
592 if (callback
->when
.tv_usec
> 1000000)
594 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
595 callback
->when
.tv_sec
+= 1;
599 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
602 callback
= next_callback
;
608 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
610 working_area_t
*c
= target
->working_areas
;
611 working_area_t
*new_wa
= NULL
;
613 /* Reevaluate working area address based on MMU state*/
614 if (target
->working_areas
== NULL
)
618 retval
= target
->type
->mmu(target
, &enabled
);
619 if (retval
!= ERROR_OK
)
625 target
->working_area
= target
->working_area_virt
;
629 target
->working_area
= target
->working_area_phys
;
633 /* only allocate multiples of 4 byte */
636 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
637 size
= CEIL(size
, 4);
640 /* see if there's already a matching working area */
643 if ((c
->free
) && (c
->size
== size
))
651 /* if not, allocate a new one */
654 working_area_t
**p
= &target
->working_areas
;
655 u32 first_free
= target
->working_area
;
656 u32 free_size
= target
->working_area_size
;
658 DEBUG("allocating new working area");
660 c
= target
->working_areas
;
663 first_free
+= c
->size
;
664 free_size
-= c
->size
;
669 if (free_size
< size
)
671 WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
672 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
675 new_wa
= malloc(sizeof(working_area_t
));
678 new_wa
->address
= first_free
;
680 if (target
->backup_working_area
)
682 new_wa
->backup
= malloc(new_wa
->size
);
683 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
687 new_wa
->backup
= NULL
;
690 /* put new entry in list */
694 /* mark as used, and return the new (reused) area */
704 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
709 if (target
->backup_working_area
)
710 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
714 /* mark user pointer invalid */
721 int target_free_all_working_areas(struct target_s
*target
)
723 working_area_t
*c
= target
->working_areas
;
727 working_area_t
*next
= c
->next
;
728 target_free_working_area(target
, c
);
738 target
->working_areas
= NULL
;
743 int target_register_commands(struct command_context_s
*cmd_ctx
)
745 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, NULL
);
746 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
747 register_command(cmd_ctx
, NULL
, "daemon_startup", handle_daemon_startup_command
, COMMAND_CONFIG
, NULL
);
748 register_command(cmd_ctx
, NULL
, "target_script", handle_target_script_command
, COMMAND_CONFIG
, NULL
);
749 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, NULL
);
750 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
751 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
752 register_command(cmd_ctx
, NULL
, "arch_state", handle_arch_state_command
, COMMAND_ANY
, "prints CPU state information");
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 command_print(cmd_ctx
, "target state: %s", target_state_strings
[target
->state
]);
1492 if (target
->state
== TARGET_HALTED
)
1494 target_arch_state(target
);
1499 if (strcmp(args
[0], "on") == 0)
1501 target_continous_poll
= 1;
1503 else if (strcmp(args
[0], "off") == 0)
1505 target_continous_poll
= 0;
1509 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1517 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1525 ms
= strtoul(args
[0], &end
, 0) * 1000;
1528 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1533 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1536 static void target_process_events(struct command_context_s
*cmd_ctx
)
1538 target_t
*target
= get_current_target(cmd_ctx
);
1539 target
->type
->poll(target
);
1540 target_call_timer_callbacks();
1543 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1546 struct timeval timeout
, now
;
1548 gettimeofday(&timeout
, NULL
);
1549 timeval_add_time(&timeout
, 0, ms
* 1000);
1550 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1552 target_t
*target
= get_current_target(cmd_ctx
);
1555 if ((retval
=target
->type
->poll(target
))!=ERROR_OK
)
1557 target_call_timer_callbacks();
1558 if (target
->state
== state
)
1560 command_print(cmd_ctx
, "target %s", target_state_strings
[state
]);
1564 gettimeofday(&now
, NULL
);
1565 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1567 command_print(cmd_ctx
, "timed out while waiting for target %s", target_state_strings
[state
]);
1568 ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1576 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1579 target_t
*target
= get_current_target(cmd_ctx
);
1583 command_print(cmd_ctx
, "requesting target halt...");
1585 if ((retval
= target
->type
->halt(target
)) != ERROR_OK
)
1589 case ERROR_TARGET_ALREADY_HALTED
:
1590 command_print(cmd_ctx
, "target already halted");
1592 case ERROR_TARGET_TIMEOUT
:
1593 command_print(cmd_ctx
, "target timed out... shutting down");
1596 command_print(cmd_ctx
, "unknown error... shutting down");
1601 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1604 /* what to do on daemon startup */
1605 int handle_daemon_startup_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1609 if (strcmp(args
[0], "attach") == 0)
1611 startup_mode
= DAEMON_ATTACH
;
1614 else if (strcmp(args
[0], "reset") == 0)
1616 startup_mode
= DAEMON_RESET
;
1621 WARNING("invalid daemon_startup configuration directive: %s", args
[0]);
1626 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1628 target_t
*target
= get_current_target(cmd_ctx
);
1631 command_print(cmd_ctx
, "requesting target halt and executing a soft reset");
1633 if ((retval
= target
->type
->soft_reset_halt(target
)) != ERROR_OK
)
1637 case ERROR_TARGET_TIMEOUT
:
1638 command_print(cmd_ctx
, "target timed out... shutting down");
1641 command_print(cmd_ctx
, "unknown error... shutting down");
1649 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1651 target_t
*target
= get_current_target(cmd_ctx
);
1652 enum target_reset_mode reset_mode
= target
->reset_mode
;
1653 enum target_reset_mode save
= target
->reset_mode
;
1659 if (strcmp("run", args
[0]) == 0)
1660 reset_mode
= RESET_RUN
;
1661 else if (strcmp("halt", args
[0]) == 0)
1662 reset_mode
= RESET_HALT
;
1663 else if (strcmp("init", args
[0]) == 0)
1664 reset_mode
= RESET_INIT
;
1665 else if (strcmp("run_and_halt", args
[0]) == 0)
1667 reset_mode
= RESET_RUN_AND_HALT
;
1670 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1673 else if (strcmp("run_and_init", args
[0]) == 0)
1675 reset_mode
= RESET_RUN_AND_INIT
;
1678 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1683 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1688 /* temporarily modify mode of current reset target */
1689 target
->reset_mode
= reset_mode
;
1691 /* reset *all* targets */
1692 target_process_reset(cmd_ctx
);
1694 /* Restore default reset mode for this target */
1695 target
->reset_mode
= save
;
1700 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1703 target_t
*target
= get_current_target(cmd_ctx
);
1708 retval
= target
->type
->resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1710 retval
= target
->type
->resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1713 command_print(cmd_ctx
, "usage: resume [address]");
1717 if (retval
!= ERROR_OK
)
1721 case ERROR_TARGET_NOT_HALTED
:
1722 command_print(cmd_ctx
, "target not halted");
1725 command_print(cmd_ctx
, "unknown error... shutting down");
1730 target_process_events(cmd_ctx
);
1735 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1737 target_t
*target
= get_current_target(cmd_ctx
);
1742 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1745 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1750 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1752 const int line_bytecnt
= 32;
1765 target_t
*target
= get_current_target(cmd_ctx
);
1771 count
= strtoul(args
[1], NULL
, 0);
1773 address
= strtoul(args
[0], NULL
, 0);
1779 size
= 4; line_modulo
= line_bytecnt
/ 4;
1782 size
= 2; line_modulo
= line_bytecnt
/ 2;
1785 size
= 1; line_modulo
= line_bytecnt
/ 1;
1791 buffer
= calloc(count
, size
);
1792 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1793 if (retval
!= ERROR_OK
)
1797 case ERROR_TARGET_UNALIGNED_ACCESS
:
1798 command_print(cmd_ctx
, "error: address not aligned");
1800 case ERROR_TARGET_NOT_HALTED
:
1801 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1803 case ERROR_TARGET_DATA_ABORT
:
1804 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1807 command_print(cmd_ctx
, "error: unknown error");
1815 for (i
= 0; i
< count
; i
++)
1817 if (i
%line_modulo
== 0)
1818 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1823 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1826 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1829 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1833 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1835 command_print(cmd_ctx
, output
);
1845 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1850 target_t
*target
= get_current_target(cmd_ctx
);
1856 address
= strtoul(args
[0], NULL
, 0);
1857 value
= strtoul(args
[1], NULL
, 0);
1862 target_buffer_set_u32(target
, value_buf
, value
);
1863 retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
);
1866 target_buffer_set_u16(target
, value_buf
, value
);
1867 retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
);
1870 value_buf
[0] = value
;
1871 retval
= target
->type
->write_memory(target
, address
, 1, 1, value_buf
);
1879 case ERROR_TARGET_UNALIGNED_ACCESS
:
1880 command_print(cmd_ctx
, "error: address not aligned");
1882 case ERROR_TARGET_DATA_ABORT
:
1883 command_print(cmd_ctx
, "error: access caused data abort, system possibly corrupted");
1885 case ERROR_TARGET_NOT_HALTED
:
1886 command_print(cmd_ctx
, "error: target must be halted for memory accesses");
1891 command_print(cmd_ctx
, "error: unknown error");
1899 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1909 duration_t duration
;
1910 char *duration_text
;
1912 target_t
*target
= get_current_target(cmd_ctx
);
1916 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
1920 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1923 image
.base_address_set
= 1;
1924 image
.base_address
= strtoul(args
[1], NULL
, 0);
1928 image
.base_address_set
= 0;
1931 image
.start_address_set
= 0;
1933 duration_start_measure(&duration
);
1935 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
1937 command_print(cmd_ctx
, "load_image error: %s", image
.error_str
);
1942 for (i
= 0; i
< image
.num_sections
; i
++)
1944 buffer
= malloc(image
.sections
[i
].size
);
1947 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
1951 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
1953 ERROR("image_read_section failed with error code: %i", retval
);
1954 command_print(cmd_ctx
, "image reading failed, download aborted");
1956 image_close(&image
);
1959 target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
);
1960 image_size
+= buf_cnt
;
1961 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
1966 duration_stop_measure(&duration
, &duration_text
);
1967 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
1968 free(duration_text
);
1970 image_close(&image
);
1976 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1985 duration_t duration
;
1986 char *duration_text
;
1988 target_t
*target
= get_current_target(cmd_ctx
);
1992 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
1996 address
= strtoul(args
[1], NULL
, 0);
1997 size
= strtoul(args
[2], NULL
, 0);
1999 if ((address
& 3) || (size
& 3))
2001 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2005 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2007 command_print(cmd_ctx
, "dump_image error: %s", fileio
.error_str
);
2011 duration_start_measure(&duration
);
2016 u32 this_run_size
= (size
> 560) ? 560 : size
;
2018 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2019 if (retval
!= ERROR_OK
)
2021 command_print(cmd_ctx
, "Reading memory failed %d", retval
);
2025 fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2027 size
-= this_run_size
;
2028 address
+= this_run_size
;
2031 fileio_close(&fileio
);
2033 duration_stop_measure(&duration
, &duration_text
);
2034 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2035 free(duration_text
);
2040 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2048 u32 mem_checksum
= 0;
2052 duration_t duration
;
2053 char *duration_text
;
2055 target_t
*target
= get_current_target(cmd_ctx
);
2059 command_print(cmd_ctx
, "usage: verify_image <file> [offset] [type]");
2065 ERROR("no target selected");
2069 duration_start_measure(&duration
);
2073 image
.base_address_set
= 1;
2074 image
.base_address
= strtoul(args
[1], NULL
, 0);
2078 image
.base_address_set
= 0;
2079 image
.base_address
= 0x0;
2082 image
.start_address_set
= 0;
2084 if (image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
) != ERROR_OK
)
2086 command_print(cmd_ctx
, "verify_image error: %s", image
.error_str
);
2091 for (i
= 0; i
< image
.num_sections
; i
++)
2093 buffer
= malloc(image
.sections
[i
].size
);
2096 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2099 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2101 ERROR("image_read_section failed with error code: %i", retval
);
2102 command_print(cmd_ctx
, "image reading failed, verify aborted");
2104 image_close(&image
);
2108 /* calculate checksum of image */
2109 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2111 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2113 if( retval
!= ERROR_OK
)
2115 command_print(cmd_ctx
, "could not calculate checksum, verify aborted");
2117 image_close(&image
);
2121 if( checksum
!= mem_checksum
)
2123 /* failed crc checksum, fall back to a binary compare */
2126 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2128 data
= (u8
*)malloc(buf_cnt
);
2130 /* Can we use 32bit word accesses? */
2132 int count
= buf_cnt
;
2133 if ((count
% 4) == 0)
2138 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2140 if (retval
== ERROR_OK
)
2143 for (t
= 0; t
< buf_cnt
; t
++)
2145 if (data
[t
] != buffer
[t
])
2147 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
]);
2150 image_close(&image
);
2160 image_size
+= buf_cnt
;
2163 duration_stop_measure(&duration
, &duration_text
);
2164 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2165 free(duration_text
);
2167 image_close(&image
);
2172 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2175 target_t
*target
= get_current_target(cmd_ctx
);
2179 breakpoint_t
*breakpoint
= target
->breakpoints
;
2183 if (breakpoint
->type
== BKPT_SOFT
)
2185 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2186 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2191 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2193 breakpoint
= breakpoint
->next
;
2201 length
= strtoul(args
[1], NULL
, 0);
2204 if (strcmp(args
[2], "hw") == 0)
2207 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2211 case ERROR_TARGET_NOT_HALTED
:
2212 command_print(cmd_ctx
, "target must be halted to set breakpoints");
2214 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2215 command_print(cmd_ctx
, "no more breakpoints available");
2218 command_print(cmd_ctx
, "unknown error, breakpoint not set");
2224 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2229 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2235 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2237 target_t
*target
= get_current_target(cmd_ctx
);
2240 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2245 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2247 target_t
*target
= get_current_target(cmd_ctx
);
2252 watchpoint_t
*watchpoint
= target
->watchpoints
;
2256 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
);
2257 watchpoint
= watchpoint
->next
;
2262 enum watchpoint_rw type
= WPT_ACCESS
;
2263 u32 data_value
= 0x0;
2264 u32 data_mask
= 0xffffffff;
2280 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2286 data_value
= strtoul(args
[3], NULL
, 0);
2290 data_mask
= strtoul(args
[4], NULL
, 0);
2293 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2294 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2298 case ERROR_TARGET_NOT_HALTED
:
2299 command_print(cmd_ctx
, "target must be halted to set watchpoints");
2301 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
2302 command_print(cmd_ctx
, "no more watchpoints available");
2305 command_print(cmd_ctx
, "unknown error, watchpoint not set");
2312 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2318 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2320 target_t
*target
= get_current_target(cmd_ctx
);
2323 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2328 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2331 target_t
*target
= get_current_target(cmd_ctx
);
2337 return ERROR_COMMAND_SYNTAX_ERROR
;
2339 va
= strtoul(args
[0], NULL
, 0);
2341 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2342 if (retval
== ERROR_OK
)
2344 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2348 /* lower levels will have logged a detailed error which is
2349 * forwarded to telnet/GDB session.
2354 int handle_arch_state_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2358 return ERROR_COMMAND_SYNTAX_ERROR
;
2360 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
2361 retval
=target_arch_state(target
);
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)