X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=61fac56b23ae336021800bf834eae9e53c1c85b7;hp=fc821f8f14e0b1caa9528d4cac5ea4d63909ccde;hb=4febcd8313cf46bea03bd5eacb3f287f19eb2961;hpb=db3d66f951428dfea526303850eb27b1dc092a55

diff --git a/src/target/target.c b/src/target/target.c
index fc821f8f14..61fac56b23 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -49,6 +49,7 @@
 
 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_daemon_startup_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);
@@ -74,6 +75,7 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
 
 /* targets
  */
@@ -83,8 +85,10 @@ extern target_type_t arm9tdmi_target;
 extern target_type_t arm920t_target;
 extern target_type_t arm966e_target;
 extern target_type_t arm926ejs_target;
+extern target_type_t feroceon_target;
 extern target_type_t xscale_target;
 extern target_type_t cortexm3_target;
+extern target_type_t arm11_target;
 
 target_type_t *target_types[] =
 {
@@ -94,8 +98,10 @@ target_type_t *target_types[] =
 	&arm720t_target,
 	&arm966e_target,
 	&arm926ejs_target,
+	&feroceon_target,
 	&xscale_target,
 	&cortexm3_target,
+	&arm11_target,
 	NULL,
 };
 
@@ -223,7 +229,7 @@ int target_init_handler(struct target_s *target, enum target_event event, void *
 	{
 		target_unregister_event_callback(target_init_handler, priv);
 
-		script = fopen(target->reset_script, "r");
+		script = open_file_from_path(cmd_ctx, target->reset_script, "r");
 		if (!script)
 		{
 			ERROR("couldn't open script file %s", target->reset_script);
@@ -253,11 +259,28 @@ int target_process_reset(struct command_context_s *cmd_ctx)
 {
 	int retval = ERROR_OK;
 	target_t *target;
+	struct timeval timeout, now;
 	
 	/* prepare reset_halt where necessary */
 	target = targets;
 	while (target)
 	{
+		if (jtag_reset_config & RESET_SRST_PULLS_TRST)
+		{
+			switch (target->reset_mode)
+			{
+				case RESET_HALT:
+					command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
+					target->reset_mode = RESET_RUN_AND_HALT;
+					break;
+				case RESET_INIT:
+					command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
+					target->reset_mode = RESET_RUN_AND_INIT;
+					break;
+				default:
+					break;
+			} 
+		}
 		switch (target->reset_mode)
 		{
 			case RESET_HALT:
@@ -313,29 +336,63 @@ int target_process_reset(struct command_context_s *cmd_ctx)
 	while (target)
 	{
 		target->type->deassert_reset(target);
+		target = target->next;
+	}
+	jtag_execute_queue();
 
-		switch (target->reset_mode)
+	/* Wait for reset to complete, maximum 5 seconds. */	
+	gettimeofday(&timeout, NULL);
+	timeval_add_time(&timeout, 5, 0);
+	for(;;)
+	{
+		gettimeofday(&now, NULL);
+		
+		target_call_timer_callbacks();
+		
+		target = targets;
+		while (target)
 		{
-			case RESET_INIT:
-			case RESET_HALT:
-				// If we're already halted, then this is harmless(reducing # of execution paths here)
-				// If nSRST & nTRST are tied together then the halt during reset failed(logged) and
-				// we use this as fallback(there is no other output to tell the user that reset halt 
-				// didn't work).
-				target->type->poll(target);
-				target->type->halt(target);
-				break;
-			default:
-				break;
+			target->type->poll(target);
+			if ((target->reset_mode == RESET_RUN_AND_INIT) || (target->reset_mode == RESET_RUN_AND_HALT))
+			{
+				if (target->state != TARGET_HALTED)
+				{
+					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 waiting for reset");
+						goto done;
+					}
+					usleep(100*1000); /* Do not eat all cpu */
+					goto again;
+				}
+			}
+			target = target->next;
 		}
+		/* All targets we're waiting for are halted */
+		break;
 		
-		
-		target = target->next;
+		again:;
 	}
-	jtag_execute_queue();
+	done:
+	
+	
+	/* We want any events to be processed before the prompt */
+	target_call_timer_callbacks();
 	
 	return retval;
-}	
+}
+
+static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
+{
+	*physical = virtual;
+	return ERROR_OK;
+}
+
+static int default_mmu(struct target_s *target, int *enabled)
+{
+	*enabled = 0;
+	return ERROR_OK;
+}
 
 int target_init(struct command_context_s *cmd_ctx)
 {
@@ -348,6 +405,16 @@ int target_init(struct command_context_s *cmd_ctx)
 			ERROR("target '%s' init failed", target->type->name);
 			exit(-1);
 		}
+		
+		/* Set up default functions if none are provided by target */
+		if (target->type->virt2phys == NULL)
+		{
+			target->type->virt2phys = default_virt2phys;
+		}
+		if (target->type->mmu == NULL)
+		{
+			target->type->mmu = default_mmu;
+		}
 		target = target->next;
 	}
 	
@@ -357,6 +424,11 @@ int target_init(struct command_context_s *cmd_ctx)
 		target_register_timer_callback(handle_target, 100, 1, NULL);
 	}
 		
+	return ERROR_OK;
+}
+
+int target_init_reset(struct command_context_s *cmd_ctx)
+{
 	if (startup_mode == DAEMON_RESET)
 		target_process_reset(cmd_ctx);
 	
@@ -539,6 +611,26 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
 	working_area_t *c = target->working_areas;
 	working_area_t *new_wa = NULL;
 	
+	/* Reevaluate working area address based on MMU state*/
+	if (target->working_areas == NULL)
+	{
+		int retval;
+		int enabled;
+		retval = target->type->mmu(target, &enabled);
+		if (retval != ERROR_OK)
+		{
+			return retval;
+		}
+		if (enabled)
+		{
+			target->working_area = target->working_area_virt;
+		}
+		else
+		{
+			target->working_area = target->working_area_phys;
+		}
+	}
+	
 	/* only allocate multiples of 4 byte */
 	if (size % 4)
 	{
@@ -577,7 +669,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
 		
 		if (free_size < size)
 		{
-			WARNING("not enough working area available");
+			WARNING("not enough working area available(requested %d, free %d)", size, free_size);
 			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 		}
 		
@@ -656,23 +748,43 @@ int target_register_commands(struct command_context_s *cmd_ctx)
 	register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL);
 	register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
 	register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, NULL);
