X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=c2f479add0fe6818c84d16eebfb3d34e14a8eedb;hp=569633b75809e806bf0bd695ce206a7f7cfbc76c;hb=6f9aac189206328568866244f471b5f27bbb0c45;hpb=fb59d0fa55c2c0e48cd3b59e3102facabe61f0f3

diff --git a/src/target/target.c b/src/target/target.c
index 569633b758..c2f479add0 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -33,58 +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_test_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);
@@ -103,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[] =
 {
@@ -117,8 +101,10 @@ target_type_t *target_types[] =
 	&feroceon_target,
 	&xscale_target,
 	&cortexm3_target,
+	&cortexa8_target,
 	&arm11_target,
 	&mips_m4k_target,
+	&avr_target,
 	NULL,
 };
 
@@ -163,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" },
 
@@ -286,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);
@@ -295,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);
@@ -304,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;
 }
@@ -333,8 +319,34 @@ 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;
+
+	/* 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 */
+	unsigned num;
+	if (parse_uint(id, &num) != ERROR_OK)
+		return NULL;
+
+	for (target = all_targets; target; target = target->next) {
+		if (target->target_number == (int)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;
 
@@ -369,7 +381,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;
@@ -380,7 +392,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;
@@ -393,7 +405,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;
@@ -420,9 +432,18 @@ int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mo
 		return ERROR_FAIL;
 	}
 
+	/* disable polling during reset to make reset event scripts
+	 * more predictable, i.e. dr/irscan & pathmove in events will
+	 * not have JTAG operations injected into the middle of a sequence.
+	 */
+	int save_poll = target_continous_poll;
+	target_continous_poll = 0;
+
 	sprintf( buf, "ocd_process_reset %s", n->name );
 	retval = Jim_Eval( interp, buf );
 
+	target_continous_poll = save_poll;
+
 	if(retval != JIM_OK) {
 		Jim_PrintErrorMessage(interp);
 		return ERROR_FAIL;
@@ -448,10 +469,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:
  *
@@ -460,19 +486,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;
@@ -482,7 +514,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;
@@ -492,7 +524,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;
@@ -502,7 +534,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;
@@ -510,6 +542,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;
@@ -517,7 +628,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;
@@ -525,7 +636,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;
 		}
 
@@ -708,46 +819,56 @@ int target_call_event_callbacks(target_t *target, enum target_event event)
 	return ERROR_OK;
 }
 
-static int target_call_timer_callbacks_check_time(int checktime)
+static int target_timer_callback_periodic_restart(
+		target_timer_callback_t *cb, struct timeval *now)
 {
-	target_timer_callback_t *callback = target_timer_callbacks;
-	target_timer_callback_t *next_callback;
-	struct timeval now;
+	int time_ms = cb->time_ms;
+	cb->when.tv_usec = now->tv_usec + (time_ms % 1000) * 1000;
+	time_ms -= (time_ms % 1000);
+	cb->when.tv_sec = now->tv_sec + time_ms / 1000;
+	if (cb->when.tv_usec > 1000000)
+	{
+		cb->when.tv_usec = cb->when.tv_usec - 1000000;
+		cb->when.tv_sec += 1;
+	}
+	return ERROR_OK;
+}
 
