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 ***************************************************************************/
37 #include "target_request.h"
38 #include "time_support.h"
47 static int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 static int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 static int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 static int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 static int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 static int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 static int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 static int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 static int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 static int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 static int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 static int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 static int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 static int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 static int handle_test_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 static int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 static int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 static int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 static int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 static int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 static int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 static int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 static int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
73 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
74 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
76 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
77 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
80 extern target_type_t arm7tdmi_target
;
81 extern target_type_t arm720t_target
;
82 extern target_type_t arm9tdmi_target
;
83 extern target_type_t arm920t_target
;
84 extern target_type_t arm966e_target
;
85 extern target_type_t arm926ejs_target
;
86 extern target_type_t feroceon_target
;
87 extern target_type_t xscale_target
;
88 extern target_type_t cortexm3_target
;
89 extern target_type_t cortexa8_target
;
90 extern target_type_t arm11_target
;
91 extern target_type_t mips_m4k_target
;
92 extern target_type_t avr_target
;
94 target_type_t
*target_types
[] =
112 target_t
*all_targets
= NULL
;
113 target_event_callback_t
*target_event_callbacks
= NULL
;
114 target_timer_callback_t
*target_timer_callbacks
= NULL
;
116 const Jim_Nvp nvp_assert
[] = {
117 { .name
= "assert", NVP_ASSERT
},
118 { .name
= "deassert", NVP_DEASSERT
},
119 { .name
= "T", NVP_ASSERT
},
120 { .name
= "F", NVP_DEASSERT
},
121 { .name
= "t", NVP_ASSERT
},
122 { .name
= "f", NVP_DEASSERT
},
123 { .name
= NULL
, .value
= -1 }
126 const Jim_Nvp nvp_error_target
[] = {
127 { .value
= ERROR_TARGET_INVALID
, .name
= "err-invalid" },
128 { .value
= ERROR_TARGET_INIT_FAILED
, .name
= "err-init-failed" },
129 { .value
= ERROR_TARGET_TIMEOUT
, .name
= "err-timeout" },
130 { .value
= ERROR_TARGET_NOT_HALTED
, .name
= "err-not-halted" },
131 { .value
= ERROR_TARGET_FAILURE
, .name
= "err-failure" },
132 { .value
= ERROR_TARGET_UNALIGNED_ACCESS
, .name
= "err-unaligned-access" },
133 { .value
= ERROR_TARGET_DATA_ABORT
, .name
= "err-data-abort" },
134 { .value
= ERROR_TARGET_RESOURCE_NOT_AVAILABLE
, .name
= "err-resource-not-available" },
135 { .value
= ERROR_TARGET_TRANSLATION_FAULT
, .name
= "err-translation-fault" },
136 { .value
= ERROR_TARGET_NOT_RUNNING
, .name
= "err-not-running" },
137 { .value
= ERROR_TARGET_NOT_EXAMINED
, .name
= "err-not-examined" },
138 { .value
= -1, .name
= NULL
}
141 const char *target_strerror_safe( int err
)
145 n
= Jim_Nvp_value2name_simple( nvp_error_target
, err
);
146 if( n
->name
== NULL
){
153 const Jim_Nvp nvp_target_event
[] = {
154 { .value
= TARGET_EVENT_OLD_gdb_program_config
, .name
= "old-gdb_program_config" },
155 { .value
= TARGET_EVENT_OLD_pre_resume
, .name
= "old-pre_resume" },
157 { .value
= TARGET_EVENT_EARLY_HALTED
, .name
= "early-halted" },
158 { .value
= TARGET_EVENT_HALTED
, .name
= "halted" },
159 { .value
= TARGET_EVENT_RESUMED
, .name
= "resumed" },
160 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
161 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
163 { .name
= "gdb-start", .value
= TARGET_EVENT_GDB_START
},
164 { .name
= "gdb-end", .value
= TARGET_EVENT_GDB_END
},
166 /* historical name */
168 { .value
= TARGET_EVENT_RESET_START
, .name
= "reset-start" },
170 { .value
= TARGET_EVENT_RESET_ASSERT_PRE
, .name
= "reset-assert-pre" },
171 { .value
= TARGET_EVENT_RESET_ASSERT_POST
, .name
= "reset-assert-post" },
172 { .value
= TARGET_EVENT_RESET_DEASSERT_PRE
, .name
= "reset-deassert-pre" },
173 { .value
= TARGET_EVENT_RESET_DEASSERT_POST
, .name
= "reset-deassert-post" },
174 { .value
= TARGET_EVENT_RESET_HALT_PRE
, .name
= "reset-halt-pre" },
175 { .value
= TARGET_EVENT_RESET_HALT_POST
, .name
= "reset-halt-post" },
176 { .value
= TARGET_EVENT_RESET_WAIT_PRE
, .name
= "reset-wait-pre" },
177 { .value
= TARGET_EVENT_RESET_WAIT_POST
, .name
= "reset-wait-post" },
178 { .value
= TARGET_EVENT_RESET_INIT
, .name
= "reset-init" },
179 { .value
= TARGET_EVENT_RESET_END
, .name
= "reset-end" },
181 { .value
= TARGET_EVENT_EXAMINE_START
, .name
= "examine-start" },
182 { .value
= TARGET_EVENT_EXAMINE_END
, .name
= "examine-end" },
184 { .value
= TARGET_EVENT_DEBUG_HALTED
, .name
= "debug-halted" },
185 { .value
= TARGET_EVENT_DEBUG_RESUMED
, .name
= "debug-resumed" },
187 { .value
= TARGET_EVENT_GDB_ATTACH
, .name
= "gdb-attach" },
188 { .value
= TARGET_EVENT_GDB_DETACH
, .name
= "gdb-detach" },
190 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_START
, .name
= "gdb-flash-write-start" },
191 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_END
, .name
= "gdb-flash-write-end" },
193 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_START
, .name
= "gdb-flash-erase-start" },
194 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_END
, .name
= "gdb-flash-erase-end" },
196 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
197 { .value
= TARGET_EVENT_RESUMED
, .name
= "resume-ok" },
198 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
200 { .name
= NULL
, .value
= -1 }
203 const Jim_Nvp nvp_target_state
[] = {
204 { .name
= "unknown", .value
= TARGET_UNKNOWN
},
205 { .name
= "running", .value
= TARGET_RUNNING
},
206 { .name
= "halted", .value
= TARGET_HALTED
},
207 { .name
= "reset", .value
= TARGET_RESET
},
208 { .name
= "debug-running", .value
= TARGET_DEBUG_RUNNING
},
209 { .name
= NULL
, .value
= -1 },
212 const Jim_Nvp nvp_target_debug_reason
[] = {
213 { .name
= "debug-request" , .value
= DBG_REASON_DBGRQ
},
214 { .name
= "breakpoint" , .value
= DBG_REASON_BREAKPOINT
},
215 { .name
= "watchpoint" , .value
= DBG_REASON_WATCHPOINT
},
216 { .name
= "watchpoint-and-breakpoint", .value
= DBG_REASON_WPTANDBKPT
},
217 { .name
= "single-step" , .value
= DBG_REASON_SINGLESTEP
},
218 { .name
= "target-not-halted" , .value
= DBG_REASON_NOTHALTED
},
219 { .name
= "undefined" , .value
= DBG_REASON_UNDEFINED
},
220 { .name
= NULL
, .value
= -1 },
223 const Jim_Nvp nvp_target_endian
[] = {
224 { .name
= "big", .value
= TARGET_BIG_ENDIAN
},
225 { .name
= "little", .value
= TARGET_LITTLE_ENDIAN
},
226 { .name
= "be", .value
= TARGET_BIG_ENDIAN
},
227 { .name
= "le", .value
= TARGET_LITTLE_ENDIAN
},
228 { .name
= NULL
, .value
= -1 },
231 const Jim_Nvp nvp_reset_modes
[] = {
232 { .name
= "unknown", .value
= RESET_UNKNOWN
},
233 { .name
= "run" , .value
= RESET_RUN
},
234 { .name
= "halt" , .value
= RESET_HALT
},
235 { .name
= "init" , .value
= RESET_INIT
},
236 { .name
= NULL
, .value
= -1 },
239 static int max_target_number(void)
247 if( x
< t
->target_number
){
248 x
= (t
->target_number
)+1;
255 /* determine the number of the new target */
256 static int new_target_number(void)
261 /* number is 0 based */
265 if( x
< t
->target_number
){
266 x
= t
->target_number
;
273 static int target_continous_poll
= 1;
275 /* read a u32 from a buffer in target memory endianness */
276 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
278 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
279 return le_to_h_u32(buffer
);
281 return be_to_h_u32(buffer
);
284 /* read a u16 from a buffer in target memory endianness */
285 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
287 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
288 return le_to_h_u16(buffer
);
290 return be_to_h_u16(buffer
);
293 /* read a u8 from a buffer in target memory endianness */
294 u8
target_buffer_get_u8(target_t
*target
, u8
*buffer
)
296 return *buffer
& 0x0ff;
299 /* write a u32 to a buffer in target memory endianness */
300 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
302 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
303 h_u32_to_le(buffer
, value
);
305 h_u32_to_be(buffer
, value
);
308 /* write a u16 to a buffer in target memory endianness */
309 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
311 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
312 h_u16_to_le(buffer
, value
);
314 h_u16_to_be(buffer
, value
);
317 /* write a u8 to a buffer in target memory endianness */
318 void target_buffer_set_u8(target_t
*target
, u8
*buffer
, u8 value
)
323 /* return a pointer to a configured target; id is name or number */
324 target_t
*get_target(const char *id
)
330 /* try as tcltarget name */
331 for (target
= all_targets
; target
; target
= target
->next
) {
332 if (target
->cmd_name
== NULL
)
334 if (strcmp(id
, target
->cmd_name
) == 0)
338 /* no match, try as number */
339 num
= strtoul(id
, &endptr
, 0);
343 for (target
= all_targets
; target
; target
= target
->next
) {
344 if (target
->target_number
== num
)
351 /* returns a pointer to the n-th configured target */
352 static target_t
*get_target_by_num(int num
)
354 target_t
*target
= all_targets
;
357 if( target
->target_number
== num
){
360 target
= target
->next
;
366 int get_num_by_target(target_t
*query_target
)
368 return query_target
->target_number
;
371 target_t
* get_current_target(command_context_t
*cmd_ctx
)
373 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
377 LOG_ERROR("BUG: current_target out of bounds");
384 int target_poll(struct target_s
*target
)
386 /* We can't poll until after examine */
387 if (!target
->type
->examined
)
389 /* Fail silently lest we pollute the log */
392 return target
->type
->poll(target
);
395 int target_halt(struct target_s
*target
)
397 /* We can't poll until after examine */
398 if (!target
->type
->examined
)
400 LOG_ERROR("Target not examined yet");
403 return target
->type
->halt(target
);
406 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
410 /* We can't poll until after examine */
411 if (!target
->type
->examined
)
413 LOG_ERROR("Target not examined yet");
417 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
418 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
421 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
427 int target_process_reset(struct command_context_s
*cmd_ctx
, enum target_reset_mode reset_mode
)
432 n
= Jim_Nvp_value2name_simple( nvp_reset_modes
, reset_mode
);
433 if( n
->name
== NULL
){
434 LOG_ERROR("invalid reset mode");
438 sprintf( buf
, "ocd_process_reset %s", n
->name
);
439 retval
= Jim_Eval( interp
, buf
);
441 if(retval
!= JIM_OK
) {
442 Jim_PrintErrorMessage(interp
);
446 /* We want any events to be processed before the prompt */
447 retval
= target_call_timer_callbacks_now();
452 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
458 static int default_mmu(struct target_s
*target
, int *enabled
)
464 static int default_examine(struct target_s
*target
)
466 target
->type
->examined
= 1;
470 /* Targets that correctly implement init+examine, i.e.
471 * no communication with target during init:
475 int target_examine(void)
477 int retval
= ERROR_OK
;
478 target_t
*target
= all_targets
;
481 if ((retval
= target
->type
->examine(target
))!=ERROR_OK
)
483 target
= target
->next
;
488 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
490 if (!target
->type
->examined
)
492 LOG_ERROR("Target not examined yet");
495 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
498 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
500 if (!target
->type
->examined
)
502 LOG_ERROR("Target not examined yet");
505 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
508 static int target_soft_reset_halt_imp(struct target_s
*target
)
510 if (!target
->type
->examined
)
512 LOG_ERROR("Target not examined yet");
515 return target
->type
->soft_reset_halt_imp(target
);
518 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
)
520 if (!target
->type
->examined
)
522 LOG_ERROR("Target not examined yet");
525 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
);
528 int target_init(struct command_context_s
*cmd_ctx
)
530 target_t
*target
= all_targets
;
535 target
->type
->examined
= 0;
536 if (target
->type
->examine
== NULL
)
538 target
->type
->examine
= default_examine
;
541 if ((retval
= target
->type
->init_target(cmd_ctx
, target
)) != ERROR_OK
)
543 LOG_ERROR("target '%s' init failed", target
->type
->name
);
547 /* Set up default functions if none are provided by target */
548 if (target
->type
->virt2phys
== NULL
)
550 target
->type
->virt2phys
= default_virt2phys
;
552 target
->type
->virt2phys
= default_virt2phys
;
553 /* a non-invasive way(in terms of patches) to add some code that
554 * runs before the type->write/read_memory implementation
556 target
->type
->write_memory_imp
= target
->type
->write_memory
;
557 target
->type
->write_memory
= target_write_memory_imp
;
558 target
->type
->read_memory_imp
= target
->type
->read_memory
;
559 target
->type
->read_memory
= target_read_memory_imp
;
560 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
561 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
562 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
563 target
->type
->run_algorithm
= target_run_algorithm_imp
;
565 if (target
->type
->mmu
== NULL
)
567 target
->type
->mmu
= default_mmu
;
569 target
= target
->next
;
574 if((retval
= target_register_user_commands(cmd_ctx
)) != ERROR_OK
)
576 if((retval
= target_register_timer_callback(handle_target
, 100, 1, NULL
)) != ERROR_OK
)
583 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
585 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
587 if (callback
== NULL
)
589 return ERROR_INVALID_ARGUMENTS
;
594 while ((*callbacks_p
)->next
)
595 callbacks_p
= &((*callbacks_p
)->next
);
596 callbacks_p
= &((*callbacks_p
)->next
);
599 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
600 (*callbacks_p
)->callback
= callback
;
601 (*callbacks_p
)->priv
= priv
;
602 (*callbacks_p
)->next
= NULL
;
607 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
609 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
612 if (callback
== NULL
)
614 return ERROR_INVALID_ARGUMENTS
;
619 while ((*callbacks_p
)->next
)
620 callbacks_p
= &((*callbacks_p
)->next
);
621 callbacks_p
= &((*callbacks_p
)->next
);
624 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
625 (*callbacks_p
)->callback
= callback
;
626 (*callbacks_p
)->periodic
= periodic
;
627 (*callbacks_p
)->time_ms
= time_ms
;
629 gettimeofday(&now
, NULL
);
630 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
631 time_ms
-= (time_ms
% 1000);
632 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
633 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
635 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
636 (*callbacks_p
)->when
.tv_sec
+= 1;
639 (*callbacks_p
)->priv
= priv
;
640 (*callbacks_p
)->next
= NULL
;
645 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
647 target_event_callback_t
**p
= &target_event_callbacks
;
648 target_event_callback_t
*c
= target_event_callbacks
;
650 if (callback
== NULL
)
652 return ERROR_INVALID_ARGUMENTS
;
657 target_event_callback_t
*next
= c
->next
;
658 if ((c
->callback
== callback
) && (c
->priv
== priv
))
672 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
674 target_timer_callback_t
**p
= &target_timer_callbacks
;
675 target_timer_callback_t
*c
= target_timer_callbacks
;
677 if (callback
== NULL
)
679 return ERROR_INVALID_ARGUMENTS
;
684 target_timer_callback_t
*next
= c
->next
;
685 if ((c
->callback
== callback
) && (c
->priv
== priv
))
699 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
701 target_event_callback_t
*callback
= target_event_callbacks
;
702 target_event_callback_t
*next_callback
;
704 if (event
== TARGET_EVENT_HALTED
)
706 /* execute early halted first */
707 target_call_event_callbacks(target
, TARGET_EVENT_EARLY_HALTED
);
710 LOG_DEBUG("target event %i (%s)",
712 Jim_Nvp_value2name_simple( nvp_target_event
, event
)->name
);
714 target_handle_event( target
, event
);
718 next_callback
= callback
->next
;
719 callback
->callback(target
, event
, callback
->priv
);
720 callback
= next_callback
;
726 static int target_call_timer_callbacks_check_time(int checktime
)
728 target_timer_callback_t
*callback
= target_timer_callbacks
;
729 target_timer_callback_t
*next_callback
;
734 gettimeofday(&now
, NULL
);
738 next_callback
= callback
->next
;
740 if ((!checktime
&&callback
->periodic
)||
741 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
742 || (now
.tv_sec
> callback
->when
.tv_sec
)))
744 if(callback
->callback
!= NULL
)
746 callback
->callback(callback
->priv
);
747 if (callback
->periodic
)
749 int time_ms
= callback
->time_ms
;
750 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
751 time_ms
-= (time_ms
% 1000);
752 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
753 if (callback
->when
.tv_usec
> 1000000)
755 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
756 callback
->when
.tv_sec
+= 1;
762 if((retval
= target_unregister_timer_callback(callback
->callback
, callback
->priv
)) != ERROR_OK
)
768 callback
= next_callback
;
774 int target_call_timer_callbacks(void)
776 return target_call_timer_callbacks_check_time(1);
779 /* invoke periodic callbacks immediately */
780 int target_call_timer_callbacks_now(void)
782 return target_call_timer_callbacks_check_time(0);
785 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
787 working_area_t
*c
= target
->working_areas
;
788 working_area_t
*new_wa
= NULL
;
790 /* Reevaluate working area address based on MMU state*/
791 if (target
->working_areas
== NULL
)
795 retval
= target
->type
->mmu(target
, &enabled
);
796 if (retval
!= ERROR_OK
)
802 target
->working_area
= target
->working_area_virt
;
806 target
->working_area
= target
->working_area_phys
;
810 /* only allocate multiples of 4 byte */
813 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
814 size
= CEIL(size
, 4);
817 /* see if there's already a matching working area */
820 if ((c
->free
) && (c
->size
== size
))
828 /* if not, allocate a new one */
831 working_area_t
**p
= &target
->working_areas
;
832 u32 first_free
= target
->working_area
;
833 u32 free_size
= target
->working_area_size
;
835 LOG_DEBUG("allocating new working area");
837 c
= target
->working_areas
;
840 first_free
+= c
->size
;
841 free_size
-= c
->size
;
846 if (free_size
< size
)
848 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
849 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
852 new_wa
= malloc(sizeof(working_area_t
));
855 new_wa
->address
= first_free
;
857 if (target
->backup_working_area
)
860 new_wa
->backup
= malloc(new_wa
->size
);
861 if((retval
= target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
)) != ERROR_OK
)
863 free(new_wa
->backup
);
870 new_wa
->backup
= NULL
;
873 /* put new entry in list */
877 /* mark as used, and return the new (reused) area */
887 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
892 if (restore
&&target
->backup_working_area
)
895 if((retval
= target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
)) != ERROR_OK
)
901 /* mark user pointer invalid */
908 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
910 return target_free_working_area_restore(target
, area
, 1);
913 /* free resources and restore memory, if restoring memory fails,
914 * free up resources anyway
916 void target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
918 working_area_t
*c
= target
->working_areas
;
922 working_area_t
*next
= c
->next
;
923 target_free_working_area_restore(target
, c
, restore
);
933 target
->working_areas
= NULL
;
936 void target_free_all_working_areas(struct target_s
*target
)
938 target_free_all_working_areas_restore(target
, 1);
941 int target_register_commands(struct command_context_s
*cmd_ctx
)
944 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)");
949 register_jim(cmd_ctx
, "target", jim_target
, "configure target" );
954 int target_arch_state(struct target_s
*target
)
959 LOG_USER("No target has been configured");
963 LOG_USER("target state: %s",
964 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
);
966 if (target
->state
!=TARGET_HALTED
)
969 retval
=target
->type
->arch_state(target
);
973 /* Single aligned words are guaranteed to use 16 or 32 bit access
974 * mode respectively, otherwise data is handled as quickly as
977 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
980 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
982 if (!target
->type
->examined
)
984 LOG_ERROR("Target not examined yet");
992 if ((address
+ size
- 1) < address
)
994 /* GDB can request this when e.g. PC is 0xfffffffc*/
995 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
999 if (((address
% 2) == 0) && (size
== 2))
1001 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
1004 /* handle unaligned head bytes */
1007 u32 unaligned
= 4 - (address
% 4);
1009 if (unaligned
> size
)
1012 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1015 buffer
+= unaligned
;
1016 address
+= unaligned
;
1020 /* handle aligned words */
1023 int aligned
= size
- (size
% 4);
1025 /* use bulk writes above a certain limit. This may have to be changed */
1028 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1033 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1042 /* handle tail writes of less than 4 bytes */
1045 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1052 /* Single aligned words are guaranteed to use 16 or 32 bit access
1053 * mode respectively, otherwise data is handled as quickly as
1056 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1059 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1061 if (!target
->type
->examined
)
1063 LOG_ERROR("Target not examined yet");
1071 if ((address
+ size
- 1) < address
)
1073 /* GDB can request this when e.g. PC is 0xfffffffc*/
1074 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
1078 if (((address
% 2) == 0) && (size
== 2))
1080 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1083 /* handle unaligned head bytes */
1086 u32 unaligned
= 4 - (address
% 4);
1088 if (unaligned
> size
)
1091 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1094 buffer
+= unaligned
;
1095 address
+= unaligned
;
1099 /* handle aligned words */
1102 int aligned
= size
- (size
% 4);
1104 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1112 /* handle tail writes of less than 4 bytes */
1115 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1122 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1128 if (!target
->type
->examined
)
1130 LOG_ERROR("Target not examined yet");
1134 if ((retval
= target
->type
->checksum_memory(target
, address
,
1135 size
, &checksum
)) != ERROR_OK
)
1137 buffer
= malloc(size
);
1140 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1141 return ERROR_INVALID_ARGUMENTS
;
1143 retval
= target_read_buffer(target
, address
, size
, buffer
);
1144 if (retval
!= ERROR_OK
)
1150 /* convert to target endianess */
1151 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1154 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1155 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1158 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1167 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1170 if (!target
->type
->examined
)
1172 LOG_ERROR("Target not examined yet");
1176 if (target
->type
->blank_check_memory
== 0)
1177 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1179 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1184 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1187 if (!target
->type
->examined
)
1189 LOG_ERROR("Target not examined yet");
1193 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1195 if (retval
== ERROR_OK
)
1197 *value
= target_buffer_get_u32(target
, value_buf
);
1198 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1203 LOG_DEBUG("address: 0x%8.8x failed", address
);
1209 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1212 if (!target
->type
->examined
)
1214 LOG_ERROR("Target not examined yet");
1218 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1220 if (retval
== ERROR_OK
)
1222 *value
= target_buffer_get_u16(target
, value_buf
);
1223 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1228 LOG_DEBUG("address: 0x%8.8x failed", address
);
1234 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1236 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1237 if (!target
->type
->examined
)
1239 LOG_ERROR("Target not examined yet");
1243 if (retval
== ERROR_OK
)
1245 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1250 LOG_DEBUG("address: 0x%8.8x failed", address
);
1256 int target_write_u32(struct target_s
*target
, u32 address
, u32 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_u32(target
, value_buf
, value
);
1269 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1271 LOG_DEBUG("failed: %i", retval
);
1277 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1281 if (!target
->type
->examined
)
1283 LOG_ERROR("Target not examined yet");
1287 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1289 target_buffer_set_u16(target
, value_buf
, value
);
1290 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1292 LOG_DEBUG("failed: %i", retval
);
1298 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1301 if (!target
->type
->examined
)
1303 LOG_ERROR("Target not examined yet");
1307 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1309 if ((retval
= target
->type
->write_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1311 LOG_DEBUG("failed: %i", retval
);
1317 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1319 int retval
= ERROR_OK
;
1322 /* script procedures */
1323 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "profiling samples the CPU PC");
1324 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing <ARRAYNAME> <WIDTH=32/16/8> <ADDRESS> <COUNT>");
1325 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values <ARRAYNAME> <WIDTH=32/16/8> <ADDRESS> <COUNT>");
1327 register_command(cmd_ctx
, NULL
, "fast_load_image", handle_fast_load_image_command
, COMMAND_ANY
,
1328 "same args as load_image, image stored in memory - mainly for profiling purposes");
1330 register_command(cmd_ctx
, NULL
, "fast_load", handle_fast_load_command
, COMMAND_ANY
,
1331 "loads active fast load image to current target - mainly for profiling purposes");
1334 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "translate a virtual address into a physical address");
1335 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, "display or set a register");
1336 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1337 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1338 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1339 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1340 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1341 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init] - default is run");
1342 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1344 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1345 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1346 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1348 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1349 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1350 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1352 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1353 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1354 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1355 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1357 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]");
1358 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1359 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1360 register_command(cmd_ctx
, NULL
, "test_image", handle_test_image_command
, COMMAND_EXEC
, "test_image <file> [offset] [type]");
1362 if((retval
= target_request_register_commands(cmd_ctx
)) != ERROR_OK
)
1364 if((retval
= trace_register_commands(cmd_ctx
)) != ERROR_OK
)
1370 static int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1372 target_t
*target
= all_targets
;
1376 target
= get_target(args
[0]);
1377 if (target
== NULL
) {
1378 command_print(cmd_ctx
,"Target: %s is unknown, try one of:\n", args
[0] );
1382 cmd_ctx
->current_target
= target
->target_number
;
1387 target
= all_targets
;
1388 command_print(cmd_ctx
, " CmdName Type Endian AbsChainPos Name State ");
1389 command_print(cmd_ctx
, "-- ---------- ---------- ---------- ----------- ------------- ----------");
1392 /* XX: abcdefghij abcdefghij abcdefghij abcdefghij */
1393 command_print(cmd_ctx
, "%2d: %-10s %-10s %-10s %10d %14s %s",
1394 target
->target_number
,
1397 Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
)->name
,
1398 target
->tap
->abs_chain_position
,
1399 target
->tap
->dotted_name
,
1400 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
1401 target
= target
->next
;
1407 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1409 static int powerDropout
;
1410 static int srstAsserted
;
1412 static int runPowerRestore
;
1413 static int runPowerDropout
;
1414 static int runSrstAsserted
;
1415 static int runSrstDeasserted
;
1417 static int sense_handler(void)
1419 static int prevSrstAsserted
= 0;
1420 static int prevPowerdropout
= 0;
1423 if ((retval
=jtag_power_dropout(&powerDropout
))!=ERROR_OK
)
1427 powerRestored
= prevPowerdropout
&& !powerDropout
;
1430 runPowerRestore
= 1;
1433 long long current
= timeval_ms();
1434 static long long lastPower
= 0;
1435 int waitMore
= lastPower
+ 2000 > current
;
1436 if (powerDropout
&& !waitMore
)
1438 runPowerDropout
= 1;
1439 lastPower
= current
;
1442 if ((retval
=jtag_srst_asserted(&srstAsserted
))!=ERROR_OK
)
1446 srstDeasserted
= prevSrstAsserted
&& !srstAsserted
;
1448 static long long lastSrst
= 0;
1449 waitMore
= lastSrst
+ 2000 > current
;
1450 if (srstDeasserted
&& !waitMore
)
1452 runSrstDeasserted
= 1;
1456 if (!prevSrstAsserted
&& srstAsserted
)
1458 runSrstAsserted
= 1;
1461 prevSrstAsserted
= srstAsserted
;
1462 prevPowerdropout
= powerDropout
;
1464 if (srstDeasserted
|| powerRestored
)
1466 /* Other than logging the event we can't do anything here.
1467 * Issuing a reset is a particularly bad idea as we might
1468 * be inside a reset already.
1475 /* process target state changes */
1476 int handle_target(void *priv
)
1478 int retval
= ERROR_OK
;
1480 /* we do not want to recurse here... */
1481 static int recursive
= 0;
1486 /* danger! running these procedures can trigger srst assertions and power dropouts.
1487 * We need to avoid an infinite loop/recursion here and we do that by
1488 * clearing the flags after running these events.
1490 int did_something
= 0;
1491 if (runSrstAsserted
)
1493 Jim_Eval( interp
, "srst_asserted");
1496 if (runSrstDeasserted
)
1498 Jim_Eval( interp
, "srst_deasserted");
1501 if (runPowerDropout
)
1503 Jim_Eval( interp
, "power_dropout");
1506 if (runPowerRestore
)
1508 Jim_Eval( interp
, "power_restore");
1514 /* clear detect flags */
1518 /* clear action flags */
1521 runSrstDeasserted
=0;
1528 target_t
*target
= all_targets
;
1533 /* only poll target if we've got power and srst isn't asserted */
1534 if (target_continous_poll
&&!powerDropout
&&!srstAsserted
)
1536 /* polling may fail silently until the target has been examined */
1537 if((retval
= target_poll(target
)) != ERROR_OK
)
1541 target
= target
->next
;
1547 static int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1556 target
= get_current_target(cmd_ctx
);
1558 /* list all available registers for the current target */
1561 reg_cache_t
*cache
= target
->reg_cache
;
1567 for (i
= 0; i
< cache
->num_regs
; i
++)
1569 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1570 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
);
1573 cache
= cache
->next
;
1579 /* access a single register by its ordinal number */
1580 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1582 int num
= strtoul(args
[0], NULL
, 0);
1583 reg_cache_t
*cache
= target
->reg_cache
;
1589 for (i
= 0; i
< cache
->num_regs
; i
++)
1593 reg
= &cache
->reg_list
[i
];
1599 cache
= cache
->next
;
1604 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1607 } else /* access a single register by its name */
1609 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1613 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1618 /* display a register */
1619 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1621 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1624 if (reg
->valid
== 0)
1626 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1627 arch_type
->get(reg
);
1629 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1630 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1635 /* set register value */
1638 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1639 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1641 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1642 arch_type
->set(reg
, buf
);
1644 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1645 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1653 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1658 static int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1660 int retval
= ERROR_OK
;
1661 target_t
*target
= get_current_target(cmd_ctx
);
1665 if((retval
= target_poll(target
)) != ERROR_OK
)
1667 if((retval
= target_arch_state(target
)) != ERROR_OK
)
1673 if (strcmp(args
[0], "on") == 0)
1675 target_continous_poll
= 1;
1677 else if (strcmp(args
[0], "off") == 0)
1679 target_continous_poll
= 0;
1683 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1687 return ERROR_COMMAND_SYNTAX_ERROR
;
1693 static int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1701 ms
= strtoul(args
[0], &end
, 0) * 1000;
1704 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1708 target_t
*target
= get_current_target(cmd_ctx
);
1710 return target_wait_state(target
, TARGET_HALTED
, ms
);
1713 /* wait for target state to change. The trick here is to have a low
1714 * latency for short waits and not to suck up all the CPU time
1717 * After 500ms, keep_alive() is invoked
1719 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1722 long long then
=0, cur
;
1727 if ((retval
=target_poll(target
))!=ERROR_OK
)
1729 if (target
->state
== state
)
1737 then
= timeval_ms();
1738 LOG_DEBUG("waiting for target %s...",
1739 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1749 LOG_ERROR("timed out while waiting for target %s",
1750 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1758 static int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1761 target_t
*target
= get_current_target(cmd_ctx
);
1765 if ((retval
= target_halt(target
)) != ERROR_OK
)
1775 wait
= strtoul(args
[0], &end
, 0);
1780 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1783 static int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1785 target_t
*target
= get_current_target(cmd_ctx
);
1787 LOG_USER("requesting target halt and executing a soft reset");
1789 target
->type
->soft_reset_halt(target
);
1794 static int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1797 enum target_reset_mode reset_mode
= RESET_RUN
;
1801 n
= Jim_Nvp_name2value_simple( nvp_reset_modes
, args
[0] );
1802 if( (n
->name
== NULL
) || (n
->value
== RESET_UNKNOWN
) ){
1803 return ERROR_COMMAND_SYNTAX_ERROR
;
1805 reset_mode
= n
->value
;
1808 /* reset *all* targets */
1809 return target_process_reset(cmd_ctx
, reset_mode
);
1813 static int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1816 target_t
*target
= get_current_target(cmd_ctx
);
1818 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1821 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1823 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1826 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
1832 static int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1834 target_t
*target
= get_current_target(cmd_ctx
);
1839 return target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1842 return target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1847 static int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1849 const int line_bytecnt
= 32;
1862 target_t
*target
= get_current_target(cmd_ctx
);
1868 count
= strtoul(args
[1], NULL
, 0);
1870 address
= strtoul(args
[0], NULL
, 0);
1875 size
= 4; line_modulo
= line_bytecnt
/ 4;
1878 size
= 2; line_modulo
= line_bytecnt
/ 2;
1881 size
= 1; line_modulo
= line_bytecnt
/ 1;
1887 buffer
= calloc(count
, size
);
1888 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1889 if (retval
== ERROR_OK
)
1893 for (i
= 0; i
< count
; i
++)
1895 if (i
%line_modulo
== 0)
1896 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1901 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1904 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1907 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1911 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1913 command_print(cmd_ctx
, "%s", output
);
1924 static int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1931 target_t
*target
= get_current_target(cmd_ctx
);
1934 if ((argc
< 2) || (argc
> 3))
1935 return ERROR_COMMAND_SYNTAX_ERROR
;
1937 address
= strtoul(args
[0], NULL
, 0);
1938 value
= strtoul(args
[1], NULL
, 0);
1940 count
= strtoul(args
[2], NULL
, 0);
1946 target_buffer_set_u32(target
, value_buf
, value
);
1950 target_buffer_set_u16(target
, value_buf
, value
);
1954 value_buf
[0] = value
;
1957 return ERROR_COMMAND_SYNTAX_ERROR
;
1959 for (i
=0; i
<count
; i
++)
1965 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1968 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1971 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1978 if (retval
!=ERROR_OK
)
1988 static int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1994 u32 max_address
=0xffffffff;
1996 int retval
, retvaltemp
;
2000 duration_t duration
;
2001 char *duration_text
;
2003 target_t
*target
= get_current_target(cmd_ctx
);
2005 if ((argc
< 1)||(argc
> 5))
2007 return ERROR_COMMAND_SYNTAX_ERROR
;
2010 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2013 image
.base_address_set
= 1;
2014 image
.base_address
= strtoul(args
[1], NULL
, 0);
2018 image
.base_address_set
= 0;
2022 image
.start_address_set
= 0;
2026 min_address
=strtoul(args
[3], NULL
, 0);
2030 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
2033 if (min_address
>max_address
)
2035 return ERROR_COMMAND_SYNTAX_ERROR
;
2038 duration_start_measure(&duration
);
2040 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2047 for (i
= 0; i
< image
.num_sections
; i
++)
2049 buffer
= malloc(image
.sections
[i
].size
);
2052 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2056 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2065 /* DANGER!!! beware of unsigned comparision here!!! */
2067 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
2068 (image
.sections
[i
].base_address
<max_address
))
2070 if (image
.sections
[i
].base_address
<min_address
)
2072 /* clip addresses below */
2073 offset
+=min_address
-image
.sections
[i
].base_address
;
2077 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
2079 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2082 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2087 image_size
+= length
;
2088 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2094 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2096 image_close(&image
);
2100 if (retval
==ERROR_OK
)
2102 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2104 free(duration_text
);
2106 image_close(&image
);
2112 static int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2119 int retval
=ERROR_OK
, retvaltemp
;
2121 duration_t duration
;
2122 char *duration_text
;
2124 target_t
*target
= get_current_target(cmd_ctx
);
2128 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2132 address
= strtoul(args
[1], NULL
, 0);
2133 size
= strtoul(args
[2], NULL
, 0);
2135 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2140 duration_start_measure(&duration
);
2145 u32 this_run_size
= (size
> 560) ? 560 : size
;
2147 retval
= target_read_buffer(target
, address
, this_run_size
, buffer
);
2148 if (retval
!= ERROR_OK
)
2153 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2154 if (retval
!= ERROR_OK
)
2159 size
-= this_run_size
;
2160 address
+= this_run_size
;
2163 if((retvaltemp
= fileio_close(&fileio
)) != ERROR_OK
)
2166 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2169 if (retval
==ERROR_OK
)
2171 command_print(cmd_ctx
, "dumped %lld byte in %s",
2172 fileio
.size
, duration_text
);
2173 free(duration_text
);
2179 static int handle_verify_image_command_internal(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, int verify
)
2185 int retval
, retvaltemp
;
2187 u32 mem_checksum
= 0;
2191 duration_t duration
;
2192 char *duration_text
;
2194 target_t
*target
= get_current_target(cmd_ctx
);
2198 return ERROR_COMMAND_SYNTAX_ERROR
;
2203 LOG_ERROR("no target selected");
2207 duration_start_measure(&duration
);
2211 image
.base_address_set
= 1;
2212 image
.base_address
= strtoul(args
[1], NULL
, 0);
2216 image
.base_address_set
= 0;
2217 image
.base_address
= 0x0;
2220 image
.start_address_set
= 0;
2222 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2229 for (i
= 0; i
< image
.num_sections
; i
++)
2231 buffer
= malloc(image
.sections
[i
].size
);
2234 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2237 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2245 /* calculate checksum of image */
2246 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2248 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2249 if( retval
!= ERROR_OK
)
2255 if( checksum
!= mem_checksum
)
2257 /* failed crc checksum, fall back to a binary compare */
2260 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2262 data
= (u8
*)malloc(buf_cnt
);
2264 /* Can we use 32bit word accesses? */
2266 int count
= buf_cnt
;
2267 if ((count
% 4) == 0)
2272 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2273 if (retval
== ERROR_OK
)
2276 for (t
= 0; t
< buf_cnt
; t
++)
2278 if (data
[t
] != buffer
[t
])
2280 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
]);
2297 command_print(cmd_ctx
, "address 0x%08x length 0x%08x", image
.sections
[i
].base_address
, buf_cnt
);
2301 image_size
+= buf_cnt
;
2305 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2307 image_close(&image
);
2311 if (retval
==ERROR_OK
)
2313 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2315 free(duration_text
);
2317 image_close(&image
);
2322 static int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2324 return handle_verify_image_command_internal(cmd_ctx
, cmd
, args
, argc
, 1);
2327 static int handle_test_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2329 return handle_verify_image_command_internal(cmd_ctx
, cmd
, args
, argc
, 0);
2332 static int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2335 target_t
*target
= get_current_target(cmd_ctx
);
2339 breakpoint_t
*breakpoint
= target
->breakpoints
;
2343 if (breakpoint
->type
== BKPT_SOFT
)
2345 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2346 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2351 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2353 breakpoint
= breakpoint
->next
;
2361 length
= strtoul(args
[1], NULL
, 0);
2364 if (strcmp(args
[2], "hw") == 0)
2367 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2369 LOG_ERROR("Failure setting breakpoints");
2373 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8lx",
2374 strtoul(args
[0], NULL
, 0));
2379 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2385 static int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2387 target_t
*target
= get_current_target(cmd_ctx
);
2390 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2395 static int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2397 target_t
*target
= get_current_target(cmd_ctx
);
2402 watchpoint_t
*watchpoint
= target
->watchpoints
;
2406 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
);
2407 watchpoint
= watchpoint
->next
;
2412 enum watchpoint_rw type
= WPT_ACCESS
;
2413 u32 data_value
= 0x0;
2414 u32 data_mask
= 0xffffffff;
2430 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2436 data_value
= strtoul(args
[3], NULL
, 0);
2440 data_mask
= strtoul(args
[4], NULL
, 0);
2443 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2444 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2446 LOG_ERROR("Failure setting breakpoints");
2451 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2457 static int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2459 target_t
*target
= get_current_target(cmd_ctx
);
2462 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2467 static int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2470 target_t
*target
= get_current_target(cmd_ctx
);
2476 return ERROR_COMMAND_SYNTAX_ERROR
;
2478 va
= strtoul(args
[0], NULL
, 0);
2480 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2481 if (retval
== ERROR_OK
)
2483 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2487 /* lower levels will have logged a detailed error which is
2488 * forwarded to telnet/GDB session.
2494 static void writeData(FILE *f
, const void *data
, size_t len
)
2496 size_t written
= fwrite(data
, len
, 1, f
);
2498 LOG_ERROR("failed to write %zu bytes: %s", len
, strerror(errno
));
2501 static void writeLong(FILE *f
, int l
)
2506 char c
=(l
>>(i
*8))&0xff;
2507 writeData(f
, &c
, 1);
2512 static void writeString(FILE *f
, char *s
)
2514 writeData(f
, s
, strlen(s
));
2517 /* Dump a gmon.out histogram file. */
2518 static void writeGmon(u32
*samples
, u32 sampleNum
, char *filename
)
2521 FILE *f
=fopen(filename
, "w");
2524 writeString(f
, "gmon");
2525 writeLong(f
, 0x00000001); /* Version */
2526 writeLong(f
, 0); /* padding */
2527 writeLong(f
, 0); /* padding */
2528 writeLong(f
, 0); /* padding */
2530 u8 zero
= 0; /* GMON_TAG_TIME_HIST */
2531 writeData(f
, &zero
, 1);
2533 /* figure out bucket size */
2536 for (i
=0; i
<sampleNum
; i
++)
2548 int addressSpace
=(max
-min
+1);
2550 static const u32 maxBuckets
= 256 * 1024; /* maximum buckets. */
2551 u32 length
= addressSpace
;
2552 if (length
> maxBuckets
)
2556 int *buckets
=malloc(sizeof(int)*length
);
2562 memset(buckets
, 0, sizeof(int)*length
);
2563 for (i
=0; i
<sampleNum
;i
++)
2565 u32 address
=samples
[i
];
2566 long long a
=address
-min
;
2567 long long b
=length
-1;
2568 long long c
=addressSpace
-1;
2569 int index
=(a
*b
)/c
; /* danger!!!! int32 overflows */
2573 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2574 writeLong(f
, min
); /* low_pc */
2575 writeLong(f
, max
); /* high_pc */
2576 writeLong(f
, length
); /* # of samples */
2577 writeLong(f
, 64000000); /* 64MHz */
2578 writeString(f
, "seconds");
2579 for (i
=0; i
<(15-strlen("seconds")); i
++)
2580 writeData(f
, &zero
, 1);
2581 writeString(f
, "s");
2583 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2585 char *data
=malloc(2*length
);
2588 for (i
=0; i
<length
;i
++)
2597 data
[i
*2+1]=(val
>>8)&0xff;
2600 writeData(f
, data
, length
* 2);
2610 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2611 static int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2613 target_t
*target
= get_current_target(cmd_ctx
);
2614 struct timeval timeout
, now
;
2616 gettimeofday(&timeout
, NULL
);
2619 return ERROR_COMMAND_SYNTAX_ERROR
;
2622 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2628 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2630 static const int maxSample
=10000;
2631 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2636 int retval
=ERROR_OK
;
2637 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2638 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2642 target_poll(target
);
2643 if (target
->state
== TARGET_HALTED
)
2645 u32 t
=*((u32
*)reg
->value
);
2646 samples
[numSamples
++]=t
;
2647 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2648 target_poll(target
);
2649 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2650 } else if (target
->state
== TARGET_RUNNING
)
2652 /* We want to quickly sample the PC. */
2653 if((retval
= target_halt(target
)) != ERROR_OK
)
2660 command_print(cmd_ctx
, "Target not halted or running");
2664 if (retval
!=ERROR_OK
)
2669 gettimeofday(&now
, NULL
);
2670 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2672 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2673 if((retval
= target_poll(target
)) != ERROR_OK
)
2678 if (target
->state
== TARGET_HALTED
)
2680 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2682 if((retval
= target_poll(target
)) != ERROR_OK
)
2687 writeGmon(samples
, numSamples
, args
[1]);
2688 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2697 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2700 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2703 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2707 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2708 valObjPtr
= Jim_NewIntObj(interp
, val
);
2709 if (!nameObjPtr
|| !valObjPtr
)
2715 Jim_IncrRefCount(nameObjPtr
);
2716 Jim_IncrRefCount(valObjPtr
);
2717 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2718 Jim_DecrRefCount(interp
, nameObjPtr
);
2719 Jim_DecrRefCount(interp
, valObjPtr
);
2721 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2725 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2727 command_context_t
*context
;
2730 context
= Jim_GetAssocData(interp
, "context");
2731 if (context
== NULL
)
2733 LOG_ERROR("mem2array: no command context");
2736 target
= get_current_target(context
);
2739 LOG_ERROR("mem2array: no current target");
2743 return target_mem2array(interp
, target
, argc
-1, argv
+1);
2746 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2754 const char *varname
;
2759 /* argv[1] = name of array to receive the data
2760 * argv[2] = desired width
2761 * argv[3] = memory address
2762 * argv[4] = count of times to read
2765 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2768 varname
= Jim_GetString(argv
[0], &len
);
2769 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2771 e
= Jim_GetLong(interp
, argv
[1], &l
);
2777 e
= Jim_GetLong(interp
, argv
[2], &l
);
2782 e
= Jim_GetLong(interp
, argv
[3], &l
);
2798 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2799 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2803 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2804 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2807 if ((addr
+ (len
* width
)) < addr
) {
2808 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2809 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2812 /* absurd transfer size? */
2814 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2815 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2820 ((width
== 2) && ((addr
& 1) == 0)) ||
2821 ((width
== 4) && ((addr
& 3) == 0))) {
2825 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2826 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2827 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2838 /* Slurp... in buffer size chunks */
2840 count
= len
; /* in objects.. */
2841 if (count
> (sizeof(buffer
)/width
)) {
2842 count
= (sizeof(buffer
)/width
);
2845 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2846 if (retval
!= ERROR_OK
) {
2848 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2849 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2850 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2854 v
= 0; /* shut up gcc */
2855 for (i
= 0 ;i
< count
;i
++, n
++) {
2858 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2861 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2864 v
= buffer
[i
] & 0x0ff;
2867 new_int_array_element(interp
, varname
, n
, v
);
2873 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2878 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2881 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2885 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2889 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2896 Jim_IncrRefCount(nameObjPtr
);
2897 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2898 Jim_DecrRefCount(interp
, nameObjPtr
);
2900 if (valObjPtr
== NULL
)
2903 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2904 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2909 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2911 command_context_t
*context
;
2914 context
= Jim_GetAssocData(interp
, "context");
2915 if (context
== NULL
){
2916 LOG_ERROR("array2mem: no command context");
2919 target
= get_current_target(context
);
2920 if (target
== NULL
){
2921 LOG_ERROR("array2mem: no current target");
2925 return target_array2mem( interp
,target
, argc
-1, argv
+1 );
2928 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2936 const char *varname
;
2941 /* argv[1] = name of array to get the data
2942 * argv[2] = desired width
2943 * argv[3] = memory address
2944 * argv[4] = count to write
2947 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2950 varname
= Jim_GetString(argv
[0], &len
);
2951 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2953 e
= Jim_GetLong(interp
, argv
[1], &l
);
2959 e
= Jim_GetLong(interp
, argv
[2], &l
);
2964 e
= Jim_GetLong(interp
, argv
[3], &l
);
2980 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2981 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2985 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2986 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2989 if ((addr
+ (len
* width
)) < addr
) {
2990 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2991 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2994 /* absurd transfer size? */
2996 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2997 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
3002 ((width
== 2) && ((addr
& 1) == 0)) ||
3003 ((width
== 4) && ((addr
& 3) == 0))) {
3007 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3008 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
3009 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
3020 /* Slurp... in buffer size chunks */
3022 count
= len
; /* in objects.. */
3023 if (count
> (sizeof(buffer
)/width
)) {
3024 count
= (sizeof(buffer
)/width
);
3027 v
= 0; /* shut up gcc */
3028 for (i
= 0 ;i
< count
;i
++, n
++) {
3029 get_int_array_element(interp
, varname
, n
, &v
);
3032 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
3035 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
3038 buffer
[i
] = v
& 0x0ff;
3044 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
3045 if (retval
!= ERROR_OK
) {
3047 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
3048 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3049 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: cannot read memory", NULL
);
3055 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3060 void target_all_handle_event( enum target_event e
)
3064 LOG_DEBUG( "**all*targets: event: %d, %s",
3066 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3068 target
= all_targets
;
3070 target_handle_event( target
, e
);
3071 target
= target
->next
;
3075 void target_handle_event( target_t
*target
, enum target_event e
)
3077 target_event_action_t
*teap
;
3080 teap
= target
->event_action
;
3084 if( teap
->event
== e
){
3086 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3087 target
->target_number
,
3091 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
,
3092 Jim_GetString( teap
->body
, NULL
) );
3093 if (Jim_EvalObj( interp
, teap
->body
)!=JIM_OK
)
3095 Jim_PrintErrorMessage(interp
);
3101 LOG_DEBUG( "event: %d %s - no action",
3103 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3107 enum target_cfg_param
{
3110 TCFG_WORK_AREA_VIRT
,
3111 TCFG_WORK_AREA_PHYS
,
3112 TCFG_WORK_AREA_SIZE
,
3113 TCFG_WORK_AREA_BACKUP
,
3116 TCFG_CHAIN_POSITION
,
3119 static Jim_Nvp nvp_config_opts
[] = {
3120 { .name
= "-type", .value
= TCFG_TYPE
},
3121 { .name
= "-event", .value
= TCFG_EVENT
},
3122 { .name
= "-work-area-virt", .value
= TCFG_WORK_AREA_VIRT
},
3123 { .name
= "-work-area-phys", .value
= TCFG_WORK_AREA_PHYS
},
3124 { .name
= "-work-area-size", .value
= TCFG_WORK_AREA_SIZE
},
3125 { .name
= "-work-area-backup", .value
= TCFG_WORK_AREA_BACKUP
},
3126 { .name
= "-endian" , .value
= TCFG_ENDIAN
},
3127 { .name
= "-variant", .value
= TCFG_VARIANT
},
3128 { .name
= "-chain-position", .value
= TCFG_CHAIN_POSITION
},
3130 { .name
= NULL
, .value
= -1 }
3133 static int target_configure( Jim_GetOptInfo
*goi
, target_t
*target
)
3141 /* parse config or cget options ... */
3142 while( goi
->argc
> 0 ){
3143 Jim_SetEmptyResult( goi
->interp
);
3144 /* Jim_GetOpt_Debug( goi ); */
3146 if( target
->type
->target_jim_configure
){
3147 /* target defines a configure function */
3148 /* target gets first dibs on parameters */
3149 e
= (*(target
->type
->target_jim_configure
))( target
, goi
);
3158 /* otherwise we 'continue' below */
3160 e
= Jim_GetOpt_Nvp( goi
, nvp_config_opts
, &n
);
3162 Jim_GetOpt_NvpUnknown( goi
, nvp_config_opts
, 0 );
3168 if( goi
->isconfigure
){
3169 Jim_SetResult_sprintf( goi
->interp
, "not setable: %s", n
->name
);
3173 if( goi
->argc
!= 0 ){
3174 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
3178 Jim_SetResultString( goi
->interp
, target
->type
->name
, -1 );
3182 if( goi
->argc
== 0 ){
3183 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ...");
3187 e
= Jim_GetOpt_Nvp( goi
, nvp_target_event
, &n
);
3189 Jim_GetOpt_NvpUnknown( goi
, nvp_target_event
, 1 );
3193 if( goi
->isconfigure
){
3194 if( goi
->argc
!= 1 ){
3195 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
3199 if( goi
->argc
!= 0 ){
3200 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
3206 target_event_action_t
*teap
;
3208 teap
= target
->event_action
;
3209 /* replace existing? */
3211 if( teap
->event
== (enum target_event
)n
->value
){
3217 if( goi
->isconfigure
){
3220 teap
= calloc( 1, sizeof(*teap
) );
3222 teap
->event
= n
->value
;
3223 Jim_GetOpt_Obj( goi
, &o
);
3225 Jim_DecrRefCount( interp
, teap
->body
);
3227 teap
->body
= Jim_DuplicateObj( goi
->interp
, o
);
3230 * Tcl/TK - "tk events" have a nice feature.
3231 * See the "BIND" command.
3232 * We should support that here.
3233 * You can specify %X and %Y in the event code.
3234 * The idea is: %T - target name.
3235 * The idea is: %N - target number
3236 * The idea is: %E - event name.
3238 Jim_IncrRefCount( teap
->body
);
3240 /* add to head of event list */
3241 teap
->next
= target
->event_action
;
3242 target
->event_action
= teap
;
3243 Jim_SetEmptyResult(goi
->interp
);
3247 Jim_SetEmptyResult( goi
->interp
);
3249 Jim_SetResult( goi
->interp
, Jim_DuplicateObj( goi
->interp
, teap
->body
) );
3256 case TCFG_WORK_AREA_VIRT
:
3257 if( goi
->isconfigure
){
3258 target_free_all_working_areas(target
);
3259 e
= Jim_GetOpt_Wide( goi
, &w
);
3263 target
->working_area_virt
= w
;
3265 if( goi
->argc
!= 0 ){
3269 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_virt
) );
3273 case TCFG_WORK_AREA_PHYS
:
3274 if( goi
->isconfigure
){
3275 target_free_all_working_areas(target
);
3276 e
= Jim_GetOpt_Wide( goi
, &w
);
3280 target
->working_area_phys
= w
;
3282 if( goi
->argc
!= 0 ){
3286 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_phys
) );
3290 case TCFG_WORK_AREA_SIZE
:
3291 if( goi
->isconfigure
){
3292 target_free_all_working_areas(target
);
3293 e
= Jim_GetOpt_Wide( goi
, &w
);
3297 target
->working_area_size
= w
;
3299 if( goi
->argc
!= 0 ){
3303 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3307 case TCFG_WORK_AREA_BACKUP
:
3308 if( goi
->isconfigure
){
3309 target_free_all_working_areas(target
);
3310 e
= Jim_GetOpt_Wide( goi
, &w
);
3314 /* make this exactly 1 or 0 */
3315 target
->backup_working_area
= (!!w
);
3317 if( goi
->argc
!= 0 ){
3321 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3322 /* loop for more e*/
3326 if( goi
->isconfigure
){
3327 e
= Jim_GetOpt_Nvp( goi
, nvp_target_endian
, &n
);
3329 Jim_GetOpt_NvpUnknown( goi
, nvp_target_endian
, 1 );
3332 target
->endianness
= n
->value
;
3334 if( goi
->argc
!= 0 ){
3338 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3339 if( n
->name
== NULL
){
3340 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3341 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3343 Jim_SetResultString( goi
->interp
, n
->name
, -1 );
3348 if( goi
->isconfigure
){
3349 if( goi
->argc
< 1 ){
3350 Jim_SetResult_sprintf( goi
->interp
,
3355 if( target
->variant
){
3356 free((void *)(target
->variant
));
3358 e
= Jim_GetOpt_String( goi
, &cp
, NULL
);
3359 target
->variant
= strdup(cp
);
3361 if( goi
->argc
!= 0 ){
3365 Jim_SetResultString( goi
->interp
, target
->variant
,-1 );
3368 case TCFG_CHAIN_POSITION
:
3369 if( goi
->isconfigure
){
3372 target_free_all_working_areas(target
);
3373 e
= Jim_GetOpt_Obj( goi
, &o
);
3377 tap
= jtag_TapByJimObj( goi
->interp
, o
);
3381 /* make this exactly 1 or 0 */
3384 if( goi
->argc
!= 0 ){
3388 Jim_SetResultString( interp
, target
->tap
->dotted_name
, -1 );
3389 /* loop for more e*/
3392 } /* while( goi->argc ) */
3395 /* done - we return */
3399 /** this is the 'tcl' handler for the target specific command */
3400 static int tcl_target_func( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3408 struct command_context_s
*cmd_ctx
;
3415 TS_CMD_MWW
, TS_CMD_MWH
, TS_CMD_MWB
,
3416 TS_CMD_MDW
, TS_CMD_MDH
, TS_CMD_MDB
,
3417 TS_CMD_MRW
, TS_CMD_MRH
, TS_CMD_MRB
,
3418 TS_CMD_MEM2ARRAY
, TS_CMD_ARRAY2MEM
,
3426 TS_CMD_INVOKE_EVENT
,
3429 static const Jim_Nvp target_options
[] = {
3430 { .name
= "configure", .value
= TS_CMD_CONFIGURE
},
3431 { .name
= "cget", .value
= TS_CMD_CGET
},
3432 { .name
= "mww", .value
= TS_CMD_MWW
},
3433 { .name
= "mwh", .value
= TS_CMD_MWH
},
3434 { .name
= "mwb", .value
= TS_CMD_MWB
},
3435 { .name
= "mdw", .value
= TS_CMD_MDW
},
3436 { .name
= "mdh", .value
= TS_CMD_MDH
},
3437 { .name
= "mdb", .value
= TS_CMD_MDB
},
3438 { .name
= "mem2array", .value
= TS_CMD_MEM2ARRAY
},
3439 { .name
= "array2mem", .value
= TS_CMD_ARRAY2MEM
},
3440 { .name
= "eventlist", .value
= TS_CMD_EVENTLIST
},
3441 { .name
= "curstate", .value
= TS_CMD_CURSTATE
},
3443 { .name
= "arp_examine", .value
= TS_CMD_EXAMINE
},
3444 { .name
= "arp_poll", .value
= TS_CMD_POLL
},
3445 { .name
= "arp_reset", .value
= TS_CMD_RESET
},
3446 { .name
= "arp_halt", .value
= TS_CMD_HALT
},
3447 { .name
= "arp_waitstate", .value
= TS_CMD_WAITSTATE
},
3448 { .name
= "invoke-event", .value
= TS_CMD_INVOKE_EVENT
},
3450 { .name
= NULL
, .value
= -1 },
3453 /* go past the "command" */
3454 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3456 target
= Jim_CmdPrivData( goi
.interp
);
3457 cmd_ctx
= Jim_GetAssocData(goi
.interp
, "context");
3459 /* commands here are in an NVP table */
3460 e
= Jim_GetOpt_Nvp( &goi
, target_options
, &n
);
3462 Jim_GetOpt_NvpUnknown( &goi
, target_options
, 0 );
3465 /* Assume blank result */
3466 Jim_SetEmptyResult( goi
.interp
);
3469 case TS_CMD_CONFIGURE
:
3471 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "missing: -option VALUE ...");
3474 goi
.isconfigure
= 1;
3475 return target_configure( &goi
, target
);
3477 // some things take params
3479 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "missing: ?-option?");
3482 goi
.isconfigure
= 0;
3483 return target_configure( &goi
, target
);
3491 * argv[3] = optional count.
3494 if( (goi
.argc
== 3) || (goi
.argc
== 4) ){
3498 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR DATA [COUNT]", n
->name
);
3502 e
= Jim_GetOpt_Wide( &goi
, &a
);
3507 e
= Jim_GetOpt_Wide( &goi
, &b
);
3512 e
= Jim_GetOpt_Wide( &goi
, &c
);
3522 target_buffer_set_u32( target
, target_buf
, b
);
3526 target_buffer_set_u16( target
, target_buf
, b
);
3530 target_buffer_set_u8( target
, target_buf
, b
);
3534 for( x
= 0 ; x
< c
; x
++ ){
3535 e
= target
->type
->write_memory( target
, a
, b
, 1, target_buf
);
3536 if( e
!= ERROR_OK
){
3537 Jim_SetResult_sprintf( interp
, "Error writing @ 0x%08x: %d\n", (int)(a
), e
);
3550 /* argv[0] = command
3552 * argv[2] = optional count
3554 if( (goi
.argc
== 2) || (goi
.argc
== 3) ){
3555 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR [COUNT]", n
->name
);
3558 e
= Jim_GetOpt_Wide( &goi
, &a
);
3563 e
= Jim_GetOpt_Wide( &goi
, &c
);
3570 b
= 1; /* shut up gcc */
3583 /* convert to "bytes" */
3585 /* count is now in 'BYTES' */
3591 e
= target
->type
->read_memory( target
, a
, b
, y
/ b
, target_buf
);
3592 if( e
!= ERROR_OK
){
3593 Jim_SetResult_sprintf( interp
, "error reading target @ 0x%08lx", (int)(a
) );
3597 Jim_fprintf( interp
, interp
->cookie_stdout
, "0x%08x ", (int)(a
) );
3600 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 4 ){
3601 z
= target_buffer_get_u32( target
, &(target_buf
[ x
* 4 ]) );
3602 Jim_fprintf( interp
, interp
->cookie_stdout
, "%08x ", (int)(z
) );
3604 for( ; (x
< 16) ; x
+= 4 ){
3605 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3609 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 2 ){
3610 z
= target_buffer_get_u16( target
, &(target_buf
[ x
* 2 ]) );
3611 Jim_fprintf( interp
, interp
->cookie_stdout
, "%04x ", (int)(z
) );
3613 for( ; (x
< 16) ; x
+= 2 ){
3614 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3619 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 1 ){
3620 z
= target_buffer_get_u8( target
, &(target_buf
[ x
* 4 ]) );
3621 Jim_fprintf( interp
, interp
->cookie_stdout
, "%02x ", (int)(z
) );
3623 for( ; (x
< 16) ; x
+= 1 ){
3624 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3628 /* ascii-ify the bytes */
3629 for( x
= 0 ; x
< y
; x
++ ){
3630 if( (target_buf
[x
] >= 0x20) &&
3631 (target_buf
[x
] <= 0x7e) ){
3635 target_buf
[x
] = '.';
3640 target_buf
[x
] = ' ';
3645 /* print - with a newline */
3646 Jim_fprintf( interp
, interp
->cookie_stdout
, "%s\n", target_buf
);
3652 case TS_CMD_MEM2ARRAY
:
3653 return target_mem2array( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3655 case TS_CMD_ARRAY2MEM
:
3656 return target_array2mem( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3658 case TS_CMD_EXAMINE
:
3660 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3663 e
= target
->type
->examine( target
);
3664 if( e
!= ERROR_OK
){
3665 Jim_SetResult_sprintf( interp
, "examine-fails: %d", e
);
3671 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3674 if( !(target
->type
->examined
) ){
3675 e
= ERROR_TARGET_NOT_EXAMINED
;
3677 e
= target
->type
->poll( target
);
3679 if( e
!= ERROR_OK
){
3680 Jim_SetResult_sprintf( interp
, "poll-fails: %d", e
);
3687 if( goi
.argc
!= 2 ){
3688 Jim_WrongNumArgs( interp
, 2, argv
, "t|f|assert|deassert BOOL");
3691 e
= Jim_GetOpt_Nvp( &goi
, nvp_assert
, &n
);
3693 Jim_GetOpt_NvpUnknown( &goi
, nvp_assert
, 1 );
3696 /* the halt or not param */
3697 e
= Jim_GetOpt_Wide( &goi
, &a
);
3701 /* determine if we should halt or not. */
3702 target
->reset_halt
= !!a
;
3703 /* When this happens - all workareas are invalid. */
3704 target_free_all_working_areas_restore(target
, 0);
3707 if( n
->value
== NVP_ASSERT
){
3708 target
->type
->assert_reset( target
);
3710 target
->type
->deassert_reset( target
);
3715 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "halt [no parameters]");
3718 target
->type
->halt( target
);
3720 case TS_CMD_WAITSTATE
:
3721 /* params: <name> statename timeoutmsecs */
3722 if( goi
.argc
!= 2 ){
3723 Jim_SetResult_sprintf( goi
.interp
, "%s STATENAME TIMEOUTMSECS", n
->name
);
3726 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_state
, &n
);
3728 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_state
,1 );
3731 e
= Jim_GetOpt_Wide( &goi
, &a
);
3735 e
= target_wait_state( target
, n
->value
, a
);
3736 if( e
!= ERROR_OK
){
3737 Jim_SetResult_sprintf( goi
.interp
,
3738 "target: %s wait %s fails (%d) %s",
3741 e
, target_strerror_safe(e
) );
3746 case TS_CMD_EVENTLIST
:
3747 /* List for human, Events defined for this target.
3748 * scripts/programs should use 'name cget -event NAME'
3751 target_event_action_t
*teap
;
3752 teap
= target
->event_action
;
3753 command_print( cmd_ctx
, "Event actions for target (%d) %s\n",
3754 target
->target_number
,
3756 command_print( cmd_ctx
, "%-25s | Body", "Event");
3757 command_print( cmd_ctx
, "------------------------- | ----------------------------------------");
3759 command_print( cmd_ctx
,
3761 Jim_Nvp_value2name_simple( nvp_target_event
, teap
->event
)->name
,
3762 Jim_GetString( teap
->body
, NULL
) );
3765 command_print( cmd_ctx
, "***END***");
3768 case TS_CMD_CURSTATE
:
3769 if( goi
.argc
!= 0 ){
3770 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "[no parameters]");
3773 Jim_SetResultString( goi
.interp
,
3774 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
,-1);
3776 case TS_CMD_INVOKE_EVENT
:
3777 if( goi
.argc
!= 1 ){
3778 Jim_SetResult_sprintf( goi
.interp
, "%s ?EVENTNAME?",n
->name
);
3781 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_event
, &n
);
3783 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_event
, 1 );
3786 target_handle_event( target
, n
->value
);
3792 static int target_create( Jim_GetOptInfo
*goi
)
3801 struct command_context_s
*cmd_ctx
;
3803 cmd_ctx
= Jim_GetAssocData(goi
->interp
, "context");
3804 if( goi
->argc
< 3 ){
3805 Jim_WrongNumArgs( goi
->interp
, 1, goi
->argv
, "?name? ?type? ..options...");
3810 Jim_GetOpt_Obj( goi
, &new_cmd
);
3811 /* does this command exist? */
3812 cmd
= Jim_GetCommand( goi
->interp
, new_cmd
, JIM_ERRMSG
);
3814 cp
= Jim_GetString( new_cmd
, NULL
);
3815 Jim_SetResult_sprintf(goi
->interp
, "Command/target: %s Exists", cp
);
3820 e
= Jim_GetOpt_String( goi
, &cp2
, NULL
);
3822 /* now does target type exist */
3823 for( x
= 0 ; target_types
[x
] ; x
++ ){
3824 if( 0 == strcmp( cp
, target_types
[x
]->name
) ){
3829 if( target_types
[x
] == NULL
){
3830 Jim_SetResult_sprintf( goi
->interp
, "Unknown target type %s, try one of ", cp
);
3831 for( x
= 0 ; target_types
[x
] ; x
++ ){
3832 if( target_types
[x
+1] ){
3833 Jim_AppendStrings( goi
->interp
,
3834 Jim_GetResult(goi
->interp
),
3835 target_types
[x
]->name
,
3838 Jim_AppendStrings( goi
->interp
,
3839 Jim_GetResult(goi
->interp
),
3841 target_types
[x
]->name
,NULL
);
3848 target
= calloc(1,sizeof(target_t
));
3849 /* set target number */
3850 target
->target_number
= new_target_number();
3852 /* allocate memory for each unique target type */
3853 target
->type
= (target_type_t
*)calloc(1,sizeof(target_type_t
));
3855 memcpy( target
->type
, target_types
[x
], sizeof(target_type_t
));
3857 /* will be set by "-endian" */
3858 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3860 target
->working_area
= 0x0;
3861 target
->working_area_size
= 0x0;
3862 target
->working_areas
= NULL
;
3863 target
->backup_working_area
= 0;
3865 target
->state
= TARGET_UNKNOWN
;
3866 target
->debug_reason
= DBG_REASON_UNDEFINED
;
3867 target
->reg_cache
= NULL
;
3868 target
->breakpoints
= NULL
;
3869 target
->watchpoints
= NULL
;
3870 target
->next
= NULL
;
3871 target
->arch_info
= NULL
;
3873 target
->display
= 1;
3875 /* initialize trace information */
3876 target
->trace_info
= malloc(sizeof(trace_t
));
3877 target
->trace_info
->num_trace_points
= 0;
3878 target
->trace_info
->trace_points_size
= 0;
3879 target
->trace_info
->trace_points
= NULL
;
3880 target
->trace_info
->trace_history_size
= 0;
3881 target
->trace_info
->trace_history
= NULL
;
3882 target
->trace_info
->trace_history_pos
= 0;
3883 target
->trace_info
->trace_history_overflowed
= 0;
3885 target
->dbgmsg
= NULL
;
3886 target
->dbg_msg_enabled
= 0;
3888 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3890 /* Do the rest as "configure" options */
3891 goi
->isconfigure
= 1;
3892 e
= target_configure( goi
, target
);
3894 if (target
->tap
== NULL
)
3896 Jim_SetResultString( interp
, "-chain-position required when creating target", -1);
3901 free( target
->type
);
3906 if( target
->endianness
== TARGET_ENDIAN_UNKNOWN
){
3907 /* default endian to little if not specified */
3908 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3911 /* incase variant is not set */
3912 if (!target
->variant
)
3913 target
->variant
= strdup("");
3915 /* create the target specific commands */
3916 if( target
->type
->register_commands
){
3917 (*(target
->type
->register_commands
))( cmd_ctx
);
3919 if( target
->type
->target_create
){
3920 (*(target
->type
->target_create
))( target
, goi
->interp
);
3923 /* append to end of list */
3926 tpp
= &(all_targets
);
3928 tpp
= &( (*tpp
)->next
);
3933 cp
= Jim_GetString( new_cmd
, NULL
);
3934 target
->cmd_name
= strdup(cp
);
3936 /* now - create the new target name command */
3937 e
= Jim_CreateCommand( goi
->interp
,
3940 tcl_target_func
, /* C function */
3941 target
, /* private data */
3942 NULL
); /* no del proc */
3947 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3951 struct command_context_s
*cmd_ctx
;
3955 /* TG = target generic */
3963 const char *target_cmds
[] = {
3964 "create", "types", "names", "current", "number",
3966 NULL
/* terminate */
3969 LOG_DEBUG("Target command params:");
3970 LOG_DEBUG("%s", Jim_Debug_ArgvString(interp
, argc
, argv
));
3972 cmd_ctx
= Jim_GetAssocData( interp
, "context" );
3974 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3976 if( goi
.argc
== 0 ){
3977 Jim_WrongNumArgs(interp
, 1, argv
, "missing: command ...");
3981 /* Jim_GetOpt_Debug( &goi ); */
3982 r
= Jim_GetOpt_Enum( &goi
, target_cmds
, &x
);
3989 Jim_Panic(goi
.interp
,"Why am I here?");
3991 case TG_CMD_CURRENT
:
3992 if( goi
.argc
!= 0 ){
3993 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters");
3996 Jim_SetResultString( goi
.interp
, get_current_target( cmd_ctx
)->cmd_name
, -1 );
3999 if( goi
.argc
!= 0 ){
4000 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4003 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4004 for( x
= 0 ; target_types
[x
] ; x
++ ){
4005 Jim_ListAppendElement( goi
.interp
,
4006 Jim_GetResult(goi
.interp
),
4007 Jim_NewStringObj( goi
.interp
, target_types
[x
]->name
, -1 ) );
4011 if( goi
.argc
!= 0 ){
4012 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4015 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4016 target
= all_targets
;
4018 Jim_ListAppendElement( goi
.interp
,
4019 Jim_GetResult(goi
.interp
),
4020 Jim_NewStringObj( goi
.interp
, target
->cmd_name
, -1 ) );
4021 target
= target
->next
;
4026 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "?name ... config options ...");
4029 return target_create( &goi
);
4032 if( goi
.argc
!= 1 ){
4033 Jim_SetResult_sprintf( goi
.interp
, "expected: target number ?NUMBER?");
4036 e
= Jim_GetOpt_Wide( &goi
, &w
);
4042 t
= get_target_by_num(w
);
4044 Jim_SetResult_sprintf( goi
.interp
,"Target: number %d does not exist", (int)(w
));
4047 Jim_SetResultString( goi
.interp
, t
->cmd_name
, -1 );
4051 if( goi
.argc
!= 0 ){
4052 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "<no parameters>");
4055 Jim_SetResult( goi
.interp
,
4056 Jim_NewIntObj( goi
.interp
, max_target_number()));
4072 static int fastload_num
;
4073 static struct FastLoad
*fastload
;
4075 static void free_fastload(void)
4080 for (i
=0; i
<fastload_num
; i
++)
4082 if (fastload
[i
].data
)
4083 free(fastload
[i
].data
);
4093 static int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4099 u32 max_address
=0xffffffff;
4105 duration_t duration
;
4106 char *duration_text
;
4108 if ((argc
< 1)||(argc
> 5))
4110 return ERROR_COMMAND_SYNTAX_ERROR
;
4113 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
4116 image
.base_address_set
= 1;
4117 image
.base_address
= strtoul(args
[1], NULL
, 0);
4121 image
.base_address_set
= 0;
4125 image
.start_address_set
= 0;
4129 min_address
=strtoul(args
[3], NULL
, 0);
4133 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
4136 if (min_address
>max_address
)
4138 return ERROR_COMMAND_SYNTAX_ERROR
;
4141 duration_start_measure(&duration
);
4143 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
4150 fastload_num
=image
.num_sections
;
4151 fastload
=(struct FastLoad
*)malloc(sizeof(struct FastLoad
)*image
.num_sections
);
4154 image_close(&image
);
4157 memset(fastload
, 0, sizeof(struct FastLoad
)*image
.num_sections
);
4158 for (i
= 0; i
< image
.num_sections
; i
++)
4160 buffer
= malloc(image
.sections
[i
].size
);
4163 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
4167 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
4177 /* DANGER!!! beware of unsigned comparision here!!! */
4179 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
4180 (image
.sections
[i
].base_address
<max_address
))
4182 if (image
.sections
[i
].base_address
<min_address
)
4184 /* clip addresses below */
4185 offset
+=min_address
-image
.sections
[i
].base_address
;
4189 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
4191 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
4194 fastload
[i
].address
=image
.sections
[i
].base_address
+offset
;
4195 fastload
[i
].data
=malloc(length
);
4196 if (fastload
[i
].data
==NULL
)
4201 memcpy(fastload
[i
].data
, buffer
+offset
, length
);
4202 fastload
[i
].length
=length
;
4204 image_size
+= length
;
4205 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
4211 duration_stop_measure(&duration
, &duration_text
);
4212 if (retval
==ERROR_OK
)
4214 command_print(cmd_ctx
, "Loaded %u bytes in %s", image_size
, duration_text
);
4215 command_print(cmd_ctx
, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4217 free(duration_text
);
4219 image_close(&image
);
4221 if (retval
!=ERROR_OK
)
4229 static int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4232 return ERROR_COMMAND_SYNTAX_ERROR
;
4235 LOG_ERROR("No image in memory");
4239 int ms
=timeval_ms();
4241 int retval
=ERROR_OK
;
4242 for (i
=0; i
<fastload_num
;i
++)
4244 target_t
*target
= get_current_target(cmd_ctx
);
4245 command_print(cmd_ctx
, "Write to 0x%08x, length 0x%08x", fastload
[i
].address
, fastload
[i
].length
);
4246 if (retval
==ERROR_OK
)
4248 retval
= target_write_buffer(target
, fastload
[i
].address
, fastload
[i
].length
, fastload
[i
].data
);
4250 size
+=fastload
[i
].length
;
4252 int after
=timeval_ms();
4253 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)