git-svn-id: svn://svn.berlios.de/openocd/trunk@565 b42882b7-edfa-0310-969c-e2dbd0fdcd60tags/v0.1.0
@@ -1482,6 +1482,9 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) | |||
int jtag_interface_init(struct command_context_s *cmd_ctx) | |||
{ | |||
if (jtag) | |||
return ERROR_OK; | |||
if (!jtag_interface) | |||
{ | |||
/* nothing was previously specified by "interface" command */ | |||
@@ -1511,11 +1514,12 @@ static int jtag_init_inner(struct command_context_s *cmd_ctx) | |||
{ | |||
int validate_tries = 0; | |||
jtag_device_t *device; | |||
int retval; | |||
LOG_DEBUG("-"); | |||
if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK) | |||
return ERROR_JTAG_INIT_FAILED; | |||
if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK) | |||
return retval; | |||
device = jtag_devices; | |||
jtag_ir_scan_size = 0; | |||
@@ -1528,7 +1532,8 @@ static int jtag_init_inner(struct command_context_s *cmd_ctx) | |||
} | |||
jtag_add_tlr(); | |||
jtag_execute_queue(); | |||
if ((retval=jtag_execute_queue())==ERROR_OK) | |||
return retval; | |||
/* examine chain first, as this could discover the real chain layout */ | |||
if (jtag_examine_chain() != ERROR_OK) | |||
@@ -1930,7 +1935,7 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char | |||
return ERROR_COMMAND_SYNTAX_ERROR; | |||
} | |||
if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK) | |||
if (jtag_interface_init(cmd_ctx) != ERROR_OK) | |||
return ERROR_JTAG_INIT_FAILED; | |||
jtag_add_reset(trst, srst); | |||
@@ -241,6 +241,10 @@ enum reset_types | |||
extern enum reset_types jtag_reset_config; | |||
/* initialize interface upon startup. A successful no-op | |||
* upon subsequent invocations | |||
*/ | |||
extern int jtag_interface_init(struct command_context_s *cmd_ctx); | |||
/* initialize JTAG chain using only a TLR reset. If init fails, | |||
* try reset + init. | |||
*/ | |||
@@ -690,7 +690,7 @@ int gdb_new_connection(connection_t *connection) | |||
* instantaneous and thus avoiding annoying timeout problems during | |||
* connect. | |||
*/ | |||
gdb_service->target->type->halt(gdb_service->target); | |||
target_halt(gdb_service->target); | |||
/* remove the initial ACK from the incoming buffer */ | |||
if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK) | |||
@@ -1231,7 +1231,7 @@ void gdb_step_continue_packet(connection_t *connection, target_t *target, char * | |||
if (packet[0] == 'c') | |||
{ | |||
LOG_DEBUG("continue"); | |||
target->type->resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */ | |||
target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */ | |||
} | |||
else if (packet[0] == 's') | |||
{ | |||
@@ -1755,7 +1755,7 @@ int gdb_detach(connection_t *connection, target_t *target) | |||
switch( detach_mode ) | |||
{ | |||
case GDB_DETACH_RESUME: | |||
target->type->resume(target, 1, 0, 1, 0); | |||
target_resume(target, 1, 0, 1, 0); | |||
break; | |||
case GDB_DETACH_RESET: | |||
@@ -1763,7 +1763,7 @@ int gdb_detach(connection_t *connection, target_t *target) | |||
break; | |||
case GDB_DETACH_HALT: | |||
target->type->halt(target); | |||
target_halt(target); | |||
break; | |||
case GDB_DETACH_NOTHING: | |||
@@ -1904,7 +1904,7 @@ int gdb_input_inner(connection_t *connection) | |||
{ | |||
if (target->state == TARGET_RUNNING) | |||
{ | |||
target->type->halt(target); | |||
target_halt(target); | |||
gdb_con->ctrl_c = 0; | |||
} | |||
} | |||
@@ -368,7 +368,7 @@ int arm720t_soft_reset_halt(struct target_s *target) | |||
int i; | |||
reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT]; | |||
target->type->halt(target); | |||
target_halt(target); | |||
for (i=0; i<10; i++) | |||
{ | |||
@@ -755,14 +755,6 @@ int arm7_9_assert_reset(target_t *target) | |||
if ((target->reset_mode == RESET_HALT) || (target->reset_mode == RESET_INIT)) | |||
{ | |||
reg_t *dbg_ctrl = &arm7_9->eice_cache->reg_list[EICE_DBG_CTRL]; | |||
/* program EmbeddedICE Debug Control Register to deassert DBGRQ | |||
* i.e. resume. | |||
*/ | |||
buf_set_u32(dbg_ctrl->value, EICE_DBG_CONTROL_DBGRQ, 1, 0); | |||
embeddedice_store_reg(dbg_ctrl); | |||
/* | |||
* Some targets do not support communication while SRST is asserted. We need to | |||
* set up the reset vector catch here. | |||
@@ -867,7 +859,7 @@ int arm7_9_soft_reset_halt(struct target_s *target) | |||
int i; | |||
int retval; | |||
if ((retval=target->type->halt(target))!=ERROR_OK) | |||
if ((retval=target_halt(target))!=ERROR_OK) | |||
return retval; | |||
for (i=0; i<10; i++) | |||
@@ -2176,11 +2168,11 @@ int arm7_9_bulk_write_memory(target_t *target, u32 address, u32 count, u8 *buffe | |||
} | |||
} | |||
target->type->halt(target); | |||
target_halt(target); | |||
for (i=0; i<100; i++) | |||
{ | |||
target->type->poll(target); | |||
target_poll(target); | |||
if (target->state == TARGET_HALTED) | |||
break; | |||
usleep(1000); /* sleep 1ms */ | |||
@@ -624,7 +624,7 @@ int arm920t_soft_reset_halt(struct target_s *target) | |||
reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT]; | |||
int i; | |||
target->type->halt(target); | |||
target_halt(target); | |||
for (i=0; i<10; i++) | |||
{ | |||
@@ -580,7 +580,7 @@ int arm926ejs_soft_reset_halt(struct target_s *target) | |||
reg_t *dbg_stat = &arm7_9->eice_cache->reg_list[EICE_DBG_STAT]; | |||
int i; | |||
target->type->halt(target); | |||
target_halt(target); | |||
for (i=0; i<10; i++) | |||
{ | |||
@@ -574,22 +574,22 @@ int armv4_5_run_algorithm(struct target_s *target, int num_mem_params, mem_param | |||
return ERROR_TARGET_FAILURE; | |||
} | |||
target->type->resume(target, 0, entry_point, 1, 1); | |||
target->type->poll(target); | |||
target_resume(target, 0, entry_point, 1, 1); | |||
target_poll(target); | |||
while (target->state != TARGET_HALTED) | |||
{ | |||
usleep(10000); | |||
target->type->poll(target); | |||
target_poll(target); | |||
if ((timeout_ms -= 10) <= 0) | |||
{ | |||
LOG_ERROR("timeout waiting for algorithm to complete, trying to halt target"); | |||
target->type->halt(target); | |||
target_halt(target); | |||
timeout_ms = 1000; | |||
while (target->state != TARGET_HALTED) | |||
{ | |||
usleep(10000); | |||
target->type->poll(target); | |||
target_poll(target); | |||
if ((timeout_ms -= 10) <= 0) | |||
{ | |||
LOG_ERROR("target didn't reenter debug state, exiting"); | |||
@@ -349,22 +349,22 @@ int armv7m_run_algorithm(struct target_s *target, int num_mem_params, mem_param_ | |||
/* This code relies on the target specific resume() and poll()->debug_entry() | |||
sequence to write register values to the processor and the read them back */ | |||
target->type->resume(target, 0, entry_point, 1, 1); | |||
target->type->poll(target); | |||
target_resume(target, 0, entry_point, 1, 1); | |||
target_poll(target); | |||
while (target->state != TARGET_HALTED) | |||
{ | |||
usleep(5000); | |||
target->type->poll(target); | |||
target_poll(target); | |||
if ((timeout_ms -= 5) <= 0) | |||
{ | |||
LOG_ERROR("timeout waiting for algorithm to complete, trying to halt target"); | |||
target->type->halt(target); | |||
target_halt(target); | |||
timeout_ms = 1000; | |||
while (target->state != TARGET_HALTED) | |||
{ | |||
usleep(10000); | |||
target->type->poll(target); | |||
target_poll(target); | |||
if ((timeout_ms -= 10) <= 0) | |||
{ | |||
LOG_ERROR("target didn't reenter debug state, exiting"); | |||
@@ -547,9 +547,9 @@ int feroceon_bulk_write_memory(target_t *target, u32 address, u32 count, u8 *buf | |||
buffer += 4; | |||
} | |||
target->type->halt(target); | |||
target_halt(target); | |||
while (target->state != TARGET_HALTED) | |||
target->type->poll(target); | |||
target_poll(target); | |||
/* restore target state */ | |||
for (i = 0; i <= 5; i++) | |||
@@ -248,11 +248,45 @@ int target_run_and_halt_handler(void *priv) | |||
{ | |||
target_t *target = priv; | |||
target->type->halt(target); | |||
target_halt(target); | |||
return ERROR_OK; | |||
} | |||
int target_poll(struct target_s *target) | |||
{ | |||
/* We can't poll until after examine */ | |||
if (!target->type->examined) | |||
{ | |||
/* Fail silently lest we pollute the log */ | |||
return ERROR_FAIL; | |||
} | |||
return target->type->poll(target); | |||
} | |||
int target_halt(struct target_s *target) | |||
{ | |||
/* We can't poll until after examine */ | |||
if (!target->type->examined) | |||
{ | |||
LOG_ERROR("Target not examined yet"); | |||
return ERROR_FAIL; | |||
} | |||
return target->type->halt(target); | |||
} | |||
int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution) | |||
{ | |||
/* We can't poll until after examine */ | |||
if (!target->type->examined) | |||
{ | |||
LOG_ERROR("Target not examined yet"); | |||
return ERROR_FAIL; | |||
} | |||
return target->type->resume(target, current, address, handle_breakpoints, debug_execution); | |||
} | |||
int target_process_reset(struct command_context_s *cmd_ctx) | |||
{ | |||
int retval = ERROR_OK; | |||
@@ -325,10 +359,10 @@ int target_process_reset(struct command_context_s *cmd_ctx) | |||
target_register_event_callback(target_init_handler, cmd_ctx); | |||
break; | |||
case RESET_HALT: | |||
target->type->halt(target); | |||
target_halt(target); | |||
break; | |||
case RESET_INIT: | |||
target->type->halt(target); | |||
target_halt(target); | |||
target_register_event_callback(target_init_handler, cmd_ctx); | |||
break; | |||
default: | |||
@@ -371,7 +405,7 @@ int target_process_reset(struct command_context_s *cmd_ctx) | |||
while (target) | |||
{ | |||
LOG_DEBUG("Polling target"); | |||
target->type->poll(target); | |||
target_poll(target); | |||
if ((target->reset_mode == RESET_RUN_AND_INIT) || | |||
(target->reset_mode == RESET_RUN_AND_HALT) || | |||
(target->reset_mode == RESET_HALT) || | |||
@@ -1414,19 +1448,14 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch | |||
/* process target state changes */ | |||
int handle_target(void *priv) | |||
{ | |||
int retval; | |||
target_t *target = targets; | |||
while (target) | |||
{ | |||
/* only poll if target isn't already halted */ | |||
if (target->state != TARGET_HALTED) | |||
if (target_continous_poll) | |||
{ | |||
if (target_continous_poll) | |||
if ((retval = target->type->poll(target)) != ERROR_OK) | |||
{ | |||
LOG_ERROR("couldn't poll target(%d). It's due for a reset.", retval); | |||
} | |||
/* polling may fail silently until the target has been examined */ | |||
target_poll(target); | |||
} | |||
target = target->next; | |||
@@ -1565,7 +1594,7 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg | |||
if (argc == 0) | |||
{ | |||
target->type->poll(target); | |||
target_poll(target); | |||
target_arch_state(target); | |||
} | |||
else | |||
@@ -1610,7 +1639,7 @@ int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char | |||
static void target_process_events(struct command_context_s *cmd_ctx) | |||
{ | |||
target_t *target = get_current_target(cmd_ctx); | |||
target->type->poll(target); | |||
target_poll(target); | |||
target_call_timer_callbacks_now(); | |||
} | |||
@@ -1625,7 +1654,7 @@ static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_ | |||
target_t *target = get_current_target(cmd_ctx); | |||
for (;;) | |||
{ | |||
if ((retval=target->type->poll(target))!=ERROR_OK) | |||
if ((retval=target_poll(target))!=ERROR_OK) | |||
return retval; | |||
target_call_timer_callbacks_now(); | |||
if (target->state == state) | |||
@@ -1656,7 +1685,7 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg | |||
LOG_DEBUG("-"); | |||
if ((retval = target->type->halt(target)) != ERROR_OK) | |||
if ((retval = target_halt(target)) != ERROR_OK) | |||
{ | |||
return retval; | |||
} | |||
@@ -1733,9 +1762,9 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a | |||
target_t *target = get_current_target(cmd_ctx); | |||
if (argc == 0) | |||
retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */ | |||
retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */ | |||
else if (argc == 1) | |||
retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */ | |||
retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */ | |||
else | |||
{ | |||
return ERROR_COMMAND_SYNTAX_ERROR; | |||
@@ -2485,18 +2514,18 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char ** | |||
for (;;) | |||
{ | |||
target->type->poll(target); | |||
target_poll(target); | |||
if (target->state == TARGET_HALTED) | |||
{ | |||
u32 t=*((u32 *)reg->value); | |||
samples[numSamples++]=t; | |||
retval = target->type->resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ | |||
target->type->poll(target); | |||
retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ | |||
target_poll(target); | |||
usleep(10*1000); // sleep 10ms, i.e. <100 samples/second. | |||
} else if (target->state == TARGET_RUNNING) | |||
{ | |||
// We want to quickly sample the PC. | |||
target->type->halt(target); | |||
target_halt(target); | |||
} else | |||
{ | |||
command_print(cmd_ctx, "Target not halted or running"); | |||
@@ -2512,12 +2541,12 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char ** | |||
if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) | |||
{ | |||
command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples); | |||
target->type->poll(target); | |||
target_poll(target); | |||
if (target->state == TARGET_HALTED) | |||
{ | |||
target->type->resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ | |||
target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ | |||
} | |||
target->type->poll(target); | |||
target_poll(target); | |||
writeGmon(samples, numSamples, args[1]); | |||
command_print(cmd_ctx, "Wrote %s", args[1]); | |||
break; | |||
@@ -256,6 +256,9 @@ extern int target_process_reset(struct command_context_s *cmd_ctx); | |||
extern int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv); | |||
extern int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv); | |||
extern int target_poll(target_t *target); | |||
extern int target_resume(target_t *target, int current, u32 address, int handle_breakpoints, int debug_execution); | |||
extern int target_halt(target_t *target); | |||
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 | |||