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 static int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 static int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 static int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 static int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 static int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 static int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 static int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 static int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 static int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 static int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 static int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 static int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 static int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 static int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 static int handle_test_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 static int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 static int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
80 static int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
81 static int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 static int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
83 static int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
84 static int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
85 static int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
87 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
88 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
89 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
91 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
92 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
95 extern target_type_t arm7tdmi_target
;
96 extern target_type_t arm720t_target
;
97 extern target_type_t arm9tdmi_target
;
98 extern target_type_t arm920t_target
;
99 extern target_type_t arm966e_target
;
100 extern target_type_t arm926ejs_target
;
101 extern target_type_t feroceon_target
;
102 extern target_type_t xscale_target
;
103 extern target_type_t cortexm3_target
;
104 extern target_type_t cortexa8_target
;
105 extern target_type_t arm11_target
;
106 extern target_type_t mips_m4k_target
;
107 extern target_type_t avr_target
;
109 target_type_t
*target_types
[] =
127 target_t
*all_targets
= NULL
;
128 target_event_callback_t
*target_event_callbacks
= NULL
;
129 target_timer_callback_t
*target_timer_callbacks
= NULL
;
131 const Jim_Nvp nvp_assert
[] = {
132 { .name
= "assert", NVP_ASSERT
},
133 { .name
= "deassert", NVP_DEASSERT
},
134 { .name
= "T", NVP_ASSERT
},
135 { .name
= "F", NVP_DEASSERT
},
136 { .name
= "t", NVP_ASSERT
},
137 { .name
= "f", NVP_DEASSERT
},
138 { .name
= NULL
, .value
= -1 }
141 const Jim_Nvp nvp_error_target
[] = {
142 { .value
= ERROR_TARGET_INVALID
, .name
= "err-invalid" },
143 { .value
= ERROR_TARGET_INIT_FAILED
, .name
= "err-init-failed" },
144 { .value
= ERROR_TARGET_TIMEOUT
, .name
= "err-timeout" },
145 { .value
= ERROR_TARGET_NOT_HALTED
, .name
= "err-not-halted" },
146 { .value
= ERROR_TARGET_FAILURE
, .name
= "err-failure" },
147 { .value
= ERROR_TARGET_UNALIGNED_ACCESS
, .name
= "err-unaligned-access" },
148 { .value
= ERROR_TARGET_DATA_ABORT
, .name
= "err-data-abort" },
149 { .value
= ERROR_TARGET_RESOURCE_NOT_AVAILABLE
, .name
= "err-resource-not-available" },
150 { .value
= ERROR_TARGET_TRANSLATION_FAULT
, .name
= "err-translation-fault" },
151 { .value
= ERROR_TARGET_NOT_RUNNING
, .name
= "err-not-running" },
152 { .value
= ERROR_TARGET_NOT_EXAMINED
, .name
= "err-not-examined" },
153 { .value
= -1, .name
= NULL
}
156 const char *target_strerror_safe( int err
)
160 n
= Jim_Nvp_value2name_simple( nvp_error_target
, err
);
161 if( n
->name
== NULL
){
168 const Jim_Nvp nvp_target_event
[] = {
169 { .value
= TARGET_EVENT_OLD_gdb_program_config
, .name
= "old-gdb_program_config" },
170 { .value
= TARGET_EVENT_OLD_pre_resume
, .name
= "old-pre_resume" },
172 { .value
= TARGET_EVENT_EARLY_HALTED
, .name
= "early-halted" },
173 { .value
= TARGET_EVENT_HALTED
, .name
= "halted" },
174 { .value
= TARGET_EVENT_RESUMED
, .name
= "resumed" },
175 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
176 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
178 { .name
= "gdb-start", .value
= TARGET_EVENT_GDB_START
},
179 { .name
= "gdb-end", .value
= TARGET_EVENT_GDB_END
},
181 /* historical name */
183 { .value
= TARGET_EVENT_RESET_START
, .name
= "reset-start" },
185 { .value
= TARGET_EVENT_RESET_ASSERT_PRE
, .name
= "reset-assert-pre" },
186 { .value
= TARGET_EVENT_RESET_ASSERT_POST
, .name
= "reset-assert-post" },
187 { .value
= TARGET_EVENT_RESET_DEASSERT_PRE
, .name
= "reset-deassert-pre" },
188 { .value
= TARGET_EVENT_RESET_DEASSERT_POST
, .name
= "reset-deassert-post" },
189 { .value
= TARGET_EVENT_RESET_HALT_PRE
, .name
= "reset-halt-pre" },
190 { .value
= TARGET_EVENT_RESET_HALT_POST
, .name
= "reset-halt-post" },
191 { .value
= TARGET_EVENT_RESET_WAIT_PRE
, .name
= "reset-wait-pre" },
192 { .value
= TARGET_EVENT_RESET_WAIT_POST
, .name
= "reset-wait-post" },
193 { .value
= TARGET_EVENT_RESET_INIT
, .name
= "reset-init" },
194 { .value
= TARGET_EVENT_RESET_END
, .name
= "reset-end" },
196 { .value
= TARGET_EVENT_EXAMINE_START
, .name
= "examine-start" },
197 { .value
= TARGET_EVENT_EXAMINE_END
, .name
= "examine-end" },
199 { .value
= TARGET_EVENT_DEBUG_HALTED
, .name
= "debug-halted" },
200 { .value
= TARGET_EVENT_DEBUG_RESUMED
, .name
= "debug-resumed" },
202 { .value
= TARGET_EVENT_GDB_ATTACH
, .name
= "gdb-attach" },
203 { .value
= TARGET_EVENT_GDB_DETACH
, .name
= "gdb-detach" },
205 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_START
, .name
= "gdb-flash-write-start" },
206 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_END
, .name
= "gdb-flash-write-end" },
208 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_START
, .name
= "gdb-flash-erase-start" },
209 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_END
, .name
= "gdb-flash-erase-end" },
211 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
212 { .value
= TARGET_EVENT_RESUMED
, .name
= "resume-ok" },
213 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
215 { .name
= NULL
, .value
= -1 }
218 const Jim_Nvp nvp_target_state
[] = {
219 { .name
= "unknown", .value
= TARGET_UNKNOWN
},
220 { .name
= "running", .value
= TARGET_RUNNING
},
221 { .name
= "halted", .value
= TARGET_HALTED
},
222 { .name
= "reset", .value
= TARGET_RESET
},
223 { .name
= "debug-running", .value
= TARGET_DEBUG_RUNNING
},
224 { .name
= NULL
, .value
= -1 },
227 const Jim_Nvp nvp_target_debug_reason
[] = {
228 { .name
= "debug-request" , .value
= DBG_REASON_DBGRQ
},
229 { .name
= "breakpoint" , .value
= DBG_REASON_BREAKPOINT
},
230 { .name
= "watchpoint" , .value
= DBG_REASON_WATCHPOINT
},
231 { .name
= "watchpoint-and-breakpoint", .value
= DBG_REASON_WPTANDBKPT
},
232 { .name
= "single-step" , .value
= DBG_REASON_SINGLESTEP
},
233 { .name
= "target-not-halted" , .value
= DBG_REASON_NOTHALTED
},
234 { .name
= "undefined" , .value
= DBG_REASON_UNDEFINED
},
235 { .name
= NULL
, .value
= -1 },
238 const Jim_Nvp nvp_target_endian
[] = {
239 { .name
= "big", .value
= TARGET_BIG_ENDIAN
},
240 { .name
= "little", .value
= TARGET_LITTLE_ENDIAN
},
241 { .name
= "be", .value
= TARGET_BIG_ENDIAN
},
242 { .name
= "le", .value
= TARGET_LITTLE_ENDIAN
},
243 { .name
= NULL
, .value
= -1 },
246 const Jim_Nvp nvp_reset_modes
[] = {
247 { .name
= "unknown", .value
= RESET_UNKNOWN
},
248 { .name
= "run" , .value
= RESET_RUN
},
249 { .name
= "halt" , .value
= RESET_HALT
},
250 { .name
= "init" , .value
= RESET_INIT
},
251 { .name
= NULL
, .value
= -1 },
254 static int max_target_number(void)
262 if( x
< t
->target_number
){
263 x
= (t
->target_number
)+1;
270 /* determine the number of the new target */
271 static int new_target_number(void)
276 /* number is 0 based */
280 if( x
< t
->target_number
){
281 x
= t
->target_number
;
288 static int target_continous_poll
= 1;
290 /* read a u32 from a buffer in target memory endianness */
291 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
293 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
294 return le_to_h_u32(buffer
);
296 return be_to_h_u32(buffer
);
299 /* read a u16 from a buffer in target memory endianness */
300 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
302 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
303 return le_to_h_u16(buffer
);
305 return be_to_h_u16(buffer
);
308 /* read a u8 from a buffer in target memory endianness */
309 u8
target_buffer_get_u8(target_t
*target
, u8
*buffer
)
311 return *buffer
& 0x0ff;
314 /* write a u32 to a buffer in target memory endianness */
315 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
317 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
318 h_u32_to_le(buffer
, value
);
320 h_u32_to_be(buffer
, value
);
323 /* write a u16 to a buffer in target memory endianness */
324 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
326 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
327 h_u16_to_le(buffer
, value
);
329 h_u16_to_be(buffer
, value
);
332 /* write a u8 to a buffer in target memory endianness */
333 void target_buffer_set_u8(target_t
*target
, u8
*buffer
, u8 value
)
338 /* returns a pointer to the n-th configured target */
339 target_t
* get_target_by_num(int num
)
341 target_t
*target
= all_targets
;
344 if( target
->target_number
== num
){
347 target
= target
->next
;
353 int get_num_by_target(target_t
*query_target
)
355 return query_target
->target_number
;
358 target_t
* get_current_target(command_context_t
*cmd_ctx
)
360 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
364 LOG_ERROR("BUG: current_target out of bounds");
371 int target_poll(struct target_s
*target
)
373 /* We can't poll until after examine */
374 if (!target
->type
->examined
)
376 /* Fail silently lest we pollute the log */
379 return target
->type
->poll(target
);
382 int target_halt(struct target_s
*target
)
384 /* We can't poll until after examine */
385 if (!target
->type
->examined
)
387 LOG_ERROR("Target not examined yet");
390 return target
->type
->halt(target
);
393 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
397 /* We can't poll until after examine */
398 if (!target
->type
->examined
)
400 LOG_ERROR("Target not examined yet");
404 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
405 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
408 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
414 int target_process_reset(struct command_context_s
*cmd_ctx
, enum target_reset_mode reset_mode
)
419 n
= Jim_Nvp_value2name_simple( nvp_reset_modes
, reset_mode
);
420 if( n
->name
== NULL
){
421 LOG_ERROR("invalid reset mode");
425 sprintf( buf
, "ocd_process_reset %s", n
->name
);
426 retval
= Jim_Eval( interp
, buf
);
428 if(retval
!= JIM_OK
) {
429 Jim_PrintErrorMessage(interp
);
433 /* We want any events to be processed before the prompt */
434 retval
= target_call_timer_callbacks_now();
439 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
445 static int default_mmu(struct target_s
*target
, int *enabled
)
451 static int default_examine(struct target_s
*target
)
453 target
->type
->examined
= 1;
457 /* Targets that correctly implement init+examine, i.e.
458 * no communication with target during init:
462 int target_examine(void)
464 int retval
= ERROR_OK
;
465 target_t
*target
= all_targets
;
468 if ((retval
= target
->type
->examine(target
))!=ERROR_OK
)
470 target
= target
->next
;
475 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
477 if (!target
->type
->examined
)
479 LOG_ERROR("Target not examined yet");
482 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
485 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
487 if (!target
->type
->examined
)
489 LOG_ERROR("Target not examined yet");
492 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
495 static int target_soft_reset_halt_imp(struct target_s
*target
)
497 if (!target
->type
->examined
)
499 LOG_ERROR("Target not examined yet");
502 return target
->type
->soft_reset_halt_imp(target
);
505 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
)
507 if (!target
->type
->examined
)
509 LOG_ERROR("Target not examined yet");
512 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
);
515 int target_init(struct command_context_s
*cmd_ctx
)
517 target_t
*target
= all_targets
;
522 target
->type
->examined
= 0;
523 if (target
->type
->examine
== NULL
)
525 target
->type
->examine
= default_examine
;
528 if ((retval
= target
->type
->init_target(cmd_ctx
, target
)) != ERROR_OK
)
530 LOG_ERROR("target '%s' init failed", target
->type
->name
);
534 /* Set up default functions if none are provided by target */
535 if (target
->type
->virt2phys
== NULL
)
537 target
->type
->virt2phys
= default_virt2phys
;
539 target
->type
->virt2phys
= default_virt2phys
;
540 /* a non-invasive way(in terms of patches) to add some code that
541 * runs before the type->write/read_memory implementation
543 target
->type
->write_memory_imp
= target
->type
->write_memory
;
544 target
->type
->write_memory
= target_write_memory_imp
;
545 target
->type
->read_memory_imp
= target
->type
->read_memory
;
546 target
->type
->read_memory
= target_read_memory_imp
;
547 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
548 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
549 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
550 target
->type
->run_algorithm
= target_run_algorithm_imp
;
552 if (target
->type
->mmu
== NULL
)
554 target
->type
->mmu
= default_mmu
;
556 target
= target
->next
;
561 if((retval
= target_register_user_commands(cmd_ctx
)) != ERROR_OK
)
563 if((retval
= target_register_timer_callback(handle_target
, 100, 1, NULL
)) != ERROR_OK
)
570 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
572 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
574 if (callback
== NULL
)
576 return ERROR_INVALID_ARGUMENTS
;
581 while ((*callbacks_p
)->next
)
582 callbacks_p
= &((*callbacks_p
)->next
);
583 callbacks_p
= &((*callbacks_p
)->next
);
586 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
587 (*callbacks_p
)->callback
= callback
;
588 (*callbacks_p
)->priv
= priv
;
589 (*callbacks_p
)->next
= NULL
;
594 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
596 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
599 if (callback
== NULL
)
601 return ERROR_INVALID_ARGUMENTS
;
606 while ((*callbacks_p
)->next
)
607 callbacks_p
= &((*callbacks_p
)->next
);
608 callbacks_p
= &((*callbacks_p
)->next
);
611 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
612 (*callbacks_p
)->callback
= callback
;
613 (*callbacks_p
)->periodic
= periodic
;
614 (*callbacks_p
)->time_ms
= time_ms
;
616 gettimeofday(&now
, NULL
);
617 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
618 time_ms
-= (time_ms
% 1000);
619 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
620 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
622 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
623 (*callbacks_p
)->when
.tv_sec
+= 1;
626 (*callbacks_p
)->priv
= priv
;
627 (*callbacks_p
)->next
= NULL
;
632 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
634 target_event_callback_t
**p
= &target_event_callbacks
;
635 target_event_callback_t
*c
= target_event_callbacks
;
637 if (callback
== NULL
)
639 return ERROR_INVALID_ARGUMENTS
;
644 target_event_callback_t
*next
= c
->next
;
645 if ((c
->callback
== callback
) && (c
->priv
== priv
))
659 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
661 target_timer_callback_t
**p
= &target_timer_callbacks
;
662 target_timer_callback_t
*c
= target_timer_callbacks
;
664 if (callback
== NULL
)
666 return ERROR_INVALID_ARGUMENTS
;
671 target_timer_callback_t
*next
= c
->next
;
672 if ((c
->callback
== callback
) && (c
->priv
== priv
))
686 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
688 target_event_callback_t
*callback
= target_event_callbacks
;
689 target_event_callback_t
*next_callback
;
691 if (event
== TARGET_EVENT_HALTED
)
693 /* execute early halted first */
694 target_call_event_callbacks(target
, TARGET_EVENT_EARLY_HALTED
);
697 LOG_DEBUG("target event %i (%s)",
699 Jim_Nvp_value2name_simple( nvp_target_event
, event
)->name
);
701 target_handle_event( target
, event
);
705 next_callback
= callback
->next
;
706 callback
->callback(target
, event
, callback
->priv
);
707 callback
= next_callback
;
713 static int target_call_timer_callbacks_check_time(int checktime
)
715 target_timer_callback_t
*callback
= target_timer_callbacks
;
716 target_timer_callback_t
*next_callback
;
721 gettimeofday(&now
, NULL
);
725 next_callback
= callback
->next
;
727 if ((!checktime
&&callback
->periodic
)||
728 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
729 || (now
.tv_sec
> callback
->when
.tv_sec
)))
731 if(callback
->callback
!= NULL
)
733 callback
->callback(callback
->priv
);
734 if (callback
->periodic
)
736 int time_ms
= callback
->time_ms
;
737 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
738 time_ms
-= (time_ms
% 1000);
739 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
740 if (callback
->when
.tv_usec
> 1000000)
742 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
743 callback
->when
.tv_sec
+= 1;
749 if((retval
= target_unregister_timer_callback(callback
->callback
, callback
->priv
)) != ERROR_OK
)
755 callback
= next_callback
;
761 int target_call_timer_callbacks(void)
763 return target_call_timer_callbacks_check_time(1);
766 /* invoke periodic callbacks immediately */
767 int target_call_timer_callbacks_now(void)
769 return target_call_timer_callbacks_check_time(0);
772 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
774 working_area_t
*c
= target
->working_areas
;
775 working_area_t
*new_wa
= NULL
;
777 /* Reevaluate working area address based on MMU state*/
778 if (target
->working_areas
== NULL
)
782 retval
= target
->type
->mmu(target
, &enabled
);
783 if (retval
!= ERROR_OK
)
789 target
->working_area
= target
->working_area_virt
;
793 target
->working_area
= target
->working_area_phys
;
797 /* only allocate multiples of 4 byte */
800 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
801 size
= CEIL(size
, 4);
804 /* see if there's already a matching working area */
807 if ((c
->free
) && (c
->size
== size
))
815 /* if not, allocate a new one */
818 working_area_t
**p
= &target
->working_areas
;
819 u32 first_free
= target
->working_area
;
820 u32 free_size
= target
->working_area_size
;
822 LOG_DEBUG("allocating new working area");
824 c
= target
->working_areas
;
827 first_free
+= c
->size
;
828 free_size
-= c
->size
;
833 if (free_size
< size
)
835 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
836 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
839 new_wa
= malloc(sizeof(working_area_t
));
842 new_wa
->address
= first_free
;
844 if (target
->backup_working_area
)
847 new_wa
->backup
= malloc(new_wa
->size
);
848 if((retval
= target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
)) != ERROR_OK
)
850 free(new_wa
->backup
);
857 new_wa
->backup
= NULL
;
860 /* put new entry in list */
864 /* mark as used, and return the new (reused) area */
874 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
879 if (restore
&&target
->backup_working_area
)
882 if((retval
= target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
)) != ERROR_OK
)
888 /* mark user pointer invalid */
895 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
897 return target_free_working_area_restore(target
, area
, 1);
900 /* free resources and restore memory, if restoring memory fails,
901 * free up resources anyway
903 void target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
905 working_area_t
*c
= target
->working_areas
;
909 working_area_t
*next
= c
->next
;
910 target_free_working_area_restore(target
, c
, restore
);
920 target
->working_areas
= NULL
;
923 void target_free_all_working_areas(struct target_s
*target
)
925 target_free_all_working_areas_restore(target
, 1);
928 int target_register_commands(struct command_context_s
*cmd_ctx
)
931 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)");
936 register_jim(cmd_ctx
, "target", jim_target
, "configure target" );
941 int target_arch_state(struct target_s
*target
)
946 LOG_USER("No target has been configured");
950 LOG_USER("target state: %s",
951 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
);
953 if (target
->state
!=TARGET_HALTED
)
956 retval
=target
->type
->arch_state(target
);
960 /* Single aligned words are guaranteed to use 16 or 32 bit access
961 * mode respectively, otherwise data is handled as quickly as
964 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
967 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
969 if (!target
->type
->examined
)
971 LOG_ERROR("Target not examined yet");
975 if ((address
+ size
- 1) < address
)
977 /* GDB can request this when e.g. PC is 0xfffffffc*/
978 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
982 if (((address
% 2) == 0) && (size
== 2))
984 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
987 /* handle unaligned head bytes */
990 u32 unaligned
= 4 - (address
% 4);
992 if (unaligned
> size
)
995 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
999 address
+= unaligned
;
1003 /* handle aligned words */
1006 int aligned
= size
- (size
% 4);
1008 /* use bulk writes above a certain limit. This may have to be changed */
1011 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1016 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1025 /* handle tail writes of less than 4 bytes */
1028 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1035 /* Single aligned words are guaranteed to use 16 or 32 bit access
1036 * mode respectively, otherwise data is handled as quickly as
1039 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1042 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1044 if (!target
->type
->examined
)
1046 LOG_ERROR("Target not examined yet");
1050 if ((address
+ size
- 1) < address
)
1052 /* GDB can request this when e.g. PC is 0xfffffffc*/
1053 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
1057 if (((address
% 2) == 0) && (size
== 2))
1059 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1062 /* handle unaligned head bytes */
1065 u32 unaligned
= 4 - (address
% 4);
1067 if (unaligned
> size
)
1070 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1073 buffer
+= unaligned
;
1074 address
+= unaligned
;
1078 /* handle aligned words */
1081 int aligned
= size
- (size
% 4);
1083 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1091 /* handle tail writes of less than 4 bytes */
1094 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1101 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1107 if (!target
->type
->examined
)
1109 LOG_ERROR("Target not examined yet");
1113 if ((retval
= target
->type
->checksum_memory(target
, address
,
1114 size
, &checksum
)) != ERROR_OK
)
1116 buffer
= malloc(size
);
1119 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1120 return ERROR_INVALID_ARGUMENTS
;
1122 retval
= target_read_buffer(target
, address
, size
, buffer
);
1123 if (retval
!= ERROR_OK
)
1129 /* convert to target endianess */
1130 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1133 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1134 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1137 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1146 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1149 if (!target
->type
->examined
)
1151 LOG_ERROR("Target not examined yet");
1155 if (target
->type
->blank_check_memory
== 0)
1156 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1158 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1163 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1166 if (!target
->type
->examined
)
1168 LOG_ERROR("Target not examined yet");
1172 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1174 if (retval
== ERROR_OK
)
1176 *value
= target_buffer_get_u32(target
, value_buf
);
1177 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1182 LOG_DEBUG("address: 0x%8.8x failed", address
);
1188 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1191 if (!target
->type
->examined
)
1193 LOG_ERROR("Target not examined yet");
1197 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1199 if (retval
== ERROR_OK
)
1201 *value
= target_buffer_get_u16(target
, value_buf
);
1202 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1207 LOG_DEBUG("address: 0x%8.8x failed", address
);
1213 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1215 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1216 if (!target
->type
->examined
)
1218 LOG_ERROR("Target not examined yet");
1222 if (retval
== ERROR_OK
)
1224 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1229 LOG_DEBUG("address: 0x%8.8x failed", address
);
1235 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1239 if (!target
->type
->examined
)
1241 LOG_ERROR("Target not examined yet");
1245 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1247 target_buffer_set_u32(target
, value_buf
, value
);
1248 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1250 LOG_DEBUG("failed: %i", retval
);
1256 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1260 if (!target
->type
->examined
)
1262 LOG_ERROR("Target not examined yet");
1266 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1268 target_buffer_set_u16(target
, value_buf
, value
);
1269 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1271 LOG_DEBUG("failed: %i", retval
);
1277 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1280 if (!target
->type
->examined
)
1282 LOG_ERROR("Target not examined yet");
1286 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1288 if ((retval
= target
->type
->write_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1290 LOG_DEBUG("failed: %i", retval
);
1296 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1298 int retval
= ERROR_OK
;
1301 /* script procedures */
1302 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "profiling samples the CPU PC");
1303 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
1304 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
1306 register_command(cmd_ctx
, NULL
, "fast_load_image", handle_fast_load_image_command
, COMMAND_ANY
,
1307 "same args as load_image, image stored in memory - mainly for profiling purposes");
1309 register_command(cmd_ctx
, NULL
, "fast_load", handle_fast_load_command
, COMMAND_ANY
,
1310 "loads active fast load image to current target - mainly for profiling purposes");
1313 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "translate a virtual address into a physical address");
1314 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, "display or set a register");
1315 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1316 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1317 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1318 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1319 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1320 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init] - default is run");
1321 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1323 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1324 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1325 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1327 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1328 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1329 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1331 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1332 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1333 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1334 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1336 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]");
1337 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1338 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1339 register_command(cmd_ctx
, NULL
, "test_image", handle_test_image_command
, COMMAND_EXEC
, "test_image <file> [offset] [type]");
1341 if((retval
= target_request_register_commands(cmd_ctx
)) != ERROR_OK
)
1343 if((retval
= trace_register_commands(cmd_ctx
)) != ERROR_OK
)
1349 static int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1352 target_t
*target
= all_targets
;
1356 /* try as tcltarget name */
1357 for( target
= all_targets
; target
; target
= target
->next
){
1358 if( target
->cmd_name
){
1359 if( 0 == strcmp( args
[0], target
->cmd_name
) ){
1365 /* no match, try as number */
1367 int num
= strtoul(args
[0], &cp
, 0 );
1369 /* then it was not a number */
1370 command_print( cmd_ctx
, "Target: %s unknown, try one of:\n", args
[0] );
1374 target
= get_target_by_num( num
);
1375 if( target
== NULL
){
1376 command_print(cmd_ctx
,"Target: %s is unknown, try one of:\n", args
[0] );
1380 cmd_ctx
->current_target
= target
->target_number
;
1385 target
= all_targets
;
1386 command_print(cmd_ctx
, " CmdName Type Endian AbsChainPos Name State ");
1387 command_print(cmd_ctx
, "-- ---------- ---------- ---------- ----------- ------------- ----------");
1390 /* XX: abcdefghij abcdefghij abcdefghij abcdefghij */
1391 command_print(cmd_ctx
, "%2d: %-10s %-10s %-10s %10d %14s %s",
1392 target
->target_number
,
1395 Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
)->name
,
1396 target
->tap
->abs_chain_position
,
1397 target
->tap
->dotted_name
,
1398 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
1399 target
= target
->next
;
1405 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1407 static int powerDropout
;
1408 static int srstAsserted
;
1410 static int runPowerRestore
;
1411 static int runPowerDropout
;
1412 static int runSrstAsserted
;
1413 static int runSrstDeasserted
;
1415 static int sense_handler(void)
1417 static int prevSrstAsserted
= 0;
1418 static int prevPowerdropout
= 0;
1421 if ((retval
=jtag_power_dropout(&powerDropout
))!=ERROR_OK
)
1425 powerRestored
= prevPowerdropout
&& !powerDropout
;
1428 runPowerRestore
= 1;
1431 long long current
= timeval_ms();
1432 static long long lastPower
= 0;
1433 int waitMore
= lastPower
+ 2000 > current
;
1434 if (powerDropout
&& !waitMore
)
1436 runPowerDropout
= 1;
1437 lastPower
= current
;
1440 if ((retval
=jtag_srst_asserted(&srstAsserted
))!=ERROR_OK
)
1444 srstDeasserted
= prevSrstAsserted
&& !srstAsserted
;
1446 static long long lastSrst
= 0;
1447 waitMore
= lastSrst
+ 2000 > current
;
1448 if (srstDeasserted
&& !waitMore
)
1450 runSrstDeasserted
= 1;
1454 if (!prevSrstAsserted
&& srstAsserted
)
1456 runSrstAsserted
= 1;
1459 prevSrstAsserted
= srstAsserted
;
1460 prevPowerdropout
= powerDropout
;
1462 if (srstDeasserted
|| powerRestored
)
1464 /* Other than logging the event we can't do anything here.
1465 * Issuing a reset is a particularly bad idea as we might
1466 * be inside a reset already.
1473 /* process target state changes */
1474 int handle_target(void *priv
)
1476 int retval
= ERROR_OK
;
1478 /* we do not want to recurse here... */
1479 static int recursive
= 0;
1484 /* danger! running these procedures can trigger srst assertions and power dropouts.
1485 * We need to avoid an infinite loop/recursion here and we do that by
1486 * clearing the flags after running these events.
1488 int did_something
= 0;
1489 if (runSrstAsserted
)
1491 Jim_Eval( interp
, "srst_asserted");
1494 if (runSrstDeasserted
)
1496 Jim_Eval( interp
, "srst_deasserted");
1499 if (runPowerDropout
)
1501 Jim_Eval( interp
, "power_dropout");
1504 if (runPowerRestore
)
1506 Jim_Eval( interp
, "power_restore");
1512 /* clear detect flags */
1516 /* clear action flags */
1519 runSrstDeasserted
=0;
1526 target_t
*target
= all_targets
;
1531 /* only poll target if we've got power and srst isn't asserted */
1532 if (target_continous_poll
&&!powerDropout
&&!srstAsserted
)
1534 /* polling may fail silently until the target has been examined */
1535 if((retval
= target_poll(target
)) != ERROR_OK
)
1539 target
= target
->next
;
1545 static int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1554 target
= get_current_target(cmd_ctx
);
1556 /* list all available registers for the current target */
1559 reg_cache_t
*cache
= target
->reg_cache
;
1565 for (i
= 0; i
< cache
->num_regs
; i
++)
1567 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1568 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
);
1571 cache
= cache
->next
;
1577 /* access a single register by its ordinal number */
1578 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1580 int num
= strtoul(args
[0], NULL
, 0);
1581 reg_cache_t
*cache
= target
->reg_cache
;
1587 for (i
= 0; i
< cache
->num_regs
; i
++)
1591 reg
= &cache
->reg_list
[i
];
1597 cache
= cache
->next
;
1602 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1605 } else /* access a single register by its name */
1607 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1611 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1616 /* display a register */
1617 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1619 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1622 if (reg
->valid
== 0)
1624 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1625 arch_type
->get(reg
);
1627 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1628 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1633 /* set register value */
1636 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1637 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1639 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1640 arch_type
->set(reg
, buf
);
1642 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1643 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1651 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1656 static int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1658 int retval
= ERROR_OK
;
1659 target_t
*target
= get_current_target(cmd_ctx
);
1663 if((retval
= target_poll(target
)) != ERROR_OK
)
1665 if((retval
= target_arch_state(target
)) != ERROR_OK
)
1671 if (strcmp(args
[0], "on") == 0)
1673 target_continous_poll
= 1;
1675 else if (strcmp(args
[0], "off") == 0)
1677 target_continous_poll
= 0;
1681 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1685 return ERROR_COMMAND_SYNTAX_ERROR
;
1691 static int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1699 ms
= strtoul(args
[0], &end
, 0) * 1000;
1702 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1706 target_t
*target
= get_current_target(cmd_ctx
);
1708 return target_wait_state(target
, TARGET_HALTED
, ms
);
1711 /* wait for target state to change. The trick here is to have a low
1712 * latency for short waits and not to suck up all the CPU time
1715 * After 500ms, keep_alive() is invoked
1717 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1720 long long then
=0, cur
;
1725 if ((retval
=target_poll(target
))!=ERROR_OK
)
1727 if (target
->state
== state
)
1735 then
= timeval_ms();
1736 LOG_DEBUG("waiting for target %s...",
1737 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1747 LOG_ERROR("timed out while waiting for target %s",
1748 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1756 static int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1759 target_t
*target
= get_current_target(cmd_ctx
);
1763 if ((retval
= target_halt(target
)) != ERROR_OK
)
1773 wait
= strtoul(args
[0], &end
, 0);
1778 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1781 static int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1783 target_t
*target
= get_current_target(cmd_ctx
);
1785 LOG_USER("requesting target halt and executing a soft reset");
1787 target
->type
->soft_reset_halt(target
);
1792 static int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1795 enum target_reset_mode reset_mode
= RESET_RUN
;
1799 n
= Jim_Nvp_name2value_simple( nvp_reset_modes
, args
[0] );
1800 if( (n
->name
== NULL
) || (n
->value
== RESET_UNKNOWN
) ){
1801 return ERROR_COMMAND_SYNTAX_ERROR
;
1803 reset_mode
= n
->value
;
1806 /* reset *all* targets */
1807 return target_process_reset(cmd_ctx
, reset_mode
);
1811 static int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1814 target_t
*target
= get_current_target(cmd_ctx
);
1816 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1819 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1821 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1824 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
1830 static int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1832 target_t
*target
= get_current_target(cmd_ctx
);
1837 return target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1840 return target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1845 static int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1847 const int line_bytecnt
= 32;
1860 target_t
*target
= get_current_target(cmd_ctx
);
1866 count
= strtoul(args
[1], NULL
, 0);
1868 address
= strtoul(args
[0], NULL
, 0);
1873 size
= 4; line_modulo
= line_bytecnt
/ 4;
1876 size
= 2; line_modulo
= line_bytecnt
/ 2;
1879 size
= 1; line_modulo
= line_bytecnt
/ 1;
1885 buffer
= calloc(count
, size
);
1886 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1887 if (retval
== ERROR_OK
)
1891 for (i
= 0; i
< count
; i
++)
1893 if (i
%line_modulo
== 0)
1894 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1899 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1902 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1905 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1909 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1911 command_print(cmd_ctx
, output
);
1922 static int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1929 target_t
*target
= get_current_target(cmd_ctx
);
1932 if ((argc
< 2) || (argc
> 3))
1933 return ERROR_COMMAND_SYNTAX_ERROR
;
1935 address
= strtoul(args
[0], NULL
, 0);
1936 value
= strtoul(args
[1], NULL
, 0);
1938 count
= strtoul(args
[2], NULL
, 0);
1944 target_buffer_set_u32(target
, value_buf
, value
);
1948 target_buffer_set_u16(target
, value_buf
, value
);
1952 value_buf
[0] = value
;
1955 return ERROR_COMMAND_SYNTAX_ERROR
;
1957 for (i
=0; i
<count
; i
++)
1963 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1966 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1969 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1976 if (retval
!=ERROR_OK
)
1986 static int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1992 u32 max_address
=0xffffffff;
1994 int retval
, retvaltemp
;
1998 duration_t duration
;
1999 char *duration_text
;
2001 target_t
*target
= get_current_target(cmd_ctx
);
2003 if ((argc
< 1)||(argc
> 5))
2005 return ERROR_COMMAND_SYNTAX_ERROR
;
2008 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2011 image
.base_address_set
= 1;
2012 image
.base_address
= strtoul(args
[1], NULL
, 0);
2016 image
.base_address_set
= 0;
2020 image
.start_address_set
= 0;
2024 min_address
=strtoul(args
[3], NULL
, 0);
2028 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
2031 if (min_address
>max_address
)
2033 return ERROR_COMMAND_SYNTAX_ERROR
;
2036 duration_start_measure(&duration
);
2038 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2045 for (i
= 0; i
< image
.num_sections
; i
++)
2047 buffer
= malloc(image
.sections
[i
].size
);
2050 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2054 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2063 /* DANGER!!! beware of unsigned comparision here!!! */
2065 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
2066 (image
.sections
[i
].base_address
<max_address
))
2068 if (image
.sections
[i
].base_address
<min_address
)
2070 /* clip addresses below */
2071 offset
+=min_address
-image
.sections
[i
].base_address
;
2075 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
2077 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2080 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2085 image_size
+= length
;
2086 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2092 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2094 image_close(&image
);
2098 if (retval
==ERROR_OK
)
2100 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2102 free(duration_text
);
2104 image_close(&image
);
2110 static int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2117 int retval
=ERROR_OK
, retvaltemp
;
2119 duration_t duration
;
2120 char *duration_text
;
2122 target_t
*target
= get_current_target(cmd_ctx
);
2126 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2130 address
= strtoul(args
[1], NULL
, 0);
2131 size
= strtoul(args
[2], NULL
, 0);
2133 if ((address
& 3) || (size
& 3))
2135 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2139 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2144 duration_start_measure(&duration
);
2149 u32 this_run_size
= (size
> 560) ? 560 : size
;
2151 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2152 if (retval
!= ERROR_OK
)
2157 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2158 if (retval
!= ERROR_OK
)
2163 size
-= this_run_size
;
2164 address
+= this_run_size
;
2167 if((retvaltemp
= fileio_close(&fileio
)) != ERROR_OK
)
2170 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2173 if (retval
==ERROR_OK
)
2175 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2177 free(duration_text
);
2182 static int handle_verify_image_command_internal(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, int verify
)
2188 int retval
, retvaltemp
;
2190 u32 mem_checksum
= 0;
2194 duration_t duration
;
2195 char *duration_text
;
2197 target_t
*target
= get_current_target(cmd_ctx
);
2201 return ERROR_COMMAND_SYNTAX_ERROR
;
2206 LOG_ERROR("no target selected");
2210 duration_start_measure(&duration
);
2214 image
.base_address_set
= 1;
2215 image
.base_address
= strtoul(args
[1], NULL
, 0);
2219 image
.base_address_set
= 0;
2220 image
.base_address
= 0x0;
2223 image
.start_address_set
= 0;
2225 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2232 for (i
= 0; i
< image
.num_sections
; i
++)
2234 buffer
= malloc(image
.sections
[i
].size
);
2237 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2240 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2248 /* calculate checksum of image */
2249 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2251 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2252 if( retval
!= ERROR_OK
)
2258 if( checksum
!= mem_checksum
)
2260 /* failed crc checksum, fall back to a binary compare */
2263 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2265 data
= (u8
*)malloc(buf_cnt
);
2267 /* Can we use 32bit word accesses? */
2269 int count
= buf_cnt
;
2270 if ((count
% 4) == 0)
2275 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2276 if (retval
== ERROR_OK
)
2279 for (t
= 0; t
< buf_cnt
; t
++)
2281 if (data
[t
] != buffer
[t
])
2283 command_print(cmd_ctx
, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", t
+ image
.sections
[i
].base_address
, data
[t
], buffer
[t
]);
2300 command_print(cmd_ctx
, "address 0x%08x length 0x%08x", image
.sections
[i
].base_address
, buf_cnt
);
2304 image_size
+= buf_cnt
;
2308 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2310 image_close(&image
);
2314 if (retval
==ERROR_OK
)
2316 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2318 free(duration_text
);
2320 image_close(&image
);
2325 static int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2327 return handle_verify_image_command_internal(cmd_ctx
, cmd
, args
, argc
, 1);
2330 static int handle_test_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2332 return handle_verify_image_command_internal(cmd_ctx
, cmd
, args
, argc
, 0);
2335 static int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2338 target_t
*target
= get_current_target(cmd_ctx
);
2342 breakpoint_t
*breakpoint
= target
->breakpoints
;
2346 if (breakpoint
->type
== BKPT_SOFT
)
2348 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2349 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2354 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2356 breakpoint
= breakpoint
->next
;
2364 length
= strtoul(args
[1], NULL
, 0);
2367 if (strcmp(args
[2], "hw") == 0)
2370 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2372 LOG_ERROR("Failure setting breakpoints");
2376 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2381 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2387 static int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2389 target_t
*target
= get_current_target(cmd_ctx
);
2392 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2397 static int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2399 target_t
*target
= get_current_target(cmd_ctx
);
2404 watchpoint_t
*watchpoint
= target
->watchpoints
;
2408 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
);
2409 watchpoint
= watchpoint
->next
;
2414 enum watchpoint_rw type
= WPT_ACCESS
;
2415 u32 data_value
= 0x0;
2416 u32 data_mask
= 0xffffffff;
2432 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2438 data_value
= strtoul(args
[3], NULL
, 0);
2442 data_mask
= strtoul(args
[4], NULL
, 0);
2445 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2446 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2448 LOG_ERROR("Failure setting breakpoints");
2453 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2459 static int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2461 target_t
*target
= get_current_target(cmd_ctx
);
2464 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2469 static int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2472 target_t
*target
= get_current_target(cmd_ctx
);
2478 return ERROR_COMMAND_SYNTAX_ERROR
;
2480 va
= strtoul(args
[0], NULL
, 0);
2482 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2483 if (retval
== ERROR_OK
)
2485 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2489 /* lower levels will have logged a detailed error which is
2490 * forwarded to telnet/GDB session.
2496 static void writeData(FILE *f
, const void *data
, size_t len
)
2498 size_t written
= fwrite(data
, len
, 1, f
);
2500 LOG_ERROR("failed to write %zu bytes: %s", len
, strerror(errno
));
2503 static void writeLong(FILE *f
, int l
)
2508 char c
=(l
>>(i
*8))&0xff;
2509 writeData(f
, &c
, 1);
2514 static void writeString(FILE *f
, char *s
)
2516 writeData(f
, s
, strlen(s
));
2519 /* Dump a gmon.out histogram file. */
2520 static void writeGmon(u32
*samples
, u32 sampleNum
, char *filename
)
2523 FILE *f
=fopen(filename
, "w");
2526 writeString(f
, "gmon");
2527 writeLong(f
, 0x00000001); /* Version */
2528 writeLong(f
, 0); /* padding */
2529 writeLong(f
, 0); /* padding */
2530 writeLong(f
, 0); /* padding */
2532 u8 zero
= 0; /* GMON_TAG_TIME_HIST */
2533 writeData(f
, &zero
, 1);
2535 /* figure out bucket size */
2538 for (i
=0; i
<sampleNum
; i
++)
2550 int addressSpace
=(max
-min
+1);
2552 static const u32 maxBuckets
= 256 * 1024; /* maximum buckets. */
2553 u32 length
= addressSpace
;
2554 if (length
> maxBuckets
)
2558 int *buckets
=malloc(sizeof(int)*length
);
2564 memset(buckets
, 0, sizeof(int)*length
);
2565 for (i
=0; i
<sampleNum
;i
++)
2567 u32 address
=samples
[i
];
2568 long long a
=address
-min
;
2569 long long b
=length
-1;
2570 long long c
=addressSpace
-1;
2571 int index
=(a
*b
)/c
; /* danger!!!! int32 overflows */
2575 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2576 writeLong(f
, min
); /* low_pc */
2577 writeLong(f
, max
); /* high_pc */
2578 writeLong(f
, length
); /* # of samples */
2579 writeLong(f
, 64000000); /* 64MHz */
2580 writeString(f
, "seconds");
2581 for (i
=0; i
<(15-strlen("seconds")); i
++)
2582 writeData(f
, &zero
, 1);
2583 writeString(f
, "s");
2585 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2587 char *data
=malloc(2*length
);
2590 for (i
=0; i
<length
;i
++)
2599 data
[i
*2+1]=(val
>>8)&0xff;
2602 writeData(f
, data
, length
* 2);
2612 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2613 static int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2615 target_t
*target
= get_current_target(cmd_ctx
);
2616 struct timeval timeout
, now
;
2618 gettimeofday(&timeout
, NULL
);
2621 return ERROR_COMMAND_SYNTAX_ERROR
;
2624 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2630 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2632 static const int maxSample
=10000;
2633 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2638 int retval
=ERROR_OK
;
2639 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2640 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2644 target_poll(target
);
2645 if (target
->state
== TARGET_HALTED
)
2647 u32 t
=*((u32
*)reg
->value
);
2648 samples
[numSamples
++]=t
;
2649 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2650 target_poll(target
);
2651 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2652 } else if (target
->state
== TARGET_RUNNING
)
2654 /* We want to quickly sample the PC. */
2655 if((retval
= target_halt(target
)) != ERROR_OK
)
2662 command_print(cmd_ctx
, "Target not halted or running");
2666 if (retval
!=ERROR_OK
)
2671 gettimeofday(&now
, NULL
);
2672 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2674 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2675 if((retval
= target_poll(target
)) != ERROR_OK
)
2680 if (target
->state
== TARGET_HALTED
)
2682 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2684 if((retval
= target_poll(target
)) != ERROR_OK
)
2689 writeGmon(samples
, numSamples
, args
[1]);
2690 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2699 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2702 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2705 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2709 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2710 valObjPtr
= Jim_NewIntObj(interp
, val
);
2711 if (!nameObjPtr
|| !valObjPtr
)
2717 Jim_IncrRefCount(nameObjPtr
);
2718 Jim_IncrRefCount(valObjPtr
);
2719 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2720 Jim_DecrRefCount(interp
, nameObjPtr
);
2721 Jim_DecrRefCount(interp
, valObjPtr
);
2723 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2727 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2729 command_context_t
*context
;
2732 context
= Jim_GetAssocData(interp
, "context");
2733 if (context
== NULL
)
2735 LOG_ERROR("mem2array: no command context");
2738 target
= get_current_target(context
);
2741 LOG_ERROR("mem2array: no current target");
2745 return target_mem2array(interp
, target
, argc
,argv
);
2748 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2756 const char *varname
;
2761 /* argv[1] = name of array to receive the data
2762 * argv[2] = desired width
2763 * argv[3] = memory address
2764 * argv[4] = count of times to read
2767 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2770 varname
= Jim_GetString(argv
[1], &len
);
2771 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2773 e
= Jim_GetLong(interp
, argv
[2], &l
);
2779 e
= Jim_GetLong(interp
, argv
[3], &l
);
2784 e
= Jim_GetLong(interp
, argv
[4], &l
);
2800 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2801 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2805 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2806 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2809 if ((addr
+ (len
* width
)) < addr
) {
2810 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2811 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2814 /* absurd transfer size? */
2816 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2817 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2822 ((width
== 2) && ((addr
& 1) == 0)) ||
2823 ((width
== 4) && ((addr
& 3) == 0))) {
2827 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2828 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2829 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2840 /* Slurp... in buffer size chunks */
2842 count
= len
; /* in objects.. */
2843 if (count
> (sizeof(buffer
)/width
)) {
2844 count
= (sizeof(buffer
)/width
);
2847 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2848 if (retval
!= ERROR_OK
) {
2850 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2851 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2852 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2856 v
= 0; /* shut up gcc */
2857 for (i
= 0 ;i
< count
;i
++, n
++) {
2860 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2863 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2866 v
= buffer
[i
] & 0x0ff;
2869 new_int_array_element(interp
, varname
, n
, v
);
2875 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2880 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2883 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2887 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2891 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2898 Jim_IncrRefCount(nameObjPtr
);
2899 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2900 Jim_DecrRefCount(interp
, nameObjPtr
);
2902 if (valObjPtr
== NULL
)
2905 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2906 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2911 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2913 command_context_t
*context
;
2916 context
= Jim_GetAssocData(interp
, "context");
2917 if (context
== NULL
){
2918 LOG_ERROR("array2mem: no command context");
2921 target
= get_current_target(context
);
2922 if (target
== NULL
){
2923 LOG_ERROR("array2mem: no current target");
2927 return target_array2mem( interp
,target
, argc
, argv
);
2930 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2938 const char *varname
;
2943 /* argv[1] = name of array to get the data
2944 * argv[2] = desired width
2945 * argv[3] = memory address
2946 * argv[4] = count to write
2949 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2952 varname
= Jim_GetString(argv
[1], &len
);
2953 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2955 e
= Jim_GetLong(interp
, argv
[2], &l
);
2961 e
= Jim_GetLong(interp
, argv
[3], &l
);
2966 e
= Jim_GetLong(interp
, argv
[4], &l
);
2982 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2983 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2987 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2988 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2991 if ((addr
+ (len
* width
)) < addr
) {
2992 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2993 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2996 /* absurd transfer size? */
2998 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2999 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
3004 ((width
== 2) && ((addr
& 1) == 0)) ||
3005 ((width
== 4) && ((addr
& 3) == 0))) {
3009 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3010 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
3011 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
3022 /* Slurp... in buffer size chunks */
3024 count
= len
; /* in objects.. */
3025 if (count
> (sizeof(buffer
)/width
)) {
3026 count
= (sizeof(buffer
)/width
);
3029 v
= 0; /* shut up gcc */
3030 for (i
= 0 ;i
< count
;i
++, n
++) {
3031 get_int_array_element(interp
, varname
, n
, &v
);
3034 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
3037 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
3040 buffer
[i
] = v
& 0x0ff;
3046 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
3047 if (retval
!= ERROR_OK
) {
3049 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
3050 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3051 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: cannot read memory", NULL
);
3057 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3062 void target_all_handle_event( enum target_event e
)
3066 LOG_DEBUG( "**all*targets: event: %d, %s",
3068 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3070 target
= all_targets
;
3072 target_handle_event( target
, e
);
3073 target
= target
->next
;
3077 void target_handle_event( target_t
*target
, enum target_event e
)
3079 target_event_action_t
*teap
;
3082 teap
= target
->event_action
;
3086 if( teap
->event
== e
){
3088 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3089 target
->target_number
,
3093 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
,
3094 Jim_GetString( teap
->body
, NULL
) );
3095 if (Jim_EvalObj( interp
, teap
->body
)!=JIM_OK
)
3097 Jim_PrintErrorMessage(interp
);
3103 LOG_DEBUG( "event: %d %s - no action",
3105 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3109 enum target_cfg_param
{
3112 TCFG_WORK_AREA_VIRT
,
3113 TCFG_WORK_AREA_PHYS
,
3114 TCFG_WORK_AREA_SIZE
,
3115 TCFG_WORK_AREA_BACKUP
,
3118 TCFG_CHAIN_POSITION
,
3121 static Jim_Nvp nvp_config_opts
[] = {
3122 { .name
= "-type", .value
= TCFG_TYPE
},
3123 { .name
= "-event", .value
= TCFG_EVENT
},
3124 { .name
= "-work-area-virt", .value
= TCFG_WORK_AREA_VIRT
},
3125 { .name
= "-work-area-phys", .value
= TCFG_WORK_AREA_PHYS
},
3126 { .name
= "-work-area-size", .value
= TCFG_WORK_AREA_SIZE
},
3127 { .name
= "-work-area-backup", .value
= TCFG_WORK_AREA_BACKUP
},
3128 { .name
= "-endian" , .value
= TCFG_ENDIAN
},
3129 { .name
= "-variant", .value
= TCFG_VARIANT
},
3130 { .name
= "-chain-position", .value
= TCFG_CHAIN_POSITION
},
3132 { .name
= NULL
, .value
= -1 }
3135 static int target_configure( Jim_GetOptInfo
*goi
, target_t
*target
)
3143 /* parse config or cget options ... */
3144 while( goi
->argc
> 0 ){
3145 Jim_SetEmptyResult( goi
->interp
);
3146 /* Jim_GetOpt_Debug( goi ); */
3148 if( target
->type
->target_jim_configure
){
3149 /* target defines a configure function */
3150 /* target gets first dibs on parameters */
3151 e
= (*(target
->type
->target_jim_configure
))( target
, goi
);
3160 /* otherwise we 'continue' below */
3162 e
= Jim_GetOpt_Nvp( goi
, nvp_config_opts
, &n
);
3164 Jim_GetOpt_NvpUnknown( goi
, nvp_config_opts
, 0 );
3170 if( goi
->isconfigure
){
3171 Jim_SetResult_sprintf( goi
->interp
, "not setable: %s", n
->name
);
3175 if( goi
->argc
!= 0 ){
3176 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
3180 Jim_SetResultString( goi
->interp
, target
->type
->name
, -1 );
3184 if( goi
->argc
== 0 ){
3185 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ...");
3189 e
= Jim_GetOpt_Nvp( goi
, nvp_target_event
, &n
);
3191 Jim_GetOpt_NvpUnknown( goi
, nvp_target_event
, 1 );
3195 if( goi
->isconfigure
){
3196 if( goi
->argc
!= 1 ){
3197 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
3201 if( goi
->argc
!= 0 ){
3202 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
3208 target_event_action_t
*teap
;
3210 teap
= target
->event_action
;
3211 /* replace existing? */
3213 if( teap
->event
== (enum target_event
)n
->value
){
3219 if( goi
->isconfigure
){
3222 teap
= calloc( 1, sizeof(*teap
) );
3224 teap
->event
= n
->value
;
3225 Jim_GetOpt_Obj( goi
, &o
);
3227 Jim_DecrRefCount( interp
, teap
->body
);
3229 teap
->body
= Jim_DuplicateObj( goi
->interp
, o
);
3232 * Tcl/TK - "tk events" have a nice feature.
3233 * See the "BIND" command.
3234 * We should support that here.
3235 * You can specify %X and %Y in the event code.
3236 * The idea is: %T - target name.
3237 * The idea is: %N - target number
3238 * The idea is: %E - event name.
3240 Jim_IncrRefCount( teap
->body
);
3242 /* add to head of event list */
3243 teap
->next
= target
->event_action
;
3244 target
->event_action
= teap
;
3245 Jim_SetEmptyResult(goi
->interp
);
3249 Jim_SetEmptyResult( goi
->interp
);
3251 Jim_SetResult( goi
->interp
, Jim_DuplicateObj( goi
->interp
, teap
->body
) );
3258 case TCFG_WORK_AREA_VIRT
:
3259 if( goi
->isconfigure
){
3260 target_free_all_working_areas(target
);
3261 e
= Jim_GetOpt_Wide( goi
, &w
);
3265 target
->working_area_virt
= w
;
3267 if( goi
->argc
!= 0 ){
3271 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_virt
) );
3275 case TCFG_WORK_AREA_PHYS
:
3276 if( goi
->isconfigure
){
3277 target_free_all_working_areas(target
);
3278 e
= Jim_GetOpt_Wide( goi
, &w
);
3282 target
->working_area_phys
= w
;
3284 if( goi
->argc
!= 0 ){
3288 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_phys
) );
3292 case TCFG_WORK_AREA_SIZE
:
3293 if( goi
->isconfigure
){
3294 target_free_all_working_areas(target
);
3295 e
= Jim_GetOpt_Wide( goi
, &w
);
3299 target
->working_area_size
= w
;
3301 if( goi
->argc
!= 0 ){
3305 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3309 case TCFG_WORK_AREA_BACKUP
:
3310 if( goi
->isconfigure
){
3311 target_free_all_working_areas(target
);
3312 e
= Jim_GetOpt_Wide( goi
, &w
);
3316 /* make this exactly 1 or 0 */
3317 target
->backup_working_area
= (!!w
);
3319 if( goi
->argc
!= 0 ){
3323 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3324 /* loop for more e*/
3328 if( goi
->isconfigure
){
3329 e
= Jim_GetOpt_Nvp( goi
, nvp_target_endian
, &n
);
3331 Jim_GetOpt_NvpUnknown( goi
, nvp_target_endian
, 1 );
3334 target
->endianness
= n
->value
;
3336 if( goi
->argc
!= 0 ){
3340 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3341 if( n
->name
== NULL
){
3342 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3343 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3345 Jim_SetResultString( goi
->interp
, n
->name
, -1 );
3350 if( goi
->isconfigure
){
3351 if( goi
->argc
< 1 ){
3352 Jim_SetResult_sprintf( goi
->interp
,
3357 if( target
->variant
){
3358 free((void *)(target
->variant
));
3360 e
= Jim_GetOpt_String( goi
, &cp
, NULL
);
3361 target
->variant
= strdup(cp
);
3363 if( goi
->argc
!= 0 ){
3367 Jim_SetResultString( goi
->interp
, target
->variant
,-1 );
3370 case TCFG_CHAIN_POSITION
:
3371 if( goi
->isconfigure
){
3374 target_free_all_working_areas(target
);
3375 e
= Jim_GetOpt_Obj( goi
, &o
);
3379 tap
= jtag_TapByJimObj( goi
->interp
, o
);
3383 /* make this exactly 1 or 0 */
3386 if( goi
->argc
!= 0 ){
3390 Jim_SetResultString( interp
, target
->tap
->dotted_name
, -1 );
3391 /* loop for more e*/
3394 } /* while( goi->argc ) */
3397 /* done - we return */
3401 /** this is the 'tcl' handler for the target specific command */
3402 static int tcl_target_func( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3410 struct command_context_s
*cmd_ctx
;
3417 TS_CMD_MWW
, TS_CMD_MWH
, TS_CMD_MWB
,
3418 TS_CMD_MDW
, TS_CMD_MDH
, TS_CMD_MDB
,
3419 TS_CMD_MRW
, TS_CMD_MRH
, TS_CMD_MRB
,
3420 TS_CMD_MEM2ARRAY
, TS_CMD_ARRAY2MEM
,
3428 TS_CMD_INVOKE_EVENT
,
3431 static const Jim_Nvp target_options
[] = {
3432 { .name
= "configure", .value
= TS_CMD_CONFIGURE
},
3433 { .name
= "cget", .value
= TS_CMD_CGET
},
3434 { .name
= "mww", .value
= TS_CMD_MWW
},
3435 { .name
= "mwh", .value
= TS_CMD_MWH
},
3436 { .name
= "mwb", .value
= TS_CMD_MWB
},
3437 { .name
= "mdw", .value
= TS_CMD_MDW
},
3438 { .name
= "mdh", .value
= TS_CMD_MDH
},
3439 { .name
= "mdb", .value
= TS_CMD_MDB
},
3440 { .name
= "mem2array", .value
= TS_CMD_MEM2ARRAY
},
3441 { .name
= "array2mem", .value
= TS_CMD_ARRAY2MEM
},
3442 { .name
= "eventlist", .value
= TS_CMD_EVENTLIST
},
3443 { .name
= "curstate", .value
= TS_CMD_CURSTATE
},
3445 { .name
= "arp_examine", .value
= TS_CMD_EXAMINE
},
3446 { .name
= "arp_poll", .value
= TS_CMD_POLL
},
3447 { .name
= "arp_reset", .value
= TS_CMD_RESET
},
3448 { .name
= "arp_halt", .value
= TS_CMD_HALT
},
3449 { .name
= "arp_waitstate", .value
= TS_CMD_WAITSTATE
},
3450 { .name
= "invoke-event", .value
= TS_CMD_INVOKE_EVENT
},
3452 { .name
= NULL
, .value
= -1 },
3455 /* go past the "command" */
3456 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3458 target
= Jim_CmdPrivData( goi
.interp
);
3459 cmd_ctx
= Jim_GetAssocData(goi
.interp
, "context");
3461 /* commands here are in an NVP table */
3462 e
= Jim_GetOpt_Nvp( &goi
, target_options
, &n
);
3464 Jim_GetOpt_NvpUnknown( &goi
, target_options
, 0 );
3467 /* Assume blank result */
3468 Jim_SetEmptyResult( goi
.interp
);
3471 case TS_CMD_CONFIGURE
:
3473 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "missing: -option VALUE ...");
3476 goi
.isconfigure
= 1;
3477 return target_configure( &goi
, target
);
3479 // some things take params
3481 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "missing: ?-option?");
3484 goi
.isconfigure
= 0;
3485 return target_configure( &goi
, target
);
3493 * argv[3] = optional count.
3496 if( (goi
.argc
== 3) || (goi
.argc
== 4) ){
3500 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR DATA [COUNT]", n
->name
);
3504 e
= Jim_GetOpt_Wide( &goi
, &a
);
3509 e
= Jim_GetOpt_Wide( &goi
, &b
);
3514 e
= Jim_GetOpt_Wide( &goi
, &c
);
3524 target_buffer_set_u32( target
, target_buf
, b
);
3528 target_buffer_set_u16( target
, target_buf
, b
);
3532 target_buffer_set_u8( target
, target_buf
, b
);
3536 for( x
= 0 ; x
< c
; x
++ ){
3537 e
= target
->type
->write_memory( target
, a
, b
, 1, target_buf
);
3538 if( e
!= ERROR_OK
){
3539 Jim_SetResult_sprintf( interp
, "Error writing @ 0x%08x: %d\n", (int)(a
), e
);
3552 /* argv[0] = command
3554 * argv[2] = optional count
3556 if( (goi
.argc
== 2) || (goi
.argc
== 3) ){
3557 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR [COUNT]", n
->name
);
3560 e
= Jim_GetOpt_Wide( &goi
, &a
);
3565 e
= Jim_GetOpt_Wide( &goi
, &c
);
3572 b
= 1; /* shut up gcc */
3585 /* convert to "bytes" */
3587 /* count is now in 'BYTES' */
3593 e
= target
->type
->read_memory( target
, a
, b
, y
/ b
, target_buf
);
3594 if( e
!= ERROR_OK
){
3595 Jim_SetResult_sprintf( interp
, "error reading target @ 0x%08lx", (int)(a
) );
3599 Jim_fprintf( interp
, interp
->cookie_stdout
, "0x%08x ", (int)(a
) );
3602 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 4 ){
3603 z
= target_buffer_get_u32( target
, &(target_buf
[ x
* 4 ]) );
3604 Jim_fprintf( interp
, interp
->cookie_stdout
, "%08x ", (int)(z
) );
3606 for( ; (x
< 16) ; x
+= 4 ){
3607 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3611 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 2 ){
3612 z
= target_buffer_get_u16( target
, &(target_buf
[ x
* 2 ]) );
3613 Jim_fprintf( interp
, interp
->cookie_stdout
, "%04x ", (int)(z
) );
3615 for( ; (x
< 16) ; x
+= 2 ){
3616 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3621 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 1 ){
3622 z
= target_buffer_get_u8( target
, &(target_buf
[ x
* 4 ]) );
3623 Jim_fprintf( interp
, interp
->cookie_stdout
, "%02x ", (int)(z
) );
3625 for( ; (x
< 16) ; x
+= 1 ){
3626 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3630 /* ascii-ify the bytes */
3631 for( x
= 0 ; x
< y
; x
++ ){
3632 if( (target_buf
[x
] >= 0x20) &&
3633 (target_buf
[x
] <= 0x7e) ){
3637 target_buf
[x
] = '.';
3642 target_buf
[x
] = ' ';
3647 /* print - with a newline */
3648 Jim_fprintf( interp
, interp
->cookie_stdout
, "%s\n", target_buf
);
3654 case TS_CMD_MEM2ARRAY
:
3655 return target_mem2array( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3657 case TS_CMD_ARRAY2MEM
:
3658 return target_array2mem( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3660 case TS_CMD_EXAMINE
:
3662 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3665 e
= target
->type
->examine( target
);
3666 if( e
!= ERROR_OK
){
3667 Jim_SetResult_sprintf( interp
, "examine-fails: %d", e
);
3673 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3676 if( !(target
->type
->examined
) ){
3677 e
= ERROR_TARGET_NOT_EXAMINED
;
3679 e
= target
->type
->poll( target
);
3681 if( e
!= ERROR_OK
){
3682 Jim_SetResult_sprintf( interp
, "poll-fails: %d", e
);
3689 if( goi
.argc
!= 2 ){
3690 Jim_WrongNumArgs( interp
, 2, argv
, "t|f|assert|deassert BOOL");
3693 e
= Jim_GetOpt_Nvp( &goi
, nvp_assert
, &n
);
3695 Jim_GetOpt_NvpUnknown( &goi
, nvp_assert
, 1 );
3698 /* the halt or not param */
3699 e
= Jim_GetOpt_Wide( &goi
, &a
);
3703 /* determine if we should halt or not. */
3704 target
->reset_halt
= !!a
;
3705 /* When this happens - all workareas are invalid. */
3706 target_free_all_working_areas_restore(target
, 0);
3709 if( n
->value
== NVP_ASSERT
){
3710 target
->type
->assert_reset( target
);
3712 target
->type
->deassert_reset( target
);
3717 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "halt [no parameters]");
3720 target
->type
->halt( target
);
3722 case TS_CMD_WAITSTATE
:
3723 /* params: <name> statename timeoutmsecs */
3724 if( goi
.argc
!= 2 ){
3725 Jim_SetResult_sprintf( goi
.interp
, "%s STATENAME TIMEOUTMSECS", n
->name
);
3728 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_state
, &n
);
3730 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_state
,1 );
3733 e
= Jim_GetOpt_Wide( &goi
, &a
);
3737 e
= target_wait_state( target
, n
->value
, a
);
3738 if( e
!= ERROR_OK
){
3739 Jim_SetResult_sprintf( goi
.interp
,
3740 "target: %s wait %s fails (%d) %s",
3743 e
, target_strerror_safe(e
) );
3748 case TS_CMD_EVENTLIST
:
3749 /* List for human, Events defined for this target.
3750 * scripts/programs should use 'name cget -event NAME'
3753 target_event_action_t
*teap
;
3754 teap
= target
->event_action
;
3755 command_print( cmd_ctx
, "Event actions for target (%d) %s\n",
3756 target
->target_number
,
3758 command_print( cmd_ctx
, "%-25s | Body", "Event");
3759 command_print( cmd_ctx
, "------------------------- | ----------------------------------------");
3761 command_print( cmd_ctx
,
3763 Jim_Nvp_value2name_simple( nvp_target_event
, teap
->event
)->name
,
3764 Jim_GetString( teap
->body
, NULL
) );
3767 command_print( cmd_ctx
, "***END***");
3770 case TS_CMD_CURSTATE
:
3771 if( goi
.argc
!= 0 ){
3772 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "[no parameters]");
3775 Jim_SetResultString( goi
.interp
,
3776 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
,-1);
3778 case TS_CMD_INVOKE_EVENT
:
3779 if( goi
.argc
!= 1 ){
3780 Jim_SetResult_sprintf( goi
.interp
, "%s ?EVENTNAME?",n
->name
);
3783 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_event
, &n
);
3785 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_event
, 1 );
3788 target_handle_event( target
, n
->value
);
3794 static int target_create( Jim_GetOptInfo
*goi
)
3803 struct command_context_s
*cmd_ctx
;
3805 cmd_ctx
= Jim_GetAssocData(goi
->interp
, "context");
3806 if( goi
->argc
< 3 ){
3807 Jim_WrongNumArgs( goi
->interp
, 1, goi
->argv
, "?name? ?type? ..options...");
3812 Jim_GetOpt_Obj( goi
, &new_cmd
);
3813 /* does this command exist? */
3814 cmd
= Jim_GetCommand( goi
->interp
, new_cmd
, JIM_ERRMSG
);
3816 cp
= Jim_GetString( new_cmd
, NULL
);
3817 Jim_SetResult_sprintf(goi
->interp
, "Command/target: %s Exists", cp
);
3822 e
= Jim_GetOpt_String( goi
, &cp2
, NULL
);
3824 /* now does target type exist */
3825 for( x
= 0 ; target_types
[x
] ; x
++ ){
3826 if( 0 == strcmp( cp
, target_types
[x
]->name
) ){
3831 if( target_types
[x
] == NULL
){
3832 Jim_SetResult_sprintf( goi
->interp
, "Unknown target type %s, try one of ", cp
);
3833 for( x
= 0 ; target_types
[x
] ; x
++ ){
3834 if( target_types
[x
+1] ){
3835 Jim_AppendStrings( goi
->interp
,
3836 Jim_GetResult(goi
->interp
),
3837 target_types
[x
]->name
,
3840 Jim_AppendStrings( goi
->interp
,
3841 Jim_GetResult(goi
->interp
),
3843 target_types
[x
]->name
,NULL
);
3850 target
= calloc(1,sizeof(target_t
));
3851 /* set target number */
3852 target
->target_number
= new_target_number();
3854 /* allocate memory for each unique target type */
3855 target
->type
= (target_type_t
*)calloc(1,sizeof(target_type_t
));
3857 memcpy( target
->type
, target_types
[x
], sizeof(target_type_t
));
3859 /* will be set by "-endian" */
3860 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3862 target
->working_area
= 0x0;
3863 target
->working_area_size
= 0x0;
3864 target
->working_areas
= NULL
;
3865 target
->backup_working_area
= 0;
3867 target
->state
= TARGET_UNKNOWN
;
3868 target
->debug_reason
= DBG_REASON_UNDEFINED
;
3869 target
->reg_cache
= NULL
;
3870 target
->breakpoints
= NULL
;
3871 target
->watchpoints
= NULL
;
3872 target
->next
= NULL
;
3873 target
->arch_info
= NULL
;
3875 target
->display
= 1;
3877 /* initialize trace information */
3878 target
->trace_info
= malloc(sizeof(trace_t
));
3879 target
->trace_info
->num_trace_points
= 0;
3880 target
->trace_info
->trace_points_size
= 0;
3881 target
->trace_info
->trace_points
= NULL
;
3882 target
->trace_info
->trace_history_size
= 0;
3883 target
->trace_info
->trace_history
= NULL
;
3884 target
->trace_info
->trace_history_pos
= 0;
3885 target
->trace_info
->trace_history_overflowed
= 0;
3887 target
->dbgmsg
= NULL
;
3888 target
->dbg_msg_enabled
= 0;
3890 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3892 /* Do the rest as "configure" options */
3893 goi
->isconfigure
= 1;
3894 e
= target_configure( goi
, target
);
3896 if (target
->tap
== NULL
)
3898 Jim_SetResultString( interp
, "-chain-position required when creating target", -1);
3903 free( target
->type
);
3908 if( target
->endianness
== TARGET_ENDIAN_UNKNOWN
){
3909 /* default endian to little if not specified */
3910 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3913 /* incase variant is not set */
3914 if (!target
->variant
)
3915 target
->variant
= strdup("");
3917 /* create the target specific commands */
3918 if( target
->type
->register_commands
){
3919 (*(target
->type
->register_commands
))( cmd_ctx
);
3921 if( target
->type
->target_create
){
3922 (*(target
->type
->target_create
))( target
, goi
->interp
);
3925 /* append to end of list */
3928 tpp
= &(all_targets
);
3930 tpp
= &( (*tpp
)->next
);
3935 cp
= Jim_GetString( new_cmd
, NULL
);
3936 target
->cmd_name
= strdup(cp
);
3938 /* now - create the new target name command */
3939 e
= Jim_CreateCommand( goi
->interp
,
3942 tcl_target_func
, /* C function */
3943 target
, /* private data */
3944 NULL
); /* no del proc */
3949 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3953 struct command_context_s
*cmd_ctx
;
3957 /* TG = target generic */
3965 const char *target_cmds
[] = {
3966 "create", "types", "names", "current", "number",
3968 NULL
/* terminate */
3971 LOG_DEBUG("Target command params:");
3972 LOG_DEBUG("%s", Jim_Debug_ArgvString(interp
, argc
, argv
));
3974 cmd_ctx
= Jim_GetAssocData( interp
, "context" );
3976 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3978 if( goi
.argc
== 0 ){
3979 Jim_WrongNumArgs(interp
, 1, argv
, "missing: command ...");
3983 /* Jim_GetOpt_Debug( &goi ); */
3984 r
= Jim_GetOpt_Enum( &goi
, target_cmds
, &x
);
3991 Jim_Panic(goi
.interp
,"Why am I here?");
3993 case TG_CMD_CURRENT
:
3994 if( goi
.argc
!= 0 ){
3995 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters");
3998 Jim_SetResultString( goi
.interp
, get_current_target( cmd_ctx
)->cmd_name
, -1 );
4001 if( goi
.argc
!= 0 ){
4002 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4005 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4006 for( x
= 0 ; target_types
[x
] ; x
++ ){
4007 Jim_ListAppendElement( goi
.interp
,
4008 Jim_GetResult(goi
.interp
),
4009 Jim_NewStringObj( goi
.interp
, target_types
[x
]->name
, -1 ) );
4013 if( goi
.argc
!= 0 ){
4014 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4017 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4018 target
= all_targets
;
4020 Jim_ListAppendElement( goi
.interp
,
4021 Jim_GetResult(goi
.interp
),
4022 Jim_NewStringObj( goi
.interp
, target
->cmd_name
, -1 ) );
4023 target
= target
->next
;
4028 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "?name ... config options ...");
4031 return target_create( &goi
);
4034 if( goi
.argc
!= 1 ){
4035 Jim_SetResult_sprintf( goi
.interp
, "expected: target number ?NUMBER?");
4038 e
= Jim_GetOpt_Wide( &goi
, &w
);
4044 t
= get_target_by_num(w
);
4046 Jim_SetResult_sprintf( goi
.interp
,"Target: number %d does not exist", (int)(w
));
4049 Jim_SetResultString( goi
.interp
, t
->cmd_name
, -1 );
4053 if( goi
.argc
!= 0 ){
4054 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "<no parameters>");
4057 Jim_SetResult( goi
.interp
,
4058 Jim_NewIntObj( goi
.interp
, max_target_number()));
4074 static int fastload_num
;
4075 static struct FastLoad
*fastload
;
4077 static void free_fastload(void)
4082 for (i
=0; i
<fastload_num
; i
++)
4084 if (fastload
[i
].data
)
4085 free(fastload
[i
].data
);
4095 static int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4101 u32 max_address
=0xffffffff;
4107 duration_t duration
;
4108 char *duration_text
;
4110 if ((argc
< 1)||(argc
> 5))
4112 return ERROR_COMMAND_SYNTAX_ERROR
;
4115 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
4118 image
.base_address_set
= 1;
4119 image
.base_address
= strtoul(args
[1], NULL
, 0);
4123 image
.base_address_set
= 0;
4127 image
.start_address_set
= 0;
4131 min_address
=strtoul(args
[3], NULL
, 0);
4135 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
4138 if (min_address
>max_address
)
4140 return ERROR_COMMAND_SYNTAX_ERROR
;
4143 duration_start_measure(&duration
);
4145 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
4152 fastload_num
=image
.num_sections
;
4153 fastload
=(struct FastLoad
*)malloc(sizeof(struct FastLoad
)*image
.num_sections
);
4156 image_close(&image
);
4159 memset(fastload
, 0, sizeof(struct FastLoad
)*image
.num_sections
);
4160 for (i
= 0; i
< image
.num_sections
; i
++)
4162 buffer
= malloc(image
.sections
[i
].size
);
4165 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
4169 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
4179 /* DANGER!!! beware of unsigned comparision here!!! */
4181 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
4182 (image
.sections
[i
].base_address
<max_address
))
4184 if (image
.sections
[i
].base_address
<min_address
)
4186 /* clip addresses below */
4187 offset
+=min_address
-image
.sections
[i
].base_address
;
4191 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
4193 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
4196 fastload
[i
].address
=image
.sections
[i
].base_address
+offset
;
4197 fastload
[i
].data
=malloc(length
);
4198 if (fastload
[i
].data
==NULL
)
4203 memcpy(fastload
[i
].data
, buffer
+offset
, length
);
4204 fastload
[i
].length
=length
;
4206 image_size
+= length
;
4207 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
4213 duration_stop_measure(&duration
, &duration_text
);
4214 if (retval
==ERROR_OK
)
4216 command_print(cmd_ctx
, "Loaded %u bytes in %s", image_size
, duration_text
);
4217 command_print(cmd_ctx
, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4219 free(duration_text
);
4221 image_close(&image
);
4223 if (retval
!=ERROR_OK
)
4231 static int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4234 return ERROR_COMMAND_SYNTAX_ERROR
;
4237 LOG_ERROR("No image in memory");
4241 int ms
=timeval_ms();
4243 int retval
=ERROR_OK
;
4244 for (i
=0; i
<fastload_num
;i
++)
4246 target_t
*target
= get_current_target(cmd_ctx
);
4247 command_print(cmd_ctx
, "Write to 0x%08x, length 0x%08x", fastload
[i
].address
, fastload
[i
].length
);
4248 if (retval
==ERROR_OK
)
4250 retval
= target_write_buffer(target
, fastload
[i
].address
, fastload
[i
].length
, fastload
[i
].data
);
4252 size
+=fastload
[i
].length
;
4254 int after
=timeval_ms();
4255 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)