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 ) */
3344 /* done - we return */
3348 /** this is the 'tcl' handler for the target specific command */
3349 static int tcl_target_func( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3357 struct command_context_s
*cmd_ctx
;
3364 TS_CMD_MWW
, TS_CMD_MWH
, TS_CMD_MWB
,
3365 TS_CMD_MDW
, TS_CMD_MDH
, TS_CMD_MDB
,
3366 TS_CMD_MRW
, TS_CMD_MRH
, TS_CMD_MRB
,
3367 TS_CMD_MEM2ARRAY
, TS_CMD_ARRAY2MEM
,
3375 TS_CMD_INVOKE_EVENT
,
3378 static const Jim_Nvp target_options
[] = {
3379 { .name
= "configure", .value
= TS_CMD_CONFIGURE
},
3380 { .name
= "cget", .value
= TS_CMD_CGET
},
3381 { .name
= "mww", .value
= TS_CMD_MWW
},
3382 { .name
= "mwh", .value
= TS_CMD_MWH
},
3383 { .name
= "mwb", .value
= TS_CMD_MWB
},
3384 { .name
= "mdw", .value
= TS_CMD_MDW
},
3385 { .name
= "mdh", .value
= TS_CMD_MDH
},
3386 { .name
= "mdb", .value
= TS_CMD_MDB
},
3387 { .name
= "mem2array", .value
= TS_CMD_MEM2ARRAY
},
3388 { .name
= "array2mem", .value
= TS_CMD_ARRAY2MEM
},
3389 { .name
= "eventlist", .value
= TS_CMD_EVENTLIST
},
3390 { .name
= "curstate", .value
= TS_CMD_CURSTATE
},
3392 { .name
= "arp_examine", .value
= TS_CMD_EXAMINE
},
3393 { .name
= "arp_poll", .value
= TS_CMD_POLL
},
3394 { .name
= "arp_reset", .value
= TS_CMD_RESET
},
3395 { .name
= "arp_halt", .value
= TS_CMD_HALT
},
3396 { .name
= "arp_waitstate", .value
= TS_CMD_WAITSTATE
},
3397 { .name
= "invoke-event", .value
= TS_CMD_INVOKE_EVENT
},
3399 { .name
= NULL
, .value
= -1 },
3402 /* go past the "command" */
3403 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3405 target
= Jim_CmdPrivData( goi
.interp
);
3406 cmd_ctx
= Jim_GetAssocData(goi
.interp
, "context");
3408 /* commands here are in an NVP table */
3409 e
= Jim_GetOpt_Nvp( &goi
, target_options
, &n
);
3411 Jim_GetOpt_NvpUnknown( &goi
, target_options
, 0 );
3414 /* Assume blank result */
3415 Jim_SetEmptyResult( goi
.interp
);
3418 case TS_CMD_CONFIGURE
:
3420 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "missing: -option VALUE ...");
3423 goi
.isconfigure
= 1;
3424 return target_configure( &goi
, target
);
3426 // some things take params
3428 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "missing: ?-option?");
3431 goi
.isconfigure
= 0;
3432 return target_configure( &goi
, target
);
3440 * argv[3] = optional count.
3443 if( (goi
.argc
== 3) || (goi
.argc
== 4) ){
3447 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR DATA [COUNT]", n
->name
);
3451 e
= Jim_GetOpt_Wide( &goi
, &a
);
3456 e
= Jim_GetOpt_Wide( &goi
, &b
);
3461 e
= Jim_GetOpt_Wide( &goi
, &c
);
3471 target_buffer_set_u32( target
, target_buf
, b
);
3475 target_buffer_set_u16( target
, target_buf
, b
);
3479 target_buffer_set_u8( target
, target_buf
, b
);
3483 for( x
= 0 ; x
< c
; x
++ ){
3484 e
= target
->type
->write_memory( target
, a
, b
, 1, target_buf
);
3485 if( e
!= ERROR_OK
){
3486 Jim_SetResult_sprintf( interp
, "Error writing @ 0x%08x: %d\n", (int)(a
), e
);
3499 /* argv[0] = command
3501 * argv[2] = optional count
3503 if( (goi
.argc
== 2) || (goi
.argc
== 3) ){
3504 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR [COUNT]", n
->name
);
3507 e
= Jim_GetOpt_Wide( &goi
, &a
);
3512 e
= Jim_GetOpt_Wide( &goi
, &c
);
3519 b
= 1; /* shut up gcc */
3532 /* convert to "bytes" */
3534 /* count is now in 'BYTES' */
3540 e
= target
->type
->read_memory( target
, a
, b
, y
/ b
, target_buf
);
3541 if( e
!= ERROR_OK
){
3542 Jim_SetResult_sprintf( interp
, "error reading target @ 0x%08lx", (int)(a
) );
3546 Jim_fprintf( interp
, interp
->cookie_stdout
, "0x%08x ", (int)(a
) );
3549 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 4 ){
3550 z
= target_buffer_get_u32( target
, &(target_buf
[ x
* 4 ]) );
3551 Jim_fprintf( interp
, interp
->cookie_stdout
, "%08x ", (int)(z
) );
3553 for( ; (x
< 16) ; x
+= 4 ){
3554 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3558 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 2 ){
3559 z
= target_buffer_get_u16( target
, &(target_buf
[ x
* 2 ]) );
3560 Jim_fprintf( interp
, interp
->cookie_stdout
, "%04x ", (int)(z
) );
3562 for( ; (x
< 16) ; x
+= 2 ){
3563 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3568 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 1 ){
3569 z
= target_buffer_get_u8( target
, &(target_buf
[ x
* 4 ]) );
3570 Jim_fprintf( interp
, interp
->cookie_stdout
, "%02x ", (int)(z
) );
3572 for( ; (x
< 16) ; x
+= 1 ){
3573 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3577 /* ascii-ify the bytes */
3578 for( x
= 0 ; x
< y
; x
++ ){
3579 if( (target_buf
[x
] >= 0x20) &&
3580 (target_buf
[x
] <= 0x7e) ){
3584 target_buf
[x
] = '.';
3589 target_buf
[x
] = ' ';
3594 /* print - with a newline */
3595 Jim_fprintf( interp
, interp
->cookie_stdout
, "%s\n", target_buf
);
3601 case TS_CMD_MEM2ARRAY
:
3602 return target_mem2array( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3604 case TS_CMD_ARRAY2MEM
:
3605 return target_array2mem( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3607 case TS_CMD_EXAMINE
:
3609 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3612 e
= target
->type
->examine( target
);
3613 if( e
!= ERROR_OK
){
3614 Jim_SetResult_sprintf( interp
, "examine-fails: %d", e
);
3620 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3623 if( !(target
->type
->examined
) ){
3624 e
= ERROR_TARGET_NOT_EXAMINED
;
3626 e
= target
->type
->poll( target
);
3628 if( e
!= ERROR_OK
){
3629 Jim_SetResult_sprintf( interp
, "poll-fails: %d", e
);
3636 if( goi
.argc
!= 2 ){
3637 Jim_WrongNumArgs( interp
, 2, argv
, "t|f|assert|deassert BOOL");
3640 e
= Jim_GetOpt_Nvp( &goi
, nvp_assert
, &n
);
3642 Jim_GetOpt_NvpUnknown( &goi
, nvp_assert
, 1 );
3645 /* the halt or not param */
3646 e
= Jim_GetOpt_Wide( &goi
, &a
);
3650 /* determine if we should halt or not. */
3651 target
->reset_halt
= !!a
;
3652 /* When this happens - all workareas are invalid. */
3653 target_free_all_working_areas_restore(target
, 0);
3656 if( n
->value
== NVP_ASSERT
){
3657 target
->type
->assert_reset( target
);
3659 target
->type
->deassert_reset( target
);
3664 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "halt [no parameters]");
3667 target
->type
->halt( target
);
3669 case TS_CMD_WAITSTATE
:
3670 /* params: <name> statename timeoutmsecs */
3671 if( goi
.argc
!= 2 ){
3672 Jim_SetResult_sprintf( goi
.interp
, "%s STATENAME TIMEOUTMSECS", n
->name
);
3675 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_state
, &n
);
3677 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_state
,1 );
3680 e
= Jim_GetOpt_Wide( &goi
, &a
);
3684 e
= target_wait_state( target
, n
->value
, a
);
3685 if( e
!= ERROR_OK
){
3686 Jim_SetResult_sprintf( goi
.interp
,
3687 "target: %s wait %s fails (%d) %s",
3690 e
, target_strerror_safe(e
) );
3695 case TS_CMD_EVENTLIST
:
3696 /* List for human, Events defined for this target.
3697 * scripts/programs should use 'name cget -event NAME'
3700 target_event_action_t
*teap
;
3701 teap
= target
->event_action
;
3702 command_print( cmd_ctx
, "Event actions for target (%d) %s\n",
3703 target
->target_number
,
3705 command_print( cmd_ctx
, "%-25s | Body", "Event");
3706 command_print( cmd_ctx
, "------------------------- | ----------------------------------------");
3708 command_print( cmd_ctx
,
3710 Jim_Nvp_value2name_simple( nvp_target_event
, teap
->event
)->name
,
3711 Jim_GetString( teap
->body
, NULL
) );
3714 command_print( cmd_ctx
, "***END***");
3717 case TS_CMD_CURSTATE
:
3718 if( goi
.argc
!= 0 ){
3719 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "[no parameters]");
3722 Jim_SetResultString( goi
.interp
,
3723 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
,-1);
3725 case TS_CMD_INVOKE_EVENT
:
3726 if( goi
.argc
!= 1 ){
3727 Jim_SetResult_sprintf( goi
.interp
, "%s ?EVENTNAME?",n
->name
);
3730 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_event
, &n
);
3732 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_event
, 1 );
3735 target_handle_event( target
, n
->value
);
3741 static int target_create( Jim_GetOptInfo
*goi
)
3750 struct command_context_s
*cmd_ctx
;
3752 cmd_ctx
= Jim_GetAssocData(goi
->interp
, "context");
3753 if( goi
->argc
< 3 ){
3754 Jim_WrongNumArgs( goi
->interp
, 1, goi
->argv
, "?name? ?type? ..options...");
3759 Jim_GetOpt_Obj( goi
, &new_cmd
);
3760 /* does this command exist? */
3761 cmd
= Jim_GetCommand( goi
->interp
, new_cmd
, JIM_ERRMSG
);
3763 cp
= Jim_GetString( new_cmd
, NULL
);
3764 Jim_SetResult_sprintf(goi
->interp
, "Command/target: %s Exists", cp
);
3769 e
= Jim_GetOpt_String( goi
, &cp2
, NULL
);
3771 /* now does target type exist */
3772 for( x
= 0 ; target_types
[x
] ; x
++ ){
3773 if( 0 == strcmp( cp
, target_types
[x
]->name
) ){
3778 if( target_types
[x
] == NULL
){
3779 Jim_SetResult_sprintf( goi
->interp
, "Unknown target type %s, try one of ", cp
);
3780 for( x
= 0 ; target_types
[x
] ; x
++ ){
3781 if( target_types
[x
+1] ){
3782 Jim_AppendStrings( goi
->interp
,
3783 Jim_GetResult(goi
->interp
),
3784 target_types
[x
]->name
,
3787 Jim_AppendStrings( goi
->interp
,
3788 Jim_GetResult(goi
->interp
),
3790 target_types
[x
]->name
,NULL
);
3797 target
= calloc(1,sizeof(target_t
));
3798 /* set target number */
3799 target
->target_number
= new_target_number();
3801 /* allocate memory for each unique target type */
3802 target
->type
= (target_type_t
*)calloc(1,sizeof(target_type_t
));
3804 memcpy( target
->type
, target_types
[x
], sizeof(target_type_t
));
3806 /* will be set by "-endian" */
3807 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3809 target
->working_area
= 0x0;
3810 target
->working_area_size
= 0x0;
3811 target
->working_areas
= NULL
;
3812 target
->backup_working_area
= 0;
3814 target
->state
= TARGET_UNKNOWN
;
3815 target
->debug_reason
= DBG_REASON_UNDEFINED
;
3816 target
->reg_cache
= NULL
;
3817 target
->breakpoints
= NULL
;
3818 target
->watchpoints
= NULL
;
3819 target
->next
= NULL
;
3820 target
->arch_info
= NULL
;
3822 target
->display
= 1;
3824 /* initialize trace information */
3825 target
->trace_info
= malloc(sizeof(trace_t
));
3826 target
->trace_info
->num_trace_points
= 0;
3827 target
->trace_info
->trace_points_size
= 0;
3828 target
->trace_info
->trace_points
= NULL
;
3829 target
->trace_info
->trace_history_size
= 0;
3830 target
->trace_info
->trace_history
= NULL
;
3831 target
->trace_info
->trace_history_pos
= 0;
3832 target
->trace_info
->trace_history_overflowed
= 0;
3834 target
->dbgmsg
= NULL
;
3835 target
->dbg_msg_enabled
= 0;
3837 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3839 /* Do the rest as "configure" options */
3840 goi
->isconfigure
= 1;
3841 e
= target_configure( goi
, target
);
3843 free( target
->type
);
3848 if( target
->endianness
== TARGET_ENDIAN_UNKNOWN
){
3849 /* default endian to little if not specified */
3850 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3853 /* incase variant is not set */
3854 if (!target
->variant
)
3855 target
->variant
= strdup("");
3857 /* create the target specific commands */
3858 if( target
->type
->register_commands
){
3859 (*(target
->type
->register_commands
))( cmd_ctx
);
3861 if( target
->type
->target_create
){
3862 (*(target
->type
->target_create
))( target
, goi
->interp
);
3865 /* append to end of list */
3868 tpp
= &(all_targets
);
3870 tpp
= &( (*tpp
)->next
);
3875 cp
= Jim_GetString( new_cmd
, NULL
);
3876 target
->cmd_name
= strdup(cp
);
3878 /* now - create the new target name command */
3879 e
= Jim_CreateCommand( goi
->interp
,
3882 tcl_target_func
, /* C function */
3883 target
, /* private data */
3884 NULL
); /* no del proc */
3889 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3893 struct command_context_s
*cmd_ctx
;
3897 /* TG = target generic */
3905 const char *target_cmds
[] = {
3906 "create", "types", "names", "current", "number",
3908 NULL
/* terminate */
3911 LOG_DEBUG("Target command params:");
3912 LOG_DEBUG(Jim_Debug_ArgvString( interp
, argc
, argv
) );
3914 cmd_ctx
= Jim_GetAssocData( interp
, "context" );
3916 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3918 if( goi
.argc
== 0 ){
3919 Jim_WrongNumArgs(interp
, 1, argv
, "missing: command ...");
3923 /* Jim_GetOpt_Debug( &goi ); */
3924 r
= Jim_GetOpt_Enum( &goi
, target_cmds
, &x
);
3931 Jim_Panic(goi
.interp
,"Why am I here?");
3933 case TG_CMD_CURRENT
:
3934 if( goi
.argc
!= 0 ){
3935 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters");
3938 Jim_SetResultString( goi
.interp
, get_current_target( cmd_ctx
)->cmd_name
, -1 );
3941 if( goi
.argc
!= 0 ){
3942 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
3945 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
3946 for( x
= 0 ; target_types
[x
] ; x
++ ){
3947 Jim_ListAppendElement( goi
.interp
,
3948 Jim_GetResult(goi
.interp
),
3949 Jim_NewStringObj( goi
.interp
, target_types
[x
]->name
, -1 ) );
3953 if( goi
.argc
!= 0 ){
3954 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
3957 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
3958 target
= all_targets
;
3960 Jim_ListAppendElement( goi
.interp
,
3961 Jim_GetResult(goi
.interp
),
3962 Jim_NewStringObj( goi
.interp
, target
->cmd_name
, -1 ) );
3963 target
= target
->next
;
3968 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "?name ... config options ...");
3971 return target_create( &goi
);
3974 if( goi
.argc
!= 1 ){
3975 Jim_SetResult_sprintf( goi
.interp
, "expected: target number ?NUMBER?");
3978 e
= Jim_GetOpt_Wide( &goi
, &w
);
3984 t
= get_target_by_num(w
);
3986 Jim_SetResult_sprintf( goi
.interp
,"Target: number %d does not exist", (int)(w
));
3989 Jim_SetResultString( goi
.interp
, t
->cmd_name
, -1 );
3993 if( goi
.argc
!= 0 ){
3994 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "<no parameters>");
3997 Jim_SetResult( goi
.interp
,
3998 Jim_NewIntObj( goi
.interp
, max_target_number()));
4014 static int fastload_num
;
4015 static struct FastLoad
*fastload
;
4017 static void free_fastload(void)
4022 for (i
=0; i
<fastload_num
; i
++)
4024 if (fastload
[i
].data
)
4025 free(fastload
[i
].data
);
4035 int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4041 u32 max_address
=0xffffffff;
4047 duration_t duration
;
4048 char *duration_text
;
4050 if ((argc
< 1)||(argc
> 5))
4052 return ERROR_COMMAND_SYNTAX_ERROR
;
4055 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
4058 image
.base_address_set
= 1;
4059 image
.base_address
= strtoul(args
[1], NULL
, 0);
4063 image
.base_address_set
= 0;
4067 image
.start_address_set
= 0;
4071 min_address
=strtoul(args
[3], NULL
, 0);
4075 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
4078 if (min_address
>max_address
)
4080 return ERROR_COMMAND_SYNTAX_ERROR
;
4083 duration_start_measure(&duration
);
4085 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
4092 fastload_num
=image
.num_sections
;
4093 fastload
=(struct FastLoad
*)malloc(sizeof(struct FastLoad
)*image
.num_sections
);
4096 image_close(&image
);
4099 memset(fastload
, 0, sizeof(struct FastLoad
)*image
.num_sections
);
4100 for (i
= 0; i
< image
.num_sections
; i
++)
4102 buffer
= malloc(image
.sections
[i
].size
);
4105 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
4109 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
4119 /* DANGER!!! beware of unsigned comparision here!!! */
4121 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
4122 (image
.sections
[i
].base_address
<max_address
))
4124 if (image
.sections
[i
].base_address
<min_address
)
4126 /* clip addresses below */
4127 offset
+=min_address
-image
.sections
[i
].base_address
;
4131 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
4133 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
4136 fastload
[i
].address
=image
.sections
[i
].base_address
+offset
;
4137 fastload
[i
].data
=malloc(length
);
4138 if (fastload
[i
].data
==NULL
)
4143 memcpy(fastload
[i
].data
, buffer
+offset
, length
);
4144 fastload
[i
].length
=length
;
4146 image_size
+= length
;
4147 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
4153 duration_stop_measure(&duration
, &duration_text
);
4154 if (retval
==ERROR_OK
)
4156 command_print(cmd_ctx
, "Loaded %u bytes in %s", image_size
, duration_text
);
4157 command_print(cmd_ctx
, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4159 free(duration_text
);
4161 image_close(&image
);
4163 if (retval
!=ERROR_OK
)
4171 int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4174 return ERROR_COMMAND_SYNTAX_ERROR
;
4177 LOG_ERROR("No image in memory");
4181 int ms
=timeval_ms();
4183 for (i
=0; i
<fastload_num
;i
++)
4186 target_t
*target
= get_current_target(cmd_ctx
);
4187 if ((retval
= target_write_buffer(target
, fastload
[i
].address
, fastload
[i
].length
, fastload
[i
].data
)) != ERROR_OK
)
4191 size
+=fastload
[i
].length
;
4193 int after
=timeval_ms();
4194 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)