X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.h;h=6ce8fee9fccca1ca51f6566e9e2b10cece11d39f;hp=46aaa7aea5efaf93b8564017c3530f951f5e5306;hb=d3f0549f08d8aac36143bca9e7f7e1308383b7c2;hpb=68b97e4b5c40a70b42dc2a970f1b90b9a3e9f13d diff --git a/src/target/target.h b/src/target/target.h index 46aaa7aea5..6ce8fee9fc 100644 --- a/src/target/target.h +++ b/src/target/target.h @@ -33,7 +33,16 @@ struct reg_s; struct command_context_s; - +/* +TARGET_UNKNOWN = 0: we don't know anything about the target yet +TARGET_RUNNING = 1: the target is executing user code +TARGET_HALTED = 2: the target is not executing code, and ready to talk to the +debugger. on an xscale it means that the debug handler is executing +TARGET_RESET = 3: the target is being held in reset (only a temporary state, +not sure how this is used with all the recent changes) +TARGET_DEBUG_RUNNING = 4: the target is running, but it is executing code on +behalf of the debugger (e.g. algorithm for flashing) +*/ enum target_state { TARGET_UNKNOWN = 0, @@ -69,7 +78,8 @@ enum target_debug_reason DBG_REASON_WATCHPOINT = 2, DBG_REASON_WPTANDBKPT = 3, DBG_REASON_SINGLESTEP = 4, - DBG_REASON_NOTHALTED = 5 + DBG_REASON_NOTHALTED = 5, + DBG_REASON_UNDEFINED = 6 }; extern char *target_debug_reason_strings[]; @@ -98,25 +108,42 @@ typedef struct target_type_s char *name; /* poll current target status */ - enum target_state (*poll)(struct target_s *target); - /* architecture specific status reply */ - int (*arch_state)(struct target_s *target, char *buf, int buf_size); + int (*poll)(struct target_s *target); + /* Invoked only from target_arch_state(). + * Issue USER() w/architecture specific status. */ + int (*arch_state)(struct target_s *target); /* target request support */ int (*target_request_data)(struct target_s *target, u32 size, u8 *buffer); - /* target execution control */ + /* halt will log a warning, but return ERROR_OK if the target is already halted. */ int (*halt)(struct target_s *target); int (*resume)(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution); int (*step)(struct target_s *target, int current, u32 address, int handle_breakpoints); - /* target reset control */ + /* target reset control. assert reset can be invoked when OpenOCD and + * the target is out of sync. + * + * A typical example is that the target was power cycled while OpenOCD + * thought the target was halted or running. + * + * assert_reset() can therefore make no assumptions whatsoever about the + * state of the target + * + */ int (*assert_reset)(struct target_s *target); int (*deassert_reset)(struct target_s *target); int (*soft_reset_halt)(struct target_s *target); - int (*prepare_reset_halt)(struct target_s *target); - /* target register access for gdb */ + /* target register access for gdb. + * + * Danger! this function will succeed even if the target is running + * and return a register list with dummy values. + * + * The reason is that GDB connection will fail without a valid register + * list, however it is after GDB is connected that monitor commands can + * be run to properly initialize the target + */ int (*get_gdb_reg_list)(struct target_s *target, struct reg_s **reg_list[], int *reg_list_size); /* target memory access @@ -147,6 +174,9 @@ typedef struct target_type_s int (*init_target)(struct command_context_s *cmd_ctx, struct target_s *target); int (*quit)(void); + int (*virt2phys)(struct target_s *target, u32 address, u32 *physical); + int (*mmu)(struct target_s *target, int *enabled); + } target_type_t; typedef struct target_s @@ -158,7 +188,11 @@ typedef struct target_s char *post_halt_script; /* script file to execute after the target halted */ char *pre_resume_script; /* script file to execute before the target resumed */ char *gdb_program_script; /* script file to execute before programming vis gdb */ - u32 working_area; /* working area (initialized RAM) */ + u32 working_area; /* working area (initialized RAM). Evaluated + upon first allocation from virtual/physical address. + */ + u32 working_area_virt; /* virtual address */ + u32 working_area_phys; /* physical address */ u32 working_area_size; /* size in bytes */ u32 backup_working_area; /* whether the content of the working area has to be preserved */ struct working_area_s *working_areas;/* list of allocated working areas */ @@ -205,6 +239,7 @@ typedef struct target_timer_callback_s extern int target_register_commands(struct command_context_s *cmd_ctx); extern int target_register_user_commands(struct command_context_s *cmd_ctx); extern int target_init(struct command_context_s *cmd_ctx); +extern int target_init_reset(struct command_context_s *cmd_ctx); extern int handle_target(void *priv); extern int target_process_reset(struct command_context_s *cmd_ctx); @@ -212,9 +247,16 @@ extern int target_register_event_callback(int (*callback)(struct target_s *targe extern int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv); extern int target_call_event_callbacks(target_t *target, enum target_event event); +/* The period is very approximate, the callback can happen much more often + * or much more rarely than specified + */ extern int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv); extern int target_unregister_timer_callback(int (*callback)(void *priv), void *priv); extern int target_call_timer_callbacks(); +/* invoke this to ensure that e.g. polling timer callbacks happen before + * a syncrhonous command completes. + */ +extern int target_call_timer_callbacks_now(); extern target_t* get_current_target(struct command_context_s *cmd_ctx); extern int get_num_by_target(target_t *query_target); @@ -224,9 +266,23 @@ extern int target_write_buffer(struct target_s *target, u32 address, u32 size, u extern int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer); extern int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc); +/* DANGER!!!!! + * + * if "area" passed in to target_alloc_working_area() points to a memory + * location that goes out of scope (e.g. a pointer on the stack), then + * the caller of target_alloc_working_area() is responsible for invoking + * target_free_working_area() before "area" goes out of scope. + * + * target_free_all_working_areas() will NULL out the "area" pointer + * upon resuming or resetting the CPU. + * + */ extern int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area); extern int target_free_working_area(struct target_s *target, working_area_t *area); +extern int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore); extern int target_free_all_working_areas(struct target_s *target); +extern int target_free_all_working_areas_restore(struct target_s *target, int restore); + extern target_t *targets; @@ -245,10 +301,12 @@ int target_write_u32(struct target_s *target, u32 address, u32 value); int target_write_u16(struct target_s *target, u32 address, u16 value); int target_write_u8(struct target_s *target, u32 address, u8 value); +/* Issues USER() statements with target state information */ +int target_arch_state(struct target_s *target); + #define ERROR_TARGET_INVALID (-300) #define ERROR_TARGET_INIT_FAILED (-301) #define ERROR_TARGET_TIMEOUT (-302) -#define ERROR_TARGET_ALREADY_HALTED (-303) #define ERROR_TARGET_NOT_HALTED (-304) #define ERROR_TARGET_FAILURE (-305) #define ERROR_TARGET_UNALIGNED_ACCESS (-306)