+static int target_call_timer_callback(target_timer_callback_t *cb,
+		struct timeval *now)
+{
+	cb->callback(cb->priv);
+
+	if (cb->periodic)
+		return target_timer_callback_periodic_restart(cb, now);
+
+	return target_unregister_timer_callback(cb->callback, cb->priv);
+}
+
+static int target_call_timer_callbacks_check_time(int checktime)
+{
 	keep_alive();
 
+	struct timeval now;
 	gettimeofday(&now, NULL);
 
+	target_timer_callback_t *callback = target_timer_callbacks;
 	while (callback)
 	{
-		next_callback = callback->next;
+		// cleaning up may unregister and free this callback
+		target_timer_callback_t *next_callback = callback->next;
 
-		if ((!checktime&&callback->periodic)||
-				(((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
-						|| (now.tv_sec > callback->when.tv_sec)))
+		bool call_it = callback->callback &&
+			((!checktime && callback->periodic) ||
+			  now.tv_sec > callback->when.tv_sec ||
+			 (now.tv_sec == callback->when.tv_sec &&
+			  now.tv_usec >= callback->when.tv_usec));
+
+		if (call_it)
 		{
-			if(callback->callback != NULL)
-			{
-				callback->callback(callback->priv);
-				if (callback->periodic)
-				{
-					int time_ms = callback->time_ms;
-					callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
-					time_ms -= (time_ms % 1000);
-					callback->when.tv_sec = now.tv_sec + time_ms / 1000;
-					if (callback->when.tv_usec > 1000000)
-					{
-						callback->when.tv_usec = callback->when.tv_usec - 1000000;
-						callback->when.tv_sec += 1;
-					}
-				}
-				else
-				{
-					int retval;
-					if((retval = target_unregister_timer_callback(callback->callback, callback->priv)) != ERROR_OK)
-						return retval;
-				}
-			}
+			int retval = target_call_timer_callback(callback, &now);
+			if (retval != ERROR_OK)
+				return retval;
 		}
 
 		callback = next_callback;
@@ -843,7 +964,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);
@@ -877,7 +998,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;
 	}
 
@@ -964,12 +1085,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*/
@@ -979,18 +1104,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;
@@ -1011,7 +1136,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;
 		}
 
@@ -1023,7 +1148,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;
 	}
 
@@ -1039,12 +1164,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*/
@@ -1054,18 +1183,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;
@@ -1078,7 +1207,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;
@@ -1089,7 +1218,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;
 	}
 
@@ -1100,9 +1229,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;
@@ -1144,7 +1273,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;
@@ -1161,13 +1290,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)
 	{
@@ -1186,13 +1315,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)
 	{
@@ -1210,8 +1339,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;
@@ -1234,7 +1363,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;
@@ -1243,7 +1372,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);
 	}
@@ -1255,7 +1384,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;
@@ -1264,7 +1393,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);
 	}
@@ -1275,7 +1404,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;
@@ -1283,7 +1412,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);
 	}
@@ -1298,8 +1427,8 @@ int target_register_user_commands(struct command_context_s *cmd_ctx)
 
 	/* 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");
-	register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values");
+	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");
@@ -1344,56 +1473,56 @@ 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:
+		if (!target->tap->enabled) {
+			command_print(cmd_ctx,"Target: TAP %s is disabled, "
+					"can't be the current target\n",
+					target->tap->dotted_name);
+			return ERROR_FAIL;
+		}
+
 		cmd_ctx->current_target = target->target_number;
 		return ERROR_OK;
 	}
 DumpTargets:
 
 	target = all_targets;
-	command_print(cmd_ctx, "    CmdName    Type       Endian     AbsChainPos Name          State     ");
-	command_print(cmd_ctx, "--  ---------- ---------- ---------- ----------- ------------- ----------");
+	command_print(cmd_ctx, "    TargetName         Type       Endian TapName            State       ");
+	command_print(cmd_ctx, "--  ------------------ ---------- ------ ------------------ ------------");
 	while (target)
 	{
-		/* XX: abcdefghij abcdefghij abcdefghij abcdefghij */
-		command_print(cmd_ctx, "%2d: %-10s %-10s %-10s %10d %14s %s",
+		const char *state;
+		char marker = ' ';
+
+		if (target->tap->enabled)
+			state = Jim_Nvp_value2name_simple(nvp_target_state,
+					target->state)->name;
+		else
+			state = "tap-disabled";
+
+		if (cmd_ctx->current_target == target->target_number)
+			marker = '*';
+
+		/* keep columns lined up to match the headers above */
+		command_print(cmd_ctx, "%2d%c %-18s %-10s %-6s %-18s %s",
 					  target->target_number,
+					  marker,
 					  target->cmd_name,
-					  target->type->name,
-					  Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness )->name,
-					  target->tap->abs_chain_position,
+					  target_get_name(target),
+					  Jim_Nvp_value2name_simple(nvp_target_endian,
+								target->endianness)->name,
 					  target->tap->dotted_name,
-					  Jim_Nvp_value2name_simple( nvp_target_state, target->state )->name );
+					  state);
 		target = target->next;
 	}
 
