1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
27 #include "replacements.h"
29 #include "target_request.h"
32 #include "configuration.h"
33 #include "binarybuffer.h"
40 #include <sys/types.h>
48 #include <time_support.h>
53 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
55 int handle_target_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_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
);
79 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
80 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
81 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
85 extern target_type_t arm7tdmi_target
;
86 extern target_type_t arm720t_target
;
87 extern target_type_t arm9tdmi_target
;
88 extern target_type_t arm920t_target
;
89 extern target_type_t arm966e_target
;
90 extern target_type_t arm926ejs_target
;
91 extern target_type_t feroceon_target
;
92 extern target_type_t xscale_target
;
93 extern target_type_t cortexm3_target
;
94 extern target_type_t arm11_target
;
96 target_type_t
*target_types
[] =
111 target_t
*targets
= NULL
;
112 target_event_callback_t
*target_event_callbacks
= NULL
;
113 target_timer_callback_t
*target_timer_callbacks
= NULL
;
115 char *target_state_strings
[] =
124 char *target_debug_reason_strings
[] =
126 "debug request", "breakpoint", "watchpoint",
127 "watchpoint and breakpoint", "single step",
128 "target not halted", "undefined"
131 char *target_endianess_strings
[] =
137 static int target_continous_poll
= 1;
139 /* read a u32 from a buffer in target memory endianness */
140 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
142 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
143 return le_to_h_u32(buffer
);
145 return be_to_h_u32(buffer
);
148 /* read a u16 from a buffer in target memory endianness */
149 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
151 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
152 return le_to_h_u16(buffer
);
154 return be_to_h_u16(buffer
);
157 /* write a u32 to a buffer in target memory endianness */
158 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
160 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
161 h_u32_to_le(buffer
, value
);
163 h_u32_to_be(buffer
, value
);
166 /* write a u16 to a buffer in target memory endianness */
167 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
169 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
170 h_u16_to_le(buffer
, value
);
172 h_u16_to_be(buffer
, value
);
175 /* returns a pointer to the n-th configured target */
176 target_t
* get_target_by_num(int num
)
178 target_t
*target
= targets
;
185 target
= target
->next
;
192 int get_num_by_target(target_t
*query_target
)
194 target_t
*target
= targets
;
199 if (target
== query_target
)
201 target
= target
->next
;
208 target_t
* get_current_target(command_context_t
*cmd_ctx
)
210 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
214 LOG_ERROR("BUG: current_target out of bounds");
221 /* Process target initialization, when target entered debug out of reset
222 * the handler is unregistered at the end of this function, so it's only called once
224 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
)
230 target_unregister_event_callback(target_init_handler
, priv
);
231 target_invoke_script(cmd_ctx
, target
, "post_reset");
232 jtag_execute_queue();
238 int target_run_and_halt_handler(void *priv
)
240 target_t
*target
= priv
;
247 int target_poll(struct target_s
*target
)
249 /* We can't poll until after examine */
250 if (!target
->type
->examined
)
252 /* Fail silently lest we pollute the log */
255 return target
->type
->poll(target
);
258 int target_halt(struct target_s
*target
)
260 /* We can't poll until after examine */
261 if (!target
->type
->examined
)
263 LOG_ERROR("Target not examined yet");
266 return target
->type
->halt(target
);
269 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
273 /* We can't poll until after examine */
274 if (!target
->type
->examined
)
276 LOG_ERROR("Target not examined yet");
280 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
281 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
284 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
290 int target_process_reset(struct command_context_s
*cmd_ctx
, enum target_reset_mode reset_mode
)
292 int retval
= ERROR_OK
;
294 struct timeval timeout
, now
;
299 target_invoke_script(cmd_ctx
, target
, "pre_reset");
300 target
= target
->next
;
303 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
306 keep_alive(); /* we might be running on a very slow JTAG clk */
308 /* First time this is executed after launching OpenOCD, it will read out
309 * the type of CPU, etc. and init Embedded ICE registers in host
312 * It will also set up ICE registers in the target.
314 * However, if we assert TRST later, we need to set up the registers again.
316 * For the "reset halt/init" case we must only set up the registers here.
318 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
321 keep_alive(); /* we might be running on a very slow JTAG clk */
326 /* we have no idea what state the target is in, so we
327 * have to drop working areas
329 target_free_all_working_areas_restore(target
, 0);
330 target
->reset_halt
=((reset_mode
==RESET_HALT
)||(reset_mode
==RESET_INIT
));
331 target
->type
->assert_reset(target
);
332 target
= target
->next
;
334 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
336 LOG_WARNING("JTAG communication failed asserting reset.");
340 /* request target halt if necessary, and schedule further action */
347 /* nothing to do if target just wants to be run */
349 case RESET_RUN_AND_HALT
:
351 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
353 case RESET_RUN_AND_INIT
:
355 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
356 target_register_event_callback(target_init_handler
, cmd_ctx
);
359 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
363 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
365 target_register_event_callback(target_init_handler
, cmd_ctx
);
368 LOG_ERROR("BUG: unknown target->reset_mode");
370 target
= target
->next
;
373 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
375 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
382 target
->type
->deassert_reset(target
);
383 /* We can fail to bring the target into the halted state */
385 if (target
->reset_halt
&&((target
->state
!= TARGET_HALTED
)))
387 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
388 target
->type
->halt(target
);
391 target
= target
->next
;
394 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
396 LOG_WARNING("JTAG communication failed while deasserting reset.");
400 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
402 /* If TRST was asserted we need to set up registers again */
403 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
407 LOG_DEBUG("Waiting for halted stated as appropriate");
409 /* Wait for reset to complete, maximum 5 seconds. */
410 gettimeofday(&timeout
, NULL
);
411 timeval_add_time(&timeout
, 5, 0);
414 gettimeofday(&now
, NULL
);
416 target_call_timer_callbacks_now();
421 LOG_DEBUG("Polling target");
423 if ((reset_mode
== RESET_RUN_AND_INIT
) ||
424 (reset_mode
== RESET_RUN_AND_HALT
) ||
425 (reset_mode
== RESET_HALT
) ||
426 (reset_mode
== RESET_INIT
))
428 if (target
->state
!= TARGET_HALTED
)
430 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
432 LOG_USER("Timed out waiting for halt after reset");
435 /* this will send alive messages on e.g. GDB remote protocol. */
437 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
441 target
= target
->next
;
443 /* All targets we're waiting for are halted */
451 /* We want any events to be processed before the prompt */
452 target_call_timer_callbacks_now();
454 /* if we timed out we need to unregister these handlers */
458 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
459 target
= target
->next
;
461 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
466 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
472 static int default_mmu(struct target_s
*target
, int *enabled
)
478 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
480 target
->type
->examined
= 1;
485 /* Targets that correctly implement init+examine, i.e.
486 * no communication with target during init:
490 int target_examine(struct command_context_s
*cmd_ctx
)
492 int retval
= ERROR_OK
;
493 target_t
*target
= targets
;
496 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
498 target
= target
->next
;
503 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
505 if (!target
->type
->examined
)
507 LOG_ERROR("Target not examined yet");
510 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
513 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
515 if (!target
->type
->examined
)
517 LOG_ERROR("Target not examined yet");
520 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
523 static int target_soft_reset_halt_imp(struct target_s
*target
)
525 if (!target
->type
->examined
)
527 LOG_ERROR("Target not examined yet");
530 return target
->type
->soft_reset_halt_imp(target
);
533 static int target_run_algorithm_imp(struct target_s
*target
, int num_mem_params
, mem_param_t
*mem_params
, int num_reg_params
, reg_param_t
*reg_param
, u32 entry_point
, u32 exit_point
, int timeout_ms
, void *arch_info
)
535 if (!target
->type
->examined
)
537 LOG_ERROR("Target not examined yet");
540 return target
->type
->run_algorithm_imp(target
, num_mem_params
, mem_params
, num_reg_params
, reg_param
, entry_point
, exit_point
, timeout_ms
, arch_info
);
543 int target_init(struct command_context_s
*cmd_ctx
)
545 target_t
*target
= targets
;
549 target
->type
->examined
= 0;
550 if (target
->type
->examine
== NULL
)
552 target
->type
->examine
= default_examine
;
555 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
557 LOG_ERROR("target '%s' init failed", target
->type
->name
);
561 /* Set up default functions if none are provided by target */
562 if (target
->type
->virt2phys
== NULL
)
564 target
->type
->virt2phys
= default_virt2phys
;
566 target
->type
->virt2phys
= default_virt2phys
;
567 /* a non-invasive way(in terms of patches) to add some code that
568 * runs before the type->write/read_memory implementation
570 target
->type
->write_memory_imp
= target
->type
->write_memory
;
571 target
->type
->write_memory
= target_write_memory_imp
;
572 target
->type
->read_memory_imp
= target
->type
->read_memory
;
573 target
->type
->read_memory
= target_read_memory_imp
;
574 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
575 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
576 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
577 target
->type
->run_algorithm
= target_run_algorithm_imp
;
580 if (target
->type
->mmu
== NULL
)
582 target
->type
->mmu
= default_mmu
;
584 target
= target
->next
;
589 target_register_user_commands(cmd_ctx
);
590 target_register_timer_callback(handle_target
, 100, 1, NULL
);
596 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
598 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
600 if (callback
== NULL
)
602 return ERROR_INVALID_ARGUMENTS
;
607 while ((*callbacks_p
)->next
)
608 callbacks_p
= &((*callbacks_p
)->next
);
609 callbacks_p
= &((*callbacks_p
)->next
);
612 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
613 (*callbacks_p
)->callback
= callback
;
614 (*callbacks_p
)->priv
= priv
;
615 (*callbacks_p
)->next
= NULL
;
620 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
622 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
625 if (callback
== NULL
)
627 return ERROR_INVALID_ARGUMENTS
;
632 while ((*callbacks_p
)->next
)
633 callbacks_p
= &((*callbacks_p
)->next
);
634 callbacks_p
= &((*callbacks_p
)->next
);
637 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
638 (*callbacks_p
)->callback
= callback
;
639 (*callbacks_p
)->periodic
= periodic
;
640 (*callbacks_p
)->time_ms
= time_ms
;
642 gettimeofday(&now
, NULL
);
643 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
644 time_ms
-= (time_ms
% 1000);
645 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
646 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
648 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
649 (*callbacks_p
)->when
.tv_sec
+= 1;
652 (*callbacks_p
)->priv
= priv
;
653 (*callbacks_p
)->next
= NULL
;
658 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
660 target_event_callback_t
**p
= &target_event_callbacks
;
661 target_event_callback_t
*c
= target_event_callbacks
;
663 if (callback
== NULL
)
665 return ERROR_INVALID_ARGUMENTS
;
670 target_event_callback_t
*next
= c
->next
;
671 if ((c
->callback
== callback
) && (c
->priv
== priv
))
685 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
687 target_timer_callback_t
**p
= &target_timer_callbacks
;
688 target_timer_callback_t
*c
= target_timer_callbacks
;
690 if (callback
== NULL
)
692 return ERROR_INVALID_ARGUMENTS
;
697 target_timer_callback_t
*next
= c
->next
;
698 if ((c
->callback
== callback
) && (c
->priv
== priv
))
712 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
714 target_event_callback_t
*callback
= target_event_callbacks
;
715 target_event_callback_t
*next_callback
;
717 LOG_DEBUG("target event %i", event
);
721 next_callback
= callback
->next
;
722 callback
->callback(target
, event
, callback
->priv
);
723 callback
= next_callback
;
729 static int target_call_timer_callbacks_check_time(int checktime
)
731 target_timer_callback_t
*callback
= target_timer_callbacks
;
732 target_timer_callback_t
*next_callback
;
737 gettimeofday(&now
, NULL
);
741 next_callback
= callback
->next
;
743 if ((!checktime
&&callback
->periodic
)||
744 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
745 || (now
.tv_sec
> callback
->when
.tv_sec
)))
747 if(callback
->callback
!= NULL
)
749 callback
->callback(callback
->priv
);
750 if (callback
->periodic
)
752 int time_ms
= callback
->time_ms
;
753 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
754 time_ms
-= (time_ms
% 1000);
755 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
756 if (callback
->when
.tv_usec
> 1000000)
758 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
759 callback
->when
.tv_sec
+= 1;
763 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
767 callback
= next_callback
;
773 int target_call_timer_callbacks()
775 return target_call_timer_callbacks_check_time(1);
778 /* invoke periodic callbacks immediately */
779 int target_call_timer_callbacks_now()
781 return target_call_timer_callbacks(0);
784 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
786 working_area_t
*c
= target
->working_areas
;
787 working_area_t
*new_wa
= NULL
;
789 /* Reevaluate working area address based on MMU state*/
790 if (target
->working_areas
== NULL
)
794 retval
= target
->type
->mmu(target
, &enabled
);
795 if (retval
!= ERROR_OK
)
801 target
->working_area
= target
->working_area_virt
;
805 target
->working_area
= target
->working_area_phys
;
809 /* only allocate multiples of 4 byte */
812 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
813 size
= CEIL(size
, 4);
816 /* see if there's already a matching working area */
819 if ((c
->free
) && (c
->size
== size
))
827 /* if not, allocate a new one */
830 working_area_t
**p
= &target
->working_areas
;
831 u32 first_free
= target
->working_area
;
832 u32 free_size
= target
->working_area_size
;
834 LOG_DEBUG("allocating new working area");
836 c
= target
->working_areas
;
839 first_free
+= c
->size
;
840 free_size
-= c
->size
;
845 if (free_size
< size
)
847 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
848 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
851 new_wa
= malloc(sizeof(working_area_t
));
854 new_wa
->address
= first_free
;
856 if (target
->backup_working_area
)
858 new_wa
->backup
= malloc(new_wa
->size
);
859 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
863 new_wa
->backup
= NULL
;
866 /* put new entry in list */
870 /* mark as used, and return the new (reused) area */
880 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
885 if (restore
&&target
->backup_working_area
)
886 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
890 /* mark user pointer invalid */
897 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
899 return target_free_working_area_restore(target
, area
, 1);
902 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
904 working_area_t
*c
= target
->working_areas
;
908 working_area_t
*next
= c
->next
;
909 target_free_working_area_restore(target
, c
, restore
);
919 target
->working_areas
= NULL
;
924 int target_free_all_working_areas(struct target_s
*target
)
926 return target_free_all_working_areas_restore(target
, 1);
929 int target_register_commands(struct command_context_s
*cmd_ctx
)
931 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
932 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
933 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
934 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
935 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
936 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
939 /* script procedures */
940 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
941 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
945 int target_arch_state(struct target_s
*target
)
950 LOG_USER("No target has been configured");
954 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
956 if (target
->state
!=TARGET_HALTED
)
959 retval
=target
->type
->arch_state(target
);
963 /* Single aligned words are guaranteed to use 16 or 32 bit access
964 * mode respectively, otherwise data is handled as quickly as
967 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
970 if (!target
->type
->examined
)
972 LOG_ERROR("Target not examined yet");
976 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
978 if (((address
% 2) == 0) && (size
== 2))
980 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
983 /* handle unaligned head bytes */
986 int unaligned
= 4 - (address
% 4);
988 if (unaligned
> size
)
991 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
995 address
+= unaligned
;
999 /* handle aligned words */
1002 int aligned
= size
- (size
% 4);
1004 /* use bulk writes above a certain limit. This may have to be changed */
1007 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1012 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1021 /* handle tail writes of less than 4 bytes */
1024 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1032 /* Single aligned words are guaranteed to use 16 or 32 bit access
1033 * mode respectively, otherwise data is handled as quickly as
1036 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1039 if (!target
->type
->examined
)
1041 LOG_ERROR("Target not examined yet");
1045 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1047 if (((address
% 2) == 0) && (size
== 2))
1049 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1052 /* handle unaligned head bytes */
1055 int unaligned
= 4 - (address
% 4);
1057 if (unaligned
> size
)
1060 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1063 buffer
+= unaligned
;
1064 address
+= unaligned
;
1068 /* handle aligned words */
1071 int aligned
= size
- (size
% 4);
1073 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1081 /* handle tail writes of less than 4 bytes */
1084 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1091 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1097 if (!target
->type
->examined
)
1099 LOG_ERROR("Target not examined yet");
1103 if ((retval
= target
->type
->checksum_memory(target
, address
,
1104 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1106 buffer
= malloc(size
);
1109 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1110 return ERROR_INVALID_ARGUMENTS
;
1112 retval
= target_read_buffer(target
, address
, size
, buffer
);
1113 if (retval
!= ERROR_OK
)
1119 /* convert to target endianess */
1120 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1123 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1124 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1127 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1136 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1139 if (!target
->type
->examined
)
1141 LOG_ERROR("Target not examined yet");
1145 if (target
->type
->blank_check_memory
== 0)
1146 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1148 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1153 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1156 if (!target
->type
->examined
)
1158 LOG_ERROR("Target not examined yet");
1162 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1164 if (retval
== ERROR_OK
)
1166 *value
= target_buffer_get_u32(target
, value_buf
);
1167 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1172 LOG_DEBUG("address: 0x%8.8x failed", address
);
1178 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1181 if (!target
->type
->examined
)
1183 LOG_ERROR("Target not examined yet");
1187 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1189 if (retval
== ERROR_OK
)
1191 *value
= target_buffer_get_u16(target
, value_buf
);
1192 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1197 LOG_DEBUG("address: 0x%8.8x failed", address
);
1203 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1205 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1206 if (!target
->type
->examined
)
1208 LOG_ERROR("Target not examined yet");
1212 if (retval
== ERROR_OK
)
1214 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1219 LOG_DEBUG("address: 0x%8.8x failed", address
);
1225 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1229 if (!target
->type
->examined
)
1231 LOG_ERROR("Target not examined yet");
1235 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1237 target_buffer_set_u32(target
, value_buf
, value
);
1238 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1240 LOG_DEBUG("failed: %i", retval
);
1246 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1250 if (!target
->type
->examined
)
1252 LOG_ERROR("Target not examined yet");
1256 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1258 target_buffer_set_u16(target
, value_buf
, value
);
1259 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1261 LOG_DEBUG("failed: %i", retval
);
1267 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1270 if (!target
->type
->examined
)
1272 LOG_ERROR("Target not examined yet");
1276 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1278 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1280 LOG_DEBUG("failed: %i", retval
);
1286 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1288 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1289 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1290 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1291 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1292 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1293 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1294 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1295 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1297 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1298 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1299 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1301 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1302 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1303 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1305 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1306 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1307 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1308 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1310 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
1311 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1312 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1314 target_request_register_commands(cmd_ctx
);
1315 trace_register_commands(cmd_ctx
);
1320 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1322 target_t
*target
= targets
;
1327 int num
= strtoul(args
[0], NULL
, 0);
1332 target
= target
->next
;
1336 cmd_ctx
->current_target
= num
;
1338 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1345 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1346 target
= target
->next
;
1352 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1359 return ERROR_COMMAND_SYNTAX_ERROR
;
1362 /* search for the specified target */
1363 if (args
[0] && (args
[0][0] != 0))
1365 for (i
= 0; target_types
[i
]; i
++)
1367 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1369 target_t
**last_target_p
= &targets
;
1371 /* register target specific commands */
1372 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1374 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1380 while ((*last_target_p
)->next
)
1381 last_target_p
= &((*last_target_p
)->next
);
1382 last_target_p
= &((*last_target_p
)->next
);
1385 *last_target_p
= malloc(sizeof(target_t
));
1387 /* allocate memory for each unique target type */
1388 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1389 *((*last_target_p
)->type
) = *target_types
[i
];
1391 if (strcmp(args
[1], "big") == 0)
1392 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1393 else if (strcmp(args
[1], "little") == 0)
1394 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1397 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1398 return ERROR_COMMAND_SYNTAX_ERROR
;
1401 if (strcmp(args
[2], "reset_halt") == 0)
1403 LOG_WARNING("reset_mode argument is obsolete.");
1404 return ERROR_COMMAND_SYNTAX_ERROR
;
1406 else if (strcmp(args
[2], "reset_run") == 0)
1408 LOG_WARNING("reset_mode argument is obsolete.");
1409 return ERROR_COMMAND_SYNTAX_ERROR
;
1411 else if (strcmp(args
[2], "reset_init") == 0)
1413 LOG_WARNING("reset_mode argument is obsolete.");
1414 return ERROR_COMMAND_SYNTAX_ERROR
;
1416 else if (strcmp(args
[2], "run_and_halt") == 0)
1418 LOG_WARNING("reset_mode argument is obsolete.");
1419 return ERROR_COMMAND_SYNTAX_ERROR
;
1421 else if (strcmp(args
[2], "run_and_init") == 0)
1423 LOG_WARNING("reset_mode argument is obsolete.");
1424 return ERROR_COMMAND_SYNTAX_ERROR
;
1428 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1432 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1434 (*last_target_p
)->working_area
= 0x0;
1435 (*last_target_p
)->working_area_size
= 0x0;
1436 (*last_target_p
)->working_areas
= NULL
;
1437 (*last_target_p
)->backup_working_area
= 0;
1439 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1440 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1441 (*last_target_p
)->reg_cache
= NULL
;
1442 (*last_target_p
)->breakpoints
= NULL
;
1443 (*last_target_p
)->watchpoints
= NULL
;
1444 (*last_target_p
)->next
= NULL
;
1445 (*last_target_p
)->arch_info
= NULL
;
1447 /* initialize trace information */
1448 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1449 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1450 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1451 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1452 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1453 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1454 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1455 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1457 (*last_target_p
)->dbgmsg
= NULL
;
1458 (*last_target_p
)->dbg_msg_enabled
= 0;
1460 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1468 /* no matching target found */
1471 LOG_ERROR("target '%s' not found", args
[0]);
1472 return ERROR_COMMAND_SYNTAX_ERROR
;
1478 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1480 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
1481 get_num_by_target(target
), name
,
1482 get_num_by_target(target
), name
);
1485 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1487 target_t
*target
= NULL
;
1491 return ERROR_COMMAND_SYNTAX_ERROR
;
1494 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1497 return ERROR_COMMAND_SYNTAX_ERROR
;
1500 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1505 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1507 target_t
*target
= NULL
;
1509 if ((argc
< 4) || (argc
> 5))
1511 return ERROR_COMMAND_SYNTAX_ERROR
;
1514 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1517 return ERROR_COMMAND_SYNTAX_ERROR
;
1519 target_free_all_working_areas(target
);
1521 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1524 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1526 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1528 if (strcmp(args
[3], "backup") == 0)
1530 target
->backup_working_area
= 1;
1532 else if (strcmp(args
[3], "nobackup") == 0)
1534 target
->backup_working_area
= 0;
1538 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1539 return ERROR_COMMAND_SYNTAX_ERROR
;
1546 /* process target state changes */
1547 int handle_target(void *priv
)
1549 target_t
*target
= targets
;
1553 if (target_continous_poll
)
1555 /* polling may fail silently until the target has been examined */
1556 target_poll(target
);
1559 target
= target
->next
;
1565 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1574 target
= get_current_target(cmd_ctx
);
1576 /* list all available registers for the current target */
1579 reg_cache_t
*cache
= target
->reg_cache
;
1585 for (i
= 0; i
< cache
->num_regs
; i
++)
1587 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1588 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
);
1591 cache
= cache
->next
;
1597 /* access a single register by its ordinal number */
1598 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1600 int num
= strtoul(args
[0], NULL
, 0);
1601 reg_cache_t
*cache
= target
->reg_cache
;
1607 for (i
= 0; i
< cache
->num_regs
; i
++)
1611 reg
= &cache
->reg_list
[i
];
1617 cache
= cache
->next
;
1622 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1625 } else /* access a single register by its name */
1627 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1631 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1636 /* display a register */
1637 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1639 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1642 if (reg
->valid
== 0)
1644 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1645 if (arch_type
== NULL
)
1647 LOG_ERROR("BUG: encountered unregistered arch type");
1650 arch_type
->get(reg
);
1652 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1653 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1658 /* set register value */
1661 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1662 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1664 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1665 if (arch_type
== NULL
)
1667 LOG_ERROR("BUG: encountered unregistered arch type");
1671 arch_type
->set(reg
, buf
);
1673 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1674 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1682 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1688 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1690 target_t
*target
= get_current_target(cmd_ctx
);
1694 target_poll(target
);
1695 target_arch_state(target
);
1699 if (strcmp(args
[0], "on") == 0)
1701 target_continous_poll
= 1;
1703 else if (strcmp(args
[0], "off") == 0)
1705 target_continous_poll
= 0;
1709 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1717 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1725 ms
= strtoul(args
[0], &end
, 0) * 1000;
1728 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1732 target_t
*target
= get_current_target(cmd_ctx
);
1734 return target_wait_state(target
, TARGET_HALTED
, ms
);
1737 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1740 struct timeval timeout
, now
;
1742 gettimeofday(&timeout
, NULL
);
1743 timeval_add_time(&timeout
, 0, ms
* 1000);
1747 if ((retval
=target_poll(target
))!=ERROR_OK
)
1749 target_call_timer_callbacks_now();
1750 if (target
->state
== state
)
1757 LOG_USER("waiting for target %s...", target_state_strings
[state
]);
1760 gettimeofday(&now
, NULL
);
1761 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1763 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1771 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1774 target_t
*target
= get_current_target(cmd_ctx
);
1778 if ((retval
= target_halt(target
)) != ERROR_OK
)
1783 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1786 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1788 target_t
*target
= get_current_target(cmd_ctx
);
1790 LOG_USER("requesting target halt and executing a soft reset");
1792 target
->type
->soft_reset_halt(target
);
1797 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1799 target_t
*target
= get_current_target(cmd_ctx
);
1800 enum target_reset_mode reset_mode
= RESET_RUN
;
1806 if (strcmp("run", args
[0]) == 0)
1807 reset_mode
= RESET_RUN
;
1808 else if (strcmp("halt", args
[0]) == 0)
1809 reset_mode
= RESET_HALT
;
1810 else if (strcmp("init", args
[0]) == 0)
1811 reset_mode
= RESET_INIT
;
1812 else if (strcmp("run_and_halt", args
[0]) == 0)
1814 reset_mode
= RESET_RUN_AND_HALT
;
1817 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1820 else if (strcmp("run_and_init", args
[0]) == 0)
1822 reset_mode
= RESET_RUN_AND_INIT
;
1825 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1830 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1835 /* reset *all* targets */
1836 target_process_reset(cmd_ctx
, reset_mode
);
1841 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1844 target_t
*target
= get_current_target(cmd_ctx
);
1846 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1849 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1851 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1854 return ERROR_COMMAND_SYNTAX_ERROR
;
1860 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1862 target_t
*target
= get_current_target(cmd_ctx
);
1867 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1870 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1875 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1877 const int line_bytecnt
= 32;
1890 target_t
*target
= get_current_target(cmd_ctx
);
1896 count
= strtoul(args
[1], NULL
, 0);
1898 address
= strtoul(args
[0], NULL
, 0);
1904 size
= 4; line_modulo
= line_bytecnt
/ 4;
1907 size
= 2; line_modulo
= line_bytecnt
/ 2;
1910 size
= 1; line_modulo
= line_bytecnt
/ 1;
1916 buffer
= calloc(count
, size
);
1917 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1918 if (retval
== ERROR_OK
)
1922 for (i
= 0; i
< count
; i
++)
1924 if (i
%line_modulo
== 0)
1925 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1930 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1933 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1936 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1940 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1942 command_print(cmd_ctx
, output
);
1953 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1960 target_t
*target
= get_current_target(cmd_ctx
);
1963 if ((argc
< 2) || (argc
> 3))
1964 return ERROR_COMMAND_SYNTAX_ERROR
;
1966 address
= strtoul(args
[0], NULL
, 0);
1967 value
= strtoul(args
[1], NULL
, 0);
1969 count
= strtoul(args
[2], NULL
, 0);
1975 target_buffer_set_u32(target
, value_buf
, value
);
1979 target_buffer_set_u16(target
, value_buf
, value
);
1983 value_buf
[0] = value
;
1986 return ERROR_COMMAND_SYNTAX_ERROR
;
1988 for (i
=0; i
<count
; i
++)
1994 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1997 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2000 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2005 if (retval
!=ERROR_OK
)
2015 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2021 u32 max_address
=0xffffffff;
2027 duration_t duration
;
2028 char *duration_text
;
2030 target_t
*target
= get_current_target(cmd_ctx
);
2032 if ((argc
< 1)||(argc
> 5))
2034 return ERROR_COMMAND_SYNTAX_ERROR
;
2037 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2040 image
.base_address_set
= 1;
2041 image
.base_address
= strtoul(args
[1], NULL
, 0);
2045 image
.base_address_set
= 0;
2049 image
.start_address_set
= 0;
2053 min_address
=strtoul(args
[3], NULL
, 0);
2057 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
2060 if (min_address
>max_address
)
2062 return ERROR_COMMAND_SYNTAX_ERROR
;
2066 duration_start_measure(&duration
);
2068 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2075 for (i
= 0; i
< image
.num_sections
; i
++)
2077 buffer
= malloc(image
.sections
[i
].size
);
2080 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2084 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2094 /* DANGER!!! beware of unsigned comparision here!!! */
2096 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
2097 (image
.sections
[i
].base_address
<max_address
))
2099 if (image
.sections
[i
].base_address
<min_address
)
2101 /* clip addresses below */
2102 offset
+=min_address
-image
.sections
[i
].base_address
;
2106 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
2108 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2111 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2116 image_size
+= length
;
2117 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2123 duration_stop_measure(&duration
, &duration_text
);
2124 if (retval
==ERROR_OK
)
2126 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2128 free(duration_text
);
2130 image_close(&image
);
2136 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2143 int retval
=ERROR_OK
;
2145 duration_t duration
;
2146 char *duration_text
;
2148 target_t
*target
= get_current_target(cmd_ctx
);
2152 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2156 address
= strtoul(args
[1], NULL
, 0);
2157 size
= strtoul(args
[2], NULL
, 0);
2159 if ((address
& 3) || (size
& 3))
2161 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2165 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2170 duration_start_measure(&duration
);
2175 u32 this_run_size
= (size
> 560) ? 560 : size
;
2177 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2178 if (retval
!= ERROR_OK
)
2183 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2184 if (retval
!= ERROR_OK
)
2189 size
-= this_run_size
;
2190 address
+= this_run_size
;
2193 fileio_close(&fileio
);
2195 duration_stop_measure(&duration
, &duration_text
);
2196 if (retval
==ERROR_OK
)
2198 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2200 free(duration_text
);
2205 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2213 u32 mem_checksum
= 0;
2217 duration_t duration
;
2218 char *duration_text
;
2220 target_t
*target
= get_current_target(cmd_ctx
);
2224 return ERROR_COMMAND_SYNTAX_ERROR
;
2229 LOG_ERROR("no target selected");
2233 duration_start_measure(&duration
);
2237 image
.base_address_set
= 1;
2238 image
.base_address
= strtoul(args
[1], NULL
, 0);
2242 image
.base_address_set
= 0;
2243 image
.base_address
= 0x0;
2246 image
.start_address_set
= 0;
2248 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2255 for (i
= 0; i
< image
.num_sections
; i
++)
2257 buffer
= malloc(image
.sections
[i
].size
);
2260 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2263 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2269 /* calculate checksum of image */
2270 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2272 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2273 if( retval
!= ERROR_OK
)
2279 if( checksum
!= mem_checksum
)
2281 /* failed crc checksum, fall back to a binary compare */
2284 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2286 data
= (u8
*)malloc(buf_cnt
);
2288 /* Can we use 32bit word accesses? */
2290 int count
= buf_cnt
;
2291 if ((count
% 4) == 0)
2296 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2297 if (retval
== ERROR_OK
)
2300 for (t
= 0; t
< buf_cnt
; t
++)
2302 if (data
[t
] != buffer
[t
])
2304 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
]);
2317 image_size
+= buf_cnt
;
2320 duration_stop_measure(&duration
, &duration_text
);
2321 if (retval
==ERROR_OK
)
2323 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2325 free(duration_text
);
2327 image_close(&image
);
2332 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2335 target_t
*target
= get_current_target(cmd_ctx
);
2339 breakpoint_t
*breakpoint
= target
->breakpoints
;
2343 if (breakpoint
->type
== BKPT_SOFT
)
2345 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2346 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2351 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2353 breakpoint
= breakpoint
->next
;
2361 length
= strtoul(args
[1], NULL
, 0);
2364 if (strcmp(args
[2], "hw") == 0)
2367 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2369 LOG_ERROR("Failure setting breakpoints");
2373 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2378 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2384 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2386 target_t
*target
= get_current_target(cmd_ctx
);
2389 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2394 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2396 target_t
*target
= get_current_target(cmd_ctx
);
2401 watchpoint_t
*watchpoint
= target
->watchpoints
;
2405 command_print(cmd_ctx
, "address: 0x%8.8x, len: 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
);
2406 watchpoint
= watchpoint
->next
;
2411 enum watchpoint_rw type
= WPT_ACCESS
;
2412 u32 data_value
= 0x0;
2413 u32 data_mask
= 0xffffffff;
2429 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2435 data_value
= strtoul(args
[3], NULL
, 0);
2439 data_mask
= strtoul(args
[4], NULL
, 0);
2442 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2443 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2445 LOG_ERROR("Failure setting breakpoints");
2450 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2456 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2458 target_t
*target
= get_current_target(cmd_ctx
);
2461 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2466 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2469 target_t
*target
= get_current_target(cmd_ctx
);
2475 return ERROR_COMMAND_SYNTAX_ERROR
;
2477 va
= strtoul(args
[0], NULL
, 0);
2479 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2480 if (retval
== ERROR_OK
)
2482 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2486 /* lower levels will have logged a detailed error which is
2487 * forwarded to telnet/GDB session.
2492 static void writeLong(FILE *f
, int l
)
2497 char c
=(l
>>(i
*8))&0xff;
2498 fwrite(&c
, 1, 1, f
);
2502 static void writeString(FILE *f
, char *s
)
2504 fwrite(s
, 1, strlen(s
), f
);
2509 // Dump a gmon.out histogram file.
2510 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2513 FILE *f
=fopen(filename
, "w");
2516 fwrite("gmon", 1, 4, f
);
2517 writeLong(f
, 0x00000001); // Version
2518 writeLong(f
, 0); // padding
2519 writeLong(f
, 0); // padding
2520 writeLong(f
, 0); // padding
2522 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2524 // figure out bucket size
2527 for (i
=0; i
<sampleNum
; i
++)
2539 int addressSpace
=(max
-min
+1);
2541 static int const maxBuckets
=256*1024; // maximum buckets.
2542 int length
=addressSpace
;
2543 if (length
> maxBuckets
)
2547 int *buckets
=malloc(sizeof(int)*length
);
2553 memset(buckets
, 0, sizeof(int)*length
);
2554 for (i
=0; i
<sampleNum
;i
++)
2556 u32 address
=samples
[i
];
2557 long long a
=address
-min
;
2558 long long b
=length
-1;
2559 long long c
=addressSpace
-1;
2560 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2564 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2565 writeLong(f
, min
); // low_pc
2566 writeLong(f
, max
); // high_pc
2567 writeLong(f
, length
); // # of samples
2568 writeLong(f
, 64000000); // 64MHz
2569 writeString(f
, "seconds");
2570 for (i
=0; i
<(15-strlen("seconds")); i
++)
2572 fwrite("", 1, 1, f
); // padding
2574 writeString(f
, "s");
2576 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2578 char *data
=malloc(2*length
);
2581 for (i
=0; i
<length
;i
++)
2590 data
[i
*2+1]=(val
>>8)&0xff;
2593 fwrite(data
, 1, length
*2, f
);
2603 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2604 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2606 target_t
*target
= get_current_target(cmd_ctx
);
2607 struct timeval timeout
, now
;
2609 gettimeofday(&timeout
, NULL
);
2612 return ERROR_COMMAND_SYNTAX_ERROR
;
2615 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2621 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2623 static const int maxSample
=10000;
2624 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2629 int retval
=ERROR_OK
;
2630 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2631 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2635 target_poll(target
);
2636 if (target
->state
== TARGET_HALTED
)
2638 u32 t
=*((u32
*)reg
->value
);
2639 samples
[numSamples
++]=t
;
2640 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2641 target_poll(target
);
2642 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2643 } else if (target
->state
== TARGET_RUNNING
)
2645 // We want to quickly sample the PC.
2646 target_halt(target
);
2649 command_print(cmd_ctx
, "Target not halted or running");
2653 if (retval
!=ERROR_OK
)
2658 gettimeofday(&now
, NULL
);
2659 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2661 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2662 target_poll(target
);
2663 if (target
->state
== TARGET_HALTED
)
2665 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2667 target_poll(target
);
2668 writeGmon(samples
, numSamples
, args
[1]);
2669 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2678 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2681 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2684 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2688 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2689 valObjPtr
= Jim_NewIntObj(interp
, val
);
2690 if (!nameObjPtr
|| !valObjPtr
)
2696 Jim_IncrRefCount(nameObjPtr
);
2697 Jim_IncrRefCount(valObjPtr
);
2698 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2699 Jim_DecrRefCount(interp
, nameObjPtr
);
2700 Jim_DecrRefCount(interp
, valObjPtr
);
2702 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2706 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2709 command_context_t
*context
;
2716 const char *varname
;
2718 int i
, n
, e
, retval
;
2720 /* argv[1] = name of array to receive the data
2721 * argv[2] = desired width
2722 * argv[3] = memory address
2723 * argv[4] = count of times to read
2726 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2729 varname
= Jim_GetString(argv
[1], &len
);
2730 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2732 e
= Jim_GetLong(interp
, argv
[2], &l
);
2738 e
= Jim_GetLong(interp
, argv
[3], &l
);
2743 e
= Jim_GetLong(interp
, argv
[4], &l
);
2759 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2760 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2764 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2765 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2768 if ((addr
+ (len
* width
)) < addr
) {
2769 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2770 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2773 /* absurd transfer size? */
2775 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2776 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2781 ((width
== 2) && ((addr
& 1) == 0)) ||
2782 ((width
== 4) && ((addr
& 3) == 0))) {
2786 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2787 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2788 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2792 context
= Jim_GetAssocData(interp
, "context");
2793 if (context
== NULL
)
2795 LOG_ERROR("mem2array: no command context");
2798 target
= get_current_target(context
);
2801 LOG_ERROR("mem2array: no current target");
2812 /* Slurp... in buffer size chunks */
2814 count
= len
; /* in objects.. */
2815 if (count
> (sizeof(buffer
)/width
)) {
2816 count
= (sizeof(buffer
)/width
);
2819 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2820 if (retval
!= ERROR_OK
) {
2822 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2823 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2824 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2828 v
= 0; /* shut up gcc */
2829 for (i
= 0 ;i
< count
;i
++, n
++) {
2832 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2835 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2838 v
= buffer
[i
] & 0x0ff;
2841 new_int_array_element(interp
, varname
, n
, v
);
2847 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2852 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2855 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2859 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2863 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2870 Jim_IncrRefCount(nameObjPtr
);
2871 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2872 Jim_DecrRefCount(interp
, nameObjPtr
);
2874 if (valObjPtr
== NULL
)
2877 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2878 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2883 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2886 command_context_t
*context
;
2893 const char *varname
;
2895 int i
, n
, e
, retval
;
2897 /* argv[1] = name of array to get the data
2898 * argv[2] = desired width
2899 * argv[3] = memory address
2900 * argv[4] = count to write
2903 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2906 varname
= Jim_GetString(argv
[1], &len
);
2907 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2909 e
= Jim_GetLong(interp
, argv
[2], &l
);
2915 e
= Jim_GetLong(interp
, argv
[3], &l
);
2920 e
= Jim_GetLong(interp
, argv
[4], &l
);
2936 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2937 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2941 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2942 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2945 if ((addr
+ (len
* width
)) < addr
) {
2946 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2947 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2950 /* absurd transfer size? */
2952 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2953 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2958 ((width
== 2) && ((addr
& 1) == 0)) ||
2959 ((width
== 4) && ((addr
& 3) == 0))) {
2963 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2964 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2965 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2969 context
= Jim_GetAssocData(interp
, "context");
2970 if (context
== NULL
)
2972 LOG_ERROR("array2mem: no command context");
2975 target
= get_current_target(context
);
2978 LOG_ERROR("array2mem: no current target");
2989 /* Slurp... in buffer size chunks */
2991 count
= len
; /* in objects.. */
2992 if (count
> (sizeof(buffer
)/width
)) {
2993 count
= (sizeof(buffer
)/width
);
2996 v
= 0; /* shut up gcc */
2997 for (i
= 0 ;i
< count
;i
++, n
++) {
2998 get_int_array_element(interp
, varname
, n
, &v
);
3001 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
3004 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
3007 buffer
[i
] = v
& 0x0ff;
3013 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
3014 if (retval
!= ERROR_OK
) {
3016 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
3017 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3018 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
3024 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
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)