1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "target_request.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
37 #include <sys/types.h>
45 #include <time_support.h>
50 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
52 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
78 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
82 extern target_type_t arm7tdmi_target
;
83 extern target_type_t arm720t_target
;
84 extern target_type_t arm9tdmi_target
;
85 extern target_type_t arm920t_target
;
86 extern target_type_t arm966e_target
;
87 extern target_type_t arm926ejs_target
;
88 extern target_type_t feroceon_target
;
89 extern target_type_t xscale_target
;
90 extern target_type_t cortexm3_target
;
91 extern target_type_t arm11_target
;
93 target_type_t
*target_types
[] =
108 target_t
*targets
= NULL
;
109 target_event_callback_t
*target_event_callbacks
= NULL
;
110 target_timer_callback_t
*target_timer_callbacks
= NULL
;
112 char *target_state_strings
[] =
121 char *target_debug_reason_strings
[] =
123 "debug request", "breakpoint", "watchpoint",
124 "watchpoint and breakpoint", "single step",
125 "target not halted", "undefined"
128 char *target_endianess_strings
[] =
134 static int target_continous_poll
= 1;
136 /* read a u32 from a buffer in target memory endianness */
137 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
139 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
140 return le_to_h_u32(buffer
);
142 return be_to_h_u32(buffer
);
145 /* read a u16 from a buffer in target memory endianness */
146 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
148 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
149 return le_to_h_u16(buffer
);
151 return be_to_h_u16(buffer
);
154 /* write a u32 to a buffer in target memory endianness */
155 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
157 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
158 h_u32_to_le(buffer
, value
);
160 h_u32_to_be(buffer
, value
);
163 /* write a u16 to a buffer in target memory endianness */
164 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
166 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
167 h_u16_to_le(buffer
, value
);
169 h_u16_to_be(buffer
, value
);
172 /* returns a pointer to the n-th configured target */
173 target_t
* get_target_by_num(int num
)
175 target_t
*target
= targets
;
182 target
= target
->next
;
189 int get_num_by_target(target_t
*query_target
)
191 target_t
*target
= targets
;
196 if (target
== query_target
)
198 target
= target
->next
;
205 target_t
* get_current_target(command_context_t
*cmd_ctx
)
207 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
211 LOG_ERROR("BUG: current_target out of bounds");
218 /* Process target initialization, when target entered debug out of reset
219 * the handler is unregistered at the end of this function, so it's only called once
221 int target_init_handler(struct target_s
*target
, enum target_event event
, void *priv
)
223 struct command_context_s
*cmd_ctx
= priv
;
225 if (event
== TARGET_EVENT_HALTED
)
227 target_unregister_event_callback(target_init_handler
, priv
);
228 target_invoke_script(cmd_ctx
, target
, "post_reset");
229 jtag_execute_queue();
235 int target_run_and_halt_handler(void *priv
)
237 target_t
*target
= priv
;
244 int target_poll(struct target_s
*target
)
246 /* We can't poll until after examine */
247 if (!target
->type
->examined
)
249 /* Fail silently lest we pollute the log */
252 return target
->type
->poll(target
);
255 int target_halt(struct target_s
*target
)
257 /* We can't poll until after examine */
258 if (!target
->type
->examined
)
260 LOG_ERROR("Target not examined yet");
263 return target
->type
->halt(target
);
266 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
269 int timeout_ms
= 5000;
271 enum target_state resume_state
= debug_execution
? TARGET_DEBUG_RUNNING
: TARGET_RUNNING
;
273 /* We can't poll until after examine */
274 if (!target
->type
->examined
)
276 LOG_ERROR("Target not examined yet");
280 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
283 /* wait for target to exit halted mode */
286 while (target
->state
!= resume_state
)
288 target_call_timer_callbacks();
291 if ((timeout_ms
-= 10) <= 0)
293 LOG_ERROR("timeout waiting for target resume");
294 return ERROR_TARGET_TIMEOUT
;
301 int target_process_reset(struct command_context_s
*cmd_ctx
)
303 int retval
= ERROR_OK
;
305 struct timeval timeout
, now
;
307 jtag
->speed(jtag_speed
);
312 target_invoke_script(cmd_ctx
, target
, "pre_reset");
313 target
= target
->next
;
316 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
319 /* First time this is executed after launching OpenOCD, it will read out
320 * the type of CPU, etc. and init Embedded ICE registers in host
323 * It will also set up ICE registers in the target.
325 * However, if we assert TRST later, we need to set up the registers again.
327 * For the "reset halt/init" case we must only set up the registers here.
329 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
332 /* prepare reset_halt where necessary */
336 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
338 switch (target
->reset_mode
)
341 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
342 target
->reset_mode
= RESET_RUN_AND_HALT
;
345 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
346 target
->reset_mode
= RESET_RUN_AND_INIT
;
352 target
= target
->next
;
358 /* we have no idea what state the target is in, so we
359 * have to drop working areas
361 target_free_all_working_areas_restore(target
, 0);
362 target
->type
->assert_reset(target
);
363 target
= target
->next
;
365 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
367 LOG_WARNING("JTAG communication failed asserting reset.");
371 /* request target halt if necessary, and schedule further action */
375 switch (target
->reset_mode
)
378 /* nothing to do if target just wants to be run */
380 case RESET_RUN_AND_HALT
:
382 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
384 case RESET_RUN_AND_INIT
:
386 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
387 target_register_event_callback(target_init_handler
, cmd_ctx
);
394 target_register_event_callback(target_init_handler
, cmd_ctx
);
397 LOG_ERROR("BUG: unknown target->reset_mode");
399 target
= target
->next
;
402 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
404 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
411 target
->type
->deassert_reset(target
);
412 target
= target
->next
;
415 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
417 LOG_WARNING("JTAG communication failed while deasserting reset.");
421 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
423 /* If TRST was asserted we need to set up registers again */
424 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
428 /* post reset scripts can be quite long, increase speed now. If post
429 * reset scripts needs a different speed, they can set the speed to
430 * whatever they need.
432 jtag
->speed(jtag_speed_post_reset
);
434 LOG_DEBUG("Waiting for halted stated as approperiate");
436 /* Wait for reset to complete, maximum 5 seconds. */
437 gettimeofday(&timeout
, NULL
);
438 timeval_add_time(&timeout
, 5, 0);
441 gettimeofday(&now
, NULL
);
443 target_call_timer_callbacks_now();
448 LOG_DEBUG("Polling target");
450 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
451 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
452 (target
->reset_mode
== RESET_HALT
) ||
453 (target
->reset_mode
== RESET_INIT
))
455 if (target
->state
!= TARGET_HALTED
)
457 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
459 LOG_USER("Timed out waiting for halt after reset");
462 /* this will send alive messages on e.g. GDB remote protocol. */
464 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
468 target
= target
->next
;
470 /* All targets we're waiting for are halted */
478 /* We want any events to be processed before the prompt */
479 target_call_timer_callbacks_now();
481 /* if we timed out we need to unregister these handlers */
485 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
486 target
= target
->next
;
488 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
494 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
500 static int default_mmu(struct target_s
*target
, int *enabled
)
506 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
508 target
->type
->examined
= 1;
513 /* Targets that correctly implement init+examine, i.e.
514 * no communication with target during init:
518 int target_examine(struct command_context_s
*cmd_ctx
)
520 int retval
= ERROR_OK
;
521 target_t
*target
= targets
;
524 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
526 target
= target
->next
;
531 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
533 if (!target
->type
->examined
)
535 LOG_ERROR("Target not examined yet");
538 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
541 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
543 if (!target
->type
->examined
)
545 LOG_ERROR("Target not examined yet");
548 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
551 static int target_soft_reset_halt_imp(struct target_s
*target
)
553 if (!target
->type
->examined
)
555 LOG_ERROR("Target not examined yet");
558 return target
->type
->soft_reset_halt_imp(target
);
561 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
)
563 if (!target
->type
->examined
)
565 LOG_ERROR("Target not examined yet");
568 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
);
571 int target_init(struct command_context_s
*cmd_ctx
)
573 target_t
*target
= targets
;
577 target
->type
->examined
= 0;
578 if (target
->type
->examine
== NULL
)
580 target
->type
->examine
= default_examine
;
583 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
585 LOG_ERROR("target '%s' init failed", target
->type
->name
);
589 /* Set up default functions if none are provided by target */
590 if (target
->type
->virt2phys
== NULL
)
592 target
->type
->virt2phys
= default_virt2phys
;
594 target
->type
->virt2phys
= default_virt2phys
;
595 /* a non-invasive way(in terms of patches) to add some code that
596 * runs before the type->write/read_memory implementation
598 target
->type
->write_memory_imp
= target
->type
->write_memory
;
599 target
->type
->write_memory
= target_write_memory_imp
;
600 target
->type
->read_memory_imp
= target
->type
->read_memory
;
601 target
->type
->read_memory
= target_read_memory_imp
;
602 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
603 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
604 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
605 target
->type
->run_algorithm
= target_run_algorithm_imp
;
608 if (target
->type
->mmu
== NULL
)
610 target
->type
->mmu
= default_mmu
;
612 target
= target
->next
;
617 target_register_user_commands(cmd_ctx
);
618 target_register_timer_callback(handle_target
, 100, 1, NULL
);
624 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
626 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
628 if (callback
== NULL
)
630 return ERROR_INVALID_ARGUMENTS
;
635 while ((*callbacks_p
)->next
)
636 callbacks_p
= &((*callbacks_p
)->next
);
637 callbacks_p
= &((*callbacks_p
)->next
);
640 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
641 (*callbacks_p
)->callback
= callback
;
642 (*callbacks_p
)->priv
= priv
;
643 (*callbacks_p
)->next
= NULL
;
648 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
650 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
653 if (callback
== NULL
)
655 return ERROR_INVALID_ARGUMENTS
;
660 while ((*callbacks_p
)->next
)
661 callbacks_p
= &((*callbacks_p
)->next
);
662 callbacks_p
= &((*callbacks_p
)->next
);
665 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
666 (*callbacks_p
)->callback
= callback
;
667 (*callbacks_p
)->periodic
= periodic
;
668 (*callbacks_p
)->time_ms
= time_ms
;
670 gettimeofday(&now
, NULL
);
671 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
672 time_ms
-= (time_ms
% 1000);
673 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
674 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
676 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
677 (*callbacks_p
)->when
.tv_sec
+= 1;
680 (*callbacks_p
)->priv
= priv
;
681 (*callbacks_p
)->next
= NULL
;
686 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
688 target_event_callback_t
**p
= &target_event_callbacks
;
689 target_event_callback_t
*c
= target_event_callbacks
;
691 if (callback
== NULL
)
693 return ERROR_INVALID_ARGUMENTS
;
698 target_event_callback_t
*next
= c
->next
;
699 if ((c
->callback
== callback
) && (c
->priv
== priv
))
713 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
715 target_timer_callback_t
**p
= &target_timer_callbacks
;
716 target_timer_callback_t
*c
= target_timer_callbacks
;
718 if (callback
== NULL
)
720 return ERROR_INVALID_ARGUMENTS
;
725 target_timer_callback_t
*next
= c
->next
;
726 if ((c
->callback
== callback
) && (c
->priv
== priv
))
740 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
742 target_event_callback_t
*callback
= target_event_callbacks
;
743 target_event_callback_t
*next_callback
;
745 LOG_DEBUG("target event %i", event
);
749 next_callback
= callback
->next
;
750 callback
->callback(target
, event
, callback
->priv
);
751 callback
= next_callback
;
757 static int target_call_timer_callbacks_check_time(int checktime
)
759 target_timer_callback_t
*callback
= target_timer_callbacks
;
760 target_timer_callback_t
*next_callback
;
765 gettimeofday(&now
, NULL
);
769 next_callback
= callback
->next
;
771 if ((!checktime
&&callback
->periodic
)||
772 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
773 || (now
.tv_sec
> callback
->when
.tv_sec
)))
775 if(callback
->callback
!= NULL
)
777 callback
->callback(callback
->priv
);
778 if (callback
->periodic
)
780 int time_ms
= callback
->time_ms
;
781 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
782 time_ms
-= (time_ms
% 1000);
783 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
784 if (callback
->when
.tv_usec
> 1000000)
786 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
787 callback
->when
.tv_sec
+= 1;
791 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
795 callback
= next_callback
;
801 int target_call_timer_callbacks()
803 return target_call_timer_callbacks_check_time(1);
806 /* invoke periodic callbacks immediately */
807 int target_call_timer_callbacks_now()
809 return target_call_timer_callbacks(0);
812 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
814 working_area_t
*c
= target
->working_areas
;
815 working_area_t
*new_wa
= NULL
;
817 /* Reevaluate working area address based on MMU state*/
818 if (target
->working_areas
== NULL
)
822 retval
= target
->type
->mmu(target
, &enabled
);
823 if (retval
!= ERROR_OK
)
829 target
->working_area
= target
->working_area_virt
;
833 target
->working_area
= target
->working_area_phys
;
837 /* only allocate multiples of 4 byte */
840 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
841 size
= CEIL(size
, 4);
844 /* see if there's already a matching working area */
847 if ((c
->free
) && (c
->size
== size
))
855 /* if not, allocate a new one */
858 working_area_t
**p
= &target
->working_areas
;
859 u32 first_free
= target
->working_area
;
860 u32 free_size
= target
->working_area_size
;
862 LOG_DEBUG("allocating new working area");
864 c
= target
->working_areas
;
867 first_free
+= c
->size
;
868 free_size
-= c
->size
;
873 if (free_size
< size
)
875 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
876 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
879 new_wa
= malloc(sizeof(working_area_t
));
882 new_wa
->address
= first_free
;
884 if (target
->backup_working_area
)
886 new_wa
->backup
= malloc(new_wa
->size
);
887 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
891 new_wa
->backup
= NULL
;
894 /* put new entry in list */
898 /* mark as used, and return the new (reused) area */
908 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
913 if (restore
&&target
->backup_working_area
)
914 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
918 /* mark user pointer invalid */
925 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
927 return target_free_working_area_restore(target
, area
, 1);
930 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
932 working_area_t
*c
= target
->working_areas
;
936 working_area_t
*next
= c
->next
;
937 target_free_working_area_restore(target
, c
, restore
);
947 target
->working_areas
= NULL
;
952 int target_free_all_working_areas(struct target_s
*target
)
954 return target_free_all_working_areas_restore(target
, 1);
957 int target_register_commands(struct command_context_s
*cmd_ctx
)
959 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
960 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
961 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
962 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
963 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
964 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
967 /* script procedures */
968 register_jim(cmd_ctx
, "openocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
969 register_jim(cmd_ctx
, "openocd_array2mem", jim_mem2array
, "convert a TCL array to memory locations and write the values");
973 int target_arch_state(struct target_s
*target
)
978 LOG_USER("No target has been configured");
982 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
984 if (target
->state
!=TARGET_HALTED
)
987 retval
=target
->type
->arch_state(target
);
991 /* Single aligned words are guaranteed to use 16 or 32 bit access
992 * mode respectively, otherwise data is handled as quickly as
995 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
998 if (!target
->type
->examined
)
1000 LOG_ERROR("Target not examined yet");
1004 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
1006 if (((address
% 2) == 0) && (size
== 2))
1008 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
1011 /* handle unaligned head bytes */
1014 int unaligned
= 4 - (address
% 4);
1016 if (unaligned
> size
)
1019 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1022 buffer
+= unaligned
;
1023 address
+= unaligned
;
1027 /* handle aligned words */
1030 int aligned
= size
- (size
% 4);
1032 /* use bulk writes above a certain limit. This may have to be changed */
1035 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1040 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1049 /* handle tail writes of less than 4 bytes */
1052 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1060 /* Single aligned words are guaranteed to use 16 or 32 bit access
1061 * mode respectively, otherwise data is handled as quickly as
1064 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1067 if (!target
->type
->examined
)
1069 LOG_ERROR("Target not examined yet");
1073 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1075 if (((address
% 2) == 0) && (size
== 2))
1077 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1080 /* handle unaligned head bytes */
1083 int unaligned
= 4 - (address
% 4);
1085 if (unaligned
> size
)
1088 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1091 buffer
+= unaligned
;
1092 address
+= unaligned
;
1096 /* handle aligned words */
1099 int aligned
= size
- (size
% 4);
1101 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1109 /* handle tail writes of less than 4 bytes */
1112 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1119 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1125 if (!target
->type
->examined
)
1127 LOG_ERROR("Target not examined yet");
1131 if ((retval
= target
->type
->checksum_memory(target
, address
,
1132 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1134 buffer
= malloc(size
);
1137 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1138 return ERROR_INVALID_ARGUMENTS
;
1140 retval
= target_read_buffer(target
, address
, size
, buffer
);
1141 if (retval
!= ERROR_OK
)
1147 /* convert to target endianess */
1148 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1151 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1152 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1155 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1164 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1167 if (!target
->type
->examined
)
1169 LOG_ERROR("Target not examined yet");
1173 if (target
->type
->blank_check_memory
== 0)
1174 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1176 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1181 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1184 if (!target
->type
->examined
)
1186 LOG_ERROR("Target not examined yet");
1190 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1192 if (retval
== ERROR_OK
)
1194 *value
= target_buffer_get_u32(target
, value_buf
);
1195 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1200 LOG_DEBUG("address: 0x%8.8x failed", address
);
1206 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1209 if (!target
->type
->examined
)
1211 LOG_ERROR("Target not examined yet");
1215 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1217 if (retval
== ERROR_OK
)
1219 *value
= target_buffer_get_u16(target
, value_buf
);
1220 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1225 LOG_DEBUG("address: 0x%8.8x failed", address
);
1231 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1233 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1234 if (!target
->type
->examined
)
1236 LOG_ERROR("Target not examined yet");
1240 if (retval
== ERROR_OK
)
1242 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1247 LOG_DEBUG("address: 0x%8.8x failed", address
);
1253 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1257 if (!target
->type
->examined
)
1259 LOG_ERROR("Target not examined yet");
1263 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1265 target_buffer_set_u32(target
, value_buf
, value
);
1266 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1268 LOG_DEBUG("failed: %i", retval
);
1274 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1278 if (!target
->type
->examined
)
1280 LOG_ERROR("Target not examined yet");
1284 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1286 target_buffer_set_u16(target
, value_buf
, value
);
1287 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1289 LOG_DEBUG("failed: %i", retval
);
1295 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1298 if (!target
->type
->examined
)
1300 LOG_ERROR("Target not examined yet");
1304 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1306 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1308 LOG_DEBUG("failed: %i", retval
);
1314 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1316 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1317 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1318 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1319 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1320 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1321 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1322 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1323 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1325 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1326 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1327 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1329 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1330 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1331 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1333 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1334 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1335 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1336 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1338 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1339 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1340 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1341 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1342 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1344 target_request_register_commands(cmd_ctx
);
1345 trace_register_commands(cmd_ctx
);
1350 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1352 target_t
*target
= targets
;
1357 int num
= strtoul(args
[0], NULL
, 0);
1362 target
= target
->next
;
1366 cmd_ctx
->current_target
= num
;
1368 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1375 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1376 target
= target
->next
;
1382 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1389 return ERROR_COMMAND_SYNTAX_ERROR
;
1392 /* search for the specified target */
1393 if (args
[0] && (args
[0][0] != 0))
1395 for (i
= 0; target_types
[i
]; i
++)
1397 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1399 target_t
**last_target_p
= &targets
;
1401 /* register target specific commands */
1402 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1404 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1410 while ((*last_target_p
)->next
)
1411 last_target_p
= &((*last_target_p
)->next
);
1412 last_target_p
= &((*last_target_p
)->next
);
1415 *last_target_p
= malloc(sizeof(target_t
));
1417 /* allocate memory for each unique target type */
1418 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1419 *((*last_target_p
)->type
) = *target_types
[i
];
1421 if (strcmp(args
[1], "big") == 0)
1422 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1423 else if (strcmp(args
[1], "little") == 0)
1424 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1427 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1428 return ERROR_COMMAND_SYNTAX_ERROR
;
1431 /* what to do on a target reset */
1432 (*last_target_p
)->reset_mode
= RESET_INIT
; /* default */
1433 if (strcmp(args
[2], "reset_halt") == 0)
1434 (*last_target_p
)->reset_mode
= RESET_HALT
;
1435 else if (strcmp(args
[2], "reset_run") == 0)
1436 (*last_target_p
)->reset_mode
= RESET_RUN
;
1437 else if (strcmp(args
[2], "reset_init") == 0)
1438 (*last_target_p
)->reset_mode
= RESET_INIT
;
1439 else if (strcmp(args
[2], "run_and_halt") == 0)
1440 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1441 else if (strcmp(args
[2], "run_and_init") == 0)
1442 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1445 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1449 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1451 (*last_target_p
)->working_area
= 0x0;
1452 (*last_target_p
)->working_area_size
= 0x0;
1453 (*last_target_p
)->working_areas
= NULL
;
1454 (*last_target_p
)->backup_working_area
= 0;
1456 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1457 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1458 (*last_target_p
)->reg_cache
= NULL
;
1459 (*last_target_p
)->breakpoints
= NULL
;
1460 (*last_target_p
)->watchpoints
= NULL
;
1461 (*last_target_p
)->next
= NULL
;
1462 (*last_target_p
)->arch_info
= NULL
;
1464 /* initialize trace information */
1465 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1466 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1467 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1468 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1469 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1470 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1471 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1472 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1474 (*last_target_p
)->dbgmsg
= NULL
;
1475 (*last_target_p
)->dbg_msg_enabled
= 0;
1477 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1485 /* no matching target found */
1488 LOG_ERROR("target '%s' not found", args
[0]);
1489 return ERROR_COMMAND_SYNTAX_ERROR
;
1495 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1497 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
1498 name
, get_num_by_target(target
),
1499 name
, get_num_by_target(target
));
1502 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1504 target_t
*target
= NULL
;
1508 return ERROR_COMMAND_SYNTAX_ERROR
;
1511 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1514 return ERROR_COMMAND_SYNTAX_ERROR
;
1517 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1522 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1524 target_t
*target
= NULL
;
1526 if ((argc
< 4) || (argc
> 5))
1528 return ERROR_COMMAND_SYNTAX_ERROR
;
1531 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1534 return ERROR_COMMAND_SYNTAX_ERROR
;
1536 target_free_all_working_areas(target
);
1538 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1541 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1543 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1545 if (strcmp(args
[3], "backup") == 0)
1547 target
->backup_working_area
= 1;
1549 else if (strcmp(args
[3], "nobackup") == 0)
1551 target
->backup_working_area
= 0;
1555 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1556 return ERROR_COMMAND_SYNTAX_ERROR
;
1563 /* process target state changes */
1564 int handle_target(void *priv
)
1566 target_t
*target
= targets
;
1570 if (target_continous_poll
)
1572 /* polling may fail silently until the target has been examined */
1573 target_poll(target
);
1576 target
= target
->next
;
1582 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1591 target
= get_current_target(cmd_ctx
);
1593 /* list all available registers for the current target */
1596 reg_cache_t
*cache
= target
->reg_cache
;
1602 for (i
= 0; i
< cache
->num_regs
; i
++)
1604 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1605 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
);
1608 cache
= cache
->next
;
1614 /* access a single register by its ordinal number */
1615 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1617 int num
= strtoul(args
[0], NULL
, 0);
1618 reg_cache_t
*cache
= target
->reg_cache
;
1624 for (i
= 0; i
< cache
->num_regs
; i
++)
1628 reg
= &cache
->reg_list
[i
];
1634 cache
= cache
->next
;
1639 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1642 } else /* access a single register by its name */
1644 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1648 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1653 /* display a register */
1654 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1656 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1659 if (reg
->valid
== 0)
1661 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1662 if (arch_type
== NULL
)
1664 LOG_ERROR("BUG: encountered unregistered arch type");
1667 arch_type
->get(reg
);
1669 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1670 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1675 /* set register value */
1678 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1679 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1681 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1682 if (arch_type
== NULL
)
1684 LOG_ERROR("BUG: encountered unregistered arch type");
1688 arch_type
->set(reg
, buf
);
1690 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1691 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1699 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1704 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1706 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1708 target_t
*target
= get_current_target(cmd_ctx
);
1712 target_poll(target
);
1713 target_arch_state(target
);
1717 if (strcmp(args
[0], "on") == 0)
1719 target_continous_poll
= 1;
1721 else if (strcmp(args
[0], "off") == 0)
1723 target_continous_poll
= 0;
1727 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1735 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1743 ms
= strtoul(args
[0], &end
, 0) * 1000;
1746 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1751 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1754 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1757 struct timeval timeout
, now
;
1759 gettimeofday(&timeout
, NULL
);
1760 timeval_add_time(&timeout
, 0, ms
* 1000);
1762 target_t
*target
= get_current_target(cmd_ctx
);
1765 if ((retval
=target_poll(target
))!=ERROR_OK
)
1767 target_call_timer_callbacks_now();
1768 if (target
->state
== state
)
1775 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1778 gettimeofday(&now
, NULL
);
1779 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1781 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1789 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1792 target_t
*target
= get_current_target(cmd_ctx
);
1796 if ((retval
= target_halt(target
)) != ERROR_OK
)
1801 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1804 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1806 target_t
*target
= get_current_target(cmd_ctx
);
1808 LOG_USER("requesting target halt and executing a soft reset");
1810 target
->type
->soft_reset_halt(target
);
1815 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1817 target_t
*target
= get_current_target(cmd_ctx
);
1818 enum target_reset_mode reset_mode
= target
->reset_mode
;
1819 enum target_reset_mode save
= target
->reset_mode
;
1825 if (strcmp("run", args
[0]) == 0)
1826 reset_mode
= RESET_RUN
;
1827 else if (strcmp("halt", args
[0]) == 0)
1828 reset_mode
= RESET_HALT
;
1829 else if (strcmp("init", args
[0]) == 0)
1830 reset_mode
= RESET_INIT
;
1831 else if (strcmp("run_and_halt", args
[0]) == 0)
1833 reset_mode
= RESET_RUN_AND_HALT
;
1836 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1839 else if (strcmp("run_and_init", args
[0]) == 0)
1841 reset_mode
= RESET_RUN_AND_INIT
;
1844 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1849 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1854 /* temporarily modify mode of current reset target */
1855 target
->reset_mode
= reset_mode
;
1857 /* reset *all* targets */
1858 target_process_reset(cmd_ctx
);
1860 /* Restore default reset mode for this target */
1861 target
->reset_mode
= save
;
1866 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1869 target_t
*target
= get_current_target(cmd_ctx
);
1871 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1874 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1876 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1879 return ERROR_COMMAND_SYNTAX_ERROR
;
1885 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1887 target_t
*target
= get_current_target(cmd_ctx
);
1892 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1895 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1900 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1902 const int line_bytecnt
= 32;
1915 target_t
*target
= get_current_target(cmd_ctx
);
1921 count
= strtoul(args
[1], NULL
, 0);
1923 address
= strtoul(args
[0], NULL
, 0);
1929 size
= 4; line_modulo
= line_bytecnt
/ 4;
1932 size
= 2; line_modulo
= line_bytecnt
/ 2;
1935 size
= 1; line_modulo
= line_bytecnt
/ 1;
1941 buffer
= calloc(count
, size
);
1942 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1943 if (retval
== ERROR_OK
)
1947 for (i
= 0; i
< count
; i
++)
1949 if (i
%line_modulo
== 0)
1950 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1955 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1958 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1961 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1965 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1967 command_print(cmd_ctx
, output
);
1978 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1985 target_t
*target
= get_current_target(cmd_ctx
);
1988 if ((argc
< 2) || (argc
> 3))
1989 return ERROR_COMMAND_SYNTAX_ERROR
;
1991 address
= strtoul(args
[0], NULL
, 0);
1992 value
= strtoul(args
[1], NULL
, 0);
1994 count
= strtoul(args
[2], NULL
, 0);
2000 target_buffer_set_u32(target
, value_buf
, value
);
2004 target_buffer_set_u16(target
, value_buf
, value
);
2008 value_buf
[0] = value
;
2011 return ERROR_COMMAND_SYNTAX_ERROR
;
2013 for (i
=0; i
<count
; i
++)
2019 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2022 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2025 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2030 if (retval
!=ERROR_OK
)
2040 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2050 duration_t duration
;
2051 char *duration_text
;
2053 target_t
*target
= get_current_target(cmd_ctx
);
2057 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2061 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2064 image
.base_address_set
= 1;
2065 image
.base_address
= strtoul(args
[1], NULL
, 0);
2069 image
.base_address_set
= 0;
2072 image
.start_address_set
= 0;
2074 duration_start_measure(&duration
);
2076 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2083 for (i
= 0; i
< image
.num_sections
; i
++)
2085 buffer
= malloc(image
.sections
[i
].size
);
2088 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2092 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2097 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2102 image_size
+= buf_cnt
;
2103 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2108 duration_stop_measure(&duration
, &duration_text
);
2109 if (retval
==ERROR_OK
)
2111 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2113 free(duration_text
);
2115 image_close(&image
);
2121 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2128 int retval
=ERROR_OK
;
2130 duration_t duration
;
2131 char *duration_text
;
2133 target_t
*target
= get_current_target(cmd_ctx
);
2137 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2141 address
= strtoul(args
[1], NULL
, 0);
2142 size
= strtoul(args
[2], NULL
, 0);
2144 if ((address
& 3) || (size
& 3))
2146 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2150 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2155 duration_start_measure(&duration
);
2160 u32 this_run_size
= (size
> 560) ? 560 : size
;
2162 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2163 if (retval
!= ERROR_OK
)
2168 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2169 if (retval
!= ERROR_OK
)
2174 size
-= this_run_size
;
2175 address
+= this_run_size
;
2178 fileio_close(&fileio
);
2180 duration_stop_measure(&duration
, &duration_text
);
2181 if (retval
==ERROR_OK
)
2183 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2185 free(duration_text
);
2190 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2198 u32 mem_checksum
= 0;
2202 duration_t duration
;
2203 char *duration_text
;
2205 target_t
*target
= get_current_target(cmd_ctx
);
2209 return ERROR_COMMAND_SYNTAX_ERROR
;
2214 LOG_ERROR("no target selected");
2218 duration_start_measure(&duration
);
2222 image
.base_address_set
= 1;
2223 image
.base_address
= strtoul(args
[1], NULL
, 0);
2227 image
.base_address_set
= 0;
2228 image
.base_address
= 0x0;
2231 image
.start_address_set
= 0;
2233 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2240 for (i
= 0; i
< image
.num_sections
; i
++)
2242 buffer
= malloc(image
.sections
[i
].size
);
2245 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2248 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2254 /* calculate checksum of image */
2255 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2257 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2258 if( retval
!= ERROR_OK
)
2264 if( checksum
!= mem_checksum
)
2266 /* failed crc checksum, fall back to a binary compare */
2269 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2271 data
= (u8
*)malloc(buf_cnt
);
2273 /* Can we use 32bit word accesses? */
2275 int count
= buf_cnt
;
2276 if ((count
% 4) == 0)
2281 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2282 if (retval
== ERROR_OK
)
2285 for (t
= 0; t
< buf_cnt
; t
++)
2287 if (data
[t
] != buffer
[t
])
2289 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
]);
2302 image_size
+= buf_cnt
;
2305 duration_stop_measure(&duration
, &duration_text
);
2306 if (retval
==ERROR_OK
)
2308 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2310 free(duration_text
);
2312 image_close(&image
);
2317 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2320 target_t
*target
= get_current_target(cmd_ctx
);
2324 breakpoint_t
*breakpoint
= target
->breakpoints
;
2328 if (breakpoint
->type
== BKPT_SOFT
)
2330 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2331 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2336 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2338 breakpoint
= breakpoint
->next
;
2346 length
= strtoul(args
[1], NULL
, 0);
2349 if (strcmp(args
[2], "hw") == 0)
2352 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2354 LOG_ERROR("Failure setting breakpoints");
2358 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2363 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2369 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2371 target_t
*target
= get_current_target(cmd_ctx
);
2374 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2379 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2381 target_t
*target
= get_current_target(cmd_ctx
);
2386 watchpoint_t
*watchpoint
= target
->watchpoints
;
2390 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
);
2391 watchpoint
= watchpoint
->next
;
2396 enum watchpoint_rw type
= WPT_ACCESS
;
2397 u32 data_value
= 0x0;
2398 u32 data_mask
= 0xffffffff;
2414 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2420 data_value
= strtoul(args
[3], NULL
, 0);
2424 data_mask
= strtoul(args
[4], NULL
, 0);
2427 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2428 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2430 LOG_ERROR("Failure setting breakpoints");
2435 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2441 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2443 target_t
*target
= get_current_target(cmd_ctx
);
2446 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2451 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2454 target_t
*target
= get_current_target(cmd_ctx
);
2460 return ERROR_COMMAND_SYNTAX_ERROR
;
2462 va
= strtoul(args
[0], NULL
, 0);
2464 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2465 if (retval
== ERROR_OK
)
2467 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2471 /* lower levels will have logged a detailed error which is
2472 * forwarded to telnet/GDB session.
2477 static void writeLong(FILE *f
, int l
)
2482 char c
=(l
>>(i
*8))&0xff;
2483 fwrite(&c
, 1, 1, f
);
2487 static void writeString(FILE *f
, char *s
)
2489 fwrite(s
, 1, strlen(s
), f
);
2494 // Dump a gmon.out histogram file.
2495 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2498 FILE *f
=fopen(filename
, "w");
2501 fwrite("gmon", 1, 4, f
);
2502 writeLong(f
, 0x00000001); // Version
2503 writeLong(f
, 0); // padding
2504 writeLong(f
, 0); // padding
2505 writeLong(f
, 0); // padding
2507 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2509 // figure out bucket size
2512 for (i
=0; i
<sampleNum
; i
++)
2524 int addressSpace
=(max
-min
+1);
2526 static int const maxBuckets
=256*1024; // maximum buckets.
2527 int length
=addressSpace
;
2528 if (length
> maxBuckets
)
2532 int *buckets
=malloc(sizeof(int)*length
);
2538 memset(buckets
, 0, sizeof(int)*length
);
2539 for (i
=0; i
<sampleNum
;i
++)
2541 u32 address
=samples
[i
];
2542 long long a
=address
-min
;
2543 long long b
=length
-1;
2544 long long c
=addressSpace
-1;
2545 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2549 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2550 writeLong(f
, min
); // low_pc
2551 writeLong(f
, max
); // high_pc
2552 writeLong(f
, length
); // # of samples
2553 writeLong(f
, 64000000); // 64MHz
2554 writeString(f
, "seconds");
2555 for (i
=0; i
<(15-strlen("seconds")); i
++)
2557 fwrite("", 1, 1, f
); // padding
2559 writeString(f
, "s");
2561 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2563 char *data
=malloc(2*length
);
2566 for (i
=0; i
<length
;i
++)
2575 data
[i
*2+1]=(val
>>8)&0xff;
2578 fwrite(data
, 1, length
*2, f
);
2588 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2589 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2591 target_t
*target
= get_current_target(cmd_ctx
);
2592 struct timeval timeout
, now
;
2594 gettimeofday(&timeout
, NULL
);
2597 return ERROR_COMMAND_SYNTAX_ERROR
;
2600 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2606 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2608 static const int maxSample
=10000;
2609 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2614 int retval
=ERROR_OK
;
2615 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2616 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2620 target_poll(target
);
2621 if (target
->state
== TARGET_HALTED
)
2623 u32 t
=*((u32
*)reg
->value
);
2624 samples
[numSamples
++]=t
;
2625 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2626 target_poll(target
);
2627 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2628 } else if (target
->state
== TARGET_RUNNING
)
2630 // We want to quickly sample the PC.
2631 target_halt(target
);
2634 command_print(cmd_ctx
, "Target not halted or running");
2638 if (retval
!=ERROR_OK
)
2643 gettimeofday(&now
, NULL
);
2644 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2646 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2647 target_poll(target
);
2648 if (target
->state
== TARGET_HALTED
)
2650 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2652 target_poll(target
);
2653 writeGmon(samples
, numSamples
, args
[1]);
2654 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2663 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2666 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2669 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2673 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2674 valObjPtr
= Jim_NewIntObj(interp
, val
);
2675 if (!nameObjPtr
|| !valObjPtr
)
2681 Jim_IncrRefCount(nameObjPtr
);
2682 Jim_IncrRefCount(valObjPtr
);
2683 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2684 Jim_DecrRefCount(interp
, nameObjPtr
);
2685 Jim_DecrRefCount(interp
, valObjPtr
);
2687 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2691 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2694 command_context_t
*context
;
2701 const char *varname
;
2703 int i
, n
, e
, retval
;
2705 /* argv[1] = name of array to receive the data
2706 * argv[2] = desired width
2707 * argv[3] = memory address
2708 * argv[4] = count of times to read
2711 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2714 varname
= Jim_GetString(argv
[1], &len
);
2715 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2717 e
= Jim_GetLong(interp
, argv
[2], &l
);
2723 e
= Jim_GetLong(interp
, argv
[3], &l
);
2728 e
= Jim_GetLong(interp
, argv
[4], &l
);
2744 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2745 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2749 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2750 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2753 if ((addr
+ (len
* width
)) < addr
) {
2754 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2755 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2758 /* absurd transfer size? */
2760 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2761 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2766 ((width
== 2) && ((addr
& 1) == 0)) ||
2767 ((width
== 4) && ((addr
& 3) == 0))) {
2771 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2772 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2773 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2777 context
= Jim_GetAssocData(interp
, "context");
2778 if (context
== NULL
)
2780 LOG_ERROR("mem2array: no command context");
2783 target
= get_current_target(context
);
2786 LOG_ERROR("mem2array: no current target");
2797 /* Slurp... in buffer size chunks */
2799 count
= len
; /* in objects.. */
2800 if (count
> (sizeof(buffer
)/width
)) {
2801 count
= (sizeof(buffer
)/width
);
2804 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2805 if (retval
!= ERROR_OK
) {
2807 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2808 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2809 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2813 v
= 0; /* shut up gcc */
2814 for (i
= 0 ;i
< count
;i
++, n
++) {
2817 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2820 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2823 v
= buffer
[i
] & 0x0ff;
2826 new_int_array_element(interp
, varname
, n
, v
);
2832 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2837 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2840 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2844 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2848 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2855 Jim_IncrRefCount(nameObjPtr
);
2856 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2857 Jim_DecrRefCount(interp
, nameObjPtr
);
2859 if (valObjPtr
== NULL
)
2862 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2863 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2868 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2871 command_context_t
*context
;
2878 const char *varname
;
2880 int i
, n
, e
, retval
;
2882 /* argv[1] = name of array to get the data
2883 * argv[2] = desired width
2884 * argv[3] = memory address
2885 * argv[4] = count to write
2888 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2891 varname
= Jim_GetString(argv
[1], &len
);
2892 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2894 e
= Jim_GetLong(interp
, argv
[2], &l
);
2900 e
= Jim_GetLong(interp
, argv
[3], &l
);
2905 e
= Jim_GetLong(interp
, argv
[4], &l
);
2921 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2922 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2926 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2927 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2930 if ((addr
+ (len
* width
)) < addr
) {
2931 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2932 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2935 /* absurd transfer size? */
2937 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2938 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2943 ((width
== 2) && ((addr
& 1) == 0)) ||
2944 ((width
== 4) && ((addr
& 3) == 0))) {
2948 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2949 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2950 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2954 context
= Jim_GetAssocData(interp
, "context");
2955 if (context
== NULL
)
2957 LOG_ERROR("array2mem: no command context");
2960 target
= get_current_target(context
);
2963 LOG_ERROR("array2mem: no current target");
2974 /* Slurp... in buffer size chunks */
2976 count
= len
; /* in objects.. */
2977 if (count
> (sizeof(buffer
)/width
)) {
2978 count
= (sizeof(buffer
)/width
);
2981 v
= 0; /* shut up gcc */
2982 for (i
= 0 ;i
< count
;i
++, n
++) {
2983 get_int_array_element(interp
, varname
, n
, &v
);
2986 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2989 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2992 buffer
[i
] = v
& 0x0ff;
2998 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2999 if (retval
!= ERROR_OK
) {
3001 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
3002 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3003 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
3009 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)