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 /* wait for target state to change. The trick here is to have a low
1704 * latency for short waits and not to suck up all the CPU time
1707 * After 500ms, keep_alive() is invoked
1709 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1712 long long then
=0, cur
;
1717 if ((retval
=target_poll(target
))!=ERROR_OK
)
1719 if (target
->state
== state
)
1727 then
= timeval_ms();
1728 LOG_DEBUG("waiting for target %s...",
1729 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1739 LOG_ERROR("timed out while waiting for target %s",
1740 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1748 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1751 target_t
*target
= get_current_target(cmd_ctx
);
1755 if ((retval
= target_halt(target
)) != ERROR_OK
)
1760 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1763 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1765 target_t
*target
= get_current_target(cmd_ctx
);
1767 LOG_USER("requesting target halt and executing a soft reset");
1769 target
->type
->soft_reset_halt(target
);
1774 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1777 enum target_reset_mode reset_mode
= RESET_RUN
;
1781 n
= Jim_Nvp_name2value_simple( nvp_reset_modes
, args
[0] );
1782 if( (n
->name
== NULL
) || (n
->value
== RESET_UNKNOWN
) ){
1783 return ERROR_COMMAND_SYNTAX_ERROR
;
1785 reset_mode
= n
->value
;
1788 /* reset *all* targets */
1789 return target_process_reset(cmd_ctx
, reset_mode
);
1793 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1796 target_t
*target
= get_current_target(cmd_ctx
);
1798 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1801 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1803 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1806 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
1812 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1814 target_t
*target
= get_current_target(cmd_ctx
);
1819 return target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1822 return target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1827 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1829 const int line_bytecnt
= 32;
1842 target_t
*target
= get_current_target(cmd_ctx
);
1848 count
= strtoul(args
[1], NULL
, 0);
1850 address
= strtoul(args
[0], NULL
, 0);
1855 size
= 4; line_modulo
= line_bytecnt
/ 4;
1858 size
= 2; line_modulo
= line_bytecnt
/ 2;
1861 size
= 1; line_modulo
= line_bytecnt
/ 1;
1867 buffer
= calloc(count
, size
);
1868 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1869 if (retval
== ERROR_OK
)
1873 for (i
= 0; i
< count
; i
++)
1875 if (i
%line_modulo
== 0)
1876 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1881 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1884 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1887 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1891 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1893 command_print(cmd_ctx
, output
);
1904 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1911 target_t
*target
= get_current_target(cmd_ctx
);
1914 if ((argc
< 2) || (argc
> 3))
1915 return ERROR_COMMAND_SYNTAX_ERROR
;
1917 address
= strtoul(args
[0], NULL
, 0);
1918 value
= strtoul(args
[1], NULL
, 0);
1920 count
= strtoul(args
[2], NULL
, 0);
1926 target_buffer_set_u32(target
, value_buf
, value
);
1930 target_buffer_set_u16(target
, value_buf
, value
);
1934 value_buf
[0] = value
;
1937 return ERROR_COMMAND_SYNTAX_ERROR
;
1939 for (i
=0; i
<count
; i
++)
1945 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1948 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1951 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1958 if (retval
!=ERROR_OK
)
1968 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1974 u32 max_address
=0xffffffff;
1976 int retval
, retvaltemp
;
1980 duration_t duration
;
1981 char *duration_text
;
1983 target_t
*target
= get_current_target(cmd_ctx
);
1985 if ((argc
< 1)||(argc
> 5))
1987 return ERROR_COMMAND_SYNTAX_ERROR
;
1990 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1993 image
.base_address_set
= 1;
1994 image
.base_address
= strtoul(args
[1], NULL
, 0);
1998 image
.base_address_set
= 0;
2002 image
.start_address_set
= 0;
2006 min_address
=strtoul(args
[3], NULL
, 0);
2010 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
2013 if (min_address
>max_address
)
2015 return ERROR_COMMAND_SYNTAX_ERROR
;
2018 duration_start_measure(&duration
);
2020 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2027 for (i
= 0; i
< image
.num_sections
; i
++)
2029 buffer
= malloc(image
.sections
[i
].size
);
2032 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2036 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2045 /* DANGER!!! beware of unsigned comparision here!!! */
2047 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
2048 (image
.sections
[i
].base_address
<max_address
))
2050 if (image
.sections
[i
].base_address
<min_address
)
2052 /* clip addresses below */
2053 offset
+=min_address
-image
.sections
[i
].base_address
;
2057 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
2059 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2062 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2067 image_size
+= length
;
2068 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2074 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2076 image_close(&image
);
2080 if (retval
==ERROR_OK
)
2082 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2084 free(duration_text
);
2086 image_close(&image
);
2092 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2099 int retval
=ERROR_OK
, retvaltemp
;
2101 duration_t duration
;
2102 char *duration_text
;
2104 target_t
*target
= get_current_target(cmd_ctx
);
2108 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2112 address
= strtoul(args
[1], NULL
, 0);
2113 size
= strtoul(args
[2], NULL
, 0);
2115 if ((address
& 3) || (size
& 3))
2117 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2121 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2126 duration_start_measure(&duration
);
2131 u32 this_run_size
= (size
> 560) ? 560 : size
;
2133 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2134 if (retval
!= ERROR_OK
)
2139 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2140 if (retval
!= ERROR_OK
)
2145 size
-= this_run_size
;
2146 address
+= this_run_size
;
2149 if((retvaltemp
= fileio_close(&fileio
)) != ERROR_OK
)
2152 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2155 if (retval
==ERROR_OK
)
2157 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2159 free(duration_text
);
2164 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2170 int retval
, retvaltemp
;
2172 u32 mem_checksum
= 0;
2176 duration_t duration
;
2177 char *duration_text
;
2179 target_t
*target
= get_current_target(cmd_ctx
);
2183 return ERROR_COMMAND_SYNTAX_ERROR
;
2188 LOG_ERROR("no target selected");
2192 duration_start_measure(&duration
);
2196 image
.base_address_set
= 1;
2197 image
.base_address
= strtoul(args
[1], NULL
, 0);
2201 image
.base_address_set
= 0;
2202 image
.base_address
= 0x0;
2205 image
.start_address_set
= 0;
2207 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2214 for (i
= 0; i
< image
.num_sections
; i
++)
2216 buffer
= malloc(image
.sections
[i
].size
);
2219 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2222 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2228 /* calculate checksum of image */
2229 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2231 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2232 if( retval
!= ERROR_OK
)
2238 if( checksum
!= mem_checksum
)
2240 /* failed crc checksum, fall back to a binary compare */
2243 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2245 data
= (u8
*)malloc(buf_cnt
);
2247 /* Can we use 32bit word accesses? */
2249 int count
= buf_cnt
;
2250 if ((count
% 4) == 0)
2255 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2256 if (retval
== ERROR_OK
)
2259 for (t
= 0; t
< buf_cnt
; t
++)
2261 if (data
[t
] != buffer
[t
])
2263 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
]);
2280 image_size
+= buf_cnt
;
2284 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2286 image_close(&image
);
2290 if (retval
==ERROR_OK
)
2292 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2294 free(duration_text
);
2296 image_close(&image
);
2301 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2304 target_t
*target
= get_current_target(cmd_ctx
);
2308 breakpoint_t
*breakpoint
= target
->breakpoints
;
2312 if (breakpoint
->type
== BKPT_SOFT
)
2314 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2315 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2320 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2322 breakpoint
= breakpoint
->next
;
2330 length
= strtoul(args
[1], NULL
, 0);
2333 if (strcmp(args
[2], "hw") == 0)
2336 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2338 LOG_ERROR("Failure setting breakpoints");
2342 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2347 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2353 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2355 target_t
*target
= get_current_target(cmd_ctx
);
2358 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2363 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2365 target_t
*target
= get_current_target(cmd_ctx
);
2370 watchpoint_t
*watchpoint
= target
->watchpoints
;
2374 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
);
2375 watchpoint
= watchpoint
->next
;
2380 enum watchpoint_rw type
= WPT_ACCESS
;
2381 u32 data_value
= 0x0;
2382 u32 data_mask
= 0xffffffff;
2398 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2404 data_value
= strtoul(args
[3], NULL
, 0);
2408 data_mask
= strtoul(args
[4], NULL
, 0);
2411 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2412 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2414 LOG_ERROR("Failure setting breakpoints");
2419 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2425 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2427 target_t
*target
= get_current_target(cmd_ctx
);
2430 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2435 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2438 target_t
*target
= get_current_target(cmd_ctx
);
2444 return ERROR_COMMAND_SYNTAX_ERROR
;
2446 va
= strtoul(args
[0], NULL
, 0);
2448 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2449 if (retval
== ERROR_OK
)
2451 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2455 /* lower levels will have logged a detailed error which is
2456 * forwarded to telnet/GDB session.
2462 static void writeLong(FILE *f
, int l
)
2467 char c
=(l
>>(i
*8))&0xff;
2468 fwrite(&c
, 1, 1, f
);
2473 static void writeString(FILE *f
, char *s
)
2475 fwrite(s
, 1, strlen(s
), f
);
2478 /* Dump a gmon.out histogram file. */
2479 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2482 FILE *f
=fopen(filename
, "w");
2485 fwrite("gmon", 1, 4, f
);
2486 writeLong(f
, 0x00000001); /* Version */
2487 writeLong(f
, 0); /* padding */
2488 writeLong(f
, 0); /* padding */
2489 writeLong(f
, 0); /* padding */
2491 fwrite("", 1, 1, f
); /* GMON_TAG_TIME_HIST */
2493 /* figure out bucket size */
2496 for (i
=0; i
<sampleNum
; i
++)
2508 int addressSpace
=(max
-min
+1);
2510 static int const maxBuckets
=256*1024; /* maximum buckets. */
2511 int length
=addressSpace
;
2512 if (length
> maxBuckets
)
2516 int *buckets
=malloc(sizeof(int)*length
);
2522 memset(buckets
, 0, sizeof(int)*length
);
2523 for (i
=0; i
<sampleNum
;i
++)
2525 u32 address
=samples
[i
];
2526 long long a
=address
-min
;
2527 long long b
=length
-1;
2528 long long c
=addressSpace
-1;
2529 int index
=(a
*b
)/c
; /* danger!!!! int32 overflows */
2533 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2534 writeLong(f
, min
); /* low_pc */
2535 writeLong(f
, max
); /* high_pc */
2536 writeLong(f
, length
); /* # of samples */
2537 writeLong(f
, 64000000); /* 64MHz */
2538 writeString(f
, "seconds");
2539 for (i
=0; i
<(15-strlen("seconds")); i
++)
2541 fwrite("", 1, 1, f
); /* padding */
2543 writeString(f
, "s");
2545 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2547 char *data
=malloc(2*length
);
2550 for (i
=0; i
<length
;i
++)
2559 data
[i
*2+1]=(val
>>8)&0xff;
2562 fwrite(data
, 1, length
*2, f
);
2572 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2573 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2575 target_t
*target
= get_current_target(cmd_ctx
);
2576 struct timeval timeout
, now
;
2578 gettimeofday(&timeout
, NULL
);
2581 return ERROR_COMMAND_SYNTAX_ERROR
;
2584 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2590 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2592 static const int maxSample
=10000;
2593 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2598 int retval
=ERROR_OK
;
2599 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2600 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2604 target_poll(target
);
2605 if (target
->state
== TARGET_HALTED
)
2607 u32 t
=*((u32
*)reg
->value
);
2608 samples
[numSamples
++]=t
;
2609 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2610 target_poll(target
);
2611 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2612 } else if (target
->state
== TARGET_RUNNING
)
2614 /* We want to quickly sample the PC. */
2615 if((retval
= target_halt(target
)) != ERROR_OK
)
2622 command_print(cmd_ctx
, "Target not halted or running");
2626 if (retval
!=ERROR_OK
)
2631 gettimeofday(&now
, NULL
);
2632 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2634 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2635 if((retval
= target_poll(target
)) != ERROR_OK
)
2640 if (target
->state
== TARGET_HALTED
)
2642 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2644 if((retval
= target_poll(target
)) != ERROR_OK
)
2649 writeGmon(samples
, numSamples
, args
[1]);
2650 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2659 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2662 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2665 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2669 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2670 valObjPtr
= Jim_NewIntObj(interp
, val
);
2671 if (!nameObjPtr
|| !valObjPtr
)
2677 Jim_IncrRefCount(nameObjPtr
);
2678 Jim_IncrRefCount(valObjPtr
);
2679 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2680 Jim_DecrRefCount(interp
, nameObjPtr
);
2681 Jim_DecrRefCount(interp
, valObjPtr
);
2683 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2687 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2689 command_context_t
*context
;
2692 context
= Jim_GetAssocData(interp
, "context");
2693 if (context
== NULL
)
2695 LOG_ERROR("mem2array: no command context");
2698 target
= get_current_target(context
);
2701 LOG_ERROR("mem2array: no current target");
2705 return target_mem2array(interp
, target
, argc
,argv
);
2708 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2716 const char *varname
;
2718 int i
, n
, e
, retval
;
2720 /* argv[1] = name of array to receive the data
2721 * argv[2] = desired width
2722 * argv[3] = memory address
2723 * argv[4] = count of times to read
2726 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2729 varname
= Jim_GetString(argv
[1], &len
);
2730 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2732 e
= Jim_GetLong(interp
, argv
[2], &l
);
2738 e
= Jim_GetLong(interp
, argv
[3], &l
);
2743 e
= Jim_GetLong(interp
, argv
[4], &l
);
2759 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2760 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2764 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2765 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2768 if ((addr
+ (len
* width
)) < addr
) {
2769 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2770 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2773 /* absurd transfer size? */
2775 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2776 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2781 ((width
== 2) && ((addr
& 1) == 0)) ||
2782 ((width
== 4) && ((addr
& 3) == 0))) {
2786 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2787 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2788 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2799 /* Slurp... in buffer size chunks */
2801 count
= len
; /* in objects.. */
2802 if (count
> (sizeof(buffer
)/width
)) {
2803 count
= (sizeof(buffer
)/width
);
2806 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2807 if (retval
!= ERROR_OK
) {
2809 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2810 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2811 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2815 v
= 0; /* shut up gcc */
2816 for (i
= 0 ;i
< count
;i
++, n
++) {
2819 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2822 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2825 v
= buffer
[i
] & 0x0ff;
2828 new_int_array_element(interp
, varname
, n
, v
);
2834 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2839 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2842 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2846 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2850 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2857 Jim_IncrRefCount(nameObjPtr
);
2858 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2859 Jim_DecrRefCount(interp
, nameObjPtr
);
2861 if (valObjPtr
== NULL
)
2864 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2865 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2870 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2872 command_context_t
*context
;
2875 context
= Jim_GetAssocData(interp
, "context");
2876 if (context
== NULL
){
2877 LOG_ERROR("array2mem: no command context");
2880 target
= get_current_target(context
);
2881 if (target
== NULL
){
2882 LOG_ERROR("array2mem: no current target");
2886 return target_array2mem( interp
,target
, argc
, argv
);
2889 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2897 const char *varname
;
2899 int i
, n
, e
, retval
;
2901 /* argv[1] = name of array to get the data
2902 * argv[2] = desired width
2903 * argv[3] = memory address
2904 * argv[4] = count to write
2907 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2910 varname
= Jim_GetString(argv
[1], &len
);
2911 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2913 e
= Jim_GetLong(interp
, argv
[2], &l
);
2919 e
= Jim_GetLong(interp
, argv
[3], &l
);
2924 e
= Jim_GetLong(interp
, argv
[4], &l
);
2940 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2941 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2945 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2946 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2949 if ((addr
+ (len
* width
)) < addr
) {
2950 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2951 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2954 /* absurd transfer size? */
2956 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2957 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2962 ((width
== 2) && ((addr
& 1) == 0)) ||
2963 ((width
== 4) && ((addr
& 3) == 0))) {
2967 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2968 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2969 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2980 /* Slurp... in buffer size chunks */
2982 count
= len
; /* in objects.. */
2983 if (count
> (sizeof(buffer
)/width
)) {
2984 count
= (sizeof(buffer
)/width
);
2987 v
= 0; /* shut up gcc */
2988 for (i
= 0 ;i
< count
;i
++, n
++) {
2989 get_int_array_element(interp
, varname
, n
, &v
);
2992 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
2995 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
2998 buffer
[i
] = v
& 0x0ff;
3004 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
3005 if (retval
!= ERROR_OK
) {
3007 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
3008 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3009 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: cannot read memory", NULL
);
3015 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3020 void target_all_handle_event( enum target_event e
)
3024 LOG_DEBUG( "**all*targets: event: %d, %s",
3026 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3028 target
= all_targets
;
3030 target_handle_event( target
, e
);
3031 target
= target
->next
;
3035 void target_handle_event( target_t
*target
, enum target_event e
)
3037 target_event_action_t
*teap
;
3040 teap
= target
->event_action
;
3044 if( teap
->event
== e
){
3046 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3047 target
->target_number
,
3051 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
,
3052 Jim_GetString( teap
->body
, NULL
) );
3053 if (Jim_EvalObj( interp
, teap
->body
)!=JIM_OK
)
3055 Jim_PrintErrorMessage(interp
);
3061 LOG_DEBUG( "event: %d %s - no action",
3063 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3067 enum target_cfg_param
{
3070 TCFG_WORK_AREA_VIRT
,
3071 TCFG_WORK_AREA_PHYS
,
3072 TCFG_WORK_AREA_SIZE
,
3073 TCFG_WORK_AREA_BACKUP
,
3076 TCFG_CHAIN_POSITION
,
3079 static Jim_Nvp nvp_config_opts
[] = {
3080 { .name
= "-type", .value
= TCFG_TYPE
},
3081 { .name
= "-event", .value
= TCFG_EVENT
},
3082 { .name
= "-work-area-virt", .value
= TCFG_WORK_AREA_VIRT
},
3083 { .name
= "-work-area-phys", .value
= TCFG_WORK_AREA_PHYS
},
3084 { .name
= "-work-area-size", .value
= TCFG_WORK_AREA_SIZE
},
3085 { .name
= "-work-area-backup", .value
= TCFG_WORK_AREA_BACKUP
},
3086 { .name
= "-endian" , .value
= TCFG_ENDIAN
},
3087 { .name
= "-variant", .value
= TCFG_VARIANT
},
3088 { .name
= "-chain-position", .value
= TCFG_CHAIN_POSITION
},
3090 { .name
= NULL
, .value
= -1 }
3093 static int target_configure( Jim_GetOptInfo
*goi
, target_t
*target
)
3101 /* parse config or cget options ... */
3102 while( goi
->argc
> 0 ){
3103 Jim_SetEmptyResult( goi
->interp
);
3104 /* Jim_GetOpt_Debug( goi ); */
3106 if( target
->type
->target_jim_configure
){
3107 /* target defines a configure function */
3108 /* target gets first dibs on parameters */
3109 e
= (*(target
->type
->target_jim_configure
))( target
, goi
);
3118 /* otherwise we 'continue' below */
3120 e
= Jim_GetOpt_Nvp( goi
, nvp_config_opts
, &n
);
3122 Jim_GetOpt_NvpUnknown( goi
, nvp_config_opts
, 0 );
3128 if( goi
->isconfigure
){
3129 Jim_SetResult_sprintf( goi
->interp
, "not setable: %s", n
->name
);
3133 if( goi
->argc
!= 0 ){
3134 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
3138 Jim_SetResultString( goi
->interp
, target
->type
->name
, -1 );
3142 if( goi
->argc
== 0 ){
3143 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ...");
3147 e
= Jim_GetOpt_Nvp( goi
, nvp_target_event
, &n
);
3149 Jim_GetOpt_NvpUnknown( goi
, nvp_target_event
, 1 );
3153 if( goi
->isconfigure
){
3154 if( goi
->argc
!= 1 ){
3155 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
3159 if( goi
->argc
!= 0 ){
3160 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
3166 target_event_action_t
*teap
;
3168 teap
= target
->event_action
;
3169 /* replace existing? */
3171 if( teap
->event
== n
->value
){
3177 if( goi
->isconfigure
){
3180 teap
= calloc( 1, sizeof(*teap
) );
3182 teap
->event
= n
->value
;
3183 Jim_GetOpt_Obj( goi
, &o
);
3185 Jim_DecrRefCount( interp
, teap
->body
);
3187 teap
->body
= Jim_DuplicateObj( goi
->interp
, o
);
3190 * Tcl/TK - "tk events" have a nice feature.
3191 * See the "BIND" command.
3192 * We should support that here.
3193 * You can specify %X and %Y in the event code.
3194 * The idea is: %T - target name.
3195 * The idea is: %N - target number
3196 * The idea is: %E - event name.
3198 Jim_IncrRefCount( teap
->body
);
3200 /* add to head of event list */
3201 teap
->next
= target
->event_action
;
3202 target
->event_action
= teap
;
3203 Jim_SetEmptyResult(goi
->interp
);
3207 Jim_SetEmptyResult( goi
->interp
);
3209 Jim_SetResult( goi
->interp
, Jim_DuplicateObj( goi
->interp
, teap
->body
) );
3216 case TCFG_WORK_AREA_VIRT
:
3217 if( goi
->isconfigure
){
3218 target_free_all_working_areas(target
);
3219 e
= Jim_GetOpt_Wide( goi
, &w
);
3223 target
->working_area_virt
= w
;
3225 if( goi
->argc
!= 0 ){
3229 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_virt
) );
3233 case TCFG_WORK_AREA_PHYS
:
3234 if( goi
->isconfigure
){
3235 target_free_all_working_areas(target
);
3236 e
= Jim_GetOpt_Wide( goi
, &w
);
3240 target
->working_area_phys
= w
;
3242 if( goi
->argc
!= 0 ){
3246 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_phys
) );
3250 case TCFG_WORK_AREA_SIZE
:
3251 if( goi
->isconfigure
){
3252 target_free_all_working_areas(target
);
3253 e
= Jim_GetOpt_Wide( goi
, &w
);
3257 target
->working_area_size
= w
;
3259 if( goi
->argc
!= 0 ){
3263 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3267 case TCFG_WORK_AREA_BACKUP
:
3268 if( goi
->isconfigure
){
3269 target_free_all_working_areas(target
);
3270 e
= Jim_GetOpt_Wide( goi
, &w
);
3274 /* make this exactly 1 or 0 */
3275 target
->backup_working_area
= (!!w
);
3277 if( goi
->argc
!= 0 ){
3281 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3282 /* loop for more e*/
3286 if( goi
->isconfigure
){
3287 e
= Jim_GetOpt_Nvp( goi
, nvp_target_endian
, &n
);
3289 Jim_GetOpt_NvpUnknown( goi
, nvp_target_endian
, 1 );
3292 target
->endianness
= n
->value
;
3294 if( goi
->argc
!= 0 ){
3298 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3299 if( n
->name
== NULL
){
3300 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3301 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3303 Jim_SetResultString( goi
->interp
, n
->name
, -1 );
3308 if( goi
->isconfigure
){
3309 if( goi
->argc
< 1 ){
3310 Jim_SetResult_sprintf( goi
->interp
,
3315 if( target
->variant
){
3316 free((void *)(target
->variant
));
3318 e
= Jim_GetOpt_String( goi
, &cp
, NULL
);
3319 target
->variant
= strdup(cp
);
3321 if( goi
->argc
!= 0 ){
3325 Jim_SetResultString( goi
->interp
, target
->variant
,-1 );
3328 case TCFG_CHAIN_POSITION
:
3329 if( goi
->isconfigure
){
3332 target_free_all_working_areas(target
);
3333 e
= Jim_GetOpt_Obj( goi
, &o
);
3337 tap
= jtag_TapByJimObj( goi
->interp
, o
);
3341 /* make this exactly 1 or 0 */
3344 if( goi
->argc
!= 0 ){
3348 Jim_SetResultString( interp
, target
->tap
->dotted_name
, -1 );
3349 /* loop for more e*/
3352 } /* while( goi->argc ) */
3355 /* done - we return */
3359 /** this is the 'tcl' handler for the target specific command */
3360 static int tcl_target_func( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3368 struct command_context_s
*cmd_ctx
;
3375 TS_CMD_MWW
, TS_CMD_MWH
, TS_CMD_MWB
,
3376 TS_CMD_MDW
, TS_CMD_MDH
, TS_CMD_MDB
,
3377 TS_CMD_MRW
, TS_CMD_MRH
, TS_CMD_MRB
,
3378 TS_CMD_MEM2ARRAY
, TS_CMD_ARRAY2MEM
,
3386 TS_CMD_INVOKE_EVENT
,
3389 static const Jim_Nvp target_options
[] = {
3390 { .name
= "configure", .value
= TS_CMD_CONFIGURE
},
3391 { .name
= "cget", .value
= TS_CMD_CGET
},
3392 { .name
= "mww", .value
= TS_CMD_MWW
},
3393 { .name
= "mwh", .value
= TS_CMD_MWH
},
3394 { .name
= "mwb", .value
= TS_CMD_MWB
},
3395 { .name
= "mdw", .value
= TS_CMD_MDW
},
3396 { .name
= "mdh", .value
= TS_CMD_MDH
},
3397 { .name
= "mdb", .value
= TS_CMD_MDB
},
3398 { .name
= "mem2array", .value
= TS_CMD_MEM2ARRAY
},
3399 { .name
= "array2mem", .value
= TS_CMD_ARRAY2MEM
},
3400 { .name
= "eventlist", .value
= TS_CMD_EVENTLIST
},
3401 { .name
= "curstate", .value
= TS_CMD_CURSTATE
},
3403 { .name
= "arp_examine", .value
= TS_CMD_EXAMINE
},
3404 { .name
= "arp_poll", .value
= TS_CMD_POLL
},
3405 { .name
= "arp_reset", .value
= TS_CMD_RESET
},
3406 { .name
= "arp_halt", .value
= TS_CMD_HALT
},
3407 { .name
= "arp_waitstate", .value
= TS_CMD_WAITSTATE
},
3408 { .name
= "invoke-event", .value
= TS_CMD_INVOKE_EVENT
},
3410 { .name
= NULL
, .value
= -1 },
3413 /* go past the "command" */
3414 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3416 target
= Jim_CmdPrivData( goi
.interp
);
3417 cmd_ctx
= Jim_GetAssocData(goi
.interp
, "context");
3419 /* commands here are in an NVP table */
3420 e
= Jim_GetOpt_Nvp( &goi
, target_options
, &n
);
3422 Jim_GetOpt_NvpUnknown( &goi
, target_options
, 0 );
3425 /* Assume blank result */
3426 Jim_SetEmptyResult( goi
.interp
);
3429 case TS_CMD_CONFIGURE
:
3431 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "missing: -option VALUE ...");
3434 goi
.isconfigure
= 1;
3435 return target_configure( &goi
, target
);
3437 // some things take params
3439 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "missing: ?-option?");
3442 goi
.isconfigure
= 0;
3443 return target_configure( &goi
, target
);
3451 * argv[3] = optional count.
3454 if( (goi
.argc
== 3) || (goi
.argc
== 4) ){
3458 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR DATA [COUNT]", n
->name
);
3462 e
= Jim_GetOpt_Wide( &goi
, &a
);
3467 e
= Jim_GetOpt_Wide( &goi
, &b
);
3472 e
= Jim_GetOpt_Wide( &goi
, &c
);
3482 target_buffer_set_u32( target
, target_buf
, b
);
3486 target_buffer_set_u16( target
, target_buf
, b
);
3490 target_buffer_set_u8( target
, target_buf
, b
);
3494 for( x
= 0 ; x
< c
; x
++ ){
3495 e
= target
->type
->write_memory( target
, a
, b
, 1, target_buf
);
3496 if( e
!= ERROR_OK
){
3497 Jim_SetResult_sprintf( interp
, "Error writing @ 0x%08x: %d\n", (int)(a
), e
);
3510 /* argv[0] = command
3512 * argv[2] = optional count
3514 if( (goi
.argc
== 2) || (goi
.argc
== 3) ){
3515 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR [COUNT]", n
->name
);
3518 e
= Jim_GetOpt_Wide( &goi
, &a
);
3523 e
= Jim_GetOpt_Wide( &goi
, &c
);
3530 b
= 1; /* shut up gcc */
3543 /* convert to "bytes" */
3545 /* count is now in 'BYTES' */
3551 e
= target
->type
->read_memory( target
, a
, b
, y
/ b
, target_buf
);
3552 if( e
!= ERROR_OK
){
3553 Jim_SetResult_sprintf( interp
, "error reading target @ 0x%08lx", (int)(a
) );
3557 Jim_fprintf( interp
, interp
->cookie_stdout
, "0x%08x ", (int)(a
) );
3560 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 4 ){
3561 z
= target_buffer_get_u32( target
, &(target_buf
[ x
* 4 ]) );
3562 Jim_fprintf( interp
, interp
->cookie_stdout
, "%08x ", (int)(z
) );
3564 for( ; (x
< 16) ; x
+= 4 ){
3565 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3569 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 2 ){
3570 z
= target_buffer_get_u16( target
, &(target_buf
[ x
* 2 ]) );
3571 Jim_fprintf( interp
, interp
->cookie_stdout
, "%04x ", (int)(z
) );
3573 for( ; (x
< 16) ; x
+= 2 ){
3574 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3579 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 1 ){
3580 z
= target_buffer_get_u8( target
, &(target_buf
[ x
* 4 ]) );
3581 Jim_fprintf( interp
, interp
->cookie_stdout
, "%02x ", (int)(z
) );
3583 for( ; (x
< 16) ; x
+= 1 ){
3584 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3588 /* ascii-ify the bytes */
3589 for( x
= 0 ; x
< y
; x
++ ){
3590 if( (target_buf
[x
] >= 0x20) &&
3591 (target_buf
[x
] <= 0x7e) ){
3595 target_buf
[x
] = '.';
3600 target_buf
[x
] = ' ';
3605 /* print - with a newline */
3606 Jim_fprintf( interp
, interp
->cookie_stdout
, "%s\n", target_buf
);
3612 case TS_CMD_MEM2ARRAY
:
3613 return target_mem2array( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3615 case TS_CMD_ARRAY2MEM
:
3616 return target_array2mem( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3618 case TS_CMD_EXAMINE
:
3620 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3623 e
= target
->type
->examine( target
);
3624 if( e
!= ERROR_OK
){
3625 Jim_SetResult_sprintf( interp
, "examine-fails: %d", e
);
3631 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3634 if( !(target
->type
->examined
) ){
3635 e
= ERROR_TARGET_NOT_EXAMINED
;
3637 e
= target
->type
->poll( target
);
3639 if( e
!= ERROR_OK
){
3640 Jim_SetResult_sprintf( interp
, "poll-fails: %d", e
);
3647 if( goi
.argc
!= 2 ){
3648 Jim_WrongNumArgs( interp
, 2, argv
, "t|f|assert|deassert BOOL");
3651 e
= Jim_GetOpt_Nvp( &goi
, nvp_assert
, &n
);
3653 Jim_GetOpt_NvpUnknown( &goi
, nvp_assert
, 1 );
3656 /* the halt or not param */
3657 e
= Jim_GetOpt_Wide( &goi
, &a
);
3661 /* determine if we should halt or not. */
3662 target
->reset_halt
= !!a
;
3663 /* When this happens - all workareas are invalid. */
3664 target_free_all_working_areas_restore(target
, 0);
3667 if( n
->value
== NVP_ASSERT
){
3668 target
->type
->assert_reset( target
);
3670 target
->type
->deassert_reset( target
);
3675 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "halt [no parameters]");
3678 target
->type
->halt( target
);
3680 case TS_CMD_WAITSTATE
:
3681 /* params: <name> statename timeoutmsecs */
3682 if( goi
.argc
!= 2 ){
3683 Jim_SetResult_sprintf( goi
.interp
, "%s STATENAME TIMEOUTMSECS", n
->name
);
3686 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_state
, &n
);
3688 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_state
,1 );
3691 e
= Jim_GetOpt_Wide( &goi
, &a
);
3695 e
= target_wait_state( target
, n
->value
, a
);
3696 if( e
!= ERROR_OK
){
3697 Jim_SetResult_sprintf( goi
.interp
,
3698 "target: %s wait %s fails (%d) %s",
3701 e
, target_strerror_safe(e
) );
3706 case TS_CMD_EVENTLIST
:
3707 /* List for human, Events defined for this target.
3708 * scripts/programs should use 'name cget -event NAME'
3711 target_event_action_t
*teap
;
3712 teap
= target
->event_action
;
3713 command_print( cmd_ctx
, "Event actions for target (%d) %s\n",
3714 target
->target_number
,
3716 command_print( cmd_ctx
, "%-25s | Body", "Event");
3717 command_print( cmd_ctx
, "------------------------- | ----------------------------------------");
3719 command_print( cmd_ctx
,
3721 Jim_Nvp_value2name_simple( nvp_target_event
, teap
->event
)->name
,
3722 Jim_GetString( teap
->body
, NULL
) );
3725 command_print( cmd_ctx
, "***END***");
3728 case TS_CMD_CURSTATE
:
3729 if( goi
.argc
!= 0 ){
3730 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "[no parameters]");
3733 Jim_SetResultString( goi
.interp
,
3734 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
,-1);
3736 case TS_CMD_INVOKE_EVENT
:
3737 if( goi
.argc
!= 1 ){
3738 Jim_SetResult_sprintf( goi
.interp
, "%s ?EVENTNAME?",n
->name
);
3741 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_event
, &n
);
3743 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_event
, 1 );
3746 target_handle_event( target
, n
->value
);
3752 static int target_create( Jim_GetOptInfo
*goi
)
3761 struct command_context_s
*cmd_ctx
;
3763 cmd_ctx
= Jim_GetAssocData(goi
->interp
, "context");
3764 if( goi
->argc
< 3 ){
3765 Jim_WrongNumArgs( goi
->interp
, 1, goi
->argv
, "?name? ?type? ..options...");
3770 Jim_GetOpt_Obj( goi
, &new_cmd
);
3771 /* does this command exist? */
3772 cmd
= Jim_GetCommand( goi
->interp
, new_cmd
, JIM_ERRMSG
);
3774 cp
= Jim_GetString( new_cmd
, NULL
);
3775 Jim_SetResult_sprintf(goi
->interp
, "Command/target: %s Exists", cp
);
3780 e
= Jim_GetOpt_String( goi
, &cp2
, NULL
);
3782 /* now does target type exist */
3783 for( x
= 0 ; target_types
[x
] ; x
++ ){
3784 if( 0 == strcmp( cp
, target_types
[x
]->name
) ){
3789 if( target_types
[x
] == NULL
){
3790 Jim_SetResult_sprintf( goi
->interp
, "Unknown target type %s, try one of ", cp
);
3791 for( x
= 0 ; target_types
[x
] ; x
++ ){
3792 if( target_types
[x
+1] ){
3793 Jim_AppendStrings( goi
->interp
,
3794 Jim_GetResult(goi
->interp
),
3795 target_types
[x
]->name
,
3798 Jim_AppendStrings( goi
->interp
,
3799 Jim_GetResult(goi
->interp
),
3801 target_types
[x
]->name
,NULL
);
3808 target
= calloc(1,sizeof(target_t
));
3809 /* set target number */
3810 target
->target_number
= new_target_number();
3812 /* allocate memory for each unique target type */
3813 target
->type
= (target_type_t
*)calloc(1,sizeof(target_type_t
));
3815 memcpy( target
->type
, target_types
[x
], sizeof(target_type_t
));
3817 /* will be set by "-endian" */
3818 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3820 target
->working_area
= 0x0;
3821 target
->working_area_size
= 0x0;
3822 target
->working_areas
= NULL
;
3823 target
->backup_working_area
= 0;
3825 target
->state
= TARGET_UNKNOWN
;
3826 target
->debug_reason
= DBG_REASON_UNDEFINED
;
3827 target
->reg_cache
= NULL
;
3828 target
->breakpoints
= NULL
;
3829 target
->watchpoints
= NULL
;
3830 target
->next
= NULL
;
3831 target
->arch_info
= NULL
;
3833 target
->display
= 1;
3835 /* initialize trace information */
3836 target
->trace_info
= malloc(sizeof(trace_t
));
3837 target
->trace_info
->num_trace_points
= 0;
3838 target
->trace_info
->trace_points_size
= 0;
3839 target
->trace_info
->trace_points
= NULL
;
3840 target
->trace_info
->trace_history_size
= 0;
3841 target
->trace_info
->trace_history
= NULL
;
3842 target
->trace_info
->trace_history_pos
= 0;
3843 target
->trace_info
->trace_history_overflowed
= 0;
3845 target
->dbgmsg
= NULL
;
3846 target
->dbg_msg_enabled
= 0;
3848 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3850 /* Do the rest as "configure" options */
3851 goi
->isconfigure
= 1;
3852 e
= target_configure( goi
, target
);
3854 if (target
->tap
== NULL
)
3856 Jim_SetResultString( interp
, "-chain-position required when creating target", -1);
3861 free( target
->type
);
3866 if( target
->endianness
== TARGET_ENDIAN_UNKNOWN
){
3867 /* default endian to little if not specified */
3868 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3871 /* incase variant is not set */
3872 if (!target
->variant
)
3873 target
->variant
= strdup("");
3875 /* create the target specific commands */
3876 if( target
->type
->register_commands
){
3877 (*(target
->type
->register_commands
))( cmd_ctx
);
3879 if( target
->type
->target_create
){
3880 (*(target
->type
->target_create
))( target
, goi
->interp
);
3883 /* append to end of list */
3886 tpp
= &(all_targets
);
3888 tpp
= &( (*tpp
)->next
);
3893 cp
= Jim_GetString( new_cmd
, NULL
);
3894 target
->cmd_name
= strdup(cp
);
3896 /* now - create the new target name command */
3897 e
= Jim_CreateCommand( goi
->interp
,
3900 tcl_target_func
, /* C function */
3901 target
, /* private data */
3902 NULL
); /* no del proc */
3907 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3911 struct command_context_s
*cmd_ctx
;
3915 /* TG = target generic */
3923 const char *target_cmds
[] = {
3924 "create", "types", "names", "current", "number",
3926 NULL
/* terminate */
3929 LOG_DEBUG("Target command params:");
3930 LOG_DEBUG(Jim_Debug_ArgvString( interp
, argc
, argv
) );
3932 cmd_ctx
= Jim_GetAssocData( interp
, "context" );
3934 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3936 if( goi
.argc
== 0 ){
3937 Jim_WrongNumArgs(interp
, 1, argv
, "missing: command ...");
3941 /* Jim_GetOpt_Debug( &goi ); */
3942 r
= Jim_GetOpt_Enum( &goi
, target_cmds
, &x
);
3949 Jim_Panic(goi
.interp
,"Why am I here?");
3951 case TG_CMD_CURRENT
:
3952 if( goi
.argc
!= 0 ){
3953 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters");
3956 Jim_SetResultString( goi
.interp
, get_current_target( cmd_ctx
)->cmd_name
, -1 );
3959 if( goi
.argc
!= 0 ){
3960 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
3963 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
3964 for( x
= 0 ; target_types
[x
] ; x
++ ){
3965 Jim_ListAppendElement( goi
.interp
,
3966 Jim_GetResult(goi
.interp
),
3967 Jim_NewStringObj( goi
.interp
, target_types
[x
]->name
, -1 ) );
3971 if( goi
.argc
!= 0 ){
3972 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
3975 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
3976 target
= all_targets
;
3978 Jim_ListAppendElement( goi
.interp
,
3979 Jim_GetResult(goi
.interp
),
3980 Jim_NewStringObj( goi
.interp
, target
->cmd_name
, -1 ) );
3981 target
= target
->next
;
3986 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "?name ... config options ...");
3989 return target_create( &goi
);
3992 if( goi
.argc
!= 1 ){
3993 Jim_SetResult_sprintf( goi
.interp
, "expected: target number ?NUMBER?");
3996 e
= Jim_GetOpt_Wide( &goi
, &w
);
4002 t
= get_target_by_num(w
);
4004 Jim_SetResult_sprintf( goi
.interp
,"Target: number %d does not exist", (int)(w
));
4007 Jim_SetResultString( goi
.interp
, t
->cmd_name
, -1 );
4011 if( goi
.argc
!= 0 ){
4012 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "<no parameters>");
4015 Jim_SetResult( goi
.interp
,
4016 Jim_NewIntObj( goi
.interp
, max_target_number()));
4032 static int fastload_num
;
4033 static struct FastLoad
*fastload
;
4035 static void free_fastload(void)
4040 for (i
=0; i
<fastload_num
; i
++)
4042 if (fastload
[i
].data
)
4043 free(fastload
[i
].data
);
4053 int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4059 u32 max_address
=0xffffffff;
4065 duration_t duration
;
4066 char *duration_text
;
4068 if ((argc
< 1)||(argc
> 5))
4070 return ERROR_COMMAND_SYNTAX_ERROR
;
4073 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
4076 image
.base_address_set
= 1;
4077 image
.base_address
= strtoul(args
[1], NULL
, 0);
4081 image
.base_address_set
= 0;
4085 image
.start_address_set
= 0;
4089 min_address
=strtoul(args
[3], NULL
, 0);
4093 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
4096 if (min_address
>max_address
)
4098 return ERROR_COMMAND_SYNTAX_ERROR
;
4101 duration_start_measure(&duration
);
4103 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
4110 fastload_num
=image
.num_sections
;
4111 fastload
=(struct FastLoad
*)malloc(sizeof(struct FastLoad
)*image
.num_sections
);
4114 image_close(&image
);
4117 memset(fastload
, 0, sizeof(struct FastLoad
)*image
.num_sections
);
4118 for (i
= 0; i
< image
.num_sections
; i
++)
4120 buffer
= malloc(image
.sections
[i
].size
);
4123 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
4127 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
4137 /* DANGER!!! beware of unsigned comparision here!!! */
4139 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
4140 (image
.sections
[i
].base_address
<max_address
))
4142 if (image
.sections
[i
].base_address
<min_address
)
4144 /* clip addresses below */
4145 offset
+=min_address
-image
.sections
[i
].base_address
;
4149 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
4151 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
4154 fastload
[i
].address
=image
.sections
[i
].base_address
+offset
;
4155 fastload
[i
].data
=malloc(length
);
4156 if (fastload
[i
].data
==NULL
)
4161 memcpy(fastload
[i
].data
, buffer
+offset
, length
);
4162 fastload
[i
].length
=length
;
4164 image_size
+= length
;
4165 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
4171 duration_stop_measure(&duration
, &duration_text
);
4172 if (retval
==ERROR_OK
)
4174 command_print(cmd_ctx
, "Loaded %u bytes in %s", image_size
, duration_text
);
4175 command_print(cmd_ctx
, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4177 free(duration_text
);
4179 image_close(&image
);
4181 if (retval
!=ERROR_OK
)
4189 int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4192 return ERROR_COMMAND_SYNTAX_ERROR
;
4195 LOG_ERROR("No image in memory");
4199 int ms
=timeval_ms();
4201 for (i
=0; i
<fastload_num
;i
++)
4204 target_t
*target
= get_current_target(cmd_ctx
);
4205 if ((retval
= target_write_buffer(target
, fastload
[i
].address
, fastload
[i
].length
, fastload
[i
].data
)) != ERROR_OK
)
4209 size
+=fastload
[i
].length
;
4211 int after
=timeval_ms();
4212 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)