X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=a282aab6ad908919c9307b981022267aa616d176;hp=f1b292ae022e191051b3f02a65b662df476d3109;hb=f1f8d9a6c9b1fd35d79627b568faa2409f13311f;hpb=321aa6aa8fe9f6c07649776722a341bbfda028ee

diff --git a/src/target/target.c b/src/target/target.c
index f1b292ae02..a282aab6ad 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -58,6 +58,7 @@ extern struct target_type arm720t_target;
 extern struct target_type arm9tdmi_target;
 extern struct target_type arm920t_target;
 extern struct target_type arm966e_target;
+extern struct target_type arm946e_target;
 extern struct target_type arm926ejs_target;
 extern struct target_type fa526_target;
 extern struct target_type feroceon_target;
@@ -70,6 +71,7 @@ extern struct target_type mips_m4k_target;
 extern struct target_type avr_target;
 extern struct target_type dsp563xx_target;
 extern struct target_type testee_target;
+extern struct target_type avr32_ap7k_target;
 
 static struct target_type *target_types[] =
 {
@@ -78,6 +80,7 @@ static struct target_type *target_types[] =
 	&arm920t_target,
 	&arm720t_target,
 	&arm966e_target,
+	&arm946e_target,
 	&arm926ejs_target,
 	&fa526_target,
 	&feroceon_target,
@@ -90,12 +93,14 @@ static struct target_type *target_types[] =
 	&avr_target,
 	&dsp563xx_target,
 	&testee_target,
+	&avr32_ap7k_target,
 	NULL,
 };
 
 struct target *all_targets = NULL;
 static struct target_event_callback *target_event_callbacks = NULL;
 static struct target_timer_callback *target_timer_callbacks = NULL;
+static const int polling_interval = 100;
 
 static const Jim_Nvp nvp_assert[] = {
 	{ .name = "assert", NVP_ASSERT },
@@ -474,19 +479,6 @@ int target_resume(struct target *target, int current, uint32_t address, int hand
 	if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
 		return retval;
 
-	/* Invalidate any cached protect/erase/... flash status, since
-	 * almost all targets will now be able modify the flash by
-	 * themselves.  We want flash drivers and infrastructure to
-	 * be able to rely on (non-invalidated) cached state.
-	 *
-	 * For now we require that algorithms provided by OpenOCD are
-	 * used only by code which properly maintains that  cached state.
-	 * state
-	 *
-	 * REVISIT do the same for NAND ; maybe other flash flavors too...
-	 */
-		if (!target->running_alg)
-		nor_resume(target);
 	return retval;
 }
 
@@ -515,7 +507,8 @@ static int target_process_reset(struct command_context *cmd_ctx, enum target_res
 	jtag_poll_set_enabled(save_poll);
 
 	if (retval != JIM_OK) {
-		Jim_PrintErrorMessage(cmd_ctx->interp);
+		Jim_MakeErrorMessage(cmd_ctx->interp);
+		command_print(NULL,"%s\n", Jim_GetString(Jim_GetResult(cmd_ctx->interp), NULL));
 		return ERROR_FAIL;
 	}
 
@@ -875,7 +868,7 @@ static int target_init(struct command_context *cmd_ctx)
 		return retval;
 
 	retval = target_register_timer_callback(&handle_target,
-			100, 1, cmd_ctx->interp);
+			polling_interval, 1, cmd_ctx->interp);
 	if (ERROR_OK != retval)
 		return retval;
 
@@ -1111,7 +1104,7 @@ int target_call_timer_callbacks_now(void)
 	return target_call_timer_callbacks_check_time(0);
 }
 
