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 keep_alive(); /* we might be running on a very slow JTAG clk */
307 /* First time this is executed after launching OpenOCD, it will read out
308 * the type of CPU, etc. and init Embedded ICE registers in host
311 * It will also set up ICE registers in the target.
313 * However, if we assert TRST later, we need to set up the registers again.
315 * For the "reset halt/init" case we must only set up the registers here.
317 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
320 keep_alive(); /* we might be running on a very slow JTAG clk */
322 /* prepare reset_halt where necessary */
326 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
328 switch (target
->reset_mode
)
331 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
332 target
->reset_mode
= RESET_RUN_AND_HALT
;
335 command_print(cmd_ctx
, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
336 target
->reset_mode
= RESET_RUN_AND_INIT
;
342 target
= target
->next
;
348 /* we have no idea what state the target is in, so we
349 * have to drop working areas
351 target_free_all_working_areas_restore(target
, 0);
352 target
->type
->assert_reset(target
);
353 target
= target
->next
;
355 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
357 LOG_WARNING("JTAG communication failed asserting reset.");
361 /* request target halt if necessary, and schedule further action */
365 switch (target
->reset_mode
)
368 /* nothing to do if target just wants to be run */
370 case RESET_RUN_AND_HALT
:
372 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
374 case RESET_RUN_AND_INIT
:
376 target_register_timer_callback(target_run_and_halt_handler
, target
->run_and_halt_time
, 0, target
);
377 target_register_event_callback(target_init_handler
, cmd_ctx
);
384 target_register_event_callback(target_init_handler
, cmd_ctx
);
387 LOG_ERROR("BUG: unknown target->reset_mode");
389 target
= target
->next
;
392 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
394 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
401 target
->type
->deassert_reset(target
);
402 target
= target
->next
;
405 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
407 LOG_WARNING("JTAG communication failed while deasserting reset.");
411 if (jtag_reset_config
& RESET_SRST_PULLS_TRST
)
413 /* If TRST was asserted we need to set up registers again */
414 if ((retval
= target_examine(cmd_ctx
)) != ERROR_OK
)
418 /* post reset scripts can be quite long, increase speed now. If post
419 * reset scripts needs a different speed, they can set the speed to
420 * whatever they need.
422 jtag
->speed(jtag_speed_post_reset
);
424 LOG_DEBUG("Waiting for halted stated as approperiate");
426 /* Wait for reset to complete, maximum 5 seconds. */
427 gettimeofday(&timeout
, NULL
);
428 timeval_add_time(&timeout
, 5, 0);
431 gettimeofday(&now
, NULL
);
433 target_call_timer_callbacks_now();
438 LOG_DEBUG("Polling target");
440 if ((target
->reset_mode
== RESET_RUN_AND_INIT
) ||
441 (target
->reset_mode
== RESET_RUN_AND_HALT
) ||
442 (target
->reset_mode
== RESET_HALT
) ||
443 (target
->reset_mode
== RESET_INIT
))
445 if (target
->state
!= TARGET_HALTED
)
447 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
449 LOG_USER("Timed out waiting for halt after reset");
452 /* this will send alive messages on e.g. GDB remote protocol. */
454 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
458 target
= target
->next
;
460 /* All targets we're waiting for are halted */
468 /* We want any events to be processed before the prompt */
469 target_call_timer_callbacks_now();
471 /* if we timed out we need to unregister these handlers */
475 target_unregister_timer_callback(target_run_and_halt_handler
, target
);
476 target
= target
->next
;
478 target_unregister_event_callback(target_init_handler
, cmd_ctx
);
484 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
490 static int default_mmu(struct target_s
*target
, int *enabled
)
496 static int default_examine(struct command_context_s
*cmd_ctx
, struct target_s
*target
)
498 target
->type
->examined
= 1;
503 /* Targets that correctly implement init+examine, i.e.
504 * no communication with target during init:
508 int target_examine(struct command_context_s
*cmd_ctx
)
510 int retval
= ERROR_OK
;
511 target_t
*target
= targets
;
514 if ((retval
= target
->type
->examine(cmd_ctx
, target
))!=ERROR_OK
)
516 target
= target
->next
;
521 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
523 if (!target
->type
->examined
)
525 LOG_ERROR("Target not examined yet");
528 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
531 static int target_read_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
->read_memory_imp(target
, address
, size
, count
, buffer
);
541 static int target_soft_reset_halt_imp(struct target_s
*target
)
543 if (!target
->type
->examined
)
545 LOG_ERROR("Target not examined yet");
548 return target
->type
->soft_reset_halt_imp(target
);
551 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
)
553 if (!target
->type
->examined
)
555 LOG_ERROR("Target not examined yet");
558 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
);
561 int target_init(struct command_context_s
*cmd_ctx
)
563 target_t
*target
= targets
;
567 target
->type
->examined
= 0;
568 if (target
->type
->examine
== NULL
)
570 target
->type
->examine
= default_examine
;
573 if (target
->type
->init_target(cmd_ctx
, target
) != ERROR_OK
)
575 LOG_ERROR("target '%s' init failed", target
->type
->name
);
579 /* Set up default functions if none are provided by target */
580 if (target
->type
->virt2phys
== NULL
)
582 target
->type
->virt2phys
= default_virt2phys
;
584 target
->type
->virt2phys
= default_virt2phys
;
585 /* a non-invasive way(in terms of patches) to add some code that
586 * runs before the type->write/read_memory implementation
588 target
->type
->write_memory_imp
= target
->type
->write_memory
;
589 target
->type
->write_memory
= target_write_memory_imp
;
590 target
->type
->read_memory_imp
= target
->type
->read_memory
;
591 target
->type
->read_memory
= target_read_memory_imp
;
592 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
593 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
594 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
595 target
->type
->run_algorithm
= target_run_algorithm_imp
;
598 if (target
->type
->mmu
== NULL
)
600 target
->type
->mmu
= default_mmu
;
602 target
= target
->next
;
607 target_register_user_commands(cmd_ctx
);
608 target_register_timer_callback(handle_target
, 100, 1, NULL
);
614 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
616 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
618 if (callback
== NULL
)
620 return ERROR_INVALID_ARGUMENTS
;
625 while ((*callbacks_p
)->next
)
626 callbacks_p
= &((*callbacks_p
)->next
);
627 callbacks_p
= &((*callbacks_p
)->next
);
630 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
631 (*callbacks_p
)->callback
= callback
;
632 (*callbacks_p
)->priv
= priv
;
633 (*callbacks_p
)->next
= NULL
;
638 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
640 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
643 if (callback
== NULL
)
645 return ERROR_INVALID_ARGUMENTS
;
650 while ((*callbacks_p
)->next
)
651 callbacks_p
= &((*callbacks_p
)->next
);
652 callbacks_p
= &((*callbacks_p
)->next
);
655 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
656 (*callbacks_p
)->callback
= callback
;
657 (*callbacks_p
)->periodic
= periodic
;
658 (*callbacks_p
)->time_ms
= time_ms
;
660 gettimeofday(&now
, NULL
);
661 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
662 time_ms
-= (time_ms
% 1000);
663 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
664 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
666 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
667 (*callbacks_p
)->when
.tv_sec
+= 1;
670 (*callbacks_p
)->priv
= priv
;
671 (*callbacks_p
)->next
= NULL
;
676 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
678 target_event_callback_t
**p
= &target_event_callbacks
;
679 target_event_callback_t
*c
= target_event_callbacks
;
681 if (callback
== NULL
)
683 return ERROR_INVALID_ARGUMENTS
;
688 target_event_callback_t
*next
= c
->next
;
689 if ((c
->callback
== callback
) && (c
->priv
== priv
))
703 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
705 target_timer_callback_t
**p
= &target_timer_callbacks
;
706 target_timer_callback_t
*c
= target_timer_callbacks
;
708 if (callback
== NULL
)
710 return ERROR_INVALID_ARGUMENTS
;
715 target_timer_callback_t
*next
= c
->next
;
716 if ((c
->callback
== callback
) && (c
->priv
== priv
))
730 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
732 target_event_callback_t
*callback
= target_event_callbacks
;
733 target_event_callback_t
*next_callback
;
735 LOG_DEBUG("target event %i", event
);
739 next_callback
= callback
->next
;
740 callback
->callback(target
, event
, callback
->priv
);
741 callback
= next_callback
;
747 static int target_call_timer_callbacks_check_time(int checktime
)
749 target_timer_callback_t
*callback
= target_timer_callbacks
;
750 target_timer_callback_t
*next_callback
;
755 gettimeofday(&now
, NULL
);
759 next_callback
= callback
->next
;
761 if ((!checktime
&&callback
->periodic
)||
762 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
763 || (now
.tv_sec
> callback
->when
.tv_sec
)))
765 if(callback
->callback
!= NULL
)
767 callback
->callback(callback
->priv
);
768 if (callback
->periodic
)
770 int time_ms
= callback
->time_ms
;
771 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
772 time_ms
-= (time_ms
% 1000);
773 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
774 if (callback
->when
.tv_usec
> 1000000)
776 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
777 callback
->when
.tv_sec
+= 1;
781 target_unregister_timer_callback(callback
->callback
, callback
->priv
);
785 callback
= next_callback
;
791 int target_call_timer_callbacks()
793 return target_call_timer_callbacks_check_time(1);
796 /* invoke periodic callbacks immediately */
797 int target_call_timer_callbacks_now()
799 return target_call_timer_callbacks(0);
802 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
804 working_area_t
*c
= target
->working_areas
;
805 working_area_t
*new_wa
= NULL
;
807 /* Reevaluate working area address based on MMU state*/
808 if (target
->working_areas
== NULL
)
812 retval
= target
->type
->mmu(target
, &enabled
);
813 if (retval
!= ERROR_OK
)
819 target
->working_area
= target
->working_area_virt
;
823 target
->working_area
= target
->working_area_phys
;
827 /* only allocate multiples of 4 byte */
830 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
831 size
= CEIL(size
, 4);
834 /* see if there's already a matching working area */
837 if ((c
->free
) && (c
->size
== size
))
845 /* if not, allocate a new one */
848 working_area_t
**p
= &target
->working_areas
;
849 u32 first_free
= target
->working_area
;
850 u32 free_size
= target
->working_area_size
;
852 LOG_DEBUG("allocating new working area");
854 c
= target
->working_areas
;
857 first_free
+= c
->size
;
858 free_size
-= c
->size
;
863 if (free_size
< size
)
865 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
866 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
869 new_wa
= malloc(sizeof(working_area_t
));
872 new_wa
->address
= first_free
;
874 if (target
->backup_working_area
)
876 new_wa
->backup
= malloc(new_wa
->size
);
877 target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
);
881 new_wa
->backup
= NULL
;
884 /* put new entry in list */
888 /* mark as used, and return the new (reused) area */
898 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
903 if (restore
&&target
->backup_working_area
)
904 target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
);
908 /* mark user pointer invalid */
915 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
917 return target_free_working_area_restore(target
, area
, 1);
920 int target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
922 working_area_t
*c
= target
->working_areas
;
926 working_area_t
*next
= c
->next
;
927 target_free_working_area_restore(target
, c
, restore
);
937 target
->working_areas
= NULL
;
942 int target_free_all_working_areas(struct target_s
*target
)
944 return target_free_all_working_areas_restore(target
, 1);
947 int target_register_commands(struct command_context_s
*cmd_ctx
)
949 register_command(cmd_ctx
, NULL
, "target", handle_target_command
, COMMAND_CONFIG
, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
950 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, NULL
);
951 register_command(cmd_ctx
, NULL
, "run_and_halt_time", handle_run_and_halt_time_command
, COMMAND_CONFIG
, "<target> <run time ms>");
952 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
953 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "virt2phys <virtual address>");
954 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "PRELIMINARY! - profile <seconds> <gmon.out>");
957 /* script procedures */
958 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
959 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
963 int target_arch_state(struct target_s
*target
)
968 LOG_USER("No target has been configured");
972 LOG_USER("target state: %s", target_state_strings
[target
->state
]);
974 if (target
->state
!=TARGET_HALTED
)
977 retval
=target
->type
->arch_state(target
);
981 /* Single aligned words are guaranteed to use 16 or 32 bit access
982 * mode respectively, otherwise data is handled as quickly as
985 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
988 if (!target
->type
->examined
)
990 LOG_ERROR("Target not examined yet");
994 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
996 if (((address
% 2) == 0) && (size
== 2))
998 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
1001 /* handle unaligned head bytes */
1004 int unaligned
= 4 - (address
% 4);
1006 if (unaligned
> size
)
1009 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1012 buffer
+= unaligned
;
1013 address
+= unaligned
;
1017 /* handle aligned words */
1020 int aligned
= size
- (size
% 4);
1022 /* use bulk writes above a certain limit. This may have to be changed */
1025 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1030 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1039 /* handle tail writes of less than 4 bytes */
1042 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1050 /* Single aligned words are guaranteed to use 16 or 32 bit access
1051 * mode respectively, otherwise data is handled as quickly as
1054 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1057 if (!target
->type
->examined
)
1059 LOG_ERROR("Target not examined yet");
1063 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1065 if (((address
% 2) == 0) && (size
== 2))
1067 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1070 /* handle unaligned head bytes */
1073 int unaligned
= 4 - (address
% 4);
1075 if (unaligned
> size
)
1078 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1081 buffer
+= unaligned
;
1082 address
+= unaligned
;
1086 /* handle aligned words */
1089 int aligned
= size
- (size
% 4);
1091 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1099 /* handle tail writes of less than 4 bytes */
1102 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1109 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1115 if (!target
->type
->examined
)
1117 LOG_ERROR("Target not examined yet");
1121 if ((retval
= target
->type
->checksum_memory(target
, address
,
1122 size
, &checksum
)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
1124 buffer
= malloc(size
);
1127 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1128 return ERROR_INVALID_ARGUMENTS
;
1130 retval
= target_read_buffer(target
, address
, size
, buffer
);
1131 if (retval
!= ERROR_OK
)
1137 /* convert to target endianess */
1138 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1141 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1142 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1145 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1154 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1157 if (!target
->type
->examined
)
1159 LOG_ERROR("Target not examined yet");
1163 if (target
->type
->blank_check_memory
== 0)
1164 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1166 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1171 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1174 if (!target
->type
->examined
)
1176 LOG_ERROR("Target not examined yet");
1180 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1182 if (retval
== ERROR_OK
)
1184 *value
= target_buffer_get_u32(target
, value_buf
);
1185 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1190 LOG_DEBUG("address: 0x%8.8x failed", address
);
1196 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1199 if (!target
->type
->examined
)
1201 LOG_ERROR("Target not examined yet");
1205 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1207 if (retval
== ERROR_OK
)
1209 *value
= target_buffer_get_u16(target
, value_buf
);
1210 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1215 LOG_DEBUG("address: 0x%8.8x failed", address
);
1221 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1223 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1224 if (!target
->type
->examined
)
1226 LOG_ERROR("Target not examined yet");
1230 if (retval
== ERROR_OK
)
1232 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1237 LOG_DEBUG("address: 0x%8.8x failed", address
);
1243 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1247 if (!target
->type
->examined
)
1249 LOG_ERROR("Target not examined yet");
1253 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1255 target_buffer_set_u32(target
, value_buf
, value
);
1256 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1258 LOG_DEBUG("failed: %i", retval
);
1264 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1268 if (!target
->type
->examined
)
1270 LOG_ERROR("Target not examined yet");
1274 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1276 target_buffer_set_u16(target
, value_buf
, value
);
1277 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1279 LOG_DEBUG("failed: %i", retval
);
1285 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1288 if (!target
->type
->examined
)
1290 LOG_ERROR("Target not examined yet");
1294 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1296 if ((retval
= target
->type
->read_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1298 LOG_DEBUG("failed: %i", retval
);
1304 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1306 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, NULL
);
1307 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1308 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1309 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1310 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1311 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1312 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init|run_and_halt|run_and_init]");
1313 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1315 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1316 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1317 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1319 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1320 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1321 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1323 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1324 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1325 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1326 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1328 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1329 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1330 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1331 register_command(cmd_ctx
, NULL
, "load_binary", handle_load_image_command
, COMMAND_EXEC
, "[DEPRECATED] load_binary <file> <address>");
1332 register_command(cmd_ctx
, NULL
, "dump_binary", handle_dump_image_command
, COMMAND_EXEC
, "[DEPRECATED] dump_binary <file> <address> <size>");
1334 target_request_register_commands(cmd_ctx
);
1335 trace_register_commands(cmd_ctx
);
1340 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1342 target_t
*target
= targets
;
1347 int num
= strtoul(args
[0], NULL
, 0);
1352 target
= target
->next
;
1356 cmd_ctx
->current_target
= num
;
1358 command_print(cmd_ctx
, "%i is out of bounds, only %i targets are configured", num
, count
);
1365 command_print(cmd_ctx
, "%i: %s (%s), state: %s", count
++, target
->type
->name
, target_endianess_strings
[target
->endianness
], target_state_strings
[target
->state
]);
1366 target
= target
->next
;
1372 int handle_target_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1379 return ERROR_COMMAND_SYNTAX_ERROR
;
1382 /* search for the specified target */
1383 if (args
[0] && (args
[0][0] != 0))
1385 for (i
= 0; target_types
[i
]; i
++)
1387 if (strcmp(args
[0], target_types
[i
]->name
) == 0)
1389 target_t
**last_target_p
= &targets
;
1391 /* register target specific commands */
1392 if (target_types
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1394 LOG_ERROR("couldn't register '%s' commands", args
[0]);
1400 while ((*last_target_p
)->next
)
1401 last_target_p
= &((*last_target_p
)->next
);
1402 last_target_p
= &((*last_target_p
)->next
);
1405 *last_target_p
= malloc(sizeof(target_t
));
1407 /* allocate memory for each unique target type */
1408 (*last_target_p
)->type
= (target_type_t
*)malloc(sizeof(target_type_t
));
1409 *((*last_target_p
)->type
) = *target_types
[i
];
1411 if (strcmp(args
[1], "big") == 0)
1412 (*last_target_p
)->endianness
= TARGET_BIG_ENDIAN
;
1413 else if (strcmp(args
[1], "little") == 0)
1414 (*last_target_p
)->endianness
= TARGET_LITTLE_ENDIAN
;
1417 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args
[1]);
1418 return ERROR_COMMAND_SYNTAX_ERROR
;
1421 if (strcmp(args
[2], "reset_halt") == 0)
1423 LOG_WARNING("reset_mode argument is deprecated. reset_mode = reset_run");
1425 else if (strcmp(args
[2], "reset_run") == 0)
1427 LOG_WARNING("reset_mode argument is deprecated. reset_mode = reset_run");
1429 else if (strcmp(args
[2], "reset_init") == 0)
1431 LOG_WARNING("reset_mode argument is deprecated. reset_mode = reset_run");
1433 else if (strcmp(args
[2], "run_and_halt") == 0)
1435 LOG_WARNING("reset_mode argument is deprecated. reset_mode = reset_run");
1437 else if (strcmp(args
[2], "run_and_init") == 0)
1439 LOG_WARNING("reset_mode argument is deprecated. reset_mode = reset_run");
1443 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1447 (*last_target_p
)->run_and_halt_time
= 1000; /* default 1s */
1449 (*last_target_p
)->working_area
= 0x0;
1450 (*last_target_p
)->working_area_size
= 0x0;
1451 (*last_target_p
)->working_areas
= NULL
;
1452 (*last_target_p
)->backup_working_area
= 0;
1454 (*last_target_p
)->state
= TARGET_UNKNOWN
;
1455 (*last_target_p
)->debug_reason
= DBG_REASON_UNDEFINED
;
1456 (*last_target_p
)->reg_cache
= NULL
;
1457 (*last_target_p
)->breakpoints
= NULL
;
1458 (*last_target_p
)->watchpoints
= NULL
;
1459 (*last_target_p
)->next
= NULL
;
1460 (*last_target_p
)->arch_info
= NULL
;
1462 /* initialize trace information */
1463 (*last_target_p
)->trace_info
= malloc(sizeof(trace_t
));
1464 (*last_target_p
)->trace_info
->num_trace_points
= 0;
1465 (*last_target_p
)->trace_info
->trace_points_size
= 0;
1466 (*last_target_p
)->trace_info
->trace_points
= NULL
;
1467 (*last_target_p
)->trace_info
->trace_history_size
= 0;
1468 (*last_target_p
)->trace_info
->trace_history
= NULL
;
1469 (*last_target_p
)->trace_info
->trace_history_pos
= 0;
1470 (*last_target_p
)->trace_info
->trace_history_overflowed
= 0;
1472 (*last_target_p
)->dbgmsg
= NULL
;
1473 (*last_target_p
)->dbg_msg_enabled
= 0;
1475 (*last_target_p
)->type
->target_command(cmd_ctx
, cmd
, args
, argc
, *last_target_p
);
1483 /* no matching target found */
1486 LOG_ERROR("target '%s' not found", args
[0]);
1487 return ERROR_COMMAND_SYNTAX_ERROR
;
1493 int target_invoke_script(struct command_context_s
*cmd_ctx
, target_t
*target
, char *name
)
1495 return command_run_linef(cmd_ctx
, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
1496 name
, get_num_by_target(target
),
1497 name
, get_num_by_target(target
));
1500 int handle_run_and_halt_time_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1502 target_t
*target
= NULL
;
1506 return ERROR_COMMAND_SYNTAX_ERROR
;
1509 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1512 return ERROR_COMMAND_SYNTAX_ERROR
;
1515 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1520 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1522 target_t
*target
= NULL
;
1524 if ((argc
< 4) || (argc
> 5))
1526 return ERROR_COMMAND_SYNTAX_ERROR
;
1529 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1532 return ERROR_COMMAND_SYNTAX_ERROR
;
1534 target_free_all_working_areas(target
);
1536 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1539 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1541 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1543 if (strcmp(args
[3], "backup") == 0)
1545 target
->backup_working_area
= 1;
1547 else if (strcmp(args
[3], "nobackup") == 0)
1549 target
->backup_working_area
= 0;
1553 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1554 return ERROR_COMMAND_SYNTAX_ERROR
;
1561 /* process target state changes */
1562 int handle_target(void *priv
)
1564 target_t
*target
= targets
;
1568 if (target_continous_poll
)
1570 /* polling may fail silently until the target has been examined */
1571 target_poll(target
);
1574 target
= target
->next
;
1580 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1589 target
= get_current_target(cmd_ctx
);
1591 /* list all available registers for the current target */
1594 reg_cache_t
*cache
= target
->reg_cache
;
1600 for (i
= 0; i
< cache
->num_regs
; i
++)
1602 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1603 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
);
1606 cache
= cache
->next
;
1612 /* access a single register by its ordinal number */
1613 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1615 int num
= strtoul(args
[0], NULL
, 0);
1616 reg_cache_t
*cache
= target
->reg_cache
;
1622 for (i
= 0; i
< cache
->num_regs
; i
++)
1626 reg
= &cache
->reg_list
[i
];
1632 cache
= cache
->next
;
1637 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1640 } else /* access a single register by its name */
1642 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1646 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1651 /* display a register */
1652 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1654 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1657 if (reg
->valid
== 0)
1659 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1660 if (arch_type
== NULL
)
1662 LOG_ERROR("BUG: encountered unregistered arch type");
1665 arch_type
->get(reg
);
1667 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1668 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1673 /* set register value */
1676 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1677 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1679 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1680 if (arch_type
== NULL
)
1682 LOG_ERROR("BUG: encountered unregistered arch type");
1686 arch_type
->set(reg
, buf
);
1688 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1689 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1697 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1702 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
);
1704 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1706 target_t
*target
= get_current_target(cmd_ctx
);
1710 target_poll(target
);
1711 target_arch_state(target
);
1715 if (strcmp(args
[0], "on") == 0)
1717 target_continous_poll
= 1;
1719 else if (strcmp(args
[0], "off") == 0)
1721 target_continous_poll
= 0;
1725 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1733 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1741 ms
= strtoul(args
[0], &end
, 0) * 1000;
1744 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1749 return wait_state(cmd_ctx
, cmd
, TARGET_HALTED
, ms
);
1752 static int wait_state(struct command_context_s
*cmd_ctx
, char *cmd
, enum target_state state
, int ms
)
1755 struct timeval timeout
, now
;
1757 gettimeofday(&timeout
, NULL
);
1758 timeval_add_time(&timeout
, 0, ms
* 1000);
1760 target_t
*target
= get_current_target(cmd_ctx
);
1763 if ((retval
=target_poll(target
))!=ERROR_OK
)
1765 target_call_timer_callbacks_now();
1766 if (target
->state
== state
)
1773 command_print(cmd_ctx
, "waiting for target %s...", target_state_strings
[state
]);
1776 gettimeofday(&now
, NULL
);
1777 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1779 LOG_ERROR("timed out while waiting for target %s", target_state_strings
[state
]);
1787 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1790 target_t
*target
= get_current_target(cmd_ctx
);
1794 if ((retval
= target_halt(target
)) != ERROR_OK
)
1799 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1802 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1804 target_t
*target
= get_current_target(cmd_ctx
);
1806 LOG_USER("requesting target halt and executing a soft reset");
1808 target
->type
->soft_reset_halt(target
);
1813 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1815 target_t
*target
= get_current_target(cmd_ctx
);
1816 enum target_reset_mode reset_mode
= RESET_RUN
;
1822 if (strcmp("run", args
[0]) == 0)
1823 reset_mode
= RESET_RUN
;
1824 else if (strcmp("halt", args
[0]) == 0)
1825 reset_mode
= RESET_HALT
;
1826 else if (strcmp("init", args
[0]) == 0)
1827 reset_mode
= RESET_INIT
;
1828 else if (strcmp("run_and_halt", args
[0]) == 0)
1830 reset_mode
= RESET_RUN_AND_HALT
;
1833 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1836 else if (strcmp("run_and_init", args
[0]) == 0)
1838 reset_mode
= RESET_RUN_AND_INIT
;
1841 target
->run_and_halt_time
= strtoul(args
[1], NULL
, 0);
1846 command_print(cmd_ctx
, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1851 /* temporarily modify mode of current reset target */
1852 target
->reset_mode
= reset_mode
;
1854 /* reset *all* targets */
1855 target_process_reset(cmd_ctx
);
1860 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1863 target_t
*target
= get_current_target(cmd_ctx
);
1865 target_invoke_script(cmd_ctx
, target
, "pre_resume");
1868 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1870 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1873 return ERROR_COMMAND_SYNTAX_ERROR
;
1879 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1881 target_t
*target
= get_current_target(cmd_ctx
);
1886 target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1889 target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1894 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1896 const int line_bytecnt
= 32;
1909 target_t
*target
= get_current_target(cmd_ctx
);
1915 count
= strtoul(args
[1], NULL
, 0);
1917 address
= strtoul(args
[0], NULL
, 0);
1923 size
= 4; line_modulo
= line_bytecnt
/ 4;
1926 size
= 2; line_modulo
= line_bytecnt
/ 2;
1929 size
= 1; line_modulo
= line_bytecnt
/ 1;
1935 buffer
= calloc(count
, size
);
1936 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1937 if (retval
== ERROR_OK
)
1941 for (i
= 0; i
< count
; i
++)
1943 if (i
%line_modulo
== 0)
1944 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1949 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1952 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1955 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1959 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1961 command_print(cmd_ctx
, output
);
1972 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1979 target_t
*target
= get_current_target(cmd_ctx
);
1982 if ((argc
< 2) || (argc
> 3))
1983 return ERROR_COMMAND_SYNTAX_ERROR
;
1985 address
= strtoul(args
[0], NULL
, 0);
1986 value
= strtoul(args
[1], NULL
, 0);
1988 count
= strtoul(args
[2], NULL
, 0);
1994 target_buffer_set_u32(target
, value_buf
, value
);
1998 target_buffer_set_u16(target
, value_buf
, value
);
2002 value_buf
[0] = value
;
2005 return ERROR_COMMAND_SYNTAX_ERROR
;
2007 for (i
=0; i
<count
; i
++)
2013 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2016 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2019 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2024 if (retval
!=ERROR_OK
)
2034 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2044 duration_t duration
;
2045 char *duration_text
;
2047 target_t
*target
= get_current_target(cmd_ctx
);
2051 command_print(cmd_ctx
, "usage: load_image <filename> [address] [type]");
2055 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2058 image
.base_address_set
= 1;
2059 image
.base_address
= strtoul(args
[1], NULL
, 0);
2063 image
.base_address_set
= 0;
2066 image
.start_address_set
= 0;
2068 duration_start_measure(&duration
);
2070 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2077 for (i
= 0; i
< image
.num_sections
; i
++)
2079 buffer
= malloc(image
.sections
[i
].size
);
2082 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2086 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2091 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
, buf_cnt
, buffer
)) != ERROR_OK
)
2096 image_size
+= buf_cnt
;
2097 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", buf_cnt
, image
.sections
[i
].base_address
);
2102 duration_stop_measure(&duration
, &duration_text
);
2103 if (retval
==ERROR_OK
)
2105 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2107 free(duration_text
);
2109 image_close(&image
);
2115 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2122 int retval
=ERROR_OK
;
2124 duration_t duration
;
2125 char *duration_text
;
2127 target_t
*target
= get_current_target(cmd_ctx
);
2131 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2135 address
= strtoul(args
[1], NULL
, 0);
2136 size
= strtoul(args
[2], NULL
, 0);
2138 if ((address
& 3) || (size
& 3))
2140 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2144 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2149 duration_start_measure(&duration
);
2154 u32 this_run_size
= (size
> 560) ? 560 : size
;
2156 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2157 if (retval
!= ERROR_OK
)
2162 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2163 if (retval
!= ERROR_OK
)
2168 size
-= this_run_size
;
2169 address
+= this_run_size
;
2172 fileio_close(&fileio
);
2174 duration_stop_measure(&duration
, &duration_text
);
2175 if (retval
==ERROR_OK
)
2177 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2179 free(duration_text
);
2184 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2192 u32 mem_checksum
= 0;
2196 duration_t duration
;
2197 char *duration_text
;
2199 target_t
*target
= get_current_target(cmd_ctx
);
2203 return ERROR_COMMAND_SYNTAX_ERROR
;
2208 LOG_ERROR("no target selected");
2212 duration_start_measure(&duration
);
2216 image
.base_address_set
= 1;
2217 image
.base_address
= strtoul(args
[1], NULL
, 0);
2221 image
.base_address_set
= 0;
2222 image
.base_address
= 0x0;
2225 image
.start_address_set
= 0;
2227 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2234 for (i
= 0; i
< image
.num_sections
; i
++)
2236 buffer
= malloc(image
.sections
[i
].size
);
2239 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2242 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2248 /* calculate checksum of image */
2249 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2251 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2252 if( retval
!= ERROR_OK
)
2258 if( checksum
!= mem_checksum
)
2260 /* failed crc checksum, fall back to a binary compare */
2263 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2265 data
= (u8
*)malloc(buf_cnt
);
2267 /* Can we use 32bit word accesses? */
2269 int count
= buf_cnt
;
2270 if ((count
% 4) == 0)
2275 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2276 if (retval
== ERROR_OK
)
2279 for (t
= 0; t
< buf_cnt
; t
++)
2281 if (data
[t
] != buffer
[t
])
2283 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
]);
2296 image_size
+= buf_cnt
;
2299 duration_stop_measure(&duration
, &duration_text
);
2300 if (retval
==ERROR_OK
)
2302 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2304 free(duration_text
);
2306 image_close(&image
);
2311 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2314 target_t
*target
= get_current_target(cmd_ctx
);
2318 breakpoint_t
*breakpoint
= target
->breakpoints
;
2322 if (breakpoint
->type
== BKPT_SOFT
)
2324 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2325 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2330 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2332 breakpoint
= breakpoint
->next
;
2340 length
= strtoul(args
[1], NULL
, 0);
2343 if (strcmp(args
[2], "hw") == 0)
2346 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2348 LOG_ERROR("Failure setting breakpoints");
2352 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2357 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2363 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2365 target_t
*target
= get_current_target(cmd_ctx
);
2368 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2373 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2375 target_t
*target
= get_current_target(cmd_ctx
);
2380 watchpoint_t
*watchpoint
= target
->watchpoints
;
2384 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
);
2385 watchpoint
= watchpoint
->next
;
2390 enum watchpoint_rw type
= WPT_ACCESS
;
2391 u32 data_value
= 0x0;
2392 u32 data_mask
= 0xffffffff;
2408 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2414 data_value
= strtoul(args
[3], NULL
, 0);
2418 data_mask
= strtoul(args
[4], NULL
, 0);
2421 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2422 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2424 LOG_ERROR("Failure setting breakpoints");
2429 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2435 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2437 target_t
*target
= get_current_target(cmd_ctx
);
2440 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2445 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2448 target_t
*target
= get_current_target(cmd_ctx
);
2454 return ERROR_COMMAND_SYNTAX_ERROR
;
2456 va
= strtoul(args
[0], NULL
, 0);
2458 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2459 if (retval
== ERROR_OK
)
2461 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2465 /* lower levels will have logged a detailed error which is
2466 * forwarded to telnet/GDB session.
2471 static void writeLong(FILE *f
, int l
)
2476 char c
=(l
>>(i
*8))&0xff;
2477 fwrite(&c
, 1, 1, f
);
2481 static void writeString(FILE *f
, char *s
)
2483 fwrite(s
, 1, strlen(s
), f
);
2488 // Dump a gmon.out histogram file.
2489 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2492 FILE *f
=fopen(filename
, "w");
2495 fwrite("gmon", 1, 4, f
);
2496 writeLong(f
, 0x00000001); // Version
2497 writeLong(f
, 0); // padding
2498 writeLong(f
, 0); // padding
2499 writeLong(f
, 0); // padding
2501 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2503 // figure out bucket size
2506 for (i
=0; i
<sampleNum
; i
++)
2518 int addressSpace
=(max
-min
+1);
2520 static int const maxBuckets
=256*1024; // maximum buckets.
2521 int length
=addressSpace
;
2522 if (length
> maxBuckets
)
2526 int *buckets
=malloc(sizeof(int)*length
);
2532 memset(buckets
, 0, sizeof(int)*length
);
2533 for (i
=0; i
<sampleNum
;i
++)
2535 u32 address
=samples
[i
];
2536 long long a
=address
-min
;
2537 long long b
=length
-1;
2538 long long c
=addressSpace
-1;
2539 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2543 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2544 writeLong(f
, min
); // low_pc
2545 writeLong(f
, max
); // high_pc
2546 writeLong(f
, length
); // # of samples
2547 writeLong(f
, 64000000); // 64MHz
2548 writeString(f
, "seconds");
2549 for (i
=0; i
<(15-strlen("seconds")); i
++)
2551 fwrite("", 1, 1, f
); // padding
2553 writeString(f
, "s");
2555 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2557 char *data
=malloc(2*length
);
2560 for (i
=0; i
<length
;i
++)
2569 data
[i
*2+1]=(val
>>8)&0xff;
2572 fwrite(data
, 1, length
*2, f
);
2582 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2583 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2585 target_t
*target
= get_current_target(cmd_ctx
);
2586 struct timeval timeout
, now
;
2588 gettimeofday(&timeout
, NULL
);
2591 return ERROR_COMMAND_SYNTAX_ERROR
;
2594 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2600 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2602 static const int maxSample
=10000;
2603 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2608 int retval
=ERROR_OK
;
2609 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2610 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2614 target_poll(target
);
2615 if (target
->state
== TARGET_HALTED
)
2617 u32 t
=*((u32
*)reg
->value
);
2618 samples
[numSamples
++]=t
;
2619 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2620 target_poll(target
);
2621 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2622 } else if (target
->state
== TARGET_RUNNING
)
2624 // We want to quickly sample the PC.
2625 target_halt(target
);
2628 command_print(cmd_ctx
, "Target not halted or running");
2632 if (retval
!=ERROR_OK
)
2637 gettimeofday(&now
, NULL
);
2638 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2640 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2641 target_poll(target
);
2642 if (target
->state
== TARGET_HALTED
)
2644 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2646 target_poll(target
);
2647 writeGmon(samples
, numSamples
, args
[1]);
2648 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2657 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2660 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2663 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2667 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2668 valObjPtr
= Jim_NewIntObj(interp
, val
);
2669 if (!nameObjPtr
|| !valObjPtr
)
2675 Jim_IncrRefCount(nameObjPtr
);
2676 Jim_IncrRefCount(valObjPtr
);
2677 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2678 Jim_DecrRefCount(interp
, nameObjPtr
);
2679 Jim_DecrRefCount(interp
, valObjPtr
);
2681 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2685 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2688 command_context_t
*context
;
2695 const char *varname
;
2697 int i
, n
, e
, retval
;
2699 /* argv[1] = name of array to receive the data
2700 * argv[2] = desired width
2701 * argv[3] = memory address
2702 * argv[4] = count of times to read
2705 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2708 varname
= Jim_GetString(argv
[1], &len
);
2709 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2711 e
= Jim_GetLong(interp
, argv
[2], &l
);
2717 e
= Jim_GetLong(interp
, argv
[3], &l
);
2722 e
= Jim_GetLong(interp
, argv
[4], &l
);
2738 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2739 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2743 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2744 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2747 if ((addr
+ (len
* width
)) < addr
) {
2748 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2749 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2752 /* absurd transfer size? */
2754 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2755 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2760 ((width
== 2) && ((addr
& 1) == 0)) ||
2761 ((width
== 4) && ((addr
& 3) == 0))) {
2765 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2766 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2767 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2771 context
= Jim_GetAssocData(interp
, "context");
2772 if (context
== NULL
)
2774 LOG_ERROR("mem2array: no command context");
2777 target
= get_current_target(context
);
2780 LOG_ERROR("mem2array: no current target");
2791 /* Slurp... in buffer size chunks */
2793 count
= len
; /* in objects.. */
2794 if (count
> (sizeof(buffer
)/width
)) {
2795 count
= (sizeof(buffer
)/width
);
2798 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2799 if (retval
!= ERROR_OK
) {
2801 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2802 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2803 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2807 v
= 0; /* shut up gcc */
2808 for (i
= 0 ;i
< count
;i
++, n
++) {
2811 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2814 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2817 v
= buffer
[i
] & 0x0ff;
2820 new_int_array_element(interp
, varname
, n
, v
);
2826 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2831 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2834 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2838 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2842 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2849 Jim_IncrRefCount(nameObjPtr
);
2850 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2851 Jim_DecrRefCount(interp
, nameObjPtr
);
2853 if (valObjPtr
== NULL
)
2856 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2857 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2862 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2865 command_context_t
*context
;
2872 const char *varname
;
2874 int i
, n
, e
, retval
;
2876 /* argv[1] = name of array to get the data
2877 * argv[2] = desired width
2878 * argv[3] = memory address
2879 * argv[4] = count to write
2882 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2885 varname
= Jim_GetString(argv
[1], &len
);
2886 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2888 e
= Jim_GetLong(interp
, argv
[2], &l
);
2894 e
= Jim_GetLong(interp
, argv
[3], &l
);
2899 e
= Jim_GetLong(interp
, argv
[4], &l
);
2915 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2916 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2920 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2921 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2924 if ((addr
+ (len
* width
)) < addr
) {
2925 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2926 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2929 /* absurd transfer size? */
2931 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2932 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2937 ((width
== 2) && ((addr
& 1) == 0)) ||
2938 ((width
== 4) && ((addr
& 3) == 0))) {
2942 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2943 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2944 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2948 context
= Jim_GetAssocData(interp
, "context");
2949 if (context
== NULL
)
2951 LOG_ERROR("array2mem: no command context");
2954 target
= get_current_target(context
);
2957 LOG_ERROR("array2mem: no current target");
2968 /* Slurp... in buffer size chunks */
2970 count
= len
; /* in objects.. */
2971 if (count
> (sizeof(buffer
)/width
)) {
2972 count
= (sizeof(buffer
)/width
);
2975 v
= 0; /* shut up gcc */
2976 for (i
= 0 ;i
< count
;i
++, n
++) {
2977 get_int_array_element(interp
, varname
, n
, &v
);
2980 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2983 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2986 buffer
[i
] = v
& 0x0ff;
2992 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2993 if (retval
!= ERROR_OK
) {
2995 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2996 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2997 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
3003 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)