X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=1c32fdbb132ac2e3141a8aa930c4c548bd416235;hb=695c6c09603547edcfc78f18c1efd23c7ccb10dd;hp=bafd98e9dec033025c957aba8f4e931b7116295a;hpb=f4d82deb36b857c6d60d9f31b60d58665a8d6216;p=openocd.git

diff --git a/src/target/target.c b/src/target/target.c
index bafd98e9de..1c32fdbb13 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -33,57 +33,40 @@
 #include "config.h"
 #endif
 
-#include "replacements.h"
 #include "target.h"
+#include "target_type.h"
 #include "target_request.h"
-
-#include "log.h"
-#include "configuration.h"
-#include "binarybuffer.h"
+#include "time_support.h"
+#include "register.h"
+#include "trace.h"
+#include "image.h"
 #include "jtag.h"
 
-#include <string.h>
-#include <stdlib.h>
-#include <inttypes.h>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <errno.h>
-
-#include <sys/time.h>
-#include <time.h>
-
-#include <time_support.h>
-
-#include <fileio.h>
-#include <image.h>
-
-int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
-
-int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-
-int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-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);
-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);
-int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+
+static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+
+static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 
 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
@@ -102,8 +85,10 @@ 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 cortexa8_target;
 extern target_type_t arm11_target;
 extern target_type_t mips_m4k_target;
+extern target_type_t avr_target;
 
 target_type_t *target_types[] =
 {
@@ -116,8 +101,10 @@ target_type_t *target_types[] =
 	&feroceon_target,
 	&xscale_target,
 	&cortexm3_target,
+	&cortexa8_target,
 	&arm11_target,
 	&mips_m4k_target,
+	&avr_target,
 	NULL,
 };
 
@@ -162,7 +149,7 @@ const char *target_strerror_safe( int err )
 	}
 }
 
