1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008, Duane Ellis *
9 * openocd@duaneeellis.com *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
14 * Copyright (C) 2008 by Rick Altherr *
15 * kc8apf@kc8apf.net> *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program; if not, write to the *
29 * Free Software Foundation, Inc., *
30 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
31 ***************************************************************************/
36 #include "replacements.h"
38 #include "target_request.h"
41 #include "configuration.h"
42 #include "binarybuffer.h"
49 #include <sys/types.h>
57 #include <time_support.h>
62 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
64 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
80 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
81 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
83 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
84 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
85 int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
86 int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
88 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
89 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
90 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
92 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
93 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
96 extern target_type_t arm7tdmi_target
;
97 extern target_type_t arm720t_target
;
98 extern target_type_t arm9tdmi_target
;
99 extern target_type_t arm920t_target
;
100 extern target_type_t arm966e_target
;
101 extern target_type_t arm926ejs_target
;
102 extern target_type_t feroceon_target
;
103 extern target_type_t xscale_target
;
104 extern target_type_t cortexm3_target
;
105 extern target_type_t arm11_target
;
106 extern target_type_t mips_m4k_target
;
108 target_type_t
*target_types
[] =
124 target_t
*all_targets
= NULL
;
125 target_event_callback_t
*target_event_callbacks
= NULL
;
126 target_timer_callback_t
*target_timer_callbacks
= NULL
;
128 const Jim_Nvp nvp_assert
[] = {
129 { .name
= "assert", NVP_ASSERT
},
130 { .name
= "deassert", NVP_DEASSERT
},
131 { .name
= "T", NVP_ASSERT
},
132 { .name
= "F", NVP_DEASSERT
},
133 { .name
= "t", NVP_ASSERT
},
134 { .name
= "f", NVP_DEASSERT
},
135 { .name
= NULL
, .value
= -1 }
138 const Jim_Nvp nvp_error_target
[] = {
139 { .value
= ERROR_TARGET_INVALID
, .name
= "err-invalid" },
140 { .value
= ERROR_TARGET_INIT_FAILED
, .name
= "err-init-failed" },
141 { .value
= ERROR_TARGET_TIMEOUT
, .name
= "err-timeout" },
142 { .value
= ERROR_TARGET_NOT_HALTED
, .name
= "err-not-halted" },
143 { .value
= ERROR_TARGET_FAILURE
, .name
= "err-failure" },
144 { .value
= ERROR_TARGET_UNALIGNED_ACCESS
, .name
= "err-unaligned-access" },
145 { .value
= ERROR_TARGET_DATA_ABORT
, .name
= "err-data-abort" },
146 { .value
= ERROR_TARGET_RESOURCE_NOT_AVAILABLE
, .name
= "err-resource-not-available" },
147 { .value
= ERROR_TARGET_TRANSLATION_FAULT
, .name
= "err-translation-fault" },
148 { .value
= ERROR_TARGET_NOT_RUNNING
, .name
= "err-not-running" },
149 { .value
= ERROR_TARGET_NOT_EXAMINED
, .name
= "err-not-examined" },
150 { .value
= -1, .name
= NULL
}
153 const char *target_strerror_safe( int err
)
157 n
= Jim_Nvp_value2name_simple( nvp_error_target
, err
);
158 if( n
->name
== NULL
){
165 const Jim_Nvp nvp_target_event
[] = {
166 { .value
= TARGET_EVENT_OLD_gdb_program_config
, .name
= "old-gdb_program_config" },
167 { .value
= TARGET_EVENT_OLD_pre_resume
, .name
= "old-pre_resume" },
169 { .value
= TARGET_EVENT_EARLY_HALTED
, .name
= "early-halted" },
170 { .value
= TARGET_EVENT_HALTED
, .name
= "halted" },
171 { .value
= TARGET_EVENT_RESUMED
, .name
= "resumed" },
172 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
173 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
175 { .name
= "gdb-start", .value
= TARGET_EVENT_GDB_START
},
176 { .name
= "gdb-end", .value
= TARGET_EVENT_GDB_END
},
178 /* historical name */
180 { .value
= TARGET_EVENT_RESET_START
, .name
= "reset-start" },
182 { .value
= TARGET_EVENT_RESET_ASSERT_PRE
, .name
= "reset-assert-pre" },
183 { .value
= TARGET_EVENT_RESET_ASSERT_POST
, .name
= "reset-assert-post" },
184 { .value
= TARGET_EVENT_RESET_DEASSERT_PRE
, .name
= "reset-deassert-pre" },
185 { .value
= TARGET_EVENT_RESET_DEASSERT_POST
, .name
= "reset-deassert-post" },
186 { .value
= TARGET_EVENT_RESET_HALT_PRE
, .name
= "reset-halt-pre" },
187 { .value
= TARGET_EVENT_RESET_HALT_POST
, .name
= "reset-halt-post" },
188 { .value
= TARGET_EVENT_RESET_WAIT_PRE
, .name
= "reset-wait-pre" },
189 { .value
= TARGET_EVENT_RESET_WAIT_POST
, .name
= "reset-wait-post" },
190 { .value
= TARGET_EVENT_RESET_INIT
, .name
= "reset-init" },
191 { .value
= TARGET_EVENT_RESET_END
, .name
= "reset-end" },
193 { .value
= TARGET_EVENT_EXAMINE_START
, .name
= "examine-start" },
194 { .value
= TARGET_EVENT_EXAMINE_END
, .name
= "examine-end" },
196 { .value
= TARGET_EVENT_DEBUG_HALTED
, .name
= "debug-halted" },
197 { .value
= TARGET_EVENT_DEBUG_RESUMED
, .name
= "debug-resumed" },
199 { .value
= TARGET_EVENT_GDB_ATTACH
, .name
= "gdb-attach" },
200 { .value
= TARGET_EVENT_GDB_DETACH
, .name
= "gdb-detach" },
202 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_START
, .name
= "gdb-flash-write-start" },
203 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_END
, .name
= "gdb-flash-write-end" },
205 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_START
, .name
= "gdb-flash-erase-start" },
206 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_END
, .name
= "gdb-flash-erase-end" },
208 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
209 { .value
= TARGET_EVENT_RESUMED
, .name
= "resume-ok" },
210 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
212 { .name
= NULL
, .value
= -1 }
215 const Jim_Nvp nvp_target_state
[] = {
216 { .name
= "unknown", .value
= TARGET_UNKNOWN
},
217 { .name
= "running", .value
= TARGET_RUNNING
},
218 { .name
= "halted", .value
= TARGET_HALTED
},
219 { .name
= "reset", .value
= TARGET_RESET
},
220 { .name
= "debug-running", .value
= TARGET_DEBUG_RUNNING
},
221 { .name
= NULL
, .value
= -1 },
224 const Jim_Nvp nvp_target_debug_reason
[] = {
225 { .name
= "debug-request" , .value
= DBG_REASON_DBGRQ
},
226 { .name
= "breakpoint" , .value
= DBG_REASON_BREAKPOINT
},
227 { .name
= "watchpoint" , .value
= DBG_REASON_WATCHPOINT
},
228 { .name
= "watchpoint-and-breakpoint", .value
= DBG_REASON_WPTANDBKPT
},
229 { .name
= "single-step" , .value
= DBG_REASON_SINGLESTEP
},
230 { .name
= "target-not-halted" , .value
= DBG_REASON_NOTHALTED
},
231 { .name
= "undefined" , .value
= DBG_REASON_UNDEFINED
},
232 { .name
= NULL
, .value
= -1 },
235 const Jim_Nvp nvp_target_endian
[] = {
236 { .name
= "big", .value
= TARGET_BIG_ENDIAN
},
237 { .name
= "little", .value
= TARGET_LITTLE_ENDIAN
},
238 { .name
= "be", .value
= TARGET_BIG_ENDIAN
},
239 { .name
= "le", .value
= TARGET_LITTLE_ENDIAN
},
240 { .name
= NULL
, .value
= -1 },
243 const Jim_Nvp nvp_reset_modes
[] = {
244 { .name
= "unknown", .value
= RESET_UNKNOWN
},
245 { .name
= "run" , .value
= RESET_RUN
},
246 { .name
= "halt" , .value
= RESET_HALT
},
247 { .name
= "init" , .value
= RESET_INIT
},
248 { .name
= NULL
, .value
= -1 },
251 static int max_target_number(void)
259 if( x
< t
->target_number
){
260 x
= (t
->target_number
)+1;
267 /* determine the number of the new target */
268 static int new_target_number(void)
273 /* number is 0 based */
277 if( x
< t
->target_number
){
278 x
= t
->target_number
;
285 static int target_continous_poll
= 1;
287 /* read a u32 from a buffer in target memory endianness */
288 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
290 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
291 return le_to_h_u32(buffer
);
293 return be_to_h_u32(buffer
);
296 /* read a u16 from a buffer in target memory endianness */
297 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
299 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
300 return le_to_h_u16(buffer
);
302 return be_to_h_u16(buffer
);
305 /* read a u8 from a buffer in target memory endianness */
306 u8
target_buffer_get_u8(target_t
*target
, u8
*buffer
)
308 return *buffer
& 0x0ff;
311 /* write a u32 to a buffer in target memory endianness */
312 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
314 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
315 h_u32_to_le(buffer
, value
);
317 h_u32_to_be(buffer
, value
);
320 /* write a u16 to a buffer in target memory endianness */
321 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
323 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
324 h_u16_to_le(buffer
, value
);
326 h_u16_to_be(buffer
, value
);
329 /* write a u8 to a buffer in target memory endianness */
330 void target_buffer_set_u8(target_t
*target
, u8
*buffer
, u8 value
)
335 /* returns a pointer to the n-th configured target */
336 target_t
* get_target_by_num(int num
)
338 target_t
*target
= all_targets
;
341 if( target
->target_number
== num
){
344 target
= target
->next
;
350 int get_num_by_target(target_t
*query_target
)
352 return query_target
->target_number
;
355 target_t
* get_current_target(command_context_t
*cmd_ctx
)
357 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
361 LOG_ERROR("BUG: current_target out of bounds");
368 int target_poll(struct target_s
*target
)
370 /* We can't poll until after examine */
371 if (!target
->type
->examined
)
373 /* Fail silently lest we pollute the log */
376 return target
->type
->poll(target
);
379 int target_halt(struct target_s
*target
)
381 /* We can't poll until after examine */
382 if (!target
->type
->examined
)
384 LOG_ERROR("Target not examined yet");
387 return target
->type
->halt(target
);
390 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
394 /* We can't poll until after examine */
395 if (!target
->type
->examined
)
397 LOG_ERROR("Target not examined yet");
401 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
402 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
405 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
411 int target_process_reset(struct command_context_s
*cmd_ctx
, enum target_reset_mode reset_mode
)
416 n
= Jim_Nvp_value2name_simple( nvp_reset_modes
, reset_mode
);
417 if( n
->name
== NULL
){
418 LOG_ERROR("invalid reset mode");
422 sprintf( buf
, "ocd_process_reset %s", n
->name
);
423 retval
= Jim_Eval( interp
, buf
);
425 if(retval
!= JIM_OK
) {
426 Jim_PrintErrorMessage(interp
);
430 /* We want any events to be processed before the prompt */
431 retval
= target_call_timer_callbacks_now();
436 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
442 static int default_mmu(struct target_s
*target
, int *enabled
)
448 static int default_examine(struct target_s
*target
)
450 target
->type
->examined
= 1;
454 /* Targets that correctly implement init+examine, i.e.
455 * no communication with target during init:
459 int target_examine(void)
461 int retval
= ERROR_OK
;
462 target_t
*target
= all_targets
;
465 if ((retval
= target
->type
->examine(target
))!=ERROR_OK
)
467 target
= target
->next
;
472 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
474 if (!target
->type
->examined
)
476 LOG_ERROR("Target not examined yet");
479 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
482 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
484 if (!target
->type
->examined
)
486 LOG_ERROR("Target not examined yet");
489 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
492 static int target_soft_reset_halt_imp(struct target_s
*target
)
494 if (!target
->type
->examined
)
496 LOG_ERROR("Target not examined yet");
499 return target
->type
->soft_reset_halt_imp(target
);
502 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
)
504 if (!target
->type
->examined
)
506 LOG_ERROR("Target not examined yet");
509 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
);
512 int target_init(struct command_context_s
*cmd_ctx
)
514 target_t
*target
= all_targets
;
519 target
->type
->examined
= 0;
520 if (target
->type
->examine
== NULL
)
522 target
->type
->examine
= default_examine
;
525 if ((retval
= target
->type
->init_target(cmd_ctx
, target
)) != ERROR_OK
)
527 LOG_ERROR("target '%s' init failed", target
->type
->name
);
531 /* Set up default functions if none are provided by target */
532 if (target
->type
->virt2phys
== NULL
)
534 target
->type
->virt2phys
= default_virt2phys
;
536 target
->type
->virt2phys
= default_virt2phys
;
537 /* a non-invasive way(in terms of patches) to add some code that
538 * runs before the type->write/read_memory implementation
540 target
->type
->write_memory_imp
= target
->type
->write_memory
;
541 target
->type
->write_memory
= target_write_memory_imp
;
542 target
->type
->read_memory_imp
= target
->type
->read_memory
;
543 target
->type
->read_memory
= target_read_memory_imp
;
544 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
545 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
546 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
547 target
->type
->run_algorithm
= target_run_algorithm_imp
;
549 if (target
->type
->mmu
== NULL
)
551 target
->type
->mmu
= default_mmu
;
553 target
= target
->next
;
558 if((retval
= target_register_user_commands(cmd_ctx
)) != ERROR_OK
)
560 if((retval
= target_register_timer_callback(handle_target
, 100, 1, NULL
)) != ERROR_OK
)
567 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
569 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
571 if (callback
== NULL
)
573 return ERROR_INVALID_ARGUMENTS
;
578 while ((*callbacks_p
)->next
)
579 callbacks_p
= &((*callbacks_p
)->next
);
580 callbacks_p
= &((*callbacks_p
)->next
);
583 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
584 (*callbacks_p
)->callback
= callback
;
585 (*callbacks_p
)->priv
= priv
;
586 (*callbacks_p
)->next
= NULL
;
591 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
593 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
596 if (callback
== NULL
)
598 return ERROR_INVALID_ARGUMENTS
;
603 while ((*callbacks_p
)->next
)
604 callbacks_p
= &((*callbacks_p
)->next
);
605 callbacks_p
= &((*callbacks_p
)->next
);
608 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
609 (*callbacks_p
)->callback
= callback
;
610 (*callbacks_p
)->periodic
= periodic
;
611 (*callbacks_p
)->time_ms
= time_ms
;
613 gettimeofday(&now
, NULL
);
614 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
615 time_ms
-= (time_ms
% 1000);
616 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
617 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
619 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
620 (*callbacks_p
)->when
.tv_sec
+= 1;
623 (*callbacks_p
)->priv
= priv
;
624 (*callbacks_p
)->next
= NULL
;
629 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
631 target_event_callback_t
**p
= &target_event_callbacks
;
632 target_event_callback_t
*c
= target_event_callbacks
;
634 if (callback
== NULL
)
636 return ERROR_INVALID_ARGUMENTS
;
641 target_event_callback_t
*next
= c
->next
;
642 if ((c
->callback
== callback
) && (c
->priv
== priv
))
656 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
658 target_timer_callback_t
**p
= &target_timer_callbacks
;
659 target_timer_callback_t
*c
= target_timer_callbacks
;
661 if (callback
== NULL
)
663 return ERROR_INVALID_ARGUMENTS
;
668 target_timer_callback_t
*next
= c
->next
;
669 if ((c
->callback
== callback
) && (c
->priv
== priv
))
683 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
685 target_event_callback_t
*callback
= target_event_callbacks
;
686 target_event_callback_t
*next_callback
;
688 if (event
== TARGET_EVENT_HALTED
)
690 /* execute early halted first */
691 target_call_event_callbacks(target
, TARGET_EVENT_EARLY_HALTED
);
694 LOG_DEBUG("target event %i (%s)",
696 Jim_Nvp_value2name_simple( nvp_target_event
, event
)->name
);
698 target_handle_event( target
, event
);
702 next_callback
= callback
->next
;
703 callback
->callback(target
, event
, callback
->priv
);
704 callback
= next_callback
;
710 static int target_call_timer_callbacks_check_time(int checktime
)
712 target_timer_callback_t
*callback
= target_timer_callbacks
;
713 target_timer_callback_t
*next_callback
;
718 gettimeofday(&now
, NULL
);
722 next_callback
= callback
->next
;
724 if ((!checktime
&&callback
->periodic
)||
725 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
726 || (now
.tv_sec
> callback
->when
.tv_sec
)))
728 if(callback
->callback
!= NULL
)
730 callback
->callback(callback
->priv
);
731 if (callback
->periodic
)
733 int time_ms
= callback
->time_ms
;
734 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
735 time_ms
-= (time_ms
% 1000);
736 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
737 if (callback
->when
.tv_usec
> 1000000)
739 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
740 callback
->when
.tv_sec
+= 1;
746 if((retval
= target_unregister_timer_callback(callback
->callback
, callback
->priv
)) != ERROR_OK
)
752 callback
= next_callback
;
758 int target_call_timer_callbacks(void)
760 return target_call_timer_callbacks_check_time(1);
763 /* invoke periodic callbacks immediately */
764 int target_call_timer_callbacks_now(void)
766 return target_call_timer_callbacks_check_time(0);
769 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
771 working_area_t
*c
= target
->working_areas
;
772 working_area_t
*new_wa
= NULL
;
774 /* Reevaluate working area address based on MMU state*/
775 if (target
->working_areas
== NULL
)
779 retval
= target
->type
->mmu(target
, &enabled
);
780 if (retval
!= ERROR_OK
)
786 target
->working_area
= target
->working_area_virt
;
790 target
->working_area
= target
->working_area_phys
;
794 /* only allocate multiples of 4 byte */
797 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
798 size
= CEIL(size
, 4);
801 /* see if there's already a matching working area */
804 if ((c
->free
) && (c
->size
== size
))
812 /* if not, allocate a new one */
815 working_area_t
**p
= &target
->working_areas
;
816 u32 first_free
= target
->working_area
;
817 u32 free_size
= target
->working_area_size
;
819 LOG_DEBUG("allocating new working area");
821 c
= target
->working_areas
;
824 first_free
+= c
->size
;
825 free_size
-= c
->size
;
830 if (free_size
< size
)
832 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
833 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
836 new_wa
= malloc(sizeof(working_area_t
));
839 new_wa
->address
= first_free
;
841 if (target
->backup_working_area
)
844 new_wa
->backup
= malloc(new_wa
->size
);
845 if((retval
= target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
)) != ERROR_OK
)
847 free(new_wa
->backup
);
854 new_wa
->backup
= NULL
;
857 /* put new entry in list */
861 /* mark as used, and return the new (reused) area */
871 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
876 if (restore
&&target
->backup_working_area
)
879 if((retval
= target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
)) != ERROR_OK
)
885 /* mark user pointer invalid */
892 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
894 return target_free_working_area_restore(target
, area
, 1);
897 /* free resources and restore memory, if restoring memory fails,
898 * free up resources anyway
900 void target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
902 working_area_t
*c
= target
->working_areas
;
906 working_area_t
*next
= c
->next
;
907 target_free_working_area_restore(target
, c
, restore
);
917 target
->working_areas
= NULL
;
920 void target_free_all_working_areas(struct target_s
*target
)
922 target_free_all_working_areas_restore(target
, 1);
925 int target_register_commands(struct command_context_s
*cmd_ctx
)
928 register_command(cmd_ctx
, NULL
, "targets", handle_targets_command
, COMMAND_EXEC
, "change the current command line target (one parameter) or lists targets (with no parameter)");
929 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "translate a virtual address into a physical address");
930 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "profiling samples the CPU PC");
932 register_command(cmd_ctx
, NULL
, "fast_load_image", handle_fast_load_image_command
, COMMAND_ANY
,
933 "same args as load_image, image stored in memory - mainly for profiling purposes");
935 register_command(cmd_ctx
, NULL
, "fast_load", handle_fast_load_command
, COMMAND_ANY
,
936 "loads active fast load image to current target - mainly for profiling purposes");
940 register_jim(cmd_ctx
, "target", jim_target
, "configure target" );
943 /* script procedures */
944 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
945 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
949 int target_arch_state(struct target_s
*target
)
954 LOG_USER("No target has been configured");
958 LOG_USER("target state: %s",
959 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
);
961 if (target
->state
!=TARGET_HALTED
)
964 retval
=target
->type
->arch_state(target
);
968 /* Single aligned words are guaranteed to use 16 or 32 bit access
969 * mode respectively, otherwise data is handled as quickly as
972 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
975 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
977 if (!target
->type
->examined
)
979 LOG_ERROR("Target not examined yet");
983 if ((address
+ size
- 1) < address
)
985 /* GDB can request this when e.g. PC is 0xfffffffc*/
986 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
990 if (((address
% 2) == 0) && (size
== 2))
992 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
995 /* handle unaligned head bytes */
998 int unaligned
= 4 - (address
% 4);
1000 if (unaligned
> size
)
1003 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1006 buffer
+= unaligned
;
1007 address
+= unaligned
;
1011 /* handle aligned words */
1014 int aligned
= size
- (size
% 4);
1016 /* use bulk writes above a certain limit. This may have to be changed */
1019 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1024 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1033 /* handle tail writes of less than 4 bytes */
1036 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1043 /* Single aligned words are guaranteed to use 16 or 32 bit access
1044 * mode respectively, otherwise data is handled as quickly as
1047 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1050 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1052 if (!target
->type
->examined
)
1054 LOG_ERROR("Target not examined yet");
1058 if ((address
+ size
- 1) < address
)
1060 /* GDB can request this when e.g. PC is 0xfffffffc*/
1061 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
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_OK
)
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
->write_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 int retval
= ERROR_OK
;
1307 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, "display or set a register");
1308 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1309 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1310 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1311 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1312 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1313 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init] - default is run");
1314 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1316 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1317 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1318 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1320 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1321 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1322 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1324 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1325 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1326 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1327 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1329 register_command(cmd_ctx
, NULL
, "load_image", handle_load_image_command
, COMMAND_EXEC
, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
1330 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1331 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1333 if((retval
= target_request_register_commands(cmd_ctx
)) != ERROR_OK
)
1335 if((retval
= trace_register_commands(cmd_ctx
)) != ERROR_OK
)
1341 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1344 target_t
*target
= all_targets
;
1348 /* try as tcltarget name */
1349 for( target
= all_targets
; target
; target
= target
->next
){
1350 if( target
->cmd_name
){
1351 if( 0 == strcmp( args
[0], target
->cmd_name
) ){
1357 /* no match, try as number */
1359 int num
= strtoul(args
[0], &cp
, 0 );
1361 /* then it was not a number */
1362 command_print( cmd_ctx
, "Target: %s unknown, try one of:\n", args
[0] );
1366 target
= get_target_by_num( num
);
1367 if( target
== NULL
){
1368 command_print(cmd_ctx
,"Target: %s is unknown, try one of:\n", args
[0] );
1372 cmd_ctx
->current_target
= target
->target_number
;
1377 target
= all_targets
;
1378 command_print(cmd_ctx
, " CmdName Type Endian AbsChainPos Name State ");
1379 command_print(cmd_ctx
, "-- ---------- ---------- ---------- ----------- ------------- ----------");
1382 /* XX: abcdefghij abcdefghij abcdefghij abcdefghij */
1383 command_print(cmd_ctx
, "%2d: %-10s %-10s %-10s %10d %14s %s",
1384 target
->target_number
,
1387 Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
)->name
,
1388 target
->tap
->abs_chain_position
,
1389 target
->tap
->dotted_name
,
1390 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
1391 target
= target
->next
;
1397 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1399 static int powerDropout
;
1400 static int srstAsserted
;
1402 static int runPowerRestore
;
1403 static int runPowerDropout
;
1404 static int runSrstAsserted
;
1405 static int runSrstDeasserted
;
1407 static int sense_handler(void)
1409 static int prevSrstAsserted
= 0;
1410 static int prevPowerdropout
= 0;
1413 if ((retval
=jtag_power_dropout(&powerDropout
))!=ERROR_OK
)
1417 powerRestored
= prevPowerdropout
&& !powerDropout
;
1420 runPowerRestore
= 1;
1423 long long current
= timeval_ms();
1424 static long long lastPower
= 0;
1425 int waitMore
= lastPower
+ 2000 > current
;
1426 if (powerDropout
&& !waitMore
)
1428 runPowerDropout
= 1;
1429 lastPower
= current
;
1432 if ((retval
=jtag_srst_asserted(&srstAsserted
))!=ERROR_OK
)
1436 srstDeasserted
= prevSrstAsserted
&& !srstAsserted
;
1438 static long long lastSrst
= 0;
1439 waitMore
= lastSrst
+ 2000 > current
;
1440 if (srstDeasserted
&& !waitMore
)
1442 runSrstDeasserted
= 1;
1446 if (!prevSrstAsserted
&& srstAsserted
)
1448 runSrstAsserted
= 1;
1451 prevSrstAsserted
= srstAsserted
;
1452 prevPowerdropout
= powerDropout
;
1454 if (srstDeasserted
|| powerRestored
)
1456 /* Other than logging the event we can't do anything here.
1457 * Issuing a reset is a particularly bad idea as we might
1458 * be inside a reset already.
1465 /* process target state changes */
1466 int handle_target(void *priv
)
1468 int retval
= ERROR_OK
;
1470 /* we do not want to recurse here... */
1471 static int recursive
= 0;
1476 /* danger! running these procedures can trigger srst assertions and power dropouts.
1477 * We need to avoid an infinite loop/recursion here and we do that by
1478 * clearing the flags after running these events.
1480 int did_something
= 0;
1481 if (runSrstAsserted
)
1483 Jim_Eval( interp
, "srst_asserted");
1486 if (runSrstDeasserted
)
1488 Jim_Eval( interp
, "srst_deasserted");
1491 if (runPowerDropout
)
1493 Jim_Eval( interp
, "power_dropout");
1496 if (runPowerRestore
)
1498 Jim_Eval( interp
, "power_restore");
1504 /* clear detect flags */
1508 /* clear action flags */
1511 runSrstDeasserted
=0;
1518 target_t
*target
= all_targets
;
1523 /* only poll target if we've got power and srst isn't asserted */
1524 if (target_continous_poll
&&!powerDropout
&&!srstAsserted
)
1526 /* polling may fail silently until the target has been examined */
1527 if((retval
= target_poll(target
)) != ERROR_OK
)
1531 target
= target
->next
;
1537 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1546 target
= get_current_target(cmd_ctx
);
1548 /* list all available registers for the current target */
1551 reg_cache_t
*cache
= target
->reg_cache
;
1557 for (i
= 0; i
< cache
->num_regs
; i
++)
1559 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1560 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
);
1563 cache
= cache
->next
;
1569 /* access a single register by its ordinal number */
1570 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1572 int num
= strtoul(args
[0], NULL
, 0);
1573 reg_cache_t
*cache
= target
->reg_cache
;
1579 for (i
= 0; i
< cache
->num_regs
; i
++)
1583 reg
= &cache
->reg_list
[i
];
1589 cache
= cache
->next
;
1594 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1597 } else /* access a single register by its name */
1599 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1603 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1608 /* display a register */
1609 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1611 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1614 if (reg
->valid
== 0)
1616 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1617 arch_type
->get(reg
);
1619 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1620 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1625 /* set register value */
1628 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1629 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1631 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1632 arch_type
->set(reg
, buf
);
1634 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1635 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1643 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1648 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1650 int retval
= ERROR_OK
;
1651 target_t
*target
= get_current_target(cmd_ctx
);
1655 if((retval
= target_poll(target
)) != ERROR_OK
)
1657 if((retval
= target_arch_state(target
)) != ERROR_OK
)
1663 if (strcmp(args
[0], "on") == 0)
1665 target_continous_poll
= 1;
1667 else if (strcmp(args
[0], "off") == 0)
1669 target_continous_poll
= 0;
1673 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1677 return ERROR_COMMAND_SYNTAX_ERROR
;
1683 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1691 ms
= strtoul(args
[0], &end
, 0) * 1000;
1694 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1698 target_t
*target
= get_current_target(cmd_ctx
);
1700 return target_wait_state(target
, TARGET_HALTED
, ms
);
1703 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1706 struct timeval timeout
, now
;
1708 gettimeofday(&timeout
, NULL
);
1709 timeval_add_time(&timeout
, 0, ms
* 1000);
1713 if ((retval
=target_poll(target
))!=ERROR_OK
)
1716 if (target
->state
== state
)
1723 LOG_DEBUG("waiting for target %s...",
1724 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1727 gettimeofday(&now
, NULL
);
1728 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1730 LOG_ERROR("timed out while waiting for target %s",
1731 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1739 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1742 target_t
*target
= get_current_target(cmd_ctx
);
1746 if ((retval
= target_halt(target
)) != ERROR_OK
)
1751 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1754 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1756 target_t
*target
= get_current_target(cmd_ctx
);
1758 LOG_USER("requesting target halt and executing a soft reset");
1760 target
->type
->soft_reset_halt(target
);
1765 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1768 enum target_reset_mode reset_mode
= RESET_RUN
;
1772 n
= Jim_Nvp_name2value_simple( nvp_reset_modes
, args
[0] );
1773 if( (n
->name
== NULL
) || (n
->value
== RESET_UNKNOWN
) ){
1774 return ERROR_COMMAND_SYNTAX_ERROR
;
1776 reset_mode
= n
->value
;
1779 /* reset *all* targets */
1780 return target_process_reset(cmd_ctx
, reset_mode
);
1784 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1787 target_t
*target
= get_current_target(cmd_ctx
);
1789 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1792 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1794 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1797 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
1803 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1805 target_t
*target
= get_current_target(cmd_ctx
);
1810 return target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1813 return target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1818 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1820 const int line_bytecnt
= 32;
1833 target_t
*target
= get_current_target(cmd_ctx
);
1839 count
= strtoul(args
[1], NULL
, 0);
1841 address
= strtoul(args
[0], NULL
, 0);
1846 size
= 4; line_modulo
= line_bytecnt
/ 4;
1849 size
= 2; line_modulo
= line_bytecnt
/ 2;
1852 size
= 1; line_modulo
= line_bytecnt
/ 1;
1858 buffer
= calloc(count
, size
);
1859 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1860 if (retval
== ERROR_OK
)
1864 for (i
= 0; i
< count
; i
++)
1866 if (i
%line_modulo
== 0)
1867 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1872 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1875 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1878 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1882 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1884 command_print(cmd_ctx
, output
);
1895 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1902 target_t
*target
= get_current_target(cmd_ctx
);
1905 if ((argc
< 2) || (argc
> 3))
1906 return ERROR_COMMAND_SYNTAX_ERROR
;
1908 address
= strtoul(args
[0], NULL
, 0);
1909 value
= strtoul(args
[1], NULL
, 0);
1911 count
= strtoul(args
[2], NULL
, 0);
1917 target_buffer_set_u32(target
, value_buf
, value
);
1921 target_buffer_set_u16(target
, value_buf
, value
);
1925 value_buf
[0] = value
;
1928 return ERROR_COMMAND_SYNTAX_ERROR
;
1930 for (i
=0; i
<count
; i
++)
1936 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1939 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1942 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1949 if (retval
!=ERROR_OK
)
1959 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1965 u32 max_address
=0xffffffff;
1967 int retval
, retvaltemp
;
1971 duration_t duration
;
1972 char *duration_text
;
1974 target_t
*target
= get_current_target(cmd_ctx
);
1976 if ((argc
< 1)||(argc
> 5))
1978 return ERROR_COMMAND_SYNTAX_ERROR
;
1981 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1984 image
.base_address_set
= 1;
1985 image
.base_address
= strtoul(args
[1], NULL
, 0);
1989 image
.base_address_set
= 0;
1993 image
.start_address_set
= 0;
1997 min_address
=strtoul(args
[3], NULL
, 0);
2001 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
2004 if (min_address
>max_address
)
2006 return ERROR_COMMAND_SYNTAX_ERROR
;
2009 duration_start_measure(&duration
);
2011 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2018 for (i
= 0; i
< image
.num_sections
; i
++)
2020 buffer
= malloc(image
.sections
[i
].size
);
2023 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2027 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2036 /* DANGER!!! beware of unsigned comparision here!!! */
2038 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
2039 (image
.sections
[i
].base_address
<max_address
))
2041 if (image
.sections
[i
].base_address
<min_address
)
2043 /* clip addresses below */
2044 offset
+=min_address
-image
.sections
[i
].base_address
;
2048 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
2050 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2053 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2058 image_size
+= length
;
2059 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2065 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2067 image_close(&image
);
2071 if (retval
==ERROR_OK
)
2073 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2075 free(duration_text
);
2077 image_close(&image
);
2083 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2090 int retval
=ERROR_OK
, retvaltemp
;
2092 duration_t duration
;
2093 char *duration_text
;
2095 target_t
*target
= get_current_target(cmd_ctx
);
2099 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2103 address
= strtoul(args
[1], NULL
, 0);
2104 size
= strtoul(args
[2], NULL
, 0);
2106 if ((address
& 3) || (size
& 3))
2108 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2112 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2117 duration_start_measure(&duration
);
2122 u32 this_run_size
= (size
> 560) ? 560 : size
;
2124 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2125 if (retval
!= ERROR_OK
)
2130 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2131 if (retval
!= ERROR_OK
)
2136 size
-= this_run_size
;
2137 address
+= this_run_size
;
2140 if((retvaltemp
= fileio_close(&fileio
)) != ERROR_OK
)
2143 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2146 if (retval
==ERROR_OK
)
2148 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2150 free(duration_text
);
2155 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2161 int retval
, retvaltemp
;
2163 u32 mem_checksum
= 0;
2167 duration_t duration
;
2168 char *duration_text
;
2170 target_t
*target
= get_current_target(cmd_ctx
);
2174 return ERROR_COMMAND_SYNTAX_ERROR
;
2179 LOG_ERROR("no target selected");
2183 duration_start_measure(&duration
);
2187 image
.base_address_set
= 1;
2188 image
.base_address
= strtoul(args
[1], NULL
, 0);
2192 image
.base_address_set
= 0;
2193 image
.base_address
= 0x0;
2196 image
.start_address_set
= 0;
2198 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2205 for (i
= 0; i
< image
.num_sections
; i
++)
2207 buffer
= malloc(image
.sections
[i
].size
);
2210 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2213 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2219 /* calculate checksum of image */
2220 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2222 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2223 if( retval
!= ERROR_OK
)
2229 if( checksum
!= mem_checksum
)
2231 /* failed crc checksum, fall back to a binary compare */
2234 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2236 data
= (u8
*)malloc(buf_cnt
);
2238 /* Can we use 32bit word accesses? */
2240 int count
= buf_cnt
;
2241 if ((count
% 4) == 0)
2246 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2247 if (retval
== ERROR_OK
)
2250 for (t
= 0; t
< buf_cnt
; t
++)
2252 if (data
[t
] != buffer
[t
])
2254 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
]);
2271 image_size
+= buf_cnt
;
2275 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2277 image_close(&image
);
2281 if (retval
==ERROR_OK
)
2283 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2285 free(duration_text
);
2287 image_close(&image
);
2292 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2295 target_t
*target
= get_current_target(cmd_ctx
);
2299 breakpoint_t
*breakpoint
= target
->breakpoints
;
2303 if (breakpoint
->type
== BKPT_SOFT
)
2305 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2306 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2311 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2313 breakpoint
= breakpoint
->next
;
2321 length
= strtoul(args
[1], NULL
, 0);
2324 if (strcmp(args
[2], "hw") == 0)
2327 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2329 LOG_ERROR("Failure setting breakpoints");
2333 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2338 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2344 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2346 target_t
*target
= get_current_target(cmd_ctx
);
2349 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2354 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2356 target_t
*target
= get_current_target(cmd_ctx
);
2361 watchpoint_t
*watchpoint
= target
->watchpoints
;
2365 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
);
2366 watchpoint
= watchpoint
->next
;
2371 enum watchpoint_rw type
= WPT_ACCESS
;
2372 u32 data_value
= 0x0;
2373 u32 data_mask
= 0xffffffff;
2389 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2395 data_value
= strtoul(args
[3], NULL
, 0);
2399 data_mask
= strtoul(args
[4], NULL
, 0);
2402 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2403 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2405 LOG_ERROR("Failure setting breakpoints");
2410 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2416 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2418 target_t
*target
= get_current_target(cmd_ctx
);
2421 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2426 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2429 target_t
*target
= get_current_target(cmd_ctx
);
2435 return ERROR_COMMAND_SYNTAX_ERROR
;
2437 va
= strtoul(args
[0], NULL
, 0);
2439 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2440 if (retval
== ERROR_OK
)
2442 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2446 /* lower levels will have logged a detailed error which is
2447 * forwarded to telnet/GDB session.
2453 static void writeLong(FILE *f
, int l
)
2458 char c
=(l
>>(i
*8))&0xff;
2459 fwrite(&c
, 1, 1, f
);
2464 static void writeString(FILE *f
, char *s
)
2466 fwrite(s
, 1, strlen(s
), f
);
2469 /* Dump a gmon.out histogram file. */
2470 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2473 FILE *f
=fopen(filename
, "w");
2476 fwrite("gmon", 1, 4, f
);
2477 writeLong(f
, 0x00000001); /* Version */
2478 writeLong(f
, 0); /* padding */
2479 writeLong(f
, 0); /* padding */
2480 writeLong(f
, 0); /* padding */
2482 fwrite("", 1, 1, f
); /* GMON_TAG_TIME_HIST */
2484 /* figure out bucket size */
2487 for (i
=0; i
<sampleNum
; i
++)
2499 int addressSpace
=(max
-min
+1);
2501 static int const maxBuckets
=256*1024; /* maximum buckets. */
2502 int length
=addressSpace
;
2503 if (length
> maxBuckets
)
2507 int *buckets
=malloc(sizeof(int)*length
);
2513 memset(buckets
, 0, sizeof(int)*length
);
2514 for (i
=0; i
<sampleNum
;i
++)
2516 u32 address
=samples
[i
];
2517 long long a
=address
-min
;
2518 long long b
=length
-1;
2519 long long c
=addressSpace
-1;
2520 int index
=(a
*b
)/c
; /* danger!!!! int32 overflows */
2524 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2525 writeLong(f
, min
); /* low_pc */
2526 writeLong(f
, max
); /* high_pc */
2527 writeLong(f
, length
); /* # of samples */
2528 writeLong(f
, 64000000); /* 64MHz */
2529 writeString(f
, "seconds");
2530 for (i
=0; i
<(15-strlen("seconds")); i
++)
2532 fwrite("", 1, 1, f
); /* padding */
2534 writeString(f
, "s");
2536 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2538 char *data
=malloc(2*length
);
2541 for (i
=0; i
<length
;i
++)
2550 data
[i
*2+1]=(val
>>8)&0xff;
2553 fwrite(data
, 1, length
*2, f
);
2563 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2564 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2566 target_t
*target
= get_current_target(cmd_ctx
);
2567 struct timeval timeout
, now
;
2569 gettimeofday(&timeout
, NULL
);
2572 return ERROR_COMMAND_SYNTAX_ERROR
;
2575 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2581 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2583 static const int maxSample
=10000;
2584 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2589 int retval
=ERROR_OK
;
2590 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2591 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2595 target_poll(target
);
2596 if (target
->state
== TARGET_HALTED
)
2598 u32 t
=*((u32
*)reg
->value
);
2599 samples
[numSamples
++]=t
;
2600 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2601 target_poll(target
);
2602 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2603 } else if (target
->state
== TARGET_RUNNING
)
2605 /* We want to quickly sample the PC. */
2606 if((retval
= target_halt(target
)) != ERROR_OK
)
2613 command_print(cmd_ctx
, "Target not halted or running");
2617 if (retval
!=ERROR_OK
)
2622 gettimeofday(&now
, NULL
);
2623 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2625 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2626 if((retval
= target_poll(target
)) != ERROR_OK
)
2631 if (target
->state
== TARGET_HALTED
)
2633 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2635 if((retval
= target_poll(target
)) != ERROR_OK
)
2640 writeGmon(samples
, numSamples
, args
[1]);
2641 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2650 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2653 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2656 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2660 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2661 valObjPtr
= Jim_NewIntObj(interp
, val
);
2662 if (!nameObjPtr
|| !valObjPtr
)
2668 Jim_IncrRefCount(nameObjPtr
);
2669 Jim_IncrRefCount(valObjPtr
);
2670 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2671 Jim_DecrRefCount(interp
, nameObjPtr
);
2672 Jim_DecrRefCount(interp
, valObjPtr
);
2674 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2678 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2680 command_context_t
*context
;
2683 context
= Jim_GetAssocData(interp
, "context");
2684 if (context
== NULL
)
2686 LOG_ERROR("mem2array: no command context");
2689 target
= get_current_target(context
);
2692 LOG_ERROR("mem2array: no current target");
2696 return target_mem2array(interp
, target
, argc
,argv
);
2699 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2707 const char *varname
;
2709 int i
, n
, e
, retval
;
2711 /* argv[1] = name of array to receive the data
2712 * argv[2] = desired width
2713 * argv[3] = memory address
2714 * argv[4] = count of times to read
2717 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2720 varname
= Jim_GetString(argv
[1], &len
);
2721 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2723 e
= Jim_GetLong(interp
, argv
[2], &l
);
2729 e
= Jim_GetLong(interp
, argv
[3], &l
);
2734 e
= Jim_GetLong(interp
, argv
[4], &l
);
2750 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2751 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2755 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2756 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2759 if ((addr
+ (len
* width
)) < addr
) {
2760 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2761 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2764 /* absurd transfer size? */
2766 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2767 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2772 ((width
== 2) && ((addr
& 1) == 0)) ||
2773 ((width
== 4) && ((addr
& 3) == 0))) {
2777 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2778 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2779 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2790 /* Slurp... in buffer size chunks */
2792 count
= len
; /* in objects.. */
2793 if (count
> (sizeof(buffer
)/width
)) {
2794 count
= (sizeof(buffer
)/width
);
2797 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2798 if (retval
!= ERROR_OK
) {
2800 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2801 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2802 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2806 v
= 0; /* shut up gcc */
2807 for (i
= 0 ;i
< count
;i
++, n
++) {
2810 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2813 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2816 v
= buffer
[i
] & 0x0ff;
2819 new_int_array_element(interp
, varname
, n
, v
);
2825 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2830 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2833 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2837 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2841 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2848 Jim_IncrRefCount(nameObjPtr
);
2849 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2850 Jim_DecrRefCount(interp
, nameObjPtr
);
2852 if (valObjPtr
== NULL
)
2855 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2856 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2861 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2863 command_context_t
*context
;
2866 context
= Jim_GetAssocData(interp
, "context");
2867 if (context
== NULL
){
2868 LOG_ERROR("array2mem: no command context");
2871 target
= get_current_target(context
);
2872 if (target
== NULL
){
2873 LOG_ERROR("array2mem: no current target");
2877 return target_array2mem( interp
,target
, argc
, argv
);
2880 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2888 const char *varname
;
2890 int i
, n
, e
, retval
;
2892 /* argv[1] = name of array to get the data
2893 * argv[2] = desired width
2894 * argv[3] = memory address
2895 * argv[4] = count to write
2898 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2901 varname
= Jim_GetString(argv
[1], &len
);
2902 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2904 e
= Jim_GetLong(interp
, argv
[2], &l
);
2910 e
= Jim_GetLong(interp
, argv
[3], &l
);
2915 e
= Jim_GetLong(interp
, argv
[4], &l
);
2931 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2932 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2936 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2937 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2940 if ((addr
+ (len
* width
)) < addr
) {
2941 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2942 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2945 /* absurd transfer size? */
2947 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2948 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2953 ((width
== 2) && ((addr
& 1) == 0)) ||
2954 ((width
== 4) && ((addr
& 3) == 0))) {
2958 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2959 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2960 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2971 /* Slurp... in buffer size chunks */
2973 count
= len
; /* in objects.. */
2974 if (count
> (sizeof(buffer
)/width
)) {
2975 count
= (sizeof(buffer
)/width
);
2978 v
= 0; /* shut up gcc */
2979 for (i
= 0 ;i
< count
;i
++, n
++) {
2980 get_int_array_element(interp
, varname
, n
, &v
);
2983 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2986 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2989 buffer
[i
] = v
& 0x0ff;
2995 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
2996 if (retval
!= ERROR_OK
) {
2998 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2999 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3000 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: cannot read memory", NULL
);
3006 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3011 void target_all_handle_event( enum target_event e
)
3015 LOG_DEBUG( "**all*targets: event: %d, %s",
3017 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3019 target
= all_targets
;
3021 target_handle_event( target
, e
);
3022 target
= target
->next
;
3026 void target_handle_event( target_t
*target
, enum target_event e
)
3028 target_event_action_t
*teap
;
3031 teap
= target
->event_action
;
3035 if( teap
->event
== e
){
3037 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3038 target
->target_number
,
3042 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
,
3043 Jim_GetString( teap
->body
, NULL
) );
3044 if (Jim_EvalObj( interp
, teap
->body
)!=JIM_OK
)
3046 Jim_PrintErrorMessage(interp
);
3052 LOG_DEBUG( "event: %d %s - no action",
3054 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3058 enum target_cfg_param
{
3061 TCFG_WORK_AREA_VIRT
,
3062 TCFG_WORK_AREA_PHYS
,
3063 TCFG_WORK_AREA_SIZE
,
3064 TCFG_WORK_AREA_BACKUP
,
3067 TCFG_CHAIN_POSITION
,
3070 static Jim_Nvp nvp_config_opts
[] = {
3071 { .name
= "-type", .value
= TCFG_TYPE
},
3072 { .name
= "-event", .value
= TCFG_EVENT
},
3073 { .name
= "-work-area-virt", .value
= TCFG_WORK_AREA_VIRT
},
3074 { .name
= "-work-area-phys", .value
= TCFG_WORK_AREA_PHYS
},
3075 { .name
= "-work-area-size", .value
= TCFG_WORK_AREA_SIZE
},
3076 { .name
= "-work-area-backup", .value
= TCFG_WORK_AREA_BACKUP
},
3077 { .name
= "-endian" , .value
= TCFG_ENDIAN
},
3078 { .name
= "-variant", .value
= TCFG_VARIANT
},
3079 { .name
= "-chain-position", .value
= TCFG_CHAIN_POSITION
},
3081 { .name
= NULL
, .value
= -1 }
3084 static int target_configure( Jim_GetOptInfo
*goi
, target_t
*target
)
3092 /* parse config or cget options ... */
3093 while( goi
->argc
> 0 ){
3094 Jim_SetEmptyResult( goi
->interp
);
3095 /* Jim_GetOpt_Debug( goi ); */
3097 if( target
->type
->target_jim_configure
){
3098 /* target defines a configure function */
3099 /* target gets first dibs on parameters */
3100 e
= (*(target
->type
->target_jim_configure
))( target
, goi
);
3109 /* otherwise we 'continue' below */
3111 e
= Jim_GetOpt_Nvp( goi
, nvp_config_opts
, &n
);
3113 Jim_GetOpt_NvpUnknown( goi
, nvp_config_opts
, 0 );
3119 if( goi
->isconfigure
){
3120 Jim_SetResult_sprintf( goi
->interp
, "not setable: %s", n
->name
);
3124 if( goi
->argc
!= 0 ){
3125 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
3129 Jim_SetResultString( goi
->interp
, target
->type
->name
, -1 );
3133 if( goi
->argc
== 0 ){
3134 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ...");
3138 e
= Jim_GetOpt_Nvp( goi
, nvp_target_event
, &n
);
3140 Jim_GetOpt_NvpUnknown( goi
, nvp_target_event
, 1 );
3144 if( goi
->isconfigure
){
3145 if( goi
->argc
!= 1 ){
3146 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
3150 if( goi
->argc
!= 0 ){
3151 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
3157 target_event_action_t
*teap
;
3159 teap
= target
->event_action
;
3160 /* replace existing? */
3162 if( teap
->event
== n
->value
){
3168 if( goi
->isconfigure
){
3171 teap
= calloc( 1, sizeof(*teap
) );
3173 teap
->event
= n
->value
;
3174 Jim_GetOpt_Obj( goi
, &o
);
3176 Jim_DecrRefCount( interp
, teap
->body
);
3178 teap
->body
= Jim_DuplicateObj( goi
->interp
, o
);
3181 * Tcl/TK - "tk events" have a nice feature.
3182 * See the "BIND" command.
3183 * We should support that here.
3184 * You can specify %X and %Y in the event code.
3185 * The idea is: %T - target name.
3186 * The idea is: %N - target number
3187 * The idea is: %E - event name.
3189 Jim_IncrRefCount( teap
->body
);
3191 /* add to head of event list */
3192 teap
->next
= target
->event_action
;
3193 target
->event_action
= teap
;
3194 Jim_SetEmptyResult(goi
->interp
);
3198 Jim_SetEmptyResult( goi
->interp
);
3200 Jim_SetResult( goi
->interp
, Jim_DuplicateObj( goi
->interp
, teap
->body
) );
3207 case TCFG_WORK_AREA_VIRT
:
3208 if( goi
->isconfigure
){
3209 target_free_all_working_areas(target
);
3210 e
= Jim_GetOpt_Wide( goi
, &w
);
3214 target
->working_area_virt
= w
;
3216 if( goi
->argc
!= 0 ){
3220 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_virt
) );
3224 case TCFG_WORK_AREA_PHYS
:
3225 if( goi
->isconfigure
){
3226 target_free_all_working_areas(target
);
3227 e
= Jim_GetOpt_Wide( goi
, &w
);
3231 target
->working_area_phys
= w
;
3233 if( goi
->argc
!= 0 ){
3237 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_phys
) );
3241 case TCFG_WORK_AREA_SIZE
:
3242 if( goi
->isconfigure
){
3243 target_free_all_working_areas(target
);
3244 e
= Jim_GetOpt_Wide( goi
, &w
);
3248 target
->working_area_size
= w
;
3250 if( goi
->argc
!= 0 ){
3254 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3258 case TCFG_WORK_AREA_BACKUP
:
3259 if( goi
->isconfigure
){
3260 target_free_all_working_areas(target
);
3261 e
= Jim_GetOpt_Wide( goi
, &w
);
3265 /* make this exactly 1 or 0 */
3266 target
->backup_working_area
= (!!w
);
3268 if( goi
->argc
!= 0 ){
3272 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3273 /* loop for more e*/
3277 if( goi
->isconfigure
){
3278 e
= Jim_GetOpt_Nvp( goi
, nvp_target_endian
, &n
);
3280 Jim_GetOpt_NvpUnknown( goi
, nvp_target_endian
, 1 );
3283 target
->endianness
= n
->value
;
3285 if( goi
->argc
!= 0 ){
3289 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3290 if( n
->name
== NULL
){
3291 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3292 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3294 Jim_SetResultString( goi
->interp
, n
->name
, -1 );
3299 if( goi
->isconfigure
){
3300 if( goi
->argc
< 1 ){
3301 Jim_SetResult_sprintf( goi
->interp
,
3306 if( target
->variant
){
3307 free((void *)(target
->variant
));
3309 e
= Jim_GetOpt_String( goi
, &cp
, NULL
);
3310 target
->variant
= strdup(cp
);
3312 if( goi
->argc
!= 0 ){
3316 Jim_SetResultString( goi
->interp
, target
->variant
,-1 );
3319 case TCFG_CHAIN_POSITION
:
3320 if( goi
->isconfigure
){
3323 target_free_all_working_areas(target
);
3324 e
= Jim_GetOpt_Obj( goi
, &o
);
3328 tap
= jtag_TapByJimObj( goi
->interp
, o
);
3332 /* make this exactly 1 or 0 */
3335 if( goi
->argc
!= 0 ){
3339 Jim_SetResultString( interp
, target
->tap
->dotted_name
, -1 );
3340 /* loop for more e*/
3343 } /* while( goi->argc ) */
3346 /* done - we return */
3350 /** this is the 'tcl' handler for the target specific command */
3351 static int tcl_target_func( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3359 struct command_context_s
*cmd_ctx
;
3366 TS_CMD_MWW
, TS_CMD_MWH
, TS_CMD_MWB
,
3367 TS_CMD_MDW
, TS_CMD_MDH
, TS_CMD_MDB
,
3368 TS_CMD_MRW
, TS_CMD_MRH
, TS_CMD_MRB
,
3369 TS_CMD_MEM2ARRAY
, TS_CMD_ARRAY2MEM
,
3377 TS_CMD_INVOKE_EVENT
,
3380 static const Jim_Nvp target_options
[] = {
3381 { .name
= "configure", .value
= TS_CMD_CONFIGURE
},
3382 { .name
= "cget", .value
= TS_CMD_CGET
},
3383 { .name
= "mww", .value
= TS_CMD_MWW
},
3384 { .name
= "mwh", .value
= TS_CMD_MWH
},
3385 { .name
= "mwb", .value
= TS_CMD_MWB
},
3386 { .name
= "mdw", .value
= TS_CMD_MDW
},
3387 { .name
= "mdh", .value
= TS_CMD_MDH
},
3388 { .name
= "mdb", .value
= TS_CMD_MDB
},
3389 { .name
= "mem2array", .value
= TS_CMD_MEM2ARRAY
},
3390 { .name
= "array2mem", .value
= TS_CMD_ARRAY2MEM
},
3391 { .name
= "eventlist", .value
= TS_CMD_EVENTLIST
},
3392 { .name
= "curstate", .value
= TS_CMD_CURSTATE
},
3394 { .name
= "arp_examine", .value
= TS_CMD_EXAMINE
},
3395 { .name
= "arp_poll", .value
= TS_CMD_POLL
},
3396 { .name
= "arp_reset", .value
= TS_CMD_RESET
},
3397 { .name
= "arp_halt", .value
= TS_CMD_HALT
},
3398 { .name
= "arp_waitstate", .value
= TS_CMD_WAITSTATE
},
3399 { .name
= "invoke-event", .value
= TS_CMD_INVOKE_EVENT
},
3401 { .name
= NULL
, .value
= -1 },
3404 /* go past the "command" */
3405 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3407 target
= Jim_CmdPrivData( goi
.interp
);
3408 cmd_ctx
= Jim_GetAssocData(goi
.interp
, "context");
3410 /* commands here are in an NVP table */
3411 e
= Jim_GetOpt_Nvp( &goi
, target_options
, &n
);
3413 Jim_GetOpt_NvpUnknown( &goi
, target_options
, 0 );
3416 /* Assume blank result */
3417 Jim_SetEmptyResult( goi
.interp
);
3420 case TS_CMD_CONFIGURE
:
3422 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "missing: -option VALUE ...");
3425 goi
.isconfigure
= 1;
3426 return target_configure( &goi
, target
);
3428 // some things take params
3430 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "missing: ?-option?");
3433 goi
.isconfigure
= 0;
3434 return target_configure( &goi
, target
);
3442 * argv[3] = optional count.
3445 if( (goi
.argc
== 3) || (goi
.argc
== 4) ){
3449 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR DATA [COUNT]", n
->name
);
3453 e
= Jim_GetOpt_Wide( &goi
, &a
);
3458 e
= Jim_GetOpt_Wide( &goi
, &b
);
3463 e
= Jim_GetOpt_Wide( &goi
, &c
);
3473 target_buffer_set_u32( target
, target_buf
, b
);
3477 target_buffer_set_u16( target
, target_buf
, b
);
3481 target_buffer_set_u8( target
, target_buf
, b
);
3485 for( x
= 0 ; x
< c
; x
++ ){
3486 e
= target
->type
->write_memory( target
, a
, b
, 1, target_buf
);
3487 if( e
!= ERROR_OK
){
3488 Jim_SetResult_sprintf( interp
, "Error writing @ 0x%08x: %d\n", (int)(a
), e
);
3501 /* argv[0] = command
3503 * argv[2] = optional count
3505 if( (goi
.argc
== 2) || (goi
.argc
== 3) ){
3506 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR [COUNT]", n
->name
);
3509 e
= Jim_GetOpt_Wide( &goi
, &a
);
3514 e
= Jim_GetOpt_Wide( &goi
, &c
);
3521 b
= 1; /* shut up gcc */
3534 /* convert to "bytes" */
3536 /* count is now in 'BYTES' */
3542 e
= target
->type
->read_memory( target
, a
, b
, y
/ b
, target_buf
);
3543 if( e
!= ERROR_OK
){
3544 Jim_SetResult_sprintf( interp
, "error reading target @ 0x%08lx", (int)(a
) );
3548 Jim_fprintf( interp
, interp
->cookie_stdout
, "0x%08x ", (int)(a
) );
3551 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 4 ){
3552 z
= target_buffer_get_u32( target
, &(target_buf
[ x
* 4 ]) );
3553 Jim_fprintf( interp
, interp
->cookie_stdout
, "%08x ", (int)(z
) );
3555 for( ; (x
< 16) ; x
+= 4 ){
3556 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3560 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 2 ){
3561 z
= target_buffer_get_u16( target
, &(target_buf
[ x
* 2 ]) );
3562 Jim_fprintf( interp
, interp
->cookie_stdout
, "%04x ", (int)(z
) );
3564 for( ; (x
< 16) ; x
+= 2 ){
3565 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3570 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 1 ){
3571 z
= target_buffer_get_u8( target
, &(target_buf
[ x
* 4 ]) );
3572 Jim_fprintf( interp
, interp
->cookie_stdout
, "%02x ", (int)(z
) );
3574 for( ; (x
< 16) ; x
+= 1 ){
3575 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3579 /* ascii-ify the bytes */
3580 for( x
= 0 ; x
< y
; x
++ ){
3581 if( (target_buf
[x
] >= 0x20) &&
3582 (target_buf
[x
] <= 0x7e) ){
3586 target_buf
[x
] = '.';
3591 target_buf
[x
] = ' ';
3596 /* print - with a newline */
3597 Jim_fprintf( interp
, interp
->cookie_stdout
, "%s\n", target_buf
);
3603 case TS_CMD_MEM2ARRAY
:
3604 return target_mem2array( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3606 case TS_CMD_ARRAY2MEM
:
3607 return target_array2mem( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3609 case TS_CMD_EXAMINE
:
3611 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3614 e
= target
->type
->examine( target
);
3615 if( e
!= ERROR_OK
){
3616 Jim_SetResult_sprintf( interp
, "examine-fails: %d", e
);
3622 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3625 if( !(target
->type
->examined
) ){
3626 e
= ERROR_TARGET_NOT_EXAMINED
;
3628 e
= target
->type
->poll( target
);
3630 if( e
!= ERROR_OK
){
3631 Jim_SetResult_sprintf( interp
, "poll-fails: %d", e
);
3638 if( goi
.argc
!= 2 ){
3639 Jim_WrongNumArgs( interp
, 2, argv
, "t|f|assert|deassert BOOL");
3642 e
= Jim_GetOpt_Nvp( &goi
, nvp_assert
, &n
);
3644 Jim_GetOpt_NvpUnknown( &goi
, nvp_assert
, 1 );
3647 /* the halt or not param */
3648 e
= Jim_GetOpt_Wide( &goi
, &a
);
3652 /* determine if we should halt or not. */
3653 target
->reset_halt
= !!a
;
3654 /* When this happens - all workareas are invalid. */
3655 target_free_all_working_areas_restore(target
, 0);
3658 if( n
->value
== NVP_ASSERT
){
3659 target
->type
->assert_reset( target
);
3661 target
->type
->deassert_reset( target
);
3666 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "halt [no parameters]");
3669 target
->type
->halt( target
);
3671 case TS_CMD_WAITSTATE
:
3672 /* params: <name> statename timeoutmsecs */
3673 if( goi
.argc
!= 2 ){
3674 Jim_SetResult_sprintf( goi
.interp
, "%s STATENAME TIMEOUTMSECS", n
->name
);
3677 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_state
, &n
);
3679 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_state
,1 );
3682 e
= Jim_GetOpt_Wide( &goi
, &a
);
3686 e
= target_wait_state( target
, n
->value
, a
);
3687 if( e
!= ERROR_OK
){
3688 Jim_SetResult_sprintf( goi
.interp
,
3689 "target: %s wait %s fails (%d) %s",
3692 e
, target_strerror_safe(e
) );
3697 case TS_CMD_EVENTLIST
:
3698 /* List for human, Events defined for this target.
3699 * scripts/programs should use 'name cget -event NAME'
3702 target_event_action_t
*teap
;
3703 teap
= target
->event_action
;
3704 command_print( cmd_ctx
, "Event actions for target (%d) %s\n",
3705 target
->target_number
,
3707 command_print( cmd_ctx
, "%-25s | Body", "Event");
3708 command_print( cmd_ctx
, "------------------------- | ----------------------------------------");
3710 command_print( cmd_ctx
,
3712 Jim_Nvp_value2name_simple( nvp_target_event
, teap
->event
)->name
,
3713 Jim_GetString( teap
->body
, NULL
) );
3716 command_print( cmd_ctx
, "***END***");
3719 case TS_CMD_CURSTATE
:
3720 if( goi
.argc
!= 0 ){
3721 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "[no parameters]");
3724 Jim_SetResultString( goi
.interp
,
3725 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
,-1);
3727 case TS_CMD_INVOKE_EVENT
:
3728 if( goi
.argc
!= 1 ){
3729 Jim_SetResult_sprintf( goi
.interp
, "%s ?EVENTNAME?",n
->name
);
3732 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_event
, &n
);
3734 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_event
, 1 );
3737 target_handle_event( target
, n
->value
);
3743 static int target_create( Jim_GetOptInfo
*goi
)
3752 struct command_context_s
*cmd_ctx
;
3754 cmd_ctx
= Jim_GetAssocData(goi
->interp
, "context");
3755 if( goi
->argc
< 3 ){
3756 Jim_WrongNumArgs( goi
->interp
, 1, goi
->argv
, "?name? ?type? ..options...");
3761 Jim_GetOpt_Obj( goi
, &new_cmd
);
3762 /* does this command exist? */
3763 cmd
= Jim_GetCommand( goi
->interp
, new_cmd
, JIM_ERRMSG
);
3765 cp
= Jim_GetString( new_cmd
, NULL
);
3766 Jim_SetResult_sprintf(goi
->interp
, "Command/target: %s Exists", cp
);
3771 e
= Jim_GetOpt_String( goi
, &cp2
, NULL
);
3773 /* now does target type exist */
3774 for( x
= 0 ; target_types
[x
] ; x
++ ){
3775 if( 0 == strcmp( cp
, target_types
[x
]->name
) ){
3780 if( target_types
[x
] == NULL
){
3781 Jim_SetResult_sprintf( goi
->interp
, "Unknown target type %s, try one of ", cp
);
3782 for( x
= 0 ; target_types
[x
] ; x
++ ){
3783 if( target_types
[x
+1] ){
3784 Jim_AppendStrings( goi
->interp
,
3785 Jim_GetResult(goi
->interp
),
3786 target_types
[x
]->name
,
3789 Jim_AppendStrings( goi
->interp
,
3790 Jim_GetResult(goi
->interp
),
3792 target_types
[x
]->name
,NULL
);
3799 target
= calloc(1,sizeof(target_t
));
3800 /* set target number */
3801 target
->target_number
= new_target_number();
3803 /* allocate memory for each unique target type */
3804 target
->type
= (target_type_t
*)calloc(1,sizeof(target_type_t
));
3806 memcpy( target
->type
, target_types
[x
], sizeof(target_type_t
));
3808 /* will be set by "-endian" */
3809 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3811 target
->working_area
= 0x0;
3812 target
->working_area_size
= 0x0;
3813 target
->working_areas
= NULL
;
3814 target
->backup_working_area
= 0;
3816 target
->state
= TARGET_UNKNOWN
;
3817 target
->debug_reason
= DBG_REASON_UNDEFINED
;
3818 target
->reg_cache
= NULL
;
3819 target
->breakpoints
= NULL
;
3820 target
->watchpoints
= NULL
;
3821 target
->next
= NULL
;
3822 target
->arch_info
= NULL
;
3824 target
->display
= 1;
3826 /* initialize trace information */
3827 target
->trace_info
= malloc(sizeof(trace_t
));
3828 target
->trace_info
->num_trace_points
= 0;
3829 target
->trace_info
->trace_points_size
= 0;
3830 target
->trace_info
->trace_points
= NULL
;
3831 target
->trace_info
->trace_history_size
= 0;
3832 target
->trace_info
->trace_history
= NULL
;
3833 target
->trace_info
->trace_history_pos
= 0;
3834 target
->trace_info
->trace_history_overflowed
= 0;
3836 target
->dbgmsg
= NULL
;
3837 target
->dbg_msg_enabled
= 0;
3839 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3841 /* Do the rest as "configure" options */
3842 goi
->isconfigure
= 1;
3843 e
= target_configure( goi
, target
);
3845 if (target
->tap
== NULL
)
3847 Jim_SetResultString( interp
, "-chain-position required when creating target", -1);
3852 free( target
->type
);
3857 if( target
->endianness
== TARGET_ENDIAN_UNKNOWN
){
3858 /* default endian to little if not specified */
3859 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3862 /* incase variant is not set */
3863 if (!target
->variant
)
3864 target
->variant
= strdup("");
3866 /* create the target specific commands */
3867 if( target
->type
->register_commands
){
3868 (*(target
->type
->register_commands
))( cmd_ctx
);
3870 if( target
->type
->target_create
){
3871 (*(target
->type
->target_create
))( target
, goi
->interp
);
3874 /* append to end of list */
3877 tpp
= &(all_targets
);
3879 tpp
= &( (*tpp
)->next
);
3884 cp
= Jim_GetString( new_cmd
, NULL
);
3885 target
->cmd_name
= strdup(cp
);
3887 /* now - create the new target name command */
3888 e
= Jim_CreateCommand( goi
->interp
,
3891 tcl_target_func
, /* C function */
3892 target
, /* private data */
3893 NULL
); /* no del proc */
3898 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3902 struct command_context_s
*cmd_ctx
;
3906 /* TG = target generic */
3914 const char *target_cmds
[] = {
3915 "create", "types", "names", "current", "number",
3917 NULL
/* terminate */
3920 LOG_DEBUG("Target command params:");
3921 LOG_DEBUG(Jim_Debug_ArgvString( interp
, argc
, argv
) );
3923 cmd_ctx
= Jim_GetAssocData( interp
, "context" );
3925 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3927 if( goi
.argc
== 0 ){
3928 Jim_WrongNumArgs(interp
, 1, argv
, "missing: command ...");
3932 /* Jim_GetOpt_Debug( &goi ); */
3933 r
= Jim_GetOpt_Enum( &goi
, target_cmds
, &x
);
3940 Jim_Panic(goi
.interp
,"Why am I here?");
3942 case TG_CMD_CURRENT
:
3943 if( goi
.argc
!= 0 ){
3944 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters");
3947 Jim_SetResultString( goi
.interp
, get_current_target( cmd_ctx
)->cmd_name
, -1 );
3950 if( goi
.argc
!= 0 ){
3951 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
3954 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
3955 for( x
= 0 ; target_types
[x
] ; x
++ ){
3956 Jim_ListAppendElement( goi
.interp
,
3957 Jim_GetResult(goi
.interp
),
3958 Jim_NewStringObj( goi
.interp
, target_types
[x
]->name
, -1 ) );
3962 if( goi
.argc
!= 0 ){
3963 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
3966 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
3967 target
= all_targets
;
3969 Jim_ListAppendElement( goi
.interp
,
3970 Jim_GetResult(goi
.interp
),
3971 Jim_NewStringObj( goi
.interp
, target
->cmd_name
, -1 ) );
3972 target
= target
->next
;
3977 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "?name ... config options ...");
3980 return target_create( &goi
);
3983 if( goi
.argc
!= 1 ){
3984 Jim_SetResult_sprintf( goi
.interp
, "expected: target number ?NUMBER?");
3987 e
= Jim_GetOpt_Wide( &goi
, &w
);
3993 t
= get_target_by_num(w
);
3995 Jim_SetResult_sprintf( goi
.interp
,"Target: number %d does not exist", (int)(w
));
3998 Jim_SetResultString( goi
.interp
, t
->cmd_name
, -1 );
4002 if( goi
.argc
!= 0 ){
4003 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "<no parameters>");
4006 Jim_SetResult( goi
.interp
,
4007 Jim_NewIntObj( goi
.interp
, max_target_number()));
4023 static int fastload_num
;
4024 static struct FastLoad
*fastload
;
4026 static void free_fastload(void)
4031 for (i
=0; i
<fastload_num
; i
++)
4033 if (fastload
[i
].data
)
4034 free(fastload
[i
].data
);
4044 int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4050 u32 max_address
=0xffffffff;
4056 duration_t duration
;
4057 char *duration_text
;
4059 if ((argc
< 1)||(argc
> 5))
4061 return ERROR_COMMAND_SYNTAX_ERROR
;
4064 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
4067 image
.base_address_set
= 1;
4068 image
.base_address
= strtoul(args
[1], NULL
, 0);
4072 image
.base_address_set
= 0;
4076 image
.start_address_set
= 0;
4080 min_address
=strtoul(args
[3], NULL
, 0);
4084 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
4087 if (min_address
>max_address
)
4089 return ERROR_COMMAND_SYNTAX_ERROR
;
4092 duration_start_measure(&duration
);
4094 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
4101 fastload_num
=image
.num_sections
;
4102 fastload
=(struct FastLoad
*)malloc(sizeof(struct FastLoad
)*image
.num_sections
);
4105 image_close(&image
);
4108 memset(fastload
, 0, sizeof(struct FastLoad
)*image
.num_sections
);
4109 for (i
= 0; i
< image
.num_sections
; i
++)
4111 buffer
= malloc(image
.sections
[i
].size
);
4114 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
4118 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
4128 /* DANGER!!! beware of unsigned comparision here!!! */
4130 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
4131 (image
.sections
[i
].base_address
<max_address
))
4133 if (image
.sections
[i
].base_address
<min_address
)
4135 /* clip addresses below */
4136 offset
+=min_address
-image
.sections
[i
].base_address
;
4140 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
4142 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
4145 fastload
[i
].address
=image
.sections
[i
].base_address
+offset
;
4146 fastload
[i
].data
=malloc(length
);
4147 if (fastload
[i
].data
==NULL
)
4152 memcpy(fastload
[i
].data
, buffer
+offset
, length
);
4153 fastload
[i
].length
=length
;
4155 image_size
+= length
;
4156 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
4162 duration_stop_measure(&duration
, &duration_text
);
4163 if (retval
==ERROR_OK
)
4165 command_print(cmd_ctx
, "Loaded %u bytes in %s", image_size
, duration_text
);
4166 command_print(cmd_ctx
, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4168 free(duration_text
);
4170 image_close(&image
);
4172 if (retval
!=ERROR_OK
)
4180 int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4183 return ERROR_COMMAND_SYNTAX_ERROR
;
4186 LOG_ERROR("No image in memory");
4190 int ms
=timeval_ms();
4192 for (i
=0; i
<fastload_num
;i
++)
4195 target_t
*target
= get_current_target(cmd_ctx
);
4196 if ((retval
= target_write_buffer(target
, fastload
[i
].address
, fastload
[i
].length
, fastload
[i
].data
)) != ERROR_OK
)
4200 size
+=fastload
[i
].length
;
4202 int after
=timeval_ms();
4203 command_print(cmd_ctx
, "Loaded image %f kBytes/s", (float)(size
/1024.0)/((float)(after
-ms
)/1000.0));
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)