-	register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_CONFIG, NULL);
+	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>");
 
 	return ERROR_OK;
 }
 
+int target_arch_state(struct target_s *target)
+{
+	int retval;
+	if (target==NULL)
+	{
+		USER("No target has been configured");
+		return ERROR_OK;
+	}
+	
+	USER("target state: %s", target_state_strings[target->state]);
+	
+	if (target->state!=TARGET_HALTED)
+		return ERROR_OK;
+	
+	retval=target->type->arch_state(target);
+	return retval;
+}
+
+/* Single aligned words are guaranteed to use 16 or 32 bit access 
+ * mode respectively, otherwise data is handled as quickly as 
+ * possible
+ */
 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
 {
 	int retval;
 	
 	DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
 	
-	/* handle writes of less than 4 byte */
-	if (size < 4)
+	if (((address % 2) == 0) && (size == 2))
 	{
-		if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
-			return retval;
-		return ERROR_OK;
+		return target->type->write_memory(target, address, 2, 1, buffer);
 	}
 	
 	/* handle unaligned head bytes */
@@ -680,6 +792,9 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
 	{
 		int unaligned = 4 - (address % 4);
 		
+		if (unaligned > size)
+			unaligned = size;
+
 		if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
 			return retval;
 		
@@ -720,18 +835,20 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
 	return ERROR_OK;
 }
 
+
+/* Single aligned words are guaranteed to use 16 or 32 bit access 
+ * mode respectively, otherwise data is handled as quickly as 
+ * possible
+ */
 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
 {
 	int retval;
 	
 	DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
 	
-	/* handle reads of less than 4 byte */
-	if (size < 4)
+	if (((address % 2) == 0) && (size == 2))
 	{
-		if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
-			return retval;
-		return ERROR_OK;
+		return target->type->read_memory(target, address, 2, 1, buffer);
 	}
 	
 	/* handle unaligned head bytes */
@@ -739,6 +856,9 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
 	{
 		int unaligned = 4 - (address % 4);
 		
+		if (unaligned > size)
+			unaligned = size;
+
 		if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
 			return retval;
 		
@@ -781,7 +901,17 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32*
 		size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
 	{
 		buffer = malloc(size);
-		target_read_buffer(target, address, size, buffer);
+		if (buffer == NULL)
+		{
+			ERROR("error allocating buffer for section (%d bytes)", size);
+			return ERROR_INVALID_ARGUMENTS;
+		}
+		retval = target_read_buffer(target, address, size, buffer);
+		if (retval != ERROR_OK)
+		{
+			free(buffer);
+			return retval;
+		}
 
 		/* convert to target endianess */
 		for (i = 0; i < (size/sizeof(u32)); i++)
@@ -1066,7 +1196,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 				
 				(*last_target_p)->dbgmsg = NULL;
 				(*last_target_p)->dbg_msg_enabled = 0;
-				
+								
 				(*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
 				
 				found = 1;
@@ -1164,10 +1294,9 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch
 {
 	target_t *target = NULL;
 	
-	if (argc < 4)
+	if ((argc < 4) || (argc > 5))
 	{
-		ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
-		exit(-1);
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	
 	target = get_target_by_num(strtoul(args[0], NULL, 0));
@@ -1177,8 +1306,13 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch
 		ERROR("target number '%s' not defined", args[0]);
 		exit(-1);
 	}
+	target_free_all_working_areas(target);
 	
-	target->working_area = strtoul(args[1], NULL, 0);
+	target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
+	if (argc == 5)
+	{
+		target->working_area_virt = strtoul(args[4], NULL, 0);
+	}
 	target->working_area_size = strtoul(args[2], NULL, 0);
 	
 	if (strcmp(args[3], "backup") == 0)
@@ -1192,7 +1326,7 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch
 	else
 	{
 		ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
-		exit(-1);
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	
 	return ERROR_OK;
@@ -1211,9 +1345,9 @@ int handle_target(void *priv)
 		if (target->state != TARGET_HALTED)
 		{
 			if (target_continous_poll)
-				if ((retval = target->type->poll(target)) < 0)
+				if ((retval = target->type->poll(target)) != ERROR_OK)
 				{
-					ERROR("couldn't poll target. It's due for a reset.");
+					ERROR("couldn't poll target(%d). It's due for a reset.", retval);
 				}
 		}
 	
@@ -1345,20 +1479,16 @@ 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);
-	char buffer[512];
 
 	if (argc == 0)
 	{
-		command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
-		if (target->state == TARGET_HALTED)
-		{
-			target->type->arch_state(target, buffer, 512);
-			buffer[511] = 0;
-			command_print(cmd_ctx, "%s", buffer);
-		}
+		target->type->poll(target);
+			target_arch_state(target);
 	}
 	else
 	{
@@ -1370,6 +1500,10 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 		{
 			target_continous_poll = 0;
 		}
+		else
+		{
+			command_print(cmd_ctx, "arg is \"on\" or \"off\"");
+		}
 	}
 	
 	
@@ -1378,38 +1512,55 @@ 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);
-	struct timeval timeout, now;
+	int ms = 5000;
 	
-	gettimeofday(&timeout, NULL);
-	if (!argc)
-		timeval_add_time(&timeout, 5, 0);
-	else {
+	if (argc > 0)
+	{
 		char *end;
 
-		timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
-		if (*end) {
-			command_print(cmd_ctx, "usage: wait_halt [seconds]");
+		ms = strtoul(args[0], &end, 0) * 1000;
+		if (*end)
+		{
+			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); 
+}
+
+static void target_process_events(struct command_context_s *cmd_ctx)
+{
+	target_t *target = get_current_target(cmd_ctx);
+	target->type->poll(target);
+	target_call_timer_callbacks();
+}
 
-	while(target->type->poll(target))
+static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
+{
+	int retval;
+	struct timeval timeout, now;
+	
+	gettimeofday(&timeout, NULL);
+	timeval_add_time(&timeout, 0, ms * 1000);
+	
+	target_t *target = get_current_target(cmd_ctx);
+	for (;;)
 	{
-		if (target->state == TARGET_HALTED)
+		if ((retval=target->type->poll(target))!=ERROR_OK)
+			return retval;
+		target_call_timer_callbacks();
+		if (target->state == state)
 		{
-			command_print(cmd_ctx, "target halted");
 			break;
 		}
-		target_call_timer_callbacks();
+		command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
 		
 		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");
-			ERROR("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 %s", target_state_strings[state]);
 			break;
 		}
 	}
@@ -1435,15 +1586,14 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 				break;
 			case ERROR_TARGET_TIMEOUT:
 				command_print(cmd_ctx, "target timed out... shutting down");
-				exit(-1);
+				return retval;
 			default:
 				command_print(cmd_ctx, "unknown error... shutting down");
-				exit(-1);
+				return retval;
 		}
 	}
 	
-	return ERROR_OK;
-
+	return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
 }
 
 /* what to do on daemon startup */
@@ -1494,7 +1644,8 @@ int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd,
 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	target_t *target = get_current_target(cmd_ctx);
-	enum target_reset_mode reset_mode = RESET_RUN;
+	enum target_reset_mode reset_mode = target->reset_mode;
+	enum target_reset_mode save = target->reset_mode;
 	
 	DEBUG("-");
 	
@@ -1527,11 +1678,17 @@ int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **ar
 			command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
 			return ERROR_OK;
 		}
-		target->reset_mode = reset_mode;
 	}
 	
+	/* temporarily modify mode of current reset target */
+	target->reset_mode = reset_mode;
+
+	/* reset *all* targets */
 	target_process_reset(cmd_ctx);
 	
+	/* Restore default reset mode for this target */
+    target->reset_mode = save;
+	
 	return ERROR_OK;
 }
 
@@ -1540,32 +1697,20 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 	int retval;
 	target_t *target = get_current_target(cmd_ctx);
 	
-	DEBUG("-");
-	
 	if (argc == 0)
 		retval = target->type->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 */
 	else
 	{
-		command_print(cmd_ctx, "usage: resume [address]");
-		return ERROR_OK;
-	}
-	
-	if (retval != ERROR_OK)
-	{	
-		switch (retval)
-		{
-			case ERROR_TARGET_NOT_HALTED:
-				command_print(cmd_ctx, "target not halted");
-				break;
-			default:
-				command_print(cmd_ctx, "unknown error... shutting down");
-				exit(-1);
-		}
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	return ERROR_OK;
+	target_process_events(cmd_ctx);
+	
+	target_arch_state(target);
+	
+	return retval;
 }
 
 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
@@ -1588,7 +1733,7 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 	const int line_bytecnt = 32;
 	int count = 1;
 	int size = 4;
-	u32 address = 0;  
+	u32 address = 0;
 	int line_modulo;
 	int i;
 
@@ -1778,6 +1923,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)
+		{
+			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);
@@ -1810,6 +1961,7 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char
 	u32 address;
 	u32 size;
 	u8 buffer[560];
