int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
-
int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
return target;
}
-static void execute_script(struct command_context_s *cmd_ctx, char *reset_script)
-{
- if (reset_script==NULL)
- return;
- FILE *script;
- script = open_file_from_path(reset_script, "r");
- if (!script)
- {
- LOG_ERROR("couldn't open script file %s", reset_script);
- return;
- }
-
- LOG_INFO("executing script '%s'", reset_script);
- command_run_file(cmd_ctx, script, COMMAND_EXEC);
- fclose(script);
-}
-
/* Process target initialization, when target entered debug out of reset
* the handler is unregistered at the end of this function, so it's only called once
*/
if (event == TARGET_EVENT_HALTED)
{
target_unregister_event_callback(target_init_handler, priv);
-
- execute_script(cmd_ctx, target->reset_script);
-
+ target_invoke_script(cmd_ctx, target, "post_reset");
jtag_execute_queue();
}
int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
{
+ int retval;
+ int timeout_ms = 5000;
+
/* 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);
+
+ if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
+ return retval;
+
+ /* only check for resume event if normal resume */
+ if (!debug_execution)
+ {
+ /* wait for target to exit halted mode - not debug resume*/
+ target_poll(target);
+
+ while (target->state != TARGET_RUNNING)
+ {
+ usleep(10000);
+ target_poll(target);
+ if ((timeout_ms -= 10) <= 0)
+ {
+ LOG_ERROR("timeout waiting for target resume");
+ return ERROR_TARGET_TIMEOUT;
+ }
+ }
+ }
+
+ return retval;
}
-
int target_process_reset(struct command_context_s *cmd_ctx)
{
int retval = ERROR_OK;
target = targets;
while (target)
{
- execute_script(cmd_ctx, target->pre_reset_script);
+ target_invoke_script(cmd_ctx, target, "pre_reset");
target = target->next;
}
target = target->next;
}
target_unregister_event_callback(target_init_handler, cmd_ctx);
-
jtag->speed(jtag_speed_post_reset);
return target_call_timer_callbacks(0);
}
-
int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
{
working_area_t *c = target->working_areas;
{
register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
- register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
+ register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG,
+ "target_script <target#> <event=reset/pre_reset/post_halt/pre_resume/gdb_program_config> <script_file>");
register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, "<target> <run time ms>");
register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
*last_target_p = malloc(sizeof(target_t));
- (*last_target_p)->type = target_types[i];
+ /* allocate memory for each unique target type */
+ (*last_target_p)->type = (target_type_t*)malloc(sizeof(target_type_t));
+ *((*last_target_p)->type) = *target_types[i];
if (strcmp(args[1], "big") == 0)
(*last_target_p)->endianness = TARGET_BIG_ENDIAN;
}
(*last_target_p)->run_and_halt_time = 1000; /* default 1s */
- (*last_target_p)->reset_script = NULL;
- (*last_target_p)->pre_reset_script = NULL;
- (*last_target_p)->post_halt_script = NULL;
- (*last_target_p)->pre_resume_script = NULL;
- (*last_target_p)->gdb_program_script = NULL;
-
(*last_target_p)->working_area = 0x0;
(*last_target_p)->working_area_size = 0x0;
(*last_target_p)->working_areas = NULL;
return ERROR_OK;
}
-/* usage: target_script <target#> <event> <script_file> */
+int target_invoke_script(struct command_context_s *cmd_ctx, target_t *target, char *name)
+{
+ return command_run_linef(cmd_ctx, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
+ name, get_num_by_target(target),
+ name, get_num_by_target(target));
+}
+
int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
target_t *target = NULL;
return ERROR_COMMAND_SYNTAX_ERROR;
}
- if ((strcmp(args[1], "reset") == 0)||(strcmp(args[1], "post_reset") == 0))
- {
- if (target->reset_script)
- free(target->reset_script);
- target->reset_script = strdup(args[2]);
- }
- else if (strcmp(args[1], "pre_reset") == 0)
- {
- if (target->pre_reset_script)
- free(target->pre_reset_script);
- target->pre_reset_script = strdup(args[2]);
- }
- else if (strcmp(args[1], "post_halt") == 0)
- {
- if (target->post_halt_script)
- free(target->post_halt_script);
- target->post_halt_script = strdup(args[2]);
- }
- else if (strcmp(args[1], "pre_resume") == 0)
+ const char *event=args[1];
+ if (strcmp("reset", event)==0)
{
- if (target->pre_resume_script)
- free(target->pre_resume_script);
- target->pre_resume_script = strdup(args[2]);
- }
- else if (strcmp(args[1], "gdb_program_config") == 0)
- {
- if (target->gdb_program_script)
- free(target->gdb_program_script);
- target->gdb_program_script = strdup(args[2]);
- }
- else
- {
- LOG_ERROR("unknown event type: '%s", args[1]);
- return ERROR_COMMAND_SYNTAX_ERROR;
+ /* synonymous */
+ event="post_reset";
}
+
+ /* Define a tcl procedure which we'll invoke upon some event */
+ command_run_linef(cmd_ctx,
+ "proc target_%s_%d {} {"
+ "openocd {script %s} ; return \"\""
+ "}",
+ event,
+ get_num_by_target(target),
+ args[2]);
return ERROR_OK;
}
return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
}
-static void target_process_events(struct command_context_s *cmd_ctx)
-{
- target_t *target = get_current_target(cmd_ctx);
- target_poll(target);
- target_call_timer_callbacks_now();
-}
-
static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
{
int retval;
return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
}
-
int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
target_t *target = get_current_target(cmd_ctx);
int retval;
target_t *target = get_current_target(cmd_ctx);
+ target_invoke_script(cmd_ctx, target, "pre_resume");
+
if (argc == 0)
retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
else if (argc == 1)
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
-
- target_process_events(cmd_ctx);
return retval;
}
output_len = 0;
}
}
- } else
- {
- LOG_ERROR("Failure examining memory");
}
free(buffer);
- return ERROR_OK;
+ return retval;
}
int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
value = strtoul(args[1], NULL, 0);
if (argc == 3)
count = strtoul(args[2], NULL, 0);
-
-
+
switch (cmd[2])
{
case 'w':
return ERROR_OK;
}
-
Code Review / openocd.git / blobdiff