-int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
+int target_alloc_working_area_try(struct target *target, uint32_t size, struct working_area **area)
 {
 	struct working_area *c = target->working_areas;
 	struct working_area *new_wa = NULL;
@@ -1189,8 +1182,6 @@ int target_alloc_working_area(struct target *target, uint32_t size, struct worki
 
 		if (free_size < size)
 		{
-			LOG_WARNING("not enough working area available(requested %u, free %u)",
-				    (unsigned)(size), (unsigned)(free_size));
 			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 		}
 
@@ -1231,6 +1222,19 @@ int target_alloc_working_area(struct target *target, uint32_t size, struct worki
 	return ERROR_OK;
 }
 
+int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
+{
+	int retval;
+
+	retval = target_alloc_working_area_try(target, size, area);
+	if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
+	{
+		LOG_WARNING("not enough working area available(requested %u)", (unsigned)(size));
+	}
+	return retval;
+
+}
+
 static int target_free_working_area_restore(struct target *target, struct working_area *area, int restore)
 {
 	if (area->free)
@@ -1802,6 +1806,9 @@ static int sense_handler(void)
 	return ERROR_OK;
 }
 
+static int backoff_times = 0;
+static int backoff_count = 0;
+
 /* process target state changes */
 static int handle_target(void *priv)
 {
@@ -1864,6 +1871,14 @@ static int handle_target(void *priv)
 		recursive = 0;
 	}
 
+	if (backoff_times > backoff_count)
+	{
+		/* do not poll this time as we failed previously */
+		backoff_count++;
+		return ERROR_OK;
+	}
+	backoff_count = 0;
+
 	/* Poll targets for state changes unless that's globally disabled.
 	 * Skip targets that are currently disabled.
 	 */
@@ -1880,17 +1895,26 @@ static int handle_target(void *priv)
 			/* polling may fail silently until the target has been examined */
 			if ((retval = target_poll(target)) != ERROR_OK)
 			{
-				/* FIX!!!!! If we add a LOG_INFO() here to output a line in GDB
-				 * *why* we are aborting GDB, then we'll spam telnet when the
-				 * poll is failing persistently.
-				 *
-				 * If we could implement an event that detected the
-				 * target going from non-pollable to pollable, we could issue
-				 * an error only upon the transition.
+				/* 100ms polling interval. Increase interval between polling up to 5000ms */
+				if (backoff_times * polling_interval < 5000)
+				{
+					backoff_times *= 2;
+					backoff_times++;
+				}
+				LOG_USER("Polling target failed, GDB will be halted. Polling again in %dms", backoff_times * polling_interval);
+
+				/* Tell GDB to halt the debugger. This allows the user to
+				 * run monitor commands to handle the situation.
 				 */
 				target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
 				return retval;
 			}
+			/* Since we succeeded, we reset backoff count */
+			if (backoff_times > 0)
+			{
+				LOG_USER("Polling succeeded again");
+			}
+			backoff_times = 0;
 		}
 	}
 
@@ -2137,11 +2161,11 @@ COMMAND_HANDLER(handle_halt_command)
 
 	if (CMD_ARGC == 1)
 	{
-		unsigned wait;
-		retval = parse_uint(CMD_ARGV[0], &wait);
+		unsigned wait_local;
+		retval = parse_uint(CMD_ARGV[0], &wait_local);
 		if (ERROR_OK != retval)
 			return ERROR_COMMAND_SYNTAX_ERROR;
-		if (!wait)
+		if (!wait_local)
 			return ERROR_OK;
 	}
 
@@ -2380,7 +2404,7 @@ static int target_fill_mem(struct target *target,
 		{
 			current = chunk_size;
 		}
-		int retval = fn(target, address + x * data_size, data_size, current, target_buf);
+		retval = fn(target, address + x * data_size, data_size, current, target_buf);
 		if (retval != ERROR_OK)
 		{
 			break;
@@ -2562,7 +2586,7 @@ COMMAND_HANDLER(handle_load_image_command)
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
 	{
 		command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
-				"in %fs (%0.3f kb/s)", image_size,
+				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 	}
 
@@ -2575,33 +2599,25 @@ COMMAND_HANDLER(handle_load_image_command)
 COMMAND_HANDLER(handle_dump_image_command)
 {
 	struct fileio fileio;
-
 	uint8_t buffer[560];
-	int retvaltemp;
-
-
+	int retval, retvaltemp;
+	uint32_t address, size;
+	struct duration bench;
 	struct target *target = get_current_target(CMD_CTX);
 
 	if (CMD_ARGC != 3)
-	{
-		command_print(CMD_CTX, "usage: dump_image <filename> <address> <size>");
-		return ERROR_OK;
-	}
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	uint32_t address;
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], address);
-	uint32_t size;
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], size);
 
