- added synchronous wait/resume patch. Thanks Øyvind Harboe

- updated docs for halt and wait_halt and resume commands

git-svn-id: svn://svn.berlios.de/openocd/trunk@285 b42882b7-edfa-0310-969c-e2dbd0fdcd60

doc/openocd.texi

@@ -651,14 +651,23 @@ Poll the target for its current state. If the target is in debug mode, architect
 specific information about the current state are printed. An optional parameter
 allows continuous polling to be enabled and disabled.
 
-@item @b{halt}
+@item @b{halt} [@option{ms}]
 @cindex halt
-Send a halt request to the target. The debugger signals the debug request,
+Send a halt request to the target and waits for it to halt for [@option{ms}].
-and waits for the target to enter debug mode.
+Default [@option{ms}] is 5 seconds if no arg given.
+Optional arg @option{ms} is a timeout in milliseconds. Using 0 as the [@option{ms}]
+will stop openocd from waiting.
+
+@item @b{wait_halt} [@option{ms}]
+@cindex wait_halt
+Wait for the target to enter debug mode. Optional [@option{ms}] is
+a timeout in milliseconds. Default [@option{ms}] is 5 seconds if no
+arg given.
 
 @item @b{resume} [@var{address}]
 @cindex resume
 Resume the target at its current code position, or at an optional address.
+Openocd will wait 5 seconds for the target to resume.
 
 @item @b{step} [@var{address}]
 @cindex step

src/target/target.c

@@ -370,6 +370,9 @@ int target_process_reset(struct command_context_s *cmd_ctx)
 	done:
 	
 	
+	/* We want any events to be processed before the prompt */
+	target_call_timer_callbacks();
+	
 	return retval;
 }
 
@@ -1391,6 +1394,8 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
 	return ERROR_OK;
 }
 
+static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
+
 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	target_t *target = get_current_target(cmd_ctx);
@@ -1428,38 +1433,46 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 
 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-	target_t *target = get_current_target(cmd_ctx);
+	int ms = 5000;
-	struct timeval timeout, now;
 	
-	gettimeofday(&timeout, NULL);
+	if (argc > 0)
-	if (!argc)
+	{
-		timeval_add_time(&timeout, 5, 0);
-	else {
 		char *end;
 
-		timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
+		ms = strtoul(args[0], &end, 0) * 1000;
-		if (*end) {
+		if (*end)
-			command_print(cmd_ctx, "usage: wait_halt [seconds]");
+		{
+			command_print(cmd_ctx, "usage: %s [seconds]", cmd);
 			return ERROR_OK;
 		}
 	}
 
-	command_print(cmd_ctx, "waiting for target halted...");
+	return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms); 
+}
 
-	while(target->type->poll(target))
+static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
+{
+	struct timeval timeout, now;
+	
+	gettimeofday(&timeout, NULL);
+	timeval_add_time(&timeout, 0, ms * 1000);
+	command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
+	
+	target_t *target = get_current_target(cmd_ctx);
+	while (target->type->poll(target))
 	{
-		if (target->state == TARGET_HALTED)
+		target_call_timer_callbacks();
+		if (target->state == state)
 		{
-			command_print(cmd_ctx, "target halted");
+			command_print(cmd_ctx, "target %s", target_state_strings[state]);
 			break;
 		}
-		target_call_timer_callbacks();
 		
 		gettimeofday(&now, NULL);
-		if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
+		if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
 		{
-			command_print(cmd_ctx, "timed out while waiting for target halt");
+			command_print(cmd_ctx, "timed out while waiting for target %s", target_state_strings[state]);
-			ERROR("timed out while waiting for target halt");
+			ERROR("timed out while waiting for target %s", target_state_strings[state]);
 			break;
 		}
 	}
@@ -1492,8 +1505,7 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 		}
 	}
 	
-	return ERROR_OK;
+	return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
-
 }
 
 /* what to do on daemon startup */
@@ -1622,7 +1634,7 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 		}
 	}
 
-	return ERROR_OK;
+	return wait_state(cmd_ctx, cmd, TARGET_RUNNING, 5000);
 }
 
 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
@@ -1835,11 +1847,12 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
 	for (i = 0; i < image.num_sections; i++)
 	{
 		buffer = malloc(image.sections[i].size);
-		if (buffer==NULL)
+		if (buffer == NULL)
 		{
 			command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
 			break;
 		}
+		
 		if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
 		{
 			ERROR("image_read_section failed with error code: %i", retval);