X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=114832783b4427960d450df0089ae6507f53b320;hb=da2bbc90fc8b1a44fe466e6f168882b65381df3e;hp=2eeb2bfc5cd6418fcba028ea05ff1ae9fa08b92a;hpb=4b97f3cbb9603c13f69f8d3b5371c12045593126;p=openocd.git

diff --git a/src/target/target.c b/src/target/target.c
index 2eeb2bfc5c..114832783b 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -23,6 +23,7 @@
 
 #include "replacements.h"
 #include "target.h"
+#include "target_request.h"
 
 #include "log.h"
 #include "configuration.h"
@@ -68,6 +69,7 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 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);
@@ -251,11 +253,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:
@@ -314,6 +333,42 @@ int target_process_reset(struct command_context_s *cmd_ctx)
 		target = target->next;
 	}
 	jtag_execute_queue();
+
+	/* 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)
+		{
+			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;
+		
+		again:;
+	}
+	done:
+	
 	
 	return retval;
 }	
@@ -338,6 +393,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);
 	
@@ -653,6 +713,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
 	{
 		if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
 			return retval;
+		return ERROR_OK;
 	}
 	
 	/* handle unaligned head bytes */
@@ -711,6 +772,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
 	{
 		if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
 			return retval;
+		return ERROR_OK;
 	}
 	
 	/* handle unaligned head bytes */
@@ -749,6 +811,41 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
 	return ERROR_OK;
 }
 
