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");
988 if ((address
+ size
- 1) < address
)
990 /* GDB can request this when e.g. PC is 0xfffffffc*/
991 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
995 if (((address
% 2) == 0) && (size
== 2))
997 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
1000 /* handle unaligned head bytes */
1003 u32 unaligned
= 4 - (address
% 4);
1005 if (unaligned
> size
)
1008 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1011 buffer
+= unaligned
;
1012 address
+= unaligned
;
1016 /* handle aligned words */
1019 int aligned
= size
- (size
% 4);
1021 /* use bulk writes above a certain limit. This may have to be changed */
1024 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1029 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1038 /* handle tail writes of less than 4 bytes */
1041 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1048 /* Single aligned words are guaranteed to use 16 or 32 bit access
1049 * mode respectively, otherwise data is handled as quickly as
1052 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1055 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1057 if (!target
->type
->examined
)
1059 LOG_ERROR("Target not examined yet");
1063 if ((address
+ size
- 1) < address
)
1065 /* GDB can request this when e.g. PC is 0xfffffffc*/
1066 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
1070 if (((address
% 2) == 0) && (size
== 2))
1072 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1075 /* handle unaligned head bytes */
1078 u32 unaligned
= 4 - (address
% 4);
1080 if (unaligned
> size
)
1083 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1086 buffer
+= unaligned
;
1087 address
+= unaligned
;
1091 /* handle aligned words */
1094 int aligned
= size
- (size
% 4);
1096 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1104 /* handle tail writes of less than 4 bytes */
1107 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1114 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1120 if (!target
->type
->examined
)
1122 LOG_ERROR("Target not examined yet");
1126 if ((retval
= target
->type
->checksum_memory(target
, address
,
1127 size
, &checksum
)) != ERROR_OK
)
1129 buffer
= malloc(size
);
1132 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1133 return ERROR_INVALID_ARGUMENTS
;
1135 retval
= target_read_buffer(target
, address
, size
, buffer
);
1136 if (retval
!= ERROR_OK
)
1142 /* convert to target endianess */
1143 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1146 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1147 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1150 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1159 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1162 if (!target
->type
->examined
)
1164 LOG_ERROR("Target not examined yet");
1168 if (target
->type
->blank_check_memory
== 0)
1169 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1171 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1176 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1179 if (!target
->type
->examined
)
1181 LOG_ERROR("Target not examined yet");
1185 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1187 if (retval
== ERROR_OK
)
1189 *value
= target_buffer_get_u32(target
, value_buf
);
1190 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1195 LOG_DEBUG("address: 0x%8.8x failed", address
);
1201 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1204 if (!target
->type
->examined
)
1206 LOG_ERROR("Target not examined yet");
1210 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1212 if (retval
== ERROR_OK
)
1214 *value
= target_buffer_get_u16(target
, value_buf
);
1215 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1220 LOG_DEBUG("address: 0x%8.8x failed", address
);
1226 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1228 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1229 if (!target
->type
->examined
)
1231 LOG_ERROR("Target not examined yet");
1235 if (retval
== ERROR_OK
)
1237 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1242 LOG_DEBUG("address: 0x%8.8x failed", address
);
1248 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1252 if (!target
->type
->examined
)
1254 LOG_ERROR("Target not examined yet");
1258 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1260 target_buffer_set_u32(target
, value_buf
, value
);
1261 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1263 LOG_DEBUG("failed: %i", retval
);
1269 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1273 if (!target
->type
->examined
)
1275 LOG_ERROR("Target not examined yet");
1279 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1281 target_buffer_set_u16(target
, value_buf
, value
);
1282 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1284 LOG_DEBUG("failed: %i", retval
);
1290 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1293 if (!target
->type
->examined
)
1295 LOG_ERROR("Target not examined yet");
1299 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1301 if ((retval
= target
->type
->write_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1303 LOG_DEBUG("failed: %i", retval
);
1309 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1311 int retval
= ERROR_OK
;
1314 /* script procedures */
1315 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "profiling samples the CPU PC");
1316 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>");
1317 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>");
1319 register_command(cmd_ctx
, NULL
, "fast_load_image", handle_fast_load_image_command
, COMMAND_ANY
,
1320 "same args as load_image, image stored in memory - mainly for profiling purposes");
1322 register_command(cmd_ctx
, NULL
, "fast_load", handle_fast_load_command
, COMMAND_ANY
,
1323 "loads active fast load image to current target - mainly for profiling purposes");
1326 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "translate a virtual address into a physical address");
1327 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, "display or set a register");
1328 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1329 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1330 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1331 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1332 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1333 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init] - default is run");
1334 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1336 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1337 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1338 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1340 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1341 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1342 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1344 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1345 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1346 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1347 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1349 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]");
1350 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1351 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1352 register_command(cmd_ctx
, NULL
, "test_image", handle_test_image_command
, COMMAND_EXEC
, "test_image <file> [offset] [type]");
1354 if((retval
= target_request_register_commands(cmd_ctx
)) != ERROR_OK
)
1356 if((retval
= trace_register_commands(cmd_ctx
)) != ERROR_OK
)
1362 static int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1364 target_t
*target
= all_targets
;
1368 target
= get_target(args
[0]);
1369 if (target
== NULL
) {
1370 command_print(cmd_ctx
,"Target: %s is unknown, try one of:\n", args
[0] );
1374 cmd_ctx
->current_target
= target
->target_number
;
1379 target
= all_targets
;
1380 command_print(cmd_ctx
, " CmdName Type Endian AbsChainPos Name State ");
1381 command_print(cmd_ctx
, "-- ---------- ---------- ---------- ----------- ------------- ----------");
1384 /* XX: abcdefghij abcdefghij abcdefghij abcdefghij */
1385 command_print(cmd_ctx
, "%2d: %-10s %-10s %-10s %10d %14s %s",
1386 target
->target_number
,
1389 Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
)->name
,
1390 target
->tap
->abs_chain_position
,
1391 target
->tap
->dotted_name
,
1392 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
1393 target
= target
->next
;
1399 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1401 static int powerDropout
;
1402 static int srstAsserted
;
1404 static int runPowerRestore
;
1405 static int runPowerDropout
;
1406 static int runSrstAsserted
;
1407 static int runSrstDeasserted
;
1409 static int sense_handler(void)
1411 static int prevSrstAsserted
= 0;
1412 static int prevPowerdropout
= 0;
1415 if ((retval
=jtag_power_dropout(&powerDropout
))!=ERROR_OK
)
1419 powerRestored
= prevPowerdropout
&& !powerDropout
;
1422 runPowerRestore
= 1;
1425 long long current
= timeval_ms();
1426 static long long lastPower
= 0;
1427 int waitMore
= lastPower
+ 2000 > current
;
1428 if (powerDropout
&& !waitMore
)
1430 runPowerDropout
= 1;
1431 lastPower
= current
;
1434 if ((retval
=jtag_srst_asserted(&srstAsserted
))!=ERROR_OK
)
1438 srstDeasserted
= prevSrstAsserted
&& !srstAsserted
;
1440 static long long lastSrst
= 0;
1441 waitMore
= lastSrst
+ 2000 > current
;
1442 if (srstDeasserted
&& !waitMore
)
1444 runSrstDeasserted
= 1;
1448 if (!prevSrstAsserted
&& srstAsserted
)
1450 runSrstAsserted
= 1;
1453 prevSrstAsserted
= srstAsserted
;
1454 prevPowerdropout
= powerDropout
;
1456 if (srstDeasserted
|| powerRestored
)
1458 /* Other than logging the event we can't do anything here.
1459 * Issuing a reset is a particularly bad idea as we might
1460 * be inside a reset already.
1467 /* process target state changes */
1468 int handle_target(void *priv
)
1470 int retval
= ERROR_OK
;
1472 /* we do not want to recurse here... */
1473 static int recursive
= 0;
1478 /* danger! running these procedures can trigger srst assertions and power dropouts.
1479 * We need to avoid an infinite loop/recursion here and we do that by
1480 * clearing the flags after running these events.
1482 int did_something
= 0;
1483 if (runSrstAsserted
)
1485 Jim_Eval( interp
, "srst_asserted");
1488 if (runSrstDeasserted
)
1490 Jim_Eval( interp
, "srst_deasserted");
1493 if (runPowerDropout
)
1495 Jim_Eval( interp
, "power_dropout");
1498 if (runPowerRestore
)
1500 Jim_Eval( interp
, "power_restore");
1506 /* clear detect flags */
1510 /* clear action flags */
1513 runSrstDeasserted
=0;
1520 target_t
*target
= all_targets
;
1525 /* only poll target if we've got power and srst isn't asserted */
1526 if (target_continous_poll
&&!powerDropout
&&!srstAsserted
)
1528 /* polling may fail silently until the target has been examined */
1529 if((retval
= target_poll(target
)) != ERROR_OK
)
1533 target
= target
->next
;
1539 static int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1548 target
= get_current_target(cmd_ctx
);
1550 /* list all available registers for the current target */
1553 reg_cache_t
*cache
= target
->reg_cache
;
1559 for (i
= 0; i
< cache
->num_regs
; i
++)
1561 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1562 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
);
1565 cache
= cache
->next
;
1571 /* access a single register by its ordinal number */
1572 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1574 int num
= strtoul(args
[0], NULL
, 0);
1575 reg_cache_t
*cache
= target
->reg_cache
;
1581 for (i
= 0; i
< cache
->num_regs
; i
++)
1585 reg
= &cache
->reg_list
[i
];
1591 cache
= cache
->next
;
1596 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1599 } else /* access a single register by its name */
1601 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1605 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1610 /* display a register */
1611 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1613 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1616 if (reg
->valid
== 0)
1618 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1619 arch_type
->get(reg
);
1621 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1622 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1627 /* set register value */
1630 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1631 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1633 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1634 arch_type
->set(reg
, buf
);
1636 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1637 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1645 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1650 static int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1652 int retval
= ERROR_OK
;
1653 target_t
*target
= get_current_target(cmd_ctx
);
1657 if((retval
= target_poll(target
)) != ERROR_OK
)
1659 if((retval
= target_arch_state(target
)) != ERROR_OK
)
1665 if (strcmp(args
[0], "on") == 0)
1667 target_continous_poll
= 1;
1669 else if (strcmp(args
[0], "off") == 0)
1671 target_continous_poll
= 0;
1675 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1679 return ERROR_COMMAND_SYNTAX_ERROR
;
1685 static int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1693 ms
= strtoul(args
[0], &end
, 0) * 1000;
1696 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1700 target_t
*target
= get_current_target(cmd_ctx
);
1702 return target_wait_state(target
, TARGET_HALTED
, ms
);
1705 /* wait for target state to change. The trick here is to have a low
1706 * latency for short waits and not to suck up all the CPU time
1709 * After 500ms, keep_alive() is invoked
1711 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1714 long long then
=0, cur
;
1719 if ((retval
=target_poll(target
))!=ERROR_OK
)
1721 if (target
->state
== state
)
1729 then
= timeval_ms();
1730 LOG_DEBUG("waiting for target %s...",
1731 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1741 LOG_ERROR("timed out while waiting for target %s",
1742 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1750 static int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1753 target_t
*target
= get_current_target(cmd_ctx
);
1757 if ((retval
= target_halt(target
)) != ERROR_OK
)
1767 wait
= strtoul(args
[0], &end
, 0);
1772 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1775 static int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1777 target_t
*target
= get_current_target(cmd_ctx
);
1779 LOG_USER("requesting target halt and executing a soft reset");
1781 target
->type
->soft_reset_halt(target
);
1786 static int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1789 enum target_reset_mode reset_mode
= RESET_RUN
;
1793 n
= Jim_Nvp_name2value_simple( nvp_reset_modes
, args
[0] );
1794 if( (n
->name
== NULL
) || (n
->value
== RESET_UNKNOWN
) ){
1795 return ERROR_COMMAND_SYNTAX_ERROR
;
1797 reset_mode
= n
->value
;
1800 /* reset *all* targets */
1801 return target_process_reset(cmd_ctx
, reset_mode
);
1805 static int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1808 target_t
*target
= get_current_target(cmd_ctx
);
1810 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1813 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1815 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1818 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
1824 static int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1826 target_t
*target
= get_current_target(cmd_ctx
);
1831 return target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1834 return target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1839 static int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1841 const int line_bytecnt
= 32;
1854 target_t
*target
= get_current_target(cmd_ctx
);
1860 count
= strtoul(args
[1], NULL
, 0);
1862 address
= strtoul(args
[0], NULL
, 0);
1867 size
= 4; line_modulo
= line_bytecnt
/ 4;
1870 size
= 2; line_modulo
= line_bytecnt
/ 2;
1873 size
= 1; line_modulo
= line_bytecnt
/ 1;
1879 buffer
= calloc(count
, size
);
1880 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1881 if (retval
== ERROR_OK
)
1885 for (i
= 0; i
< count
; i
++)
1887 if (i
%line_modulo
== 0)
1888 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1893 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1896 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1899 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1903 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1905 command_print(cmd_ctx
, output
);
1916 static int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1923 target_t
*target
= get_current_target(cmd_ctx
);
1926 if ((argc
< 2) || (argc
> 3))
1927 return ERROR_COMMAND_SYNTAX_ERROR
;
1929 address
= strtoul(args
[0], NULL
, 0);
1930 value
= strtoul(args
[1], NULL
, 0);
1932 count
= strtoul(args
[2], NULL
, 0);
1938 target_buffer_set_u32(target
, value_buf
, value
);
1942 target_buffer_set_u16(target
, value_buf
, value
);
1946 value_buf
[0] = value
;
1949 return ERROR_COMMAND_SYNTAX_ERROR
;
1951 for (i
=0; i
<count
; i
++)
1957 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1960 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1963 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1970 if (retval
!=ERROR_OK
)
1980 static int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1986 u32 max_address
=0xffffffff;
1988 int retval
, retvaltemp
;
1992 duration_t duration
;
1993 char *duration_text
;
1995 target_t
*target
= get_current_target(cmd_ctx
);
1997 if ((argc
< 1)||(argc
> 5))
1999 return ERROR_COMMAND_SYNTAX_ERROR
;
2002 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2005 image
.base_address_set
= 1;
2006 image
.base_address
= strtoul(args
[1], NULL
, 0);
2010 image
.base_address_set
= 0;
2014 image
.start_address_set
= 0;
2018 min_address
=strtoul(args
[3], NULL
, 0);
2022 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
2025 if (min_address
>max_address
)
2027 return ERROR_COMMAND_SYNTAX_ERROR
;
2030 duration_start_measure(&duration
);
2032 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2039 for (i
= 0; i
< image
.num_sections
; i
++)
2041 buffer
= malloc(image
.sections
[i
].size
);
2044 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2048 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2057 /* DANGER!!! beware of unsigned comparision here!!! */
2059 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
2060 (image
.sections
[i
].base_address
<max_address
))
2062 if (image
.sections
[i
].base_address
<min_address
)
2064 /* clip addresses below */
2065 offset
+=min_address
-image
.sections
[i
].base_address
;
2069 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
2071 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2074 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2079 image_size
+= length
;
2080 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2086 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2088 image_close(&image
);
2092 if (retval
==ERROR_OK
)
2094 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2096 free(duration_text
);
2098 image_close(&image
);
2104 static int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2111 int retval
=ERROR_OK
, retvaltemp
;
2113 duration_t duration
;
2114 char *duration_text
;
2116 target_t
*target
= get_current_target(cmd_ctx
);
2120 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2124 address
= strtoul(args
[1], NULL
, 0);
2125 size
= strtoul(args
[2], NULL
, 0);
2127 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2132 duration_start_measure(&duration
);
2137 u32 this_run_size
= (size
> 560) ? 560 : size
;
2139 retval
= target_read_buffer(target
, address
, this_run_size
, buffer
);
2140 if (retval
!= ERROR_OK
)
2145 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2146 if (retval
!= ERROR_OK
)
2151 size
-= this_run_size
;
2152 address
+= this_run_size
;
2155 if((retvaltemp
= fileio_close(&fileio
)) != ERROR_OK
)
2158 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2161 if (retval
==ERROR_OK
)
2163 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2164 free(duration_text
);
2170 static int handle_verify_image_command_internal(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, int verify
)
2176 int retval
, retvaltemp
;
2178 u32 mem_checksum
= 0;
2182 duration_t duration
;
2183 char *duration_text
;
2185 target_t
*target
= get_current_target(cmd_ctx
);
2189 return ERROR_COMMAND_SYNTAX_ERROR
;
2194 LOG_ERROR("no target selected");
2198 duration_start_measure(&duration
);
2202 image
.base_address_set
= 1;
2203 image
.base_address
= strtoul(args
[1], NULL
, 0);
2207 image
.base_address_set
= 0;
2208 image
.base_address
= 0x0;
2211 image
.start_address_set
= 0;
2213 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2220 for (i
= 0; i
< image
.num_sections
; i
++)
2222 buffer
= malloc(image
.sections
[i
].size
);
2225 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2228 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2236 /* calculate checksum of image */
2237 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2239 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2240 if( retval
!= ERROR_OK
)
2246 if( checksum
!= mem_checksum
)
2248 /* failed crc checksum, fall back to a binary compare */
2251 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2253 data
= (u8
*)malloc(buf_cnt
);
2255 /* Can we use 32bit word accesses? */
2257 int count
= buf_cnt
;
2258 if ((count
% 4) == 0)
2263 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2264 if (retval
== ERROR_OK
)
2267 for (t
= 0; t
< buf_cnt
; t
++)
2269 if (data
[t
] != buffer
[t
])
2271 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
]);
2288 command_print(cmd_ctx
, "address 0x%08x length 0x%08x", image
.sections
[i
].base_address
, buf_cnt
);
2292 image_size
+= buf_cnt
;
2296 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2298 image_close(&image
);
2302 if (retval
==ERROR_OK
)
2304 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2306 free(duration_text
);
2308 image_close(&image
);
2313 static int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2315 return handle_verify_image_command_internal(cmd_ctx
, cmd
, args
, argc
, 1);
2318 static int handle_test_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2320 return handle_verify_image_command_internal(cmd_ctx
, cmd
, args
, argc
, 0);
2323 static int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2326 target_t
*target
= get_current_target(cmd_ctx
);
2330 breakpoint_t
*breakpoint
= target
->breakpoints
;
2334 if (breakpoint
->type
== BKPT_SOFT
)
2336 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2337 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2342 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2344 breakpoint
= breakpoint
->next
;
2352 length
= strtoul(args
[1], NULL
, 0);
2355 if (strcmp(args
[2], "hw") == 0)
2358 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2360 LOG_ERROR("Failure setting breakpoints");
2364 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2369 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2375 static int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2377 target_t
*target
= get_current_target(cmd_ctx
);
2380 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2385 static int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2387 target_t
*target
= get_current_target(cmd_ctx
);
2392 watchpoint_t
*watchpoint
= target
->watchpoints
;
2396 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
);
2397 watchpoint
= watchpoint
->next
;
2402 enum watchpoint_rw type
= WPT_ACCESS
;
2403 u32 data_value
= 0x0;
2404 u32 data_mask
= 0xffffffff;
2420 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2426 data_value
= strtoul(args
[3], NULL
, 0);
2430 data_mask
= strtoul(args
[4], NULL
, 0);
2433 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2434 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2436 LOG_ERROR("Failure setting breakpoints");
2441 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2447 static int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2449 target_t
*target
= get_current_target(cmd_ctx
);
2452 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2457 static int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2460 target_t
*target
= get_current_target(cmd_ctx
);
2466 return ERROR_COMMAND_SYNTAX_ERROR
;
2468 va
= strtoul(args
[0], NULL
, 0);
2470 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2471 if (retval
== ERROR_OK
)
2473 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2477 /* lower levels will have logged a detailed error which is
2478 * forwarded to telnet/GDB session.
2484 static void writeData(FILE *f
, const void *data
, size_t len
)
2486 size_t written
= fwrite(data
, len
, 1, f
);
2488 LOG_ERROR("failed to write %zu bytes: %s", len
, strerror(errno
));
2491 static void writeLong(FILE *f
, int l
)
2496 char c
=(l
>>(i
*8))&0xff;
2497 writeData(f
, &c
, 1);
2502 static void writeString(FILE *f
, char *s
)
2504 writeData(f
, s
, strlen(s
));
2507 /* Dump a gmon.out histogram file. */
2508 static void writeGmon(u32
*samples
, u32 sampleNum
, char *filename
)
2511 FILE *f
=fopen(filename
, "w");
2514 writeString(f
, "gmon");
2515 writeLong(f
, 0x00000001); /* Version */
2516 writeLong(f
, 0); /* padding */
2517 writeLong(f
, 0); /* padding */
2518 writeLong(f
, 0); /* padding */
2520 u8 zero
= 0; /* GMON_TAG_TIME_HIST */
2521 writeData(f
, &zero
, 1);
2523 /* figure out bucket size */
2526 for (i
=0; i
<sampleNum
; i
++)
2538 int addressSpace
=(max
-min
+1);
2540 static const u32 maxBuckets
= 256 * 1024; /* maximum buckets. */
2541 u32 length
= addressSpace
;
2542 if (length
> maxBuckets
)
2546 int *buckets
=malloc(sizeof(int)*length
);
2552 memset(buckets
, 0, sizeof(int)*length
);
2553 for (i
=0; i
<sampleNum
;i
++)
2555 u32 address
=samples
[i
];
2556 long long a
=address
-min
;
2557 long long b
=length
-1;
2558 long long c
=addressSpace
-1;
2559 int index
=(a
*b
)/c
; /* danger!!!! int32 overflows */
2563 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2564 writeLong(f
, min
); /* low_pc */
2565 writeLong(f
, max
); /* high_pc */
2566 writeLong(f
, length
); /* # of samples */
2567 writeLong(f
, 64000000); /* 64MHz */
2568 writeString(f
, "seconds");
2569 for (i
=0; i
<(15-strlen("seconds")); i
++)
2570 writeData(f
, &zero
, 1);
2571 writeString(f
, "s");
2573 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2575 char *data
=malloc(2*length
);
2578 for (i
=0; i
<length
;i
++)
2587 data
[i
*2+1]=(val
>>8)&0xff;
2590 writeData(f
, data
, length
* 2);
2600 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2601 static int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2603 target_t
*target
= get_current_target(cmd_ctx
);
2604 struct timeval timeout
, now
;
2606 gettimeofday(&timeout
, NULL
);
2609 return ERROR_COMMAND_SYNTAX_ERROR
;
2612 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2618 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2620 static const int maxSample
=10000;
2621 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2626 int retval
=ERROR_OK
;
2627 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2628 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2632 target_poll(target
);
2633 if (target
->state
== TARGET_HALTED
)
2635 u32 t
=*((u32
*)reg
->value
);
2636 samples
[numSamples
++]=t
;
2637 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2638 target_poll(target
);
2639 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2640 } else if (target
->state
== TARGET_RUNNING
)
2642 /* We want to quickly sample the PC. */
2643 if((retval
= target_halt(target
)) != ERROR_OK
)
2650 command_print(cmd_ctx
, "Target not halted or running");
2654 if (retval
!=ERROR_OK
)
2659 gettimeofday(&now
, NULL
);
2660 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2662 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2663 if((retval
= target_poll(target
)) != ERROR_OK
)
2668 if (target
->state
== TARGET_HALTED
)
2670 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2672 if((retval
= target_poll(target
)) != ERROR_OK
)
2677 writeGmon(samples
, numSamples
, args
[1]);
2678 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2687 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2690 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2693 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2697 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2698 valObjPtr
= Jim_NewIntObj(interp
, val
);
2699 if (!nameObjPtr
|| !valObjPtr
)
2705 Jim_IncrRefCount(nameObjPtr
);
2706 Jim_IncrRefCount(valObjPtr
);
2707 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2708 Jim_DecrRefCount(interp
, nameObjPtr
);
2709 Jim_DecrRefCount(interp
, valObjPtr
);
2711 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2715 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2717 command_context_t
*context
;
2720 context
= Jim_GetAssocData(interp
, "context");
2721 if (context
== NULL
)
2723 LOG_ERROR("mem2array: no command context");
2726 target
= get_current_target(context
);
2729 LOG_ERROR("mem2array: no current target");
2733 return target_mem2array(interp
, target
, argc
-1, argv
+1);
2736 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2744 const char *varname
;
2749 /* argv[1] = name of array to receive the data
2750 * argv[2] = desired width
2751 * argv[3] = memory address
2752 * argv[4] = count of times to read
2755 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2758 varname
= Jim_GetString(argv
[0], &len
);
2759 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2761 e
= Jim_GetLong(interp
, argv
[1], &l
);
2767 e
= Jim_GetLong(interp
, argv
[2], &l
);
2772 e
= Jim_GetLong(interp
, argv
[3], &l
);
2788 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2789 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2793 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2794 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2797 if ((addr
+ (len
* width
)) < addr
) {
2798 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2799 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2802 /* absurd transfer size? */
2804 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2805 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2810 ((width
== 2) && ((addr
& 1) == 0)) ||
2811 ((width
== 4) && ((addr
& 3) == 0))) {
2815 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2816 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2817 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2828 /* Slurp... in buffer size chunks */
2830 count
= len
; /* in objects.. */
2831 if (count
> (sizeof(buffer
)/width
)) {
2832 count
= (sizeof(buffer
)/width
);
2835 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2836 if (retval
!= ERROR_OK
) {
2838 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2839 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2840 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2844 v
= 0; /* shut up gcc */
2845 for (i
= 0 ;i
< count
;i
++, n
++) {
2848 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2851 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2854 v
= buffer
[i
] & 0x0ff;
2857 new_int_array_element(interp
, varname
, n
, v
);
2863 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2868 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2871 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2875 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2879 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2886 Jim_IncrRefCount(nameObjPtr
);
2887 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2888 Jim_DecrRefCount(interp
, nameObjPtr
);
2890 if (valObjPtr
== NULL
)
2893 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2894 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2899 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2901 command_context_t
*context
;
2904 context
= Jim_GetAssocData(interp
, "context");
2905 if (context
== NULL
){
2906 LOG_ERROR("array2mem: no command context");
2909 target
= get_current_target(context
);
2910 if (target
== NULL
){
2911 LOG_ERROR("array2mem: no current target");
2915 return target_array2mem( interp
,target
, argc
-1, argv
+1 );
2918 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2926 const char *varname
;
2931 /* argv[1] = name of array to get the data
2932 * argv[2] = desired width
2933 * argv[3] = memory address
2934 * argv[4] = count to write
2937 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2940 varname
= Jim_GetString(argv
[0], &len
);
2941 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2943 e
= Jim_GetLong(interp
, argv
[1], &l
);
2949 e
= Jim_GetLong(interp
, argv
[2], &l
);
2954 e
= Jim_GetLong(interp
, argv
[3], &l
);
2970 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2971 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2975 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2976 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2979 if ((addr
+ (len
* width
)) < addr
) {
2980 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2981 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2984 /* absurd transfer size? */
2986 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2987 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
2992 ((width
== 2) && ((addr
& 1) == 0)) ||
2993 ((width
== 4) && ((addr
& 3) == 0))) {
2997 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2998 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2999 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
3010 /* Slurp... in buffer size chunks */
3012 count
= len
; /* in objects.. */
3013 if (count
> (sizeof(buffer
)/width
)) {
3014 count
= (sizeof(buffer
)/width
);
3017 v
= 0; /* shut up gcc */
3018 for (i
= 0 ;i
< count
;i
++, n
++) {
3019 get_int_array_element(interp
, varname
, n
, &v
);
3022 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
3025 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
3028 buffer
[i
] = v
& 0x0ff;
3034 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
3035 if (retval
!= ERROR_OK
) {
3037 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
3038 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3039 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: cannot read memory", NULL
);
3045 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3050 void target_all_handle_event( enum target_event e
)
3054 LOG_DEBUG( "**all*targets: event: %d, %s",
3056 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3058 target
= all_targets
;
3060 target_handle_event( target
, e
);
3061 target
= target
->next
;
3065 void target_handle_event( target_t
*target
, enum target_event e
)
3067 target_event_action_t
*teap
;
3070 teap
= target
->event_action
;
3074 if( teap
->event
== e
){
3076 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3077 target
->target_number
,
3081 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
,
3082 Jim_GetString( teap
->body
, NULL
) );
3083 if (Jim_EvalObj( interp
, teap
->body
)!=JIM_OK
)
3085 Jim_PrintErrorMessage(interp
);
3091 LOG_DEBUG( "event: %d %s - no action",
3093 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3097 enum target_cfg_param
{
3100 TCFG_WORK_AREA_VIRT
,
3101 TCFG_WORK_AREA_PHYS
,
3102 TCFG_WORK_AREA_SIZE
,
3103 TCFG_WORK_AREA_BACKUP
,
3106 TCFG_CHAIN_POSITION
,
3109 static Jim_Nvp nvp_config_opts
[] = {
3110 { .name
= "-type", .value
= TCFG_TYPE
},
3111 { .name
= "-event", .value
= TCFG_EVENT
},
3112 { .name
= "-work-area-virt", .value
= TCFG_WORK_AREA_VIRT
},
3113 { .name
= "-work-area-phys", .value
= TCFG_WORK_AREA_PHYS
},
3114 { .name
= "-work-area-size", .value
= TCFG_WORK_AREA_SIZE
},
3115 { .name
= "-work-area-backup", .value
= TCFG_WORK_AREA_BACKUP
},
3116 { .name
= "-endian" , .value
= TCFG_ENDIAN
},
3117 { .name
= "-variant", .value
= TCFG_VARIANT
},
3118 { .name
= "-chain-position", .value
= TCFG_CHAIN_POSITION
},
3120 { .name
= NULL
, .value
= -1 }
3123 static int target_configure( Jim_GetOptInfo
*goi
, target_t
*target
)
3131 /* parse config or cget options ... */
3132 while( goi
->argc
> 0 ){
3133 Jim_SetEmptyResult( goi
->interp
);
3134 /* Jim_GetOpt_Debug( goi ); */
3136 if( target
->type
->target_jim_configure
){
3137 /* target defines a configure function */
3138 /* target gets first dibs on parameters */
3139 e
= (*(target
->type
->target_jim_configure
))( target
, goi
);
3148 /* otherwise we 'continue' below */
3150 e
= Jim_GetOpt_Nvp( goi
, nvp_config_opts
, &n
);
3152 Jim_GetOpt_NvpUnknown( goi
, nvp_config_opts
, 0 );
3158 if( goi
->isconfigure
){
3159 Jim_SetResult_sprintf( goi
->interp
, "not setable: %s", n
->name
);
3163 if( goi
->argc
!= 0 ){
3164 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
3168 Jim_SetResultString( goi
->interp
, target
->type
->name
, -1 );
3172 if( goi
->argc
== 0 ){
3173 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ...");
3177 e
= Jim_GetOpt_Nvp( goi
, nvp_target_event
, &n
);
3179 Jim_GetOpt_NvpUnknown( goi
, nvp_target_event
, 1 );
3183 if( goi
->isconfigure
){
3184 if( goi
->argc
!= 1 ){
3185 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
3189 if( goi
->argc
!= 0 ){
3190 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
3196 target_event_action_t
*teap
;
3198 teap
= target
->event_action
;
3199 /* replace existing? */
3201 if( teap
->event
== (enum target_event
)n
->value
){
3207 if( goi
->isconfigure
){
3210 teap
= calloc( 1, sizeof(*teap
) );
3212 teap
->event
= n
->value
;
3213 Jim_GetOpt_Obj( goi
, &o
);
3215 Jim_DecrRefCount( interp
, teap
->body
);
3217 teap
->body
= Jim_DuplicateObj( goi
->interp
, o
);
3220 * Tcl/TK - "tk events" have a nice feature.
3221 * See the "BIND" command.
3222 * We should support that here.
3223 * You can specify %X and %Y in the event code.
3224 * The idea is: %T - target name.
3225 * The idea is: %N - target number
3226 * The idea is: %E - event name.
3228 Jim_IncrRefCount( teap
->body
);
3230 /* add to head of event list */
3231 teap
->next
= target
->event_action
;
3232 target
->event_action
= teap
;
3233 Jim_SetEmptyResult(goi
->interp
);
3237 Jim_SetEmptyResult( goi
->interp
);
3239 Jim_SetResult( goi
->interp
, Jim_DuplicateObj( goi
->interp
, teap
->body
) );
3246 case TCFG_WORK_AREA_VIRT
:
3247 if( goi
->isconfigure
){
3248 target_free_all_working_areas(target
);
3249 e
= Jim_GetOpt_Wide( goi
, &w
);
3253 target
->working_area_virt
= w
;
3255 if( goi
->argc
!= 0 ){
3259 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_virt
) );
3263 case TCFG_WORK_AREA_PHYS
:
3264 if( goi
->isconfigure
){
3265 target_free_all_working_areas(target
);
3266 e
= Jim_GetOpt_Wide( goi
, &w
);
3270 target
->working_area_phys
= w
;
3272 if( goi
->argc
!= 0 ){
3276 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_phys
) );
3280 case TCFG_WORK_AREA_SIZE
:
3281 if( goi
->isconfigure
){
3282 target_free_all_working_areas(target
);
3283 e
= Jim_GetOpt_Wide( goi
, &w
);
3287 target
->working_area_size
= w
;
3289 if( goi
->argc
!= 0 ){
3293 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3297 case TCFG_WORK_AREA_BACKUP
:
3298 if( goi
->isconfigure
){
3299 target_free_all_working_areas(target
);
3300 e
= Jim_GetOpt_Wide( goi
, &w
);
3304 /* make this exactly 1 or 0 */
3305 target
->backup_working_area
= (!!w
);
3307 if( goi
->argc
!= 0 ){
3311 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3312 /* loop for more e*/
3316 if( goi
->isconfigure
){
3317 e
= Jim_GetOpt_Nvp( goi
, nvp_target_endian
, &n
);
3319 Jim_GetOpt_NvpUnknown( goi
, nvp_target_endian
, 1 );
3322 target
->endianness
= n
->value
;
3324 if( goi
->argc
!= 0 ){
3328 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3329 if( n
->name
== NULL
){
3330 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3331 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3333 Jim_SetResultString( goi
->interp
, n
->name
, -1 );
3338 if( goi
->isconfigure
){
3339 if( goi
->argc
< 1 ){
3340 Jim_SetResult_sprintf( goi
->interp
,
3345 if( target
->variant
){
3346 free((void *)(target
->variant
));
3348 e
= Jim_GetOpt_String( goi
, &cp
, NULL
);
3349 target
->variant
= strdup(cp
);
3351 if( goi
->argc
!= 0 ){
3355 Jim_SetResultString( goi
->interp
, target
->variant
,-1 );
3358 case TCFG_CHAIN_POSITION
:
3359 if( goi
->isconfigure
){
3362 target_free_all_working_areas(target
);
3363 e
= Jim_GetOpt_Obj( goi
, &o
);
3367 tap
= jtag_TapByJimObj( goi
->interp
, o
);
3371 /* make this exactly 1 or 0 */
3374 if( goi
->argc
!= 0 ){
3378 Jim_SetResultString( interp
, target
->tap
->dotted_name
, -1 );
3379 /* loop for more e*/
3382 } /* while( goi->argc ) */
3385 /* done - we return */
3389 /** this is the 'tcl' handler for the target specific command */
3390 static int tcl_target_func( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3398 struct command_context_s
*cmd_ctx
;
3405 TS_CMD_MWW
, TS_CMD_MWH
, TS_CMD_MWB
,
3406 TS_CMD_MDW
, TS_CMD_MDH
, TS_CMD_MDB
,
3407 TS_CMD_MRW
, TS_CMD_MRH
, TS_CMD_MRB
,
3408 TS_CMD_MEM2ARRAY
, TS_CMD_ARRAY2MEM
,
3416 TS_CMD_INVOKE_EVENT
,
3419 static const Jim_Nvp target_options
[] = {
3420 { .name
= "configure", .value
= TS_CMD_CONFIGURE
},
3421 { .name
= "cget", .value
= TS_CMD_CGET
},
3422 { .name
= "mww", .value
= TS_CMD_MWW
},
3423 { .name
= "mwh", .value
= TS_CMD_MWH
},
3424 { .name
= "mwb", .value
= TS_CMD_MWB
},
3425 { .name
= "mdw", .value
= TS_CMD_MDW
},
3426 { .name
= "mdh", .value
= TS_CMD_MDH
},
3427 { .name
= "mdb", .value
= TS_CMD_MDB
},
3428 { .name
= "mem2array", .value
= TS_CMD_MEM2ARRAY
},
3429 { .name
= "array2mem", .value
= TS_CMD_ARRAY2MEM
},
3430 { .name
= "eventlist", .value
= TS_CMD_EVENTLIST
},
3431 { .name
= "curstate", .value
= TS_CMD_CURSTATE
},
3433 { .name
= "arp_examine", .value
= TS_CMD_EXAMINE
},
3434 { .name
= "arp_poll", .value
= TS_CMD_POLL
},
3435 { .name
= "arp_reset", .value
= TS_CMD_RESET
},
3436 { .name
= "arp_halt", .value
= TS_CMD_HALT
},
3437 { .name
= "arp_waitstate", .value
= TS_CMD_WAITSTATE
},
3438 { .name
= "invoke-event", .value
= TS_CMD_INVOKE_EVENT
},
3440 { .name
= NULL
, .value
= -1 },
3443 /* go past the "command" */
3444 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3446 target
= Jim_CmdPrivData( goi
.interp
);
3447 cmd_ctx
= Jim_GetAssocData(goi
.interp
, "context");
3449 /* commands here are in an NVP table */
3450 e
= Jim_GetOpt_Nvp( &goi
, target_options
, &n
);
3452 Jim_GetOpt_NvpUnknown( &goi
, target_options
, 0 );
3455 /* Assume blank result */
3456 Jim_SetEmptyResult( goi
.interp
);
3459 case TS_CMD_CONFIGURE
:
3461 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "missing: -option VALUE ...");
3464 goi
.isconfigure
= 1;
3465 return target_configure( &goi
, target
);
3467 // some things take params
3469 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "missing: ?-option?");
3472 goi
.isconfigure
= 0;
3473 return target_configure( &goi
, target
);
3481 * argv[3] = optional count.
3484 if( (goi
.argc
== 3) || (goi
.argc
== 4) ){
3488 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR DATA [COUNT]", n
->name
);
3492 e
= Jim_GetOpt_Wide( &goi
, &a
);
3497 e
= Jim_GetOpt_Wide( &goi
, &b
);
3502 e
= Jim_GetOpt_Wide( &goi
, &c
);
3512 target_buffer_set_u32( target
, target_buf
, b
);
3516 target_buffer_set_u16( target
, target_buf
, b
);
3520 target_buffer_set_u8( target
, target_buf
, b
);
3524 for( x
= 0 ; x
< c
; x
++ ){
3525 e
= target
->type
->write_memory( target
, a
, b
, 1, target_buf
);
3526 if( e
!= ERROR_OK
){
3527 Jim_SetResult_sprintf( interp
, "Error writing @ 0x%08x: %d\n", (int)(a
), e
);
3540 /* argv[0] = command
3542 * argv[2] = optional count
3544 if( (goi
.argc
== 2) || (goi
.argc
== 3) ){
3545 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR [COUNT]", n
->name
);
3548 e
= Jim_GetOpt_Wide( &goi
, &a
);
3553 e
= Jim_GetOpt_Wide( &goi
, &c
);
3560 b
= 1; /* shut up gcc */
3573 /* convert to "bytes" */
3575 /* count is now in 'BYTES' */
3581 e
= target
->type
->read_memory( target
, a
, b
, y
/ b
, target_buf
);
3582 if( e
!= ERROR_OK
){
3583 Jim_SetResult_sprintf( interp
, "error reading target @ 0x%08lx", (int)(a
) );
3587 Jim_fprintf( interp
, interp
->cookie_stdout
, "0x%08x ", (int)(a
) );
3590 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 4 ){
3591 z
= target_buffer_get_u32( target
, &(target_buf
[ x
* 4 ]) );
3592 Jim_fprintf( interp
, interp
->cookie_stdout
, "%08x ", (int)(z
) );
3594 for( ; (x
< 16) ; x
+= 4 ){
3595 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3599 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 2 ){
3600 z
= target_buffer_get_u16( target
, &(target_buf
[ x
* 2 ]) );
3601 Jim_fprintf( interp
, interp
->cookie_stdout
, "%04x ", (int)(z
) );
3603 for( ; (x
< 16) ; x
+= 2 ){
3604 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3609 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 1 ){
3610 z
= target_buffer_get_u8( target
, &(target_buf
[ x
* 4 ]) );
3611 Jim_fprintf( interp
, interp
->cookie_stdout
, "%02x ", (int)(z
) );
3613 for( ; (x
< 16) ; x
+= 1 ){
3614 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3618 /* ascii-ify the bytes */
3619 for( x
= 0 ; x
< y
; x
++ ){
3620 if( (target_buf
[x
] >= 0x20) &&
3621 (target_buf
[x
] <= 0x7e) ){
3625 target_buf
[x
] = '.';
3630 target_buf
[x
] = ' ';
3635 /* print - with a newline */
3636 Jim_fprintf( interp
, interp
->cookie_stdout
, "%s\n", target_buf
);
3642 case TS_CMD_MEM2ARRAY
:
3643 return target_mem2array( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3645 case TS_CMD_ARRAY2MEM
:
3646 return target_array2mem( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3648 case TS_CMD_EXAMINE
:
3650 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3653 e
= target
->type
->examine( target
);
3654 if( e
!= ERROR_OK
){
3655 Jim_SetResult_sprintf( interp
, "examine-fails: %d", e
);
3661 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3664 if( !(target
->type
->examined
) ){
3665 e
= ERROR_TARGET_NOT_EXAMINED
;
3667 e
= target
->type
->poll( target
);
3669 if( e
!= ERROR_OK
){
3670 Jim_SetResult_sprintf( interp
, "poll-fails: %d", e
);
3677 if( goi
.argc
!= 2 ){
3678 Jim_WrongNumArgs( interp
, 2, argv
, "t|f|assert|deassert BOOL");
3681 e
= Jim_GetOpt_Nvp( &goi
, nvp_assert
, &n
);
3683 Jim_GetOpt_NvpUnknown( &goi
, nvp_assert
, 1 );
3686 /* the halt or not param */
3687 e
= Jim_GetOpt_Wide( &goi
, &a
);
3691 /* determine if we should halt or not. */
3692 target
->reset_halt
= !!a
;
3693 /* When this happens - all workareas are invalid. */
3694 target_free_all_working_areas_restore(target
, 0);
3697 if( n
->value
== NVP_ASSERT
){
3698 target
->type
->assert_reset( target
);
3700 target
->type
->deassert_reset( target
);
3705 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "halt [no parameters]");
3708 target
->type
->halt( target
);
3710 case TS_CMD_WAITSTATE
:
3711 /* params: <name> statename timeoutmsecs */
3712 if( goi
.argc
!= 2 ){
3713 Jim_SetResult_sprintf( goi
.interp
, "%s STATENAME TIMEOUTMSECS", n
->name
);
3716 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_state
, &n
);
3718 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_state
,1 );
3721 e
= Jim_GetOpt_Wide( &goi
, &a
);
3725 e
= target_wait_state( target
, n
->value
, a
);
3726 if( e
!= ERROR_OK
){
3727 Jim_SetResult_sprintf( goi
.interp
,
3728 "target: %s wait %s fails (%d) %s",
3731 e
, target_strerror_safe(e
) );
3736 case TS_CMD_EVENTLIST
:
3737 /* List for human, Events defined for this target.
3738 * scripts/programs should use 'name cget -event NAME'
3741 target_event_action_t
*teap
;
3742 teap
= target
->event_action
;
3743 command_print( cmd_ctx
, "Event actions for target (%d) %s\n",
3744 target
->target_number
,
3746 command_print( cmd_ctx
, "%-25s | Body", "Event");
3747 command_print( cmd_ctx
, "------------------------- | ----------------------------------------");
3749 command_print( cmd_ctx
,
3751 Jim_Nvp_value2name_simple( nvp_target_event
, teap
->event
)->name
,
3752 Jim_GetString( teap
->body
, NULL
) );
3755 command_print( cmd_ctx
, "***END***");
3758 case TS_CMD_CURSTATE
:
3759 if( goi
.argc
!= 0 ){
3760 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "[no parameters]");
3763 Jim_SetResultString( goi
.interp
,
3764 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
,-1);
3766 case TS_CMD_INVOKE_EVENT
:
3767 if( goi
.argc
!= 1 ){
3768 Jim_SetResult_sprintf( goi
.interp
, "%s ?EVENTNAME?",n
->name
);
3771 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_event
, &n
);
3773 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_event
, 1 );
3776 target_handle_event( target
, n
->value
);
3782 static int target_create( Jim_GetOptInfo
*goi
)
3791 struct command_context_s
*cmd_ctx
;
3793 cmd_ctx
= Jim_GetAssocData(goi
->interp
, "context");
3794 if( goi
->argc
< 3 ){
3795 Jim_WrongNumArgs( goi
->interp
, 1, goi
->argv
, "?name? ?type? ..options...");
3800 Jim_GetOpt_Obj( goi
, &new_cmd
);
3801 /* does this command exist? */
3802 cmd
= Jim_GetCommand( goi
->interp
, new_cmd
, JIM_ERRMSG
);
3804 cp
= Jim_GetString( new_cmd
, NULL
);
3805 Jim_SetResult_sprintf(goi
->interp
, "Command/target: %s Exists", cp
);
3810 e
= Jim_GetOpt_String( goi
, &cp2
, NULL
);
3812 /* now does target type exist */
3813 for( x
= 0 ; target_types
[x
] ; x
++ ){
3814 if( 0 == strcmp( cp
, target_types
[x
]->name
) ){
3819 if( target_types
[x
] == NULL
){
3820 Jim_SetResult_sprintf( goi
->interp
, "Unknown target type %s, try one of ", cp
);
3821 for( x
= 0 ; target_types
[x
] ; x
++ ){
3822 if( target_types
[x
+1] ){
3823 Jim_AppendStrings( goi
->interp
,
3824 Jim_GetResult(goi
->interp
),
3825 target_types
[x
]->name
,
3828 Jim_AppendStrings( goi
->interp
,
3829 Jim_GetResult(goi
->interp
),
3831 target_types
[x
]->name
,NULL
);
3838 target
= calloc(1,sizeof(target_t
));
3839 /* set target number */
3840 target
->target_number
= new_target_number();
3842 /* allocate memory for each unique target type */
3843 target
->type
= (target_type_t
*)calloc(1,sizeof(target_type_t
));
3845 memcpy( target
->type
, target_types
[x
], sizeof(target_type_t
));
3847 /* will be set by "-endian" */
3848 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3850 target
->working_area
= 0x0;
3851 target
->working_area_size
= 0x0;
3852 target
->working_areas
= NULL
;
3853 target
->backup_working_area
= 0;
3855 target
->state
= TARGET_UNKNOWN
;
3856 target
->debug_reason
= DBG_REASON_UNDEFINED
;
3857 target
->reg_cache
= NULL
;
3858 target
->breakpoints
= NULL
;
3859 target
->watchpoints
= NULL
;
3860 target
->next
= NULL
;
3861 target
->arch_info
= NULL
;
3863 target
->display
= 1;
3865 /* initialize trace information */
3866 target
->trace_info
= malloc(sizeof(trace_t
));
3867 target
->trace_info
->num_trace_points
= 0;
3868 target
->trace_info
->trace_points_size
= 0;
3869 target
->trace_info
->trace_points
= NULL
;
3870 target
->trace_info
->trace_history_size
= 0;
3871 target
->trace_info
->trace_history
= NULL
;
3872 target
->trace_info
->trace_history_pos
= 0;
3873 target
->trace_info
->trace_history_overflowed
= 0;
3875 target
->dbgmsg
= NULL
;
3876 target
->dbg_msg_enabled
= 0;
3878 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3880 /* Do the rest as "configure" options */
3881 goi
->isconfigure
= 1;
3882 e
= target_configure( goi
, target
);
3884 if (target
->tap
== NULL
)
3886 Jim_SetResultString( interp
, "-chain-position required when creating target", -1);
3891 free( target
->type
);
3896 if( target
->endianness
== TARGET_ENDIAN_UNKNOWN
){
3897 /* default endian to little if not specified */
3898 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3901 /* incase variant is not set */
3902 if (!target
->variant
)
3903 target
->variant
= strdup("");
3905 /* create the target specific commands */
3906 if( target
->type
->register_commands
){
3907 (*(target
->type
->register_commands
))( cmd_ctx
);
3909 if( target
->type
->target_create
){
3910 (*(target
->type
->target_create
))( target
, goi
->interp
);
3913 /* append to end of list */
3916 tpp
= &(all_targets
);
3918 tpp
= &( (*tpp
)->next
);
3923 cp
= Jim_GetString( new_cmd
, NULL
);
3924 target
->cmd_name
= strdup(cp
);
3926 /* now - create the new target name command */
3927 e
= Jim_CreateCommand( goi
->interp
,
3930 tcl_target_func
, /* C function */
3931 target
, /* private data */
3932 NULL
); /* no del proc */
3937 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3941 struct command_context_s
*cmd_ctx
;
3945 /* TG = target generic */
3953 const char *target_cmds
[] = {
3954 "create", "types", "names", "current", "number",
3956 NULL
/* terminate */
3959 LOG_DEBUG("Target command params:");
3960 LOG_DEBUG("%s", Jim_Debug_ArgvString(interp
, argc
, argv
));
3962 cmd_ctx
= Jim_GetAssocData( interp
, "context" );
3964 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3966 if( goi
.argc
== 0 ){
3967 Jim_WrongNumArgs(interp
, 1, argv
, "missing: command ...");
3971 /* Jim_GetOpt_Debug( &goi ); */
3972 r
= Jim_GetOpt_Enum( &goi
, target_cmds
, &x
);
3979 Jim_Panic(goi
.interp
,"Why am I here?");
3981 case TG_CMD_CURRENT
:
3982 if( goi
.argc
!= 0 ){
3983 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters");
3986 Jim_SetResultString( goi
.interp
, get_current_target( cmd_ctx
)->cmd_name
, -1 );
3989 if( goi
.argc
!= 0 ){
3990 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
3993 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
3994 for( x
= 0 ; target_types
[x
] ; x
++ ){
3995 Jim_ListAppendElement( goi
.interp
,
3996 Jim_GetResult(goi
.interp
),
3997 Jim_NewStringObj( goi
.interp
, target_types
[x
]->name
, -1 ) );
4001 if( goi
.argc
!= 0 ){
4002 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4005 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4006 target
= all_targets
;
4008 Jim_ListAppendElement( goi
.interp
,
4009 Jim_GetResult(goi
.interp
),
4010 Jim_NewStringObj( goi
.interp
, target
->cmd_name
, -1 ) );
4011 target
= target
->next
;
4016 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "?name ... config options ...");
4019 return target_create( &goi
);
4022 if( goi
.argc
!= 1 ){
4023 Jim_SetResult_sprintf( goi
.interp
, "expected: target number ?NUMBER?");
4026 e
= Jim_GetOpt_Wide( &goi
, &w
);
4032 t
= get_target_by_num(w
);
4034 Jim_SetResult_sprintf( goi
.interp
,"Target: number %d does not exist", (int)(w
));
4037 Jim_SetResultString( goi
.interp
, t
->cmd_name
, -1 );
4041 if( goi
.argc
!= 0 ){
4042 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "<no parameters>");
4045 Jim_SetResult( goi
.interp
,
4046 Jim_NewIntObj( goi
.interp
, max_target_number()));
4062 static int fastload_num
;
4063 static struct FastLoad
*fastload
;
4065 static void free_fastload(void)
4070 for (i
=0; i
<fastload_num
; i
++)
4072 if (fastload
[i
].data
)
4073 free(fastload
[i
].data
);
4083 static int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4089 u32 max_address
=0xffffffff;
4095 duration_t duration
;
4096 char *duration_text
;
4098 if ((argc
< 1)||(argc
> 5))
4100 return ERROR_COMMAND_SYNTAX_ERROR
;
4103 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
4106 image
.base_address_set
= 1;
4107 image
.base_address
= strtoul(args
[1], NULL
, 0);
4111 image
.base_address_set
= 0;
4115 image
.start_address_set
= 0;
4119 min_address
=strtoul(args
[3], NULL
, 0);
4123 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
4126 if (min_address
>max_address
)
4128 return ERROR_COMMAND_SYNTAX_ERROR
;
4131 duration_start_measure(&duration
);
4133 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
4140 fastload_num
=image
.num_sections
;
4141 fastload
=(struct FastLoad
*)malloc(sizeof(struct FastLoad
)*image
.num_sections
);
4144 image_close(&image
);
4147 memset(fastload
, 0, sizeof(struct FastLoad
)*image
.num_sections
);
4148 for (i
= 0; i
< image
.num_sections
; i
++)
4150 buffer
= malloc(image
.sections
[i
].size
);
4153 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
4157 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
4167 /* DANGER!!! beware of unsigned comparision here!!! */
4169 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
4170 (image
.sections
[i
].base_address
<max_address
))
4172 if (image
.sections
[i
].base_address
<min_address
)
4174 /* clip addresses below */
4175 offset
+=min_address
-image
.sections
[i
].base_address
;
4179 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
4181 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
4184 fastload
[i
].address
=image
.sections
[i
].base_address
+offset
;
4185 fastload
[i
].data
=malloc(length
);
4186 if (fastload
[i
].data
==NULL
)
4191 memcpy(fastload
[i
].data
, buffer
+offset
, length
);
4192 fastload
[i
].length
=length
;
4194 image_size
+= length
;
4195 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
4201 duration_stop_measure(&duration
, &duration_text
);
4202 if (retval
==ERROR_OK
)
4204 command_print(cmd_ctx
, "Loaded %u bytes in %s", image_size
, duration_text
);
4205 command_print(cmd_ctx
, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4207 free(duration_text
);
4209 image_close(&image
);
4211 if (retval
!=ERROR_OK
)
4219 static int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4222 return ERROR_COMMAND_SYNTAX_ERROR
;
4225 LOG_ERROR("No image in memory");
4229 int ms
=timeval_ms();
4231 int retval
=ERROR_OK
;
4232 for (i
=0; i
<fastload_num
;i
++)
4234 target_t
*target
= get_current_target(cmd_ctx
);
4235 command_print(cmd_ctx
, "Write to 0x%08x, length 0x%08x", fastload
[i
].address
, fastload
[i
].length
);
4236 if (retval
==ERROR_OK
)
4238 retval
= target_write_buffer(target
, fastload
[i
].address
, fastload
[i
].length
, fastload
[i
].data
);
4240 size
+=fastload
[i
].length
;
4242 int after
=timeval_ms();
4243 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)