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
)
270 /* We can't poll until after examine */
271 if (!target
->type
->examined
)
273 LOG_ERROR("Target not examined yet");
277 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
278 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
281 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
287 int target_process_reset(struct command_context_s
*cmd_ctx
)
289 int retval
= ERROR_OK
;
291 struct timeval timeout
, now
;
293 jtag
->speed(jtag_speed
);
298 target_invoke_script(cmd_ctx
, target
, "pre_reset");
299 target
= target
->next
;
302 if ((retval
= jtag_init_reset(cmd_ctx
)) != ERROR_OK
)
305 /* First time this is executed after launching OpenOCD, it will read out
306 * the type of CPU, etc. and init Embedded ICE registers in host
309 * It will also set up ICE registers in the target.
311 * However, if we assert TRST later, we need to set up the registers again.
313 * For the "reset halt/init" case we must only set up the registers here.
315 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
318 /* prepare reset_halt where necessary */
322 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
324 switch (target
->reset_mode
)
327 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
328 target
->reset_mode
= RESET_RUN_AND_HALT
;
331 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
332 target
->reset_mode
= RESET_RUN_AND_INIT
;
338 target
= target
->next
;
344 /* we have no idea what state the target is in, so we
345 * have to drop working areas
347 target_free_all_working_areas_restore(target
, 0);
348 target
->type
->assert_reset(target
);
349 target
= target
->next
;
351 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
353 LOG_WARNING("JTAG communication failed asserting reset.");
357 /* request target halt if necessary, and schedule further action */
361 switch (target
->reset_mode
)
364 /* nothing to do if target just wants to be run */
366 case RESET_RUN_AND_HALT
:
368 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
370 case RESET_RUN_AND_INIT
:
372 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
373 target_register_event_callback(target_init_handler
, cmd_ctx
);
380 target_register_event_callback(target_init_handler
, cmd_ctx
);
383 LOG_ERROR("BUG: unknown target->reset_mode");
385 target
= target
->next
;
388 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
390 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
397 target
->type
->deassert_reset(target
);
398 target
= target
->next
;
401 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
403 LOG_WARNING("JTAG communication failed while deasserting reset.");
407 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
409 /* If TRST was asserted we need to set up registers again */
410 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
414 /* post reset scripts can be quite long, increase speed now. If post
415 * reset scripts needs a different speed, they can set the speed to
416 * whatever they need.
418 jtag
->speed(jtag_speed_post_reset
);
420 LOG_DEBUG("Waiting for halted stated as approperiate");
422 /* Wait for reset to complete, maximum 5 seconds. */
423 gettimeofday(&timeout
, NULL
);
424 timeval_add_time(&timeout
, 5, 0);
427 gettimeofday(&now
, NULL
);
429 target_call_timer_callbacks_now();
434 LOG_DEBUG("Polling target");
436 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
437 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
438 (target
->reset_mode
== RESET_HALT
) ||
439 (target
->reset_mode
== RESET_INIT
))
441 if (target
->state
!= TARGET_HALTED
)
443 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
445 LOG_USER("Timed out waiting for halt after reset");
448 /* this will send alive messages on e.g. GDB remote protocol. */
450 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
454 target
= target
->next
;
456 /* All targets we're waiting for are halted */
464 /* We want any events to be processed before the prompt */
465 target_call_timer_callbacks_now();
467 /* if we timed out we need to unregister these handlers */
471 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
472 target
= target
->next
;
474 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
480 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
486 static int default_mmu(struct target_s
*target
, int *enabled
)
492 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
494 target
->type
->examined
= 1;
499 /* Targets that correctly implement init+examine, i.e.
500 * no communication with target during init:
504 int target_examine(struct command_context_s
*cmd_ctx
)
506 int retval
= ERROR_OK
;
507 target_t
*target
= targets
;
510 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
512 target
= target
->next
;
517 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
519 if (!target
->type
->examined
)
521 LOG_ERROR("Target not examined yet");
524 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
527 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
529 if (!target
->type
->examined
)
531 LOG_ERROR("Target not examined yet");
534 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
537 static int target_soft_reset_halt_imp(struct target_s
*target
)
539 if (!target
->type
->examined
)
541 LOG_ERROR("Target not examined yet");
544 return target
->type
->soft_reset_halt_imp(target
);
547 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
)
549 if (!target
->type
->examined
)
551 LOG_ERROR("Target not examined yet");
554 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
);
557 int target_init(struct command_context_s
*cmd_ctx
)
559 target_t
*target
= targets
;
563 target
->type
->examined
= 0;
564 if (target
->type
->examine
== NULL
)
566 target
->type
->examine
= default_examine
;
569 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
571 LOG_ERROR("target '%s' init failed", target
->type
->name
);
575 /* Set up default functions if none are provided by target */
576 if (target
->type
->virt2phys
== NULL
)
578 target
->type
->virt2phys
= default_virt2phys
;
580 target
->type
->virt2phys
= default_virt2phys
;
581 /* a non-invasive way(in terms of patches) to add some code that
582 * runs before the type->write/read_memory implementation
584 target
->type
->write_memory_imp
= target
->type
->write_memory
;
585 target
->type
->write_memory
= target_write_memory_imp
;
586 target
->type
->read_memory_imp
= target
->type
->read_memory
;
587 target
->type
->read_memory
= target_read_memory_imp
;
588 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
589 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
590 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
591 target
->type
->run_algorithm
= target_run_algorithm_imp
;
594 if (target
->type
->mmu
== NULL
)
596 target
->type
->mmu
= default_mmu
;
598 target
= target
->next
;
603 target_register_user_commands(cmd_ctx
);
604 target_register_timer_callback(handle_target
, 100, 1, NULL
);
610 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
612 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
614 if (callback
== NULL
)
616 return ERROR_INVALID_ARGUMENTS
;
621 while ((*callbacks_p
)->next
)
622 callbacks_p
= &((*callbacks_p
)->next
);
623 callbacks_p
= &((*callbacks_p
)->next
);
626 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
627 (*callbacks_p
)->callback
= callback
;
628 (*callbacks_p
)->priv
= priv
;
629 (*callbacks_p
)->next
= NULL
;
634 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
636 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
639 if (callback
== NULL
)
641 return ERROR_INVALID_ARGUMENTS
;
646 while ((*callbacks_p
)->next
)
647 callbacks_p
= &((*callbacks_p
)->next
);
648 callbacks_p
= &((*callbacks_p
)->next
);
651 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
652 (*callbacks_p
)->callback
= callback
;
653 (*callbacks_p
)->periodic
= periodic
;
654 (*callbacks_p
)->time_ms
= time_ms
;
656 gettimeofday(&now
, NULL
);
657 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
658 time_ms
-= (time_ms
% 1000);
659 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
660 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
662 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
663 (*callbacks_p
)->when
.tv_sec
+= 1;
666 (*callbacks_p
)->priv
= priv
;
667 (*callbacks_p
)->next
= NULL
;
672 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
674 target_event_callback_t
**p
= &target_event_callbacks
;
675 target_event_callback_t
*c
= target_event_callbacks
;
677 if (callback
== NULL
)
679 return ERROR_INVALID_ARGUMENTS
;
684 target_event_callback_t
*next
= c
->next
;
685 if ((c
->callback
== callback
) && (c
->priv
== priv
))
699 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
701 target_timer_callback_t
**p
= &target_timer_callbacks
;
702 target_timer_callback_t
*c
= target_timer_callbacks
;
704 if (callback
== NULL
)
706 return ERROR_INVALID_ARGUMENTS
;
711 target_timer_callback_t
*next
= c
->next
;
712 if ((c
->callback
== callback
) && (c
->priv
== priv
))
726 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
728 target_event_callback_t
*callback
= target_event_callbacks
;
729 target_event_callback_t
*next_callback
;
731 LOG_DEBUG("target event %i", event
);
735 next_callback
= callback
->next
;
736 callback
->callback(target
, event
, callback
->priv
);
737 callback
= next_callback
;
743 static int target_call_timer_callbacks_check_time(int checktime
)
745 target_timer_callback_t
*callback
= target_timer_callbacks
;
746 target_timer_callback_t
*next_callback
;
751 gettimeofday(&now
, NULL
);
755 next_callback
= callback
->next
;
757 if ((!checktime
&&callback
->periodic
)||
758 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
759 || (now
.tv_sec
> callback
->when
.tv_sec
)))
761 if(callback
->callback
!= NULL
)
763 callback
->callback(callback
->priv
);
764 if (callback
->periodic
)
766 int time_ms
= callback
->time_ms
;
767 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
768 time_ms
-= (time_ms
% 1000);
769 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
770 if (callback
->when
.tv_usec
> 1000000)
772 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
773 callback
->when
.tv_sec
+= 1;
777 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
781 callback
= next_callback
;
787 int target_call_timer_callbacks()
789 return target_call_timer_callbacks_check_time(1);
792 /* invoke periodic callbacks immediately */
793 int target_call_timer_callbacks_now()
795 return target_call_timer_callbacks(0);
798 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
800 working_area_t
*c
= target
->working_areas
;
801 working_area_t
*new_wa
= NULL
;
803 /* Reevaluate working area address based on MMU state*/
804 if (target
->working_areas
== NULL
)
808 retval
= target
->type
->mmu(target
, &enabled
);
809 if (retval
!= ERROR_OK
)
815 target
->working_area
= target
->working_area_virt
;
819 target
->working_area
= target
->working_area_phys
;
823 /* only allocate multiples of 4 byte */
826 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
827 size
= CEIL(size
, 4);
830 /* see if there's already a matching working area */
833 if ((c
->free
) && (c
->size
== size
))
841 /* if not, allocate a new one */
844 working_area_t
**p
= &target
->working_areas
;
845 u32 first_free
= target
->working_area
;
846 u32 free_size
= target
->working_area_size
;
848 LOG_DEBUG("allocating new working area");
850 c
= target
->working_areas
;
853 first_free
+= c
->size
;
854 free_size
-= c
->size
;
859 if (free_size
< size
)
861 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
862 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
865 new_wa
= malloc(sizeof(working_area_t
));
868 new_wa
->address
= first_free
;
870 if (target
->backup_working_area
)
872 new_wa
->backup
= malloc(new_wa
->size
);
873 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
877 new_wa
->backup
= NULL
;
880 /* put new entry in list */
884 /* mark as used, and return the new (reused) area */
894 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
899 if (restore
&&target
->backup_working_area
)
900 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
904 /* mark user pointer invalid */
911 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
913 return target_free_working_area_restore(target
, area
, 1);
916 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
918 working_area_t
*c
= target
->working_areas
;
922 working_area_t
*next
= c
->next
;
923 target_free_working_area_restore(target
, c
, restore
);
933 target
->working_areas
= NULL
;
938 int target_free_all_working_areas(struct target_s
*target
)
940 return target_free_all_working_areas_restore(target
, 1);
943 int target_register_commands(struct command_context_s
*cmd_ctx
)
945 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
946 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
947 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
948 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
949 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
950 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
953 /* script procedures */
954 register_jim(cmd_ctx
, "openocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
955 register_jim(cmd_ctx
, "openocd_array2mem", jim_mem2array
, "convert a TCL array to memory locations and write the values");
959 int target_arch_state(struct target_s
*target
)
964 LOG_USER("No target has been configured");
968 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
970 if (target
->state
!=TARGET_HALTED
)
973 retval
=target
->type
->arch_state(target
);
977 /* Single aligned words are guaranteed to use 16 or 32 bit access
978 * mode respectively, otherwise data is handled as quickly as
981 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
984 if (!target
->type
->examined
)
986 LOG_ERROR("Target not examined yet");
990 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
992 if (((address
% 2) == 0) && (size
== 2))
994 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
997 /* handle unaligned head bytes */
1000 int unaligned
= 4 - (address
% 4);
1002 if (unaligned
> size
)
1005 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1008 buffer
+= unaligned
;
1009 address
+= unaligned
;
1013 /* handle aligned words */
1016 int aligned
= size
- (size
% 4);
1018 /* use bulk writes above a certain limit. This may have to be changed */
1021 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1026 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1035 /* handle tail writes of less than 4 bytes */
1038 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1046 /* Single aligned words are guaranteed to use 16 or 32 bit access
1047 * mode respectively, otherwise data is handled as quickly as
1050 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1053 if (!target
->type
->examined
)
1055 LOG_ERROR("Target not examined yet");
1059 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1061 if (((address
% 2) == 0) && (size
== 2))
1063 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1066 /* handle unaligned head bytes */
1069 int unaligned
= 4 - (address
% 4);
1071 if (unaligned
> size
)
1074 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1077 buffer
+= unaligned
;
1078 address
+= unaligned
;
1082 /* handle aligned words */
1085 int aligned
= size
- (size
% 4);
1087 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1095 /* handle tail writes of less than 4 bytes */
1098 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1105 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1111 if (!target
->type
->examined
)
1113 LOG_ERROR("Target not examined yet");
1117 if ((retval
= target
->type
->checksum_memory(target
, address
,
1118 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1120 buffer
= malloc(size
);
1123 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1124 return ERROR_INVALID_ARGUMENTS
;
1126 retval
= target_read_buffer(target
, address
, size
, buffer
);
1127 if (retval
!= ERROR_OK
)
1133 /* convert to target endianess */
1134 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1137 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1138 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1141 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1150 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1153 if (!target
->type
->examined
)
1155 LOG_ERROR("Target not examined yet");
1159 if (target
->type
->blank_check_memory
== 0)
1160 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1162 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1167 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1170 if (!target
->type
->examined
)
1172 LOG_ERROR("Target not examined yet");
1176 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1178 if (retval
== ERROR_OK
)
1180 *value
= target_buffer_get_u32(target
, value_buf
);
1181 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1186 LOG_DEBUG("address: 0x%8.8x failed", address
);
1192 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1195 if (!target
->type
->examined
)
1197 LOG_ERROR("Target not examined yet");
1201 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1203 if (retval
== ERROR_OK
)
1205 *value
= target_buffer_get_u16(target
, value_buf
);
1206 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1211 LOG_DEBUG("address: 0x%8.8x failed", address
);
1217 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1219 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1220 if (!target
->type
->examined
)
1222 LOG_ERROR("Target not examined yet");
1226 if (retval
== ERROR_OK
)
1228 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1233 LOG_DEBUG("address: 0x%8.8x failed", address
);
1239 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1243 if (!target
->type
->examined
)
1245 LOG_ERROR("Target not examined yet");
1249 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1251 target_buffer_set_u32(target
, value_buf
, value
);
1252 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1254 LOG_DEBUG("failed: %i", retval
);
1260 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1264 if (!target
->type
->examined
)
1266 LOG_ERROR("Target not examined yet");
1270 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1272 target_buffer_set_u16(target
, value_buf
, value
);
1273 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1275 LOG_DEBUG("failed: %i", retval
);
1281 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1284 if (!target
->type
->examined
)
1286 LOG_ERROR("Target not examined yet");
1290 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1292 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1294 LOG_DEBUG("failed: %i", retval
);
1300 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1302 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1303 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1304 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1305 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1306 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1307 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1308 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1309 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1311 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1312 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1313 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1315 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1316 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1317 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1319 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1320 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1321 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1322 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1324 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1325 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1326 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1327 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1328 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1330 target_request_register_commands(cmd_ctx
);
1331 trace_register_commands(cmd_ctx
);
1336 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1338 target_t
*target
= targets
;
1343 int num
= strtoul(args
[0], NULL
, 0);
1348 target
= target
->next
;
1352 cmd_ctx
->current_target
= num
;
1354 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1361 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1362 target
= target
->next
;
1368 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1375 return ERROR_COMMAND_SYNTAX_ERROR
;
1378 /* search for the specified target */
1379 if (args
[0] && (args
[0][0] != 0))
1381 for (i
= 0; target_types
[i
]; i
++)
1383 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1385 target_t
**last_target_p
= &targets
;
1387 /* register target specific commands */
1388 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1390 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1396 while ((*last_target_p
)->next
)
1397 last_target_p
= &((*last_target_p
)->next
);
1398 last_target_p
= &((*last_target_p
)->next
);
1401 *last_target_p
= malloc(sizeof(target_t
));
1403 /* allocate memory for each unique target type */
1404 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1405 *((*last_target_p
)->type
) = *target_types
[i
];
1407 if (strcmp(args
[1], "big") == 0)
1408 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1409 else if (strcmp(args
[1], "little") == 0)
1410 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1413 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1414 return ERROR_COMMAND_SYNTAX_ERROR
;
1417 /* what to do on a target reset */
1418 (*last_target_p
)->reset_mode
= RESET_INIT
; /* default */
1419 if (strcmp(args
[2], "reset_halt") == 0)
1420 (*last_target_p
)->reset_mode
= RESET_HALT
;
1421 else if (strcmp(args
[2], "reset_run") == 0)
1422 (*last_target_p
)->reset_mode
= RESET_RUN
;
1423 else if (strcmp(args
[2], "reset_init") == 0)
1424 (*last_target_p
)->reset_mode
= RESET_INIT
;
1425 else if (strcmp(args
[2], "run_and_halt") == 0)
1426 (*last_target_p
)->reset_mode
= RESET_RUN_AND_HALT
;
1427 else if (strcmp(args
[2], "run_and_init") == 0)
1428 (*last_target_p
)->reset_mode
= RESET_RUN_AND_INIT
;
1431 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1435 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1437 (*last_target_p
)->working_area
= 0x0;
1438 (*last_target_p
)->working_area_size
= 0x0;
1439 (*last_target_p
)->working_areas
= NULL
;
1440 (*last_target_p
)->backup_working_area
= 0;
1442 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1443 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1444 (*last_target_p
)->reg_cache
= NULL
;
1445 (*last_target_p
)->breakpoints
= NULL
;
1446 (*last_target_p
)->watchpoints
= NULL
;
1447 (*last_target_p
)->next
= NULL
;
1448 (*last_target_p
)->arch_info
= NULL
;
1450 /* initialize trace information */
1451 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1452 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1453 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1454 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1455 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1456 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1457 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1458 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1460 (*last_target_p
)->dbgmsg
= NULL
;
1461 (*last_target_p
)->dbg_msg_enabled
= 0;
1463 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1471 /* no matching target found */
1474 LOG_ERROR("target '%s' not found", args
[0]);
1475 return ERROR_COMMAND_SYNTAX_ERROR
;
1481 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1483 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
1484 name
, get_num_by_target(target
),
1485 name
, get_num_by_target(target
));
1488 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1490 target_t
*target
= NULL
;
1494 return ERROR_COMMAND_SYNTAX_ERROR
;
1497 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1500 return ERROR_COMMAND_SYNTAX_ERROR
;
1503 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1508 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1510 target_t
*target
= NULL
;
1512 if ((argc
< 4) || (argc
> 5))
1514 return ERROR_COMMAND_SYNTAX_ERROR
;
1517 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1520 return ERROR_COMMAND_SYNTAX_ERROR
;
1522 target_free_all_working_areas(target
);
1524 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1527 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1529 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1531 if (strcmp(args
[3], "backup") == 0)
1533 target
->backup_working_area
= 1;
1535 else if (strcmp(args
[3], "nobackup") == 0)
1537 target
->backup_working_area
= 0;
1541 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1542 return ERROR_COMMAND_SYNTAX_ERROR
;
1549 /* process target state changes */
1550 int handle_target(void *priv
)
1552 target_t
*target
= targets
;
1556 if (target_continous_poll
)
1558 /* polling may fail silently until the target has been examined */
1559 target_poll(target
);
1562 target
= target
->next
;
1568 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1577 target
= get_current_target(cmd_ctx
);
1579 /* list all available registers for the current target */
1582 reg_cache_t
*cache
= target
->reg_cache
;
1588 for (i
= 0; i
< cache
->num_regs
; i
++)
1590 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1591 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
);
1594 cache
= cache
->next
;
1600 /* access a single register by its ordinal number */
1601 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1603 int num
= strtoul(args
[0], NULL
, 0);
1604 reg_cache_t
*cache
= target
->reg_cache
;
1610 for (i
= 0; i
< cache
->num_regs
; i
++)
1614 reg
= &cache
->reg_list
[i
];
1620 cache
= cache
->next
;
1625 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1628 } else /* access a single register by its name */
1630 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1634 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1639 /* display a register */
1640 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1642 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1645 if (reg
->valid
== 0)
1647 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1648 if (arch_type
== NULL
)
1650 LOG_ERROR("BUG: encountered unregistered arch type");
1653 arch_type
->get(reg
);
1655 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1656 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1661 /* set register value */
1664 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1665 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1667 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1668 if (arch_type
== NULL
)
1670 LOG_ERROR("BUG: encountered unregistered arch type");
1674 arch_type
->set(reg
, buf
);
1676 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1677 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1685 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1690 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1692 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1694 target_t
*target
= get_current_target(cmd_ctx
);
1698 target_poll(target
);
1699 target_arch_state(target
);
1703 if (strcmp(args
[0], "on") == 0)
1705 target_continous_poll
= 1;
1707 else if (strcmp(args
[0], "off") == 0)
1709 target_continous_poll
= 0;
1713 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1721 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1729 ms
= strtoul(args
[0], &end
, 0) * 1000;
1732 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1737 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1740 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1743 struct timeval timeout
, now
;
1745 gettimeofday(&timeout
, NULL
);
1746 timeval_add_time(&timeout
, 0, ms
* 1000);
1748 target_t
*target
= get_current_target(cmd_ctx
);
1751 if ((retval
=target_poll(target
))!=ERROR_OK
)
1753 target_call_timer_callbacks_now();
1754 if (target
->state
== state
)
1761 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1764 gettimeofday(&now
, NULL
);
1765 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1767 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1775 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1778 target_t
*target
= get_current_target(cmd_ctx
);
1782 if ((retval
= target_halt(target
)) != ERROR_OK
)
1787 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1790 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1792 target_t
*target
= get_current_target(cmd_ctx
);
1794 LOG_USER("requesting target halt and executing a soft reset");
1796 target
->type
->soft_reset_halt(target
);
1801 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1803 target_t
*target
= get_current_target(cmd_ctx
);
1804 enum target_reset_mode reset_mode
= target
->reset_mode
;
1805 enum target_reset_mode save
= target
->reset_mode
;
1811 if (strcmp("run", args
[0]) == 0)
1812 reset_mode
= RESET_RUN
;
1813 else if (strcmp("halt", args
[0]) == 0)
1814 reset_mode
= RESET_HALT
;
1815 else if (strcmp("init", args
[0]) == 0)
1816 reset_mode
= RESET_INIT
;
1817 else if (strcmp("run_and_halt", args
[0]) == 0)
1819 reset_mode
= RESET_RUN_AND_HALT
;
1822 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1825 else if (strcmp("run_and_init", args
[0]) == 0)
1827 reset_mode
= RESET_RUN_AND_INIT
;
1830 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1835 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1840 /* temporarily modify mode of current reset target */
1841 target
->reset_mode
= reset_mode
;
1843 /* reset *all* targets */
1844 target_process_reset(cmd_ctx
);
1846 /* Restore default reset mode for this target */
1847 target
->reset_mode
= save
;
1852 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1855 target_t
*target
= get_current_target(cmd_ctx
);
1857 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1860 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1862 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1865 return ERROR_COMMAND_SYNTAX_ERROR
;
1871 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1873 target_t
*target
= get_current_target(cmd_ctx
);
1878 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1881 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1886 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1888 const int line_bytecnt
= 32;
1901 target_t
*target
= get_current_target(cmd_ctx
);
1907 count
= strtoul(args
[1], NULL
, 0);
1909 address
= strtoul(args
[0], NULL
, 0);
1915 size
= 4; line_modulo
= line_bytecnt
/ 4;
1918 size
= 2; line_modulo
= line_bytecnt
/ 2;
1921 size
= 1; line_modulo
= line_bytecnt
/ 1;
1927 buffer
= calloc(count
, size
);
1928 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1929 if (retval
== ERROR_OK
)
1933 for (i
= 0; i
< count
; i
++)
1935 if (i
%line_modulo
== 0)
1936 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1941 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1944 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1947 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1951 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1953 command_print(cmd_ctx
, output
);
1964 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1971 target_t
*target
= get_current_target(cmd_ctx
);
1974 if ((argc
< 2) || (argc
> 3))
1975 return ERROR_COMMAND_SYNTAX_ERROR
;
1977 address
= strtoul(args
[0], NULL
, 0);
1978 value
= strtoul(args
[1], NULL
, 0);
1980 count
= strtoul(args
[2], NULL
, 0);
1986 target_buffer_set_u32(target
, value_buf
, value
);
1990 target_buffer_set_u16(target
, value_buf
, value
);
1994 value_buf
[0] = value
;
1997 return ERROR_COMMAND_SYNTAX_ERROR
;
1999 for (i
=0; i
<count
; i
++)
2005 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2008 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2011 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2016 if (retval
!=ERROR_OK
)
2026 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2036 duration_t duration
;
2037 char *duration_text
;
2039 target_t
*target
= get_current_target(cmd_ctx
);
2043 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2047 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2050 image
.base_address_set
= 1;
2051 image
.base_address
= strtoul(args
[1], NULL
, 0);
2055 image
.base_address_set
= 0;
2058 image
.start_address_set
= 0;
2060 duration_start_measure(&duration
);
2062 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2069 for (i
= 0; i
< image
.num_sections
; i
++)
2071 buffer
= malloc(image
.sections
[i
].size
);
2074 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2078 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2083 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2088 image_size
+= buf_cnt
;
2089 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2094 duration_stop_measure(&duration
, &duration_text
);
2095 if (retval
==ERROR_OK
)
2097 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2099 free(duration_text
);
2101 image_close(&image
);
2107 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2114 int retval
=ERROR_OK
;
2116 duration_t duration
;
2117 char *duration_text
;
2119 target_t
*target
= get_current_target(cmd_ctx
);
2123 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2127 address
= strtoul(args
[1], NULL
, 0);
2128 size
= strtoul(args
[2], NULL
, 0);
2130 if ((address
& 3) || (size
& 3))
2132 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2136 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2141 duration_start_measure(&duration
);
2146 u32 this_run_size
= (size
> 560) ? 560 : size
;
2148 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2149 if (retval
!= ERROR_OK
)
2154 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2155 if (retval
!= ERROR_OK
)
2160 size
-= this_run_size
;
2161 address
+= this_run_size
;
2164 fileio_close(&fileio
);
2166 duration_stop_measure(&duration
, &duration_text
);
2167 if (retval
==ERROR_OK
)
2169 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2171 free(duration_text
);
2176 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2184 u32 mem_checksum
= 0;
2188 duration_t duration
;
2189 char *duration_text
;
2191 target_t
*target
= get_current_target(cmd_ctx
);
2195 return ERROR_COMMAND_SYNTAX_ERROR
;
2200 LOG_ERROR("no target selected");
2204 duration_start_measure(&duration
);
2208 image
.base_address_set
= 1;
2209 image
.base_address
= strtoul(args
[1], NULL
, 0);
2213 image
.base_address_set
= 0;
2214 image
.base_address
= 0x0;
2217 image
.start_address_set
= 0;
2219 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2226 for (i
= 0; i
< image
.num_sections
; i
++)
2228 buffer
= malloc(image
.sections
[i
].size
);
2231 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2234 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2240 /* calculate checksum of image */
2241 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2243 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2244 if( retval
!= ERROR_OK
)
2250 if( checksum
!= mem_checksum
)
2252 /* failed crc checksum, fall back to a binary compare */
2255 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2257 data
= (u8
*)malloc(buf_cnt
);
2259 /* Can we use 32bit word accesses? */
2261 int count
= buf_cnt
;
2262 if ((count
% 4) == 0)
2267 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2268 if (retval
== ERROR_OK
)
2271 for (t
= 0; t
< buf_cnt
; t
++)
2273 if (data
[t
] != buffer
[t
])
2275 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
]);
2288 image_size
+= buf_cnt
;
2291 duration_stop_measure(&duration
, &duration_text
);
2292 if (retval
==ERROR_OK
)
2294 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2296 free(duration_text
);
2298 image_close(&image
);
2303 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2306 target_t
*target
= get_current_target(cmd_ctx
);
2310 breakpoint_t
*breakpoint
= target
->breakpoints
;
2314 if (breakpoint
->type
== BKPT_SOFT
)
2316 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2317 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2322 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2324 breakpoint
= breakpoint
->next
;
2332 length
= strtoul(args
[1], NULL
, 0);
2335 if (strcmp(args
[2], "hw") == 0)
2338 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2340 LOG_ERROR("Failure setting breakpoints");
2344 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2349 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2355 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2357 target_t
*target
= get_current_target(cmd_ctx
);
2360 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2365 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2367 target_t
*target
= get_current_target(cmd_ctx
);
2372 watchpoint_t
*watchpoint
= target
->watchpoints
;
2376 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
);
2377 watchpoint
= watchpoint
->next
;
2382 enum watchpoint_rw type
= WPT_ACCESS
;
2383 u32 data_value
= 0x0;
2384 u32 data_mask
= 0xffffffff;
2400 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2406 data_value
= strtoul(args
[3], NULL
, 0);
2410 data_mask
= strtoul(args
[4], NULL
, 0);
2413 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2414 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2416 LOG_ERROR("Failure setting breakpoints");
2421 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2427 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2429 target_t
*target
= get_current_target(cmd_ctx
);
2432 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2437 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2440 target_t
*target
= get_current_target(cmd_ctx
);
2446 return ERROR_COMMAND_SYNTAX_ERROR
;
2448 va
= strtoul(args
[0], NULL
, 0);
2450 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2451 if (retval
== ERROR_OK
)
2453 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2457 /* lower levels will have logged a detailed error which is
2458 * forwarded to telnet/GDB session.
2463 static void writeLong(FILE *f
, int l
)
2468 char c
=(l
>>(i
*8))&0xff;
2469 fwrite(&c
, 1, 1, f
);
2473 static void writeString(FILE *f
, char *s
)
2475 fwrite(s
, 1, strlen(s
), f
);
2480 // Dump a gmon.out histogram file.
2481 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2484 FILE *f
=fopen(filename
, "w");
2487 fwrite("gmon", 1, 4, f
);
2488 writeLong(f
, 0x00000001); // Version
2489 writeLong(f
, 0); // padding
2490 writeLong(f
, 0); // padding
2491 writeLong(f
, 0); // padding
2493 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2495 // figure out bucket size
2498 for (i
=0; i
<sampleNum
; i
++)
2510 int addressSpace
=(max
-min
+1);
2512 static int const maxBuckets
=256*1024; // maximum buckets.
2513 int length
=addressSpace
;
2514 if (length
> maxBuckets
)
2518 int *buckets
=malloc(sizeof(int)*length
);
2524 memset(buckets
, 0, sizeof(int)*length
);
2525 for (i
=0; i
<sampleNum
;i
++)
2527 u32 address
=samples
[i
];
2528 long long a
=address
-min
;
2529 long long b
=length
-1;
2530 long long c
=addressSpace
-1;
2531 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2535 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2536 writeLong(f
, min
); // low_pc
2537 writeLong(f
, max
); // high_pc
2538 writeLong(f
, length
); // # of samples
2539 writeLong(f
, 64000000); // 64MHz
2540 writeString(f
, "seconds");
2541 for (i
=0; i
<(15-strlen("seconds")); i
++)
2543 fwrite("", 1, 1, f
); // padding
2545 writeString(f
, "s");
2547 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2549 char *data
=malloc(2*length
);
2552 for (i
=0; i
<length
;i
++)
2561 data
[i
*2+1]=(val
>>8)&0xff;
2564 fwrite(data
, 1, length
*2, f
);
2574 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2575 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2577 target_t
*target
= get_current_target(cmd_ctx
);
2578 struct timeval timeout
, now
;
2580 gettimeofday(&timeout
, NULL
);
2583 return ERROR_COMMAND_SYNTAX_ERROR
;
2586 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2592 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2594 static const int maxSample
=10000;
2595 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2600 int retval
=ERROR_OK
;
2601 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2602 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2606 target_poll(target
);
2607 if (target
->state
== TARGET_HALTED
)
2609 u32 t
=*((u32
*)reg
->value
);
2610 samples
[numSamples
++]=t
;
2611 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2612 target_poll(target
);
2613 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2614 } else if (target
->state
== TARGET_RUNNING
)
2616 // We want to quickly sample the PC.
2617 target_halt(target
);
2620 command_print(cmd_ctx
, "Target not halted or running");
2624 if (retval
!=ERROR_OK
)
2629 gettimeofday(&now
, NULL
);
2630 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2632 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2633 target_poll(target
);
2634 if (target
->state
== TARGET_HALTED
)
2636 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2638 target_poll(target
);
2639 writeGmon(samples
, numSamples
, args
[1]);
2640 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2649 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2652 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2655 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2659 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2660 valObjPtr
= Jim_NewIntObj(interp
, val
);
2661 if (!nameObjPtr
|| !valObjPtr
)
2667 Jim_IncrRefCount(nameObjPtr
);
2668 Jim_IncrRefCount(valObjPtr
);
2669 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2670 Jim_DecrRefCount(interp
, nameObjPtr
);
2671 Jim_DecrRefCount(interp
, valObjPtr
);
2673 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2677 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2680 command_context_t
*context
;
2687 const char *varname
;
2689 int i
, n
, e
, retval
;
2691 /* argv[1] = name of array to receive the data
2692 * argv[2] = desired width
2693 * argv[3] = memory address
2694 * argv[4] = count of times to read
2697 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2700 varname
= Jim_GetString(argv
[1], &len
);
2701 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2703 e
= Jim_GetLong(interp
, argv
[2], &l
);
2709 e
= Jim_GetLong(interp
, argv
[3], &l
);
2714 e
= Jim_GetLong(interp
, argv
[4], &l
);
2730 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2731 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2735 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2736 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2739 if ((addr
+ (len
* width
)) < addr
) {
2740 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2741 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2744 /* absurd transfer size? */
2746 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2747 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2752 ((width
== 2) && ((addr
& 1) == 0)) ||
2753 ((width
== 4) && ((addr
& 3) == 0))) {
2757 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2758 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2759 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2763 context
= Jim_GetAssocData(interp
, "context");
2764 if (context
== NULL
)
2766 LOG_ERROR("mem2array: no command context");
2769 target
= get_current_target(context
);
2772 LOG_ERROR("mem2array: no current target");
2783 /* Slurp... in buffer size chunks */
2785 count
= len
; /* in objects.. */
2786 if (count
> (sizeof(buffer
)/width
)) {
2787 count
= (sizeof(buffer
)/width
);
2790 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2791 if (retval
!= ERROR_OK
) {
2793 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2794 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2795 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2799 v
= 0; /* shut up gcc */
2800 for (i
= 0 ;i
< count
;i
++, n
++) {
2803 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2806 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2809 v
= buffer
[i
] & 0x0ff;
2812 new_int_array_element(interp
, varname
, n
, v
);
2818 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2823 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2826 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2830 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2834 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2841 Jim_IncrRefCount(nameObjPtr
);
2842 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2843 Jim_DecrRefCount(interp
, nameObjPtr
);
2845 if (valObjPtr
== NULL
)
2848 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2849 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2854 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2857 command_context_t
*context
;
2864 const char *varname
;
2866 int i
, n
, e
, retval
;
2868 /* argv[1] = name of array to get the data
2869 * argv[2] = desired width
2870 * argv[3] = memory address
2871 * argv[4] = count to write
2874 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2877 varname
= Jim_GetString(argv
[1], &len
);
2878 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2880 e
= Jim_GetLong(interp
, argv
[2], &l
);
2886 e
= Jim_GetLong(interp
, argv
[3], &l
);
2891 e
= Jim_GetLong(interp
, argv
[4], &l
);
2907 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2908 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2912 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2913 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2916 if ((addr
+ (len
* width
)) < addr
) {
2917 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2918 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2921 /* absurd transfer size? */
2923 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2924 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2929 ((width
== 2) && ((addr
& 1) == 0)) ||
2930 ((width
== 4) && ((addr
& 3) == 0))) {
2934 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2935 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2936 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2940 context
= Jim_GetAssocData(interp
, "context");
2941 if (context
== NULL
)
2943 LOG_ERROR("array2mem: no command context");
2946 target
= get_current_target(context
);
2949 LOG_ERROR("array2mem: no current target");
2960 /* Slurp... in buffer size chunks */
2962 count
= len
; /* in objects.. */
2963 if (count
> (sizeof(buffer
)/width
)) {
2964 count
= (sizeof(buffer
)/width
);
2967 v
= 0; /* shut up gcc */
2968 for (i
= 0 ;i
< count
;i
++, n
++) {
2969 get_int_array_element(interp
, varname
, n
, &v
);
2972 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2975 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2978 buffer
[i
] = v
& 0x0ff;
2984 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2985 if (retval
!= ERROR_OK
) {
2987 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2988 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2989 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2995 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)