+int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
+{
+	u8 *buffer;
+	int retval;
+	int i;
+	u32 checksum = 0;
+	
+	if ((retval = target->type->checksum_memory(target, address,
+		size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
+	{
+		buffer = malloc(size);
+		if (buffer == NULL)
+		{
+			ERROR("error allocating buffer for section (%d bytes)", size);
+			return ERROR_OK;
+		}
+		target_read_buffer(target, address, size, buffer);
+
+		/* convert to target endianess */
+		for (i = 0; i < (size/sizeof(u32)); i++)
+		{
+			u32 target_data;
+			target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
+			target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
+		}
+
+		retval = image_calculate_checksum( buffer, size, &checksum );
+		free(buffer);
+	}
+	
+	*crc = checksum;
+	
+	return retval;
+}
+
 int target_read_u32(struct target_s *target, u32 address, u32 *value)
 {
 	u8 value_buf[4];
@@ -859,7 +956,7 @@ int target_register_user_commands(struct command_context_s *cmd_ctx)
 	register_command(cmd_ctx,  NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
 	register_command(cmd_ctx,  NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
 	register_command(cmd_ctx,  NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
-	register_command(cmd_ctx,  NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction");
+	register_command(cmd_ctx,  NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
 	register_command(cmd_ctx,  NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
 	register_command(cmd_ctx,  NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
 
@@ -876,11 +973,15 @@ int target_register_user_commands(struct command_context_s *cmd_ctx)
 	register_command(cmd_ctx,  NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");	
 	register_command(cmd_ctx,  NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
 	
-	register_command(cmd_ctx,  NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf']");
+	register_command(cmd_ctx,  NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
 	register_command(cmd_ctx,  NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
+	register_command(cmd_ctx,  NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
 	register_command(cmd_ctx,  NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
 	register_command(cmd_ctx,  NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
 	
+	target_request_register_commands(cmd_ctx);
+	trace_register_commands(cmd_ctx);
+	
 	return ERROR_OK;
 }
 
@@ -985,6 +1086,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 				(*last_target_p)->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;
@@ -998,6 +1100,19 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 				(*last_target_p)->next = NULL;
 				(*last_target_p)->arch_info = NULL;
 				
+				/* initialize trace information */
+				(*last_target_p)->trace_info = malloc(sizeof(trace_t));
+				(*last_target_p)->trace_info->num_trace_points = 0;
+				(*last_target_p)->trace_info->trace_points_size = 0;
+				(*last_target_p)->trace_info->trace_points = NULL;
+				(*last_target_p)->trace_info->trace_history_size = 0;
+				(*last_target_p)->trace_info->trace_history = NULL;
+				(*last_target_p)->trace_info->trace_history_pos = 0;
+				(*last_target_p)->trace_info->trace_history_overflowed = 0;
+				
+				(*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;
@@ -1053,6 +1168,12 @@ int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, c
 			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
 	{
 		ERROR("unknown event type: '%s", args[1]);
@@ -1138,8 +1259,7 @@ int handle_target(void *priv)
 			if (target_continous_poll)
 				if ((retval = target->type->poll(target)) < 0)
 				{
-					ERROR("couldn't poll target, exiting");
-					exit(-1);
+					ERROR("couldn't poll target. It's due for a reset.");
 				}
 		}
 	
@@ -1296,6 +1416,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\"");
+		}
 	}
 	
 	
@@ -1361,10 +1485,10 @@ 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;
 		}
 	}
 	
@@ -1420,7 +1544,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("-");
 	
@@ -1453,11 +1578,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;
 }
 
@@ -1511,9 +1642,11 @@ int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 
 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
+	const int line_bytecnt = 32;
 	int count = 1;
 	int size = 4;
 	u32 address = 0;
+	int line_modulo;
 	int i;
 
 	char output[128];
@@ -1536,20 +1669,21 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 	switch (cmd[2])
 	{
 		case 'w':
-			size = 4;
+			size = 4; line_modulo = line_bytecnt / 4;
 			break;
 		case 'h':
-			size = 2;
+			size = 2; line_modulo = line_bytecnt / 2;
 			break;
 		case 'b':
-			size = 1;
+			size = 1; line_modulo = line_bytecnt / 1;
 			break;
 		default:
 			return ERROR_OK;
 	}
 
 	buffer = calloc(count, size);
-	if ((retval  = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
+	retval  = target->type->read_memory(target, address, size, count, buffer);
+	if (retval != ERROR_OK)
 	{
 		switch (retval)
 		{
@@ -1573,7 +1707,7 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 
 	for (i = 0; i < count; i++)
 	{
-		if (i%8 == 0)
+		if (i%line_modulo == 0)
 			output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
 		
 		switch (size)
@@ -1589,7 +1723,7 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 				break;
 		}
 
-		if ((i%8 == 7) || (i == count - 1))
+		if ((i%line_modulo == line_modulo-1) || (i == count - 1))
 		{
 			command_print(cmd_ctx, output);
 			output_len = 0;
@@ -1701,6 +1835,11 @@ 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);
@@ -1733,6 +1872,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;
@@ -1767,7 +1907,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;
@@ -1781,7 +1927,138 @@ 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)
+{
+	u8 *buffer;
+	u32 buf_cnt;
+	u32 image_size;
+	int i;
+	int retval;
+	u32 checksum = 0;
+	u32 mem_checksum = 0;
+
+	image_t image;	
+	
+	duration_t duration;
+	char *duration_text;
+	
+	target_t *target = get_current_target(cmd_ctx);
+	
+	if (argc < 1)
+	{
+		command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
+		return ERROR_OK;
+	}
+	
+	if (!target)
+	{
+		ERROR("no target selected");
+		return ERROR_OK;
+	}
+	
+	duration_start_measure(&duration);
+	
+	if (argc >= 2)
+	{
+		image.base_address_set = 1;
+		image.base_address = strtoul(args[1], NULL, 0);
+	}
+	else
+	{
+		image.base_address_set = 0;
+		image.base_address = 0x0;
+	}
 
+	image.start_address_set = 0;
+
+	if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
+	{
+		command_print(cmd_ctx, "verify_image error: %s", image.error_str);
+		return ERROR_OK;
+	}
+	
+	image_size = 0x0;
+	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);
+			command_print(cmd_ctx, "image reading failed, verify aborted");
+			free(buffer);
+			image_close(&image);
+			return ERROR_OK;
+		}
+		
+		/* calculate checksum of image */
+		image_calculate_checksum( buffer, buf_cnt, &checksum );
+		
+		retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
+		
+		if( retval != ERROR_OK )
+		{
+			command_print(cmd_ctx, "image verify failed, verify aborted");
+			free(buffer);
+			image_close(&image);
+			return ERROR_OK;
+		}
+		
+		if( checksum != mem_checksum )
+		{
+			/* failed crc checksum, fall back to a binary compare */
+			u8 *data;
+			
+			command_print(cmd_ctx, "image verify checksum failed - attempting binary compare");
+			
+			data = (u8*)malloc(buf_cnt);
+			
+			/* Can we use 32bit word accesses? */
+			int size = 1;
+			int count = buf_cnt;
+			if ((count % 4) == 0)
+			{
+				size *= 4;
+				count /= 4;
+			}
+			retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
+	
+			if (retval == ERROR_OK)
+			{
+				int t;
+				for (t = 0; t < buf_cnt; t++)
+				{
+					if (data[t] != buffer[t])
+					{
+						command_print(cmd_ctx, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", t + image.sections[i].base_address, data[t], buffer[t]);
+						free(data);
+						free(buffer);
+						image_close(&image);
+						return ERROR_OK;
+					}
+				}
+			}
+			
+			free(data);
+		}
+		
+		free(buffer);
+		image_size += buf_cnt;
+	}
+	
+	duration_stop_measure(&duration, &duration_text);
+	command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
+	free(duration_text);
+	
+	image_close(&image);
+	
+	return ERROR_OK;
 }
 
 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
@@ -1860,6 +2137,7 @@ int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args
 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	target_t *target = get_current_target(cmd_ctx);
+	int retval;
 
 	if (argc == 0)
 	{
@@ -1903,7 +2181,23 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 		{
 			data_mask = strtoul(args[4], NULL, 0);
 		}
-		watchpoint_add(target, strtoul(args[0], NULL, 0), strtoul(args[1], NULL, 0), type, data_value, data_mask);
+		
+		if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
+				strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
+		{
+			switch (retval)
+			{
+				case ERROR_TARGET_NOT_HALTED:
+					command_print(cmd_ctx, "target must be halted to set watchpoints");
+					break;
+				case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
+					command_print(cmd_ctx, "no more watchpoints available");
+					break;
+				default:
+					command_print(cmd_ctx, "unknown error, watchpoint not set");
+					break;
+			}	
+		}
 	}
 	else
 	{
@@ -1922,4 +2216,3 @@ int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args
 	
 	return ERROR_OK;
 }
-