-	if (fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
-	{
-		return ERROR_OK;
-	}
+	retval = fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY);
+	if (retval != ERROR_OK)
+		return retval;
 
-	struct duration bench;
 	duration_start(&bench);
 
-	int retval = ERROR_OK;
+	retval = ERROR_OK;
 	while (size > 0)
 	{
 		size_t size_written;
@@ -2622,16 +2638,20 @@ COMMAND_HANDLER(handle_dump_image_command)
 		address += this_run_size;
 	}
 
-	if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
-		return retvaltemp;
-
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
 	{
+		int filesize;
+		retval = fileio_size(&fileio, &filesize);
+		if (retval != ERROR_OK)
+			return retval;
 		command_print(CMD_CTX,
-				"dumped %ld bytes in %fs (%0.3f kb/s)", (long)fileio.size,
-				duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
+				"dumped %ld bytes in %fs (%0.3f KiB/s)", (long)filesize,
+				duration_elapsed(&bench), duration_kbps(&bench, filesize));
 	}
 
+	if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
+		return retvaltemp;
+
 	return retval;
 }
 
@@ -2684,6 +2704,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 	}
 
 	image_size = 0x0;
+	int diffs = 0;
 	retval = ERROR_OK;
 	for (i = 0; i < image.num_sections; i++)
 	{
@@ -2704,7 +2725,12 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 		if (verify)
 		{
 			/* calculate checksum of image */
-			image_calculate_checksum(buffer, buf_cnt, &checksum);
+			retval = image_calculate_checksum(buffer, buf_cnt, &checksum);
+			if (retval != ERROR_OK)
+			{
+				free(buffer);
+				break;
+			}
 
 			retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
 			if (retval != ERROR_OK)
@@ -2718,7 +2744,10 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 				/* failed crc checksum, fall back to a binary compare */
 				uint8_t *data;
 
-				command_print(CMD_CTX, "checksum mismatch - attempting binary compare");
+				if (diffs == 0)
+				{
+					LOG_ERROR("checksum mismatch - attempting binary compare");
+				}
 
 				data = (uint8_t*)malloc(buf_cnt);
 
@@ -2739,22 +2768,22 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 						if (data[t] != buffer[t])
 						{
 							command_print(CMD_CTX,
-										  "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n",
+										  "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
+										  diffs,
 										  (unsigned)(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();
+							if (diffs++ >= 127)
+							{
+								command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
+								free(data);
+								free(buffer);
+								goto done;
+							}
 						}
+						keep_alive();
 					}
 				}
-
 				free(data);
 			}
 		} else
@@ -2767,11 +2796,19 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 		free(buffer);
 		image_size += buf_cnt;
 	}
+	if (diffs > 0)
+	{
+		command_print(CMD_CTX, "No more differences found.");
+	}
 done:
+	if (diffs > 0)
+	{
+		retval = ERROR_FAIL;
+	}
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
 	{
 		command_print(CMD_CTX, "verified %" PRIu32 " bytes "
-				"in %fs (%0.3f kb/s)", image_size,
+				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 	}
 
@@ -3059,8 +3096,8 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam
 		long long a = address-min;
 		long long b = length-1;
 		long long c = addressSpace-1;
-		int index = (a*b)/c; /* danger!!!! int32 overflows */
-		buckets[index]++;
+		int index_t = (a*b)/c; /* danger!!!! int32 overflows */
+		buckets[index_t]++;
 	}
 
 	/* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
@@ -3225,12 +3262,9 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	struct command_context *context;
 	struct target *target;
 
-	context = Jim_GetAssocData(interp, "context");
-	if (context == NULL)
-	{
-		LOG_ERROR("mem2array: no command context");
-		return JIM_ERR;
-	}
+	context = current_command_context(interp);
+	assert (context != NULL);
+
 	target = get_current_target(context);
 	if (target == NULL)
 	{
@@ -3421,11 +3455,9 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	struct command_context *context;
 	struct target *target;
 
-	context = Jim_GetAssocData(interp, "context");
-	if (context == NULL) {
-		LOG_ERROR("array2mem: no command context");
-		return JIM_ERR;
-	}
+	context = current_command_context(interp);
+	assert (context != NULL);
+
 	target = get_current_target(context);
 	if (target == NULL) {
 		LOG_ERROR("array2mem: no current target");
@@ -3580,22 +3612,6 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
 	return JIM_OK;
 }
 
-void target_all_handle_event(enum target_event e)
-{
-	struct target *target;
-
-	LOG_DEBUG("**all*targets: event: %d, %s",
-			   (int)e,
-			   Jim_Nvp_value2name_simple(nvp_target_event, e)->name);
-
-	target = all_targets;
-	while (target) {
-		target_handle_event(target, e);
-		target = target->next;
-	}
-}
-
-
 /* FIX? should we propagate errors here rather than printing them
  * and continuing?
  */
@@ -3614,7 +3630,8 @@ void target_handle_event(struct target *target, enum target_event e)
 					   Jim_GetString(teap->body, NULL));
 			if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK)
 			{
-				Jim_PrintErrorMessage(teap->interp);
+				Jim_MakeErrorMessage(teap->interp);
+				command_print(NULL,"%s\n", Jim_GetString(Jim_GetResult(teap->interp), NULL));
 			}
 		}
 	}