@@ -1540,7 +1669,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;
@@ -1575,16 +1704,19 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
 	/* access a single register by its ordinal number */
 	if ((args[0][0] >= '0') && (args[0][0] <= '9'))
 	{
-		int num = strtoul(args[0], NULL, 0);
-		reg_cache_t *cache = target->reg_cache;
+		unsigned num;
+		int retval = parse_uint(args[0], &num);
+		if (ERROR_OK != retval)
+			return ERROR_COMMAND_SYNTAX_ERROR;
 
+		reg_cache_t *cache = target->reg_cache;
 		count = 0;
 		while(cache)
 		{
 			int i;
 			for (i = 0; i < cache->num_regs; i++)
 			{
-				if (count++ == num)
+				if (count++ == (int)num)
 				{
 					reg = &cache->reg_list[i];
 					break;
@@ -1651,16 +1783,18 @@ 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);
 
 	if (argc == 0)
 	{
-		if((retval = target_poll(target)) != ERROR_OK)
+		command_print(cmd_ctx, "background polling: %s",
+				target_continous_poll ?  "on" : "off");
+		if ((retval = target_poll(target)) != ERROR_OK)
 			return retval;
-		if((retval = target_arch_state(target)) != ERROR_OK)
+		if ((retval = target_arch_state(target)) != ERROR_OK)
 			return retval;
 
 	}
@@ -1686,23 +1820,25 @@ 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;
+	if (argc > 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	if (argc > 0)
+	unsigned ms = 5000;
+	if (1 == argc)
 	{
-		char *end;
-
-		ms = strtoul(args[0], &end, 0) * 1000;
-		if (*end)
+		int retval = parse_uint(args[0], &ms);
+		if (ERROR_OK != retval)
 		{
 			command_print(cmd_ctx, "usage: %s [seconds]", cmd);
-			return ERROR_OK;
+			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
+		// convert seconds (given) to milliseconds (needed)
+		ms *= 1000;
 	}
-	target_t *target = get_current_target(cmd_ctx);
 
+	target_t *target = get_current_target(cmd_ctx);
 	return target_wait_state(target, TARGET_HALTED, ms);
 }
 
@@ -1751,32 +1887,29 @@ 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);
-
 	LOG_DEBUG("-");
 
-	if ((retval = target_halt(target)) != ERROR_OK)
-	{
+	target_t *target = get_current_target(cmd_ctx);
+	int retval = target_halt(target);
+	if (ERROR_OK != retval)
 		return retval;
-	}
 
 	if (argc == 1)
 	{
-		int wait;
-		char *end;
-
-		wait = strtoul(args[0], &end, 0);
-		if (!*end && !wait)
+		unsigned wait;
+		retval = parse_uint(args[0], &wait);
+		if (ERROR_OK != retval)
+			return ERROR_COMMAND_SYNTAX_ERROR;
+		if (!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);
 
@@ -1787,13 +1920,15 @@ 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;
+	if (argc > 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	if (argc >= 1)
+	enum target_reset_mode reset_mode = RESET_RUN;
+	if (argc == 1)
 	{
+		const Jim_Nvp *n;
 		n = Jim_Nvp_name2value_simple( nvp_reset_modes, args[0] );
 		if( (n->name == NULL) || (n->value == RESET_UNKNOWN) ){
 			return ERROR_COMMAND_SYNTAX_ERROR;
@@ -1806,135 +1941,163 @@ 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);
+	if (argc > 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	target_handle_event( target, TARGET_EVENT_OLD_pre_resume );
+	target_t *target = get_current_target(cmd_ctx);
+	target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
 
-	if (argc == 0)
-		retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
-	else if (argc == 1)
-		retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
-	else
+	/* with no args, resume from current pc, addr = 0,
+	 * with one arguments, addr = args[0],
+	 * handle breakpoints, not debugging */
+	u32 addr = 0;
+	if (argc == 1)
 	{
-		retval = ERROR_COMMAND_SYNTAX_ERROR;
+		int retval = parse_u32(args[0], &addr);
+		if (ERROR_OK != retval)
+			return retval;
 	}
 
-	return retval;
+	return target_resume(target, 0, addr, 1, 0);
 }
 
-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);
+	if (argc > 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	LOG_DEBUG("-");
 
-	if (argc == 0)
-		return target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
-
+	/* with no args, step from current pc, addr = 0,
+	 * with one argument addr = args[0],
+	 * handle breakpoints, debugging */
+	u32 addr = 0;
 	if (argc == 1)
-		return target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
+	{
+		int retval = parse_u32(args[0], &addr);
+		if (ERROR_OK != retval)
+			return retval;
+	}
 
-	return ERROR_OK;
+	target_t *target = get_current_target(cmd_ctx);
+	return target->type->step(target, 0, addr, 1);
 }
 
-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;
+	int retval = parse_u32(args[0], &address);
+	if (ERROR_OK != retval)
+		return retval;
 
-		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)
+	{
+		retval = parse_uint(args[1], &count);
+		if (ERROR_OK != retval)
+			return retval;
+	}
 
-			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);
+	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;
-	int count = 1;
-	int i;
-	int wordsize;
-	target_t *target = get_current_target(cmd_ctx);
-	u8 value_buf[4];
-
 	 if ((argc < 2) || (argc > 3))
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	address = strtoul(args[0], NULL, 0);
-	value = strtoul(args[1], NULL, 0);
+	u32 address;
+	int retval = parse_u32(args[0], &address);
+	if (ERROR_OK != retval)
+		return retval;
+
+	u32 value;
+	retval = parse_u32(args[1], &value);
+	if (ERROR_OK != retval)
+		return retval;
+
+	unsigned count = 1;
 	if (argc == 3)
-		count = strtoul(args[2], NULL, 0);
+	{
+		retval = parse_uint(args[2], &count);
+		if (ERROR_OK != retval)
+			return retval;
+	}
 
+	target_t *target = get_current_target(cmd_ctx);
+	unsigned wordsize;
+	u8 value_buf[4];
 	switch (cmd[2])
 	{
 		case 'w':
@@ -1952,36 +2115,20 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 		default:
 			return ERROR_COMMAND_SYNTAX_ERROR;
 	}
-	for (i=0; i<count; i++)
+	for (unsigned 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)
-		{
+		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;
@@ -2105,7 +2252,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;
 
@@ -2128,12 +2275,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;
@@ -2146,7 +2287,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;
@@ -2170,14 +2311,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_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
+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;
@@ -2270,10 +2412,10 @@ int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char
 					size *= 4;
 					count /= 4;
 				}
-				retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
+				retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
 				if (retval == ERROR_OK)
 				{
-					int t;
+					u32 t;
 					for (t = 0; t < buf_cnt; t++)
 					{
 						if (data[t] != buffer[t])
@@ -2320,69 +2462,82 @@ done:
 	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(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1);
 }
 
-int handle_test_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)
 {
 	return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
 }
 
-int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_bp_command_list(struct command_context_s *cmd_ctx)
 {
-	int retval;
 	target_t *target = get_current_target(cmd_ctx);
-
-	if (argc == 0)
-	{
-		breakpoint_t *breakpoint = target->breakpoints;
-
-		while (breakpoint)
-		{
-			if (breakpoint->type == BKPT_SOFT)
-			{
-				char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
-				command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
-				free(buf);
-			}
-			else
-			{
-				command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
-			}
-			breakpoint = breakpoint->next;
-		}
-	}
-	else if (argc >= 2)
+	breakpoint_t *breakpoint = target->breakpoints;
+	while (breakpoint)
 	{
-		int hw = BKPT_SOFT;
-		u32 length = 0;
-
-		length = strtoul(args[1], NULL, 0);
-
-		if (argc >= 3)
-			if (strcmp(args[2], "hw") == 0)
-				hw = BKPT_HARD;
-
-		if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
+		if (breakpoint->type == BKPT_SOFT)
 		{
-			LOG_ERROR("Failure setting breakpoints");
+			char* buf = buf_to_str(breakpoint->orig_instr,
+					breakpoint->length, 16);
+			command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s",
+					breakpoint->address, breakpoint->length,
+					breakpoint->set, buf);
+			free(buf);
 		}
 		else
 		{
-			command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
+			command_print(cmd_ctx, "0x%8.8x, 0x%x, %i",
+					breakpoint->address, breakpoint->length, breakpoint->set);
 		}
+
+		breakpoint = breakpoint->next;
 	}
+	return ERROR_OK;
+}
+
+static int handle_bp_command_set(struct command_context_s *cmd_ctx,
+		u32 addr, u32 length, int hw)
+{
+	target_t *target = get_current_target(cmd_ctx);
+	int retval = breakpoint_add(target, addr, length, hw);
+	if (ERROR_OK == retval)
+		command_print(cmd_ctx, "breakpoint set at 0x%8.8x", addr);
 	else
+		LOG_ERROR("Failure setting breakpoint");
+	return retval;
+}
+
+static int handle_bp_command(struct command_context_s *cmd_ctx,
+		char *cmd, char **args, int argc)
+{
+	if (argc == 0)
+		return handle_bp_command_list(cmd_ctx);
+
+	if (argc < 2 || argc > 3)
 	{
 		command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	return ERROR_OK;
+	u32 addr = strtoul(args[0], NULL, 0);
+	u32 length = strtoul(args[1], NULL, 0);
+
+	int hw = BKPT_SOFT;
+	if (argc == 3)
+	{
+		if (strcmp(args[2], "hw") == 0)
+			hw = BKPT_HARD;
+		else
+			return ERROR_COMMAND_SYNTAX_ERROR;
+	}
+
+	return handle_bp_command_set(cmd_ctx, addr, length, hw);
 }
 
-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);
 
@@ -2392,7 +2547,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;
@@ -2454,73 +2609,79 @@ 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);
+	if (argc != 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	if (argc > 0)
-		watchpoint_remove(target, strtoul(args[0], NULL, 0));
+	target_t *target = get_current_target(cmd_ctx);
+	watchpoint_remove(target, strtoul(args[0], NULL, 0));
 
 	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;
 
+/**
+ * Translate a virtual address to a physical address.
+ *
+ * The low-level target implementation must have logged a detailed error
+ * which is forwarded to telnet/GDB session.
+ */
+static int handle_virt2phys_command(command_context_t *cmd_ctx,
+		char *cmd, char **args, int argc)
+{
 	if (argc != 1)
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
-	va = strtoul(args[0], NULL, 0);
 
-	retval = target->type->virt2phys(target, va, &pa);
+	target_t *target = get_current_target(cmd_ctx);
+	u32 va = strtoul(args[0], NULL, 0);
+	u32 pa;
+
+	int 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;
 }
 
+static void writeData(FILE *f, const void *data, size_t len)
+{
+	size_t written = fwrite(data, 1, len, 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];
@@ -2539,8 +2700,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;
@@ -2569,9 +2730,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) */
@@ -2591,7 +2750,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
 	{
@@ -2602,7 +2761,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;
@@ -2734,7 +2893,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)
@@ -2747,32 +2906,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;
@@ -2835,7 +2995,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);
@@ -2915,7 +3075,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)
@@ -2928,32 +3088,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;
@@ -3033,7 +3194,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);
@@ -3078,7 +3239,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 ) );
@@ -3167,7 +3328,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:
@@ -3200,7 +3361,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;
@@ -3310,7 +3471,7 @@ static int target_configure( Jim_GetOptInfo *goi, target_t *target )
 					goto no_params;
 				}
 			}
-			Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_size ) );
+			Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
 			/* loop for more e*/
 			break;
 
@@ -3366,7 +3527,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;
 				}
@@ -3524,7 +3685,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;
@@ -3580,7 +3741,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;
@@ -3652,6 +3813,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 );
@@ -3663,7 +3826,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 );
@@ -3690,6 +3855,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. */
@@ -3707,6 +3874,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:
@@ -3724,6 +3893,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,
@@ -3779,6 +3950,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 )
@@ -3959,7 +4134,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" );
 
@@ -4082,7 +4257,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;
@@ -4218,7 +4393,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;