-const Jim_Nvp nvp_target_event[] = {
+static const Jim_Nvp nvp_target_event[] = {
 	{ .value = TARGET_EVENT_OLD_gdb_program_config , .name = "old-gdb_program_config" },
 	{ .value = TARGET_EVENT_OLD_pre_resume         , .name = "old-pre_resume" },
 
@@ -285,7 +272,7 @@ static int new_target_number(void)
 static int target_continous_poll = 1;
 
 /* read a u32 from a buffer in target memory endianness */
-u32 target_buffer_get_u32(target_t *target, u8 *buffer)
+u32 target_buffer_get_u32(target_t *target, const u8 *buffer)
 {
 	if (target->endianness == TARGET_LITTLE_ENDIAN)
 		return le_to_h_u32(buffer);
@@ -294,7 +281,7 @@ u32 target_buffer_get_u32(target_t *target, u8 *buffer)
 }
 
 /* read a u16 from a buffer in target memory endianness */
-u16 target_buffer_get_u16(target_t *target, u8 *buffer)
+u16 target_buffer_get_u16(target_t *target, const u8 *buffer)
 {
 	if (target->endianness == TARGET_LITTLE_ENDIAN)
 		return le_to_h_u16(buffer);
@@ -303,7 +290,7 @@ u16 target_buffer_get_u16(target_t *target, u8 *buffer)
 }
 
 /* read a u8 from a buffer in target memory endianness */
-u8 target_buffer_get_u8(target_t *target, u8 *buffer)
+u8 target_buffer_get_u8(target_t *target, const u8 *buffer)
 {
 	return *buffer & 0x0ff;
 }
@@ -332,8 +319,36 @@ void target_buffer_set_u8(target_t *target, u8 *buffer, u8 value)
 	*buffer = value;
 }
 
+/* return a pointer to a configured target; id is name or number */
+target_t *get_target(const char *id)
+{
+	target_t *target;
+	char *endptr;
+	int num;
+
+	/* try as tcltarget name */
+	for (target = all_targets; target; target = target->next) {
+		if (target->cmd_name == NULL)
+			continue;
+		if (strcmp(id, target->cmd_name) == 0)
+			return target;
+	}
+
+	/* no match, try as number */
+	num = strtoul(id, &endptr, 0);
+	if (*endptr != 0)
+		return NULL;
+
+	for (target = all_targets; target; target = target->next) {
+		if (target->target_number == num)
+			return target;
+	}
+
+	return NULL;
+}
+
 /* returns a pointer to the n-th configured target */
-target_t* get_target_by_num(int num)
+static target_t *get_target_by_num(int num)
 {
 	target_t *target = all_targets;
 
@@ -368,7 +383,7 @@ target_t* get_current_target(command_context_t *cmd_ctx)
 int target_poll(struct target_s *target)
 {
 	/* We can't poll until after examine */
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		/* Fail silently lest we pollute the log */
 		return ERROR_FAIL;
@@ -379,7 +394,7 @@ int target_poll(struct target_s *target)
 int target_halt(struct target_s *target)
 {
 	/* We can't poll until after examine */
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -392,7 +407,7 @@ int target_resume(struct target_s *target, int current, u32 address, int handle_
 	int retval;
 
 	/* We can't poll until after examine */
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -447,10 +462,15 @@ static int default_mmu(struct target_s *target, int *enabled)
 
 static int default_examine(struct target_s *target)
 {
-	target->type->examined = 1;
+	target_set_examined(target);
 	return ERROR_OK;
 }
 
+int target_examine_one(struct target_s *target)
+{
+	return target->type->examine(target);
+}
+
 /* Targets that correctly implement init+examine, i.e.
  * no communication with target during init:
  *
@@ -459,19 +479,25 @@ static int default_examine(struct target_s *target)
 int target_examine(void)
 {
 	int retval = ERROR_OK;
-	target_t *target = all_targets;
-	while (target)
+	target_t *target;
+
+	for (target = all_targets; target; target = target->next)
 	{
-		if ((retval = target->type->examine(target))!=ERROR_OK)
+		if (!target->tap->enabled)
+			continue;
+		if ((retval = target_examine_one(target)) != ERROR_OK)
 			return retval;
-		target = target->next;
 	}
 	return retval;
 }
+const char *target_get_name(struct target_s *target)
+{
+	return target->type->name;
+}
 
 static int target_write_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
 {
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -481,7 +507,7 @@ static int target_write_memory_imp(struct target_s *target, u32 address, u32 siz
 
 static int target_read_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
 {
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -491,7 +517,7 @@ static int target_read_memory_imp(struct target_s *target, u32 address, u32 size
 
 static int target_soft_reset_halt_imp(struct target_s *target)
 {
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -501,7 +527,7 @@ static int target_soft_reset_halt_imp(struct target_s *target)
 
 static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, u32 entry_point, u32 exit_point, int timeout_ms, void *arch_info)
 {
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -509,6 +535,85 @@ static int target_run_algorithm_imp(struct target_s *target, int num_mem_params,
 	return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info);
 }
 
+int target_read_memory(struct target_s *target,
+		u32 address, u32 size, u32 count, u8 *buffer)
+{
+	return target->type->read_memory(target, address, size, count, buffer);
+}
+
+int target_write_memory(struct target_s *target,
+		u32 address, u32 size, u32 count, u8 *buffer)
+{
+	return target->type->write_memory(target, address, size, count, buffer);
+}
+int target_bulk_write_memory(struct target_s *target,
+		u32 address, u32 count, u8 *buffer)
+{
+	return target->type->bulk_write_memory(target, address, count, buffer);
+}
+
+int target_add_breakpoint(struct target_s *target,
+		struct breakpoint_s *breakpoint)
+{
+	return target->type->add_breakpoint(target, breakpoint);
+}
+int target_remove_breakpoint(struct target_s *target,
+		struct breakpoint_s *breakpoint)
+{
+	return target->type->remove_breakpoint(target, breakpoint);
+}
+
+int target_add_watchpoint(struct target_s *target,
+		struct watchpoint_s *watchpoint)
+{
+	return target->type->add_watchpoint(target, watchpoint);
+}
+int target_remove_watchpoint(struct target_s *target,
+		struct watchpoint_s *watchpoint)
+{
+	return target->type->remove_watchpoint(target, watchpoint);
+}
+
+int target_get_gdb_reg_list(struct target_s *target,
+		struct reg_s **reg_list[], int *reg_list_size)
+{
+	return target->type->get_gdb_reg_list(target, reg_list, reg_list_size);
+}
+int target_step(struct target_s *target,
+		int current, u32 address, int handle_breakpoints)
+{
+	return target->type->step(target, current, address, handle_breakpoints);
+}
+
+
+int target_run_algorithm(struct target_s *target,
+		int num_mem_params, mem_param_t *mem_params,
+		int num_reg_params, reg_param_t *reg_param,
+		u32 entry_point, u32 exit_point,
+		int timeout_ms, void *arch_info)
+{
+	return target->type->run_algorithm(target,
+			num_mem_params, mem_params, num_reg_params, reg_param,
+			entry_point, exit_point, timeout_ms, arch_info);
+}
+
+/// @returns @c true if the target has been examined.
+bool target_was_examined(struct target_s *target)
+{
+	return target->type->examined;
+}
+/// Sets the @c examined flag for the given target.
+void target_set_examined(struct target_s *target)
+{
+	target->type->examined = true;
+}
+// Reset the @c examined flag for the given target.
+void target_reset_examined(struct target_s *target)
+{
+	target->type->examined = false;
+}
+
+
 int target_init(struct command_context_s *cmd_ctx)
 {
 	target_t *target = all_targets;
@@ -516,7 +621,7 @@ int target_init(struct command_context_s *cmd_ctx)
 
 	while (target)
 	{
-		target->type->examined = 0;
+		target_reset_examined(target);
 		if (target->type->examine == NULL)
 		{
 			target->type->examine = default_examine;
@@ -524,7 +629,7 @@ int target_init(struct command_context_s *cmd_ctx)
 
 		if ((retval = target->type->init_target(cmd_ctx, target)) != ERROR_OK)
 		{
-			LOG_ERROR("target '%s' init failed", target->type->name);
+			LOG_ERROR("target '%s' init failed", target_get_name(target));
 			return retval;
 		}
 
@@ -842,7 +947,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
 		{
 			int retval;
 			new_wa->backup = malloc(new_wa->size);
-			if((retval = target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
+			if((retval = target_read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
 			{
 				free(new_wa->backup);
 				free(new_wa);
@@ -876,7 +981,7 @@ int target_free_working_area_restore(struct target_s *target, working_area_t *ar
 	if (restore&&target->backup_working_area)
 	{
 		int retval;
-		if((retval = target->type->write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
+		if((retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
 			return retval;
 	}
 
@@ -926,23 +1031,12 @@ int target_register_commands(struct command_context_s *cmd_ctx)
 {
 
 	register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, "change the current command line target (one parameter) or lists targets (with no parameter)");
-	register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "translate a virtual address into a physical address");
-	register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC");
 
-	register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
-			"same args as load_image, image stored in memory - mainly for profiling purposes");
-
-	register_command(cmd_ctx, NULL, "fast_load", handle_fast_load_command, COMMAND_ANY,
-			"loads active fast load image to current target - mainly for profiling purposes");
 
 
 
 	register_jim(cmd_ctx, "target", jim_target, "configure target" );
 
-
-	/* script procedures */
-	register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing");
-	register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values");
 	return ERROR_OK;
 }
 
@@ -974,12 +1068,16 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
 	int retval;
 	LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
 
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
+	if (size == 0) {
+		return ERROR_OK;
+	}
+
 	if ((address + size - 1) < address)
 	{
 		/* GDB can request this when e.g. PC is 0xfffffffc*/
@@ -989,18 +1087,18 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
 
 	if (((address % 2) == 0) && (size == 2))
 	{
-		return target->type->write_memory(target, address, 2, 1, buffer);
+		return target_write_memory(target, address, 2, 1, buffer);
 	}
 
 	/* handle unaligned head bytes */
 	if (address % 4)
 	{
-		int unaligned = 4 - (address % 4);
+		u32 unaligned = 4 - (address % 4);
 
 		if (unaligned > size)
 			unaligned = size;
 
-		if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
+		if ((retval = target_write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
 			return retval;
 
 		buffer += unaligned;
@@ -1021,7 +1119,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
 		}
 		else
 		{
-			if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
+			if ((retval = target_write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
 				return retval;
 		}
 
@@ -1033,7 +1131,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
 	/* handle tail writes of less than 4 bytes */
 	if (size > 0)
 	{
-		if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
+		if ((retval = target_write_memory(target, address, 1, size, buffer)) != ERROR_OK)
 			return retval;
 	}
 
@@ -1049,12 +1147,16 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
 	int retval;
 	LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
 
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
+	if (size == 0) {
+		return ERROR_OK;
+	}
+
 	if ((address + size - 1) < address)
 	{
 		/* GDB can request this when e.g. PC is 0xfffffffc*/
@@ -1064,18 +1166,18 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
 
 	if (((address % 2) == 0) && (size == 2))
 	{
-		return target->type->read_memory(target, address, 2, 1, buffer);
+		return target_read_memory(target, address, 2, 1, buffer);
 	}
 
 	/* handle unaligned head bytes */
 	if (address % 4)
 	{
-		int unaligned = 4 - (address % 4);
+		u32 unaligned = 4 - (address % 4);
 
 		if (unaligned > size)
 			unaligned = size;
 
-		if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
+		if ((retval = target_read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
 			return retval;
 
 		buffer += unaligned;
@@ -1088,7 +1190,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
 	{
 		int aligned = size - (size % 4);
 
-		if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
+		if ((retval = target_read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
 			return retval;
 
 		buffer += aligned;
@@ -1099,7 +1201,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
 	/* handle tail writes of less than 4 bytes */
 	if (size > 0)
 	{
-		if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
+		if ((retval = target_read_memory(target, address, 1, size, buffer)) != ERROR_OK)
 			return retval;
 	}
 
@@ -1110,9 +1212,9 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32*
 {
 	u8 *buffer;
 	int retval;
-	int i;
+	u32 i;
 	u32 checksum = 0;
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -1154,7 +1256,7 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32*
 int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u32* blank)
 {
 	int retval;
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -1171,13 +1273,13 @@ int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u3
 int target_read_u32(struct target_s *target, u32 address, u32 *value)
 {
 	u8 value_buf[4];
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
-	int retval = target->type->read_memory(target, address, 4, 1, value_buf);
+	int retval = target_read_memory(target, address, 4, 1, value_buf);
 
 	if (retval == ERROR_OK)
 	{
@@ -1196,13 +1298,13 @@ int target_read_u32(struct target_s *target, u32 address, u32 *value)
 int target_read_u16(struct target_s *target, u32 address, u16 *value)
 {
 	u8 value_buf[2];
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
-	int retval = target->type->read_memory(target, address, 2, 1, value_buf);
+	int retval = target_read_memory(target, address, 2, 1, value_buf);
 
 	if (retval == ERROR_OK)
 	{
@@ -1220,8 +1322,8 @@ int target_read_u16(struct target_s *target, u32 address, u16 *value)
 
 int target_read_u8(struct target_s *target, u32 address, u8 *value)
 {
-	int retval = target->type->read_memory(target, address, 1, 1, value);
-	if (!target->type->examined)
+	int retval = target_read_memory(target, address, 1, 1, value);
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -1244,7 +1346,7 @@ int target_write_u32(struct target_s *target, u32 address, u32 value)
 {
 	int retval;
 	u8 value_buf[4];
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -1253,7 +1355,7 @@ int target_write_u32(struct target_s *target, u32 address, u32 value)
 	LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
 
 	target_buffer_set_u32(target, value_buf, value);
-	if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
+	if ((retval = target_write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
 	{
 		LOG_DEBUG("failed: %i", retval);
 	}
@@ -1265,7 +1367,7 @@ int target_write_u16(struct target_s *target, u32 address, u16 value)
 {
 	int retval;
 	u8 value_buf[2];
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -1274,7 +1376,7 @@ int target_write_u16(struct target_s *target, u32 address, u16 value)
 	LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
 
 	target_buffer_set_u16(target, value_buf, value);
-	if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
+	if ((retval = target_write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
 	{
 		LOG_DEBUG("failed: %i", retval);
 	}
@@ -1285,7 +1387,7 @@ int target_write_u16(struct target_s *target, u32 address, u16 value)
 int target_write_u8(struct target_s *target, u32 address, u8 value)
 {
 	int retval;
-	if (!target->type->examined)
+	if (!target_was_examined(target))
 	{
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
@@ -1293,7 +1395,7 @@ int target_write_u8(struct target_s *target, u32 address, u8 value)
 
 	LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
 
-	if ((retval = target->type->write_memory(target, address, 1, 1, &value)) != ERROR_OK)
+	if ((retval = target_write_memory(target, address, 1, 1, &value)) != ERROR_OK)
 	{
 		LOG_DEBUG("failed: %i", retval);
 	}
@@ -1304,6 +1406,21 @@ int target_write_u8(struct target_s *target, u32 address, u8 value)
 int target_register_user_commands(struct command_context_s *cmd_ctx)
 {
 	int retval = ERROR_OK;
+
+
+	/* script procedures */
+	register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC");
+	register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing <ARRAYNAME> <WIDTH=32/16/8> <ADDRESS> <COUNT>");
+	register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values  <ARRAYNAME> <WIDTH=32/16/8> <ADDRESS> <COUNT>");
+
+	register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
+			"same args as load_image, image stored in memory - mainly for profiling purposes");
+
+	register_command(cmd_ctx, NULL, "fast_load", handle_fast_load_command, COMMAND_ANY,
+			"loads active fast load image to current target - mainly for profiling purposes");
+
+
+	register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "translate a virtual address into a physical address");
 	register_command(cmd_ctx,  NULL, "reg", handle_reg_command, COMMAND_EXEC, "display or set a register");
 	register_command(cmd_ctx,  NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
 	register_command(cmd_ctx,  NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
@@ -1329,6 +1446,7 @@ int target_register_user_commands(struct command_context_s *cmd_ctx)
 	register_command(cmd_ctx,  NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
 	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, "test_image", handle_test_image_command, COMMAND_EXEC, "test_image <file> [offset] [type]");
 
 	if((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
 		return retval;
@@ -1338,37 +1456,18 @@ int target_register_user_commands(struct command_context_s *cmd_ctx)
 	return retval;
 }
 
-int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-	char *cp;
 	target_t *target = all_targets;
 
 	if (argc == 1)
 	{
-		/* try as tcltarget name */
-		for( target = all_targets ; target ; target = target->next ){
-		  if( target->cmd_name ){
-			if( 0 == strcmp( args[0], target->cmd_name ) ){
-				/* MATCH */
-				goto Match;
-			}
-		  }
-		}
-		/* no match, try as number */
-
-		int num = strtoul(args[0], &cp, 0 );
-		if( *cp != 0 ){
-			/* then it was not a number */
-			command_print( cmd_ctx, "Target: %s unknown, try one of:\n", args[0] );
-			goto DumpTargets;
-		}
-
-		target = get_target_by_num( num );
-		if( target == NULL ){
+		target = get_target(args[0]);
+		if (target == NULL) {
 			command_print(cmd_ctx,"Target: %s is unknown, try one of:\n", args[0] );
 			goto DumpTargets;
 		}
-	Match:
+
 		cmd_ctx->current_target = target->target_number;
 		return ERROR_OK;
 	}
@@ -1383,7 +1482,7 @@ DumpTargets:
 		command_print(cmd_ctx, "%2d: %-10s %-10s %-10s %10d %14s %s",
 					  target->target_number,
 					  target->cmd_name,
-					  target->type->name,
+					  target_get_name(target),
 					  Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness )->name,
 					  target->tap->abs_chain_position,
 					  target->tap->dotted_name,
@@ -1534,7 +1633,7 @@ int handle_target(void *priv)
 	return retval;
 }
 
-int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	target_t *target;
 	reg_t *reg = NULL;
@@ -1645,7 +1744,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
 	return ERROR_OK;
 }
 
-int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	int retval = ERROR_OK;
 	target_t *target = get_current_target(cmd_ctx);
@@ -1680,7 +1779,7 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 	return retval;
 }
 
-int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	int ms = 5000;
 
@@ -1700,32 +1799,41 @@ int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char
 	return target_wait_state(target, TARGET_HALTED, ms);
 }
 
+/* wait for target state to change. The trick here is to have a low
+ * latency for short waits and not to suck up all the CPU time
+ * on longer waits.
+ *
+ * After 500ms, keep_alive() is invoked
+ */
 int target_wait_state(target_t *target, enum target_state state, int ms)
 {
 	int retval;
-	struct timeval timeout, now;
+	long long then=0, cur;
 	int once=1;
-	gettimeofday(&timeout, NULL);
-	timeval_add_time(&timeout, 0, ms * 1000);
 
 	for (;;)
 	{
 		if ((retval=target_poll(target))!=ERROR_OK)
 			return retval;
-		keep_alive();
 		if (target->state == state)
 		{
 			break;
 		}
+		cur = timeval_ms();
 		if (once)
 		{
 			once=0;
+			then = timeval_ms();
 			LOG_DEBUG("waiting for target %s...",
 				Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
 		}
 
-		gettimeofday(&now, NULL);
-		if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
+		if (cur-then>500)
+		{
+			keep_alive();
+		}
+
+		if ((cur-then)>ms)
 		{
 			LOG_ERROR("timed out while waiting for target %s",
 				Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
@@ -1736,7 +1844,7 @@ int target_wait_state(target_t *target, enum target_state state, int ms)
 	return ERROR_OK;
 }
 
-int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	int retval;
 	target_t *target = get_current_target(cmd_ctx);
@@ -1748,10 +1856,20 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 		return retval;
 	}
 
+	if (argc == 1)
+	{
+		int wait;
+		char *end;
+
+		wait = strtoul(args[0], &end, 0);
+		if (!*end && !wait)
+			return ERROR_OK;
+	}
+
 	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)
+static 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);
 
@@ -1762,7 +1880,7 @@ int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd,
 	return ERROR_OK;
 }
 
-int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	const Jim_Nvp *n;
 	enum target_reset_mode reset_mode = RESET_RUN;
@@ -1781,7 +1899,7 @@ int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **ar
 }
 
 
-int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	int retval;
 	target_t *target = get_current_target(cmd_ctx);
@@ -1800,7 +1918,7 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 	return retval;
 }
 
-int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	target_t *target = get_current_target(cmd_ctx);
 
@@ -1815,84 +1933,87 @@ int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 	return ERROR_OK;
 }
 
-int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static void handle_md_output(struct command_context_s *cmd_ctx,
+		struct target_s *target, u32 address, unsigned size,
+		unsigned count, const u8 *buffer)
 {
-	const int line_bytecnt = 32;
-	int count = 1;
-	int size = 4;
-	u32 address = 0;
-	int line_modulo;
-	int i;
+	const unsigned line_bytecnt = 32;
+	unsigned line_modulo = line_bytecnt / size;
 
-	char output[128];
-	int output_len;
+	char output[line_bytecnt * 4 + 1];
+	unsigned output_len = 0;
 
-	int retval;
+	const char *value_fmt;
+	switch (size) {
+	case 4: value_fmt = "%8.8x "; break;
+	case 2: value_fmt = "%4.2x "; break;
+	case 1: value_fmt = "%2.2x "; break;
+	default:
+		LOG_ERROR("invalid memory read size: %u", size);
+		exit(-1);
+	}
 
-	u8 *buffer;
-	target_t *target = get_current_target(cmd_ctx);
+	for (unsigned i = 0; i < count; i++)
+	{
+		if (i % line_modulo == 0)
+		{
+			output_len += snprintf(output + output_len,
+					sizeof(output) - output_len,
+					"0x%8.8x: ", address + (i*size));
+		}
 
-	if (argc < 1)
-		return ERROR_OK;
+		u32 value=0;
+		const u8 *value_ptr = buffer + i * size;
+		switch (size) {
+		case 4: value = target_buffer_get_u32(target, value_ptr); break;
+		case 2: value = target_buffer_get_u16(target, value_ptr); break;
+		case 1: value = *value_ptr;
+		}
+		output_len += snprintf(output + output_len,
+				sizeof(output) - output_len,
+				value_fmt, value);
 
-	if (argc == 2)
-		count = strtoul(args[1], NULL, 0);
+		if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
+		{
+			command_print(cmd_ctx, "%s", output);
+			output_len = 0;
+		}
+	}
+}
 
-	address = strtoul(args[0], NULL, 0);
+static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+	if (argc < 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	switch (cmd[2])
-	{
-		case 'w':
-			size = 4; line_modulo = line_bytecnt / 4;
-			break;
-		case 'h':
-			size = 2; line_modulo = line_bytecnt / 2;
-			break;
-		case 'b':
-			size = 1; line_modulo = line_bytecnt / 1;
-			break;
-		default:
-			return ERROR_OK;
+	unsigned size = 0;
+	switch (cmd[2]) {
+	case 'w': size = 4; break;
+	case 'h': size = 2; break;
+	case 'b': size = 1; break;
+	default: return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	buffer = calloc(count, size);
-	retval  = target->type->read_memory(target, address, size, count, buffer);
-	if (retval == ERROR_OK)
-	{
-		output_len = 0;
+	u32 address = strtoul(args[0], NULL, 0);
 
-		for (i = 0; i < count; i++)
-		{
-			if (i%line_modulo == 0)
-				output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
+	unsigned count = 1;
+	if (argc == 2)
+		count = strtoul(args[1], NULL, 0);
 
-			switch (size)
-			{
-				case 4:
-					output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
-					break;
-				case 2:
-					output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
-					break;
-				case 1:
-					output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
-					break;
-			}
+	u8 *buffer = calloc(count, size);
 
-			if ((i%line_modulo == line_modulo-1) || (i == count - 1))
-			{
-				command_print(cmd_ctx, output);
-				output_len = 0;
-			}
-		}
-	}
+	target_t *target = get_current_target(cmd_ctx);
+	int retval = target_read_memory(target,
+				address, size, count, buffer);
+	if (ERROR_OK == retval)
+		handle_md_output(cmd_ctx, target, address, size, count, buffer);
 
 	free(buffer);
 
 	return retval;
 }
 
-int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	u32 address = 0;
 	u32 value = 0;
@@ -1929,34 +2050,18 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 	}
 	for (i=0; i<count; i++)
 	{
-		int retval;
-		switch (wordsize)
-		{
-			case 4:
-				retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
-				break;
-			case 2:
-				retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
-				break;
-			case 1:
-				retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
-			break;
-			default:
-			return ERROR_OK;
-		}
-		keep_alive();
-
-		if (retval!=ERROR_OK)
-		{
+		int retval = target_write_memory(target,
+				address + i * wordsize, wordsize, 1, value_buf);
+		if (ERROR_OK != retval)
 			return retval;
-		}
+		keep_alive();
 	}
 
 	return ERROR_OK;
 
 }
 
-int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	u8 *buffer;
 	u32 buf_cnt;
@@ -2080,7 +2185,7 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
 
 }
 
-int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	fileio_t fileio;
 
@@ -2103,12 +2208,6 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char
 	address = strtoul(args[1], NULL, 0);
 	size = strtoul(args[2], NULL, 0);
 
-	if ((address & 3) || (size & 3))
-	{
-		command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
-		return ERROR_OK;
-	}
-
 	if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
 	{
 		return ERROR_OK;
@@ -2121,7 +2220,7 @@ 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;
 
-		retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
+		retval = target_read_buffer(target, address, this_run_size, buffer);
 		if (retval != ERROR_OK)
 		{
 			break;
@@ -2145,14 +2244,15 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char
 
 	if (retval==ERROR_OK)
 	{
-		command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
+		command_print(cmd_ctx, "dumped %lld byte in %s",
+				fileio.size, duration_text);
+		free(duration_text);
 	}
-	free(duration_text);
 
-	return ERROR_OK;
+	return retval;
 }
 
-int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
 {
 	u8 *buffer;
 	u32 buf_cnt;
@@ -2216,55 +2316,61 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
 			break;
 		}
 
-		/* 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 )
+		if (verify)
 		{
-			free(buffer);
-			break;
-		}
-
-		if( checksum != mem_checksum )
-		{
-			/* failed crc checksum, fall back to a binary compare */
-			u8 *data;
-
-			command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
+			/* calculate checksum of image */
+			image_calculate_checksum( buffer, buf_cnt, &checksum );
 
-			data = (u8*)malloc(buf_cnt);
-
-			/* Can we use 32bit word accesses? */
-			int size = 1;
-			int count = buf_cnt;
-			if ((count % 4) == 0)
+			retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
+			if( retval != ERROR_OK )
 			{
-				size *= 4;
-				count /= 4;
+				free(buffer);
+				break;
 			}
-			retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
-			if (retval == ERROR_OK)
+
+			if( checksum != mem_checksum )
 			{
-				int t;
-				for (t = 0; t < buf_cnt; t++)
+				/* failed crc checksum, fall back to a binary compare */
+				u8 *data;
+
+				command_print(cmd_ctx, "checksum mismatch - 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)
 				{
-					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);
-						retval=ERROR_FAIL;
-						goto done;
-					}
-					if ((t%16384)==0)
+					size *= 4;
+					count /= 4;
+				}
+				retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
+				if (retval == ERROR_OK)
+				{
+					u32 t;
+					for (t = 0; t < buf_cnt; t++)
 					{
-						keep_alive();
+						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);
+							retval=ERROR_FAIL;
+							goto done;
+						}
+						if ((t%16384)==0)
+						{
+							keep_alive();
+						}
 					}
 				}
-			}
 
-			free(data);
+				free(data);
+			}
+		} else
+		{
+			command_print(cmd_ctx, "address 0x%08x length 0x%08x", image.sections[i].base_address, buf_cnt);
 		}
 
 		free(buffer);
@@ -2289,7 +2395,17 @@ done:
 	return retval;
 }
 
-int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+	return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1);
+}
+
+static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+	return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
+}
+
+static int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	int retval;
 	target_t *target = get_current_target(cmd_ctx);
@@ -2330,7 +2446,8 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 		}
 		else
 		{
-			command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
+			command_print(cmd_ctx, "breakpoint added at address 0x%8.8lx",
+					strtoul(args[0], NULL, 0));
 		}
 	}
 	else
@@ -2341,7 +2458,7 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 	return ERROR_OK;
 }
 
-int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	target_t *target = get_current_target(cmd_ctx);
 
@@ -2351,7 +2468,7 @@ int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args
 	return ERROR_OK;
 }
 
-int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static 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;
@@ -2413,7 +2530,7 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 	return ERROR_OK;
 }
 
-int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	target_t *target = get_current_target(cmd_ctx);
 
@@ -2423,7 +2540,7 @@ 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)
+static 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);
@@ -2450,36 +2567,44 @@ int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args,
 	return retval;
 }
 
+static void writeData(FILE *f, const void *data, size_t len)
+{
+	size_t written = fwrite(data, len, 1, f);
+	if (written != len)
+		LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
+}
+
 static void writeLong(FILE *f, int l)
 {
 	int i;
 	for (i=0; i<4; i++)
 	{
 		char c=(l>>(i*8))&0xff;
-		fwrite(&c, 1, 1, f);
+		writeData(f, &c, 1);
 	}
 
 }
 
 static void writeString(FILE *f, char *s)
 {
-	fwrite(s, 1, strlen(s), f);
+	writeData(f, s, strlen(s));
 }
 
 /* Dump a gmon.out histogram file. */
-static void writeGmon(u32 *samples, int sampleNum, char *filename)
+static void writeGmon(u32 *samples, u32 sampleNum, char *filename)
 {
-	int i;
+	u32 i;
 	FILE *f=fopen(filename, "w");
 	if (f==NULL)
 		return;
-	fwrite("gmon", 1, 4, f);
+	writeString(f, "gmon");
 	writeLong(f, 0x00000001); /* Version */
 	writeLong(f, 0); /* padding */
 	writeLong(f, 0); /* padding */
 	writeLong(f, 0); /* padding */
 
-	fwrite("", 1, 1, f);  /* GMON_TAG_TIME_HIST */
+	u8 zero = 0;  /* GMON_TAG_TIME_HIST */
+	writeData(f, &zero, 1);
 
 	/* figure out bucket size */
 	u32 min=samples[0];
@@ -2498,8 +2623,8 @@ static void writeGmon(u32 *samples, int sampleNum, char *filename)
 
 	int addressSpace=(max-min+1);
 
-	static int const maxBuckets=256*1024; /* maximum buckets. */
-	int length=addressSpace;
+	static const u32 maxBuckets = 256 * 1024; /* maximum buckets. */
+	u32 length = addressSpace;
 	if (length > maxBuckets)
 	{
 		length=maxBuckets;
@@ -2528,9 +2653,7 @@ static void writeGmon(u32 *samples, int sampleNum, char *filename)
 	writeLong(f, 64000000); 	/* 64MHz */
 	writeString(f, "seconds");
 	for (i=0; i<(15-strlen("seconds")); i++)
-	{
-		fwrite("", 1, 1, f);	/* padding */
-	}
+		writeData(f, &zero, 1);
 	writeString(f, "s");
 
 	/*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
@@ -2550,7 +2673,7 @@ static void writeGmon(u32 *samples, int sampleNum, char *filename)
 			data[i*2+1]=(val>>8)&0xff;
 		}
 		free(buckets);
-		fwrite(data, 1, length*2, f);
+		writeData(f, data, length * 2);
 		free(data);
 	} else
 	{
@@ -2561,7 +2684,7 @@ static void writeGmon(u32 *samples, int sampleNum, char *filename)
 }
 
 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
-int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_profile_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;
@@ -2693,7 +2816,7 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		return JIM_ERR;
 	}
 
-	return 	target_mem2array(interp, target, argc,argv);
+	return 	target_mem2array(interp, target, argc-1, argv+1);
 }
 
 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
@@ -2706,32 +2829,33 @@ static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_
 	u32 v;
 	const char *varname;
 	u8 buffer[4096];
-	int  i, n, e, retval;
+	int  n, e, retval;
+	u32 i;
 
 	/* argv[1] = name of array to receive the data
 	 * argv[2] = desired width
 	 * argv[3] = memory address
 	 * argv[4] = count of times to read
 	 */
-	if (argc != 5) {
+	if (argc != 4) {
 		Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
 		return JIM_ERR;
 	}
-	varname = Jim_GetString(argv[1], &len);
+	varname = Jim_GetString(argv[0], &len);
 	/* given "foo" get space for worse case "foo(%d)" .. add 20 */
 
-	e = Jim_GetLong(interp, argv[2], &l);
+	e = Jim_GetLong(interp, argv[1], &l);
 	width = l;
 	if (e != JIM_OK) {
 		return e;
 	}
 
-	e = Jim_GetLong(interp, argv[3], &l);
+	e = Jim_GetLong(interp, argv[2], &l);
 	addr = l;
 	if (e != JIM_OK) {
 		return e;
 	}
-	e = Jim_GetLong(interp, argv[4], &l);
+	e = Jim_GetLong(interp, argv[3], &l);
 	len = l;
 	if (e != JIM_OK) {
 		return e;
@@ -2794,7 +2918,7 @@ static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_
 			count = (sizeof(buffer)/width);
 		}
 
-		retval = target->type->read_memory( target, addr, width, count, buffer );
+		retval = target_read_memory( target, addr, width, count, buffer );
 		if (retval != ERROR_OK) {
 			/* BOO !*/
 			LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
@@ -2874,7 +2998,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		return JIM_ERR;
 	}
 
-	return target_array2mem( interp,target, argc, argv );
+	return target_array2mem( interp,target, argc-1, argv+1 );
 }
 
 static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
@@ -2887,32 +3011,33 @@ static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_
 	u32 v;
 	const char *varname;
 	u8 buffer[4096];
-	int  i, n, e, retval;
+	int  n, e, retval;
+	u32 i;
 
 	/* argv[1] = name of array to get the data
 	 * argv[2] = desired width
 	 * argv[3] = memory address
 	 * argv[4] = count to write
 	 */
-	if (argc != 5) {
+	if (argc != 4) {
 		Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
 		return JIM_ERR;
 	}
-	varname = Jim_GetString(argv[1], &len);
+	varname = Jim_GetString(argv[0], &len);
 	/* given "foo" get space for worse case "foo(%d)" .. add 20 */
 
-	e = Jim_GetLong(interp, argv[2], &l);
+	e = Jim_GetLong(interp, argv[1], &l);
 	width = l;
 	if (e != JIM_OK) {
 		return e;
 	}
 
-	e = Jim_GetLong(interp, argv[3], &l);
+	e = Jim_GetLong(interp, argv[2], &l);
 	addr = l;
 	if (e != JIM_OK) {
 		return e;
 	}
-	e = Jim_GetLong(interp, argv[4], &l);
+	e = Jim_GetLong(interp, argv[3], &l);
 	len = l;
 	if (e != JIM_OK) {
 		return e;
@@ -2992,7 +3117,7 @@ static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_
 		}
 		len -= count;
 
-		retval = target->type->write_memory(target, addr, width, count, buffer);
+		retval = target_write_memory(target, addr, width, count, buffer);
 		if (retval != ERROR_OK) {
 			/* BOO !*/
 			LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
@@ -3037,7 +3162,7 @@ void target_handle_event( target_t *target, enum target_event e )
 			LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
 					   target->target_number,
 					   target->cmd_name,
-					   target->type->name,
+					   target_get_name(target),
 					   e,
 					   Jim_Nvp_value2name_simple( nvp_target_event, e )->name,
 					   Jim_GetString( teap->body, NULL ) );
@@ -3126,7 +3251,7 @@ static int target_configure( Jim_GetOptInfo *goi, target_t *target )
 					return JIM_ERR;
 				}
 			}
-			Jim_SetResultString( goi->interp, target->type->name, -1 );
+			Jim_SetResultString( goi->interp, target_get_name(target), -1 );
 			/* loop for more */
 			break;
 		case TCFG_EVENT:
@@ -3159,7 +3284,7 @@ static int target_configure( Jim_GetOptInfo *goi, target_t *target )
 				teap = target->event_action;
 				/* replace existing? */
 				while( teap ){
-					if( teap->event == n->value ){
+					if( teap->event == (enum target_event)n->value ){
 						break;
 					}
 					teap = teap->next;
@@ -3325,7 +3450,7 @@ static int target_configure( Jim_GetOptInfo *goi, target_t *target )
 				if( e != JIM_OK ){
 					return e;
 				}
-				tap = jtag_TapByJimObj( goi->interp, o );
+				tap = jtag_tap_by_jim_obj( goi->interp, o );
 				if( tap == NULL ){
 					return JIM_ERR;
 				}
@@ -3341,6 +3466,8 @@ static int target_configure( Jim_GetOptInfo *goi, target_t *target )
 			break;
 		}
 	} /* while( goi->argc ) */
+
+
 		/* done - we return */
 	return JIM_OK;
 }
@@ -3481,7 +3608,7 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 			break;
 		}
 		for( x = 0 ; x < c ; x++ ){
-			e = target->type->write_memory( target, a, b, 1, target_buf );
+			e = target_write_memory( target, a, b, 1, target_buf );
 			if( e != ERROR_OK ){
 				Jim_SetResult_sprintf( interp, "Error writing @ 0x%08x: %d\n", (int)(a), e );
 				return JIM_ERR;
@@ -3537,7 +3664,7 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 			if( y > 16 ){
 				y = 16;
 			}
-			e = target->type->read_memory( target, a, b, y / b, target_buf );
+			e = target_read_memory( target, a, b, y / b, target_buf );
 			if( e != ERROR_OK ){
 				Jim_SetResult_sprintf( interp, "error reading target @ 0x%08lx", (int)(a) );
 				return JIM_ERR;
@@ -3609,6 +3736,8 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 			Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
 			return JIM_ERR;
 		}
+		if (!target->tap->enabled)
+			goto err_tap_disabled;
 		e = target->type->examine( target );
 		if( e != ERROR_OK ){
 			Jim_SetResult_sprintf( interp, "examine-fails: %d", e );
@@ -3620,7 +3749,9 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 			Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
 			return JIM_ERR;
 		}
-		if( !(target->type->examined) ){
+		if (!target->tap->enabled)
+			goto err_tap_disabled;
+		if( !(target_was_examined(target)) ){
 			e = ERROR_TARGET_NOT_EXAMINED;
 		} else {
 			e = target->type->poll( target );
@@ -3647,6 +3778,8 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 		if( e != JIM_OK ){
 			return e;
 		}
+		if (!target->tap->enabled)
+			goto err_tap_disabled;
 		/* determine if we should halt or not. */
 		target->reset_halt = !!a;
 		/* When this happens - all workareas are invalid. */
@@ -3664,6 +3797,8 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 			Jim_WrongNumArgs( goi.interp, 0, argv, "halt [no parameters]");
 			return JIM_ERR;
 		}
+		if (!target->tap->enabled)
+			goto err_tap_disabled;
 		target->type->halt( target );
 		return JIM_OK;
 	case TS_CMD_WAITSTATE:
@@ -3681,6 +3816,8 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 		if( e != JIM_OK ){
 			return e;
 		}
+		if (!target->tap->enabled)
+			goto err_tap_disabled;
 		e = target_wait_state( target, n->value, a );
 		if( e != ERROR_OK ){
 			Jim_SetResult_sprintf( goi.interp,
@@ -3736,6 +3873,10 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 		return JIM_OK;
 	}
 	return JIM_ERR;
+
+err_tap_disabled:
+	Jim_SetResult_sprintf(interp, "[TAP is disabled]");
+	return JIM_ERR;
 }
 
 static int target_create( Jim_GetOptInfo *goi )
@@ -3839,6 +3980,13 @@ static int target_create( Jim_GetOptInfo *goi )
 	/* Do the rest as "configure" options */
 	goi->isconfigure = 1;
 	e = target_configure( goi, target);
+
+	if (target->tap == NULL)
+	{
+		Jim_SetResultString( interp, "-chain-position required when creating target", -1);
+		e=JIM_ERR;
+	}
+
 	if( e != JIM_OK ){
 		free( target->type );
 		free( target );
@@ -3909,7 +4057,7 @@ static int jim_target( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
 	};
 
 	LOG_DEBUG("Target command params:");
-	LOG_DEBUG(Jim_Debug_ArgvString( interp, argc, argv) );
+	LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
 
 	cmd_ctx = Jim_GetAssocData( interp, "context" );
 
@@ -4032,7 +4180,7 @@ static void free_fastload(void)
 
 
 
-int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	u8 *buffer;
 	u32 buf_cnt;
@@ -4168,7 +4316,7 @@ int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd,
 	return retval;
 }
 
-int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	if (argc>0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
@@ -4180,17 +4328,18 @@ int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char
 	int i;
 	int ms=timeval_ms();
 	int size=0;
+	int retval=ERROR_OK;
 	for (i=0; i<fastload_num;i++)
 	{
-		int retval;
 		target_t *target = get_current_target(cmd_ctx);
-		if ((retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data)) != ERROR_OK)
+		command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x", fastload[i].address, fastload[i].length);
+		if (retval==ERROR_OK)
 		{
-			return retval;
+			retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
 		}
 		size+=fastload[i].length;
 	}
 	int after=timeval_ms();
 	command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
-	return ERROR_OK;
+	return retval;
 }