@@ -3696,7 +3713,7 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 		case TCFG_TYPE:
 			/* not setable */
 			if (goi->isconfigure) {
-				Jim_SetResult_sprintf(goi->interp,
+				Jim_SetResultFormatted(goi->interp,
 						"not settable: %s", n->name);
 				return JIM_ERR;
 			} else {
@@ -3889,7 +3906,7 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 		case TCFG_VARIANT:
 			if (goi->isconfigure) {
 				if (goi->argc < 1) {
-					Jim_SetResult_sprintf(goi->interp,
+					Jim_SetResultFormatted(goi->interp,
 										   "%s ?STRING?",
 										   n->name);
 					return JIM_ERR;
@@ -3909,14 +3926,14 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 			break;
 		case TCFG_CHAIN_POSITION:
 			if (goi->isconfigure) {
-				Jim_Obj *o;
+				Jim_Obj *o_t;
 				struct jtag_tap *tap;
 				target_free_all_working_areas(target);
-				e = Jim_GetOpt_Obj(goi, &o);
+				e = Jim_GetOpt_Obj(goi, &o_t);
 				if (e != JIM_OK) {
 					return e;
 				}
-				tap = jtag_tap_by_jim_obj(goi->interp, o);
+				tap = jtag_tap_by_jim_obj(goi->interp, o_t);
 				if (tap == NULL) {
 					return JIM_ERR;
 				}
@@ -3965,19 +3982,30 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	Jim_GetOptInfo goi;
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
-	/* danger! goi.argc will be modified below! */
-	argc = goi.argc;
-
-	if (argc != 2 && argc != 3)
+	if (goi.argc < 2 || goi.argc > 4)
 	{
-		Jim_SetResult_sprintf(goi.interp,
-				"usage: %s <address> <data> [<count>]", cmd_name);
+		Jim_SetResultFormatted(goi.interp,
+				"usage: %s [phys] <address> <data> [<count>]", cmd_name);
 		return JIM_ERR;
 	}
 
+	target_write_fn fn;
+	fn = target_write_memory_fast;
+
+	int e;
+	if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0)
+	{
+		/* consume it */
+		struct Jim_Obj *obj;
+		e = Jim_GetOpt_Obj(&goi, &obj);
+		if (e != JIM_OK)
+			return e;
+
+		fn = target_write_phys_memory;
+	}
 
 	jim_wide a;
-	int e = Jim_GetOpt_Wide(&goi, &a);
+	e = Jim_GetOpt_Wide(&goi, &a);
 	if (e != JIM_OK)
 		return e;
 
@@ -3987,13 +4015,19 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		return e;
 
 	jim_wide c = 1;
-	if (argc == 3)
+	if (goi.argc == 1)
 	{
 		e = Jim_GetOpt_Wide(&goi, &c);
 		if (e != JIM_OK)
 			return e;
 	}
 
+	/* all args must be consumed */
+	if (goi.argc != 0)
+	{
+		return JIM_ERR;
+	}
+
 	struct target *target = Jim_CmdPrivData(goi.interp);
 	unsigned data_size;
 	if (strcasecmp(cmd_name, "mww") == 0) {
@@ -4009,7 +4043,7 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		return JIM_ERR;
 	}
 
-	return (target_fill_mem(target, a, target_write_memory_fast, data_size, b, c) == ERROR_OK) ? JIM_OK : JIM_ERR;
+	return (target_fill_mem(target, a, fn, data_size, b, c) == ERROR_OK) ? JIM_OK : JIM_ERR;
 }
 
 static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
@@ -4019,23 +4053,36 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	Jim_GetOptInfo goi;
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
-	/* danger! goi.argc will be modified below! */
-	argc = goi.argc;
-
-	if ((argc != 1) && (argc != 2))
+	if ((goi.argc < 1) || (goi.argc > 3))
 	{
-		Jim_SetResult_sprintf(goi.interp,
-				"usage: %s <address> [<count>]", cmd_name);
+		Jim_SetResultFormatted(goi.interp,
+				"usage: %s [phys] <address> [<count>]", cmd_name);
 		return JIM_ERR;
 	}
 
+	int (*fn)(struct target *target,
+			uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+	fn=target_read_memory;
+
+	int e;
+	if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0)
+	{
+		/* consume it */
+		struct Jim_Obj *obj;
+		e = Jim_GetOpt_Obj(&goi, &obj);
+		if (e != JIM_OK)
+			return e;
+
+		fn=target_read_phys_memory;
+	}
+
 	jim_wide a;
-	int e = Jim_GetOpt_Wide(&goi, &a);
+	e = Jim_GetOpt_Wide(&goi, &a);
 	if (e != JIM_OK) {
 		return JIM_ERR;
 	}
 	jim_wide c;
-	if (argc == 2) {
+	if (goi.argc == 1) {
 		e = Jim_GetOpt_Wide(&goi, &c);
 		if (e != JIM_OK) {
 			return JIM_ERR;
@@ -4043,6 +4090,13 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	} else {
 		c = 1;
 	}
+
+	/* all args must be consumed */
+	if (goi.argc != 0)
+	{
+		return JIM_ERR;
+	}
+
 	jim_wide b = 1; /* shut up gcc */
 	if (strcasecmp(cmd_name, "mdw") == 0)
 		b = 4;
@@ -4066,42 +4120,44 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		if (y > 16) {
 			y = 16;
 		}
-		e = target_read_memory(target, a, b, y / b, target_buf);
+		e = fn(target, a, b, y / b, target_buf);
 		if (e != ERROR_OK) {
-			Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
+			char tmp[10];
+			snprintf(tmp, sizeof(tmp), "%08lx", (long)a);
+			Jim_SetResultFormatted(interp, "error reading target @ 0x%s", tmp);
 			return JIM_ERR;
 		}
 
-		Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a));
+		command_print(NULL, "0x%08x ", (int)(a));
 		switch (b) {
 		case 4:
 			for (x = 0; x < 16 && x < y; x += 4)
 			{
 				z = target_buffer_get_u32(target, &(target_buf[ x ]));
-				Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
+				command_print(NULL, "%08x ", (int)(z));
 			}
 			for (; (x < 16) ; x += 4) {
-				Jim_fprintf(interp, interp->cookie_stdout, "         ");
+				command_print(NULL, "         ");
 			}
 			break;
 		case 2:
 			for (x = 0; x < 16 && x < y; x += 2)
 			{
 				z = target_buffer_get_u16(target, &(target_buf[ x ]));
-				Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
+				command_print(NULL, "%04x ", (int)(z));
 			}
 			for (; (x < 16) ; x += 2) {
-				Jim_fprintf(interp, interp->cookie_stdout, "     ");
+				command_print(NULL, "     ");
 			}
 			break;
 		case 1:
 		default:
 			for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
 				z = target_buffer_get_u8(target, &(target_buf[ x ]));
-				Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
+				command_print(NULL, "%02x ", (int)(z));
 			}
 			for (; (x < 16) ; x += 1) {
-				Jim_fprintf(interp, interp->cookie_stdout, "   ");
+				command_print(NULL, "   ");
 			}
 			break;
 		}
@@ -4123,7 +4179,7 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		/* terminate */
 		target_buf[16] = 0;
 		/* print - with a newline */
-		Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
+		command_print(NULL, "%s\n", target_buf);
 		/* NEXT... */
 		c -= 16;
 		a += 16;
@@ -4147,7 +4203,7 @@ static int jim_target_array2mem(Jim_Interp *interp,
 
 static int jim_target_tap_disabled(Jim_Interp *interp)
 {
-	Jim_SetResult_sprintf(interp, "[TAP is disabled]");
+	Jim_SetResultFormatted(interp, "[TAP is disabled]");
 	return JIM_ERR;
 }
 
@@ -4165,7 +4221,9 @@ static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv
 	int e = target->type->examine(target);
 	if (e != ERROR_OK)
 	{
-		Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
+		Jim_Obj *eObj = Jim_NewIntObj(interp, e);
+		Jim_SetResultFormatted(interp, "examine-fails: %#s", eObj);
+		Jim_FreeNewObj(interp, eObj);
 		return JIM_ERR;
 	}
 	return JIM_OK;
@@ -4205,7 +4263,9 @@ static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	}
 	if (e != ERROR_OK)
 	{
-		Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
+		Jim_Obj *eObj = Jim_NewIntObj(interp, e);
+		Jim_SetResultFormatted(interp, "poll-fails: %#s", eObj);
+		Jim_FreeNewObj(interp, eObj);
 		return JIM_ERR;
 	}
 	return JIM_OK;
@@ -4246,7 +4306,7 @@ static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	}
 	if (!target->type->assert_reset || !target->type->deassert_reset)
 	{
-		Jim_SetResult_sprintf(interp,
+		Jim_SetResultFormatted(interp,
 				"No target-specific reset for %s",
 				target_name(target));
 		return JIM_ERR;
@@ -4287,7 +4347,7 @@ static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *a
 	if (goi.argc != 2)
 	{
 		const char *cmd_name = Jim_GetString(argv[0], NULL);
-		Jim_SetResult_sprintf(goi.interp,
+		Jim_SetResultFormatted(goi.interp,
 				"%s <state_name> <timeout_in_msec>", cmd_name);
 		return JIM_ERR;
 	}
@@ -4310,10 +4370,12 @@ static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *a
 	e = target_wait_state(target, n->value, a);
 	if (e != ERROR_OK)
 	{
-		Jim_SetResult_sprintf(goi.interp,
-				"target: %s wait %s fails (%d) %s",
+		Jim_Obj *eObj = Jim_NewIntObj(interp, e);
+		Jim_SetResultFormatted(goi.interp,
+				"target: %s wait %s fails (%#s) %s",
 				target_name(target), n->name,
-				e, target_strerror_safe(e));
+				eObj, target_strerror_safe(e));
+		Jim_FreeNewObj(interp, eObj);
 		return JIM_ERR;
 	}
 	return JIM_OK;
@@ -4323,7 +4385,9 @@ static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *a
  */
 static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	struct command_context *cmd_ctx = Jim_GetAssocData(interp, "context");
+	struct command_context *cmd_ctx = current_command_context(interp);
+	assert (cmd_ctx != NULL);
+
 	struct target *target = Jim_CmdPrivData(interp);
 	struct target_event_action *teap = target->event_action;
 	command_print(cmd_ctx, "Event actions for target (%d) %s\n",
@@ -4360,7 +4424,7 @@ static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const
 	if (goi.argc != 1)
 	{
 		const char *cmd_name = Jim_GetString(argv[0], NULL);
-		Jim_SetResult_sprintf(goi.interp, "%s <eventname>", cmd_name);
+		Jim_SetResultFormatted(goi.interp, "%s <eventname>", cmd_name);
 		return JIM_ERR;
 	}
 	Jim_Nvp *n;
@@ -4517,7 +4581,9 @@ static int target_create(Jim_GetOptInfo *goi)
 	struct target *target;
 	struct command_context *cmd_ctx;
 
-	cmd_ctx = Jim_GetAssocData(goi->interp, "context");
+	cmd_ctx = current_command_context(goi->interp);
+	assert (cmd_ctx != NULL);
+
 	if (goi->argc < 3) {
 		Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
 		return JIM_ERR;
@@ -4529,7 +4595,7 @@ static int target_create(Jim_GetOptInfo *goi)
 	cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
 	if (cmd) {
 		cp = Jim_GetString(new_cmd, NULL);
-		Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
+		Jim_SetResultFormatted(goi->interp, "Command/target: %s Exists", cp);
 		return JIM_ERR;
 	}
 
@@ -4544,7 +4610,7 @@ static int target_create(Jim_GetOptInfo *goi)
 		}
 	}
 	if (target_types[x] == NULL) {
-		Jim_SetResult_sprintf(goi->interp, "Unknown target type %s, try one of ", cp);
+		Jim_SetResultFormatted(goi->interp, "Unknown target type %s, try one of ", cp);
 		for (x = 0 ; target_types[x] ; x++) {
 			if (target_types[x + 1]) {
 				Jim_AppendStrings(goi->interp,
@@ -4691,7 +4757,9 @@ static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv
 		Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 		return JIM_ERR;
 	}
-	struct command_context *cmd_ctx = Jim_GetAssocData(interp, "context");
+	struct command_context *cmd_ctx = current_command_context(interp);
+	assert (cmd_ctx != NULL);
+
 	Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
 	return JIM_OK;
 }
@@ -4752,7 +4820,7 @@ static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	LOG_WARNING("don't use numbers as target identifiers; use names");
 	if (goi.argc != 1)
 	{
-		Jim_SetResult_sprintf(goi.interp, "usage: target number <number>");
+		Jim_SetResultFormatted(goi.interp, "usage: target number <number>");
 		return JIM_ERR;
 	}
 	jim_wide w;
@@ -4769,8 +4837,12 @@ static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		Jim_SetResultString(goi.interp, target_name(target), -1);
 		return JIM_OK;
 	}
-	Jim_SetResult_sprintf(goi.interp,
-			"Target: number %d does not exist", (int)(w));
+	{
+		Jim_Obj *wObj = Jim_NewIntObj(goi.interp, w);
+		Jim_SetResultFormatted(goi.interp,
+			"Target: number %#s does not exist", wObj);
+		Jim_FreeNewObj(interp, wObj);
+	}
 	return JIM_ERR;
 }
 
@@ -4966,7 +5038,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
 	{
 		command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
-				"in %fs (%0.3f kb/s)", image_size, 
+				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 
 		command_print(CMD_CTX,
@@ -5238,7 +5310,7 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.usage = "filename [offset [type]]",
 	},
 	{
-		.name = "ocd_mem2array",
+		.name = "mem2array",
 		.mode = COMMAND_EXEC,
 		.jim_handler = jim_mem2array,
 		.help = "read 8/16/32 bit memory and return as a TCL array "
@@ -5246,7 +5318,7 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.usage = "arrayname bitwidth address count",
 	},
 	{
-		.name = "ocd_array2mem",
+		.name = "array2mem",
 		.mode = COMMAND_EXEC,
 		.jim_handler = jim_array2mem,
 		.help = "convert a TCL array to memory locations "