+	int retval;
 	
 	duration_t duration;
 	char *duration_text;
@@ -1844,7 +1996,13 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char
 		u32 size_written;
 		u32 this_run_size = (size > 560) ? 560 : size;
 		
-		target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
+		retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
+		if (retval != ERROR_OK)
+		{
+			command_print(cmd_ctx, "Reading memory failed %d", retval);
+			break;
+		}
+		
 		fileio_write(&fileio, this_run_size, buffer, &size_written);
 		
 		size -= this_run_size;
@@ -1858,7 +2016,6 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char
 	free(duration_text);
 	
 	return ERROR_OK;
-
 }
 
 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
@@ -1915,6 +2072,11 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
 	for (i = 0; i < image.num_sections; i++)
 	{
 		buffer = malloc(image.sections[i].size);
+		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);
@@ -1931,7 +2093,7 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
 		
 		if( retval != ERROR_OK )
 		{
-			command_print(cmd_ctx, "image verify failed, verify aborted");
+			command_print(cmd_ctx, "could not calculate checksum, verify aborted");
 			free(buffer);
 			image_close(&image);
 			return ERROR_OK;
@@ -1942,7 +2104,7 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
 			/* failed crc checksum, fall back to a binary compare */
 			u8 *data;
 			
-			command_print(cmd_ctx, "image verify checksum failed - attempting binary compare");
+			command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
 			
 			data = (u8*)malloc(buf_cnt);
 			
@@ -2144,4 +2306,29 @@ int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args
 	return ERROR_OK;
 }
 
+int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
+{
+	int retval;
+	target_t *target = get_current_target(cmd_ctx);
+	u32 va;
+	u32 pa;
+
+	if (argc != 1)
+	{
+		return ERROR_COMMAND_SYNTAX_ERROR;
+	}
+	va = strtoul(args[0], NULL, 0);
 
+	retval = target->type->virt2phys(target, va, &pa);
+	if (retval == ERROR_OK)
+	{
+		command_print(cmd_ctx, "Physical address 0x%08x", pa);
+	}
+	else
+	{
+		/* lower levels will have logged a detailed error which is 
+		 * forwarded to telnet/GDB session.  
+		 */
+	}
+	return retval;
+}