1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008, Duane Ellis *
9 * openocd@duaneeellis.com *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
14 * Copyright (C) 2008 by Rick Altherr *
15 * kc8apf@kc8apf.net> *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program; if not, write to the *
29 * Free Software Foundation, Inc., *
30 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
31 ***************************************************************************/
36 #include "replacements.h"
38 #include "target_request.h"
41 #include "configuration.h"
42 #include "binarybuffer.h"
49 #include <sys/types.h>
57 #include <time_support.h>
62 static int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 static int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 static int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 static int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
67 static int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 static int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
69 static int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 static int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 static int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 static int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 static int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
74 static int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
75 static int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
76 static int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
77 static int handle_test_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 static int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 static int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
80 static int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
81 static int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 static int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
);
83 static int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
84 static int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
85 static int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
87 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
88 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
89 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
91 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
92 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
);
95 extern target_type_t arm7tdmi_target
;
96 extern target_type_t arm720t_target
;
97 extern target_type_t arm9tdmi_target
;
98 extern target_type_t arm920t_target
;
99 extern target_type_t arm966e_target
;
100 extern target_type_t arm926ejs_target
;
101 extern target_type_t feroceon_target
;
102 extern target_type_t xscale_target
;
103 extern target_type_t cortexm3_target
;
104 extern target_type_t arm11_target
;
105 extern target_type_t mips_m4k_target
;
106 extern target_type_t avr_target
;
108 target_type_t
*target_types
[] =
125 target_t
*all_targets
= NULL
;
126 target_event_callback_t
*target_event_callbacks
= NULL
;
127 target_timer_callback_t
*target_timer_callbacks
= NULL
;
129 const Jim_Nvp nvp_assert
[] = {
130 { .name
= "assert", NVP_ASSERT
},
131 { .name
= "deassert", NVP_DEASSERT
},
132 { .name
= "T", NVP_ASSERT
},
133 { .name
= "F", NVP_DEASSERT
},
134 { .name
= "t", NVP_ASSERT
},
135 { .name
= "f", NVP_DEASSERT
},
136 { .name
= NULL
, .value
= -1 }
139 const Jim_Nvp nvp_error_target
[] = {
140 { .value
= ERROR_TARGET_INVALID
, .name
= "err-invalid" },
141 { .value
= ERROR_TARGET_INIT_FAILED
, .name
= "err-init-failed" },
142 { .value
= ERROR_TARGET_TIMEOUT
, .name
= "err-timeout" },
143 { .value
= ERROR_TARGET_NOT_HALTED
, .name
= "err-not-halted" },
144 { .value
= ERROR_TARGET_FAILURE
, .name
= "err-failure" },
145 { .value
= ERROR_TARGET_UNALIGNED_ACCESS
, .name
= "err-unaligned-access" },
146 { .value
= ERROR_TARGET_DATA_ABORT
, .name
= "err-data-abort" },
147 { .value
= ERROR_TARGET_RESOURCE_NOT_AVAILABLE
, .name
= "err-resource-not-available" },
148 { .value
= ERROR_TARGET_TRANSLATION_FAULT
, .name
= "err-translation-fault" },
149 { .value
= ERROR_TARGET_NOT_RUNNING
, .name
= "err-not-running" },
150 { .value
= ERROR_TARGET_NOT_EXAMINED
, .name
= "err-not-examined" },
151 { .value
= -1, .name
= NULL
}
154 const char *target_strerror_safe( int err
)
158 n
= Jim_Nvp_value2name_simple( nvp_error_target
, err
);
159 if( n
->name
== NULL
){
166 const Jim_Nvp nvp_target_event
[] = {
167 { .value
= TARGET_EVENT_OLD_gdb_program_config
, .name
= "old-gdb_program_config" },
168 { .value
= TARGET_EVENT_OLD_pre_resume
, .name
= "old-pre_resume" },
170 { .value
= TARGET_EVENT_EARLY_HALTED
, .name
= "early-halted" },
171 { .value
= TARGET_EVENT_HALTED
, .name
= "halted" },
172 { .value
= TARGET_EVENT_RESUMED
, .name
= "resumed" },
173 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
174 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
176 { .name
= "gdb-start", .value
= TARGET_EVENT_GDB_START
},
177 { .name
= "gdb-end", .value
= TARGET_EVENT_GDB_END
},
179 /* historical name */
181 { .value
= TARGET_EVENT_RESET_START
, .name
= "reset-start" },
183 { .value
= TARGET_EVENT_RESET_ASSERT_PRE
, .name
= "reset-assert-pre" },
184 { .value
= TARGET_EVENT_RESET_ASSERT_POST
, .name
= "reset-assert-post" },
185 { .value
= TARGET_EVENT_RESET_DEASSERT_PRE
, .name
= "reset-deassert-pre" },
186 { .value
= TARGET_EVENT_RESET_DEASSERT_POST
, .name
= "reset-deassert-post" },
187 { .value
= TARGET_EVENT_RESET_HALT_PRE
, .name
= "reset-halt-pre" },
188 { .value
= TARGET_EVENT_RESET_HALT_POST
, .name
= "reset-halt-post" },
189 { .value
= TARGET_EVENT_RESET_WAIT_PRE
, .name
= "reset-wait-pre" },
190 { .value
= TARGET_EVENT_RESET_WAIT_POST
, .name
= "reset-wait-post" },
191 { .value
= TARGET_EVENT_RESET_INIT
, .name
= "reset-init" },
192 { .value
= TARGET_EVENT_RESET_END
, .name
= "reset-end" },
194 { .value
= TARGET_EVENT_EXAMINE_START
, .name
= "examine-start" },
195 { .value
= TARGET_EVENT_EXAMINE_END
, .name
= "examine-end" },
197 { .value
= TARGET_EVENT_DEBUG_HALTED
, .name
= "debug-halted" },
198 { .value
= TARGET_EVENT_DEBUG_RESUMED
, .name
= "debug-resumed" },
200 { .value
= TARGET_EVENT_GDB_ATTACH
, .name
= "gdb-attach" },
201 { .value
= TARGET_EVENT_GDB_DETACH
, .name
= "gdb-detach" },
203 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_START
, .name
= "gdb-flash-write-start" },
204 { .value
= TARGET_EVENT_GDB_FLASH_WRITE_END
, .name
= "gdb-flash-write-end" },
206 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_START
, .name
= "gdb-flash-erase-start" },
207 { .value
= TARGET_EVENT_GDB_FLASH_ERASE_END
, .name
= "gdb-flash-erase-end" },
209 { .value
= TARGET_EVENT_RESUME_START
, .name
= "resume-start" },
210 { .value
= TARGET_EVENT_RESUMED
, .name
= "resume-ok" },
211 { .value
= TARGET_EVENT_RESUME_END
, .name
= "resume-end" },
213 { .name
= NULL
, .value
= -1 }
216 const Jim_Nvp nvp_target_state
[] = {
217 { .name
= "unknown", .value
= TARGET_UNKNOWN
},
218 { .name
= "running", .value
= TARGET_RUNNING
},
219 { .name
= "halted", .value
= TARGET_HALTED
},
220 { .name
= "reset", .value
= TARGET_RESET
},
221 { .name
= "debug-running", .value
= TARGET_DEBUG_RUNNING
},
222 { .name
= NULL
, .value
= -1 },
225 const Jim_Nvp nvp_target_debug_reason
[] = {
226 { .name
= "debug-request" , .value
= DBG_REASON_DBGRQ
},
227 { .name
= "breakpoint" , .value
= DBG_REASON_BREAKPOINT
},
228 { .name
= "watchpoint" , .value
= DBG_REASON_WATCHPOINT
},
229 { .name
= "watchpoint-and-breakpoint", .value
= DBG_REASON_WPTANDBKPT
},
230 { .name
= "single-step" , .value
= DBG_REASON_SINGLESTEP
},
231 { .name
= "target-not-halted" , .value
= DBG_REASON_NOTHALTED
},
232 { .name
= "undefined" , .value
= DBG_REASON_UNDEFINED
},
233 { .name
= NULL
, .value
= -1 },
236 const Jim_Nvp nvp_target_endian
[] = {
237 { .name
= "big", .value
= TARGET_BIG_ENDIAN
},
238 { .name
= "little", .value
= TARGET_LITTLE_ENDIAN
},
239 { .name
= "be", .value
= TARGET_BIG_ENDIAN
},
240 { .name
= "le", .value
= TARGET_LITTLE_ENDIAN
},
241 { .name
= NULL
, .value
= -1 },
244 const Jim_Nvp nvp_reset_modes
[] = {
245 { .name
= "unknown", .value
= RESET_UNKNOWN
},
246 { .name
= "run" , .value
= RESET_RUN
},
247 { .name
= "halt" , .value
= RESET_HALT
},
248 { .name
= "init" , .value
= RESET_INIT
},
249 { .name
= NULL
, .value
= -1 },
252 static int max_target_number(void)
260 if( x
< t
->target_number
){
261 x
= (t
->target_number
)+1;
268 /* determine the number of the new target */
269 static int new_target_number(void)
274 /* number is 0 based */
278 if( x
< t
->target_number
){
279 x
= t
->target_number
;
286 static int target_continous_poll
= 1;
288 /* read a u32 from a buffer in target memory endianness */
289 u32
target_buffer_get_u32(target_t
*target
, u8
*buffer
)
291 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
292 return le_to_h_u32(buffer
);
294 return be_to_h_u32(buffer
);
297 /* read a u16 from a buffer in target memory endianness */
298 u16
target_buffer_get_u16(target_t
*target
, u8
*buffer
)
300 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
301 return le_to_h_u16(buffer
);
303 return be_to_h_u16(buffer
);
306 /* read a u8 from a buffer in target memory endianness */
307 u8
target_buffer_get_u8(target_t
*target
, u8
*buffer
)
309 return *buffer
& 0x0ff;
312 /* write a u32 to a buffer in target memory endianness */
313 void target_buffer_set_u32(target_t
*target
, u8
*buffer
, u32 value
)
315 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
316 h_u32_to_le(buffer
, value
);
318 h_u32_to_be(buffer
, value
);
321 /* write a u16 to a buffer in target memory endianness */
322 void target_buffer_set_u16(target_t
*target
, u8
*buffer
, u16 value
)
324 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
325 h_u16_to_le(buffer
, value
);
327 h_u16_to_be(buffer
, value
);
330 /* write a u8 to a buffer in target memory endianness */
331 void target_buffer_set_u8(target_t
*target
, u8
*buffer
, u8 value
)
336 /* returns a pointer to the n-th configured target */
337 target_t
* get_target_by_num(int num
)
339 target_t
*target
= all_targets
;
342 if( target
->target_number
== num
){
345 target
= target
->next
;
351 int get_num_by_target(target_t
*query_target
)
353 return query_target
->target_number
;
356 target_t
* get_current_target(command_context_t
*cmd_ctx
)
358 target_t
*target
= get_target_by_num(cmd_ctx
->current_target
);
362 LOG_ERROR("BUG: current_target out of bounds");
369 int target_poll(struct target_s
*target
)
371 /* We can't poll until after examine */
372 if (!target
->type
->examined
)
374 /* Fail silently lest we pollute the log */
377 return target
->type
->poll(target
);
380 int target_halt(struct target_s
*target
)
382 /* We can't poll until after examine */
383 if (!target
->type
->examined
)
385 LOG_ERROR("Target not examined yet");
388 return target
->type
->halt(target
);
391 int target_resume(struct target_s
*target
, int current
, u32 address
, int handle_breakpoints
, int debug_execution
)
395 /* We can't poll until after examine */
396 if (!target
->type
->examined
)
398 LOG_ERROR("Target not examined yet");
402 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
403 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
406 if ((retval
= target
->type
->resume(target
, current
, address
, handle_breakpoints
, debug_execution
)) != ERROR_OK
)
412 int target_process_reset(struct command_context_s
*cmd_ctx
, enum target_reset_mode reset_mode
)
417 n
= Jim_Nvp_value2name_simple( nvp_reset_modes
, reset_mode
);
418 if( n
->name
== NULL
){
419 LOG_ERROR("invalid reset mode");
423 sprintf( buf
, "ocd_process_reset %s", n
->name
);
424 retval
= Jim_Eval( interp
, buf
);
426 if(retval
!= JIM_OK
) {
427 Jim_PrintErrorMessage(interp
);
431 /* We want any events to be processed before the prompt */
432 retval
= target_call_timer_callbacks_now();
437 static int default_virt2phys(struct target_s
*target
, u32
virtual, u32
*physical
)
443 static int default_mmu(struct target_s
*target
, int *enabled
)
449 static int default_examine(struct target_s
*target
)
451 target
->type
->examined
= 1;
455 /* Targets that correctly implement init+examine, i.e.
456 * no communication with target during init:
460 int target_examine(void)
462 int retval
= ERROR_OK
;
463 target_t
*target
= all_targets
;
466 if ((retval
= target
->type
->examine(target
))!=ERROR_OK
)
468 target
= target
->next
;
473 static int target_write_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
475 if (!target
->type
->examined
)
477 LOG_ERROR("Target not examined yet");
480 return target
->type
->write_memory_imp(target
, address
, size
, count
, buffer
);
483 static int target_read_memory_imp(struct target_s
*target
, u32 address
, u32 size
, u32 count
, u8
*buffer
)
485 if (!target
->type
->examined
)
487 LOG_ERROR("Target not examined yet");
490 return target
->type
->read_memory_imp(target
, address
, size
, count
, buffer
);
493 static int target_soft_reset_halt_imp(struct target_s
*target
)
495 if (!target
->type
->examined
)
497 LOG_ERROR("Target not examined yet");
500 return target
->type
->soft_reset_halt_imp(target
);
503 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
)
505 if (!target
->type
->examined
)
507 LOG_ERROR("Target not examined yet");
510 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
);
513 int target_init(struct command_context_s
*cmd_ctx
)
515 target_t
*target
= all_targets
;
520 target
->type
->examined
= 0;
521 if (target
->type
->examine
== NULL
)
523 target
->type
->examine
= default_examine
;
526 if ((retval
= target
->type
->init_target(cmd_ctx
, target
)) != ERROR_OK
)
528 LOG_ERROR("target '%s' init failed", target
->type
->name
);
532 /* Set up default functions if none are provided by target */
533 if (target
->type
->virt2phys
== NULL
)
535 target
->type
->virt2phys
= default_virt2phys
;
537 target
->type
->virt2phys
= default_virt2phys
;
538 /* a non-invasive way(in terms of patches) to add some code that
539 * runs before the type->write/read_memory implementation
541 target
->type
->write_memory_imp
= target
->type
->write_memory
;
542 target
->type
->write_memory
= target_write_memory_imp
;
543 target
->type
->read_memory_imp
= target
->type
->read_memory
;
544 target
->type
->read_memory
= target_read_memory_imp
;
545 target
->type
->soft_reset_halt_imp
= target
->type
->soft_reset_halt
;
546 target
->type
->soft_reset_halt
= target_soft_reset_halt_imp
;
547 target
->type
->run_algorithm_imp
= target
->type
->run_algorithm
;
548 target
->type
->run_algorithm
= target_run_algorithm_imp
;
550 if (target
->type
->mmu
== NULL
)
552 target
->type
->mmu
= default_mmu
;
554 target
= target
->next
;
559 if((retval
= target_register_user_commands(cmd_ctx
)) != ERROR_OK
)
561 if((retval
= target_register_timer_callback(handle_target
, 100, 1, NULL
)) != ERROR_OK
)
568 int target_register_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
570 target_event_callback_t
**callbacks_p
= &target_event_callbacks
;
572 if (callback
== NULL
)
574 return ERROR_INVALID_ARGUMENTS
;
579 while ((*callbacks_p
)->next
)
580 callbacks_p
= &((*callbacks_p
)->next
);
581 callbacks_p
= &((*callbacks_p
)->next
);
584 (*callbacks_p
) = malloc(sizeof(target_event_callback_t
));
585 (*callbacks_p
)->callback
= callback
;
586 (*callbacks_p
)->priv
= priv
;
587 (*callbacks_p
)->next
= NULL
;
592 int target_register_timer_callback(int (*callback
)(void *priv
), int time_ms
, int periodic
, void *priv
)
594 target_timer_callback_t
**callbacks_p
= &target_timer_callbacks
;
597 if (callback
== NULL
)
599 return ERROR_INVALID_ARGUMENTS
;
604 while ((*callbacks_p
)->next
)
605 callbacks_p
= &((*callbacks_p
)->next
);
606 callbacks_p
= &((*callbacks_p
)->next
);
609 (*callbacks_p
) = malloc(sizeof(target_timer_callback_t
));
610 (*callbacks_p
)->callback
= callback
;
611 (*callbacks_p
)->periodic
= periodic
;
612 (*callbacks_p
)->time_ms
= time_ms
;
614 gettimeofday(&now
, NULL
);
615 (*callbacks_p
)->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
616 time_ms
-= (time_ms
% 1000);
617 (*callbacks_p
)->when
.tv_sec
= now
.tv_sec
+ (time_ms
/ 1000);
618 if ((*callbacks_p
)->when
.tv_usec
> 1000000)
620 (*callbacks_p
)->when
.tv_usec
= (*callbacks_p
)->when
.tv_usec
- 1000000;
621 (*callbacks_p
)->when
.tv_sec
+= 1;
624 (*callbacks_p
)->priv
= priv
;
625 (*callbacks_p
)->next
= NULL
;
630 int target_unregister_event_callback(int (*callback
)(struct target_s
*target
, enum target_event event
, void *priv
), void *priv
)
632 target_event_callback_t
**p
= &target_event_callbacks
;
633 target_event_callback_t
*c
= target_event_callbacks
;
635 if (callback
== NULL
)
637 return ERROR_INVALID_ARGUMENTS
;
642 target_event_callback_t
*next
= c
->next
;
643 if ((c
->callback
== callback
) && (c
->priv
== priv
))
657 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
)
659 target_timer_callback_t
**p
= &target_timer_callbacks
;
660 target_timer_callback_t
*c
= target_timer_callbacks
;
662 if (callback
== NULL
)
664 return ERROR_INVALID_ARGUMENTS
;
669 target_timer_callback_t
*next
= c
->next
;
670 if ((c
->callback
== callback
) && (c
->priv
== priv
))
684 int target_call_event_callbacks(target_t
*target
, enum target_event event
)
686 target_event_callback_t
*callback
= target_event_callbacks
;
687 target_event_callback_t
*next_callback
;
689 if (event
== TARGET_EVENT_HALTED
)
691 /* execute early halted first */
692 target_call_event_callbacks(target
, TARGET_EVENT_EARLY_HALTED
);
695 LOG_DEBUG("target event %i (%s)",
697 Jim_Nvp_value2name_simple( nvp_target_event
, event
)->name
);
699 target_handle_event( target
, event
);
703 next_callback
= callback
->next
;
704 callback
->callback(target
, event
, callback
->priv
);
705 callback
= next_callback
;
711 static int target_call_timer_callbacks_check_time(int checktime
)
713 target_timer_callback_t
*callback
= target_timer_callbacks
;
714 target_timer_callback_t
*next_callback
;
719 gettimeofday(&now
, NULL
);
723 next_callback
= callback
->next
;
725 if ((!checktime
&&callback
->periodic
)||
726 (((now
.tv_sec
>= callback
->when
.tv_sec
) && (now
.tv_usec
>= callback
->when
.tv_usec
))
727 || (now
.tv_sec
> callback
->when
.tv_sec
)))
729 if(callback
->callback
!= NULL
)
731 callback
->callback(callback
->priv
);
732 if (callback
->periodic
)
734 int time_ms
= callback
->time_ms
;
735 callback
->when
.tv_usec
= now
.tv_usec
+ (time_ms
% 1000) * 1000;
736 time_ms
-= (time_ms
% 1000);
737 callback
->when
.tv_sec
= now
.tv_sec
+ time_ms
/ 1000;
738 if (callback
->when
.tv_usec
> 1000000)
740 callback
->when
.tv_usec
= callback
->when
.tv_usec
- 1000000;
741 callback
->when
.tv_sec
+= 1;
747 if((retval
= target_unregister_timer_callback(callback
->callback
, callback
->priv
)) != ERROR_OK
)
753 callback
= next_callback
;
759 int target_call_timer_callbacks(void)
761 return target_call_timer_callbacks_check_time(1);
764 /* invoke periodic callbacks immediately */
765 int target_call_timer_callbacks_now(void)
767 return target_call_timer_callbacks_check_time(0);
770 int target_alloc_working_area(struct target_s
*target
, u32 size
, working_area_t
**area
)
772 working_area_t
*c
= target
->working_areas
;
773 working_area_t
*new_wa
= NULL
;
775 /* Reevaluate working area address based on MMU state*/
776 if (target
->working_areas
== NULL
)
780 retval
= target
->type
->mmu(target
, &enabled
);
781 if (retval
!= ERROR_OK
)
787 target
->working_area
= target
->working_area_virt
;
791 target
->working_area
= target
->working_area_phys
;
795 /* only allocate multiples of 4 byte */
798 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
799 size
= CEIL(size
, 4);
802 /* see if there's already a matching working area */
805 if ((c
->free
) && (c
->size
== size
))
813 /* if not, allocate a new one */
816 working_area_t
**p
= &target
->working_areas
;
817 u32 first_free
= target
->working_area
;
818 u32 free_size
= target
->working_area_size
;
820 LOG_DEBUG("allocating new working area");
822 c
= target
->working_areas
;
825 first_free
+= c
->size
;
826 free_size
-= c
->size
;
831 if (free_size
< size
)
833 LOG_WARNING("not enough working area available(requested %d, free %d)", size
, free_size
);
834 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
837 new_wa
= malloc(sizeof(working_area_t
));
840 new_wa
->address
= first_free
;
842 if (target
->backup_working_area
)
845 new_wa
->backup
= malloc(new_wa
->size
);
846 if((retval
= target
->type
->read_memory(target
, new_wa
->address
, 4, new_wa
->size
/ 4, new_wa
->backup
)) != ERROR_OK
)
848 free(new_wa
->backup
);
855 new_wa
->backup
= NULL
;
858 /* put new entry in list */
862 /* mark as used, and return the new (reused) area */
872 int target_free_working_area_restore(struct target_s
*target
, working_area_t
*area
, int restore
)
877 if (restore
&&target
->backup_working_area
)
880 if((retval
= target
->type
->write_memory(target
, area
->address
, 4, area
->size
/ 4, area
->backup
)) != ERROR_OK
)
886 /* mark user pointer invalid */
893 int target_free_working_area(struct target_s
*target
, working_area_t
*area
)
895 return target_free_working_area_restore(target
, area
, 1);
898 /* free resources and restore memory, if restoring memory fails,
899 * free up resources anyway
901 void target_free_all_working_areas_restore(struct target_s
*target
, int restore
)
903 working_area_t
*c
= target
->working_areas
;
907 working_area_t
*next
= c
->next
;
908 target_free_working_area_restore(target
, c
, restore
);
918 target
->working_areas
= NULL
;
921 void target_free_all_working_areas(struct target_s
*target
)
923 target_free_all_working_areas_restore(target
, 1);
926 int target_register_commands(struct command_context_s
*cmd_ctx
)
929 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)");
934 register_jim(cmd_ctx
, "target", jim_target
, "configure target" );
939 int target_arch_state(struct target_s
*target
)
944 LOG_USER("No target has been configured");
948 LOG_USER("target state: %s",
949 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
);
951 if (target
->state
!=TARGET_HALTED
)
954 retval
=target
->type
->arch_state(target
);
958 /* Single aligned words are guaranteed to use 16 or 32 bit access
959 * mode respectively, otherwise data is handled as quickly as
962 int target_write_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
965 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size
, address
);
967 if (!target
->type
->examined
)
969 LOG_ERROR("Target not examined yet");
973 if ((address
+ size
- 1) < address
)
975 /* GDB can request this when e.g. PC is 0xfffffffc*/
976 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
980 if (((address
% 2) == 0) && (size
== 2))
982 return target
->type
->write_memory(target
, address
, 2, 1, buffer
);
985 /* handle unaligned head bytes */
988 u32 unaligned
= 4 - (address
% 4);
990 if (unaligned
> size
)
993 if ((retval
= target
->type
->write_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
997 address
+= unaligned
;
1001 /* handle aligned words */
1004 int aligned
= size
- (size
% 4);
1006 /* use bulk writes above a certain limit. This may have to be changed */
1009 if ((retval
= target
->type
->bulk_write_memory(target
, address
, aligned
/ 4, buffer
)) != ERROR_OK
)
1014 if ((retval
= target
->type
->write_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1023 /* handle tail writes of less than 4 bytes */
1026 if ((retval
= target
->type
->write_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1033 /* Single aligned words are guaranteed to use 16 or 32 bit access
1034 * mode respectively, otherwise data is handled as quickly as
1037 int target_read_buffer(struct target_s
*target
, u32 address
, u32 size
, u8
*buffer
)
1040 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size
, address
);
1042 if (!target
->type
->examined
)
1044 LOG_ERROR("Target not examined yet");
1048 if ((address
+ size
- 1) < address
)
1050 /* GDB can request this when e.g. PC is 0xfffffffc*/
1051 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address
, size
);
1055 if (((address
% 2) == 0) && (size
== 2))
1057 return target
->type
->read_memory(target
, address
, 2, 1, buffer
);
1060 /* handle unaligned head bytes */
1063 u32 unaligned
= 4 - (address
% 4);
1065 if (unaligned
> size
)
1068 if ((retval
= target
->type
->read_memory(target
, address
, 1, unaligned
, buffer
)) != ERROR_OK
)
1071 buffer
+= unaligned
;
1072 address
+= unaligned
;
1076 /* handle aligned words */
1079 int aligned
= size
- (size
% 4);
1081 if ((retval
= target
->type
->read_memory(target
, address
, 4, aligned
/ 4, buffer
)) != ERROR_OK
)
1089 /* handle tail writes of less than 4 bytes */
1092 if ((retval
= target
->type
->read_memory(target
, address
, 1, size
, buffer
)) != ERROR_OK
)
1099 int target_checksum_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* crc
)
1105 if (!target
->type
->examined
)
1107 LOG_ERROR("Target not examined yet");
1111 if ((retval
= target
->type
->checksum_memory(target
, address
,
1112 size
, &checksum
)) != ERROR_OK
)
1114 buffer
= malloc(size
);
1117 LOG_ERROR("error allocating buffer for section (%d bytes)", size
);
1118 return ERROR_INVALID_ARGUMENTS
;
1120 retval
= target_read_buffer(target
, address
, size
, buffer
);
1121 if (retval
!= ERROR_OK
)
1127 /* convert to target endianess */
1128 for (i
= 0; i
< (size
/sizeof(u32
)); i
++)
1131 target_data
= target_buffer_get_u32(target
, &buffer
[i
*sizeof(u32
)]);
1132 target_buffer_set_u32(target
, &buffer
[i
*sizeof(u32
)], target_data
);
1135 retval
= image_calculate_checksum( buffer
, size
, &checksum
);
1144 int target_blank_check_memory(struct target_s
*target
, u32 address
, u32 size
, u32
* blank
)
1147 if (!target
->type
->examined
)
1149 LOG_ERROR("Target not examined yet");
1153 if (target
->type
->blank_check_memory
== 0)
1154 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
1156 retval
= target
->type
->blank_check_memory(target
, address
, size
, blank
);
1161 int target_read_u32(struct target_s
*target
, u32 address
, u32
*value
)
1164 if (!target
->type
->examined
)
1166 LOG_ERROR("Target not examined yet");
1170 int retval
= target
->type
->read_memory(target
, address
, 4, 1, value_buf
);
1172 if (retval
== ERROR_OK
)
1174 *value
= target_buffer_get_u32(target
, value_buf
);
1175 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, *value
);
1180 LOG_DEBUG("address: 0x%8.8x failed", address
);
1186 int target_read_u16(struct target_s
*target
, u32 address
, u16
*value
)
1189 if (!target
->type
->examined
)
1191 LOG_ERROR("Target not examined yet");
1195 int retval
= target
->type
->read_memory(target
, address
, 2, 1, value_buf
);
1197 if (retval
== ERROR_OK
)
1199 *value
= target_buffer_get_u16(target
, value_buf
);
1200 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address
, *value
);
1205 LOG_DEBUG("address: 0x%8.8x failed", address
);
1211 int target_read_u8(struct target_s
*target
, u32 address
, u8
*value
)
1213 int retval
= target
->type
->read_memory(target
, address
, 1, 1, value
);
1214 if (!target
->type
->examined
)
1216 LOG_ERROR("Target not examined yet");
1220 if (retval
== ERROR_OK
)
1222 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, *value
);
1227 LOG_DEBUG("address: 0x%8.8x failed", address
);
1233 int target_write_u32(struct target_s
*target
, u32 address
, u32 value
)
1237 if (!target
->type
->examined
)
1239 LOG_ERROR("Target not examined yet");
1243 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1245 target_buffer_set_u32(target
, value_buf
, value
);
1246 if ((retval
= target
->type
->write_memory(target
, address
, 4, 1, value_buf
)) != ERROR_OK
)
1248 LOG_DEBUG("failed: %i", retval
);
1254 int target_write_u16(struct target_s
*target
, u32 address
, u16 value
)
1258 if (!target
->type
->examined
)
1260 LOG_ERROR("Target not examined yet");
1264 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address
, value
);
1266 target_buffer_set_u16(target
, value_buf
, value
);
1267 if ((retval
= target
->type
->write_memory(target
, address
, 2, 1, value_buf
)) != ERROR_OK
)
1269 LOG_DEBUG("failed: %i", retval
);
1275 int target_write_u8(struct target_s
*target
, u32 address
, u8 value
)
1278 if (!target
->type
->examined
)
1280 LOG_ERROR("Target not examined yet");
1284 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address
, value
);
1286 if ((retval
= target
->type
->write_memory(target
, address
, 1, 1, &value
)) != ERROR_OK
)
1288 LOG_DEBUG("failed: %i", retval
);
1294 int target_register_user_commands(struct command_context_s
*cmd_ctx
)
1296 int retval
= ERROR_OK
;
1299 /* script procedures */
1300 register_command(cmd_ctx
, NULL
, "profile", handle_profile_command
, COMMAND_EXEC
, "profiling samples the CPU PC");
1301 register_jim(cmd_ctx
, "ocd_mem2array", jim_mem2array
, "read memory and return as a TCL array for script processing");
1302 register_jim(cmd_ctx
, "ocd_array2mem", jim_array2mem
, "convert a TCL array to memory locations and write the values");
1304 register_command(cmd_ctx
, NULL
, "fast_load_image", handle_fast_load_image_command
, COMMAND_ANY
,
1305 "same args as load_image, image stored in memory - mainly for profiling purposes");
1307 register_command(cmd_ctx
, NULL
, "fast_load", handle_fast_load_command
, COMMAND_ANY
,
1308 "loads active fast load image to current target - mainly for profiling purposes");
1311 register_command(cmd_ctx
, NULL
, "virt2phys", handle_virt2phys_command
, COMMAND_ANY
, "translate a virtual address into a physical address");
1312 register_command(cmd_ctx
, NULL
, "reg", handle_reg_command
, COMMAND_EXEC
, "display or set a register");
1313 register_command(cmd_ctx
, NULL
, "poll", handle_poll_command
, COMMAND_EXEC
, "poll target state");
1314 register_command(cmd_ctx
, NULL
, "wait_halt", handle_wait_halt_command
, COMMAND_EXEC
, "wait for target halt [time (s)]");
1315 register_command(cmd_ctx
, NULL
, "halt", handle_halt_command
, COMMAND_EXEC
, "halt target");
1316 register_command(cmd_ctx
, NULL
, "resume", handle_resume_command
, COMMAND_EXEC
, "resume target [addr]");
1317 register_command(cmd_ctx
, NULL
, "step", handle_step_command
, COMMAND_EXEC
, "step one instruction from current PC or [addr]");
1318 register_command(cmd_ctx
, NULL
, "reset", handle_reset_command
, COMMAND_EXEC
, "reset target [run|halt|init] - default is run");
1319 register_command(cmd_ctx
, NULL
, "soft_reset_halt", handle_soft_reset_halt_command
, COMMAND_EXEC
, "halt the target and do a soft reset");
1321 register_command(cmd_ctx
, NULL
, "mdw", handle_md_command
, COMMAND_EXEC
, "display memory words <addr> [count]");
1322 register_command(cmd_ctx
, NULL
, "mdh", handle_md_command
, COMMAND_EXEC
, "display memory half-words <addr> [count]");
1323 register_command(cmd_ctx
, NULL
, "mdb", handle_md_command
, COMMAND_EXEC
, "display memory bytes <addr> [count]");
1325 register_command(cmd_ctx
, NULL
, "mww", handle_mw_command
, COMMAND_EXEC
, "write memory word <addr> <value> [count]");
1326 register_command(cmd_ctx
, NULL
, "mwh", handle_mw_command
, COMMAND_EXEC
, "write memory half-word <addr> <value> [count]");
1327 register_command(cmd_ctx
, NULL
, "mwb", handle_mw_command
, COMMAND_EXEC
, "write memory byte <addr> <value> [count]");
1329 register_command(cmd_ctx
, NULL
, "bp", handle_bp_command
, COMMAND_EXEC
, "set breakpoint <address> <length> [hw]");
1330 register_command(cmd_ctx
, NULL
, "rbp", handle_rbp_command
, COMMAND_EXEC
, "remove breakpoint <adress>");
1331 register_command(cmd_ctx
, NULL
, "wp", handle_wp_command
, COMMAND_EXEC
, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1332 register_command(cmd_ctx
, NULL
, "rwp", handle_rwp_command
, COMMAND_EXEC
, "remove watchpoint <adress>");
1334 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]");
1335 register_command(cmd_ctx
, NULL
, "dump_image", handle_dump_image_command
, COMMAND_EXEC
, "dump_image <file> <address> <size>");
1336 register_command(cmd_ctx
, NULL
, "verify_image", handle_verify_image_command
, COMMAND_EXEC
, "verify_image <file> [offset] [type]");
1337 register_command(cmd_ctx
, NULL
, "test_image", handle_test_image_command
, COMMAND_EXEC
, "test_image <file> [offset] [type]");
1339 if((retval
= target_request_register_commands(cmd_ctx
)) != ERROR_OK
)
1341 if((retval
= trace_register_commands(cmd_ctx
)) != ERROR_OK
)
1347 static int handle_targets_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1350 target_t
*target
= all_targets
;
1354 /* try as tcltarget name */
1355 for( target
= all_targets
; target
; target
= target
->next
){
1356 if( target
->cmd_name
){
1357 if( 0 == strcmp( args
[0], target
->cmd_name
) ){
1363 /* no match, try as number */
1365 int num
= strtoul(args
[0], &cp
, 0 );
1367 /* then it was not a number */
1368 command_print( cmd_ctx
, "Target: %s unknown, try one of:\n", args
[0] );
1372 target
= get_target_by_num( num
);
1373 if( target
== NULL
){
1374 command_print(cmd_ctx
,"Target: %s is unknown, try one of:\n", args
[0] );
1378 cmd_ctx
->current_target
= target
->target_number
;
1383 target
= all_targets
;
1384 command_print(cmd_ctx
, " CmdName Type Endian AbsChainPos Name State ");
1385 command_print(cmd_ctx
, "-- ---------- ---------- ---------- ----------- ------------- ----------");
1388 /* XX: abcdefghij abcdefghij abcdefghij abcdefghij */
1389 command_print(cmd_ctx
, "%2d: %-10s %-10s %-10s %10d %14s %s",
1390 target
->target_number
,
1393 Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
)->name
,
1394 target
->tap
->abs_chain_position
,
1395 target
->tap
->dotted_name
,
1396 Jim_Nvp_value2name_simple( nvp_target_state
, target
->state
)->name
);
1397 target
= target
->next
;
1403 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1405 static int powerDropout
;
1406 static int srstAsserted
;
1408 static int runPowerRestore
;
1409 static int runPowerDropout
;
1410 static int runSrstAsserted
;
1411 static int runSrstDeasserted
;
1413 static int sense_handler(void)
1415 static int prevSrstAsserted
= 0;
1416 static int prevPowerdropout
= 0;
1419 if ((retval
=jtag_power_dropout(&powerDropout
))!=ERROR_OK
)
1423 powerRestored
= prevPowerdropout
&& !powerDropout
;
1426 runPowerRestore
= 1;
1429 long long current
= timeval_ms();
1430 static long long lastPower
= 0;
1431 int waitMore
= lastPower
+ 2000 > current
;
1432 if (powerDropout
&& !waitMore
)
1434 runPowerDropout
= 1;
1435 lastPower
= current
;
1438 if ((retval
=jtag_srst_asserted(&srstAsserted
))!=ERROR_OK
)
1442 srstDeasserted
= prevSrstAsserted
&& !srstAsserted
;
1444 static long long lastSrst
= 0;
1445 waitMore
= lastSrst
+ 2000 > current
;
1446 if (srstDeasserted
&& !waitMore
)
1448 runSrstDeasserted
= 1;
1452 if (!prevSrstAsserted
&& srstAsserted
)
1454 runSrstAsserted
= 1;
1457 prevSrstAsserted
= srstAsserted
;
1458 prevPowerdropout
= powerDropout
;
1460 if (srstDeasserted
|| powerRestored
)
1462 /* Other than logging the event we can't do anything here.
1463 * Issuing a reset is a particularly bad idea as we might
1464 * be inside a reset already.
1471 /* process target state changes */
1472 int handle_target(void *priv
)
1474 int retval
= ERROR_OK
;
1476 /* we do not want to recurse here... */
1477 static int recursive
= 0;
1482 /* danger! running these procedures can trigger srst assertions and power dropouts.
1483 * We need to avoid an infinite loop/recursion here and we do that by
1484 * clearing the flags after running these events.
1486 int did_something
= 0;
1487 if (runSrstAsserted
)
1489 Jim_Eval( interp
, "srst_asserted");
1492 if (runSrstDeasserted
)
1494 Jim_Eval( interp
, "srst_deasserted");
1497 if (runPowerDropout
)
1499 Jim_Eval( interp
, "power_dropout");
1502 if (runPowerRestore
)
1504 Jim_Eval( interp
, "power_restore");
1510 /* clear detect flags */
1514 /* clear action flags */
1517 runSrstDeasserted
=0;
1524 target_t
*target
= all_targets
;
1529 /* only poll target if we've got power and srst isn't asserted */
1530 if (target_continous_poll
&&!powerDropout
&&!srstAsserted
)
1532 /* polling may fail silently until the target has been examined */
1533 if((retval
= target_poll(target
)) != ERROR_OK
)
1537 target
= target
->next
;
1543 static int handle_reg_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1552 target
= get_current_target(cmd_ctx
);
1554 /* list all available registers for the current target */
1557 reg_cache_t
*cache
= target
->reg_cache
;
1563 for (i
= 0; i
< cache
->num_regs
; i
++)
1565 value
= buf_to_str(cache
->reg_list
[i
].value
, cache
->reg_list
[i
].size
, 16);
1566 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
);
1569 cache
= cache
->next
;
1575 /* access a single register by its ordinal number */
1576 if ((args
[0][0] >= '0') && (args
[0][0] <= '9'))
1578 int num
= strtoul(args
[0], NULL
, 0);
1579 reg_cache_t
*cache
= target
->reg_cache
;
1585 for (i
= 0; i
< cache
->num_regs
; i
++)
1589 reg
= &cache
->reg_list
[i
];
1595 cache
= cache
->next
;
1600 command_print(cmd_ctx
, "%i is out of bounds, the current target has only %i registers (0 - %i)", num
, count
, count
- 1);
1603 } else /* access a single register by its name */
1605 reg
= register_get_by_name(target
->reg_cache
, args
[0], 1);
1609 command_print(cmd_ctx
, "register %s not found in current target", args
[0]);
1614 /* display a register */
1615 if ((argc
== 1) || ((argc
== 2) && !((args
[1][0] >= '0') && (args
[1][0] <= '9'))))
1617 if ((argc
== 2) && (strcmp(args
[1], "force") == 0))
1620 if (reg
->valid
== 0)
1622 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1623 arch_type
->get(reg
);
1625 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1626 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1631 /* set register value */
1634 u8
*buf
= malloc(CEIL(reg
->size
, 8));
1635 str_to_buf(args
[1], strlen(args
[1]), buf
, reg
->size
, 0);
1637 reg_arch_type_t
*arch_type
= register_get_arch_type(reg
->arch_type
);
1638 arch_type
->set(reg
, buf
);
1640 value
= buf_to_str(reg
->value
, reg
->size
, 16);
1641 command_print(cmd_ctx
, "%s (/%i): 0x%s", reg
->name
, reg
->size
, value
);
1649 command_print(cmd_ctx
, "usage: reg <#|name> [value]");
1654 static int handle_poll_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1656 int retval
= ERROR_OK
;
1657 target_t
*target
= get_current_target(cmd_ctx
);
1661 if((retval
= target_poll(target
)) != ERROR_OK
)
1663 if((retval
= target_arch_state(target
)) != ERROR_OK
)
1669 if (strcmp(args
[0], "on") == 0)
1671 target_continous_poll
= 1;
1673 else if (strcmp(args
[0], "off") == 0)
1675 target_continous_poll
= 0;
1679 command_print(cmd_ctx
, "arg is \"on\" or \"off\"");
1683 return ERROR_COMMAND_SYNTAX_ERROR
;
1689 static int handle_wait_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1697 ms
= strtoul(args
[0], &end
, 0) * 1000;
1700 command_print(cmd_ctx
, "usage: %s [seconds]", cmd
);
1704 target_t
*target
= get_current_target(cmd_ctx
);
1706 return target_wait_state(target
, TARGET_HALTED
, ms
);
1709 /* wait for target state to change. The trick here is to have a low
1710 * latency for short waits and not to suck up all the CPU time
1713 * After 500ms, keep_alive() is invoked
1715 int target_wait_state(target_t
*target
, enum target_state state
, int ms
)
1718 long long then
=0, cur
;
1723 if ((retval
=target_poll(target
))!=ERROR_OK
)
1725 if (target
->state
== state
)
1733 then
= timeval_ms();
1734 LOG_DEBUG("waiting for target %s...",
1735 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1745 LOG_ERROR("timed out while waiting for target %s",
1746 Jim_Nvp_value2name_simple(nvp_target_state
,state
)->name
);
1754 static int handle_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1757 target_t
*target
= get_current_target(cmd_ctx
);
1761 if ((retval
= target_halt(target
)) != ERROR_OK
)
1771 wait
= strtoul(args
[0], &end
, 0);
1776 return handle_wait_halt_command(cmd_ctx
, cmd
, args
, argc
);
1779 static int handle_soft_reset_halt_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1781 target_t
*target
= get_current_target(cmd_ctx
);
1783 LOG_USER("requesting target halt and executing a soft reset");
1785 target
->type
->soft_reset_halt(target
);
1790 static int handle_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1793 enum target_reset_mode reset_mode
= RESET_RUN
;
1797 n
= Jim_Nvp_name2value_simple( nvp_reset_modes
, args
[0] );
1798 if( (n
->name
== NULL
) || (n
->value
== RESET_UNKNOWN
) ){
1799 return ERROR_COMMAND_SYNTAX_ERROR
;
1801 reset_mode
= n
->value
;
1804 /* reset *all* targets */
1805 return target_process_reset(cmd_ctx
, reset_mode
);
1809 static int handle_resume_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1812 target_t
*target
= get_current_target(cmd_ctx
);
1814 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1817 retval
= target_resume(target
, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1819 retval
= target_resume(target
, 0, strtoul(args
[0], NULL
, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1822 retval
= ERROR_COMMAND_SYNTAX_ERROR
;
1828 static int handle_step_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1830 target_t
*target
= get_current_target(cmd_ctx
);
1835 return target
->type
->step(target
, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1838 return target
->type
->step(target
, 0, strtoul(args
[0], NULL
, 0), 1); /* addr = args[0], handle breakpoints */
1843 static int handle_md_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1845 const int line_bytecnt
= 32;
1858 target_t
*target
= get_current_target(cmd_ctx
);
1864 count
= strtoul(args
[1], NULL
, 0);
1866 address
= strtoul(args
[0], NULL
, 0);
1871 size
= 4; line_modulo
= line_bytecnt
/ 4;
1874 size
= 2; line_modulo
= line_bytecnt
/ 2;
1877 size
= 1; line_modulo
= line_bytecnt
/ 1;
1883 buffer
= calloc(count
, size
);
1884 retval
= target
->type
->read_memory(target
, address
, size
, count
, buffer
);
1885 if (retval
== ERROR_OK
)
1889 for (i
= 0; i
< count
; i
++)
1891 if (i
%line_modulo
== 0)
1892 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "0x%8.8x: ", address
+ (i
*size
));
1897 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%8.8x ", target_buffer_get_u32(target
, &buffer
[i
*4]));
1900 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%4.4x ", target_buffer_get_u16(target
, &buffer
[i
*2]));
1903 output_len
+= snprintf(output
+ output_len
, 128 - output_len
, "%2.2x ", buffer
[i
*1]);
1907 if ((i
%line_modulo
== line_modulo
-1) || (i
== count
- 1))
1909 command_print(cmd_ctx
, output
);
1920 static int handle_mw_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1927 target_t
*target
= get_current_target(cmd_ctx
);
1930 if ((argc
< 2) || (argc
> 3))
1931 return ERROR_COMMAND_SYNTAX_ERROR
;
1933 address
= strtoul(args
[0], NULL
, 0);
1934 value
= strtoul(args
[1], NULL
, 0);
1936 count
= strtoul(args
[2], NULL
, 0);
1942 target_buffer_set_u32(target
, value_buf
, value
);
1946 target_buffer_set_u16(target
, value_buf
, value
);
1950 value_buf
[0] = value
;
1953 return ERROR_COMMAND_SYNTAX_ERROR
;
1955 for (i
=0; i
<count
; i
++)
1961 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 4, 1, value_buf
);
1964 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 2, 1, value_buf
);
1967 retval
= target
->type
->write_memory(target
, address
+ i
*wordsize
, 1, 1, value_buf
);
1974 if (retval
!=ERROR_OK
)
1984 static int handle_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1990 u32 max_address
=0xffffffff;
1992 int retval
, retvaltemp
;
1996 duration_t duration
;
1997 char *duration_text
;
1999 target_t
*target
= get_current_target(cmd_ctx
);
2001 if ((argc
< 1)||(argc
> 5))
2003 return ERROR_COMMAND_SYNTAX_ERROR
;
2006 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2009 image
.base_address_set
= 1;
2010 image
.base_address
= strtoul(args
[1], NULL
, 0);
2014 image
.base_address_set
= 0;
2018 image
.start_address_set
= 0;
2022 min_address
=strtoul(args
[3], NULL
, 0);
2026 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
2029 if (min_address
>max_address
)
2031 return ERROR_COMMAND_SYNTAX_ERROR
;
2034 duration_start_measure(&duration
);
2036 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
2043 for (i
= 0; i
< image
.num_sections
; i
++)
2045 buffer
= malloc(image
.sections
[i
].size
);
2048 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2052 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2061 /* DANGER!!! beware of unsigned comparision here!!! */
2063 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
2064 (image
.sections
[i
].base_address
<max_address
))
2066 if (image
.sections
[i
].base_address
<min_address
)
2068 /* clip addresses below */
2069 offset
+=min_address
-image
.sections
[i
].base_address
;
2073 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
2075 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
2078 if ((retval
= target_write_buffer(target
, image
.sections
[i
].base_address
+offset
, length
, buffer
+offset
)) != ERROR_OK
)
2083 image_size
+= length
;
2084 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
2090 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2092 image_close(&image
);
2096 if (retval
==ERROR_OK
)
2098 command_print(cmd_ctx
, "downloaded %u byte in %s", image_size
, duration_text
);
2100 free(duration_text
);
2102 image_close(&image
);
2108 static int handle_dump_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2115 int retval
=ERROR_OK
, retvaltemp
;
2117 duration_t duration
;
2118 char *duration_text
;
2120 target_t
*target
= get_current_target(cmd_ctx
);
2124 command_print(cmd_ctx
, "usage: dump_image <filename> <address> <size>");
2128 address
= strtoul(args
[1], NULL
, 0);
2129 size
= strtoul(args
[2], NULL
, 0);
2131 if ((address
& 3) || (size
& 3))
2133 command_print(cmd_ctx
, "only 32-bit aligned address and size are supported");
2137 if (fileio_open(&fileio
, args
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
2142 duration_start_measure(&duration
);
2147 u32 this_run_size
= (size
> 560) ? 560 : size
;
2149 retval
= target
->type
->read_memory(target
, address
, 4, this_run_size
/ 4, buffer
);
2150 if (retval
!= ERROR_OK
)
2155 retval
= fileio_write(&fileio
, this_run_size
, buffer
, &size_written
);
2156 if (retval
!= ERROR_OK
)
2161 size
-= this_run_size
;
2162 address
+= this_run_size
;
2165 if((retvaltemp
= fileio_close(&fileio
)) != ERROR_OK
)
2168 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2171 if (retval
==ERROR_OK
)
2173 command_print(cmd_ctx
, "dumped %"PRIi64
" byte in %s", fileio
.size
, duration_text
);
2175 free(duration_text
);
2180 static int handle_verify_image_command_internal(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, int verify
)
2186 int retval
, retvaltemp
;
2188 u32 mem_checksum
= 0;
2192 duration_t duration
;
2193 char *duration_text
;
2195 target_t
*target
= get_current_target(cmd_ctx
);
2199 return ERROR_COMMAND_SYNTAX_ERROR
;
2204 LOG_ERROR("no target selected");
2208 duration_start_measure(&duration
);
2212 image
.base_address_set
= 1;
2213 image
.base_address
= strtoul(args
[1], NULL
, 0);
2217 image
.base_address_set
= 0;
2218 image
.base_address
= 0x0;
2221 image
.start_address_set
= 0;
2223 if ((retval
=image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
)) != ERROR_OK
)
2230 for (i
= 0; i
< image
.num_sections
; i
++)
2232 buffer
= malloc(image
.sections
[i
].size
);
2235 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
2238 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
2246 /* calculate checksum of image */
2247 image_calculate_checksum( buffer
, buf_cnt
, &checksum
);
2249 retval
= target_checksum_memory(target
, image
.sections
[i
].base_address
, buf_cnt
, &mem_checksum
);
2250 if( retval
!= ERROR_OK
)
2256 if( checksum
!= mem_checksum
)
2258 /* failed crc checksum, fall back to a binary compare */
2261 command_print(cmd_ctx
, "checksum mismatch - attempting binary compare");
2263 data
= (u8
*)malloc(buf_cnt
);
2265 /* Can we use 32bit word accesses? */
2267 int count
= buf_cnt
;
2268 if ((count
% 4) == 0)
2273 retval
= target
->type
->read_memory(target
, image
.sections
[i
].base_address
, size
, count
, data
);
2274 if (retval
== ERROR_OK
)
2277 for (t
= 0; t
< buf_cnt
; t
++)
2279 if (data
[t
] != buffer
[t
])
2281 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
]);
2298 command_print(cmd_ctx
, "address 0x%08x length 0x%08x", image
.sections
[i
].base_address
, buf_cnt
);
2302 image_size
+= buf_cnt
;
2306 if((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
2308 image_close(&image
);
2312 if (retval
==ERROR_OK
)
2314 command_print(cmd_ctx
, "verified %u bytes in %s", image_size
, duration_text
);
2316 free(duration_text
);
2318 image_close(&image
);
2323 static int handle_verify_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2325 return handle_verify_image_command_internal(cmd_ctx
, cmd
, args
, argc
, 1);
2328 static int handle_test_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2330 return handle_verify_image_command_internal(cmd_ctx
, cmd
, args
, argc
, 0);
2333 static int handle_bp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2336 target_t
*target
= get_current_target(cmd_ctx
);
2340 breakpoint_t
*breakpoint
= target
->breakpoints
;
2344 if (breakpoint
->type
== BKPT_SOFT
)
2346 char* buf
= buf_to_str(breakpoint
->orig_instr
, breakpoint
->length
, 16);
2347 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
, buf
);
2352 command_print(cmd_ctx
, "0x%8.8x, 0x%x, %i", breakpoint
->address
, breakpoint
->length
, breakpoint
->set
);
2354 breakpoint
= breakpoint
->next
;
2362 length
= strtoul(args
[1], NULL
, 0);
2365 if (strcmp(args
[2], "hw") == 0)
2368 if ((retval
= breakpoint_add(target
, strtoul(args
[0], NULL
, 0), length
, hw
)) != ERROR_OK
)
2370 LOG_ERROR("Failure setting breakpoints");
2374 command_print(cmd_ctx
, "breakpoint added at address 0x%8.8x", strtoul(args
[0], NULL
, 0));
2379 command_print(cmd_ctx
, "usage: bp <address> <length> ['hw']");
2385 static int handle_rbp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2387 target_t
*target
= get_current_target(cmd_ctx
);
2390 breakpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2395 static int handle_wp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2397 target_t
*target
= get_current_target(cmd_ctx
);
2402 watchpoint_t
*watchpoint
= target
->watchpoints
;
2406 command_print(cmd_ctx
, "address: 0x%8.8x, len: 0x%8.8x, r/w/a: %i, value: 0x%8.8x, mask: 0x%8.8x", watchpoint
->address
, watchpoint
->length
, watchpoint
->rw
, watchpoint
->value
, watchpoint
->mask
);
2407 watchpoint
= watchpoint
->next
;
2412 enum watchpoint_rw type
= WPT_ACCESS
;
2413 u32 data_value
= 0x0;
2414 u32 data_mask
= 0xffffffff;
2430 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2436 data_value
= strtoul(args
[3], NULL
, 0);
2440 data_mask
= strtoul(args
[4], NULL
, 0);
2443 if ((retval
= watchpoint_add(target
, strtoul(args
[0], NULL
, 0),
2444 strtoul(args
[1], NULL
, 0), type
, data_value
, data_mask
)) != ERROR_OK
)
2446 LOG_ERROR("Failure setting breakpoints");
2451 command_print(cmd_ctx
, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2457 static int handle_rwp_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2459 target_t
*target
= get_current_target(cmd_ctx
);
2462 watchpoint_remove(target
, strtoul(args
[0], NULL
, 0));
2467 static int handle_virt2phys_command(command_context_t
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2470 target_t
*target
= get_current_target(cmd_ctx
);
2476 return ERROR_COMMAND_SYNTAX_ERROR
;
2478 va
= strtoul(args
[0], NULL
, 0);
2480 retval
= target
->type
->virt2phys(target
, va
, &pa
);
2481 if (retval
== ERROR_OK
)
2483 command_print(cmd_ctx
, "Physical address 0x%08x", pa
);
2487 /* lower levels will have logged a detailed error which is
2488 * forwarded to telnet/GDB session.
2494 static void writeData(FILE *f
, const void *data
, size_t len
)
2496 size_t written
= fwrite(data
, len
, 1, f
);
2498 LOG_ERROR("failed to write %zu bytes: %s", len
, strerror(errno
));
2501 static void writeLong(FILE *f
, int l
)
2506 char c
=(l
>>(i
*8))&0xff;
2507 writeData(f
, &c
, 1);
2512 static void writeString(FILE *f
, char *s
)
2514 writeData(f
, s
, strlen(s
));
2517 /* Dump a gmon.out histogram file. */
2518 static void writeGmon(u32
*samples
, u32 sampleNum
, char *filename
)
2521 FILE *f
=fopen(filename
, "w");
2524 writeString(f
, "gmon");
2525 writeLong(f
, 0x00000001); /* Version */
2526 writeLong(f
, 0); /* padding */
2527 writeLong(f
, 0); /* padding */
2528 writeLong(f
, 0); /* padding */
2530 u8 zero
= 0; /* GMON_TAG_TIME_HIST */
2531 writeData(f
, &zero
, 1);
2533 /* figure out bucket size */
2536 for (i
=0; i
<sampleNum
; i
++)
2548 int addressSpace
=(max
-min
+1);
2550 static const u32 maxBuckets
= 256 * 1024; /* maximum buckets. */
2551 u32 length
= addressSpace
;
2552 if (length
> maxBuckets
)
2556 int *buckets
=malloc(sizeof(int)*length
);
2562 memset(buckets
, 0, sizeof(int)*length
);
2563 for (i
=0; i
<sampleNum
;i
++)
2565 u32 address
=samples
[i
];
2566 long long a
=address
-min
;
2567 long long b
=length
-1;
2568 long long c
=addressSpace
-1;
2569 int index
=(a
*b
)/c
; /* danger!!!! int32 overflows */
2573 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2574 writeLong(f
, min
); /* low_pc */
2575 writeLong(f
, max
); /* high_pc */
2576 writeLong(f
, length
); /* # of samples */
2577 writeLong(f
, 64000000); /* 64MHz */
2578 writeString(f
, "seconds");
2579 for (i
=0; i
<(15-strlen("seconds")); i
++)
2580 writeData(f
, &zero
, 1);
2581 writeString(f
, "s");
2583 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2585 char *data
=malloc(2*length
);
2588 for (i
=0; i
<length
;i
++)
2597 data
[i
*2+1]=(val
>>8)&0xff;
2600 writeData(f
, data
, length
* 2);
2610 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2611 static int handle_profile_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2613 target_t
*target
= get_current_target(cmd_ctx
);
2614 struct timeval timeout
, now
;
2616 gettimeofday(&timeout
, NULL
);
2619 return ERROR_COMMAND_SYNTAX_ERROR
;
2622 timeval_add_time(&timeout
, strtoul(args
[0], &end
, 0), 0);
2628 command_print(cmd_ctx
, "Starting profiling. Halting and resuming the target as often as we can...");
2630 static const int maxSample
=10000;
2631 u32
*samples
=malloc(sizeof(u32
)*maxSample
);
2636 int retval
=ERROR_OK
;
2637 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2638 reg_t
*reg
= register_get_by_name(target
->reg_cache
, "pc", 1);
2642 target_poll(target
);
2643 if (target
->state
== TARGET_HALTED
)
2645 u32 t
=*((u32
*)reg
->value
);
2646 samples
[numSamples
++]=t
;
2647 retval
= target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2648 target_poll(target
);
2649 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2650 } else if (target
->state
== TARGET_RUNNING
)
2652 /* We want to quickly sample the PC. */
2653 if((retval
= target_halt(target
)) != ERROR_OK
)
2660 command_print(cmd_ctx
, "Target not halted or running");
2664 if (retval
!=ERROR_OK
)
2669 gettimeofday(&now
, NULL
);
2670 if ((numSamples
>=maxSample
) || ((now
.tv_sec
>= timeout
.tv_sec
) && (now
.tv_usec
>= timeout
.tv_usec
)))
2672 command_print(cmd_ctx
, "Profiling completed. %d samples.", numSamples
);
2673 if((retval
= target_poll(target
)) != ERROR_OK
)
2678 if (target
->state
== TARGET_HALTED
)
2680 target_resume(target
, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2682 if((retval
= target_poll(target
)) != ERROR_OK
)
2687 writeGmon(samples
, numSamples
, args
[1]);
2688 command_print(cmd_ctx
, "Wrote %s", args
[1]);
2697 static int new_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32 val
)
2700 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2703 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2707 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2708 valObjPtr
= Jim_NewIntObj(interp
, val
);
2709 if (!nameObjPtr
|| !valObjPtr
)
2715 Jim_IncrRefCount(nameObjPtr
);
2716 Jim_IncrRefCount(valObjPtr
);
2717 result
= Jim_SetVariable(interp
, nameObjPtr
, valObjPtr
);
2718 Jim_DecrRefCount(interp
, nameObjPtr
);
2719 Jim_DecrRefCount(interp
, valObjPtr
);
2721 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2725 static int jim_mem2array(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2727 command_context_t
*context
;
2730 context
= Jim_GetAssocData(interp
, "context");
2731 if (context
== NULL
)
2733 LOG_ERROR("mem2array: no command context");
2736 target
= get_current_target(context
);
2739 LOG_ERROR("mem2array: no current target");
2743 return target_mem2array(interp
, target
, argc
,argv
);
2746 static int target_mem2array(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2754 const char *varname
;
2759 /* argv[1] = name of array to receive the data
2760 * argv[2] = desired width
2761 * argv[3] = memory address
2762 * argv[4] = count of times to read
2765 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2768 varname
= Jim_GetString(argv
[1], &len
);
2769 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2771 e
= Jim_GetLong(interp
, argv
[2], &l
);
2777 e
= Jim_GetLong(interp
, argv
[3], &l
);
2782 e
= Jim_GetLong(interp
, argv
[4], &l
);
2798 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2799 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2803 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2804 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: zero width read?", NULL
);
2807 if ((addr
+ (len
* width
)) < addr
) {
2808 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2809 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: addr + len - wraps to zero?", NULL
);
2812 /* absurd transfer size? */
2814 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2815 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: absurd > 64K item request", NULL
);
2820 ((width
== 2) && ((addr
& 1) == 0)) ||
2821 ((width
== 4) && ((addr
& 3) == 0))) {
2825 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2826 sprintf(buf
, "mem2array address: 0x%08x is not aligned for %d byte reads", addr
, width
);
2827 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
2838 /* Slurp... in buffer size chunks */
2840 count
= len
; /* in objects.. */
2841 if (count
> (sizeof(buffer
)/width
)) {
2842 count
= (sizeof(buffer
)/width
);
2845 retval
= target
->type
->read_memory( target
, addr
, width
, count
, buffer
);
2846 if (retval
!= ERROR_OK
) {
2848 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
2849 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2850 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "mem2array: cannot read memory", NULL
);
2854 v
= 0; /* shut up gcc */
2855 for (i
= 0 ;i
< count
;i
++, n
++) {
2858 v
= target_buffer_get_u32(target
, &buffer
[i
*width
]);
2861 v
= target_buffer_get_u16(target
, &buffer
[i
*width
]);
2864 v
= buffer
[i
] & 0x0ff;
2867 new_int_array_element(interp
, varname
, n
, v
);
2873 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2878 static int get_int_array_element(Jim_Interp
* interp
, const char *varname
, int idx
, u32
*val
)
2881 Jim_Obj
*nameObjPtr
, *valObjPtr
;
2885 namebuf
= alloc_printf("%s(%d)", varname
, idx
);
2889 nameObjPtr
= Jim_NewStringObj(interp
, namebuf
, -1);
2896 Jim_IncrRefCount(nameObjPtr
);
2897 valObjPtr
= Jim_GetVariable(interp
, nameObjPtr
, JIM_ERRMSG
);
2898 Jim_DecrRefCount(interp
, nameObjPtr
);
2900 if (valObjPtr
== NULL
)
2903 result
= Jim_GetLong(interp
, valObjPtr
, &l
);
2904 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2909 static int jim_array2mem(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2911 command_context_t
*context
;
2914 context
= Jim_GetAssocData(interp
, "context");
2915 if (context
== NULL
){
2916 LOG_ERROR("array2mem: no command context");
2919 target
= get_current_target(context
);
2920 if (target
== NULL
){
2921 LOG_ERROR("array2mem: no current target");
2925 return target_array2mem( interp
,target
, argc
, argv
);
2928 static int target_array2mem(Jim_Interp
*interp
, target_t
*target
, int argc
, Jim_Obj
*const *argv
)
2936 const char *varname
;
2941 /* argv[1] = name of array to get the data
2942 * argv[2] = desired width
2943 * argv[3] = memory address
2944 * argv[4] = count to write
2947 Jim_WrongNumArgs(interp
, 1, argv
, "varname width addr nelems");
2950 varname
= Jim_GetString(argv
[1], &len
);
2951 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2953 e
= Jim_GetLong(interp
, argv
[2], &l
);
2959 e
= Jim_GetLong(interp
, argv
[3], &l
);
2964 e
= Jim_GetLong(interp
, argv
[4], &l
);
2980 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2981 Jim_AppendStrings( interp
, Jim_GetResult(interp
), "Invalid width param, must be 8/16/32", NULL
);
2985 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2986 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: zero width read?", NULL
);
2989 if ((addr
+ (len
* width
)) < addr
) {
2990 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2991 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: addr + len - wraps to zero?", NULL
);
2994 /* absurd transfer size? */
2996 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2997 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: absurd > 64K item request", NULL
);
3002 ((width
== 2) && ((addr
& 1) == 0)) ||
3003 ((width
== 4) && ((addr
& 3) == 0))) {
3007 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3008 sprintf(buf
, "array2mem address: 0x%08x is not aligned for %d byte reads", addr
, width
);
3009 Jim_AppendStrings(interp
, Jim_GetResult(interp
), buf
, NULL
);
3020 /* Slurp... in buffer size chunks */
3022 count
= len
; /* in objects.. */
3023 if (count
> (sizeof(buffer
)/width
)) {
3024 count
= (sizeof(buffer
)/width
);
3027 v
= 0; /* shut up gcc */
3028 for (i
= 0 ;i
< count
;i
++, n
++) {
3029 get_int_array_element(interp
, varname
, n
, &v
);
3032 target_buffer_set_u32(target
, &buffer
[i
*width
], v
);
3035 target_buffer_set_u16(target
, &buffer
[i
*width
], v
);
3038 buffer
[i
] = v
& 0x0ff;
3044 retval
= target
->type
->write_memory(target
, addr
, width
, count
, buffer
);
3045 if (retval
!= ERROR_OK
) {
3047 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr
, width
, count
);
3048 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3049 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "array2mem: cannot read memory", NULL
);
3055 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
3060 void target_all_handle_event( enum target_event e
)
3064 LOG_DEBUG( "**all*targets: event: %d, %s",
3066 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3068 target
= all_targets
;
3070 target_handle_event( target
, e
);
3071 target
= target
->next
;
3075 void target_handle_event( target_t
*target
, enum target_event e
)
3077 target_event_action_t
*teap
;
3080 teap
= target
->event_action
;
3084 if( teap
->event
== e
){
3086 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3087 target
->target_number
,
3091 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
,
3092 Jim_GetString( teap
->body
, NULL
) );
3093 if (Jim_EvalObj( interp
, teap
->body
)!=JIM_OK
)
3095 Jim_PrintErrorMessage(interp
);
3101 LOG_DEBUG( "event: %d %s - no action",
3103 Jim_Nvp_value2name_simple( nvp_target_event
, e
)->name
);
3107 enum target_cfg_param
{
3110 TCFG_WORK_AREA_VIRT
,
3111 TCFG_WORK_AREA_PHYS
,
3112 TCFG_WORK_AREA_SIZE
,
3113 TCFG_WORK_AREA_BACKUP
,
3116 TCFG_CHAIN_POSITION
,
3119 static Jim_Nvp nvp_config_opts
[] = {
3120 { .name
= "-type", .value
= TCFG_TYPE
},
3121 { .name
= "-event", .value
= TCFG_EVENT
},
3122 { .name
= "-work-area-virt", .value
= TCFG_WORK_AREA_VIRT
},
3123 { .name
= "-work-area-phys", .value
= TCFG_WORK_AREA_PHYS
},
3124 { .name
= "-work-area-size", .value
= TCFG_WORK_AREA_SIZE
},
3125 { .name
= "-work-area-backup", .value
= TCFG_WORK_AREA_BACKUP
},
3126 { .name
= "-endian" , .value
= TCFG_ENDIAN
},
3127 { .name
= "-variant", .value
= TCFG_VARIANT
},
3128 { .name
= "-chain-position", .value
= TCFG_CHAIN_POSITION
},
3130 { .name
= NULL
, .value
= -1 }
3133 static int target_configure( Jim_GetOptInfo
*goi
, target_t
*target
)
3141 /* parse config or cget options ... */
3142 while( goi
->argc
> 0 ){
3143 Jim_SetEmptyResult( goi
->interp
);
3144 /* Jim_GetOpt_Debug( goi ); */
3146 if( target
->type
->target_jim_configure
){
3147 /* target defines a configure function */
3148 /* target gets first dibs on parameters */
3149 e
= (*(target
->type
->target_jim_configure
))( target
, goi
);
3158 /* otherwise we 'continue' below */
3160 e
= Jim_GetOpt_Nvp( goi
, nvp_config_opts
, &n
);
3162 Jim_GetOpt_NvpUnknown( goi
, nvp_config_opts
, 0 );
3168 if( goi
->isconfigure
){
3169 Jim_SetResult_sprintf( goi
->interp
, "not setable: %s", n
->name
);
3173 if( goi
->argc
!= 0 ){
3174 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
3178 Jim_SetResultString( goi
->interp
, target
->type
->name
, -1 );
3182 if( goi
->argc
== 0 ){
3183 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ...");
3187 e
= Jim_GetOpt_Nvp( goi
, nvp_target_event
, &n
);
3189 Jim_GetOpt_NvpUnknown( goi
, nvp_target_event
, 1 );
3193 if( goi
->isconfigure
){
3194 if( goi
->argc
!= 1 ){
3195 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
3199 if( goi
->argc
!= 0 ){
3200 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
3206 target_event_action_t
*teap
;
3208 teap
= target
->event_action
;
3209 /* replace existing? */
3211 if( teap
->event
== (enum target_event
)n
->value
){
3217 if( goi
->isconfigure
){
3220 teap
= calloc( 1, sizeof(*teap
) );
3222 teap
->event
= n
->value
;
3223 Jim_GetOpt_Obj( goi
, &o
);
3225 Jim_DecrRefCount( interp
, teap
->body
);
3227 teap
->body
= Jim_DuplicateObj( goi
->interp
, o
);
3230 * Tcl/TK - "tk events" have a nice feature.
3231 * See the "BIND" command.
3232 * We should support that here.
3233 * You can specify %X and %Y in the event code.
3234 * The idea is: %T - target name.
3235 * The idea is: %N - target number
3236 * The idea is: %E - event name.
3238 Jim_IncrRefCount( teap
->body
);
3240 /* add to head of event list */
3241 teap
->next
= target
->event_action
;
3242 target
->event_action
= teap
;
3243 Jim_SetEmptyResult(goi
->interp
);
3247 Jim_SetEmptyResult( goi
->interp
);
3249 Jim_SetResult( goi
->interp
, Jim_DuplicateObj( goi
->interp
, teap
->body
) );
3256 case TCFG_WORK_AREA_VIRT
:
3257 if( goi
->isconfigure
){
3258 target_free_all_working_areas(target
);
3259 e
= Jim_GetOpt_Wide( goi
, &w
);
3263 target
->working_area_virt
= w
;
3265 if( goi
->argc
!= 0 ){
3269 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_virt
) );
3273 case TCFG_WORK_AREA_PHYS
:
3274 if( goi
->isconfigure
){
3275 target_free_all_working_areas(target
);
3276 e
= Jim_GetOpt_Wide( goi
, &w
);
3280 target
->working_area_phys
= w
;
3282 if( goi
->argc
!= 0 ){
3286 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_phys
) );
3290 case TCFG_WORK_AREA_SIZE
:
3291 if( goi
->isconfigure
){
3292 target_free_all_working_areas(target
);
3293 e
= Jim_GetOpt_Wide( goi
, &w
);
3297 target
->working_area_size
= w
;
3299 if( goi
->argc
!= 0 ){
3303 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3307 case TCFG_WORK_AREA_BACKUP
:
3308 if( goi
->isconfigure
){
3309 target_free_all_working_areas(target
);
3310 e
= Jim_GetOpt_Wide( goi
, &w
);
3314 /* make this exactly 1 or 0 */
3315 target
->backup_working_area
= (!!w
);
3317 if( goi
->argc
!= 0 ){
3321 Jim_SetResult( interp
, Jim_NewIntObj( goi
->interp
, target
->working_area_size
) );
3322 /* loop for more e*/
3326 if( goi
->isconfigure
){
3327 e
= Jim_GetOpt_Nvp( goi
, nvp_target_endian
, &n
);
3329 Jim_GetOpt_NvpUnknown( goi
, nvp_target_endian
, 1 );
3332 target
->endianness
= n
->value
;
3334 if( goi
->argc
!= 0 ){
3338 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3339 if( n
->name
== NULL
){
3340 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3341 n
= Jim_Nvp_value2name_simple( nvp_target_endian
, target
->endianness
);
3343 Jim_SetResultString( goi
->interp
, n
->name
, -1 );
3348 if( goi
->isconfigure
){
3349 if( goi
->argc
< 1 ){
3350 Jim_SetResult_sprintf( goi
->interp
,
3355 if( target
->variant
){
3356 free((void *)(target
->variant
));
3358 e
= Jim_GetOpt_String( goi
, &cp
, NULL
);
3359 target
->variant
= strdup(cp
);
3361 if( goi
->argc
!= 0 ){
3365 Jim_SetResultString( goi
->interp
, target
->variant
,-1 );
3368 case TCFG_CHAIN_POSITION
:
3369 if( goi
->isconfigure
){
3372 target_free_all_working_areas(target
);
3373 e
= Jim_GetOpt_Obj( goi
, &o
);
3377 tap
= jtag_TapByJimObj( goi
->interp
, o
);
3381 /* make this exactly 1 or 0 */
3384 if( goi
->argc
!= 0 ){
3388 Jim_SetResultString( interp
, target
->tap
->dotted_name
, -1 );
3389 /* loop for more e*/
3392 } /* while( goi->argc ) */
3395 /* done - we return */
3399 /** this is the 'tcl' handler for the target specific command */
3400 static int tcl_target_func( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3408 struct command_context_s
*cmd_ctx
;
3415 TS_CMD_MWW
, TS_CMD_MWH
, TS_CMD_MWB
,
3416 TS_CMD_MDW
, TS_CMD_MDH
, TS_CMD_MDB
,
3417 TS_CMD_MRW
, TS_CMD_MRH
, TS_CMD_MRB
,
3418 TS_CMD_MEM2ARRAY
, TS_CMD_ARRAY2MEM
,
3426 TS_CMD_INVOKE_EVENT
,
3429 static const Jim_Nvp target_options
[] = {
3430 { .name
= "configure", .value
= TS_CMD_CONFIGURE
},
3431 { .name
= "cget", .value
= TS_CMD_CGET
},
3432 { .name
= "mww", .value
= TS_CMD_MWW
},
3433 { .name
= "mwh", .value
= TS_CMD_MWH
},
3434 { .name
= "mwb", .value
= TS_CMD_MWB
},
3435 { .name
= "mdw", .value
= TS_CMD_MDW
},
3436 { .name
= "mdh", .value
= TS_CMD_MDH
},
3437 { .name
= "mdb", .value
= TS_CMD_MDB
},
3438 { .name
= "mem2array", .value
= TS_CMD_MEM2ARRAY
},
3439 { .name
= "array2mem", .value
= TS_CMD_ARRAY2MEM
},
3440 { .name
= "eventlist", .value
= TS_CMD_EVENTLIST
},
3441 { .name
= "curstate", .value
= TS_CMD_CURSTATE
},
3443 { .name
= "arp_examine", .value
= TS_CMD_EXAMINE
},
3444 { .name
= "arp_poll", .value
= TS_CMD_POLL
},
3445 { .name
= "arp_reset", .value
= TS_CMD_RESET
},
3446 { .name
= "arp_halt", .value
= TS_CMD_HALT
},
3447 { .name
= "arp_waitstate", .value
= TS_CMD_WAITSTATE
},
3448 { .name
= "invoke-event", .value
= TS_CMD_INVOKE_EVENT
},
3450 { .name
= NULL
, .value
= -1 },
3453 /* go past the "command" */
3454 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3456 target
= Jim_CmdPrivData( goi
.interp
);
3457 cmd_ctx
= Jim_GetAssocData(goi
.interp
, "context");
3459 /* commands here are in an NVP table */
3460 e
= Jim_GetOpt_Nvp( &goi
, target_options
, &n
);
3462 Jim_GetOpt_NvpUnknown( &goi
, target_options
, 0 );
3465 /* Assume blank result */
3466 Jim_SetEmptyResult( goi
.interp
);
3469 case TS_CMD_CONFIGURE
:
3471 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "missing: -option VALUE ...");
3474 goi
.isconfigure
= 1;
3475 return target_configure( &goi
, target
);
3477 // some things take params
3479 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "missing: ?-option?");
3482 goi
.isconfigure
= 0;
3483 return target_configure( &goi
, target
);
3491 * argv[3] = optional count.
3494 if( (goi
.argc
== 3) || (goi
.argc
== 4) ){
3498 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR DATA [COUNT]", n
->name
);
3502 e
= Jim_GetOpt_Wide( &goi
, &a
);
3507 e
= Jim_GetOpt_Wide( &goi
, &b
);
3512 e
= Jim_GetOpt_Wide( &goi
, &c
);
3522 target_buffer_set_u32( target
, target_buf
, b
);
3526 target_buffer_set_u16( target
, target_buf
, b
);
3530 target_buffer_set_u8( target
, target_buf
, b
);
3534 for( x
= 0 ; x
< c
; x
++ ){
3535 e
= target
->type
->write_memory( target
, a
, b
, 1, target_buf
);
3536 if( e
!= ERROR_OK
){
3537 Jim_SetResult_sprintf( interp
, "Error writing @ 0x%08x: %d\n", (int)(a
), e
);
3550 /* argv[0] = command
3552 * argv[2] = optional count
3554 if( (goi
.argc
== 2) || (goi
.argc
== 3) ){
3555 Jim_SetResult_sprintf( goi
.interp
, "expected: %s ADDR [COUNT]", n
->name
);
3558 e
= Jim_GetOpt_Wide( &goi
, &a
);
3563 e
= Jim_GetOpt_Wide( &goi
, &c
);
3570 b
= 1; /* shut up gcc */
3583 /* convert to "bytes" */
3585 /* count is now in 'BYTES' */
3591 e
= target
->type
->read_memory( target
, a
, b
, y
/ b
, target_buf
);
3592 if( e
!= ERROR_OK
){
3593 Jim_SetResult_sprintf( interp
, "error reading target @ 0x%08lx", (int)(a
) );
3597 Jim_fprintf( interp
, interp
->cookie_stdout
, "0x%08x ", (int)(a
) );
3600 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 4 ){
3601 z
= target_buffer_get_u32( target
, &(target_buf
[ x
* 4 ]) );
3602 Jim_fprintf( interp
, interp
->cookie_stdout
, "%08x ", (int)(z
) );
3604 for( ; (x
< 16) ; x
+= 4 ){
3605 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3609 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 2 ){
3610 z
= target_buffer_get_u16( target
, &(target_buf
[ x
* 2 ]) );
3611 Jim_fprintf( interp
, interp
->cookie_stdout
, "%04x ", (int)(z
) );
3613 for( ; (x
< 16) ; x
+= 2 ){
3614 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3619 for( x
= 0 ; (x
< 16) && (x
< y
) ; x
+= 1 ){
3620 z
= target_buffer_get_u8( target
, &(target_buf
[ x
* 4 ]) );
3621 Jim_fprintf( interp
, interp
->cookie_stdout
, "%02x ", (int)(z
) );
3623 for( ; (x
< 16) ; x
+= 1 ){
3624 Jim_fprintf( interp
, interp
->cookie_stdout
, " " );
3628 /* ascii-ify the bytes */
3629 for( x
= 0 ; x
< y
; x
++ ){
3630 if( (target_buf
[x
] >= 0x20) &&
3631 (target_buf
[x
] <= 0x7e) ){
3635 target_buf
[x
] = '.';
3640 target_buf
[x
] = ' ';
3645 /* print - with a newline */
3646 Jim_fprintf( interp
, interp
->cookie_stdout
, "%s\n", target_buf
);
3652 case TS_CMD_MEM2ARRAY
:
3653 return target_mem2array( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3655 case TS_CMD_ARRAY2MEM
:
3656 return target_array2mem( goi
.interp
, target
, goi
.argc
, goi
.argv
);
3658 case TS_CMD_EXAMINE
:
3660 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3663 e
= target
->type
->examine( target
);
3664 if( e
!= ERROR_OK
){
3665 Jim_SetResult_sprintf( interp
, "examine-fails: %d", e
);
3671 Jim_WrongNumArgs( goi
.interp
, 2, argv
, "[no parameters]");
3674 if( !(target
->type
->examined
) ){
3675 e
= ERROR_TARGET_NOT_EXAMINED
;
3677 e
= target
->type
->poll( target
);
3679 if( e
!= ERROR_OK
){
3680 Jim_SetResult_sprintf( interp
, "poll-fails: %d", e
);
3687 if( goi
.argc
!= 2 ){
3688 Jim_WrongNumArgs( interp
, 2, argv
, "t|f|assert|deassert BOOL");
3691 e
= Jim_GetOpt_Nvp( &goi
, nvp_assert
, &n
);
3693 Jim_GetOpt_NvpUnknown( &goi
, nvp_assert
, 1 );
3696 /* the halt or not param */
3697 e
= Jim_GetOpt_Wide( &goi
, &a
);
3701 /* determine if we should halt or not. */
3702 target
->reset_halt
= !!a
;
3703 /* When this happens - all workareas are invalid. */
3704 target_free_all_working_areas_restore(target
, 0);
3707 if( n
->value
== NVP_ASSERT
){
3708 target
->type
->assert_reset( target
);
3710 target
->type
->deassert_reset( target
);
3715 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "halt [no parameters]");
3718 target
->type
->halt( target
);
3720 case TS_CMD_WAITSTATE
:
3721 /* params: <name> statename timeoutmsecs */
3722 if( goi
.argc
!= 2 ){
3723 Jim_SetResult_sprintf( goi
.interp
, "%s STATENAME TIMEOUTMSECS", n
->name
);
3726 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_state
, &n
);
3728 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_state
,1 );
3731 e
= Jim_GetOpt_Wide( &goi
, &a
);
3735 e
= target_wait_state( target
, n
->value
, a
);
3736 if( e
!= ERROR_OK
){
3737 Jim_SetResult_sprintf( goi
.interp
,
3738 "target: %s wait %s fails (%d) %s",
3741 e
, target_strerror_safe(e
) );
3746 case TS_CMD_EVENTLIST
:
3747 /* List for human, Events defined for this target.
3748 * scripts/programs should use 'name cget -event NAME'
3751 target_event_action_t
*teap
;
3752 teap
= target
->event_action
;
3753 command_print( cmd_ctx
, "Event actions for target (%d) %s\n",
3754 target
->target_number
,
3756 command_print( cmd_ctx
, "%-25s | Body", "Event");
3757 command_print( cmd_ctx
, "------------------------- | ----------------------------------------");
3759 command_print( cmd_ctx
,
3761 Jim_Nvp_value2name_simple( nvp_target_event
, teap
->event
)->name
,
3762 Jim_GetString( teap
->body
, NULL
) );
3765 command_print( cmd_ctx
, "***END***");
3768 case TS_CMD_CURSTATE
:
3769 if( goi
.argc
!= 0 ){
3770 Jim_WrongNumArgs( goi
.interp
, 0, argv
, "[no parameters]");
3773 Jim_SetResultString( goi
.interp
,
3774 Jim_Nvp_value2name_simple(nvp_target_state
,target
->state
)->name
,-1);
3776 case TS_CMD_INVOKE_EVENT
:
3777 if( goi
.argc
!= 1 ){
3778 Jim_SetResult_sprintf( goi
.interp
, "%s ?EVENTNAME?",n
->name
);
3781 e
= Jim_GetOpt_Nvp( &goi
, nvp_target_event
, &n
);
3783 Jim_GetOpt_NvpUnknown( &goi
, nvp_target_event
, 1 );
3786 target_handle_event( target
, n
->value
);
3792 static int target_create( Jim_GetOptInfo
*goi
)
3801 struct command_context_s
*cmd_ctx
;
3803 cmd_ctx
= Jim_GetAssocData(goi
->interp
, "context");
3804 if( goi
->argc
< 3 ){
3805 Jim_WrongNumArgs( goi
->interp
, 1, goi
->argv
, "?name? ?type? ..options...");
3810 Jim_GetOpt_Obj( goi
, &new_cmd
);
3811 /* does this command exist? */
3812 cmd
= Jim_GetCommand( goi
->interp
, new_cmd
, JIM_ERRMSG
);
3814 cp
= Jim_GetString( new_cmd
, NULL
);
3815 Jim_SetResult_sprintf(goi
->interp
, "Command/target: %s Exists", cp
);
3820 e
= Jim_GetOpt_String( goi
, &cp2
, NULL
);
3822 /* now does target type exist */
3823 for( x
= 0 ; target_types
[x
] ; x
++ ){
3824 if( 0 == strcmp( cp
, target_types
[x
]->name
) ){
3829 if( target_types
[x
] == NULL
){
3830 Jim_SetResult_sprintf( goi
->interp
, "Unknown target type %s, try one of ", cp
);
3831 for( x
= 0 ; target_types
[x
] ; x
++ ){
3832 if( target_types
[x
+1] ){
3833 Jim_AppendStrings( goi
->interp
,
3834 Jim_GetResult(goi
->interp
),
3835 target_types
[x
]->name
,
3838 Jim_AppendStrings( goi
->interp
,
3839 Jim_GetResult(goi
->interp
),
3841 target_types
[x
]->name
,NULL
);
3848 target
= calloc(1,sizeof(target_t
));
3849 /* set target number */
3850 target
->target_number
= new_target_number();
3852 /* allocate memory for each unique target type */
3853 target
->type
= (target_type_t
*)calloc(1,sizeof(target_type_t
));
3855 memcpy( target
->type
, target_types
[x
], sizeof(target_type_t
));
3857 /* will be set by "-endian" */
3858 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3860 target
->working_area
= 0x0;
3861 target
->working_area_size
= 0x0;
3862 target
->working_areas
= NULL
;
3863 target
->backup_working_area
= 0;
3865 target
->state
= TARGET_UNKNOWN
;
3866 target
->debug_reason
= DBG_REASON_UNDEFINED
;
3867 target
->reg_cache
= NULL
;
3868 target
->breakpoints
= NULL
;
3869 target
->watchpoints
= NULL
;
3870 target
->next
= NULL
;
3871 target
->arch_info
= NULL
;
3873 target
->display
= 1;
3875 /* initialize trace information */
3876 target
->trace_info
= malloc(sizeof(trace_t
));
3877 target
->trace_info
->num_trace_points
= 0;
3878 target
->trace_info
->trace_points_size
= 0;
3879 target
->trace_info
->trace_points
= NULL
;
3880 target
->trace_info
->trace_history_size
= 0;
3881 target
->trace_info
->trace_history
= NULL
;
3882 target
->trace_info
->trace_history_pos
= 0;
3883 target
->trace_info
->trace_history_overflowed
= 0;
3885 target
->dbgmsg
= NULL
;
3886 target
->dbg_msg_enabled
= 0;
3888 target
->endianness
= TARGET_ENDIAN_UNKNOWN
;
3890 /* Do the rest as "configure" options */
3891 goi
->isconfigure
= 1;
3892 e
= target_configure( goi
, target
);
3894 if (target
->tap
== NULL
)
3896 Jim_SetResultString( interp
, "-chain-position required when creating target", -1);
3901 free( target
->type
);
3906 if( target
->endianness
== TARGET_ENDIAN_UNKNOWN
){
3907 /* default endian to little if not specified */
3908 target
->endianness
= TARGET_LITTLE_ENDIAN
;
3911 /* incase variant is not set */
3912 if (!target
->variant
)
3913 target
->variant
= strdup("");
3915 /* create the target specific commands */
3916 if( target
->type
->register_commands
){
3917 (*(target
->type
->register_commands
))( cmd_ctx
);
3919 if( target
->type
->target_create
){
3920 (*(target
->type
->target_create
))( target
, goi
->interp
);
3923 /* append to end of list */
3926 tpp
= &(all_targets
);
3928 tpp
= &( (*tpp
)->next
);
3933 cp
= Jim_GetString( new_cmd
, NULL
);
3934 target
->cmd_name
= strdup(cp
);
3936 /* now - create the new target name command */
3937 e
= Jim_CreateCommand( goi
->interp
,
3940 tcl_target_func
, /* C function */
3941 target
, /* private data */
3942 NULL
); /* no del proc */
3947 static int jim_target( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
3951 struct command_context_s
*cmd_ctx
;
3955 /* TG = target generic */
3963 const char *target_cmds
[] = {
3964 "create", "types", "names", "current", "number",
3966 NULL
/* terminate */
3969 LOG_DEBUG("Target command params:");
3970 LOG_DEBUG("%s", Jim_Debug_ArgvString(interp
, argc
, argv
));
3972 cmd_ctx
= Jim_GetAssocData( interp
, "context" );
3974 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
3976 if( goi
.argc
== 0 ){
3977 Jim_WrongNumArgs(interp
, 1, argv
, "missing: command ...");
3981 /* Jim_GetOpt_Debug( &goi ); */
3982 r
= Jim_GetOpt_Enum( &goi
, target_cmds
, &x
);
3989 Jim_Panic(goi
.interp
,"Why am I here?");
3991 case TG_CMD_CURRENT
:
3992 if( goi
.argc
!= 0 ){
3993 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters");
3996 Jim_SetResultString( goi
.interp
, get_current_target( cmd_ctx
)->cmd_name
, -1 );
3999 if( goi
.argc
!= 0 ){
4000 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4003 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4004 for( x
= 0 ; target_types
[x
] ; x
++ ){
4005 Jim_ListAppendElement( goi
.interp
,
4006 Jim_GetResult(goi
.interp
),
4007 Jim_NewStringObj( goi
.interp
, target_types
[x
]->name
, -1 ) );
4011 if( goi
.argc
!= 0 ){
4012 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
, "Too many parameters" );
4015 Jim_SetResult( goi
.interp
, Jim_NewListObj( goi
.interp
, NULL
, 0 ) );
4016 target
= all_targets
;
4018 Jim_ListAppendElement( goi
.interp
,
4019 Jim_GetResult(goi
.interp
),
4020 Jim_NewStringObj( goi
.interp
, target
->cmd_name
, -1 ) );
4021 target
= target
->next
;
4026 Jim_WrongNumArgs( goi
.interp
, goi
.argc
, goi
.argv
, "?name ... config options ...");
4029 return target_create( &goi
);
4032 if( goi
.argc
!= 1 ){
4033 Jim_SetResult_sprintf( goi
.interp
, "expected: target number ?NUMBER?");
4036 e
= Jim_GetOpt_Wide( &goi
, &w
);
4042 t
= get_target_by_num(w
);
4044 Jim_SetResult_sprintf( goi
.interp
,"Target: number %d does not exist", (int)(w
));
4047 Jim_SetResultString( goi
.interp
, t
->cmd_name
, -1 );
4051 if( goi
.argc
!= 0 ){
4052 Jim_WrongNumArgs( goi
.interp
, 0, goi
.argv
, "<no parameters>");
4055 Jim_SetResult( goi
.interp
,
4056 Jim_NewIntObj( goi
.interp
, max_target_number()));
4072 static int fastload_num
;
4073 static struct FastLoad
*fastload
;
4075 static void free_fastload(void)
4080 for (i
=0; i
<fastload_num
; i
++)
4082 if (fastload
[i
].data
)
4083 free(fastload
[i
].data
);
4093 static int handle_fast_load_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4099 u32 max_address
=0xffffffff;
4105 duration_t duration
;
4106 char *duration_text
;
4108 if ((argc
< 1)||(argc
> 5))
4110 return ERROR_COMMAND_SYNTAX_ERROR
;
4113 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
4116 image
.base_address_set
= 1;
4117 image
.base_address
= strtoul(args
[1], NULL
, 0);
4121 image
.base_address_set
= 0;
4125 image
.start_address_set
= 0;
4129 min_address
=strtoul(args
[3], NULL
, 0);
4133 max_address
=strtoul(args
[4], NULL
, 0)+min_address
;
4136 if (min_address
>max_address
)
4138 return ERROR_COMMAND_SYNTAX_ERROR
;
4141 duration_start_measure(&duration
);
4143 if (image_open(&image
, args
[0], (argc
>= 3) ? args
[2] : NULL
) != ERROR_OK
)
4150 fastload_num
=image
.num_sections
;
4151 fastload
=(struct FastLoad
*)malloc(sizeof(struct FastLoad
)*image
.num_sections
);
4154 image_close(&image
);
4157 memset(fastload
, 0, sizeof(struct FastLoad
)*image
.num_sections
);
4158 for (i
= 0; i
< image
.num_sections
; i
++)
4160 buffer
= malloc(image
.sections
[i
].size
);
4163 command_print(cmd_ctx
, "error allocating buffer for section (%d bytes)", image
.sections
[i
].size
);
4167 if ((retval
= image_read_section(&image
, i
, 0x0, image
.sections
[i
].size
, buffer
, &buf_cnt
)) != ERROR_OK
)
4177 /* DANGER!!! beware of unsigned comparision here!!! */
4179 if ((image
.sections
[i
].base_address
+buf_cnt
>=min_address
)&&
4180 (image
.sections
[i
].base_address
<max_address
))
4182 if (image
.sections
[i
].base_address
<min_address
)
4184 /* clip addresses below */
4185 offset
+=min_address
-image
.sections
[i
].base_address
;
4189 if (image
.sections
[i
].base_address
+buf_cnt
>max_address
)
4191 length
-=(image
.sections
[i
].base_address
+buf_cnt
)-max_address
;
4194 fastload
[i
].address
=image
.sections
[i
].base_address
+offset
;
4195 fastload
[i
].data
=malloc(length
);
4196 if (fastload
[i
].data
==NULL
)
4201 memcpy(fastload
[i
].data
, buffer
+offset
, length
);
4202 fastload
[i
].length
=length
;
4204 image_size
+= length
;
4205 command_print(cmd_ctx
, "%u byte written at address 0x%8.8x", length
, image
.sections
[i
].base_address
+offset
);
4211 duration_stop_measure(&duration
, &duration_text
);
4212 if (retval
==ERROR_OK
)
4214 command_print(cmd_ctx
, "Loaded %u bytes in %s", image_size
, duration_text
);
4215 command_print(cmd_ctx
, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4217 free(duration_text
);
4219 image_close(&image
);
4221 if (retval
!=ERROR_OK
)
4229 static int handle_fast_load_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
4232 return ERROR_COMMAND_SYNTAX_ERROR
;
4235 LOG_ERROR("No image in memory");
4239 int ms
=timeval_ms();
4241 int retval
=ERROR_OK
;
4242 for (i
=0; i
<fastload_num
;i
++)
4244 target_t
*target
= get_current_target(cmd_ctx
);
4245 command_print(cmd_ctx
, "Write to 0x%08x, length 0x%08x", fastload
[i
].address
, fastload
[i
].length
);
4246 if (retval
==ERROR_OK
)
4248 retval
= target_write_buffer(target
, fastload
[i
].address
, fastload
[i
].length
, fastload
[i
].data
);
4250 size
+=fastload
[i
].length
;
4252 int after
=timeval_ms();
4253 command_print(cmd_ctx
, "Loaded image %f kBytes/s", (float)(size
/1024.0)/((float)(after
-ms
)/1000.0));
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)