1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008, Duane Ellis *
9 * openocd@duaneeellis.com *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
14 * Copyright (C) 2008 by Rick Altherr *
15 * kc8apf@kc8apf.net> *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program; if not, write to the *
29 * Free Software Foundation, Inc., *
30 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
31 ***************************************************************************/
36 #include "replacements.h"
38 #include "target_request.h"
41 #include "configuration.h"
42 #include "binarybuffer.h"
49 #include <sys/types.h>
57 #include <time_support.h>
62 int cli_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
);
65 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
80 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
81 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
83 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
84 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
85 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
86 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
87 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
88 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
89 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
90 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
92 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
93 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
98 extern target_type_t arm7tdmi_target
;
99 extern target_type_t arm720t_target
;
100 extern target_type_t arm9tdmi_target
;
101 extern target_type_t arm920t_target
;
102 extern target_type_t arm966e_target
;
103 extern target_type_t arm926ejs_target
;
104 extern target_type_t feroceon_target
;
105 extern target_type_t xscale_target
;
106 extern target_type_t cortexm3_target
;
107 extern target_type_t arm11_target
;
108 extern target_type_t mips_m4k_target
;
110 target_type_t
*target_types
[] =
126 target_t
*all_targets
= NULL
;
127 target_event_callback_t
*target_event_callbacks
= NULL
;
128 target_timer_callback_t
*target_timer_callbacks
= NULL
;
130 const Jim_Nvp nvp_assert
[] = {
131 { .name
= "assert", NVP_ASSERT
},
132 { .name
= "deassert", NVP_DEASSERT
},
133 { .name
= "T", NVP_ASSERT
},
134 { .name
= "F", NVP_DEASSERT
},
135 { .name
= "t", NVP_ASSERT
},
136 { .name
= "f", NVP_DEASSERT
},
137 { .name
= NULL
, .value
= -1 }
140 const Jim_Nvp nvp_error_target
[] = {
141 { .value
= ERROR_TARGET_INVALID
, .name
= "err-invalid" },
142 { .value
= ERROR_TARGET_INIT_FAILED
, .name
= "err-init-failed" },
143 { .value
= ERROR_TARGET_TIMEOUT
, .name
= "err-timeout" },
144 { .value
= ERROR_TARGET_NOT_HALTED
, .name
= "err-not-halted" },
145 { .value
= ERROR_TARGET_FAILURE
, .name
= "err-failure" },
146 { .value
= ERROR_TARGET_UNALIGNED_ACCESS
, .name
= "err-unaligned-access" },
147 { .value
= ERROR_TARGET_DATA_ABORT
, .name
= "err-data-abort" },
148 { .value
= ERROR_TARGET_RESOURCE_NOT_AVAILABLE
, .name
= "err-resource-not-available" },
149 { .value
= ERROR_TARGET_TRANSLATION_FAULT
, .name
= "err-translation-fault" },
150 { .value
= ERROR_TARGET_NOT_RUNNING
, .name
= "err-not-running" },
151 { .value
= ERROR_TARGET_NOT_EXAMINED
, .name
= "err-not-examined" },
152 { .value
= -1, .name
= NULL
}
155 const char *target_strerror_safe( int err
)
159 n
= Jim_Nvp_value2name_simple( nvp_error_target
, err
);
160 if( n
->name
== NULL
){
167 const Jim_Nvp nvp_target_event
[] = {
168 { .value
= TARGET_EVENT_OLD_gdb_program_config
, .name
= "old-gdb_program_config" },
169 { .value
= TARGET_EVENT_OLD_pre_resume
, .name
= "old-pre_resume" },
172 { .value
= TARGET_EVENT_EARLY_HALTED
, .name
= "early-halted" },
173 { .value
= TARGET_EVENT_HALTED
, .name
= "halted" },
174 { .value
= TARGET_EVENT_RESUMED
, .name
= "resumed" },
175 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
176 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
179 { .name
= "gdb-start", .value
= TARGET_EVENT_GDB_START
},
180 { .name
= "gdb-end", .value
= TARGET_EVENT_GDB_END
},
183 /* historical name */
185 { .value
= TARGET_EVENT_RESET_START
, .name
= "reset-start" },
187 { .value
= TARGET_EVENT_RESET_ASSERT_PRE
, .name
= "reset-assert-pre" },
188 { .value
= TARGET_EVENT_RESET_ASSERT_POST
, .name
= "reset-assert-post" },
189 { .value
= TARGET_EVENT_RESET_DEASSERT_PRE
, .name
= "reset-deassert-pre" },
190 { .value
= TARGET_EVENT_RESET_DEASSERT_POST
, .name
= "reset-deassert-post" },
191 { .value
= TARGET_EVENT_RESET_HALT_PRE
, .name
= "reset-halt-pre" },
192 { .value
= TARGET_EVENT_RESET_HALT_POST
, .name
= "reset-halt-post" },
193 { .value
= TARGET_EVENT_RESET_WAIT_PRE
, .name
= "reset-wait-pre" },
194 { .value
= TARGET_EVENT_RESET_WAIT_POST
, .name
= "reset-wait-post" },
195 { .value
= TARGET_EVENT_RESET_INIT
, .name
= "reset-init" },
196 { .value
= TARGET_EVENT_RESET_END
, .name
= "reset-end" },
202 { .value
= TARGET_EVENT_EXAMINE_START
, .name
= "examine-start" },
203 { .value
= TARGET_EVENT_EXAMINE_START
, .name
= "examine-end" },
206 { .value
= TARGET_EVENT_DEBUG_HALTED
, .name
= "debug-halted" },
207 { .value
= TARGET_EVENT_DEBUG_RESUMED
, .name
= "debug-resumed" },
209 { .value
= TARGET_EVENT_GDB_ATTACH
, .name
= "gdb-attach" },
210 { .value
= TARGET_EVENT_GDB_DETACH
, .name
= "gdb-detach" },
213 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_START
, .name
= "gdb-flash-write-start" },
214 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_END
, .name
= "gdb-flash-write-end" },
216 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_START
, .name
= "gdb-flash-erase-start" },
217 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_END
, .name
= "gdb-flash-erase-end" },
219 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
220 { .value
= TARGET_EVENT_RESUMED
, .name
= "resume-ok" },
221 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
223 { .name
= NULL
, .value
= -1 }
226 const Jim_Nvp nvp_target_state
[] = {
227 { .name
= "unknown", .value
= TARGET_UNKNOWN
},
228 { .name
= "running", .value
= TARGET_RUNNING
},
229 { .name
= "halted", .value
= TARGET_HALTED
},
230 { .name
= "reset", .value
= TARGET_RESET
},
231 { .name
= "debug-running", .value
= TARGET_DEBUG_RUNNING
},
232 { .name
= NULL
, .value
= -1 },
236 const Jim_Nvp nvp_target_debug_reason
[] = {
237 { .name
= "debug-request" , .value
= DBG_REASON_DBGRQ
},
238 { .name
= "breakpoint" , .value
= DBG_REASON_BREAKPOINT
},
239 { .name
= "watchpoint" , .value
= DBG_REASON_WATCHPOINT
},
240 { .name
= "watchpoint-and-breakpoint", .value
= DBG_REASON_WPTANDBKPT
},
241 { .name
= "single-step" , .value
= DBG_REASON_SINGLESTEP
},
242 { .name
= "target-not-halted" , .value
= DBG_REASON_NOTHALTED
},
243 { .name
= "undefined" , .value
= DBG_REASON_UNDEFINED
},
244 { .name
= NULL
, .value
= -1 },
248 const Jim_Nvp nvp_target_endian
[] = {
249 { .name
= "big", .value
= TARGET_BIG_ENDIAN
},
250 { .name
= "little", .value
= TARGET_LITTLE_ENDIAN
},
251 { .name
= "be", .value
= TARGET_BIG_ENDIAN
},
252 { .name
= "le", .value
= TARGET_LITTLE_ENDIAN
},
253 { .name
= NULL
, .value
= -1 },
256 const Jim_Nvp nvp_reset_modes
[] = {
257 { .name
= "unknown", .value
= RESET_UNKNOWN
},
258 { .name
= "run" , .value
= RESET_RUN
},
259 { .name
= "halt" , .value
= RESET_HALT
},
260 { .name
= "init" , .value
= RESET_INIT
},
261 { .name
= NULL
, .value
= -1 },
265 max_target_number( void )
273 if( x
< t
->target_number
){
274 x
= (t
->target_number
)+1;
281 /* determine the number of the new target */
283 new_target_number( void )
288 /* number is 0 based */
292 if( x
< t
->target_number
){
293 x
= t
->target_number
;
300 static int target_continous_poll
= 1;
302 /* read a u32 from a buffer in target memory endianness */
303 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
305 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
306 return le_to_h_u32(buffer
);
308 return be_to_h_u32(buffer
);
311 /* read a u16 from a buffer in target memory endianness */
312 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
314 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
315 return le_to_h_u16(buffer
);
317 return be_to_h_u16(buffer
);
320 /* read a u8 from a buffer in target memory endianness */
321 u8
target_buffer_get_u8(target_t
*target
, u8
*buffer
)
323 return *buffer
& 0x0ff;
326 /* write a u32 to a buffer in target memory endianness */
327 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
329 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
330 h_u32_to_le(buffer
, value
);
332 h_u32_to_be(buffer
, value
);
335 /* write a u16 to a buffer in target memory endianness */
336 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
338 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
339 h_u16_to_le(buffer
, value
);
341 h_u16_to_be(buffer
, value
);
344 /* write a u8 to a buffer in target memory endianness */
345 void target_buffer_set_u8(target_t
*target
, u8
*buffer
, u8 value
)
350 /* returns a pointer to the n-th configured target */
351 target_t
* get_target_by_num(int num
)
353 target_t
*target
= all_targets
;
356 if( target
->target_number
== num
){
359 target
= target
->next
;
365 int get_num_by_target(target_t
*query_target
)
367 return query_target
->target_number
;
370 target_t
* get_current_target(command_context_t
*cmd_ctx
)
372 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
376 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
)
428 int target_process_reset(struct command_context_s
*cmd_ctx
, enum target_reset_mode reset_mode
)
433 n
= Jim_Nvp_value2name_simple( nvp_reset_modes
, reset_mode
);
434 if( n
->name
== NULL
){
435 LOG_ERROR("invalid reset mode");
439 sprintf( buf
, "ocd_process_reset %s", n
->name
);
440 retval
= Jim_Eval( interp
, buf
);
442 if(retval
!= JIM_OK
) {
443 Jim_PrintErrorMessage(interp
);
447 /* We want any events to be processed before the prompt */
448 retval
= target_call_timer_callbacks_now();
454 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
460 static int default_mmu(struct target_s
*target
, int *enabled
)
466 static int default_examine(struct target_s
*target
)
468 target
->type
->examined
= 1;
473 /* Targets that correctly implement init+examine, i.e.
474 * no communication with target during init:
478 int target_examine(void)
480 int retval
= ERROR_OK
;
481 target_t
*target
= all_targets
;
484 if ((retval
= target
->type
->examine(target
))!=ERROR_OK
)
486 target
= target
->next
;
491 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
493 if (!target
->type
->examined
)
495 LOG_ERROR("Target not examined yet");
498 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
501 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
503 if (!target
->type
->examined
)
505 LOG_ERROR("Target not examined yet");
508 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
511 static int target_soft_reset_halt_imp(struct target_s
*target
)
513 if (!target
->type
->examined
)
515 LOG_ERROR("Target not examined yet");
518 return target
->type
->soft_reset_halt_imp(target
);
521 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
)
523 if (!target
->type
->examined
)
525 LOG_ERROR("Target not examined yet");
528 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
);
531 int target_init(struct command_context_s
*cmd_ctx
)
533 target_t
*target
= all_targets
;
538 target
->type
->examined
= 0;
539 if (target
->type
->examine
== NULL
)
541 target
->type
->examine
= default_examine
;
544 if ((retval
= target
->type
->init_target(cmd_ctx
, target
)) != ERROR_OK
)
546 LOG_ERROR("target '%s' init failed", target
->type
->name
);
550 /* Set up default functions if none are provided by target */
551 if (target
->type
->virt2phys
== NULL
)
553 target
->type
->virt2phys
= default_virt2phys
;
555 target
->type
->virt2phys
= default_virt2phys
;
556 /* a non-invasive way(in terms of patches) to add some code that
557 * runs before the type->write/read_memory implementation
559 target
->type
->write_memory_imp
= target
->type
->write_memory
;
560 target
->type
->write_memory
= target_write_memory_imp
;
561 target
->type
->read_memory_imp
= target
->type
->read_memory
;
562 target
->type
->read_memory
= target_read_memory_imp
;
563 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
564 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
565 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
566 target
->type
->run_algorithm
= target_run_algorithm_imp
;
569 if (target
->type
->mmu
== NULL
)
571 target
->type
->mmu
= default_mmu
;
573 target
= target
->next
;
578 if((retval
= target_register_user_commands(cmd_ctx
)) != ERROR_OK
)
580 if((retval
= target_register_timer_callback(handle_target
, 100, 1, NULL
)) != ERROR_OK
)
587 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
589 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
591 if (callback
== NULL
)
593 return ERROR_INVALID_ARGUMENTS
;
598 while ((*callbacks_p
)->next
)
599 callbacks_p
= &((*callbacks_p
)->next
);
600 callbacks_p
= &((*callbacks_p
)->next
);
603 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
604 (*callbacks_p
)->callback
= callback
;
605 (*callbacks_p
)->priv
= priv
;
606 (*callbacks_p
)->next
= NULL
;
611 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
613 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
616 if (callback
== NULL
)
618 return ERROR_INVALID_ARGUMENTS
;
623 while ((*callbacks_p
)->next
)
624 callbacks_p
= &((*callbacks_p
)->next
);
625 callbacks_p
= &((*callbacks_p
)->next
);
628 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
629 (*callbacks_p
)->callback
= callback
;
630 (*callbacks_p
)->periodic
= periodic
;
631 (*callbacks_p
)->time_ms
= time_ms
;
633 gettimeofday(&now
, NULL
);
634 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
635 time_ms
-= (time_ms
% 1000);
636 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
637 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
639 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
640 (*callbacks_p
)->when
.tv_sec
+= 1;
643 (*callbacks_p
)->priv
= priv
;
644 (*callbacks_p
)->next
= NULL
;
649 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
651 target_event_callback_t
**p
= &target_event_callbacks
;
652 target_event_callback_t
*c
= target_event_callbacks
;
654 if (callback
== NULL
)
656 return ERROR_INVALID_ARGUMENTS
;
661 target_event_callback_t
*next
= c
->next
;
662 if ((c
->callback
== callback
) && (c
->priv
== priv
))
676 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
678 target_timer_callback_t
**p
= &target_timer_callbacks
;
679 target_timer_callback_t
*c
= target_timer_callbacks
;
681 if (callback
== NULL
)
683 return ERROR_INVALID_ARGUMENTS
;
688 target_timer_callback_t
*next
= c
->next
;
689 if ((c
->callback
== callback
) && (c
->priv
== priv
))
703 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
705 target_event_callback_t
*callback
= target_event_callbacks
;
706 target_event_callback_t
*next_callback
;
708 if (event
== TARGET_EVENT_HALTED
)
710 /* execute early halted first */
711 target_call_event_callbacks(target
, TARGET_EVENT_EARLY_HALTED
);
715 LOG_DEBUG("target event %i (%s)",
717 Jim_Nvp_value2name_simple( nvp_target_event
, event
)->name
);
719 target_handle_event( target
, event
);
723 next_callback
= callback
->next
;
724 callback
->callback(target
, event
, callback
->priv
);
725 callback
= next_callback
;
731 static int target_call_timer_callbacks_check_time(int checktime
)
733 target_timer_callback_t
*callback
= target_timer_callbacks
;
734 target_timer_callback_t
*next_callback
;
739 gettimeofday(&now
, NULL
);
743 next_callback
= callback
->next
;
745 if ((!checktime
&&callback
->periodic
)||
746 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
747 || (now
.tv_sec
> callback
->when
.tv_sec
)))
749 if(callback
->callback
!= NULL
)
751 callback
->callback(callback
->priv
);
752 if (callback
->periodic
)
754 int time_ms
= callback
->time_ms
;
755 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
756 time_ms
-= (time_ms
% 1000);
757 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
758 if (callback
->when
.tv_usec
> 1000000)
760 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
761 callback
->when
.tv_sec
+= 1;
767 if((retval
= target_unregister_timer_callback(callback
->callback
, callback
->priv
)) != ERROR_OK
)
773 callback
= next_callback
;
779 int target_call_timer_callbacks(void)
781 return target_call_timer_callbacks_check_time(1);
784 /* invoke periodic callbacks immediately */
785 int target_call_timer_callbacks_now(void)
787 return target_call_timer_callbacks_check_time(0);
790 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
792 working_area_t
*c
= target
->working_areas
;
793 working_area_t
*new_wa
= NULL
;
795 /* Reevaluate working area address based on MMU state*/
796 if (target
->working_areas
== NULL
)
800 retval
= target
->type
->mmu(target
, &enabled
);
801 if (retval
!= ERROR_OK
)
807 target
->working_area
= target
->working_area_virt
;
811 target
->working_area
= target
->working_area_phys
;
815 /* only allocate multiples of 4 byte */
818 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
819 size
= CEIL(size
, 4);
822 /* see if there's already a matching working area */
825 if ((c
->free
) && (c
->size
== size
))
833 /* if not, allocate a new one */
836 working_area_t
**p
= &target
->working_areas
;
837 u32 first_free
= target
->working_area
;
838 u32 free_size
= target
->working_area_size
;
840 LOG_DEBUG("allocating new working area");
842 c
= target
->working_areas
;
845 first_free
+= c
->size
;
846 free_size
-= c
->size
;
851 if (free_size
< size
)
853 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
854 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
857 new_wa
= malloc(sizeof(working_area_t
));
860 new_wa
->address
= first_free
;
862 if (target
->backup_working_area
)
865 new_wa
->backup
= malloc(new_wa
->size
);
866 if((retval
= target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
)) != ERROR_OK
)
868 free(new_wa
->backup
);
875 new_wa
->backup
= NULL
;
878 /* put new entry in list */
882 /* mark as used, and return the new (reused) area */
892 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
897 if (restore
&&target
->backup_working_area
)
900 if((retval
= target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
)) != ERROR_OK
)
906 /* mark user pointer invalid */
913 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
915 return target_free_working_area_restore(target
, area
, 1);
918 /* free resources and restore memory, if restoring memory fails,
919 * free up resources anyway
921 void target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
923 working_area_t
*c
= target
->working_areas
;
927 working_area_t
*next
= c
->next
;
928 target_free_working_area_restore(target
, c
, restore
);
938 target
->working_areas
= NULL
;
941 void target_free_all_working_areas(struct target_s
*target
)
943 target_free_all_working_areas_restore(target
, 1);
946 int target_register_commands(struct command_context_s
*cmd_ctx
)
949 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)");
950 register_command(cmd_ctx
, NULL
, "working_area", handle_working_area_command
, COMMAND_ANY
, "set a new working space");
951 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "translate a virtual address into a physical address");
952 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "profiling samples the CPU PC");
954 register_jim(cmd_ctx
, "target", jim_target
, "configure target" );
957 /* script procedures */
958 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
959 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
963 int target_arch_state(struct target_s
*target
)
968 LOG_USER("No target has been configured");
972 LOG_USER("target state: %s",
973 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
);
975 if (target
->state
!=TARGET_HALTED
)
978 retval
=target
->type
->arch_state(target
);
982 /* Single aligned words are guaranteed to use 16 or 32 bit access
983 * mode respectively, otherwise data is handled as quickly as
986 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
989 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
991 if (!target
->type
->examined
)
993 LOG_ERROR("Target not examined yet");
997 if ((address
+ size
- 1) < address
)
999 /* GDB can request this when e.g. PC is 0xfffffffc*/
1000 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
1004 if (((address
% 2) == 0) && (size
== 2))
1006 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
1009 /* handle unaligned head bytes */
1012 int unaligned
= 4 - (address
% 4);
1014 if (unaligned
> size
)
1017 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1020 buffer
+= unaligned
;
1021 address
+= unaligned
;
1025 /* handle aligned words */
1028 int aligned
= size
- (size
% 4);
1030 /* use bulk writes above a certain limit. This may have to be changed */
1033 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1038 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1047 /* handle tail writes of less than 4 bytes */
1050 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1058 /* Single aligned words are guaranteed to use 16 or 32 bit access
1059 * mode respectively, otherwise data is handled as quickly as
1062 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1065 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1067 if (!target
->type
->examined
)
1069 LOG_ERROR("Target not examined yet");
1073 if ((address
+ size
- 1) < address
)
1075 /* GDB can request this when e.g. PC is 0xfffffffc*/
1076 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
1080 if (((address
% 2) == 0) && (size
== 2))
1082 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1085 /* handle unaligned head bytes */
1088 int unaligned
= 4 - (address
% 4);
1090 if (unaligned
> size
)
1093 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1096 buffer
+= unaligned
;
1097 address
+= unaligned
;
1101 /* handle aligned words */
1104 int aligned
= size
- (size
% 4);
1106 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1114 /* handle tail writes of less than 4 bytes */
1117 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1124 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1130 if (!target
->type
->examined
)
1132 LOG_ERROR("Target not examined yet");
1136 if ((retval
= target
->type
->checksum_memory(target
, address
,
1137 size
, &checksum
)) != ERROR_OK
)
1139 buffer
= malloc(size
);
1142 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1143 return ERROR_INVALID_ARGUMENTS
;
1145 retval
= target_read_buffer(target
, address
, size
, buffer
);
1146 if (retval
!= ERROR_OK
)
1152 /* convert to target endianess */
1153 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1156 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1157 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1160 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1169 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1172 if (!target
->type
->examined
)
1174 LOG_ERROR("Target not examined yet");
1178 if (target
->type
->blank_check_memory
== 0)
1179 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1181 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1186 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1189 if (!target
->type
->examined
)
1191 LOG_ERROR("Target not examined yet");
1195 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1197 if (retval
== ERROR_OK
)
1199 *value
= target_buffer_get_u32(target
, value_buf
);
1200 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1205 LOG_DEBUG("address: 0x%8.8x failed", address
);
1211 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1214 if (!target
->type
->examined
)
1216 LOG_ERROR("Target not examined yet");
1220 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1222 if (retval
== ERROR_OK
)
1224 *value
= target_buffer_get_u16(target
, value_buf
);
1225 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1230 LOG_DEBUG("address: 0x%8.8x failed", address
);
1236 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1238 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1239 if (!target
->type
->examined
)
1241 LOG_ERROR("Target not examined yet");
1245 if (retval
== ERROR_OK
)
1247 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1252 LOG_DEBUG("address: 0x%8.8x failed", address
);
1258 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1262 if (!target
->type
->examined
)
1264 LOG_ERROR("Target not examined yet");
1268 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1270 target_buffer_set_u32(target
, value_buf
, value
);
1271 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1273 LOG_DEBUG("failed: %i", retval
);
1279 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1283 if (!target
->type
->examined
)
1285 LOG_ERROR("Target not examined yet");
1289 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1291 target_buffer_set_u16(target
, value_buf
, value
);
1292 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1294 LOG_DEBUG("failed: %i", retval
);
1300 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1303 if (!target
->type
->examined
)
1305 LOG_ERROR("Target not examined yet");
1309 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1311 if ((retval
= target
->type
->write_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1313 LOG_DEBUG("failed: %i", retval
);
1319 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1321 int retval
= ERROR_OK
;
1322 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, "display or set a register");
1323 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1324 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1325 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1326 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1327 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1328 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init] - default is run");
1329 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1331 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1332 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1333 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1335 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1336 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1337 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1339 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1340 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1341 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1342 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1344 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]");
1345 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1346 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1348 if((retval
= target_request_register_commands(cmd_ctx
)) != ERROR_OK
)
1350 if((retval
= trace_register_commands(cmd_ctx
)) != ERROR_OK
)
1357 int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1360 target_t
*target
= all_targets
;
1364 /* try as tcltarget name */
1365 for( target
= all_targets
; target
; target
++ ){
1366 if( target
->cmd_name
){
1367 if( 0 == strcmp( args
[0], target
->cmd_name
) ){
1373 /* no match, try as number */
1375 int num
= strtoul(args
[0], &cp
, 0 );
1377 /* then it was not a number */
1378 command_print( cmd_ctx
, "Target: %s unknown, try one of:\n", args
[0] );
1382 target
= get_target_by_num( num
);
1383 if( target
== NULL
){
1384 command_print(cmd_ctx
,"Target: %s is unknown, try one of:\n", args
[0] );
1388 cmd_ctx
->current_target
= target
->target_number
;
1393 command_print(cmd_ctx
, " CmdName Type Endian ChainPos State ");
1394 command_print(cmd_ctx
, "-- ---------- ---------- ---------- -------- ----------");
1397 /* XX: abcdefghij abcdefghij abcdefghij abcdefghij */
1398 command_print(cmd_ctx
, "%2d: %-10s %-10s %-10s %8d %s",
1399 target
->target_number
,
1402 Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
)->name
,
1403 target
->chain_position
,
1404 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
1405 target
= target
->next
;
1413 int handle_working_area_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1415 int retval
= ERROR_OK
;
1416 target_t
*target
= NULL
;
1418 if ((argc
< 4) || (argc
> 5))
1420 return ERROR_COMMAND_SYNTAX_ERROR
;
1423 target
= get_target_by_num(strtoul(args
[0], NULL
, 0));
1426 return ERROR_COMMAND_SYNTAX_ERROR
;
1428 target_free_all_working_areas(target
);
1430 target
->working_area_phys
= target
->working_area_virt
= strtoul(args
[1], NULL
, 0);
1433 target
->working_area_virt
= strtoul(args
[4], NULL
, 0);
1435 target
->working_area_size
= strtoul(args
[2], NULL
, 0);
1437 if (strcmp(args
[3], "backup") == 0)
1439 target
->backup_working_area
= 1;
1441 else if (strcmp(args
[3], "nobackup") == 0)
1443 target
->backup_working_area
= 0;
1447 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args
[3]);
1448 return ERROR_COMMAND_SYNTAX_ERROR
;
1455 // every 300ms we check for reset & powerdropout and issue a "reset halt" if
1458 static int powerDropout
;
1459 static int srstAsserted
;
1461 static int runPowerRestore
;
1462 static int runPowerDropout
;
1463 static int runSrstAsserted
;
1464 static int runSrstDeasserted
;
1466 static int sense_handler()
1468 static int prevSrstAsserted
= 0;
1469 static int prevPowerdropout
= 0;
1472 if ((retval
=jtag_power_dropout(&powerDropout
))!=ERROR_OK
)
1476 powerRestored
= prevPowerdropout
&& !powerDropout
;
1479 runPowerRestore
= 1;
1482 long long current
= timeval_ms();
1483 static long long lastPower
= 0;
1484 int waitMore
= lastPower
+ 2000 > current
;
1485 if (powerDropout
&& !waitMore
)
1487 runPowerDropout
= 1;
1488 lastPower
= current
;
1491 if ((retval
=jtag_srst_asserted(&srstAsserted
))!=ERROR_OK
)
1495 srstDeasserted
= prevSrstAsserted
&& !srstAsserted
;
1497 static long long lastSrst
= 0;
1498 waitMore
= lastSrst
+ 2000 > current
;
1499 if (srstDeasserted
&& !waitMore
)
1501 runSrstDeasserted
= 1;
1505 if (!prevSrstAsserted
&& srstAsserted
)
1507 runSrstAsserted
= 1;
1510 prevSrstAsserted
= srstAsserted
;
1511 prevPowerdropout
= powerDropout
;
1513 if (srstDeasserted
|| powerRestored
)
1515 /* Other than logging the event we can't do anything here.
1516 * Issuing a reset is a particularly bad idea as we might
1517 * be inside a reset already.
1525 /* process target state changes */
1526 int handle_target(void *priv
)
1528 int retval
= ERROR_OK
;
1530 /* we do not want to recurse here... */
1531 static int recursive
= 0;
1536 /* danger! running these procedures can trigger srst assertions and power dropouts.
1537 * We need to avoid an infinite loop/recursion here and we do that by
1538 * clearing the flags after running these events.
1540 int did_something
= 0;
1541 if (runSrstAsserted
)
1543 Jim_Eval( interp
, "srst_asserted");
1546 if (runSrstDeasserted
)
1548 Jim_Eval( interp
, "srst_deasserted");
1551 if (runPowerDropout
)
1553 Jim_Eval( interp
, "power_dropout");
1556 if (runPowerRestore
)
1558 Jim_Eval( interp
, "power_restore");
1564 /* clear detect flags */
1568 /* clear action flags */
1571 runSrstDeasserted
=0;
1578 target_t
*target
= all_targets
;
1583 /* only poll target if we've got power and srst isn't asserted */
1584 if (target_continous_poll
&&!powerDropout
&&!srstAsserted
)
1586 /* polling may fail silently until the target has been examined */
1587 if((retval
= target_poll(target
)) != ERROR_OK
)
1591 target
= target
->next
;
1598 int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1607 target
= get_current_target(cmd_ctx
);
1609 /* list all available registers for the current target */
1612 reg_cache_t
*cache
= target
->reg_cache
;
1618 for (i
= 0; i
< cache
->num_regs
; i
++)
1620 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1621 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
);
1624 cache
= cache
->next
;
1630 /* access a single register by its ordinal number */
1631 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1633 int num
= strtoul(args
[0], NULL
, 0);
1634 reg_cache_t
*cache
= target
->reg_cache
;
1640 for (i
= 0; i
< cache
->num_regs
; i
++)
1644 reg
= &cache
->reg_list
[i
];
1650 cache
= cache
->next
;
1655 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1658 } else /* access a single register by its name */
1660 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1664 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1669 /* display a register */
1670 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1672 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1675 if (reg
->valid
== 0)
1677 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1678 arch_type
->get(reg
);
1680 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1681 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1686 /* set register value */
1689 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1690 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1692 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1693 arch_type
->set(reg
, buf
);
1695 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1696 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1704 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1710 int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1712 int retval
= ERROR_OK
;
1713 target_t
*target
= get_current_target(cmd_ctx
);
1717 if((retval
= target_poll(target
)) != ERROR_OK
)
1719 if((retval
= target_arch_state(target
)) != ERROR_OK
)
1725 if (strcmp(args
[0], "on") == 0)
1727 target_continous_poll
= 1;
1729 else if (strcmp(args
[0], "off") == 0)
1731 target_continous_poll
= 0;
1735 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1739 return ERROR_COMMAND_SYNTAX_ERROR
;
1746 int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1754 ms
= strtoul(args
[0], &end
, 0) * 1000;
1757 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1761 target_t
*target
= get_current_target(cmd_ctx
);
1763 return target_wait_state(target
, TARGET_HALTED
, ms
);
1766 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1769 struct timeval timeout
, now
;
1771 gettimeofday(&timeout
, NULL
);
1772 timeval_add_time(&timeout
, 0, ms
* 1000);
1776 if ((retval
=target_poll(target
))!=ERROR_OK
)
1779 if (target
->state
== state
)
1786 LOG_DEBUG("waiting for target %s...",
1787 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1790 gettimeofday(&now
, NULL
);
1791 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
1793 LOG_ERROR("timed out while waiting for target %s",
1794 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1802 int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1805 target_t
*target
= get_current_target(cmd_ctx
);
1809 if ((retval
= target_halt(target
)) != ERROR_OK
)
1814 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1817 int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1819 target_t
*target
= get_current_target(cmd_ctx
);
1821 LOG_USER("requesting target halt and executing a soft reset");
1823 target
->type
->soft_reset_halt(target
);
1828 int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1831 enum target_reset_mode reset_mode
= RESET_RUN
;
1835 n
= Jim_Nvp_name2value_simple( nvp_reset_modes
, args
[0] );
1836 if( (n
->name
== NULL
) || (n
->value
== RESET_UNKNOWN
) ){
1837 return ERROR_COMMAND_SYNTAX_ERROR
;
1839 reset_mode
= n
->value
;
1842 /* reset *all* targets */
1843 return target_process_reset(cmd_ctx
, reset_mode
);
1847 int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1850 target_t
*target
= get_current_target(cmd_ctx
);
1852 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1855 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1857 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1860 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
1866 int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1868 target_t
*target
= get_current_target(cmd_ctx
);
1873 return target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1876 return target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1881 int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1883 const int line_bytecnt
= 32;
1896 target_t
*target
= get_current_target(cmd_ctx
);
1902 count
= strtoul(args
[1], NULL
, 0);
1904 address
= strtoul(args
[0], NULL
, 0);
1910 size
= 4; line_modulo
= line_bytecnt
/ 4;
1913 size
= 2; line_modulo
= line_bytecnt
/ 2;
1916 size
= 1; line_modulo
= line_bytecnt
/ 1;
1922 buffer
= calloc(count
, size
);
1923 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1924 if (retval
== ERROR_OK
)
1928 for (i
= 0; i
< count
; i
++)
1930 if (i
%line_modulo
== 0)
1931 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1936 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1939 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1942 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1946 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1948 command_print(cmd_ctx
, output
);
1959 int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1966 target_t
*target
= get_current_target(cmd_ctx
);
1969 if ((argc
< 2) || (argc
> 3))
1970 return ERROR_COMMAND_SYNTAX_ERROR
;
1972 address
= strtoul(args
[0], NULL
, 0);
1973 value
= strtoul(args
[1], NULL
, 0);
1975 count
= strtoul(args
[2], NULL
, 0);
1981 target_buffer_set_u32(target
, value_buf
, value
);
1985 target_buffer_set_u16(target
, value_buf
, value
);
1989 value_buf
[0] = value
;
1992 return ERROR_COMMAND_SYNTAX_ERROR
;
1994 for (i
=0; i
<count
; i
++)
2000 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
2003 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
2006 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
2013 if (retval
!=ERROR_OK
)
2023 int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2029 u32 max_address
=0xffffffff;
2031 int retval
, retvaltemp
;
2035 duration_t duration
;
2036 char *duration_text
;
2038 target_t
*target
= get_current_target(cmd_ctx
);
2040 if ((argc
< 1)||(argc
> 5))
2042 return ERROR_COMMAND_SYNTAX_ERROR
;
2045 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2048 image
.base_address_set
= 1;
2049 image
.base_address
= strtoul(args
[1], NULL
, 0);
2053 image
.base_address_set
= 0;
2057 image
.start_address_set
= 0;
2061 min_address
=strtoul(args
[3], NULL
, 0);
2065 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
2068 if (min_address
>max_address
)
2070 return ERROR_COMMAND_SYNTAX_ERROR
;
2074 duration_start_measure(&duration
);
2076 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2083 for (i
= 0; i
< image
.num_sections
; i
++)
2085 buffer
= malloc(image
.sections
[i
].size
);
2088 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2092 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2102 /* DANGER!!! beware of unsigned comparision here!!! */
2104 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
2105 (image
.sections
[i
].base_address
<max_address
))
2107 if (image
.sections
[i
].base_address
<min_address
)
2109 /* clip addresses below */
2110 offset
+=min_address
-image
.sections
[i
].base_address
;
2114 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
2116 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2119 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2124 image_size
+= length
;
2125 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2131 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2133 image_close(&image
);
2137 if (retval
==ERROR_OK
)
2139 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2141 free(duration_text
);
2143 image_close(&image
);
2149 int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2156 int retval
=ERROR_OK
, retvaltemp
;
2158 duration_t duration
;
2159 char *duration_text
;
2161 target_t
*target
= get_current_target(cmd_ctx
);
2165 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2169 address
= strtoul(args
[1], NULL
, 0);
2170 size
= strtoul(args
[2], NULL
, 0);
2172 if ((address
& 3) || (size
& 3))
2174 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2178 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2183 duration_start_measure(&duration
);
2188 u32 this_run_size
= (size
> 560) ? 560 : size
;
2190 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2191 if (retval
!= ERROR_OK
)
2196 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2197 if (retval
!= ERROR_OK
)
2202 size
-= this_run_size
;
2203 address
+= this_run_size
;
2206 if((retvaltemp
= fileio_close(&fileio
)) != ERROR_OK
)
2209 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2212 if (retval
==ERROR_OK
)
2214 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2216 free(duration_text
);
2221 int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2227 int retval
, retvaltemp
;
2229 u32 mem_checksum
= 0;
2233 duration_t duration
;
2234 char *duration_text
;
2236 target_t
*target
= get_current_target(cmd_ctx
);
2240 return ERROR_COMMAND_SYNTAX_ERROR
;
2245 LOG_ERROR("no target selected");
2249 duration_start_measure(&duration
);
2253 image
.base_address_set
= 1;
2254 image
.base_address
= strtoul(args
[1], NULL
, 0);
2258 image
.base_address_set
= 0;
2259 image
.base_address
= 0x0;
2262 image
.start_address_set
= 0;
2264 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2271 for (i
= 0; i
< image
.num_sections
; i
++)
2273 buffer
= malloc(image
.sections
[i
].size
);
2276 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2279 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2285 /* calculate checksum of image */
2286 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2288 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2289 if( retval
!= ERROR_OK
)
2295 if( checksum
!= mem_checksum
)
2297 /* failed crc checksum, fall back to a binary compare */
2300 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2302 data
= (u8
*)malloc(buf_cnt
);
2304 /* Can we use 32bit word accesses? */
2306 int count
= buf_cnt
;
2307 if ((count
% 4) == 0)
2312 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2313 if (retval
== ERROR_OK
)
2316 for (t
= 0; t
< buf_cnt
; t
++)
2318 if (data
[t
] != buffer
[t
])
2320 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
]);
2337 image_size
+= buf_cnt
;
2341 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2343 image_close(&image
);
2347 if (retval
==ERROR_OK
)
2349 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2351 free(duration_text
);
2353 image_close(&image
);
2358 int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2361 target_t
*target
= get_current_target(cmd_ctx
);
2365 breakpoint_t
*breakpoint
= target
->breakpoints
;
2369 if (breakpoint
->type
== BKPT_SOFT
)
2371 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2372 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2377 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2379 breakpoint
= breakpoint
->next
;
2387 length
= strtoul(args
[1], NULL
, 0);
2390 if (strcmp(args
[2], "hw") == 0)
2393 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2395 LOG_ERROR("Failure setting breakpoints");
2399 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2404 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2410 int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2412 target_t
*target
= get_current_target(cmd_ctx
);
2415 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2420 int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2422 target_t
*target
= get_current_target(cmd_ctx
);
2427 watchpoint_t
*watchpoint
= target
->watchpoints
;
2431 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
);
2432 watchpoint
= watchpoint
->next
;
2437 enum watchpoint_rw type
= WPT_ACCESS
;
2438 u32 data_value
= 0x0;
2439 u32 data_mask
= 0xffffffff;
2455 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2461 data_value
= strtoul(args
[3], NULL
, 0);
2465 data_mask
= strtoul(args
[4], NULL
, 0);
2468 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2469 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2471 LOG_ERROR("Failure setting breakpoints");
2476 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2482 int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2484 target_t
*target
= get_current_target(cmd_ctx
);
2487 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2492 int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2495 target_t
*target
= get_current_target(cmd_ctx
);
2501 return ERROR_COMMAND_SYNTAX_ERROR
;
2503 va
= strtoul(args
[0], NULL
, 0);
2505 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2506 if (retval
== ERROR_OK
)
2508 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2512 /* lower levels will have logged a detailed error which is
2513 * forwarded to telnet/GDB session.
2518 static void writeLong(FILE *f
, int l
)
2523 char c
=(l
>>(i
*8))&0xff;
2524 fwrite(&c
, 1, 1, f
);
2528 static void writeString(FILE *f
, char *s
)
2530 fwrite(s
, 1, strlen(s
), f
);
2535 // Dump a gmon.out histogram file.
2536 static void writeGmon(u32
*samples
, int sampleNum
, char *filename
)
2539 FILE *f
=fopen(filename
, "w");
2542 fwrite("gmon", 1, 4, f
);
2543 writeLong(f
, 0x00000001); // Version
2544 writeLong(f
, 0); // padding
2545 writeLong(f
, 0); // padding
2546 writeLong(f
, 0); // padding
2548 fwrite("", 1, 1, f
); // GMON_TAG_TIME_HIST
2550 // figure out bucket size
2553 for (i
=0; i
<sampleNum
; i
++)
2565 int addressSpace
=(max
-min
+1);
2567 static int const maxBuckets
=256*1024; // maximum buckets.
2568 int length
=addressSpace
;
2569 if (length
> maxBuckets
)
2573 int *buckets
=malloc(sizeof(int)*length
);
2579 memset(buckets
, 0, sizeof(int)*length
);
2580 for (i
=0; i
<sampleNum
;i
++)
2582 u32 address
=samples
[i
];
2583 long long a
=address
-min
;
2584 long long b
=length
-1;
2585 long long c
=addressSpace
-1;
2586 int index
=(a
*b
)/c
; // danger!!!! int32 overflows
2590 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2591 writeLong(f
, min
); // low_pc
2592 writeLong(f
, max
); // high_pc
2593 writeLong(f
, length
); // # of samples
2594 writeLong(f
, 64000000); // 64MHz
2595 writeString(f
, "seconds");
2596 for (i
=0; i
<(15-strlen("seconds")); i
++)
2598 fwrite("", 1, 1, f
); // padding
2600 writeString(f
, "s");
2602 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2604 char *data
=malloc(2*length
);
2607 for (i
=0; i
<length
;i
++)
2616 data
[i
*2+1]=(val
>>8)&0xff;
2619 fwrite(data
, 1, length
*2, f
);
2629 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2630 int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2632 target_t
*target
= get_current_target(cmd_ctx
);
2633 struct timeval timeout
, now
;
2635 gettimeofday(&timeout
, NULL
);
2638 return ERROR_COMMAND_SYNTAX_ERROR
;
2641 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2647 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2649 static const int maxSample
=10000;
2650 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2655 int retval
=ERROR_OK
;
2656 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2657 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2661 target_poll(target
);
2662 if (target
->state
== TARGET_HALTED
)
2664 u32 t
=*((u32
*)reg
->value
);
2665 samples
[numSamples
++]=t
;
2666 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2667 target_poll(target
);
2668 alive_sleep(10); // sleep 10ms, i.e. <100 samples/second.
2669 } else if (target
->state
== TARGET_RUNNING
)
2671 // We want to quickly sample the PC.
2672 if((retval
= target_halt(target
)) != ERROR_OK
)
2679 command_print(cmd_ctx
, "Target not halted or running");
2683 if (retval
!=ERROR_OK
)
2688 gettimeofday(&now
, NULL
);
2689 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2691 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2692 if((retval
= target_poll(target
)) != ERROR_OK
)
2697 if (target
->state
== TARGET_HALTED
)
2699 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2701 if((retval
= target_poll(target
)) != ERROR_OK
)
2706 writeGmon(samples
, numSamples
, args
[1]);
2707 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2716 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2719 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2722 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2726 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2727 valObjPtr
= Jim_NewIntObj(interp
, val
);
2728 if (!nameObjPtr
|| !valObjPtr
)
2734 Jim_IncrRefCount(nameObjPtr
);
2735 Jim_IncrRefCount(valObjPtr
);
2736 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2737 Jim_DecrRefCount(interp
, nameObjPtr
);
2738 Jim_DecrRefCount(interp
, valObjPtr
);
2740 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2744 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2746 command_context_t
*context
;
2749 context
= Jim_GetAssocData(interp
, "context");
2750 if (context
== NULL
)
2752 LOG_ERROR("mem2array: no command context");
2755 target
= get_current_target(context
);
2758 LOG_ERROR("mem2array: no current target");
2762 return target_mem2array(interp
, target
, argc
,argv
);
2765 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2773 const char *varname
;
2775 int i
, n
, e
, retval
;
2777 /* argv[1] = name of array to receive the data
2778 * argv[2] = desired width
2779 * argv[3] = memory address
2780 * argv[4] = count of times to read
2783 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2786 varname
= Jim_GetString(argv
[1], &len
);
2787 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2789 e
= Jim_GetLong(interp
, argv
[2], &l
);
2795 e
= Jim_GetLong(interp
, argv
[3], &l
);
2800 e
= Jim_GetLong(interp
, argv
[4], &l
);
2816 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2817 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2821 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2822 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2825 if ((addr
+ (len
* width
)) < addr
) {
2826 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2827 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2830 /* absurd transfer size? */
2832 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2833 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2838 ((width
== 2) && ((addr
& 1) == 0)) ||
2839 ((width
== 4) && ((addr
& 3) == 0))) {
2843 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2844 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2845 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2856 /* Slurp... in buffer size chunks */
2858 count
= len
; /* in objects.. */
2859 if (count
> (sizeof(buffer
)/width
)) {
2860 count
= (sizeof(buffer
)/width
);
2863 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2864 if (retval
!= ERROR_OK
) {
2866 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2867 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2868 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2872 v
= 0; /* shut up gcc */
2873 for (i
= 0 ;i
< count
;i
++, n
++) {
2876 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2879 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2882 v
= buffer
[i
] & 0x0ff;
2885 new_int_array_element(interp
, varname
, n
, v
);
2891 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2896 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2899 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2903 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2907 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2914 Jim_IncrRefCount(nameObjPtr
);
2915 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2916 Jim_DecrRefCount(interp
, nameObjPtr
);
2918 if (valObjPtr
== NULL
)
2921 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2922 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2927 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2929 command_context_t
*context
;
2932 context
= Jim_GetAssocData(interp
, "context");
2933 if (context
== NULL
){
2934 LOG_ERROR("array2mem: no command context");
2937 target
= get_current_target(context
);
2938 if (target
== NULL
){
2939 LOG_ERROR("array2mem: no current target");
2943 return target_array2mem( interp
,target
, argc
, argv
);
2947 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2955 const char *varname
;
2957 int i
, n
, e
, retval
;
2959 /* argv[1] = name of array to get the data
2960 * argv[2] = desired width
2961 * argv[3] = memory address
2962 * argv[4] = count to write
2965 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2968 varname
= Jim_GetString(argv
[1], &len
);
2969 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2971 e
= Jim_GetLong(interp
, argv
[2], &l
);
2977 e
= Jim_GetLong(interp
, argv
[3], &l
);
2982 e
= Jim_GetLong(interp
, argv
[4], &l
);
2998 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2999 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
3003 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3004 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
3007 if ((addr
+ (len
* width
)) < addr
) {
3008 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3009 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
3012 /* absurd transfer size? */
3014 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3015 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
3020 ((width
== 2) && ((addr
& 1) == 0)) ||
3021 ((width
== 4) && ((addr
& 3) == 0))) {
3025 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3026 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
3027 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
3039 /* Slurp... in buffer size chunks */
3041 count
= len
; /* in objects.. */
3042 if (count
> (sizeof(buffer
)/width
)) {
3043 count
= (sizeof(buffer
)/width
);
3046 v
= 0; /* shut up gcc */
3047 for (i
= 0 ;i
< count
;i
++, n
++) {
3048 get_int_array_element(interp
, varname
, n
, &v
);
3051 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
3054 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
3057 buffer
[i
] = v
& 0x0ff;
3063 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
3064 if (retval
!= ERROR_OK
) {
3066 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
3067 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3068 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: cannot read memory", NULL
);
3074 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3080 target_all_handle_event( enum target_event e
)
3085 LOG_DEBUG( "**all*targets: event: %d, %s",
3087 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3089 target
= all_targets
;
3091 target_handle_event( target
, e
);
3092 target
= target
->next
;
3097 target_handle_event( target_t
*target
, enum target_event e
)
3099 target_event_action_t
*teap
;
3102 teap
= target
->event_action
;
3106 if( teap
->event
== e
){
3108 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3109 target
->target_number
,
3113 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
,
3114 Jim_GetString( teap
->body
, NULL
) );
3115 if (Jim_EvalObj( interp
, teap
->body
)!=JIM_OK
)
3117 Jim_PrintErrorMessage(interp
);
3123 LOG_DEBUG( "event: %d %s - no action",
3125 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3129 enum target_cfg_param
{
3132 TCFG_WORK_AREA_VIRT
,
3133 TCFG_WORK_AREA_PHYS
,
3134 TCFG_WORK_AREA_SIZE
,
3135 TCFG_WORK_AREA_BACKUP
,
3138 TCFG_CHAIN_POSITION
,
3142 static Jim_Nvp nvp_config_opts
[] = {
3143 { .name
= "-type", .value
= TCFG_TYPE
},
3144 { .name
= "-event", .value
= TCFG_EVENT
},
3145 { .name
= "-work-area-virt", .value
= TCFG_WORK_AREA_VIRT
},
3146 { .name
= "-work-area-phys", .value
= TCFG_WORK_AREA_PHYS
},
3147 { .name
= "-work-area-size", .value
= TCFG_WORK_AREA_SIZE
},
3148 { .name
= "-work-area-backup", .value
= TCFG_WORK_AREA_BACKUP
},
3149 { .name
= "-endian" , .value
= TCFG_ENDIAN
},
3150 { .name
= "-variant", .value
= TCFG_VARIANT
},
3151 { .name
= "-chain-position", .value
= TCFG_CHAIN_POSITION
},
3153 { .name
= NULL
, .value
= -1 }
3158 target_configure( Jim_GetOptInfo
*goi
,
3168 /* parse config or cget options ... */
3169 while( goi
->argc
> 0 ){
3170 Jim_SetEmptyResult( goi
->interp
);
3171 //Jim_GetOpt_Debug( goi );
3173 if( target
->type
->target_jim_configure
){
3174 /* target defines a configure function */
3175 /* target gets first dibs on parameters */
3176 e
= (*(target
->type
->target_jim_configure
))( target
, goi
);
3185 /* otherwise we 'continue' below */
3187 e
= Jim_GetOpt_Nvp( goi
, nvp_config_opts
, &n
);
3189 Jim_GetOpt_NvpUnknown( goi
, nvp_config_opts
, 0 );
3195 if( goi
->isconfigure
){
3196 Jim_SetResult_sprintf( goi
->interp
, "not setable: %s", n
->name
);
3200 if( goi
->argc
!= 0 ){
3201 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
3205 Jim_SetResultString( goi
->interp
, target
->type
->name
, -1 );
3209 if( goi
->argc
== 0 ){
3210 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ...");
3214 e
= Jim_GetOpt_Nvp( goi
, nvp_target_event
, &n
);
3216 Jim_GetOpt_NvpUnknown( goi
, nvp_target_event
, 1 );
3220 if( goi
->isconfigure
){
3221 if( goi
->argc
!= 1 ){
3222 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
3226 if( goi
->argc
!= 0 ){
3227 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
3234 target_event_action_t
*teap
;
3236 teap
= target
->event_action
;
3237 /* replace existing? */
3239 if( teap
->event
== n
->value
){
3245 if( goi
->isconfigure
){
3248 teap
= calloc( 1, sizeof(*teap
) );
3250 teap
->event
= n
->value
;
3251 Jim_GetOpt_Obj( goi
, &o
);
3253 Jim_DecrRefCount( interp
, teap
->body
);
3255 teap
->body
= Jim_DuplicateObj( goi
->interp
, o
);
3258 * Tcl/TK - "tk events" have a nice feature.
3259 * See the "BIND" command.
3260 * We should support that here.
3261 * You can specify %X and %Y in the event code.
3262 * The idea is: %T - target name.
3263 * The idea is: %N - target number
3264 * The idea is: %E - event name.
3266 Jim_IncrRefCount( teap
->body
);
3268 /* add to head of event list */
3269 teap
->next
= target
->event_action
;
3270 target
->event_action
= teap
;
3271 Jim_SetEmptyResult(goi
->interp
);
3275 Jim_SetEmptyResult( goi
->interp
);
3277 Jim_SetResult( goi
->interp
, Jim_DuplicateObj( goi
->interp
, teap
->body
) );
3284 case TCFG_WORK_AREA_VIRT
:
3285 if( goi
->isconfigure
){
3286 target_free_all_working_areas(target
);
3287 e
= Jim_GetOpt_Wide( goi
, &w
);
3291 target
->working_area_virt
= w
;
3293 if( goi
->argc
!= 0 ){
3297 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_virt
) );
3301 case TCFG_WORK_AREA_PHYS
:
3302 if( goi
->isconfigure
){
3303 target_free_all_working_areas(target
);
3304 e
= Jim_GetOpt_Wide( goi
, &w
);
3308 target
->working_area_phys
= w
;
3310 if( goi
->argc
!= 0 ){
3314 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_phys
) );
3318 case TCFG_WORK_AREA_SIZE
:
3319 if( goi
->isconfigure
){
3320 target_free_all_working_areas(target
);
3321 e
= Jim_GetOpt_Wide( goi
, &w
);
3325 target
->working_area_size
= w
;
3327 if( goi
->argc
!= 0 ){
3331 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3335 case TCFG_WORK_AREA_BACKUP
:
3336 if( goi
->isconfigure
){
3337 target_free_all_working_areas(target
);
3338 e
= Jim_GetOpt_Wide( goi
, &w
);
3342 /* make this exactly 1 or 0 */
3343 target
->backup_working_area
= (!!w
);
3345 if( goi
->argc
!= 0 ){
3349 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3350 /* loop for more e*/
3354 if( goi
->isconfigure
){
3355 e
= Jim_GetOpt_Nvp( goi
, nvp_target_endian
, &n
);
3357 Jim_GetOpt_NvpUnknown( goi
, nvp_target_endian
, 1 );
3360 target
->endianness
= n
->value
;
3362 if( goi
->argc
!= 0 ){
3366 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3367 if( n
->name
== NULL
){
3368 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3369 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3371 Jim_SetResultString( goi
->interp
, n
->name
, -1 );
3376 if( goi
->isconfigure
){
3377 if( goi
->argc
< 1 ){
3378 Jim_SetResult_sprintf( goi
->interp
,
3383 if( target
->variant
){
3384 free((void *)(target
->variant
));
3386 e
= Jim_GetOpt_String( goi
, &cp
, NULL
);
3387 target
->variant
= strdup(cp
);
3389 if( goi
->argc
!= 0 ){
3393 Jim_SetResultString( goi
->interp
, target
->variant
,-1 );
3396 case TCFG_CHAIN_POSITION
:
3397 if( goi
->isconfigure
){
3398 target_free_all_working_areas(target
);
3399 e
= Jim_GetOpt_Wide( goi
, &w
);
3403 if (jtag_get_device(w
)==NULL
)
3406 /* make this exactly 1 or 0 */
3407 target
->chain_position
= w
;
3409 if( goi
->argc
!= 0 ){
3413 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->chain_position
) );
3414 /* loop for more e*/
3417 } /* while( goi->argc ) */
3418 /* done - we return */
3423 /** this is the 'tcl' handler for the target specific command */
3425 tcl_target_func( Jim_Interp
*interp
,
3427 Jim_Obj
*const *argv
)
3435 struct command_context_s
*cmd_ctx
;
3443 TS_CMD_MWW
, TS_CMD_MWH
, TS_CMD_MWB
,
3444 TS_CMD_MDW
, TS_CMD_MDH
, TS_CMD_MDB
,
3445 TS_CMD_MRW
, TS_CMD_MRH
, TS_CMD_MRB
,
3446 TS_CMD_MEM2ARRAY
, TS_CMD_ARRAY2MEM
,
3454 TS_CMD_INVOKE_EVENT
,
3457 static const Jim_Nvp target_options
[] = {
3458 { .name
= "configure", .value
= TS_CMD_CONFIGURE
},
3459 { .name
= "cget", .value
= TS_CMD_CGET
},
3460 { .name
= "mww", .value
= TS_CMD_MWW
},
3461 { .name
= "mwh", .value
= TS_CMD_MWH
},
3462 { .name
= "mwb", .value
= TS_CMD_MWB
},
3463 { .name
= "mdw", .value
= TS_CMD_MDW
},
3464 { .name
= "mdh", .value
= TS_CMD_MDH
},
3465 { .name
= "mdb", .value
= TS_CMD_MDB
},
3466 { .name
= "mem2array", .value
= TS_CMD_MEM2ARRAY
},
3467 { .name
= "array2mem", .value
= TS_CMD_ARRAY2MEM
},
3468 { .name
= "eventlist", .value
= TS_CMD_EVENTLIST
},
3469 { .name
= "curstate", .value
= TS_CMD_CURSTATE
},
3471 { .name
= "arp_examine", .value
= TS_CMD_EXAMINE
},
3472 { .name
= "arp_poll", .value
= TS_CMD_POLL
},
3473 { .name
= "arp_reset", .value
= TS_CMD_RESET
},
3474 { .name
= "arp_halt", .value
= TS_CMD_HALT
},
3475 { .name
= "arp_waitstate", .value
= TS_CMD_WAITSTATE
},
3476 { .name
= "invoke-event", .value
= TS_CMD_INVOKE_EVENT
},
3478 { .name
= NULL
, .value
= -1 },
3482 /* go past the "command" */
3483 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3485 target
= Jim_CmdPrivData( goi
.interp
);
3486 cmd_ctx
= Jim_GetAssocData(goi
.interp
, "context");
3488 /* commands here are in an NVP table */
3489 e
= Jim_GetOpt_Nvp( &goi
, target_options
, &n
);
3491 Jim_GetOpt_NvpUnknown( &goi
, target_options
, 0 );
3494 // Assume blank result
3495 Jim_SetEmptyResult( goi
.interp
);
3498 case TS_CMD_CONFIGURE
:
3500 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "missing: -option VALUE ...");
3503 goi
.isconfigure
= 1;
3504 return target_configure( &goi
, target
);
3506 // some things take params
3508 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "missing: ?-option?");
3511 goi
.isconfigure
= 0;
3512 return target_configure( &goi
, target
);
3520 * argv[3] = optional count.
3523 if( (goi
.argc
== 3) || (goi
.argc
== 4) ){
3527 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR DATA [COUNT]", n
->name
);
3531 e
= Jim_GetOpt_Wide( &goi
, &a
);
3536 e
= Jim_GetOpt_Wide( &goi
, &b
);
3541 e
= Jim_GetOpt_Wide( &goi
, &c
);
3551 target_buffer_set_u32( target
, target_buf
, b
);
3555 target_buffer_set_u16( target
, target_buf
, b
);
3559 target_buffer_set_u8( target
, target_buf
, b
);
3563 for( x
= 0 ; x
< c
; x
++ ){
3564 e
= target
->type
->write_memory( target
, a
, b
, 1, target_buf
);
3565 if( e
!= ERROR_OK
){
3566 Jim_SetResult_sprintf( interp
, "Error writing @ 0x%08x: %d\n", (int)(a
), e
);
3579 /* argv[0] = command
3581 * argv[2] = optional count
3583 if( (goi
.argc
== 2) || (goi
.argc
== 3) ){
3584 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR [COUNT]", n
->name
);
3587 e
= Jim_GetOpt_Wide( &goi
, &a
);
3592 e
= Jim_GetOpt_Wide( &goi
, &c
);
3599 b
= 1; /* shut up gcc */
3612 /* convert to "bytes" */
3614 /* count is now in 'BYTES' */
3620 e
= target
->type
->read_memory( target
, a
, b
, y
/ b
, target_buf
);
3621 if( e
!= ERROR_OK
){
3622 Jim_SetResult_sprintf( interp
, "error reading target @ 0x%08lx", (int)(a
) );
3626 Jim_fprintf( interp
, interp
->cookie_stdout
, "0x%08x ", (int)(a
) );
3629 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 4 ){
3630 z
= target_buffer_get_u32( target
, &(target_buf
[ x
* 4 ]) );
3631 Jim_fprintf( interp
, interp
->cookie_stdout
, "%08x ", (int)(z
) );
3633 for( ; (x
< 16) ; x
+= 4 ){
3634 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3638 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 2 ){
3639 z
= target_buffer_get_u16( target
, &(target_buf
[ x
* 2 ]) );
3640 Jim_fprintf( interp
, interp
->cookie_stdout
, "%04x ", (int)(z
) );
3642 for( ; (x
< 16) ; x
+= 2 ){
3643 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3648 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 1 ){
3649 z
= target_buffer_get_u8( target
, &(target_buf
[ x
* 4 ]) );
3650 Jim_fprintf( interp
, interp
->cookie_stdout
, "%02x ", (int)(z
) );
3652 for( ; (x
< 16) ; x
+= 1 ){
3653 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3657 /* ascii-ify the bytes */
3658 for( x
= 0 ; x
< y
; x
++ ){
3659 if( (target_buf
[x
] >= 0x20) &&
3660 (target_buf
[x
] <= 0x7e) ){
3664 target_buf
[x
] = '.';
3669 target_buf
[x
] = ' ';
3674 /* print - with a newline */
3675 Jim_fprintf( interp
, interp
->cookie_stdout
, "%s\n", target_buf
);
3681 case TS_CMD_MEM2ARRAY
:
3682 return target_mem2array( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3684 case TS_CMD_ARRAY2MEM
:
3685 return target_array2mem( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3687 case TS_CMD_EXAMINE
:
3689 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3692 e
= target
->type
->examine( target
);
3693 if( e
!= ERROR_OK
){
3694 Jim_SetResult_sprintf( interp
, "examine-fails: %d", e
);
3700 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3703 if( !(target
->type
->examined
) ){
3704 e
= ERROR_TARGET_NOT_EXAMINED
;
3706 e
= target
->type
->poll( target
);
3708 if( e
!= ERROR_OK
){
3709 Jim_SetResult_sprintf( interp
, "poll-fails: %d", e
);
3716 if( goi
.argc
!= 2 ){
3717 Jim_WrongNumArgs( interp
, 2, argv
, "t|f|assert|deassert BOOL");
3720 e
= Jim_GetOpt_Nvp( &goi
, nvp_assert
, &n
);
3722 Jim_GetOpt_NvpUnknown( &goi
, nvp_assert
, 1 );
3725 // the halt or not param
3726 e
= Jim_GetOpt_Wide( &goi
, &a
);
3730 // determine if we should halt or not.
3731 target
->reset_halt
= !!a
;
3732 // When this happens - all workareas are invalid.
3733 target_free_all_working_areas_restore(target
, 0);
3736 if( n
->value
== NVP_ASSERT
){
3737 target
->type
->assert_reset( target
);
3739 target
->type
->deassert_reset( target
);
3744 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "halt [no parameters]");
3747 target
->type
->halt( target
);
3749 case TS_CMD_WAITSTATE
:
3750 // params: <name> statename timeoutmsecs
3751 if( goi
.argc
!= 2 ){
3752 Jim_SetResult_sprintf( goi
.interp
, "%s STATENAME TIMEOUTMSECS", n
->name
);
3755 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_state
, &n
);
3757 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_state
,1 );
3760 e
= Jim_GetOpt_Wide( &goi
, &a
);
3764 e
= target_wait_state( target
, n
->value
, a
);
3765 if( e
!= ERROR_OK
){
3766 Jim_SetResult_sprintf( goi
.interp
,
3767 "target: %s wait %s fails (%d) %s",
3770 e
, target_strerror_safe(e
) );
3775 case TS_CMD_EVENTLIST
:
3776 /* List for human, Events defined for this target.
3777 * scripts/programs should use 'name cget -event NAME'
3780 target_event_action_t
*teap
;
3781 teap
= target
->event_action
;
3782 command_print( cmd_ctx
, "Event actions for target (%d) %s\n",
3783 target
->target_number
,
3785 command_print( cmd_ctx
, "%-25s | Body", "Event");
3786 command_print( cmd_ctx
, "------------------------- | ----------------------------------------");
3788 command_print( cmd_ctx
,
3790 Jim_Nvp_value2name_simple( nvp_target_event
, teap
->event
)->name
,
3791 Jim_GetString( teap
->body
, NULL
) );
3794 command_print( cmd_ctx
, "***END***");
3797 case TS_CMD_CURSTATE
:
3798 if( goi
.argc
!= 0 ){
3799 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "[no parameters]");
3802 Jim_SetResultString( goi
.interp
,
3803 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
,-1);
3805 case TS_CMD_INVOKE_EVENT
:
3806 if( goi
.argc
!= 1 ){
3807 Jim_SetResult_sprintf( goi
.interp
, "%s ?EVENTNAME?",n
->name
);
3810 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_event
, &n
);
3812 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_event
, 1 );
3815 target_handle_event( target
, n
->value
);
3823 target_create( Jim_GetOptInfo
*goi
)
3833 struct command_context_s
*cmd_ctx
;
3835 cmd_ctx
= Jim_GetAssocData(goi
->interp
, "context");
3836 if( goi
->argc
< 3 ){
3837 Jim_WrongNumArgs( goi
->interp
, 1, goi
->argv
, "?name? ?type? ..options...");
3842 Jim_GetOpt_Obj( goi
, &new_cmd
);
3843 /* does this command exist? */
3844 cmd
= Jim_GetCommand( goi
->interp
, new_cmd
, JIM_ERRMSG
);
3846 cp
= Jim_GetString( new_cmd
, NULL
);
3847 Jim_SetResult_sprintf(goi
->interp
, "Command/target: %s Exists", cp
);
3852 e
= Jim_GetOpt_String( goi
, &cp2
, NULL
);
3854 /* now does target type exist */
3855 for( x
= 0 ; target_types
[x
] ; x
++ ){
3856 if( 0 == strcmp( cp
, target_types
[x
]->name
) ){
3861 if( target_types
[x
] == NULL
){
3862 Jim_SetResult_sprintf( goi
->interp
, "Unknown target type %s, try one of ", cp
);
3863 for( x
= 0 ; target_types
[x
] ; x
++ ){
3864 if( target_types
[x
+1] ){
3865 Jim_AppendStrings( goi
->interp
,
3866 Jim_GetResult(goi
->interp
),
3867 target_types
[x
]->name
,
3870 Jim_AppendStrings( goi
->interp
,
3871 Jim_GetResult(goi
->interp
),
3873 target_types
[x
]->name
,NULL
);
3881 target
= calloc(1,sizeof(target_t
));
3882 /* set target number */
3883 target
->target_number
= new_target_number();
3885 /* allocate memory for each unique target type */
3886 target
->type
= (target_type_t
*)calloc(1,sizeof(target_type_t
));
3888 memcpy( target
->type
, target_types
[x
], sizeof(target_type_t
));
3890 /* will be set by "-endian" */
3891 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3893 target
->working_area
= 0x0;
3894 target
->working_area_size
= 0x0;
3895 target
->working_areas
= NULL
;
3896 target
->backup_working_area
= 0;
3898 target
->state
= TARGET_UNKNOWN
;
3899 target
->debug_reason
= DBG_REASON_UNDEFINED
;
3900 target
->reg_cache
= NULL
;
3901 target
->breakpoints
= NULL
;
3902 target
->watchpoints
= NULL
;
3903 target
->next
= NULL
;
3904 target
->arch_info
= NULL
;
3906 target
->display
= 1;
3908 /* initialize trace information */
3909 target
->trace_info
= malloc(sizeof(trace_t
));
3910 target
->trace_info
->num_trace_points
= 0;
3911 target
->trace_info
->trace_points_size
= 0;
3912 target
->trace_info
->trace_points
= NULL
;
3913 target
->trace_info
->trace_history_size
= 0;
3914 target
->trace_info
->trace_history
= NULL
;
3915 target
->trace_info
->trace_history_pos
= 0;
3916 target
->trace_info
->trace_history_overflowed
= 0;
3918 target
->dbgmsg
= NULL
;
3919 target
->dbg_msg_enabled
= 0;
3921 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3923 /* Do the rest as "configure" options */
3924 goi
->isconfigure
= 1;
3925 e
= target_configure( goi
, target
);
3927 free( target
->type
);
3932 if( target
->endianness
== TARGET_ENDIAN_UNKNOWN
){
3933 /* default endian to little if not specified */
3934 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3937 /* create the target specific commands */
3938 if( target
->type
->register_commands
){
3939 (*(target
->type
->register_commands
))( cmd_ctx
);
3941 if( target
->type
->target_create
){
3942 (*(target
->type
->target_create
))( target
, goi
->interp
);
3945 /* append to end of list */
3948 tpp
= &(all_targets
);
3950 tpp
= &( (*tpp
)->next
);
3955 cp
= Jim_GetString( new_cmd
, NULL
);
3956 target
->cmd_name
= strdup(cp
);
3958 /* now - create the new target name command */
3959 e
= Jim_CreateCommand( goi
->interp
,
3962 tcl_target_func
, /* C function */
3963 target
, /* private data */
3964 NULL
); /* no del proc */
3970 jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3974 struct command_context_s
*cmd_ctx
;
3979 /* TG = target generic */
3987 const char *target_cmds
[] = {
3988 "create", "types", "names", "current", "number",
3993 LOG_DEBUG("Target command params:");
3994 LOG_DEBUG(Jim_Debug_ArgvString( interp
, argc
, argv
) );
3996 cmd_ctx
= Jim_GetAssocData( interp
, "context" );
3998 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
4000 if( goi
.argc
== 0 ){
4001 Jim_WrongNumArgs(interp
, 1, argv
, "missing: command ...");
4005 /* is this old syntax? */
4006 /* To determine: We have to peek at argv[0]*/
4007 cp
= Jim_GetString( goi
.argv
[0], NULL
);
4008 for( x
= 0 ; target_types
[x
] ; x
++ ){
4009 if( 0 == strcmp(cp
,target_types
[x
]->name
) ){
4013 if( target_types
[x
] ){
4014 /* YES IT IS OLD SYNTAX */
4015 Jim_Obj
*new_argv
[10];
4018 /* target_old_syntax
4020 * It appears that there are 2 old syntaxes:
4022 * target <typename> <endian> <chain position> <variant>
4026 * target <typename> <endian> <reset mode> <chain position> <variant>
4030 /* The minimum number of arguments is 4 */
4032 Jim_WrongNumArgs( interp
, 1, argv
, "[OLDSYNTAX] ?TYPE? ?ENDIAN? ?CHAIN-POSITION? ?VARIANT?");
4037 new_argv
[0] = argv
[0];
4038 new_argv
[1] = Jim_NewStringObj( interp
, "create", -1 );
4041 sprintf( buf
, "target%d", new_target_number() );
4042 new_argv
[2] = Jim_NewStringObj( interp
, buf
, -1 );
4044 new_argv
[3] = goi
.argv
[0]; /* typename */
4045 new_argv
[4] = Jim_NewStringObj( interp
, "-endian", -1 );
4046 new_argv
[5] = goi
.argv
[1];
4047 new_argv
[6] = Jim_NewStringObj( interp
, "-chain-position", -1 );
4049 /* If goi.argv[2] is not a number, we need to skip it since it is the reset mode. */
4051 int chain_position_argv
= 2;
4052 if (JIM_ERR
== Jim_GetWide(interp
, goi
.argv
[chain_position_argv
], &w
)) {
4053 if (chain_position_argv
+ 1 < goi
.argc
) {
4054 chain_position_argv
+= 1;
4056 Jim_WrongNumArgs( interp
, 1, argv
, "[OLDSYNTAX] ?TYPE? ?ENDIAN? ?RESET? ?CHAIN-POSITION? ?VARIANT?");
4061 new_argv
[7] = goi
.argv
[chain_position_argv
];
4063 /* Only provide a variant configure option if there was a variant specified */
4064 if (chain_position_argv
+ 1 < goi
.argc
) {
4065 new_argv
[8] = Jim_NewStringObj( interp
, "-variant", -1 );
4066 new_argv
[9] = goi
.argv
[chain_position_argv
+ 1];
4077 * argv[3] = typename
4080 * argv[6] = -position
4082 * argv[8] = -variant
4083 * argv[9] = "somestring"
4086 /* don't let these be released */
4087 for( x
= 0 ; x
< new_argc
; x
++ ){
4088 Jim_IncrRefCount( new_argv
[x
]);
4091 LOG_DEBUG("Target OLD SYNTAX - converted to new syntax");
4093 r
= jim_target( goi
.interp
, new_argc
, new_argv
);
4095 /* release? these items */
4096 for( x
= 0 ; x
< new_argc
; x
++ ){
4097 Jim_DecrRefCount( interp
, new_argv
[x
] );
4102 //Jim_GetOpt_Debug( &goi );
4103 r
= Jim_GetOpt_Enum( &goi
, target_cmds
, &x
);
4110 Jim_Panic(goi
.interp
,"Why am I here?");
4112 case TG_CMD_CURRENT
:
4113 if( goi
.argc
!= 0 ){
4114 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters");
4117 Jim_SetResultString( goi
.interp
, get_current_target( cmd_ctx
)->cmd_name
, -1 );
4120 if( goi
.argc
!= 0 ){
4121 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4124 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4125 for( x
= 0 ; target_types
[x
] ; x
++ ){
4126 Jim_ListAppendElement( goi
.interp
,
4127 Jim_GetResult(goi
.interp
),
4128 Jim_NewStringObj( goi
.interp
, target_types
[x
]->name
, -1 ) );
4132 if( goi
.argc
!= 0 ){
4133 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4136 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4137 target
= all_targets
;
4139 Jim_ListAppendElement( goi
.interp
,
4140 Jim_GetResult(goi
.interp
),
4141 Jim_NewStringObj( goi
.interp
, target
->cmd_name
, -1 ) );
4142 target
= target
->next
;
4147 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "?name ... config options ...");
4150 return target_create( &goi
);
4153 if( goi
.argc
!= 1 ){
4154 Jim_SetResult_sprintf( goi
.interp
, "expected: target number ?NUMBER?");
4157 e
= Jim_GetOpt_Wide( &goi
, &w
);
4163 t
= get_target_by_num(w
);
4165 Jim_SetResult_sprintf( goi
.interp
,"Target: number %d does not exist", (int)(w
));
4168 Jim_SetResultString( goi
.interp
, t
->cmd_name
, -1 );
4172 if( goi
.argc
!= 0 ){
4173 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "<no parameters>");
4176 Jim_SetResult( goi
.interp
,
4177 Jim_NewIntObj( goi
.interp
, max_target_number()));
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)