helper/command: change prototype of command_print/command_print_sameline

To prepare for handling TCL return values consistently, all calls
to command_print/command_print_sameline should switch to CMD as
first parameter.

Change prototype of command_print() and command_print_sameline()
to pass CMD instead of CMD_CTX.
Since the first parameter is currently not used, the change can be
done though scripts without manual coding.
This patch is created using the command:
	sed -i PATTERN $(find src/ doc/ -type f)
with all the following patters:
	's/\(command_print(cmd\)->ctx,/\1,/'
	's/\(command_print(CMD\)_CTX,/\1,/'
	's/\(command_print(struct command_\)context \*context,/\1invocation *cmd,/'
	's/\(command_print_sameline(cmd\)->ctx,/\1,/'
	's/\(command_print_sameline(CMD\)_CTX,/\1,/'
	's/\(command_print_sameline(struct command_\)context \*context,/\1invocation *cmd,/'

This change is inspired by http://openocd.zylin.com/1815 from Paul
Fertser but is now done through scripting.

Change-Id: I3386d8f96cdc477e7a2308dd18269de3bed04385
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Signed-off-by: Paul Fertser <fercerpav@gmail.com>
Reviewed-on: http://openocd.zylin.com/5081
Tested-by: jenkins
Reviewed-by: Tomas Vanek <vanekt@fbl.cz>

105 files changed, 963 insertions, 963 deletions

diff --git a/doc/manual/primer/commands.txt b/doc/manual/primer/commands.txt
index a626f56..8ea2282 100644
--- a/doc/manual/primer/commands.txt
+++ b/doc/manual/primer/commands.txt
@@ -16,7 +16,7 @@ COMMAND_HANDLER(handle_hello_command)
 	const char *sep, *name;
 	int retval = CALL_COMMAND_HANDLER(handle_hello_args);
 	if (ERROR_OK == retval)
-		command_print(CMD_CTX, "Greetings%s%s!", sep, name);
+		command_print(CMD, "Greetings%s%s!", sep, name);
 	return retval;
 }
 @endcode
diff --git a/src/flash/mflash.c b/src/flash/mflash.c
index 1ad7290..acf1441 100644
--- a/src/flash/mflash.c
+++ b/src/flash/mflash.c
@@ -423,7 +423,7 @@ COMMAND_HANDLER(mg_probe_cmd)
 	ret = mg_mflash_probe();
 
 	if (ret == ERROR_OK) {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"mflash (total %" PRIu32 " sectors) found at 0x%8.8" PRIx32 "",
 			mflash_bank->drv_info->tot_sects,
 			mflash_bank->base);
@@ -799,7 +799,7 @@ COMMAND_HANDLER(mg_write_cmd)
 	}
 
 	if (duration_measure(&bench) == ERROR_OK) {
-		command_print(CMD_CTX, "wrote %zu bytes from file %s "
+		command_print(CMD, "wrote %zu bytes from file %s "
 			"in %fs (%0.3f kB/s)", filesize, CMD_ARGV[1],
 			duration_elapsed(&bench), duration_kbps(&bench, filesize));
 	}
@@ -866,7 +866,7 @@ COMMAND_HANDLER(mg_dump_cmd)
 	}
 
 	if (duration_measure(&bench) == ERROR_OK) {
-		command_print(CMD_CTX, "dump image (address 0x%8.8" PRIx32 " "
+		command_print(CMD, "dump image (address 0x%8.8" PRIx32 " "
 			"size %" PRIu32 ") to file %s in %fs (%0.3f kB/s)",
 			address, size, CMD_ARGV[1],
 			duration_elapsed(&bench), duration_kbps(&bench, size));
diff --git a/src/flash/nand/at91sam9.c b/src/flash/nand/at91sam9.c
index 0af12b2..47c0505 100644
--- a/src/flash/nand/at91sam9.c
+++ b/src/flash/nand/at91sam9.c
@@ -547,14 +547,14 @@ COMMAND_HANDLER(handle_at91sam9_cle_command)
 	unsigned num, address_line;
 
 	if (CMD_ARGC != 2) {
-		command_print(CMD_CTX, "incorrect number of arguments for 'at91sam9 cle' command");
+		command_print(CMD, "incorrect number of arguments for 'at91sam9 cle' command");
 		return ERROR_OK;
 	}
 
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
 	nand = get_nand_device_by_num(num);
 	if (!nand) {
-		command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
+		command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]);
 		return ERROR_OK;
 	}
 
@@ -582,7 +582,7 @@ COMMAND_HANDLER(handle_at91sam9_ale_command)
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
 	nand = get_nand_device_by_num(num);
 	if (!nand) {
-		command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
+		command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]);
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
@@ -610,7 +610,7 @@ COMMAND_HANDLER(handle_at91sam9_rdy_busy_command)
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
 	nand = get_nand_device_by_num(num);
 	if (!nand) {
-		command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
+		command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]);
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
@@ -641,7 +641,7 @@ COMMAND_HANDLER(handle_at91sam9_ce_command)
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
 	nand = get_nand_device_by_num(num);
 	if (!nand) {
-		command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
+		command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]);
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
diff --git a/src/flash/nand/core.c b/src/flash/nand/core.c
index 7428d22..b9ac793 100644
--- a/src/flash/nand/core.c
+++ b/src/flash/nand/core.c
@@ -217,7 +217,7 @@ COMMAND_HELPER(nand_command_get_device, unsigned name_index,
 	COMMAND_PARSE_NUMBER(uint, str, num);
 	*nand = get_nand_device_by_num(num);
 	if (!*nand) {
-		command_print(CMD_CTX, "NAND flash device '%s' not found", str);
+		command_print(CMD, "NAND flash device '%s' not found", str);
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	return ERROR_OK;
diff --git a/src/flash/nand/fileio.c b/src/flash/nand/fileio.c
index 76f6e10..f65f957 100644
--- a/src/flash/nand/fileio.c
+++ b/src/flash/nand/fileio.c
@@ -59,7 +59,7 @@ int nand_fileio_start(struct command_invocation *cmd,
 	struct nand_fileio_state *state)
 {
 	if (state->address % nand->page_size) {
-		command_print(cmd->ctx, "only page-aligned addresses are supported");
+		command_print(cmd, "only page-aligned addresses are supported");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -69,7 +69,7 @@ int nand_fileio_start(struct command_invocation *cmd,
 		int retval = fileio_open(&state->fileio, filename, filemode, FILEIO_BINARY);
 		if (ERROR_OK != retval) {
 			const char *msg = (FILEIO_READ == filemode) ? "read" : "write";
-			command_print(cmd->ctx, "failed to open '%s' for %s access",
+			command_print(cmd, "failed to open '%s' for %s access",
 				filename, msg);
 			return retval;
 		}
@@ -131,7 +131,7 @@ COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state,
 		return retval;
 
 	if (NULL == nand->device) {
-		command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]);
+		command_print(CMD, "#%s: not probed", CMD_ARGV[0]);
 		return ERROR_NAND_DEVICE_NOT_PROBED;
 	}
 
@@ -139,7 +139,7 @@ COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state,
 	if (need_size) {
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], state->size);
 		if (state->size % nand->page_size) {
-			command_print(CMD_CTX, "only page-aligned sizes are supported");
+			command_print(CMD, "only page-aligned sizes are supported");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 	}
@@ -155,7 +155,7 @@ COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state,
 			else if (sw_ecc && !strcmp(CMD_ARGV[i], "oob_softecc_kw"))
 				state->oob_format |= NAND_OOB_SW_ECC_KW;
 			else {
-				command_print(CMD_CTX, "unknown option: %s", CMD_ARGV[i]);
+				command_print(CMD, "unknown option: %s", CMD_ARGV[i]);
 				return ERROR_COMMAND_SYNTAX_ERROR;
 			}
 		}
diff --git a/src/flash/nand/lpc3180.c b/src/flash/nand/lpc3180.c
index d15fdce..436580e 100644
--- a/src/flash/nand/lpc3180.c
+++ b/src/flash/nand/lpc3180.c
@@ -1290,7 +1290,7 @@ COMMAND_HANDLER(handle_lpc3180_select_command)
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
 	struct nand_device *nand = get_nand_device_by_num(num);
 	if (!nand) {
-		command_print(CMD_CTX, "nand device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "nand device '#%s' is out of bounds", CMD_ARGV[0]);
 		return ERROR_OK;
 	}
 
@@ -1310,10 +1310,10 @@ COMMAND_HANDLER(handle_lpc3180_select_command)
 	}
 
 	if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER)
-		command_print(CMD_CTX, "%s controller selected",
+		command_print(CMD, "%s controller selected",
 			selected[lpc3180_info->selected_controller]);
 	else
-		command_print(CMD_CTX,
+		command_print(CMD,
 			lpc3180_info->is_bulk ? "%s controller selected bulk mode is available" :
 			"%s controller selected bulk mode is not available",
 			selected[lpc3180_info->selected_controller]);
diff --git a/src/flash/nand/lpc32xx.c b/src/flash/nand/lpc32xx.c
index 1ed16df..6febe16 100644
--- a/src/flash/nand/lpc32xx.c
+++ b/src/flash/nand/lpc32xx.c
@@ -1760,7 +1760,7 @@ COMMAND_HANDLER(handle_lpc32xx_select_command)
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
 	struct nand_device *nand = get_nand_device_by_num(num);
 	if (!nand) {
-		command_print(CMD_CTX, "nand device '#%s' is out of bounds",
+		command_print(CMD, "nand device '#%s' is out of bounds",
 			CMD_ARGV[0]);
 		return ERROR_OK;
 	}
@@ -1778,7 +1778,7 @@ COMMAND_HANDLER(handle_lpc32xx_select_command)
 			return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX, "%s controller selected",
+	command_print(CMD, "%s controller selected",
 		selected[lpc32xx_info->selected_controller]);
 
 	return ERROR_OK;
diff --git a/src/flash/nand/mxc.c b/src/flash/nand/mxc.c
index 6069c62..b541157 100644
--- a/src/flash/nand/mxc.c
+++ b/src/flash/nand/mxc.c
@@ -157,7 +157,7 @@ COMMAND_HANDLER(handle_mxc_biswap_command)
 
 	int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &nand);
 	if (retval != ERROR_OK) {
-		command_print(CMD_CTX, "invalid nand device number or name: %s", CMD_ARGV[0]);
+		command_print(CMD, "invalid nand device number or name: %s", CMD_ARGV[0]);
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
@@ -169,9 +169,9 @@ COMMAND_HANDLER(handle_mxc_biswap_command)
 			mxc_nf_info->flags.biswap_enabled = false;
 	}
 	if (mxc_nf_info->flags.biswap_enabled)
-		command_print(CMD_CTX, "BI-swapping enabled on %s", nand->name);
+		command_print(CMD, "BI-swapping enabled on %s", nand->name);
 	else
-		command_print(CMD_CTX, "BI-swapping disabled on %s", nand->name);
+		command_print(CMD, "BI-swapping disabled on %s", nand->name);
 
 	return ERROR_OK;
 }
diff --git a/src/flash/nand/tcl.c b/src/flash/nand/tcl.c
index 8a7022a..5480e0d 100644
--- a/src/flash/nand/tcl.c
+++ b/src/flash/nand/tcl.c
@@ -37,20 +37,20 @@ COMMAND_HANDLER(handle_nand_list_command)
 	int i;
 
 	if (!nand_devices) {
-		command_print(CMD_CTX, "no NAND flash devices configured");
+		command_print(CMD, "no NAND flash devices configured");
 		return ERROR_OK;
 	}
 
 	for (p = nand_devices, i = 0; p; p = p->next, i++) {
 		if (p->device)
-			command_print(CMD_CTX, "#%i: %s (%s) "
+			command_print(CMD, "#%i: %s (%s) "
 				"pagesize: %i, buswidth: %i,\n\t"
 				"blocksize: %i, blocks: %i",
 				i, p->device->name, p->manufacturer->name,
 				p->page_size, p->bus_width,
 				p->erase_size, p->num_blocks);
 		else
-			command_print(CMD_CTX, "#%i: not probed", i);
+			command_print(CMD, "#%i: not probed", i);
 	}
 
 	return ERROR_OK;
@@ -87,7 +87,7 @@ COMMAND_HANDLER(handle_nand_info_command)
 		return retval;
 
 	if (NULL == p->device) {
-		command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]);
+		command_print(CMD, "#%s: not probed", CMD_ARGV[0]);
 		return ERROR_OK;
 	}
 
@@ -97,7 +97,7 @@ COMMAND_HANDLER(handle_nand_info_command)
 	if (last >= p->num_blocks)
 		last = p->num_blocks - 1;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i",
 		i++,
 		p->device->name,
@@ -123,7 +123,7 @@ COMMAND_HANDLER(handle_nand_info_command)
 		else
 			bad_state = " (block condition unknown)";
 
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"\t#%i: 0x%8.8" PRIx32 " (%" PRId32 "kB) %s%s",
 			j,
 			p->blocks[j].offset,
@@ -147,7 +147,7 @@ COMMAND_HANDLER(handle_nand_probe_command)
 
 	retval = nand_probe(p);
 	if (retval == ERROR_OK) {
-		command_print(CMD_CTX, "NAND flash device '%s (%s)' found",
+		command_print(CMD, "NAND flash device '%s (%s)' found",
 			p->device->name, p->manufacturer->name);
 	}
 
@@ -189,7 +189,7 @@ COMMAND_HANDLER(handle_nand_erase_command)
 
 	retval = nand_erase(p, offset, offset + length - 1);
 	if (retval == ERROR_OK) {
-		command_print(CMD_CTX, "erased blocks %lu to %lu "
+		command_print(CMD, "erased blocks %lu to %lu "
 			"on NAND flash device #%s '%s'",
 			offset, offset + length - 1,
 			CMD_ARGV[0], p->device->name);
@@ -233,7 +233,7 @@ COMMAND_HANDLER(handle_nand_check_bad_blocks_command)
 
 	retval = nand_build_bbt(p, first, last);
 	if (retval == ERROR_OK) {
-		command_print(CMD_CTX, "checked NAND flash device for bad blocks, "
+		command_print(CMD, "checked NAND flash device for bad blocks, "
 			"use \"nand info\" command to list blocks");
 	}
 
@@ -253,7 +253,7 @@ COMMAND_HANDLER(handle_nand_write_command)
 	while (s.size > 0) {
 		int bytes_read = nand_fileio_read(nand, &s);
 		if (bytes_read <= 0) {
-			command_print(CMD_CTX, "error while reading file");
+			command_print(CMD, "error while reading file");
 			nand_fileio_cleanup(&s);
 			return ERROR_FAIL;
 		}
@@ -262,7 +262,7 @@ COMMAND_HANDLER(handle_nand_write_command)
 		retval = nand_write_page(nand, s.address / nand->page_size,
 				s.page, s.page_size, s.oob, s.oob_size);
 		if (ERROR_OK != retval) {
-			command_print(CMD_CTX, "failed writing file %s "
+			command_print(CMD, "failed writing file %s "
 				"to NAND flash %s at offset 0x%8.8" PRIx32,
 				CMD_ARGV[1], CMD_ARGV[0], s.address);
 			nand_fileio_cleanup(&s);
@@ -272,7 +272,7 @@ COMMAND_HANDLER(handle_nand_write_command)
 	}
 
 	if (nand_fileio_finish(&s) == ERROR_OK) {
-		command_print(CMD_CTX, "wrote file %s to NAND flash %s up to "
+		command_print(CMD, "wrote file %s to NAND flash %s up to "
 			"offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
 			CMD_ARGV[1], CMD_ARGV[0], s.address, duration_elapsed(&s.bench),
 			duration_kbps(&s.bench, total_bytes));
@@ -302,7 +302,7 @@ COMMAND_HANDLER(handle_nand_verify_command)
 		retval = nand_read_page(nand, dev.address / dev.page_size,
 				dev.page, dev.page_size, dev.oob, dev.oob_size);
 		if (ERROR_OK != retval) {
-			command_print(CMD_CTX, "reading NAND flash page failed");
+			command_print(CMD, "reading NAND flash page failed");
 			nand_fileio_cleanup(&dev);
 			nand_fileio_cleanup(&file);
 			return retval;
@@ -310,7 +310,7 @@ COMMAND_HANDLER(handle_nand_verify_command)
 
 		int bytes_read = nand_fileio_read(nand, &file);
 		if (bytes_read <= 0) {
-			command_print(CMD_CTX, "error while reading file");
+			command_print(CMD, "error while reading file");
 			nand_fileio_cleanup(&dev);
 			nand_fileio_cleanup(&file);
 			return ERROR_FAIL;
@@ -318,7 +318,7 @@ COMMAND_HANDLER(handle_nand_verify_command)
 
 		if ((dev.page && memcmp(dev.page, file.page, dev.page_size)) ||
 				(dev.oob && memcmp(dev.oob, file.oob, dev.oob_size))) {
-			command_print(CMD_CTX, "NAND flash contents differ "
+			command_print(CMD, "NAND flash contents differ "
 				"at 0x%8.8" PRIx32, dev.address);
 			nand_fileio_cleanup(&dev);
 			nand_fileio_cleanup(&file);
@@ -330,7 +330,7 @@ COMMAND_HANDLER(handle_nand_verify_command)
 	}
 
 	if (nand_fileio_finish(&file) == ERROR_OK) {
-		command_print(CMD_CTX, "verified file %s in NAND flash %s "
+		command_print(CMD, "verified file %s in NAND flash %s "
 			"up to offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
 			CMD_ARGV[1], CMD_ARGV[0], dev.address, duration_elapsed(&file.bench),
 			duration_kbps(&file.bench, dev.size));
@@ -354,7 +354,7 @@ COMMAND_HANDLER(handle_nand_dump_command)
 		retval = nand_read_page(nand, s.address / nand->page_size,
 				s.page, s.page_size, s.oob, s.oob_size);
 		if (ERROR_OK != retval) {
-			command_print(CMD_CTX, "reading NAND flash page failed");
+			command_print(CMD, "reading NAND flash page failed");
 			nand_fileio_cleanup(&s);
 			return retval;
 		}
@@ -374,7 +374,7 @@ COMMAND_HANDLER(handle_nand_dump_command)
 		return retval;
 
 	if (nand_fileio_finish(&s) == ERROR_OK) {
-		command_print(CMD_CTX, "dumped %zu bytes in %fs (%0.3f KiB/s)",
+		command_print(CMD, "dumped %zu bytes in %fs (%0.3f KiB/s)",
 			filesize, duration_elapsed(&s.bench),
 			duration_kbps(&s.bench, filesize));
 	}
@@ -392,7 +392,7 @@ COMMAND_HANDLER(handle_nand_raw_access_command)
 		return retval;
 
 	if (NULL == p->device) {
-		command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]);
+		command_print(CMD, "#%s: not probed", CMD_ARGV[0]);
 		return ERROR_OK;
 	}
 
@@ -400,7 +400,7 @@ COMMAND_HANDLER(handle_nand_raw_access_command)
 		COMMAND_PARSE_ENABLE(CMD_ARGV[1], p->use_raw);
 
 	const char *msg = p->use_raw ? "enabled" : "disabled";
-	command_print(CMD_CTX, "raw access is %s", msg);
+	command_print(CMD, "raw access is %s", msg);
 
 	return ERROR_OK;
 }
@@ -502,13 +502,13 @@ COMMAND_HANDLER(handle_nand_init_command)
 static int nand_list_walker(struct nand_flash_controller *c, void *x)
 {
 	struct command_invocation *cmd = x;
-	command_print(cmd->ctx, "  %s", c->name);
+	command_print(cmd, "  %s", c->name);
 	return ERROR_OK;
 }
 
 COMMAND_HANDLER(handle_nand_list_drivers)
 {
-	command_print(CMD_CTX, "Available NAND flash controller drivers:");
+	command_print(CMD, "Available NAND flash controller drivers:");
 	return nand_driver_walk(&nand_list_walker, CMD);
 }
 
diff --git a/src/flash/nor/ambiqmicro.c b/src/flash/nor/ambiqmicro.c
index a536d54..b1e3e72 100644
--- a/src/flash/nor/ambiqmicro.c
+++ b/src/flash/nor/ambiqmicro.c
@@ -791,9 +791,9 @@ COMMAND_HANDLER(ambiqmicro_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "ambiqmicro mass erase complete");
+		command_print(CMD, "ambiqmicro mass erase complete");
 	} else
-		command_print(CMD_CTX, "ambiqmicro mass erase failed");
+		command_print(CMD, "ambiqmicro mass erase failed");
 
 	return ERROR_OK;
 }
@@ -815,9 +815,9 @@ COMMAND_HANDLER(ambiqmicro_handle_page_erase_command)
 		return retval;
 
 	if (ambiqmicro_erase(bank, first, last) == ERROR_OK)
-		command_print(CMD_CTX, "ambiqmicro page erase complete");
+		command_print(CMD, "ambiqmicro page erase complete");
 	else
-		command_print(CMD_CTX, "ambiqmicro page erase failed");
+		command_print(CMD, "ambiqmicro page erase failed");
 
 	return ERROR_OK;
 }
@@ -838,7 +838,7 @@ COMMAND_HANDLER(ambiqmicro_handle_program_otp_command)
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], offset);
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count);
 
-	command_print(CMD_CTX, "offset=0x%08x count=%d", offset, count);
+	command_print(CMD, "offset=0x%08x count=%d", offset, count);
 
 	CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
 
diff --git a/src/flash/nor/at91sam3.c b/src/flash/nor/at91sam3.c
index 616c3fe..2457c15 100644
--- a/src/flash/nor/at91sam3.c
+++ b/src/flash/nor/at91sam3.c
@@ -256,7 +256,7 @@ static struct sam3_chip *get_current_sam3(struct command_invocation *cmd)
 
 	t = get_current_target(cmd->ctx);
 	if (!t) {
-		command_print(cmd->ctx, "No current target?");
+		command_print(cmd, "No current target?");
 		return NULL;
 	}
 
@@ -264,7 +264,7 @@ static struct sam3_chip *get_current_sam3(struct command_invocation *cmd)
 	if (!p) {
 		/* this should not happen */
 		/* the command is not registered until the chip is created? */
-		command_print(cmd->ctx, "No SAM3 chips exist?");
+		command_print(cmd, "No SAM3 chips exist?");
 		return NULL;
 	}
 
@@ -273,7 +273,7 @@ static struct sam3_chip *get_current_sam3(struct command_invocation *cmd)
 			return p;
 		p = p->next;
 	}
-	command_print(cmd->ctx, "Cannot find SAM3 chip?");
+	command_print(cmd, "Cannot find SAM3 chip?");
 	return NULL;
 }
 
@@ -3549,7 +3549,7 @@ COMMAND_HANDLER(sam3_handle_info_command)
 	if (pChip->details.bank[0].pBank == NULL) {
 		x = 0;
 need_define:
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"Please define bank %d via command: flash bank %s ... ",
 			x,
 			at91sam3_flash.name);
@@ -3608,7 +3608,7 @@ COMMAND_HANDLER(sam3_handle_gpnvm_command)
 	}
 
 	if (pChip->details.bank[0].pBank == NULL) {
-		command_print(CMD_CTX, "Bank0 must be defined first via: flash bank %s ...",
+		command_print(CMD, "Bank0 must be defined first via: flash bank %s ...",
 			at91sam3_flash.name);
 		return ERROR_FAIL;
 	}
@@ -3647,22 +3647,22 @@ showall:
 				r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), x, &v);
 				if (r != ERROR_OK)
 					break;
-				command_print(CMD_CTX, "sam3-gpnvm%u: %u", x, v);
+				command_print(CMD, "sam3-gpnvm%u: %u", x, v);
 			}
 			return r;
 		}
 		if ((who >= 0) && (((unsigned)(who)) < pChip->details.n_gpnvms)) {
 			r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), who, &v);
-			command_print(CMD_CTX, "sam3-gpnvm%u: %u", who, v);
+			command_print(CMD, "sam3-gpnvm%u: %u", who, v);
 			return r;
 		} else {
-			command_print(CMD_CTX, "sam3-gpnvm invalid GPNVM: %u", who);
+			command_print(CMD, "sam3-gpnvm invalid GPNVM: %u", who);
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 	}
 
 	if (who == -1) {
-		command_print(CMD_CTX, "Missing GPNVM number");
+		command_print(CMD, "Missing GPNVM number");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -3672,7 +3672,7 @@ showall:
 		 (0 == strcmp("clear", CMD_ARGV[0])))			/* quietly accept both */
 		r = FLASHD_ClrGPNVM(&(pChip->details.bank[0]), who);
 	else {
-		command_print(CMD_CTX, "Unknown command: %s", CMD_ARGV[0]);
+		command_print(CMD, "Unknown command: %s", CMD_ARGV[0]);
 		r = ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	return r;
@@ -3697,7 +3697,7 @@ COMMAND_HANDLER(sam3_handle_slowclk_command)
 			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
 			if (v > 200000) {
 				/* absurd slow clock of 200Khz? */
-				command_print(CMD_CTX, "Absurd/illegal slow clock freq: %d\n", (int)(v));
+				command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v));
 				return ERROR_COMMAND_SYNTAX_ERROR;
 			}
 			pChip->cfg.slow_freq = v;
@@ -3705,11 +3705,11 @@ COMMAND_HANDLER(sam3_handle_slowclk_command)
 		}
 		default:
 			/* error */
-			command_print(CMD_CTX, "Too many parameters");
+			command_print(CMD, "Too many parameters");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 			break;
 	}
-	command_print(CMD_CTX, "Slowclk freq: %d.%03dkhz",
+	command_print(CMD, "Slowclk freq: %d.%03dkhz",
 		(int)(pChip->cfg.slow_freq / 1000),
 		(int)(pChip->cfg.slow_freq % 1000));
 	return ERROR_OK;
diff --git a/src/flash/nor/at91sam4.c b/src/flash/nor/at91sam4.c
index 719da2b..621754c 100644
--- a/src/flash/nor/at91sam4.c
+++ b/src/flash/nor/at91sam4.c
@@ -235,7 +235,7 @@ static struct sam4_chip *get_current_sam4(struct command_invocation *cmd)
 
 	t = get_current_target(cmd->ctx);
 	if (!t) {
-		command_print(cmd->ctx, "No current target?");
+		command_print(cmd, "No current target?");
 		return NULL;
 	}
 
@@ -243,7 +243,7 @@ static struct sam4_chip *get_current_sam4(struct command_invocation *cmd)
 	if (!p) {
 		/* this should not happen */
 		/* the command is not registered until the chip is created? */
-		command_print(cmd->ctx, "No SAM4 chips exist?");
+		command_print(cmd, "No SAM4 chips exist?");
 		return NULL;
 	}
 
@@ -252,7 +252,7 @@ static struct sam4_chip *get_current_sam4(struct command_invocation *cmd)
 			return p;
 		p = p->next;
 	}
-	command_print(cmd->ctx, "Cannot find SAM4 chip?");
+	command_print(cmd, "Cannot find SAM4 chip?");
 	return NULL;
 }
 
@@ -3029,7 +3029,7 @@ COMMAND_HANDLER(sam4_handle_info_command)
 	if (pChip->details.bank[0].pBank == NULL) {
 		x = 0;
 need_define:
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"Please define bank %d via command: flash bank %s ... ",
 			x,
 			at91sam4_flash.name);
@@ -3088,7 +3088,7 @@ COMMAND_HANDLER(sam4_handle_gpnvm_command)
 	}
 
 	if (pChip->details.bank[0].pBank == NULL) {
-		command_print(CMD_CTX, "Bank0 must be defined first via: flash bank %s ...",
+		command_print(CMD, "Bank0 must be defined first via: flash bank %s ...",
 			at91sam4_flash.name);
 		return ERROR_FAIL;
 	}
@@ -3127,23 +3127,23 @@ showall:
 				r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), x, &v);
 				if (r != ERROR_OK)
 					break;
-				command_print(CMD_CTX, "sam4-gpnvm%u: %u", x, v);
+				command_print(CMD, "sam4-gpnvm%u: %u", x, v);
 			}
 			return r;
 		}
 		if ((who >= 0) && (((unsigned)(who)) < pChip->details.n_gpnvms)) {
 			r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), who, &v);
 			if (r == ERROR_OK)
-				command_print(CMD_CTX, "sam4-gpnvm%u: %u", who, v);
+				command_print(CMD, "sam4-gpnvm%u: %u", who, v);
 			return r;
 		} else {
-			command_print(CMD_CTX, "sam4-gpnvm invalid GPNVM: %u", who);
+			command_print(CMD, "sam4-gpnvm invalid GPNVM: %u", who);
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 	}
 
 	if (who == -1) {
-		command_print(CMD_CTX, "Missing GPNVM number");
+		command_print(CMD, "Missing GPNVM number");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -3153,7 +3153,7 @@ showall:
 		 (0 == strcmp("clear", CMD_ARGV[0])))			/* quietly accept both */
 		r = FLASHD_ClrGPNVM(&(pChip->details.bank[0]), who);
 	else {
-		command_print(CMD_CTX, "Unknown command: %s", CMD_ARGV[0]);
+		command_print(CMD, "Unknown command: %s", CMD_ARGV[0]);
 		r = ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	return r;
@@ -3178,7 +3178,7 @@ COMMAND_HANDLER(sam4_handle_slowclk_command)
 			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
 			if (v > 200000) {
 				/* absurd slow clock of 200Khz? */
-				command_print(CMD_CTX, "Absurd/illegal slow clock freq: %d\n", (int)(v));
+				command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v));
 				return ERROR_COMMAND_SYNTAX_ERROR;
 			}
 			pChip->cfg.slow_freq = v;
@@ -3186,11 +3186,11 @@ COMMAND_HANDLER(sam4_handle_slowclk_command)
 		}
 		default:
 			/* error */
-			command_print(CMD_CTX, "Too many parameters");
+			command_print(CMD, "Too many parameters");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 			break;
 	}
-	command_print(CMD_CTX, "Slowclk freq: %d.%03dkhz",
+	command_print(CMD, "Slowclk freq: %d.%03dkhz",
 		(int)(pChip->cfg.slow_freq / 1000),
 		(int)(pChip->cfg.slow_freq % 1000));
 	return ERROR_OK;
diff --git a/src/flash/nor/at91sam7.c b/src/flash/nor/at91sam7.c
index 15b93a2..232260b 100644
--- a/src/flash/nor/at91sam7.c
+++ b/src/flash/nor/at91sam7.c
@@ -1067,7 +1067,7 @@ COMMAND_HANDLER(at91sam7_handle_gpnvm_command)
 	if (bank ==  NULL)
 		return ERROR_FLASH_BANK_INVALID;
 	if (strcmp(bank->driver->name, "at91sam7")) {
-		command_print(CMD_CTX, "not an at91sam7 flash bank '%s'", CMD_ARGV[0]);
+		command_print(CMD, "not an at91sam7 flash bank '%s'", CMD_ARGV[0]);
 		return ERROR_FLASH_BANK_INVALID;
 	}
 	if (bank->target->state != TARGET_HALTED) {
@@ -1091,7 +1091,7 @@ COMMAND_HANDLER(at91sam7_handle_gpnvm_command)
 
 	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], bit);
 	if ((bit < 0) || (bit >= at91sam7_info->num_nvmbits)) {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"gpnvm bit '#%s' is out of bounds for target %s",
 			CMD_ARGV[0],
 			at91sam7_info->target_name);
diff --git a/src/flash/nor/at91samd.c b/src/flash/nor/at91samd.c
index c325194..b6cff9a 100644
--- a/src/flash/nor/at91samd.c
+++ b/src/flash/nor/at91samd.c
@@ -947,9 +947,9 @@ COMMAND_HANDLER(samd_handle_chip_erase_command)
 		 * perform the erase. */
 		res = target_write_u8(target, SAMD_DSU + SAMD_DSU_CTRL_EXT, (1<<4));
 		if (res == ERROR_OK)
-			command_print(CMD_CTX, "chip erase started");
+			command_print(CMD, "chip erase started");
 		else
-			command_print(CMD_CTX, "write to DSU CTRL failed");
+			command_print(CMD, "write to DSU CTRL failed");
 	}
 
 	return res;
@@ -961,7 +961,7 @@ COMMAND_HANDLER(samd_handle_set_security_command)
 	struct target *target = get_current_target(CMD_CTX);
 
 	if (CMD_ARGC < 1 || (CMD_ARGC >= 1 && (strcmp(CMD_ARGV[0], "enable")))) {
-		command_print(CMD_CTX, "supply the \"enable\" argument to proceed.");
+		command_print(CMD, "supply the \"enable\" argument to proceed.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -975,9 +975,9 @@ COMMAND_HANDLER(samd_handle_set_security_command)
 
 		/* Check (and clear) error conditions */
 		if (res == ERROR_OK)
-			command_print(CMD_CTX, "chip secured on next power-cycle");
+			command_print(CMD, "chip secured on next power-cycle");
 		else
-			command_print(CMD_CTX, "failed to secure chip");
+			command_print(CMD, "failed to secure chip");
 	}
 
 	return res;
@@ -1008,7 +1008,7 @@ COMMAND_HANDLER(samd_handle_eeprom_command)
 				}
 
 				if (code > 6) {
-					command_print(CMD_CTX, "Invalid EEPROM size.  Please see "
+					command_print(CMD, "Invalid EEPROM size.  Please see "
 							"datasheet for a list valid sizes.");
 					return ERROR_COMMAND_SYNTAX_ERROR;
 				}
@@ -1022,10 +1022,10 @@ COMMAND_HANDLER(samd_handle_eeprom_command)
 				uint32_t size = ((val >> 4) & 0x7); /* grab size code */
 
 				if (size == 0x7)
-					command_print(CMD_CTX, "EEPROM is disabled");
+					command_print(CMD, "EEPROM is disabled");
 				else {
 					/* Otherwise, 6 is 256B, 0 is 16KB */
-					command_print(CMD_CTX, "EEPROM size is %u bytes",
+					command_print(CMD, "EEPROM size is %u bytes",
 							(2 << (13 - size)));
 				}
 			}
@@ -1038,7 +1038,7 @@ COMMAND_HANDLER(samd_handle_eeprom_command)
 static COMMAND_HELPER(get_u64_from_hexarg, unsigned int num, uint64_t *value)
 {
 	if (num >= CMD_ARGC) {
-		command_print(CMD_CTX, "Too few Arguments.");
+		command_print(CMD, "Too few Arguments.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1049,12 +1049,12 @@ static COMMAND_HELPER(get_u64_from_hexarg, unsigned int num, uint64_t *value)
 		*value = strtoull(&(CMD_ARGV[num][2]), &check, 16);
 		if ((value == 0 && errno == ERANGE) ||
 			check == NULL || *check != 0) {
-			command_print(CMD_CTX, "Invalid 64-bit hex value in argument %d.",
+			command_print(CMD, "Invalid 64-bit hex value in argument %d.",
 				num + 1);
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 	} else {
-		command_print(CMD_CTX, "Argument %d needs to be a hex value.", num + 1);
+		command_print(CMD, "Argument %d needs to be a hex value.", num + 1);
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	return ERROR_OK;
@@ -1067,7 +1067,7 @@ COMMAND_HANDLER(samd_handle_nvmuserrow_command)
 
 	if (target) {
 		if (CMD_ARGC > 2) {
-			command_print(CMD_CTX, "Too much Arguments given.");
+			command_print(CMD, "Too much Arguments given.");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 
@@ -1105,7 +1105,7 @@ COMMAND_HANDLER(samd_handle_nvmuserrow_command)
 		uint64_t value;
 		res = read_userrow(target, &value);
 		if (res == ERROR_OK)
-			command_print(CMD_CTX, "NVMUSERROW: 0x%016"PRIX64, value);
+			command_print(CMD, "NVMUSERROW: 0x%016"PRIX64, value);
 		else
 			LOG_ERROR("NVMUSERROW could not be read.");
 	}
@@ -1145,7 +1145,7 @@ COMMAND_HANDLER(samd_handle_bootloader_command)
 				}
 
 				if (code > 6) {
-					command_print(CMD_CTX, "Invalid bootloader size.  Please "
+					command_print(CMD, "Invalid bootloader size.  Please "
 							"see datasheet for a list valid sizes.");
 					return ERROR_COMMAND_SYNTAX_ERROR;
 				}
@@ -1166,7 +1166,7 @@ COMMAND_HANDLER(samd_handle_bootloader_command)
 					nb = (2 << (8 - size)) * page_size;
 
 				/* There are 4 pages per row */
-				command_print(CMD_CTX, "Bootloader size is %" PRIu32 " bytes (%" PRIu32 " rows)",
+				command_print(CMD, "Bootloader size is %" PRIu32 " bytes (%" PRIu32 " rows)",
 					   nb, (uint32_t)(nb / (page_size * 4)));
 			}
 		}
diff --git a/src/flash/nor/atsame5.c b/src/flash/nor/atsame5.c
index 4a114a3..eac7847 100644
--- a/src/flash/nor/atsame5.c
+++ b/src/flash/nor/atsame5.c
@@ -765,9 +765,9 @@ COMMAND_HANDLER(same5_handle_chip_erase_command)
 	 * perform the erase. */
 	int res = target_write_u8(target, SAMD_DSU + SAMD_DSU_CTRL_EXT, (1<<4));
 	if (res == ERROR_OK)
-		command_print(CMD_CTX, "chip erase started");
+		command_print(CMD, "chip erase started");
 	else
-		command_print(CMD_CTX, "write to DSU CTRL failed");
+		command_print(CMD, "write to DSU CTRL failed");
 
 	return res;
 }
@@ -781,7 +781,7 @@ COMMAND_HANDLER(same5_handle_userpage_command)
 		return ERROR_FAIL;
 
 	if (CMD_ARGC > 2) {
-		command_print(CMD_CTX, "Too much Arguments given.");
+		command_print(CMD, "Too much Arguments given.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -806,7 +806,7 @@ COMMAND_HANDLER(same5_handle_userpage_command)
 	int res2 = target_read_memory(target, SAMD_USER_ROW, 4, 2, buffer);
 	if (res2 == ERROR_OK) {
 		uint64_t value = target_buffer_get_u64(target, buffer);
-		command_print(CMD_CTX, "USER PAGE: 0x%016"PRIX64, value);
+		command_print(CMD, "USER PAGE: 0x%016"PRIX64, value);
 	} else {
 		LOG_ERROR("USER PAGE could not be read.");
 	}
@@ -829,7 +829,7 @@ COMMAND_HANDLER(same5_handle_bootloader_command)
 		unsigned long size = strtoul(CMD_ARGV[0], NULL, 0);
 		uint32_t code = (size + 8191) / 8192;
 		if (code > 15) {
-			command_print(CMD_CTX, "Invalid bootloader size.  Please "
+			command_print(CMD, "Invalid bootloader size.  Please "
 						"see datasheet for a list valid sizes.");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
@@ -842,7 +842,7 @@ COMMAND_HANDLER(same5_handle_bootloader_command)
 	if (res2 == ERROR_OK) {
 		uint32_t code = (val >> 26) & 0xf; /* grab size code */
 		uint32_t size = (15 - code) * 8192;
-		command_print(CMD_CTX, "Bootloader protected in the first %"
+		command_print(CMD, "Bootloader protected in the first %"
 				      PRIu32 " bytes", size);
 	}
 
diff --git a/src/flash/nor/atsamv.c b/src/flash/nor/atsamv.c
index 5beeefc..d6f1a0a 100644
--- a/src/flash/nor/atsamv.c
+++ b/src/flash/nor/atsamv.c
@@ -672,22 +672,22 @@ showall:
 				r = samv_get_gpnvm(target, x, &v);
 				if (r != ERROR_OK)
 					break;
-				command_print(CMD_CTX, "samv-gpnvm%u: %u", x, v);
+				command_print(CMD, "samv-gpnvm%u: %u", x, v);
 			}
 			return r;
 		}
 		if ((who >= 0) && (((unsigned)who) < SAMV_NUM_GPNVM_BITS)) {
 			r = samv_get_gpnvm(target, who, &v);
-			command_print(CMD_CTX, "samv-gpnvm%u: %u", who, v);
+			command_print(CMD, "samv-gpnvm%u: %u", who, v);
 			return r;
 		} else {
-			command_print(CMD_CTX, "invalid gpnvm: %u", who);
+			command_print(CMD, "invalid gpnvm: %u", who);
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 	}
 
 	if (who == -1) {
-		command_print(CMD_CTX, "missing gpnvm number");
+		command_print(CMD, "missing gpnvm number");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -696,7 +696,7 @@ showall:
 	else if (!strcmp("clr", CMD_ARGV[0]) || !strcmp("clear", CMD_ARGV[0]))
 		r = samv_clear_gpnvm(target, who);
 	else {
-		command_print(CMD_CTX, "unknown command: %s", CMD_ARGV[0]);
+		command_print(CMD, "unknown command: %s", CMD_ARGV[0]);
 		r = ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	return r;
diff --git a/src/flash/nor/avrf.c b/src/flash/nor/avrf.c
index 6969f77..178567e 100644
--- a/src/flash/nor/avrf.c
+++ b/src/flash/nor/avrf.c
@@ -433,9 +433,9 @@ COMMAND_HANDLER(avrf_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "avr mass erase complete");
+		command_print(CMD, "avr mass erase complete");
 	} else
-		command_print(CMD_CTX, "avr mass erase failed");
+		command_print(CMD, "avr mass erase failed");
 
 	LOG_DEBUG("%s", __func__);
 	return ERROR_OK;
diff --git a/src/flash/nor/efm32.c b/src/flash/nor/efm32.c
index d2ac3a8..83d133f 100644
--- a/src/flash/nor/efm32.c
+++ b/src/flash/nor/efm32.c
@@ -1093,7 +1093,7 @@ COMMAND_HANDLER(efm32x_handle_debuglock_command)
 		return retval;
 	}
 
-	command_print(CMD_CTX, "efm32x debug interface locked, reset the device to apply");
+	command_print(CMD, "efm32x debug interface locked, reset the device to apply");
 
 	return ERROR_OK;
 }
diff --git a/src/flash/nor/em357.c b/src/flash/nor/em357.c
index e6b2728..38fb731 100644
--- a/src/flash/nor/em357.c
+++ b/src/flash/nor/em357.c
@@ -776,7 +776,7 @@ COMMAND_HANDLER(em357_handle_lock_command)
 	}
 
 	if (em357_erase_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "em357 failed to erase options");
+		command_print(CMD, "em357 failed to erase options");
 		return ERROR_OK;
 	}
 
@@ -784,11 +784,11 @@ COMMAND_HANDLER(em357_handle_lock_command)
 	em357_info->option_bytes.RDP = 0;
 
 	if (em357_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "em357 failed to lock device");
+		command_print(CMD, "em357 failed to lock device");
 		return ERROR_OK;
 	}
 
-	command_print(CMD_CTX, "em357 locked");
+	command_print(CMD, "em357 locked");
 
 	return ERROR_OK;
 }
@@ -813,16 +813,16 @@ COMMAND_HANDLER(em357_handle_unlock_command)
 	}
 
 	if (em357_erase_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "em357 failed to unlock device");
+		command_print(CMD, "em357 failed to unlock device");
 		return ERROR_OK;
 	}
 
 	if (em357_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "em357 failed to lock device");
+		command_print(CMD, "em357 failed to lock device");
 		return ERROR_OK;
 	}
 
-	command_print(CMD_CTX, "em357 unlocked.\n"
+	command_print(CMD, "em357 unlocked.\n"
 		"INFO: a reset or power cycle is required "
 		"for the new settings to take effect.");
 
@@ -886,9 +886,9 @@ COMMAND_HANDLER(em357_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "em357 mass erase complete");
+		command_print(CMD, "em357 mass erase complete");
 	} else
-		command_print(CMD_CTX, "em357 mass erase failed");
+		command_print(CMD, "em357 mass erase failed");
 
 	return retval;
 }
diff --git a/src/flash/nor/esirisc_flash.c b/src/flash/nor/esirisc_flash.c
index 948d001..4e33b94 100644
--- a/src/flash/nor/esirisc_flash.c
+++ b/src/flash/nor/esirisc_flash.c
@@ -516,7 +516,7 @@ COMMAND_HANDLER(handle_esirisc_flash_mass_erase_command)
 
 	retval = esirisc_flash_mass_erase(bank);
 
-	command_print(CMD_CTX, "mass erase %s",
+	command_print(CMD, "mass erase %s",
 			(retval == ERROR_OK) ? "successful" : "failed");
 
 	return retval;
@@ -536,7 +536,7 @@ COMMAND_HANDLER(handle_esirisc_flash_ref_erase_command)
 
 	retval = esirisc_flash_ref_erase(bank);
 
-	command_print(CMD_CTX, "erase reference cell %s",
+	command_print(CMD, "erase reference cell %s",
 			(retval == ERROR_OK) ? "successful" : "failed");
 
 	return retval;
diff --git a/src/flash/nor/fm3.c b/src/flash/nor/fm3.c
index f2da2af..eeefa3f 100644
--- a/src/flash/nor/fm3.c
+++ b/src/flash/nor/fm3.c
@@ -958,9 +958,9 @@ COMMAND_HANDLER(fm3_handle_chip_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "fm3 chip erase complete");
+		command_print(CMD, "fm3 chip erase complete");
 	} else {
-		command_print(CMD_CTX, "fm3 chip erase failed");
+		command_print(CMD, "fm3 chip erase failed");
 	}
 
 	return ERROR_OK;
diff --git a/src/flash/nor/kinetis.c b/src/flash/nor/kinetis.c
index 8475135..687a337 100644
--- a/src/flash/nor/kinetis.c
+++ b/src/flash/nor/kinetis.c
@@ -2895,7 +2895,7 @@ COMMAND_HANDLER(kinetis_nvm_partition)
 		flex_nvm_partition_code = (uint8_t)((sim_fcfg1 >> 8) & 0x0f);
 		switch (flex_nvm_partition_code) {
 		case 0:
-			command_print(CMD_CTX, "No EEPROM backup, data flash only");
+			command_print(CMD, "No EEPROM backup, data flash only");
 			break;
 		case 1:
 		case 2:
@@ -2903,10 +2903,10 @@ COMMAND_HANDLER(kinetis_nvm_partition)
 		case 4:
 		case 5:
 		case 6:
-			command_print(CMD_CTX, "EEPROM backup %d KB", 4 << flex_nvm_partition_code);
+			command_print(CMD, "EEPROM backup %d KB", 4 << flex_nvm_partition_code);
 			break;
 		case 8:
-			command_print(CMD_CTX, "No data flash, EEPROM backup only");
+			command_print(CMD, "No data flash, EEPROM backup only");
 			break;
 		case 0x9:
 		case 0xA:
@@ -2914,13 +2914,13 @@ COMMAND_HANDLER(kinetis_nvm_partition)
 		case 0xC:
 		case 0xD:
 		case 0xE:
-			command_print(CMD_CTX, "data flash %d KB", 4 << (flex_nvm_partition_code & 7));
+			command_print(CMD, "data flash %d KB", 4 << (flex_nvm_partition_code & 7));
 			break;
 		case 0xf:
-			command_print(CMD_CTX, "No EEPROM backup, data flash only (DEPART not set)");
+			command_print(CMD, "No EEPROM backup, data flash only (DEPART not set)");
 			break;
 		default:
-			command_print(CMD_CTX, "Unsupported EEPROM backup size code 0x%02" PRIx8, flex_nvm_partition_code);
+			command_print(CMD, "Unsupported EEPROM backup size code 0x%02" PRIx8, flex_nvm_partition_code);
 		}
 		return ERROR_OK;
 
@@ -2986,7 +2986,7 @@ COMMAND_HANDLER(kinetis_nvm_partition)
 	if (result != ERROR_OK)
 		return result;
 
-	command_print(CMD_CTX, "FlexNVM partition set. Please reset MCU.");
+	command_print(CMD, "FlexNVM partition set. Please reset MCU.");
 
 	if (k_chip) {
 		first_nvm_bank = k_chip->num_pflash_blocks;
@@ -2996,7 +2996,7 @@ COMMAND_HANDLER(kinetis_nvm_partition)
 		k_chip->probed = false;
 	}
 
-	command_print(CMD_CTX, "FlexNVM banks will be re-probed to set new data flash size.");
+	command_print(CMD, "FlexNVM banks will be re-probed to set new data flash size.");
 	return ERROR_OK;
 }
 
@@ -3015,12 +3015,12 @@ COMMAND_HANDLER(kinetis_fcf_source_handler)
 	}
 
 	if (allow_fcf_writes) {
-		command_print(CMD_CTX, "Arbitrary Flash Configuration Field writes enabled.");
-		command_print(CMD_CTX, "Protection info writes to FCF disabled.");
+		command_print(CMD, "Arbitrary Flash Configuration Field writes enabled.");
+		command_print(CMD, "Protection info writes to FCF disabled.");
 		LOG_WARNING("BEWARE: incorrect flash configuration may permanently lock the device.");
 	} else {
-		command_print(CMD_CTX, "Protection info writes to Flash Configuration Field enabled.");
-		command_print(CMD_CTX, "Arbitrary FCF writes disabled. Mode safe from unwanted locking of the device.");
+		command_print(CMD, "Protection info writes to Flash Configuration Field enabled.");
+		command_print(CMD, "Arbitrary FCF writes disabled. Mode safe from unwanted locking of the device.");
 	}
 
 	return ERROR_OK;
@@ -3035,7 +3035,7 @@ COMMAND_HANDLER(kinetis_fopt_handler)
 		fcf_fopt = (uint8_t)strtoul(CMD_ARGV[0], NULL, 0);
 		fcf_fopt_configured = true;
 	} else {
-		command_print(CMD_CTX, "FCF_FOPT 0x%02" PRIx8, fcf_fopt);
+		command_print(CMD, "FCF_FOPT 0x%02" PRIx8, fcf_fopt);
 	}
 
 	return ERROR_OK;
diff --git a/src/flash/nor/lpc2000.c b/src/flash/nor/lpc2000.c
index cb3f58e..2a69af6 100644
--- a/src/flash/nor/lpc2000.c
+++ b/src/flash/nor/lpc2000.c
@@ -1579,11 +1579,11 @@ COMMAND_HANDLER(lpc2000_handle_part_id_command)
 	int status_code = get_lpc2000_part_id(bank, &part_id);
 	if (status_code != 0x0) {
 		if (status_code == ERROR_FLASH_OPERATION_FAILED) {
-			command_print(CMD_CTX, "no sufficient working area specified, can't access LPC2000 IAP interface");
+			command_print(CMD, "no sufficient working area specified, can't access LPC2000 IAP interface");
 		} else
-			command_print(CMD_CTX, "lpc2000 IAP returned status code %i", status_code);
+			command_print(CMD, "lpc2000 IAP returned status code %i", status_code);
 	} else
-		command_print(CMD_CTX, "lpc2000 part id: 0x%8.8" PRIx32, part_id);
+		command_print(CMD, "lpc2000 part id: 0x%8.8" PRIx32, part_id);
 
 	return retval;
 }
diff --git a/src/flash/nor/lpc2900.c b/src/flash/nor/lpc2900.c
index c798e44..5412c93 100644
--- a/src/flash/nor/lpc2900.c
+++ b/src/flash/nor/lpc2900.c
@@ -501,7 +501,7 @@ COMMAND_HANDLER(lpc2900_handle_signature_command)
 	if (status != ERROR_OK)
 		return status;
 
-	command_print(CMD_CTX, "signature: 0x%8.8" PRIx32
+	command_print(CMD, "signature: 0x%8.8" PRIx32
 		":0x%8.8" PRIx32
 		":0x%8.8" PRIx32
 		":0x%8.8" PRIx32,
@@ -595,11 +595,11 @@ COMMAND_HANDLER(lpc2900_handle_password_command)
 	lpc2900_info->risky = !strcmp(CMD_ARGV[1], ISS_PASSWORD);
 
 	if (!lpc2900_info->risky) {
-		command_print(CMD_CTX, "Wrong password (use '%s')", ISS_PASSWORD);
+		command_print(CMD, "Wrong password (use '%s')", ISS_PASSWORD);
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"Potentially dangerous operation allowed in next command!");
 
 	return ERROR_OK;
@@ -622,7 +622,7 @@ COMMAND_HANDLER(lpc2900_handle_write_custom_command)
 
 	/* Check if command execution is allowed. */
 	if (!lpc2900_info->risky) {
-		command_print(CMD_CTX, "Command execution not allowed!");
+		command_print(CMD, "Command execution not allowed!");
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 	lpc2900_info->risky = 0;
@@ -721,7 +721,7 @@ COMMAND_HANDLER(lpc2900_handle_secure_sector_command)
 
 	/* Check if command execution is allowed. */
 	if (!lpc2900_info->risky) {
-		command_print(CMD_CTX, "Command execution not allowed! "
+		command_print(CMD, "Command execution not allowed! "
 			"(use 'password' command first)");
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
@@ -734,7 +734,7 @@ COMMAND_HANDLER(lpc2900_handle_secure_sector_command)
 	if ((first >= bank->num_sectors) ||
 			(last >= bank->num_sectors) ||
 			(first > last)) {
-		command_print(CMD_CTX, "Illegal sector range");
+		command_print(CMD, "Illegal sector range");
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
@@ -773,7 +773,7 @@ COMMAND_HANDLER(lpc2900_handle_secure_sector_command)
 		}
 	}
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"Sectors security will become effective after next power cycle");
 
 	/* Update the sector security status */
@@ -803,7 +803,7 @@ COMMAND_HANDLER(lpc2900_handle_secure_jtag_command)
 
 	/* Check if command execution is allowed. */
 	if (!lpc2900_info->risky) {
-		command_print(CMD_CTX, "Command execution not allowed! "
+		command_print(CMD, "Command execution not allowed! "
 			"(use 'password' command first)");
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
diff --git a/src/flash/nor/max32xxx.c b/src/flash/nor/max32xxx.c
index f51f6e2..3bf4b22 100644
--- a/src/flash/nor/max32xxx.c
+++ b/src/flash/nor/max32xxx.c
@@ -772,7 +772,7 @@ COMMAND_HANDLER(max32xxx_handle_mass_erase_command)
 	int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
 
 	if (CMD_ARGC < 1) {
-		command_print(CMD_CTX, "max32xxx mass_erase <bank>");
+		command_print(CMD, "max32xxx mass_erase <bank>");
 		return ERROR_OK;
 	}
 
@@ -784,9 +784,9 @@ COMMAND_HANDLER(max32xxx_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "max32xxx mass erase complete");
+		command_print(CMD, "max32xxx mass erase complete");
 	} else
-		command_print(CMD_CTX, "max32xxx mass erase failed");
+		command_print(CMD, "max32xxx mass erase failed");
 
 	return ERROR_OK;
 }
@@ -799,7 +799,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_set_command)
 	uint32_t addr, len;
 
 	if (CMD_ARGC != 3) {
-		command_print(CMD_CTX, "max32xxx protection_set <bank> <addr> <size>");
+		command_print(CMD, "max32xxx protection_set <bank> <addr> <size>");
 		return ERROR_OK;
 	}
 
@@ -811,7 +811,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_set_command)
 	/* Convert the range to the page numbers */
 	if (1 != sscanf(CMD_ARGV[1], "0x%"SCNx32, &addr)) {
 		LOG_WARNING("Error parsing address");
-		command_print(CMD_CTX, "max32xxx protection_set <bank> <addr> <size>");
+		command_print(CMD, "max32xxx protection_set <bank> <addr> <size>");
 		return ERROR_FAIL;
 	}
 	/* Mask off the top portion on the address */
@@ -819,7 +819,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_set_command)
 
 	if (1 != sscanf(CMD_ARGV[2], "0x%"SCNx32, &len)) {
 		LOG_WARNING("Error parsing length");
-		command_print(CMD_CTX, "max32xxx protection_set <bank> <addr> <size>");
+		command_print(CMD, "max32xxx protection_set <bank> <addr> <size>");
 		return ERROR_FAIL;
 	}
 
@@ -840,9 +840,9 @@ COMMAND_HANDLER(max32xxx_handle_protection_set_command)
 	len = addr + (len / info->sector_size) - 1;
 
 	if (max32xxx_protect(bank, 1, addr, len) == ERROR_OK)
-		command_print(CMD_CTX, "max32xxx protection set complete");
+		command_print(CMD, "max32xxx protection set complete");
 	else
-		command_print(CMD_CTX, "max32xxx protection set failed");
+		command_print(CMD, "max32xxx protection set failed");
 
 	return ERROR_OK;
 }
@@ -855,7 +855,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_clr_command)
 	uint32_t addr, len;
 
 	if (CMD_ARGC != 3) {
-		command_print(CMD_CTX, "max32xxx protection_clr <bank> <addr> <size>");
+		command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>");
 		return ERROR_OK;
 	}
 
@@ -867,7 +867,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_clr_command)
 	/* Convert the range to the page numbers */
 	if (1 != sscanf(CMD_ARGV[1], "0x%"SCNx32, &addr)) {
 		LOG_WARNING("Error parsing address");
-		command_print(CMD_CTX, "max32xxx protection_clr <bank> <addr> <size>");
+		command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>");
 		return ERROR_FAIL;
 	}
 	/* Mask off the top portion on the address */
@@ -875,7 +875,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_clr_command)
 
 	if (1 != sscanf(CMD_ARGV[2], "0x%"SCNx32, &len)) {
 		LOG_WARNING("Error parsing length");
-		command_print(CMD_CTX, "max32xxx protection_clr <bank> <addr> <size>");
+		command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>");
 		return ERROR_FAIL;
 	}
 
@@ -896,9 +896,9 @@ COMMAND_HANDLER(max32xxx_handle_protection_clr_command)
 	len = addr + (len / info->sector_size) - 1;
 
 	if (max32xxx_protect(bank, 0, addr, len) == ERROR_OK)
-		command_print(CMD_CTX, "max32xxx protection clear complete");
+		command_print(CMD, "max32xxx protection clear complete");
 	else
-		command_print(CMD_CTX, "max32xxx protection clear failed");
+		command_print(CMD, "max32xxx protection clear failed");
 
 	return ERROR_OK;
 }
@@ -911,7 +911,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_check_command)
 	int i;
 
 	if (CMD_ARGC < 1) {
-		command_print(CMD_CTX, "max32xxx protection_check <bank>");
+		command_print(CMD, "max32xxx protection_check <bank>");
 		return ERROR_OK;
 	}
 
diff --git a/src/flash/nor/niietcm4.c b/src/flash/nor/niietcm4.c
index b034ee1..62549f2 100644
--- a/src/flash/nor/niietcm4.c
+++ b/src/flash/nor/niietcm4.c
@@ -425,7 +425,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_read_byte_command)
 	retval = target_read_u32(target, UFMD, &uflash_data);
 	if (retval != ERROR_OK)
 		return retval;
-	command_print(CMD_CTX,  "Read userflash %s region:\n"
+	command_print(CMD,  "Read userflash %s region:\n"
 							"address = 0x%04x,\n"
 							"value   = 0x%02x.", CMD_ARGV[0], uflash_addr, uflash_data);
 	return retval;
@@ -467,7 +467,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_write_byte_command)
 
 	int page_num = uflash_addr/USERFLASH_PAGE_SIZE;
 
-	command_print(CMD_CTX, "Write userflash %s region:\n"
+	command_print(CMD, "Write userflash %s region:\n"
 						   "address = 0x%04x,\n"
 						   "value   = 0x%02x.\n"
 						   "Please wait ... ", CMD_ARGV[0], uflash_addr, uflash_data);
@@ -483,7 +483,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_write_byte_command)
 
 	/* write dump to userflash */
 	niietcm4_load_uflash_page(bank, uflash_dump, page_num, mem_type);
-	command_print(CMD_CTX, "done!");
+	command_print(CMD, "done!");
 	return retval;
 }
 
@@ -520,7 +520,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_full_erase_command)
 	retval = niietcm4_uopstatus_check(bank);
 	if (retval != ERROR_OK)
 		return retval;
-	command_print(CMD_CTX, "Userflash full erase done!");
+	command_print(CMD, "Userflash full erase done!");
 
 	return retval;
 }
@@ -563,7 +563,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_erase_command)
 			return retval;
 	}
 
-	command_print(CMD_CTX, "Erase %s userflash pages %d through %d done!", CMD_ARGV[0], first, last);
+	command_print(CMD, "Erase %s userflash pages %d through %d done!", CMD_ARGV[0], first, last);
 
 	return retval;
 }
@@ -621,9 +621,9 @@ COMMAND_HANDLER(niietcm4_handle_uflash_protect_check_command)
 			return retval;
 
 		if (uflash_data & INFOWORD3_LOCK_IFB_UF)
-			command_print(CMD_CTX, "All sectors of info userflash are not protected!");
+			command_print(CMD, "All sectors of info userflash are not protected!");
 		else
-			command_print(CMD_CTX, "All sectors of info userflash are protected!");
+			command_print(CMD, "All sectors of info userflash are protected!");
 	} else {
 		uflash_addr = UF_LOCK_ADDR;
 		uflash_cmd = UFMC_MAGIC_KEY | UFMC_READ_IFB;
@@ -645,10 +645,10 @@ COMMAND_HANDLER(niietcm4_handle_uflash_protect_check_command)
 
 			for (j = 0; j < 8; j++) {
 				if (uflash_data & 0x1)
-					command_print(CMD_CTX, "Userflash sector #%03d: 0x%04x (0x100) is not protected!",
+					command_print(CMD, "Userflash sector #%03d: 0x%04x (0x100) is not protected!",
 											i*8+j, (i*8+j)*USERFLASH_PAGE_SIZE);
 				else
-					command_print(CMD_CTX, "Userflash sector #%03d: 0x%04x (0x100) is protected!",
+					command_print(CMD, "Userflash sector #%03d: 0x%04x (0x100) is protected!",
 											i*8+j, (i*8+j)*USERFLASH_PAGE_SIZE);
 				uflash_data = uflash_data >> 1;
 			}
@@ -693,11 +693,11 @@ COMMAND_HANDLER(niietcm4_handle_uflash_protect_command)
 
 	int set;
 	if (strcmp("on", CMD_ARGV[3]) == 0) {
-		command_print(CMD_CTX, "Try to enable %s userflash sectors %d through %d protection. Please wait ... ",
+		command_print(CMD, "Try to enable %s userflash sectors %d through %d protection. Please wait ... ",
 								CMD_ARGV[0], first, last);
 		set = 1;
 	} else if (strcmp("off", CMD_ARGV[3]) == 0) {
-		command_print(CMD_CTX, "Try to disable %s userflash sectors %d through %d protection. Please wait ... ",
+		command_print(CMD, "Try to disable %s userflash sectors %d through %d protection. Please wait ... ",
 								CMD_ARGV[0], first, last);
 		set = 0;
 	} else
@@ -707,7 +707,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_protect_command)
 		if (retval != ERROR_OK)
 			return retval;
 
-	command_print(CMD_CTX, "done!");
+	command_print(CMD, "done!");
 	return retval;
 }
 
@@ -733,10 +733,10 @@ COMMAND_HANDLER(niietcm4_handle_bflash_info_remap_command)
 
 	int set;
 	if (strcmp("on", CMD_ARGV[0]) == 0) {
-		command_print(CMD_CTX, "Try to enable bootflash info region remap. Please wait ...");
+		command_print(CMD, "Try to enable bootflash info region remap. Please wait ...");
 		set = 1;
 	} else if (strcmp("off", CMD_ARGV[0]) == 0) {
-		command_print(CMD_CTX, "Try to disable bootflash info region remap. Please wait ...");
+		command_print(CMD, "Try to disable bootflash info region remap. Please wait ...");
 		set = 0;
 	} else
 		return ERROR_COMMAND_SYNTAX_ERROR;
@@ -756,7 +756,7 @@ COMMAND_HANDLER(niietcm4_handle_bflash_info_remap_command)
 
 	/* write dump to userflash */
 	niietcm4_load_uflash_page(bank, uflash_dump, 0, 1);
-	command_print(CMD_CTX, "done!");
+	command_print(CMD, "done!");
 
 	return retval;
 }
@@ -814,7 +814,7 @@ COMMAND_HANDLER(niietcm4_handle_extmem_cfg_command)
 	else
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,  "Try to configure external memory boot interface:\n"
+	command_print(CMD,  "Try to configure external memory boot interface:\n"
 							"port = %s\n"
 							"pin  = %s\n"
 							"func = %s\n"
@@ -833,7 +833,7 @@ COMMAND_HANDLER(niietcm4_handle_extmem_cfg_command)
 
 	/* write dump to userflash */
 	niietcm4_load_uflash_page(bank, uflash_dump, 0, 1);
-	command_print(CMD_CTX, "done!");
+	command_print(CMD, "done!");
 
 	return retval;
 }
@@ -861,10 +861,10 @@ COMMAND_HANDLER(niietcm4_handle_extmem_boot_command)
 	int set;
 
 	if (strcmp("on", CMD_ARGV[0]) == 0) {
-		command_print(CMD_CTX, "Try to enable boot from external memory. Please wait ...");
+		command_print(CMD, "Try to enable boot from external memory. Please wait ...");
 		set = 1;
 	} else if (strcmp("off", CMD_ARGV[0]) == 0) {
-		command_print(CMD_CTX, "Try to disable boot from external memory. Please wait ...");
+		command_print(CMD, "Try to disable boot from external memory. Please wait ...");
 		set = 0;
 	} else
 		return ERROR_COMMAND_SYNTAX_ERROR;
@@ -884,7 +884,7 @@ COMMAND_HANDLER(niietcm4_handle_extmem_boot_command)
 
 	/* write dump to userflash */
 	niietcm4_load_uflash_page(bank, uflash_dump, 0, 1);
-	command_print(CMD_CTX, "done!");
+	command_print(CMD, "done!");
 
 	return retval;
 }
@@ -900,7 +900,7 @@ COMMAND_HANDLER(niietcm4_handle_service_mode_erase_command)
 		return retval;
 	struct target *target = bank->target;
 
-	command_print(CMD_CTX, "Try to perform service mode erase. Please wait ...");
+	command_print(CMD, "Try to perform service mode erase. Please wait ...");
 
 	retval = target_write_u32(target, SERVICE_MODE_ERASE_ADDR, 1);
 	if (retval != ERROR_OK)
@@ -923,7 +923,7 @@ COMMAND_HANDLER(niietcm4_handle_service_mode_erase_command)
 			}
 		busy_sleep(1);	/* can use busy sleep for short times. */
 	}
-	command_print(CMD_CTX, "done! All data erased.");
+	command_print(CMD, "done! All data erased.");
 
 	return retval;
 }
@@ -938,7 +938,7 @@ COMMAND_HANDLER(niietcm4_handle_driver_info_command)
 	if (retval != ERROR_OK)
 		return retval;
 
-	command_print(CMD_CTX, "niietcm4 flash driver\n"
+	command_print(CMD, "niietcm4 flash driver\n"
 						   "version: %d.%d\n"
 						   "author: Bogdan Kolbov\n"
 						   "mail: kolbov@niiet.ru",
diff --git a/src/flash/nor/numicro.c b/src/flash/nor/numicro.c
index 47f9a88..c62af04 100644
--- a/src/flash/nor/numicro.c
+++ b/src/flash/nor/numicro.c
@@ -1827,11 +1827,11 @@ COMMAND_HANDLER(numicro_handle_chip_erase_command)
 
 	retval = numicro_fmc_cmd(target, ISPCMD_CHIPERASE, 0, 0, &rdat);
 	if (retval != ERROR_OK) {
-		command_print(CMD_CTX, "numicro chip_erase failed");
+		command_print(CMD, "numicro chip_erase failed");
 		return retval;
 	}
 
-	command_print(CMD_CTX, "numicro chip_erase complete");
+	command_print(CMD, "numicro chip_erase complete");
 
 	return ERROR_OK;
 }
diff --git a/src/flash/nor/pic32mx.c b/src/flash/nor/pic32mx.c
index 5ad4cb7..81ffdc4 100644
--- a/src/flash/nor/pic32mx.c
+++ b/src/flash/nor/pic32mx.c
@@ -858,7 +858,7 @@ COMMAND_HANDLER(pic32mx_handle_pgm_word_command)
 		return retval;
 
 	if (address < bank->base || address >= (bank->base + bank->size)) {
-		command_print(CMD_CTX, "flash address '%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "flash address '%s' is out of bounds", CMD_ARGV[0]);
 		return ERROR_OK;
 	}
 
@@ -870,9 +870,9 @@ COMMAND_HANDLER(pic32mx_handle_pgm_word_command)
 		res = ERROR_FLASH_OPERATION_FAILED;
 
 	if (res == ERROR_OK)
-		command_print(CMD_CTX, "pic32mx pgm word complete");
+		command_print(CMD, "pic32mx pgm word complete");
 	else
-		command_print(CMD_CTX, "pic32mx pgm word failed (status = 0x%x)", status);
+		command_print(CMD, "pic32mx pgm word failed (status = 0x%x)", status);
 
 	return ERROR_OK;
 }
@@ -885,7 +885,7 @@ COMMAND_HANDLER(pic32mx_handle_unlock_command)
 	int timeout = 10;
 
 	if (CMD_ARGC < 1) {
-		command_print(CMD_CTX, "pic32mx unlock <bank>");
+		command_print(CMD, "pic32mx unlock <bank>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -907,7 +907,7 @@ COMMAND_HANDLER(pic32mx_handle_unlock_command)
 	mips_ejtag_drscan_8(ejtag_info, &mchip_cmd);
 	if (mchip_cmd & (1 << 7)) {
 		/* device is not locked */
-		command_print(CMD_CTX, "pic32mx is already unlocked, erasing anyway");
+		command_print(CMD, "pic32mx is already unlocked, erasing anyway");
 	}
 
 	/* unlock/erase device */
@@ -931,7 +931,7 @@ COMMAND_HANDLER(pic32mx_handle_unlock_command)
 	/* select ejtag tap */
 	mips_ejtag_set_instr(ejtag_info, MTAP_SW_ETAP);
 
-	command_print(CMD_CTX, "pic32mx unlocked.\n"
+	command_print(CMD, "pic32mx unlocked.\n"
 			"INFO: a reset or power cycle is required "
 			"for the new settings to take effect.");
 
diff --git a/src/flash/nor/psoc4.c b/src/flash/nor/psoc4.c
index 0058f2d..1eb6a26 100644
--- a/src/flash/nor/psoc4.c
+++ b/src/flash/nor/psoc4.c
@@ -913,9 +913,9 @@ COMMAND_HANDLER(psoc4_handle_mass_erase_command)
 
 	retval = psoc4_mass_erase(bank);
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "psoc mass erase complete");
+		command_print(CMD, "psoc mass erase complete");
 	else
-		command_print(CMD_CTX, "psoc mass erase failed");
+		command_print(CMD, "psoc mass erase failed");
 
 	return retval;
 }
diff --git a/src/flash/nor/psoc5lp.c b/src/flash/nor/psoc5lp.c
index 66e2b07..7f801f2 100644
--- a/src/flash/nor/psoc5lp.c
+++ b/src/flash/nor/psoc5lp.c
@@ -1501,9 +1501,9 @@ COMMAND_HANDLER(psoc5lp_handle_mass_erase_command)
 
 	retval = psoc5lp_spc_erase_all(bank->target);
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "PSoC 5LP erase succeeded");
+		command_print(CMD, "PSoC 5LP erase succeeded");
 	else
-		command_print(CMD_CTX, "PSoC 5LP erase failed");
+		command_print(CMD, "PSoC 5LP erase failed");
 
 	return retval;
 }
diff --git a/src/flash/nor/stellaris.c b/src/flash/nor/stellaris.c
index 6b6f6e8..9c4c4bc 100644
--- a/src/flash/nor/stellaris.c
+++ b/src/flash/nor/stellaris.c
@@ -1336,9 +1336,9 @@ COMMAND_HANDLER(stellaris_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "stellaris mass erase complete");
+		command_print(CMD, "stellaris mass erase complete");
 	} else
-		command_print(CMD_CTX, "stellaris mass erase failed");
+		command_print(CMD, "stellaris mass erase failed");
 
 	return ERROR_OK;
 }
diff --git a/src/flash/nor/stm32f1x.c b/src/flash/nor/stm32f1x.c
index d5d59c6..cf10e37 100644
--- a/src/flash/nor/stm32f1x.c
+++ b/src/flash/nor/stm32f1x.c
@@ -1186,7 +1186,7 @@ COMMAND_HANDLER(stm32x_handle_lock_command)
 		return retval;
 
 	if (stm32x_erase_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "stm32x failed to erase options");
+		command_print(CMD, "stm32x failed to erase options");
 		return ERROR_OK;
 	}
 
@@ -1194,11 +1194,11 @@ COMMAND_HANDLER(stm32x_handle_lock_command)
 	stm32x_info->option_bytes.rdp = 0;
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "stm32x failed to lock device");
+		command_print(CMD, "stm32x failed to lock device");
 		return ERROR_OK;
 	}
 
-	command_print(CMD_CTX, "stm32x locked");
+	command_print(CMD, "stm32x locked");
 
 	return ERROR_OK;
 }
@@ -1227,16 +1227,16 @@ COMMAND_HANDLER(stm32x_handle_unlock_command)
 		return retval;
 
 	if (stm32x_erase_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "stm32x failed to erase options");
+		command_print(CMD, "stm32x failed to erase options");
 		return ERROR_OK;
 	}
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "stm32x failed to unlock device");
+		command_print(CMD, "stm32x failed to unlock device");
 		return ERROR_OK;
 	}
 
-	command_print(CMD_CTX, "stm32x unlocked.\n"
+	command_print(CMD, "stm32x unlocked.\n"
 			"INFO: a reset or power cycle is required "
 			"for the new settings to take effect.");
 
@@ -1281,30 +1281,30 @@ COMMAND_HANDLER(stm32x_handle_options_read_command)
 		return retval;
 
 	if (optionbyte & (1 << OPT_ERROR))
-		command_print(CMD_CTX, "option byte complement error");
+		command_print(CMD, "option byte complement error");
 
-	command_print(CMD_CTX, "option byte register = 0x%" PRIx32 "", optionbyte);
-	command_print(CMD_CTX, "write protection register = 0x%" PRIx32 "", protection);
+	command_print(CMD, "option byte register = 0x%" PRIx32 "", optionbyte);
+	command_print(CMD, "write protection register = 0x%" PRIx32 "", protection);
 
-	command_print(CMD_CTX, "read protection: %s",
+	command_print(CMD, "read protection: %s",
 				(optionbyte & (1 << OPT_READOUT)) ? "on" : "off");
 
 	/* user option bytes are offset depending on variant */
 	optionbyte >>= stm32x_info->option_offset;
 
-	command_print(CMD_CTX, "watchdog: %sware",
+	command_print(CMD, "watchdog: %sware",
 				(optionbyte & (1 << OPT_RDWDGSW)) ? "soft" : "hard");
 
-	command_print(CMD_CTX, "stop mode: %sreset generated upon entry",
+	command_print(CMD, "stop mode: %sreset generated upon entry",
 				(optionbyte & (1 << OPT_RDRSTSTOP)) ? "no " : "");
 
-	command_print(CMD_CTX, "standby mode: %sreset generated upon entry",
+	command_print(CMD, "standby mode: %sreset generated upon entry",
 				(optionbyte & (1 << OPT_RDRSTSTDBY)) ? "no " : "");
 
 	if (stm32x_info->has_dual_banks)
-		command_print(CMD_CTX, "boot: bank %d", (optionbyte & (1 << OPT_BFB2)) ? 0 : 1);
+		command_print(CMD, "boot: bank %d", (optionbyte & (1 << OPT_BFB2)) ? 0 : 1);
 
-	command_print(CMD_CTX, "user data = 0x%02" PRIx16 "", user_data);
+	command_print(CMD, "user data = 0x%02" PRIx16 "", user_data);
 
 	return ERROR_OK;
 }
@@ -1383,7 +1383,7 @@ COMMAND_HANDLER(stm32x_handle_options_write_command)
 	}
 
 	if (stm32x_erase_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "stm32x failed to erase options");
+		command_print(CMD, "stm32x failed to erase options");
 		return ERROR_OK;
 	}
 
@@ -1391,11 +1391,11 @@ COMMAND_HANDLER(stm32x_handle_options_write_command)
 	stm32x_info->option_bytes.data = useropt;
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "stm32x failed to write options");
+		command_print(CMD, "stm32x failed to write options");
 		return ERROR_OK;
 	}
 
-	command_print(CMD_CTX, "stm32x write options complete.\n"
+	command_print(CMD, "stm32x write options complete.\n"
 				"INFO: %spower cycle is required "
 				"for the new settings to take effect.",
 				stm32x_info->can_load_options
@@ -1504,9 +1504,9 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "stm32x mass erase complete");
+		command_print(CMD, "stm32x mass erase complete");
 	} else
-		command_print(CMD_CTX, "stm32x mass erase failed");
+		command_print(CMD, "stm32x mass erase failed");
 
 	return retval;
 }
diff --git a/src/flash/nor/stm32f2x.c b/src/flash/nor/stm32f2x.c
index 23f0030..b49e76e 100644
--- a/src/flash/nor/stm32f2x.c
+++ b/src/flash/nor/stm32f2x.c
@@ -1415,7 +1415,7 @@ COMMAND_HANDLER(stm32x_handle_lock_command)
 	}
 
 	if (stm32x_read_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to read options", bank->driver->name);
+		command_print(CMD, "%s failed to read options", bank->driver->name);
 		return ERROR_OK;
 	}
 
@@ -1423,11 +1423,11 @@ COMMAND_HANDLER(stm32x_handle_lock_command)
 	stm32x_info->option_bytes.RDP = 0;
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to lock device", bank->driver->name);
+		command_print(CMD, "%s failed to lock device", bank->driver->name);
 		return ERROR_OK;
 	}
 
-	command_print(CMD_CTX, "%s locked", bank->driver->name);
+	command_print(CMD, "%s locked", bank->driver->name);
 
 	return ERROR_OK;
 }
@@ -1454,7 +1454,7 @@ COMMAND_HANDLER(stm32x_handle_unlock_command)
 	}
 
 	if (stm32x_read_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to read options", bank->driver->name);
+		command_print(CMD, "%s failed to read options", bank->driver->name);
 		return ERROR_OK;
 	}
 
@@ -1466,11 +1466,11 @@ COMMAND_HANDLER(stm32x_handle_unlock_command)
 	}
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name);
+		command_print(CMD, "%s failed to unlock device", bank->driver->name);
 		return ERROR_OK;
 	}
 
-	command_print(CMD_CTX, "%s unlocked.\n"
+	command_print(CMD, "%s unlocked.\n"
 			"INFO: a reset or power cycle is required "
 			"for the new settings to take effect.", bank->driver->name);
 
@@ -1525,7 +1525,7 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command)
 	int i;
 
 	if (CMD_ARGC < 1) {
-		command_print(CMD_CTX, "stm32x mass_erase <bank>");
+		command_print(CMD, "stm32x mass_erase <bank>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1540,9 +1540,9 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "stm32x mass erase complete");
+		command_print(CMD, "stm32x mass erase complete");
 	} else {
-		command_print(CMD_CTX, "stm32x mass erase failed");
+		command_print(CMD, "stm32x mass erase failed");
 	}
 
 	return retval;
@@ -1555,7 +1555,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_read_command)
 	struct stm32x_flash_bank *stm32x_info = NULL;
 
 	if (CMD_ARGC != 1) {
-		command_print(CMD_CTX, "stm32f2x options_read <bank>");
+		command_print(CMD, "stm32f2x options_read <bank>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1572,20 +1572,20 @@ COMMAND_HANDLER(stm32f2x_handle_options_read_command)
 		if (stm32x_info->has_boot_addr) {
 			uint32_t boot_addr = stm32x_info->option_bytes.boot_addr;
 
-			command_print(CMD_CTX, "stm32f2x user_options 0x%03X,"
+			command_print(CMD, "stm32f2x user_options 0x%03X,"
 				" boot_add0 0x%04X, boot_add1 0x%04X",
 				stm32x_info->option_bytes.user_options,
 				boot_addr & 0xffff, (boot_addr & 0xffff0000) >> 16);
 			if (stm32x_info->has_optcr2_pcrop) {
-				command_print(CMD_CTX, "stm32f2x optcr2_pcrop 0x%08X",
+				command_print(CMD, "stm32f2x optcr2_pcrop 0x%08X",
 						stm32x_info->option_bytes.optcr2_pcrop);
 			}
 		} else {
-			command_print(CMD_CTX, "stm32f2x user_options 0x%03X",
+			command_print(CMD, "stm32f2x user_options 0x%03X",
 				stm32x_info->option_bytes.user_options);
 		}
 	} else {
-		command_print(CMD_CTX, "stm32f2x user_options 0x%02X",
+		command_print(CMD, "stm32f2x user_options 0x%02X",
 			stm32x_info->option_bytes.user_options);
 
 	}
@@ -1601,7 +1601,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command)
 	uint16_t user_options, boot_addr0, boot_addr1, options_mask;
 
 	if (CMD_ARGC < 1) {
-		command_print(CMD_CTX, "stm32f2x options_write <bank> ...");
+		command_print(CMD, "stm32f2x options_write <bank> ...");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1616,7 +1616,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command)
 	stm32x_info = bank->driver_priv;
 	if (stm32x_info->has_boot_addr) {
 		if (CMD_ARGC != 4) {
-			command_print(CMD_CTX, "stm32f2x options_write <bank> <user_options>"
+			command_print(CMD, "stm32f2x options_write <bank> <user_options>"
 				" <boot_addr0> <boot_addr1>");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
@@ -1625,7 +1625,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command)
 		stm32x_info->option_bytes.boot_addr = boot_addr0 | (((uint32_t) boot_addr1) << 16);
 	} else {
 		if (CMD_ARGC != 2) {
-			command_print(CMD_CTX, "stm32f2x options_write <bank> <user_options>");
+			command_print(CMD, "stm32f2x options_write <bank> <user_options>");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 	}
@@ -1634,14 +1634,14 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command)
 	options_mask = !stm32x_info->has_extra_options ? ~0xfc :
 		~(((0xf00 << (stm32x_info->protection_bits - 12)) | 0xff) & 0xffc);
 	if (user_options & options_mask) {
-		command_print(CMD_CTX, "stm32f2x invalid user_options");
+		command_print(CMD, "stm32f2x invalid user_options");
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
 	stm32x_info->option_bytes.user_options = user_options;
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "stm32f2x failed to write options");
+		command_print(CMD, "stm32f2x failed to write options");
 		return ERROR_OK;
 	}
 
@@ -1649,7 +1649,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command)
 	/* ... and reprogramming of whole flash */
 	stm32x_info->probed = false;
 
-	command_print(CMD_CTX, "stm32f2x write options complete.\n"
+	command_print(CMD, "stm32f2x write options complete.\n"
 				"INFO: a reset or power cycle is required "
 				"for the new settings to take effect.");
 	return retval;
@@ -1663,7 +1663,7 @@ COMMAND_HANDLER(stm32f2x_handle_optcr2_write_command)
 	uint32_t optcr2_pcrop;
 
 	if (CMD_ARGC != 2) {
-		command_print(CMD_CTX, "stm32f2x optcr2_write <bank> <optcr2_value>");
+		command_print(CMD, "stm32f2x optcr2_write <bank> <optcr2_value>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1673,11 +1673,11 @@ COMMAND_HANDLER(stm32f2x_handle_optcr2_write_command)
 
 	stm32x_info = bank->driver_priv;
 	if (!stm32x_info->has_optcr2_pcrop) {
-		command_print(CMD_CTX, "no optcr2 register");
+		command_print(CMD, "no optcr2 register");
 		return ERROR_COMMAND_ARGUMENT_INVALID;
 	}
 
-	command_print(CMD_CTX, "INFO: To disable PCROP, set PCROP_RDP"
+	command_print(CMD, "INFO: To disable PCROP, set PCROP_RDP"
 				" with PCROPi bits STILL SET, then\nlock device and"
 				" finally unlock it. Clears PCROP and mass erases flash.");
 
@@ -1689,18 +1689,18 @@ COMMAND_HANDLER(stm32f2x_handle_optcr2_write_command)
 	stm32x_info->option_bytes.optcr2_pcrop = optcr2_pcrop;
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "stm32f2x failed to write options");
+		command_print(CMD, "stm32f2x failed to write options");
 		return ERROR_OK;
 	}
 
-	command_print(CMD_CTX, "stm32f2x optcr2_write complete.");
+	command_print(CMD, "stm32f2x optcr2_write complete.");
 	return retval;
 }
 
 COMMAND_HANDLER(stm32x_handle_otp_command)
 {
 	if (CMD_ARGC < 2) {
-		command_print(CMD_CTX, "stm32x otp <bank> (enable|disable|show)");
+		command_print(CMD, "stm32x otp <bank> (enable|disable|show)");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1714,7 +1714,7 @@ COMMAND_HANDLER(stm32x_handle_otp_command)
 		} else if (strcmp(CMD_ARGV[1], "disable") == 0) {
 			stm32x_otp_disable(bank);
 		} else if (strcmp(CMD_ARGV[1], "show") == 0) {
-			command_print(CMD_CTX,
+			command_print(CMD,
 				"OTP memory bank #%d is %s for write commands.",
 				bank->bank_number,
 				stm32x_is_otp_unlocked(bank) ? "enabled" : "disabled");
@@ -1722,7 +1722,7 @@ COMMAND_HANDLER(stm32x_handle_otp_command)
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 	} else {
-		command_print(CMD_CTX, "Failed: not an OTP bank.");
+		command_print(CMD, "Failed: not an OTP bank.");
 	}
 
 	return retval;
diff --git a/src/flash/nor/stm32h7x.c b/src/flash/nor/stm32h7x.c
index 90bc8f3..cb96cf2 100644
--- a/src/flash/nor/stm32h7x.c
+++ b/src/flash/nor/stm32h7x.c
@@ -952,7 +952,7 @@ COMMAND_HANDLER(stm32x_handle_lock_command)
 	}
 
 	if (stm32x_read_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to read options",
+		command_print(CMD, "%s failed to read options",
 			      bank->driver->name);
 		return ERROR_OK;
 	}
@@ -960,11 +960,11 @@ COMMAND_HANDLER(stm32x_handle_lock_command)
 	stm32x_info->option_bytes.RDP = 0;
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to lock device",
+		command_print(CMD, "%s failed to lock device",
 			      bank->driver->name);
 		return ERROR_OK;
 	}
-	command_print(CMD_CTX, "%s locked", bank->driver->name);
+	command_print(CMD, "%s locked", bank->driver->name);
 
 	return ERROR_OK;
 }
@@ -998,7 +998,7 @@ COMMAND_HANDLER(stm32x_handle_unlock_command)
 	}
 
 	if (stm32x_read_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to read options", bank->driver->name);
+		command_print(CMD, "%s failed to read options", bank->driver->name);
 		return ERROR_OK;
 	}
 
@@ -1007,10 +1007,10 @@ COMMAND_HANDLER(stm32x_handle_unlock_command)
 	stm32x_info->option_bytes.RDP = 0xAA;
 
 	if (stm32x_write_options(bank) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name);
+		command_print(CMD, "%s failed to unlock device", bank->driver->name);
 		return ERROR_OK;
 	}
-	command_print(CMD_CTX, "%s unlocked.\n", bank->driver->name);
+	command_print(CMD, "%s unlocked.\n", bank->driver->name);
 
 	return ERROR_OK;
 }
@@ -1056,7 +1056,7 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command)
 	int i;
 
 	if (CMD_ARGC < 1) {
-		command_print(CMD_CTX, "stm32h7x mass_erase <bank>");
+		command_print(CMD, "stm32h7x mass_erase <bank>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1071,9 +1071,9 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "stm32h7x mass erase complete");
+		command_print(CMD, "stm32h7x mass erase complete");
 	} else {
-		command_print(CMD_CTX, "stm32h7x mass erase failed");
+		command_print(CMD, "stm32h7x mass erase failed");
 	}
 
 	return retval;
diff --git a/src/flash/nor/stm32l4x.c b/src/flash/nor/stm32l4x.c
index 3d4303b..f680542 100644
--- a/src/flash/nor/stm32l4x.c
+++ b/src/flash/nor/stm32l4x.c
@@ -835,7 +835,7 @@ COMMAND_HANDLER(stm32l4_handle_mass_erase_command)
 	uint32_t action;
 
 	if (CMD_ARGC < 1) {
-		command_print(CMD_CTX, "stm32l4x mass_erase <STM32L4 bank>");
+		command_print(CMD, "stm32l4x mass_erase <STM32L4 bank>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -851,9 +851,9 @@ COMMAND_HANDLER(stm32l4_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "stm32l4x mass erase complete");
+		command_print(CMD, "stm32l4x mass erase complete");
 	} else {
-		command_print(CMD_CTX, "stm32l4x mass erase failed");
+		command_print(CMD, "stm32l4x mass erase failed");
 	}
 
 	return retval;
@@ -862,7 +862,7 @@ COMMAND_HANDLER(stm32l4_handle_mass_erase_command)
 COMMAND_HANDLER(stm32l4_handle_option_read_command)
 {
 	if (CMD_ARGC < 2) {
-		command_print(CMD_CTX, "stm32l4x option_read <STM32L4 bank> <option_reg offset>");
+		command_print(CMD, "stm32l4x option_read <STM32L4 bank> <option_reg offset>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -880,7 +880,7 @@ COMMAND_HANDLER(stm32l4_handle_option_read_command)
 	if (ERROR_OK != retval)
 		return retval;
 
-	command_print(CMD_CTX, "Option Register: <0x%" PRIx32 "> = 0x%" PRIx32 "", reg_addr, value);
+	command_print(CMD, "Option Register: <0x%" PRIx32 "> = 0x%" PRIx32 "", reg_addr, value);
 
 	return retval;
 }
@@ -888,7 +888,7 @@ COMMAND_HANDLER(stm32l4_handle_option_read_command)
 COMMAND_HANDLER(stm32l4_handle_option_write_command)
 {
 	if (CMD_ARGC < 3) {
-		command_print(CMD_CTX, "stm32l4x option_write <STM32L4 bank> <option_reg offset> <value> [mask]");
+		command_print(CMD, "stm32l4x option_write <STM32L4 bank> <option_reg offset> <value> [mask]");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -906,7 +906,7 @@ COMMAND_HANDLER(stm32l4_handle_option_write_command)
 	if (CMD_ARGC > 3)
 		mask = strtoul(CMD_ARGV[3], NULL, 16);
 
-	command_print(CMD_CTX, "%s Option written.\n"
+	command_print(CMD, "%s Option written.\n"
 				"INFO: a reset or power cycle is required "
 				"for the new settings to take effect.", bank->driver->name);
 
@@ -937,7 +937,7 @@ COMMAND_HANDLER(stm32l4_handle_option_load_command)
 	/* Write the OBLLAUNCH bit in CR -> Cause device "POR" and option bytes reload */
 	retval = target_write_u32(target, stm32l4_get_flash_reg(bank, STM32_FLASH_CR), FLASH_OBLLAUNCH);
 
-	command_print(CMD_CTX, "stm32l4x option load (POR) completed.");
+	command_print(CMD, "stm32l4x option load (POR) completed.");
 	return retval;
 }
 
@@ -962,7 +962,7 @@ COMMAND_HANDLER(stm32l4_handle_lock_command)
 
 	/* set readout protection level 1 by erasing the RDP option byte */
 	if (stm32l4_write_option(bank, STM32_FLASH_OPTR, 0, 0x000000FF) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to lock device", bank->driver->name);
+		command_print(CMD, "%s failed to lock device", bank->driver->name);
 		return ERROR_OK;
 	}
 
@@ -989,7 +989,7 @@ COMMAND_HANDLER(stm32l4_handle_unlock_command)
 	}
 
 	if (stm32l4_write_option(bank, STM32_FLASH_OPTR, RDP_LEVEL_0, 0x000000FF) != ERROR_OK) {
-		command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name);
+		command_print(CMD, "%s failed to unlock device", bank->driver->name);
 		return ERROR_OK;
 	}
 
diff --git a/src/flash/nor/stm32lx.c b/src/flash/nor/stm32lx.c
index 2778010..e6473f8 100644
--- a/src/flash/nor/stm32lx.c
+++ b/src/flash/nor/stm32lx.c
@@ -324,9 +324,9 @@ COMMAND_HANDLER(stm32lx_handle_mass_erase_command)
 		for (i = 0; i < bank->num_sectors; i++)
 			bank->sectors[i].is_erased = 1;
 
-		command_print(CMD_CTX, "stm32lx mass erase complete");
+		command_print(CMD, "stm32lx mass erase complete");
 	} else {
-		command_print(CMD_CTX, "stm32lx mass erase failed");
+		command_print(CMD, "stm32lx mass erase failed");
 	}
 
 	return retval;
@@ -345,9 +345,9 @@ COMMAND_HANDLER(stm32lx_handle_lock_command)
 	retval = stm32lx_lock(bank);
 
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "STM32Lx locked, takes effect after power cycle.");
+		command_print(CMD, "STM32Lx locked, takes effect after power cycle.");
 	else
-		command_print(CMD_CTX, "STM32Lx lock failed");
+		command_print(CMD, "STM32Lx lock failed");
 
 	return retval;
 }
@@ -365,9 +365,9 @@ COMMAND_HANDLER(stm32lx_handle_unlock_command)
 	retval = stm32lx_unlock(bank);
 
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "STM32Lx unlocked, takes effect after power cycle.");
+		command_print(CMD, "STM32Lx unlocked, takes effect after power cycle.");
 	else
-		command_print(CMD_CTX, "STM32Lx unlock failed");
+		command_print(CMD, "STM32Lx unlock failed");
 
 	return retval;
 }
diff --git a/src/flash/nor/str9xpec.c b/src/flash/nor/str9xpec.c
index 37d8053..6e1ecf3 100644
--- a/src/flash/nor/str9xpec.c
+++ b/src/flash/nor/str9xpec.c
@@ -746,7 +746,7 @@ COMMAND_HANDLER(str9xpec_handle_part_id_command)
 
 	idcode = buf_get_u32(buffer, 0, 32);
 
-	command_print(CMD_CTX, "str9xpec part id: 0x%8.8" PRIx32 "", idcode);
+	command_print(CMD, "str9xpec part id: 0x%8.8" PRIx32 "", idcode);
 
 	free(buffer);
 
@@ -780,33 +780,33 @@ COMMAND_HANDLER(str9xpec_handle_flash_options_read_command)
 
 	/* boot bank */
 	if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_CSMAPBIT, 1))
-		command_print(CMD_CTX, "CS Map: bank1");
+		command_print(CMD, "CS Map: bank1");
 	else
-		command_print(CMD_CTX, "CS Map: bank0");
+		command_print(CMD, "CS Map: bank0");
 
 	/* OTP lock */
 	if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_OTPBIT, 1))
-		command_print(CMD_CTX, "OTP Lock: OTP Locked");
+		command_print(CMD, "OTP Lock: OTP Locked");
 	else
-		command_print(CMD_CTX, "OTP Lock: OTP Unlocked");
+		command_print(CMD, "OTP Lock: OTP Unlocked");
 
 	/* LVD Threshold */
 	if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDTHRESBIT, 1))
-		command_print(CMD_CTX, "LVD Threshold: 2.7v");
+		command_print(CMD, "LVD Threshold: 2.7v");
 	else
-		command_print(CMD_CTX, "LVD Threshold: 2.4v");
+		command_print(CMD, "LVD Threshold: 2.4v");
 
 	/* LVD reset warning */
 	if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDWARNBIT, 1))
-		command_print(CMD_CTX, "LVD Reset Warning: VDD or VDDQ Inputs");
+		command_print(CMD, "LVD Reset Warning: VDD or VDDQ Inputs");
 	else
-		command_print(CMD_CTX, "LVD Reset Warning: VDD Input Only");
+		command_print(CMD, "LVD Reset Warning: VDD Input Only");
 
 	/* LVD reset select */
 	if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDSELBIT, 1))
-		command_print(CMD_CTX, "LVD Reset Selection: VDD or VDDQ Inputs");
+		command_print(CMD, "LVD Reset Selection: VDD or VDDQ Inputs");
 	else
-		command_print(CMD_CTX, "LVD Reset Selection: VDD Input Only");
+		command_print(CMD, "LVD Reset Selection: VDD Input Only");
 
 	return ERROR_OK;
 }
@@ -885,7 +885,7 @@ COMMAND_HANDLER(str9xpec_handle_flash_options_write_command)
 	if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS)
 		return ERROR_FLASH_OPERATION_FAILED;
 
-	command_print(CMD_CTX, "str9xpec write options complete.\n"
+	command_print(CMD, "str9xpec write options complete.\n"
 			"INFO: a reset or power cycle is required "
 			"for the new settings to take effect.");
 
@@ -1017,7 +1017,7 @@ COMMAND_HANDLER(str9xpec_handle_flash_unlock_command)
 	if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS)
 		return ERROR_FLASH_OPERATION_FAILED;
 
-	command_print(CMD_CTX, "str9xpec unlocked.\n"
+	command_print(CMD, "str9xpec unlocked.\n"
 			"INFO: a reset or power cycle is required "
 			"for the new settings to take effect.");
 
@@ -1045,19 +1045,19 @@ COMMAND_HANDLER(str9xpec_handle_flash_enable_turbo_command)
 	tap0 = str9xpec_info->tap;
 	if (tap0 == NULL) {
 		/* things are *WRONG* */
-		command_print(CMD_CTX, "**STR9FLASH** (tap0) invalid chain?");
+		command_print(CMD, "**STR9FLASH** (tap0) invalid chain?");
 		return ERROR_FAIL;
 	}
 	tap1 = tap0->next_tap;
 	if (tap1 == NULL) {
 		/* things are *WRONG* */
-		command_print(CMD_CTX, "**STR9FLASH** (tap1) invalid chain?");
+		command_print(CMD, "**STR9FLASH** (tap1) invalid chain?");
 		return ERROR_FAIL;
 	}
 	tap2 = tap1->next_tap;
 	if (tap2 == NULL) {
 		/* things are *WRONG* */
-		command_print(CMD_CTX, "**STR9FLASH** (tap2) invalid chain?");
+		command_print(CMD, "**STR9FLASH** (tap2) invalid chain?");
 		return ERROR_FAIL;
 	}
 
diff --git a/src/flash/nor/tcl.c b/src/flash/nor/tcl.c
index 87d599a..0daa531 100644
--- a/src/flash/nor/tcl.c
+++ b/src/flash/nor/tcl.c
@@ -111,7 +111,7 @@ COMMAND_HANDLER(handle_flash_info_command)
 		if (retval == ERROR_FLASH_OPER_UNSUPPORTED)
 			LOG_WARNING("Flash protection check is not implemented.");
 
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"#%d : %s at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32
 			", buswidth %i, chipwidth %i",
 			p->bank_number,
@@ -140,7 +140,7 @@ COMMAND_HANDLER(handle_flash_info_command)
 			else if (!show_sectors || !prot_block_available)
 				protect_state = "protection state unknown";
 
-			command_print(CMD_CTX,
+			command_print(CMD,
 				"\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
 				j,
 				block_array[j].offset,
@@ -152,7 +152,7 @@ COMMAND_HANDLER(handle_flash_info_command)
 		if (p->driver->info != NULL) {
 			retval = p->driver->info(p, buf, sizeof(buf));
 			if (retval == ERROR_OK)
-				command_print(CMD_CTX, "%s", buf);
+				command_print(CMD, "%s", buf);
 			else
 				LOG_ERROR("error retrieving flash info");
 		}
@@ -176,12 +176,12 @@ COMMAND_HANDLER(handle_flash_probe_command)
 	if (p) {
 		retval = p->driver->probe(p);
 		if (retval == ERROR_OK)
-			command_print(CMD_CTX,
+			command_print(CMD,
 				"flash '%s' found at " TARGET_ADDR_FMT,
 				p->driver->name,
 				p->base);
 	} else {
-		command_print(CMD_CTX, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
 		retval = ERROR_FAIL;
 	}
 
@@ -202,9 +202,9 @@ COMMAND_HANDLER(handle_flash_erase_check_command)
 	int j;
 	retval = p->driver->erase_check(p);
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "successfully checked erase state");
+		command_print(CMD, "successfully checked erase state");
 	else {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"unknown error when checking erase state of flash bank #%s at "
 			TARGET_ADDR_FMT,
 			CMD_ARGV[0],
@@ -222,7 +222,7 @@ COMMAND_HANDLER(handle_flash_erase_check_command)
 			erase_state = "erase state unknown";
 
 		blank = false;
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
 			j,
 			p->sectors[j].offset,
@@ -232,7 +232,7 @@ COMMAND_HANDLER(handle_flash_erase_check_command)
 	}
 
 	if (blank)
-		command_print(CMD_CTX, "\tBank is erased");
+		command_print(CMD, "\tBank is erased");
 	return retval;
 }
 
@@ -267,7 +267,7 @@ COMMAND_HANDLER(handle_flash_erase_address_command)
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
 
 	if (length <= 0) {
-		command_print(CMD_CTX, "Length must be >0");
+		command_print(CMD, "Length must be >0");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -289,7 +289,7 @@ COMMAND_HANDLER(handle_flash_erase_address_command)
 		retval = flash_erase_address_range(target, do_pad, address, length);
 
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "erased address " TARGET_ADDR_FMT " (length %"
+		command_print(CMD, "erased address " TARGET_ADDR_FMT " (length %"
 				PRIi32 ")"
 			" in %fs (%0.3f KiB/s)", address, length,
 			duration_elapsed(&bench), duration_kbps(&bench, length));
@@ -320,13 +320,13 @@ COMMAND_HANDLER(handle_flash_erase_command)
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
 
 	if (!(first <= last)) {
-		command_print(CMD_CTX, "ERROR: "
+		command_print(CMD, "ERROR: "
 			"first sector must be <= last");
 		return ERROR_FAIL;
 	}
 
 	if (!(last <= (uint32_t)(p->num_sectors - 1))) {
-		command_print(CMD_CTX, "ERROR: "
+		command_print(CMD, "ERROR: "
 			"last sector must be <= %" PRIu32,
 			p->num_sectors - 1);
 		return ERROR_FAIL;
@@ -338,7 +338,7 @@ COMMAND_HANDLER(handle_flash_erase_command)
 	retval = flash_driver_erase(p, first, last);
 
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "erased sectors %" PRIu32 " "
+		command_print(CMD, "erased sectors %" PRIu32 " "
 			"through %" PRIu32 " on flash bank %d "
 			"in %fs", first, last, p->bank_number, duration_elapsed(&bench));
 	}
@@ -377,14 +377,14 @@ COMMAND_HANDLER(handle_flash_protect_command)
 	COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set);
 
 	if (!(first <= last)) {
-		command_print(CMD_CTX, "ERROR: "
+		command_print(CMD, "ERROR: "
 			"first %s must be <= last",
 			(p->num_prot_blocks) ? "block" : "sector");
 		return ERROR_FAIL;
 	}
 
 	if (!(last <= (uint32_t)(num_blocks - 1))) {
-		command_print(CMD_CTX, "ERROR: "
+		command_print(CMD, "ERROR: "
 			"last %s must be <= %" PRIu32,
 			(p->num_prot_blocks) ? "block" : "sector",
 			num_blocks - 1);
@@ -393,7 +393,7 @@ COMMAND_HANDLER(handle_flash_protect_command)
 
 	retval = flash_driver_protect(p, set, first, last);
 	if (retval == ERROR_OK) {
-		command_print(CMD_CTX, "%s protection for %s %" PRIu32
+		command_print(CMD, "%s protection for %s %" PRIu32
 			" through %" PRIu32 " on flash bank %d",
 			(set) ? "set" : "cleared",
 			(p->num_prot_blocks) ? "blocks" : "sectors",
@@ -421,12 +421,12 @@ COMMAND_HANDLER(handle_flash_write_image_command)
 			auto_erase = 1;
 			CMD_ARGV++;
 			CMD_ARGC--;
-			command_print(CMD_CTX, "auto erase enabled");
+			command_print(CMD, "auto erase enabled");
 		} else if (strcmp(CMD_ARGV[0], "unlock") == 0) {
 			auto_unlock = true;
 			CMD_ARGV++;
 			CMD_ARGC--;
-			command_print(CMD_CTX, "auto unlock enabled");
+			command_print(CMD, "auto unlock enabled");
 		} else
 			break;
 	}
@@ -463,7 +463,7 @@ COMMAND_HANDLER(handle_flash_write_image_command)
 	}
 
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "wrote %" PRIu32 " bytes from file %s "
+		command_print(CMD, "wrote %" PRIu32 " bytes from file %s "
 			"in %fs (%0.3f KiB/s)", written, CMD_ARGV[0],
 			duration_elapsed(&bench), duration_kbps(&bench, written));
 	}
@@ -602,7 +602,7 @@ COMMAND_HANDLER(handle_flash_fill_command)
 	}
 
 	if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "wrote %" PRIu32 " bytes to " TARGET_ADDR_FMT
+		command_print(CMD, "wrote %" PRIu32 " bytes to " TARGET_ADDR_FMT
 			" in %fs (%0.3f KiB/s)", size_bytes, address,
 			duration_elapsed(&bench), duration_kbps(&bench, size_bytes));
 	}
@@ -716,7 +716,7 @@ COMMAND_HANDLER(handle_flash_write_bank_command)
 	free(buffer);
 
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "wrote %zu bytes from file %s to flash bank %u"
+		command_print(CMD, "wrote %zu bytes from file %s to flash bank %u"
 			" at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
 			length, CMD_ARGV[1], bank->bank_number, offset,
 			duration_elapsed(&bench), duration_kbps(&bench, length));
@@ -798,7 +798,7 @@ COMMAND_HANDLER(handle_flash_read_bank_command)
 	}
 
 	if (duration_measure(&bench) == ERROR_OK)
-		command_print(CMD_CTX, "wrote %zd bytes to file %s from flash bank %u"
+		command_print(CMD, "wrote %zd bytes to file %s from flash bank %u"
 			" at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
 			written, CMD_ARGV[1], p->bank_number, offset,
 			duration_elapsed(&bench), duration_kbps(&bench, written));
@@ -900,23 +900,23 @@ COMMAND_HANDLER(handle_flash_verify_bank_command)
 	}
 
 	if (duration_measure(&bench) == ERROR_OK)
-		command_print(CMD_CTX, "read %zd bytes from file %s and flash bank %u"
+		command_print(CMD, "read %zd bytes from file %s and flash bank %u"
 			" at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
 			length, CMD_ARGV[1], p->bank_number, offset,
 			duration_elapsed(&bench), duration_kbps(&bench, length));
 
 	differ = memcmp(buffer_file, buffer_flash, length);
-	command_print(CMD_CTX, "contents %s", differ ? "differ" : "match");
+	command_print(CMD, "contents %s", differ ? "differ" : "match");
 	if (differ) {
 		uint32_t t;
 		int diffs = 0;
 		for (t = 0; t < length; t++) {
 			if (buffer_flash[t] == buffer_file[t])
 				continue;
-			command_print(CMD_CTX, "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
+			command_print(CMD, "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
 					diffs, t + offset, buffer_flash[t], buffer_file[t]);
 			if (diffs++ >= 127) {
-				command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
+				command_print(CMD, "More than 128 errors, the rest are not printed.");
 				break;
 			}
 			keep_alive();
@@ -952,7 +952,7 @@ COMMAND_HANDLER(handle_flash_padded_value_command)
 
 	COMMAND_PARSE_NUMBER(u8, CMD_ARGV[1], p->default_padded_value);
 
-	command_print(CMD_CTX, "Default padded value set to 0x%" PRIx8 " for flash bank %u", \
+	command_print(CMD, "Default padded value set to 0x%" PRIx8 " for flash bank %u", \
 			p->default_padded_value, p->bank_number);
 
 	return retval;
diff --git a/src/flash/nor/tms470.c b/src/flash/nor/tms470.c
index 195d1ae..90557b8 100644
--- a/src/flash/nor/tms470.c
+++ b/src/flash/nor/tms470.c
@@ -301,7 +301,7 @@ COMMAND_HANDLER(tms470_handle_flash_keyset_command)
 			int start = (0 == strncmp(CMD_ARGV[i], "0x", 2)) ? 2 : 0;
 
 			if (1 != sscanf(&CMD_ARGV[i][start], "%" SCNx32 "", &flashKeys[i])) {
-				command_print(CMD_CTX, "could not process flash key %s",
+				command_print(CMD, "could not process flash key %s",
 					CMD_ARGV[i]);
 				LOG_ERROR("could not process flash key %s", CMD_ARGV[i]);
 				return ERROR_COMMAND_SYNTAX_ERROR;
@@ -310,19 +310,19 @@ COMMAND_HANDLER(tms470_handle_flash_keyset_command)
 
 		keysSet = 1;
 	} else if (CMD_ARGC != 0) {
-		command_print(CMD_CTX, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
+		command_print(CMD, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	if (keysSet) {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"using flash keys 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 "",
 			flashKeys[0],
 			flashKeys[1],
 			flashKeys[2],
 			flashKeys[3]);
 	} else
-		command_print(CMD_CTX, "flash keys not set");
+		command_print(CMD, "flash keys not set");
 
 	return ERROR_OK;
 }
@@ -352,12 +352,12 @@ COMMAND_HANDLER(tms470_handle_osc_megahertz_command)
 
 	if (oscMHz <= 0) {
 		LOG_ERROR("osc_megahertz must be positive and non-zero!");
-		command_print(CMD_CTX, "osc_megahertz must be positive and non-zero!");
+		command_print(CMD, "osc_megahertz must be positive and non-zero!");
 		oscMHz = 12;
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX, "osc_megahertz=%d", oscMHz);
+	command_print(CMD, "osc_megahertz=%d", oscMHz);
 
 	return ERROR_OK;
 }
@@ -375,7 +375,7 @@ COMMAND_HANDLER(tms470_handle_plldis_command)
 		plldis = plldis ? 1 : 0;
 	}
 
-	command_print(CMD_CTX, "plldis=%d", plldis);
+	command_print(CMD, "plldis=%d", plldis);
 
 	return ERROR_OK;
 }
diff --git a/src/flash/nor/xmc4xxx.c b/src/flash/nor/xmc4xxx.c
index d85be62..d6a1ad4 100644
--- a/src/flash/nor/xmc4xxx.c
+++ b/src/flash/nor/xmc4xxx.c
@@ -1284,9 +1284,9 @@ COMMAND_HANDLER(xmc4xxx_handle_flash_password_command)
 
 	fb->pw_set = true;
 
-	command_print(CMD_CTX, "XMC4xxx flash passwords set to:\n");
-	command_print(CMD_CTX, "-0x%08"PRIx32"\n", fb->pw1);
-	command_print(CMD_CTX, "-0x%08"PRIx32"\n", fb->pw2);
+	command_print(CMD, "XMC4xxx flash passwords set to:\n");
+	command_print(CMD, "-0x%08"PRIx32"\n", fb->pw1);
+	command_print(CMD, "-0x%08"PRIx32"\n", fb->pw2);
 	return ERROR_OK;
 }
 
diff --git a/src/hello.c b/src/hello.c
index 2afbba3..a1c00c0 100644
--- a/src/hello.c
+++ b/src/hello.c
@@ -89,7 +89,7 @@ COMMAND_HANDLER(handle_hello_command)
 	const char *sep, *name;
 	int retval = CALL_COMMAND_HANDLER(handle_hello_args, &sep, &name);
 	if (ERROR_OK == retval)
-		command_print(CMD_CTX, "Greetings%s%s!", sep, name);
+		command_print(CMD, "Greetings%s%s!", sep, name);
 	return retval;
 }
 
diff --git a/src/helper/command.c b/src/helper/command.c
index aadc072..be131bb 100644
--- a/src/helper/command.c
+++ b/src/helper/command.c
@@ -502,7 +502,7 @@ void command_output_text(struct command_context *context, const char *data)
 		context->output_handler(context, data);
 }
 
-void command_print_sameline(struct command_context *context, const char *format, ...)
+void command_print_sameline(struct command_invocation *cmd, const char *format, ...)
 {
 	char *string;
 
@@ -525,7 +525,7 @@ void command_print_sameline(struct command_context *context, const char *format,
 	va_end(ap);
 }
 
-void command_print(struct command_context *context, const char *format, ...)
+void command_print(struct command_invocation *cmd, const char *format, ...)
 {
 	char *string;
 
diff --git a/src/helper/command.h b/src/helper/command.h
index 9aed282..41cdc0b 100644
--- a/src/helper/command.h
+++ b/src/helper/command.h
@@ -353,9 +353,9 @@ struct command_context *copy_command_context(struct command_context *cmd_ctx);
  */
 void command_done(struct command_context *context);
 
-void command_print(struct command_context *context, const char *format, ...)
+void command_print(struct command_invocation *cmd, const char *format, ...)
 __attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
-void command_print_sameline(struct command_context *context, const char *format, ...)
+void command_print_sameline(struct command_invocation *cmd, const char *format, ...)
 __attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
 int command_run_line(struct command_context *context, char *line);
 int command_run_linef(struct command_context *context, const char *format, ...)
@@ -409,7 +409,7 @@ DECLARE_PARSE_WRAPPER(_target_addr, target_addr_t);
 	do { \
 		int retval_macro_tmp = parse_ ## type(in, &(out)); \
 		if (ERROR_OK != retval_macro_tmp) { \
-			command_print(CMD_CTX, stringify(out) \
+			command_print(CMD, stringify(out) \
 				" option value ('%s') is not valid", in); \
 			return retval_macro_tmp; \
 		} \
@@ -429,9 +429,9 @@ DECLARE_PARSE_WRAPPER(_target_addr, target_addr_t);
 		bool value; \
 		int retval_macro_tmp = command_parse_bool_arg(in, &value); \
 		if (ERROR_OK != retval_macro_tmp) { \
-			command_print(CMD_CTX, stringify(out) \
+			command_print(CMD, stringify(out) \
 				" option value ('%s') is not valid", in); \
-			command_print(CMD_CTX, "  choices are '%s' or '%s'", \
+			command_print(CMD, "  choices are '%s' or '%s'", \
 				on, off); \
 			return retval_macro_tmp; \
 		} \
diff --git a/src/helper/ioutil.c b/src/helper/ioutil.c
index a488799..d4f39e2 100644
--- a/src/helper/ioutil.c
+++ b/src/helper/ioutil.c
@@ -113,10 +113,10 @@ COMMAND_HANDLER(handle_cat_command)
 
 	int retval = load_file(CMD_ARGV[0], &data, &len);
 	if (retval == ERROR_OK) {
-		command_print(CMD_CTX, "%s", data);
+		command_print(CMD, "%s", data);
 		free(data);
 	} else
-		command_print(CMD_CTX, "%s not found", CMD_ARGV[0]);
+		command_print(CMD, "%s not found", CMD_ARGV[0]);
 
 	return ERROR_OK;
 }
@@ -146,10 +146,10 @@ COMMAND_HANDLER(handle_meminfo_command)
 	info = mallinfo();
 
 	if (prev > 0)
-		command_print(CMD_CTX, "Diff:            %d", prev - info.fordblks);
+		command_print(CMD, "Diff:            %d", prev - info.fordblks);
 	prev = info.fordblks;
 
-	command_print(CMD_CTX, "Available ram:   %d", info.fordblks);
+	command_print(CMD, "Available ram:   %d", info.fordblks);
 
 	return ERROR_OK;
 }
@@ -217,7 +217,7 @@ COMMAND_HANDLER(handle_cp_command)
 		if (retval != ERROR_OK)
 			break;
 
-		command_print(CMD_CTX, "%zu", len - pos);
+		command_print(CMD, "%zu", len - pos);
 
 		pos += chunk;
 
@@ -226,9 +226,9 @@ COMMAND_HANDLER(handle_cp_command)
 	}
 
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "Copied %s to %s", CMD_ARGV[0], CMD_ARGV[1]);
+		command_print(CMD, "Copied %s to %s", CMD_ARGV[0], CMD_ARGV[1]);
 	else
-		command_print(CMD_CTX, "copy failed");
+		command_print(CMD, "copy failed");
 
 	if (data != NULL)
 		free(data);
diff --git a/src/helper/log.c b/src/helper/log.c
index 90653c4..d65430c 100644
--- a/src/helper/log.c
+++ b/src/helper/log.c
@@ -213,7 +213,7 @@ COMMAND_HANDLER(handle_debug_level_command)
 	} else if (CMD_ARGC > 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX, "debug_level: %i", debug_level);
+	command_print(CMD, "debug_level: %i", debug_level);
 
 	return ERROR_OK;
 }
diff --git a/src/jtag/adapter.c b/src/jtag/adapter.c
index 24706f5..0a887ef 100644
--- a/src/jtag/adapter.c
+++ b/src/jtag/adapter.c
@@ -114,10 +114,10 @@ COMMAND_HANDLER(handle_interface_list_command)
 	if (strcmp(CMD_NAME, "interface_list") == 0 && CMD_ARGC > 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX, "The following debug interfaces are available:");
+	command_print(CMD, "The following debug interfaces are available:");
 	for (unsigned i = 0; NULL != jtag_interfaces[i]; i++) {
 		const char *name = jtag_interfaces[i]->name;
-		command_print(CMD_CTX, "%u: %s", i + 1, name);
+		command_print(CMD, "%u: %s", i + 1, name);
 	}
 
 	return ERROR_OK;
@@ -394,7 +394,7 @@ next:
 		modes[5] = "";
 	}
 
-	command_print(CMD_CTX, "%s %s%s%s%s%s",
+	command_print(CMD, "%s %s%s%s%s%s",
 			modes[0], modes[1],
 			modes[2], modes[3], modes[4], modes[5]);
 
@@ -411,7 +411,7 @@ COMMAND_HANDLER(handle_adapter_nsrst_delay_command)
 
 		jtag_set_nsrst_delay(delay);
 	}
-	command_print(CMD_CTX, "adapter_nsrst_delay: %u", jtag_get_nsrst_delay());
+	command_print(CMD, "adapter_nsrst_delay: %u", jtag_get_nsrst_delay());
 	return ERROR_OK;
 }
 
@@ -425,7 +425,7 @@ COMMAND_HANDLER(handle_adapter_nsrst_assert_width_command)
 
 		jtag_set_nsrst_assert_width(width);
 	}
-	command_print(CMD_CTX, "adapter_nsrst_assert_width: %u", jtag_get_nsrst_assert_width());
+	command_print(CMD, "adapter_nsrst_assert_width: %u", jtag_get_nsrst_assert_width());
 	return ERROR_OK;
 }
 
@@ -450,9 +450,9 @@ COMMAND_HANDLER(handle_adapter_khz_command)
 		return retval;
 
 	if (cur_speed)
-		command_print(CMD_CTX, "adapter speed: %d kHz", cur_speed);
+		command_print(CMD, "adapter speed: %d kHz", cur_speed);
 	else
-		command_print(CMD_CTX, "adapter speed: RCLK - adaptive");
+		command_print(CMD, "adapter speed: RCLK - adaptive");
 
 	return retval;
 }
@@ -464,7 +464,7 @@ COMMAND_HANDLER(handle_usb_location_command)
 	if (CMD_ARGC == 1)
 		jtag_usb_set_location(CMD_ARGV[0]);
 
-	command_print(CMD_CTX, "adapter usb location: %s", jtag_usb_get_location());
+	command_print(CMD, "adapter usb location: %s", jtag_usb_get_location());
 
 	return ERROR_OK;
 }
diff --git a/src/jtag/aice/aice_interface.c b/src/jtag/aice/aice_interface.c
index c758bb4..2aac5e9 100644
--- a/src/jtag/aice/aice_interface.c
+++ b/src/jtag/aice/aice_interface.c
@@ -269,10 +269,10 @@ COMMAND_HANDLER(aice_handle_aice_info_command)
 {
 	LOG_DEBUG("aice_handle_aice_info_command");
 
-	command_print(CMD_CTX, "Description: %s", param.device_desc);
-	command_print(CMD_CTX, "Serial number: %s", param.serial);
+	command_print(CMD, "Description: %s", param.device_desc);
+	command_print(CMD, "Serial number: %s", param.serial);
 	if (strncmp(aice_port->name, "aice_pipe", 9) == 0)
-		command_print(CMD_CTX, "Adapter: %s", param.adapter_name);
+		command_print(CMD, "Adapter: %s", param.adapter_name);
 
 	return ERROR_OK;
 }
diff --git a/src/jtag/aice/aice_transport.c b/src/jtag/aice/aice_transport.c
index 0658318..15ebcac 100644
--- a/src/jtag/aice/aice_transport.c
+++ b/src/jtag/aice/aice_transport.c
@@ -165,9 +165,9 @@ COMMAND_HANDLER(handle_scan_chain_command)
 
 	aice_scan_jtag_chain();
 	tap = jtag_all_taps();
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"   TapName             Enabled  IdCode     Expected   IrLen IrCap IrMask");
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"-- ------------------- -------- ---------- ---------- ----- ----- ------");
 
 	while (tap) {
@@ -183,7 +183,7 @@ COMMAND_HANDLER(handle_scan_chain_command)
 		expected = buf_get_u32(tap->expected, 0, tap->ir_length);
 		expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
 
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"%2d %-18s     %c     0x%08x %s %5d 0x%02x  0x%02x",
 			tap->abs_chain_position,
 			tap->dotted_name,
@@ -200,7 +200,7 @@ COMMAND_HANDLER(handle_scan_chain_command)
 			if (tap->ignore_version)
 				expected_id[2] = '*';
 
-			command_print(CMD_CTX,
+			command_print(CMD,
 				"                                           %s",
 				expected_id);
 		}
diff --git a/src/jtag/drivers/amt_jtagaccel.c b/src/jtag/drivers/amt_jtagaccel.c
index 57c0ce6..9808e34 100644
--- a/src/jtag/drivers/amt_jtagaccel.c
+++ b/src/jtag/drivers/amt_jtagaccel.c
@@ -548,7 +548,7 @@ COMMAND_HANDLER(amt_jtagaccel_handle_parport_port_command)
 		}
 	}
 
-	command_print(CMD_CTX, "parport port = %u", amt_jtagaccel_port);
+	command_print(CMD, "parport port = %u", amt_jtagaccel_port);
 
 	return ERROR_OK;
 }
@@ -556,7 +556,7 @@ COMMAND_HANDLER(amt_jtagaccel_handle_parport_port_command)
 COMMAND_HANDLER(amt_jtagaccel_handle_rtck_command)
 {
 	if (CMD_ARGC == 0) {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"amt_jtagaccel RTCK feature %s",
 			(rtck_enabled) ? "enabled" : "disabled");
 		return ERROR_OK;
diff --git a/src/jtag/drivers/bcm2835gpio.c b/src/jtag/drivers/bcm2835gpio.c
index 926bd89..edec4be 100644
--- a/src/jtag/drivers/bcm2835gpio.c
+++ b/src/jtag/drivers/bcm2835gpio.c
@@ -199,7 +199,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionums)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"BCM2835 GPIO config: tck = %d, tms = %d, tdi = %d, tdo = %d",
 			tck_gpio, tms_gpio, tdi_gpio, tdo_gpio);
 
@@ -211,7 +211,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_tck)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio);
 
-	command_print(CMD_CTX, "BCM2835 GPIO config: tck = %d", tck_gpio);
+	command_print(CMD, "BCM2835 GPIO config: tck = %d", tck_gpio);
 	return ERROR_OK;
 }
 
@@ -220,7 +220,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_tms)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio);
 
-	command_print(CMD_CTX, "BCM2835 GPIO config: tms = %d", tms_gpio);
+	command_print(CMD, "BCM2835 GPIO config: tms = %d", tms_gpio);
 	return ERROR_OK;
 }
 
@@ -229,7 +229,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_tdo)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio);
 
-	command_print(CMD_CTX, "BCM2835 GPIO config: tdo = %d", tdo_gpio);
+	command_print(CMD, "BCM2835 GPIO config: tdo = %d", tdo_gpio);
 	return ERROR_OK;
 }
 
@@ -238,7 +238,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_tdi)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio);
 
-	command_print(CMD_CTX, "BCM2835 GPIO config: tdi = %d", tdi_gpio);
+	command_print(CMD, "BCM2835 GPIO config: tdi = %d", tdi_gpio);
 	return ERROR_OK;
 }
 
@@ -247,7 +247,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_srst)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio);
 
-	command_print(CMD_CTX, "BCM2835 GPIO config: srst = %d", srst_gpio);
+	command_print(CMD, "BCM2835 GPIO config: srst = %d", srst_gpio);
 	return ERROR_OK;
 }
 
@@ -256,7 +256,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_trst)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio);
 
-	command_print(CMD_CTX, "BCM2835 GPIO config: trst = %d", trst_gpio);
+	command_print(CMD, "BCM2835 GPIO config: trst = %d", trst_gpio);
 	return ERROR_OK;
 }
 
@@ -269,7 +269,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_swd_gpionums)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"BCM2835 GPIO nums: swclk = %d, swdio = %d",
 			swclk_gpio, swdio_gpio);
 
@@ -281,7 +281,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_swd_gpionum_swclk)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio);
 
-	command_print(CMD_CTX, "BCM2835 num: swclk = %d", swclk_gpio);
+	command_print(CMD, "BCM2835 num: swclk = %d", swclk_gpio);
 	return ERROR_OK;
 }
 
@@ -290,7 +290,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_swd_gpionum_swdio)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio);
 
-	command_print(CMD_CTX, "BCM2835 num: swdio = %d", swdio_gpio);
+	command_print(CMD, "BCM2835 num: swdio = %d", swdio_gpio);
 	return ERROR_OK;
 }
 
diff --git a/src/jtag/drivers/ft232r.c b/src/jtag/drivers/ft232r.c
index e16bcdc..0389427 100644
--- a/src/jtag/drivers/ft232r.c
+++ b/src/jtag/drivers/ft232r.c
@@ -442,7 +442,7 @@ COMMAND_HANDLER(ft232r_handle_jtag_nums_command)
 	if (tdo_gpio < 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"FT232R nums: TCK = %d %s, TMS = %d %s, TDI = %d %s, TDO = %d %s",
 			tck_gpio, ft232r_bit_number_to_name(tck_gpio),
 			tms_gpio, ft232r_bit_number_to_name(tms_gpio),
@@ -462,7 +462,7 @@ COMMAND_HANDLER(ft232r_handle_tck_num_command)
 	if (tck_gpio < 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"FT232R num: TCK = %d %s", tck_gpio, ft232r_bit_number_to_name(tck_gpio));
 
 	return ERROR_OK;
@@ -478,7 +478,7 @@ COMMAND_HANDLER(ft232r_handle_tms_num_command)
 	if (tms_gpio < 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"FT232R num: TMS = %d %s", tms_gpio, ft232r_bit_number_to_name(tms_gpio));
 
 	return ERROR_OK;
@@ -494,7 +494,7 @@ COMMAND_HANDLER(ft232r_handle_tdo_num_command)
 	if (tdo_gpio < 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"FT232R num: TDO = %d %s", tdo_gpio, ft232r_bit_number_to_name(tdo_gpio));
 
 	return ERROR_OK;
@@ -510,7 +510,7 @@ COMMAND_HANDLER(ft232r_handle_tdi_num_command)
 	if (tdi_gpio < 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"FT232R num: TDI = %d %s", tdi_gpio, ft232r_bit_number_to_name(tdi_gpio));
 
 	return ERROR_OK;
@@ -526,7 +526,7 @@ COMMAND_HANDLER(ft232r_handle_trst_num_command)
 	if (ntrst_gpio < 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"FT232R num: TRST = %d %s", ntrst_gpio, ft232r_bit_number_to_name(ntrst_gpio));
 
 	return ERROR_OK;
@@ -542,7 +542,7 @@ COMMAND_HANDLER(ft232r_handle_srst_num_command)
 	if (nsysrst_gpio < 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"FT232R num: SRST = %d %s", nsysrst_gpio, ft232r_bit_number_to_name(nsysrst_gpio));
 
 	return ERROR_OK;
@@ -555,7 +555,7 @@ COMMAND_HANDLER(ft232r_handle_restore_serial_command)
 	else if (CMD_ARGC != 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"FT232R restore serial: 0x%04X (%s)",
 			ft232r_restore_bitmode, ft232r_restore_bitmode == 0xFFFF ? "disabled" : "enabled");
 
diff --git a/src/jtag/drivers/ftdi.c b/src/jtag/drivers/ftdi.c
index e7f3c3d..00ae8d0 100644
--- a/src/jtag/drivers/ftdi.c
+++ b/src/jtag/drivers/ftdi.c
@@ -930,7 +930,7 @@ COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command)
 	}
 
 	n = Jim_Nvp_value2name_simple(nvp_ftdi_jtag_modes, ftdi_jtag_mode);
-	command_print(CMD_CTX, "ftdi samples TDO on %s edge of TCK", n->name);
+	command_print(CMD, "ftdi samples TDO on %s edge of TCK", n->name);
 
 	return ERROR_OK;
 }
diff --git a/src/jtag/drivers/gw16012.c b/src/jtag/drivers/gw16012.c
index f668996..f91f7ac 100644
--- a/src/jtag/drivers/gw16012.c
+++ b/src/jtag/drivers/gw16012.c
@@ -515,7 +515,7 @@ COMMAND_HANDLER(gw16012_handle_parport_port_command)
 		}
 	}
 
-	command_print(CMD_CTX, "parport port = %u", gw16012_port);
+	command_print(CMD, "parport port = %u", gw16012_port);
 
 	return ERROR_OK;
 }
diff --git a/src/jtag/drivers/imx_gpio.c b/src/jtag/drivers/imx_gpio.c
index 8f172c2..196d0e4 100644
--- a/src/jtag/drivers/imx_gpio.c
+++ b/src/jtag/drivers/imx_gpio.c
@@ -221,7 +221,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionums)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"imx_gpio GPIO config: tck = %d, tms = %d, tdi = %d, tdo = %d",
 			tck_gpio, tms_gpio, tdi_gpio, tdo_gpio);
 
@@ -233,7 +233,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_tck)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio);
 
-	command_print(CMD_CTX, "imx_gpio GPIO config: tck = %d", tck_gpio);
+	command_print(CMD, "imx_gpio GPIO config: tck = %d", tck_gpio);
 	return ERROR_OK;
 }
 
@@ -242,7 +242,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_tms)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio);
 
-	command_print(CMD_CTX, "imx_gpio GPIO config: tms = %d", tms_gpio);
+	command_print(CMD, "imx_gpio GPIO config: tms = %d", tms_gpio);
 	return ERROR_OK;
 }
 
@@ -251,7 +251,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_tdo)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio);
 
-	command_print(CMD_CTX, "imx_gpio GPIO config: tdo = %d", tdo_gpio);
+	command_print(CMD, "imx_gpio GPIO config: tdo = %d", tdo_gpio);
 	return ERROR_OK;
 }
 
@@ -260,7 +260,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_tdi)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio);
 
-	command_print(CMD_CTX, "imx_gpio GPIO config: tdi = %d", tdi_gpio);
+	command_print(CMD, "imx_gpio GPIO config: tdi = %d", tdi_gpio);
 	return ERROR_OK;
 }
 
@@ -269,7 +269,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_srst)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio);
 
-	command_print(CMD_CTX, "imx_gpio GPIO config: srst = %d", srst_gpio);
+	command_print(CMD, "imx_gpio GPIO config: srst = %d", srst_gpio);
 	return ERROR_OK;
 }
 
@@ -278,7 +278,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_trst)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio);
 
-	command_print(CMD_CTX, "imx_gpio GPIO config: trst = %d", trst_gpio);
+	command_print(CMD, "imx_gpio GPIO config: trst = %d", trst_gpio);
 	return ERROR_OK;
 }
 
@@ -291,7 +291,7 @@ COMMAND_HANDLER(imx_gpio_handle_swd_gpionums)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"imx_gpio GPIO nums: swclk = %d, swdio = %d",
 			swclk_gpio, swdio_gpio);
 
@@ -303,7 +303,7 @@ COMMAND_HANDLER(imx_gpio_handle_swd_gpionum_swclk)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio);
 
-	command_print(CMD_CTX, "imx_gpio num: swclk = %d", swclk_gpio);
+	command_print(CMD, "imx_gpio num: swclk = %d", swclk_gpio);
 	return ERROR_OK;
 }
 
@@ -312,7 +312,7 @@ COMMAND_HANDLER(imx_gpio_handle_swd_gpionum_swdio)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio);
 
-	command_print(CMD_CTX, "imx_gpio num: swdio = %d", swdio_gpio);
+	command_print(CMD, "imx_gpio num: swdio = %d", swdio_gpio);
 	return ERROR_OK;
 }
 
diff --git a/src/jtag/drivers/jlink.c b/src/jtag/drivers/jlink.c
index 090eeaa..cc04953 100644
--- a/src/jtag/drivers/jlink.c
+++ b/src/jtag/drivers/jlink.c
@@ -923,17 +923,17 @@ COMMAND_HANDLER(jlink_usb_command)
 	int tmp;
 
 	if (CMD_ARGC != 1) {
-		command_print(CMD_CTX, "Need exactly one argument for jlink usb.");
+		command_print(CMD, "Need exactly one argument for jlink usb.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) {
-		command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
+		command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
 	if (tmp < JAYLINK_USB_ADDRESS_0 || tmp > JAYLINK_USB_ADDRESS_3) {
-		command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
+		command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -950,17 +950,17 @@ COMMAND_HANDLER(jlink_serial_command)
 	int ret;
 
 	if (CMD_ARGC != 1) {
-		command_print(CMD_CTX, "Need exactly one argument for jlink serial.");
+		command_print(CMD, "Need exactly one argument for jlink serial.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	ret = jaylink_parse_serial_number(CMD_ARGV[0], &serial_number);
 
 	if (ret == JAYLINK_ERR) {
-		command_print(CMD_CTX, "Invalid serial number: %s.", CMD_ARGV[0]);
+		command_print(CMD, "Invalid serial number: %s.", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	} else if (ret != JAYLINK_OK) {
-		command_print(CMD_CTX, "jaylink_parse_serial_number() failed: %s.",
+		command_print(CMD, "jaylink_parse_serial_number() failed: %s.",
 			jaylink_strerror(ret));
 		return ERROR_FAIL;
 	}
@@ -979,20 +979,20 @@ COMMAND_HANDLER(jlink_handle_hwstatus_command)
 	ret = jaylink_get_hardware_status(devh, &status);
 
 	if (ret != JAYLINK_OK) {
-		command_print(CMD_CTX, "jaylink_get_hardware_status() failed: %s.",
+		command_print(CMD, "jaylink_get_hardware_status() failed: %s.",
 			jaylink_strerror(ret));
 		return ERROR_FAIL;
 	}
 
-	command_print(CMD_CTX, "VTarget = %u.%03u V",
+	command_print(CMD, "VTarget = %u.%03u V",
 		status.target_voltage / 1000, status.target_voltage % 1000);
 
-	command_print(CMD_CTX, "TCK = %u TDI = %u TDO = %u TMS = %u SRST = %u "
+	command_print(CMD, "TCK = %u TDI = %u TDO = %u TMS = %u SRST = %u "
 		"TRST = %u", status.tck, status.tdi, status.tdo, status.tms,
 		status.tres, status.trst);
 
 	if (status.target_voltage < 1500)
-		command_print(CMD_CTX, "Target voltage too low. Check target power.");
+		command_print(CMD, "Target voltage too low. Check target power.");
 
 	return ERROR_OK;
 }
@@ -1003,7 +1003,7 @@ COMMAND_HANDLER(jlink_handle_free_memory_command)
 	uint32_t tmp;
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY)) {
-		command_print(CMD_CTX, "Retrieval of free memory is not supported by "
+		command_print(CMD, "Retrieval of free memory is not supported by "
 			"the device.");
 		return ERROR_OK;
 	}
@@ -1011,12 +1011,12 @@ COMMAND_HANDLER(jlink_handle_free_memory_command)
 	ret = jaylink_get_free_memory(devh, &tmp);
 
 	if (ret != JAYLINK_OK) {
-		command_print(CMD_CTX, "jaylink_get_free_memory() failed: %s.",
+		command_print(CMD, "jaylink_get_free_memory() failed: %s.",
 			jaylink_strerror(ret));
 		return ERROR_FAIL;
 	}
 
-	command_print(CMD_CTX, "Device has %u bytes of free memory.", tmp);
+	command_print(CMD, "Device has %u bytes of free memory.", tmp);
 
 	return ERROR_OK;
 }
@@ -1038,10 +1038,10 @@ COMMAND_HANDLER(jlink_handle_jlink_jtag_command)
 				return ERROR_FAIL;
 		}
 
-		command_print(CMD_CTX, "JTAG command version: %i", version);
+		command_print(CMD, "JTAG command version: %i", version);
 	} else if (CMD_ARGC == 1) {
 		if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) {
-			command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
+			command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 
@@ -1053,11 +1053,11 @@ COMMAND_HANDLER(jlink_handle_jlink_jtag_command)
 				jtag_command_version = JAYLINK_JTAG_VERSION_3;
 				break;
 			default:
-				command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
+				command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
 				return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 	} else {
-		command_print(CMD_CTX, "Need exactly one argument for jlink jtag.");
+		command_print(CMD, "Need exactly one argument for jlink jtag.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1070,13 +1070,13 @@ COMMAND_HANDLER(jlink_handle_target_power_command)
 	int enable;
 
 	if (CMD_ARGC != 1) {
-		command_print(CMD_CTX, "Need exactly one argument for jlink "
+		command_print(CMD, "Need exactly one argument for jlink "
 			"targetpower.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
-		command_print(CMD_CTX, "Target power supply is not supported by the "
+		command_print(CMD, "Target power supply is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
@@ -1086,14 +1086,14 @@ COMMAND_HANDLER(jlink_handle_target_power_command)
 	} else if (!strcmp(CMD_ARGV[0], "off")) {
 		enable = false;
 	} else {
-		command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
+		command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
 	ret = jaylink_set_target_power(devh, enable);
 
 	if (ret != JAYLINK_OK) {
-		command_print(CMD_CTX, "jaylink_set_target_power() failed: %s.",
+		command_print(CMD, "jaylink_set_target_power() failed: %s.",
 			jaylink_strerror(ret));
 		return ERROR_FAIL;
 	}
@@ -1104,31 +1104,31 @@ COMMAND_HANDLER(jlink_handle_target_power_command)
 static void show_config_usb_address(struct command_invocation *cmd)
 {
 	if (config.usb_address != tmp_config.usb_address)
-		command_print(cmd->ctx, "USB address: %u [%u]", config.usb_address,
+		command_print(cmd, "USB address: %u [%u]", config.usb_address,
 			tmp_config.usb_address);
 	else
-		command_print(cmd->ctx, "USB address: %u", config.usb_address);
+		command_print(cmd, "USB address: %u", config.usb_address);
 }
 
 static void show_config_ip_address(struct command_invocation *cmd)
 {
 	if (!memcmp(config.ip_address, tmp_config.ip_address, 4))
-		command_print(cmd->ctx, "IP address: %d.%d.%d.%d",
+		command_print(cmd, "IP address: %d.%d.%d.%d",
 			config.ip_address[3], config.ip_address[2],
 			config.ip_address[1], config.ip_address[0]);
 	else
-		command_print(cmd->ctx, "IP address: %d.%d.%d.%d [%d.%d.%d.%d]",
+		command_print(cmd, "IP address: %d.%d.%d.%d [%d.%d.%d.%d]",
 			config.ip_address[3], config.ip_address[2],
 			config.ip_address[1], config.ip_address[0],
 			tmp_config.ip_address[3], tmp_config.ip_address[2],
 			tmp_config.ip_address[1], tmp_config.ip_address[0]);
 
 	if (!memcmp(config.subnet_mask, tmp_config.subnet_mask, 4))
-		command_print(cmd->ctx, "Subnet mask: %d.%d.%d.%d",
+		command_print(cmd, "Subnet mask: %d.%d.%d.%d",
 			config.subnet_mask[3], config.subnet_mask[2],
 			config.subnet_mask[1], config.subnet_mask[0]);
 	else
-		command_print(cmd->ctx, "Subnet mask: %d.%d.%d.%d [%d.%d.%d.%d]",
+		command_print(cmd, "Subnet mask: %d.%d.%d.%d [%d.%d.%d.%d]",
 			config.subnet_mask[3], config.subnet_mask[2],
 			config.subnet_mask[1], config.subnet_mask[0],
 			tmp_config.subnet_mask[3], tmp_config.subnet_mask[2],
@@ -1138,12 +1138,12 @@ static void show_config_ip_address(struct command_invocation *cmd)
 static void show_config_mac_address(struct command_invocation *cmd)
 {
 	if (!memcmp(config.mac_address, tmp_config.mac_address, 6))
-		command_print(cmd->ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
+		command_print(cmd, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
 			config.mac_address[5], config.mac_address[4],
 			config.mac_address[3], config.mac_address[2],
 			config.mac_address[1], config.mac_address[0]);
 	else
-		command_print(cmd->ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x "
+		command_print(cmd, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x "
 			"[%.02x:%.02x:%.02x:%.02x:%.02x:%.02x]",
 			config.mac_address[5], config.mac_address[4],
 			config.mac_address[3], config.mac_address[2],
@@ -1169,15 +1169,15 @@ static void show_config_target_power(struct command_invocation *cmd)
 		current_target_power = "on";
 
 	if (config.target_power != tmp_config.target_power)
-		command_print(cmd->ctx, "Target power supply: %s [%s]", target_power,
+		command_print(cmd, "Target power supply: %s [%s]", target_power,
 			current_target_power);
 	else
-		command_print(cmd->ctx, "Target power supply: %s", target_power);
+		command_print(cmd, "Target power supply: %s", target_power);
 }
 
 static void show_config(struct command_invocation *cmd)
 {
-	command_print(cmd->ctx, "J-Link device configuration:");
+	command_print(cmd, "J-Link device configuration:");
 
 	show_config_usb_address(cmd);
 
@@ -1346,7 +1346,7 @@ COMMAND_HANDLER(jlink_handle_config_usb_address_command)
 	uint8_t tmp;
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
-		command_print(CMD_CTX, "Reading configuration is not supported by the "
+		command_print(CMD, "Reading configuration is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
@@ -1355,18 +1355,18 @@ COMMAND_HANDLER(jlink_handle_config_usb_address_command)
 		show_config_usb_address(CMD);
 	} else if (CMD_ARGC == 1) {
 		if (sscanf(CMD_ARGV[0], "%" SCNd8, &tmp) != 1) {
-			command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
+			command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]);
 			return ERROR_FAIL;
 		}
 
 		if (tmp > JAYLINK_USB_ADDRESS_3) {
-			command_print(CMD_CTX, "Invalid USB address: %u.", tmp);
+			command_print(CMD, "Invalid USB address: %u.", tmp);
 			return ERROR_FAIL;
 		}
 
 		tmp_config.usb_address = tmp;
 	} else {
-		command_print(CMD_CTX, "Need exactly one argument for jlink config "
+		command_print(CMD, "Need exactly one argument for jlink config "
 			"usb.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
@@ -1379,13 +1379,13 @@ COMMAND_HANDLER(jlink_handle_config_target_power_command)
 	int enable;
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
-		command_print(CMD_CTX, "Reading configuration is not supported by the "
+		command_print(CMD, "Reading configuration is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
-		command_print(CMD_CTX, "Target power supply is not supported by the "
+		command_print(CMD, "Target power supply is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
@@ -1398,13 +1398,13 @@ COMMAND_HANDLER(jlink_handle_config_target_power_command)
 		} else if (!strcmp(CMD_ARGV[0], "off")) {
 			enable = false;
 		} else {
-			command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
+			command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
 			return ERROR_FAIL;
 		}
 
 		tmp_config.target_power = enable;
 	} else {
-		command_print(CMD_CTX, "Need exactly one argument for jlink config "
+		command_print(CMD, "Need exactly one argument for jlink config "
 			"targetpower.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
@@ -1420,13 +1420,13 @@ COMMAND_HANDLER(jlink_handle_config_mac_address_command)
 	const char *str;
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
-		command_print(CMD_CTX, "Reading configuration is not supported by the "
+		command_print(CMD, "Reading configuration is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
-		command_print(CMD_CTX, "Ethernet connectivity is not supported by the "
+		command_print(CMD, "Ethernet connectivity is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
@@ -1438,7 +1438,7 @@ COMMAND_HANDLER(jlink_handle_config_mac_address_command)
 
 		if ((strlen(str) != 17) || (str[2] != ':' || str[5] != ':' || \
 				str[8] != ':' || str[11] != ':' || str[14] != ':')) {
-			command_print(CMD_CTX, "Invalid MAC address format.");
+			command_print(CMD, "Invalid MAC address format.");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 
@@ -1448,18 +1448,18 @@ COMMAND_HANDLER(jlink_handle_config_mac_address_command)
 		}
 
 		if (!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5])) {
-			command_print(CMD_CTX, "Invalid MAC address: zero address.");
+			command_print(CMD, "Invalid MAC address: zero address.");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 
 		if (!(0x01 & addr[0])) {
-			command_print(CMD_CTX, "Invalid MAC address: multicast address.");
+			command_print(CMD, "Invalid MAC address: multicast address.");
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 
 		memcpy(tmp_config.mac_address, addr, sizeof(addr));
 	} else {
-		command_print(CMD_CTX, "Need exactly one argument for jlink config "
+		command_print(CMD, "Need exactly one argument for jlink config "
 			" mac.");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
@@ -1508,13 +1508,13 @@ COMMAND_HANDLER(jlink_handle_config_ip_address_command)
 	uint8_t subnet_bits = 24;
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
-		command_print(CMD_CTX, "Reading configuration is not supported by the "
+		command_print(CMD, "Reading configuration is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
-		command_print(CMD_CTX, "Ethernet connectivity is not supported by the "
+		command_print(CMD, "Ethernet connectivity is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
@@ -1565,19 +1565,19 @@ COMMAND_HANDLER(jlink_handle_config_write_command)
 	int ret;
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
-		command_print(CMD_CTX, "Reading configuration is not supported by the "
+		command_print(CMD, "Reading configuration is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
 
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_WRITE_CONFIG)) {
-		command_print(CMD_CTX, "Writing configuration is not supported by the "
+		command_print(CMD, "Writing configuration is not supported by the "
 			"device.");
 		return ERROR_OK;
 	}
 
 	if (!memcmp(&config, &tmp_config, sizeof(struct device_config))) {
-		command_print(CMD_CTX, "Operation not performed due to no changes in "
+		command_print(CMD, "Operation not performed due to no changes in "
 			"the configuration.");
 		return ERROR_OK;
 	}
@@ -1602,7 +1602,7 @@ COMMAND_HANDLER(jlink_handle_config_write_command)
 	}
 
 	memcpy(&tmp_config, &config, sizeof(struct device_config));
-	command_print(CMD_CTX, "The new device configuration applies after power "
+	command_print(CMD, "The new device configuration applies after power "
 		"cycling the J-Link device.");
 
 	return ERROR_OK;
@@ -1611,7 +1611,7 @@ COMMAND_HANDLER(jlink_handle_config_write_command)
 COMMAND_HANDLER(jlink_handle_config_command)
 {
 	if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
-		command_print(CMD_CTX, "Device doesn't support reading configuration.");
+		command_print(CMD, "Device doesn't support reading configuration.");
 		return ERROR_OK;
 	}
 
@@ -1732,7 +1732,7 @@ COMMAND_HANDLER(jlink_handle_emucom_read_command)
 		return ERROR_FAIL;
 	}
 
-	command_print(CMD_CTX, "%s", buf + length);
+	command_print(CMD, "%s", buf + length);
 	free(buf);
 
 	return ERROR_OK;
diff --git a/src/jtag/drivers/opendous.c b/src/jtag/drivers/opendous.c
index cec453d..2f8b524 100644
--- a/src/jtag/drivers/opendous.c
+++ b/src/jtag/drivers/opendous.c
@@ -185,7 +185,7 @@ COMMAND_HANDLER(opendous_handle_opendous_hw_jtag_command)
 {
 	switch (CMD_ARGC) {
 		case 0:
-			command_print(CMD_CTX, "opendous hw jtag  %i", opendous_hw_jtag_version);
+			command_print(CMD, "opendous hw jtag  %i", opendous_hw_jtag_version);
 			break;
 
 		case 1: {
diff --git a/src/jtag/drivers/parport.c b/src/jtag/drivers/parport.c
index 14fa9df..0e7992f 100644
--- a/src/jtag/drivers/parport.c
+++ b/src/jtag/drivers/parport.c
@@ -413,7 +413,7 @@ COMMAND_HANDLER(parport_handle_parport_port_command)
 		}
 	}
 
-	command_print(CMD_CTX, "parport port = 0x%" PRIx16 "", parport_port);
+	command_print(CMD, "parport port = 0x%" PRIx16 "", parport_port);
 
 	return ERROR_OK;
 }
@@ -470,7 +470,7 @@ COMMAND_HANDLER(parport_handle_parport_toggling_time_command)
 		}
 	}
 
-	command_print(CMD_CTX, "parport toggling time = %" PRIu32 " ns",
+	command_print(CMD, "parport toggling time = %" PRIu32 " ns",
 			parport_toggling_time_ns);
 
 	return ERROR_OK;
diff --git a/src/jtag/drivers/sysfsgpio.c b/src/jtag/drivers/sysfsgpio.c
index 90e93f5..eb4941e 100644
--- a/src/jtag/drivers/sysfsgpio.c
+++ b/src/jtag/drivers/sysfsgpio.c
@@ -356,7 +356,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionums)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"SysfsGPIO nums: tck = %d, tms = %d, tdi = %d, tdo = %d",
 			tck_gpio, tms_gpio, tdi_gpio, tdo_gpio);
 
@@ -368,7 +368,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_tck)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio);
 
-	command_print(CMD_CTX, "SysfsGPIO num: tck = %d", tck_gpio);
+	command_print(CMD, "SysfsGPIO num: tck = %d", tck_gpio);
 	return ERROR_OK;
 }
 
@@ -377,7 +377,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_tms)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio);
 
-	command_print(CMD_CTX, "SysfsGPIO num: tms = %d", tms_gpio);
+	command_print(CMD, "SysfsGPIO num: tms = %d", tms_gpio);
 	return ERROR_OK;
 }
 
@@ -386,7 +386,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_tdo)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio);
 
-	command_print(CMD_CTX, "SysfsGPIO num: tdo = %d", tdo_gpio);
+	command_print(CMD, "SysfsGPIO num: tdo = %d", tdo_gpio);
 	return ERROR_OK;
 }
 
@@ -395,7 +395,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_tdi)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio);
 
-	command_print(CMD_CTX, "SysfsGPIO num: tdi = %d", tdi_gpio);
+	command_print(CMD, "SysfsGPIO num: tdi = %d", tdi_gpio);
 	return ERROR_OK;
 }
 
@@ -404,7 +404,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_srst)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio);
 
-	command_print(CMD_CTX, "SysfsGPIO num: srst = %d", srst_gpio);
+	command_print(CMD, "SysfsGPIO num: srst = %d", srst_gpio);
 	return ERROR_OK;
 }
 
@@ -413,7 +413,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_trst)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio);
 
-	command_print(CMD_CTX, "SysfsGPIO num: trst = %d", trst_gpio);
+	command_print(CMD, "SysfsGPIO num: trst = %d", trst_gpio);
 	return ERROR_OK;
 }
 
@@ -426,7 +426,7 @@ COMMAND_HANDLER(sysfsgpio_handle_swd_gpionums)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 			"SysfsGPIO nums: swclk = %d, swdio = %d",
 			swclk_gpio, swdio_gpio);
 
@@ -438,7 +438,7 @@ COMMAND_HANDLER(sysfsgpio_handle_swd_gpionum_swclk)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio);
 
-	command_print(CMD_CTX, "SysfsGPIO num: swclk = %d", swclk_gpio);
+	command_print(CMD, "SysfsGPIO num: swclk = %d", swclk_gpio);
 	return ERROR_OK;
 }
 
@@ -447,7 +447,7 @@ COMMAND_HANDLER(sysfsgpio_handle_swd_gpionum_swdio)
 	if (CMD_ARGC == 1)
 		COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio);
 
-	command_print(CMD_CTX, "SysfsGPIO num: swdio = %d", swdio_gpio);
+	command_print(CMD, "SysfsGPIO num: swdio = %d", swdio_gpio);
 	return ERROR_OK;
 }
 
diff --git a/src/jtag/tcl.c b/src/jtag/tcl.c
index 71d220b..0161b28 100644
--- a/src/jtag/tcl.c
+++ b/src/jtag/tcl.c
@@ -952,9 +952,9 @@ COMMAND_HANDLER(handle_scan_chain_command)
 	char expected_id[12];
 
 	tap = jtag_all_taps();
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"   TapName             Enabled  IdCode     Expected   IrLen IrCap IrMask");
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"-- ------------------- -------- ---------- ---------- ----- ----- ------");
 
 	while (tap) {
@@ -970,7 +970,7 @@ COMMAND_HANDLER(handle_scan_chain_command)
 		expected = buf_get_u32(tap->expected, 0, tap->ir_length);
 		expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
 
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"%2d %-18s     %c     0x%08x %s %5d 0x%02x  0x%02x",
 			tap->abs_chain_position,
 			tap->dotted_name,
@@ -987,7 +987,7 @@ COMMAND_HANDLER(handle_scan_chain_command)
 			if (tap->ignore_version)
 				expected_id[2] = '*';
 
-			command_print(CMD_CTX,
+			command_print(CMD,
 				"                                           %s",
 				expected_id);
 		}
@@ -1008,7 +1008,7 @@ COMMAND_HANDLER(handle_jtag_ntrst_delay_command)
 
 		jtag_set_ntrst_delay(delay);
 	}
-	command_print(CMD_CTX, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
+	command_print(CMD, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
 	return ERROR_OK;
 }
 
@@ -1022,7 +1022,7 @@ COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command)
 
 		jtag_set_ntrst_assert_width(delay);
 	}
-	command_print(CMD_CTX, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
+	command_print(CMD, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
 	return ERROR_OK;
 }
 
@@ -1047,9 +1047,9 @@ COMMAND_HANDLER(handle_jtag_rclk_command)
 		return retval;
 
 	if (cur_khz)
-		command_print(CMD_CTX, "RCLK not supported - fallback to %d kHz", cur_khz);
+		command_print(CMD, "RCLK not supported - fallback to %d kHz", cur_khz);
 	else
-		command_print(CMD_CTX, "RCLK - adaptive");
+		command_print(CMD, "RCLK - adaptive");
 
 	return retval;
 }
@@ -1148,7 +1148,7 @@ COMMAND_HANDLER(handle_irscan_command)
 		tap = jtag_tap_by_string(CMD_ARGV[i*2]);
 		if (tap == NULL) {
 			free(fields);
-			command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i*2]);
+			command_print(CMD, "Tap: %s unknown", CMD_ARGV[i*2]);
 
 			return ERROR_FAIL;
 		}
@@ -1193,7 +1193,7 @@ COMMAND_HANDLER(handle_verify_ircapture_command)
 	}
 
 	const char *status = jtag_will_verify_capture_ir() ? "enabled" : "disabled";
-	command_print(CMD_CTX, "verify Capture-IR is %s", status);
+	command_print(CMD, "verify Capture-IR is %s", status);
 
 	return ERROR_OK;
 }
@@ -1210,7 +1210,7 @@ COMMAND_HANDLER(handle_verify_jtag_command)
 	}
 
 	const char *status = jtag_will_verify() ? "enabled" : "disabled";
-	command_print(CMD_CTX, "verify jtag capture is %s", status);
+	command_print(CMD, "verify jtag capture is %s", status);
 
 	return ERROR_OK;
 }
@@ -1232,7 +1232,7 @@ COMMAND_HANDLER(handle_tms_sequence_command)
 		tap_use_new_tms_table(use_new_table);
 	}
 
-	command_print(CMD_CTX, "tms sequence is  %s",
+	command_print(CMD, "tms sequence is  %s",
 		tap_uses_new_tms_table() ? "short" : "long");
 
 	return ERROR_OK;
diff --git a/src/pld/pld.c b/src/pld/pld.c
index 3f23f6a..ef7993c 100644
--- a/src/pld/pld.c
+++ b/src/pld/pld.c
@@ -116,12 +116,12 @@ COMMAND_HANDLER(handle_pld_devices_command)
 	int i = 0;
 
 	if (!pld_devices) {
-		command_print(CMD_CTX, "no pld devices configured");
+		command_print(CMD, "no pld devices configured");
 		return ERROR_OK;
 	}
 
 	for (p = pld_devices; p; p = p->next)
-		command_print(CMD_CTX, "#%i: %s", i++, p->driver->name);
+		command_print(CMD, "#%i: %s", i++, p->driver->name);
 
 	return ERROR_OK;
 }
@@ -141,13 +141,13 @@ COMMAND_HANDLER(handle_pld_load_command)
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
 	p = get_pld_device_by_num(dev_id);
 	if (!p) {
-		command_print(CMD_CTX, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
 		return ERROR_OK;
 	}
 
 	retval = p->driver->load(p, CMD_ARGV[1]);
 	if (retval != ERROR_OK) {
-		command_print(CMD_CTX, "failed loading file %s to pld device %u",
+		command_print(CMD, "failed loading file %s to pld device %u",
 			CMD_ARGV[1], dev_id);
 		switch (retval) {
 		}
@@ -156,7 +156,7 @@ COMMAND_HANDLER(handle_pld_load_command)
 		gettimeofday(&end, NULL);
 		timeval_subtract(&duration, &end, &start);
 
-		command_print(CMD_CTX, "loaded file %s to pld device %u in %jis %jius",
+		command_print(CMD, "loaded file %s to pld device %u in %jis %jius",
 			CMD_ARGV[1], dev_id,
 			(intmax_t)duration.tv_sec, (intmax_t)duration.tv_usec);
 	}
diff --git a/src/pld/virtex2.c b/src/pld/virtex2.c
index 4e385e9..934a680 100644
--- a/src/pld/virtex2.c
+++ b/src/pld/virtex2.c
@@ -183,13 +183,13 @@ COMMAND_HANDLER(virtex2_handle_read_stat_command)
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
 	device = get_pld_device_by_num(dev_id);
 	if (!device) {
-		command_print(CMD_CTX, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
 		return ERROR_OK;
 	}
 
 	virtex2_read_stat(device, &status);
 
-	command_print(CMD_CTX, "virtex2 status register: 0x%8.8" PRIx32 "", status);
+	command_print(CMD, "virtex2 status register: 0x%8.8" PRIx32 "", status);
 
 	return ERROR_OK;
 }
@@ -205,7 +205,7 @@ PLD_DEVICE_COMMAND_HANDLER(virtex2_pld_device_command)
 
 	tap = jtag_tap_by_string(CMD_ARGV[1]);
 	if (tap == NULL) {
-		command_print(CMD_CTX, "Tap: %s does not exist", CMD_ARGV[1]);
+		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
 		return ERROR_OK;
 	}
 
diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index 95e6c04..c6cf7d3 100644
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -3494,7 +3494,7 @@ COMMAND_HANDLER(handle_gdb_sync_command)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	if (current_gdb_connection == NULL) {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"gdb_sync command can only be run from within gdb using \"monitor gdb_sync\"");
 		return ERROR_FAIL;
 	}
diff --git a/src/server/server.c b/src/server/server.c
index 539bdaf..9e63f74 100644
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -769,7 +769,7 @@ COMMAND_HANDLER(handle_bindto_command)
 {
 	switch (CMD_ARGC) {
 		case 0:
-			command_print(CMD_CTX, "bindto name: %s", bindto_name);
+			command_print(CMD, "bindto name: %s", bindto_name);
 			break;
 		case 1:
 			free(bindto_name);
@@ -828,7 +828,7 @@ COMMAND_HELPER(server_port_command, unsigned short *out)
 {
 	switch (CMD_ARGC) {
 		case 0:
-			command_print(CMD_CTX, "%d", *out);
+			command_print(CMD, "%d", *out);
 			break;
 		case 1:
 		{
@@ -847,7 +847,7 @@ COMMAND_HELPER(server_pipe_command, char **out)
 {
 	switch (CMD_ARGC) {
 		case 0:
-			command_print(CMD_CTX, "%s", *out);
+			command_print(CMD, "%s", *out);
 			break;
 		case 1:
 		{
diff --git a/src/svf/svf.c b/src/svf/svf.c
index 223af7e..759ba52 100644
--- a/src/svf/svf.c
+++ b/src/svf/svf.c
@@ -382,7 +382,7 @@ COMMAND_HANDLER(handle_svf_command)
 		if (strcmp(CMD_ARGV[i], "-tap") == 0) {
 			tap = jtag_tap_by_string(CMD_ARGV[i+1]);
 			if (!tap) {
-				command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i+1]);
+				command_print(CMD, "Tap: %s unknown", CMD_ARGV[i+1]);
 				return ERROR_FAIL;
 			}
 			i++;
@@ -401,7 +401,7 @@ COMMAND_HANDLER(handle_svf_command)
 			svf_fd = fopen(CMD_ARGV[i], "r");
 			if (svf_fd == NULL) {
 				int err = errno;
-				command_print(CMD_CTX, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err));
+				command_print(CMD, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err));
 				/* no need to free anything now */
 				return ERROR_COMMAND_SYNTAX_ERROR;
 			} else
@@ -534,7 +534,7 @@ COMMAND_HANDLER(handle_svf_command)
 	time_measure_m = time_measure_s / 60;
 	time_measure_s %= 60;
 	if (time_measure_ms < 1000)
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"\r\nTime used: %dm%ds%" PRId64 "ms ",
 			time_measure_m,
 			time_measure_s,
@@ -579,13 +579,13 @@ free_all:
 	svf_free_xxd_para(&svf_para.sir_para);
 
 	if (ERROR_OK == ret)
-		command_print(CMD_CTX,
+		command_print(CMD,
 			      "svf file programmed %s for %d commands with %d errors",
 			      (svf_ignore_error > 1) ? "unsuccessfully" : "successfully",
 			      command_num,
 			      (svf_ignore_error > 1) ? (svf_ignore_error - 1) : 0);
 	else
-		command_print(CMD_CTX, "svf file programmed failed");
+		command_print(CMD, "svf file programmed failed");
 
 	svf_ignore_error = 0;
 	return ret;
diff --git a/src/target/aarch64.c b/src/target/aarch64.c
index 68ae9f1..9e8983f 100644
--- a/src/target/aarch64.c
+++ b/src/target/aarch64.c
@@ -2572,7 +2572,7 @@ COMMAND_HANDLER(aarch64_mask_interrupts_command)
 	}
 
 	n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, aarch64->isrmasking_mode);
-	command_print(CMD_CTX, "aarch64 interrupt mask %s", n->name);
+	command_print(CMD, "aarch64 interrupt mask %s", n->name);
 
 	return ERROR_OK;
 }
diff --git a/src/target/arm720t.c b/src/target/arm720t.c
index e8ad852..abe5f1c 100644
--- a/src/target/arm720t.c
+++ b/src/target/arm720t.c
@@ -237,7 +237,7 @@ static int arm720t_verify_pointer(struct command_invocation *cmd,
 		struct arm720t_common *arm720t)
 {
 	if (arm720t->common_magic != ARM720T_COMMON_MAGIC) {
-		command_print(cmd->ctx, "target is not an ARM720");
+		command_print(cmd, "target is not an ARM720");
 		return ERROR_TARGET_INVALID;
 	}
 	return ERROR_OK;
@@ -447,7 +447,7 @@ COMMAND_HANDLER(arm720t_handle_cp15_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -460,7 +460,7 @@ COMMAND_HANDLER(arm720t_handle_cp15_command)
 			uint32_t value;
 			retval = arm720t_read_cp15(target, opcode, &value);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode);
+				command_print(CMD, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode);
 				return ERROR_OK;
 			}
 
@@ -468,17 +468,17 @@ COMMAND_HANDLER(arm720t_handle_cp15_command)
 			if (retval != ERROR_OK)
 				return retval;
 
-			command_print(CMD_CTX, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
+			command_print(CMD, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
 		} else if (CMD_ARGC == 2) {
 			uint32_t value;
 			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
 
 			retval = arm720t_write_cp15(target, opcode, value);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode);
+				command_print(CMD, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode);
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
+			command_print(CMD, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
 		}
 	}
 
diff --git a/src/target/arm7_9_common.c b/src/target/arm7_9_common.c
index 4fedc0d..b2962d1 100644
--- a/src/target/arm7_9_common.c
+++ b/src/target/arm7_9_common.c
@@ -2747,14 +2747,14 @@ COMMAND_HANDLER(handle_arm7_9_dbgrq_command)
 	struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
 
 	if (!is_arm7_9(arm7_9)) {
-		command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target");
+		command_print(CMD, "current target isn't an ARM7/ARM9 target");
 		return ERROR_TARGET_INVALID;
 	}
 
 	if (CMD_ARGC > 0)
 		COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->use_dbgrq);
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"use of EmbeddedICE dbgrq instead of breakpoint for target halt %s",
 		(arm7_9->use_dbgrq) ? "enabled" : "disabled");
 
@@ -2767,14 +2767,14 @@ COMMAND_HANDLER(handle_arm7_9_fast_memory_access_command)
 	struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
 
 	if (!is_arm7_9(arm7_9)) {
-		command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target");
+		command_print(CMD, "current target isn't an ARM7/ARM9 target");
 		return ERROR_TARGET_INVALID;
 	}
 
 	if (CMD_ARGC > 0)
 		COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->fast_memory_access);
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"fast memory access is %s",
 		(arm7_9->fast_memory_access) ? "enabled" : "disabled");
 
@@ -2787,14 +2787,14 @@ COMMAND_HANDLER(handle_arm7_9_dcc_downloads_command)
 	struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
 
 	if (!is_arm7_9(arm7_9)) {
-		command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target");
+		command_print(CMD, "current target isn't an ARM7/ARM9 target");
 		return ERROR_TARGET_INVALID;
 	}
 
 	if (CMD_ARGC > 0)
 		COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->dcc_downloads);
 
-	command_print(CMD_CTX,
+	command_print(CMD,
 		"dcc downloads are %s",
 		(arm7_9->dcc_downloads) ? "enabled" : "disabled");
 
diff --git a/src/target/arm920t.c b/src/target/arm920t.c
index 88a0395..2ecf218 100644
--- a/src/target/arm920t.c
+++ b/src/target/arm920t.c
@@ -511,7 +511,7 @@ static int arm920t_verify_pointer(struct command_invocation *cmd,
 	struct arm920t_common *arm920t)
 {
 	if (arm920t->common_magic != ARM920T_COMMON_MAGIC) {
-		command_print(cmd->ctx, arm920_not);
+		command_print(cmd, arm920_not);
 		return ERROR_TARGET_INVALID;
 	}
 
@@ -1103,7 +1103,7 @@ COMMAND_HANDLER(arm920t_handle_read_cache_command)
 	/* restore CP15 MMU and Cache settings */
 	arm920t_write_cp15_physical(target, CP15PHYS_CTRL, cp15_ctrl_saved);
 
-	command_print(CMD_CTX, "cache content successfully output to %s",
+	command_print(CMD, "cache content successfully output to %s",
 		CMD_ARGV[0]);
 
 	fclose(output);
@@ -1415,7 +1415,7 @@ COMMAND_HANDLER(arm920t_handle_read_mmu_command)
 			(i_tlb[i].cam & 0x20) ? "(valid)" : "(invalid)");
 	}
 
-	command_print(CMD_CTX, "mmu content successfully output to %s",
+	command_print(CMD, "mmu content successfully output to %s",
 		CMD_ARGV[0]);
 
 	fclose(output);
@@ -1456,7 +1456,7 @@ COMMAND_HANDLER(arm920t_handle_cp15_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for "
+		command_print(CMD, "target must be stopped for "
 			"\"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
@@ -1472,7 +1472,7 @@ COMMAND_HANDLER(arm920t_handle_cp15_command)
 			uint32_t value;
 			retval = arm920t_read_cp15_physical(target, address, &value);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"couldn't access reg %i", address);
 				return ERROR_OK;
 			}
@@ -1480,7 +1480,7 @@ COMMAND_HANDLER(arm920t_handle_cp15_command)
 			if (retval != ERROR_OK)
 				return retval;
 
-			command_print(CMD_CTX, "%i: %8.8" PRIx32,
+			command_print(CMD, "%i: %8.8" PRIx32,
 				address, value);
 		} else if (CMD_ARGC == 2)   {
 			uint32_t value;
@@ -1488,12 +1488,12 @@ COMMAND_HANDLER(arm920t_handle_cp15_command)
 			retval = arm920t_write_cp15_physical(target,
 					address, value);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"couldn't access reg %i", address);
 				/* REVISIT why lie? "return retval"? */
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "%i: %8.8" PRIx32,
+			command_print(CMD, "%i: %8.8" PRIx32,
 				address, value);
 		}
 	}
@@ -1513,7 +1513,7 @@ COMMAND_HANDLER(arm920t_handle_cp15i_command)
 
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for "
+		command_print(CMD, "target must be stopped for "
 			"\"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
@@ -1530,14 +1530,14 @@ COMMAND_HANDLER(arm920t_handle_cp15i_command)
 			retval = arm920t_read_cp15_interpreted(target,
 					opcode, 0x0, &value);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"couldn't execute %8.8" PRIx32,
 					opcode);
 				/* REVISIT why lie? "return retval"? */
 				return ERROR_OK;
 			}
 
-			command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32,
+			command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32,
 				opcode, value);
 		} else if (CMD_ARGC == 2) {
 			uint32_t value;
@@ -1545,13 +1545,13 @@ COMMAND_HANDLER(arm920t_handle_cp15i_command)
 			retval = arm920t_write_cp15_interpreted(target,
 					opcode, value, 0);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"couldn't execute %8.8" PRIx32,
 					opcode);
 				/* REVISIT why lie? "return retval"? */
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32,
+			command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32,
 				opcode, value);
 		} else if (CMD_ARGC == 3) {
 			uint32_t value;
@@ -1561,12 +1561,12 @@ COMMAND_HANDLER(arm920t_handle_cp15i_command)
 			retval = arm920t_write_cp15_interpreted(target,
 					opcode, value, address);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"couldn't execute %8.8" PRIx32, opcode);
 				/* REVISIT why lie? "return retval"? */
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32
+			command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32
 				" %8.8" PRIx32, opcode, value, address);
 		}
 	} else
diff --git a/src/target/arm926ejs.c b/src/target/arm926ejs.c
index 01ce176..ac30485 100644
--- a/src/target/arm926ejs.c
+++ b/src/target/arm926ejs.c
@@ -505,7 +505,7 @@ static int arm926ejs_verify_pointer(struct command_invocation *cmd,
 		struct arm926ejs_common *arm926)
 {
 	if (arm926->common_magic != ARM926EJS_COMMON_MAGIC) {
-		command_print(cmd->ctx, arm926_not);
+		command_print(cmd, arm926_not);
 		return ERROR_TARGET_INVALID;
 	}
 	return ERROR_OK;
diff --git a/src/target/arm946e.c b/src/target/arm946e.c
index 278a70c..112631a 100644
--- a/src/target/arm946e.c
+++ b/src/target/arm946e.c
@@ -103,7 +103,7 @@ static int arm946e_verify_pointer(struct command_invocation *cmd,
 	struct arm946e_common *arm946e)
 {
 	if (arm946e->common_magic != ARM946E_COMMON_MAGIC) {
-		command_print(cmd->ctx, "target is not an ARM946");
+		command_print(cmd, "target is not an ARM946");
 		return ERROR_TARGET_INVALID;
 	}
 	return ERROR_OK;
@@ -563,7 +563,7 @@ COMMAND_HANDLER(arm946e_handle_cp15)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_TARGET_NOT_HALTED;
 	}
 
@@ -574,7 +574,7 @@ COMMAND_HANDLER(arm946e_handle_cp15)
 		uint32_t value;
 		retval = arm946e_read_cp15(target, address, &value);
 		if (retval != ERROR_OK) {
-			command_print(CMD_CTX, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address);
+			command_print(CMD, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address);
 			return retval;
 		}
 		retval = jtag_execute_queue();
@@ -582,14 +582,14 @@ COMMAND_HANDLER(arm946e_handle_cp15)
 			return retval;
 
 		/* Return value in hex format */
-		command_print(CMD_CTX, "0x%08" PRIx32, value);
+		command_print(CMD, "0x%08" PRIx32, value);
 	} else if (CMD_ARGC == 2) {
 		uint32_t value;
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
 
 		retval = arm946e_write_cp15(target, address, value);
 		if (retval != ERROR_OK) {
-			command_print(CMD_CTX, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address);
+			command_print(CMD, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address);
 			return retval;
 		}
 		if (address == CP15_CTL)
@@ -613,7 +613,7 @@ COMMAND_HANDLER(arm946e_handle_idcache)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_TARGET_NOT_HALTED;
 	}
 
@@ -623,9 +623,9 @@ COMMAND_HANDLER(arm946e_handle_idcache)
 		bool  bena = ((arm946e->cp15_control_reg & (icache ? CP15_CTL_ICACHE : CP15_CTL_DCACHE)) != 0)
 			  && (arm946e->cp15_control_reg & 0x1);
 		if (csize == 0)
-			command_print(CMD_CTX, "%s-cache absent", icache ? "I" : "D");
+			command_print(CMD, "%s-cache absent", icache ? "I" : "D");
 		else
-			command_print(CMD_CTX, "%s-cache size: %" PRIu32 "K, %s",
+			command_print(CMD, "%s-cache size: %" PRIu32 "K, %s",
 				      icache ? "I" : "D", csize, bena ? "enabled" : "disabled");
 		return ERROR_OK;
 	}
@@ -643,7 +643,7 @@ COMMAND_HANDLER(arm946e_handle_idcache)
 
 	/* Do not invalidate or change state, if cache is absent */
 	if (csize == 0) {
-		command_print(CMD_CTX, "%s-cache absent, '%s' operation undefined", icache ? "I" : "D", CMD_ARGV[0]);
+		command_print(CMD, "%s-cache absent, '%s' operation undefined", icache ? "I" : "D", CMD_ARGV[0]);
 		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 	}
 
diff --git a/src/target/arm966e.c b/src/target/arm966e.c
index 98c6274..8462f54 100644
--- a/src/target/arm966e.c
+++ b/src/target/arm966e.c
@@ -60,7 +60,7 @@ static int arm966e_verify_pointer(struct command_invocation *cmd,
 		struct arm966e_common *arm966e)
 {
 	if (arm966e->common_magic != ARM966E_COMMON_MAGIC) {
-		command_print(cmd->ctx, "target is not an ARM966");
+		command_print(cmd, "target is not an ARM966");
 		return ERROR_TARGET_INVALID;
 	}
 	return ERROR_OK;
@@ -175,7 +175,7 @@ COMMAND_HANDLER(arm966e_handle_cp15_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -188,7 +188,7 @@ COMMAND_HANDLER(arm966e_handle_cp15_command)
 			uint32_t value;
 			retval = arm966e_read_cp15(target, address, &value);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 						"couldn't access reg %" PRIi32,
 						address);
 				return ERROR_OK;
@@ -197,19 +197,19 @@ COMMAND_HANDLER(arm966e_handle_cp15_command)
 			if (retval != ERROR_OK)
 				return retval;
 
-			command_print(CMD_CTX, "%" PRIi32 ": %8.8" PRIx32,
+			command_print(CMD, "%" PRIi32 ": %8.8" PRIx32,
 					address, value);
 		} else if (CMD_ARGC == 2) {
 			uint32_t value;
 			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
 			retval = arm966e_write_cp15(target, address, value);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 						"couldn't access reg %" PRIi32,
 						address);
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "%" PRIi32 ": %8.8" PRIx32,
+			command_print(CMD, "%" PRIi32 ": %8.8" PRIx32,
 					address, value);
 		}
 	}
diff --git a/src/target/arm9tdmi.c b/src/target/arm9tdmi.c
index 6425027..6ab06ed 100644
--- a/src/target/arm9tdmi.c
+++ b/src/target/arm9tdmi.c
@@ -801,7 +801,7 @@ COMMAND_HANDLER(handle_arm9tdmi_catch_vectors_command)
 	/* it's uncommon, but some ARM7 chips can support this */
 	if (arm7_9->common_magic != ARM7_9_COMMON_MAGIC
 			|| !arm7_9->has_vector_catch) {
-		command_print(CMD_CTX, "target doesn't have EmbeddedICE "
+		command_print(CMD, "target doesn't have EmbeddedICE "
 				"with vector_catch");
 		return ERROR_TARGET_INVALID;
 	}
@@ -834,7 +834,7 @@ COMMAND_HANDLER(handle_arm9tdmi_catch_vectors_command)
 
 				/* complain if vector wasn't found */
 				if (!arm9tdmi_vectors[j].name) {
-					command_print(CMD_CTX, "vector '%s' not found, leaving current setting unchanged", CMD_ARGV[i]);
+					command_print(CMD, "vector '%s' not found, leaving current setting unchanged", CMD_ARGV[i]);
 
 					/* reread current setting */
 					vector_catch_value = buf_get_u32(
@@ -852,7 +852,7 @@ COMMAND_HANDLER(handle_arm9tdmi_catch_vectors_command)
 
 	/* output current settings */
 	for (unsigned i = 0; arm9tdmi_vectors[i].name; i++) {
-		command_print(CMD_CTX, "%s: %s", arm9tdmi_vectors[i].name,
+		command_print(CMD, "%s: %s", arm9tdmi_vectors[i].name,
 			(vector_catch_value & arm9tdmi_vectors[i].value)
 				? "catch" : "don't catch");
 	}
diff --git a/src/target/arm_adi_v5.c b/src/target/arm_adi_v5.c
index f9eb8f4..8ff5efd 100644
--- a/src/target/arm_adi_v5.c
+++ b/src/target/arm_adi_v5.c
@@ -1199,7 +1199,7 @@ static int dap_rom_display(struct command_invocation *cmd,
 	char tabs[16] = "";
 
 	if (depth > 16) {
-		command_print(cmd->ctx, "\tTables too deep");
+		command_print(cmd, "\tTables too deep");
 		return ERROR_FAIL;
 	}
 
@@ -1207,25 +1207,25 @@ static int dap_rom_display(struct command_invocation *cmd,
 		snprintf(tabs, sizeof(tabs), "[L%02d] ", depth);
 
 	uint32_t base_addr = dbgbase & 0xFFFFF000;
-	command_print(cmd->ctx, "\t\tComponent base address 0x%08" PRIx32, base_addr);
+	command_print(cmd, "\t\tComponent base address 0x%08" PRIx32, base_addr);
 
 	retval = dap_read_part_id(ap, base_addr, &cid, &pid);
 	if (retval != ERROR_OK) {
-		command_print(cmd->ctx, "\t\tCan't read component, the corresponding core might be turned off");
+		command_print(cmd, "\t\tCan't read component, the corresponding core might be turned off");
 		return ERROR_OK; /* Don't abort recursion */
 	}
 
 	if (!is_dap_cid_ok(cid)) {
-		command_print(cmd->ctx, "\t\tInvalid CID 0x%08" PRIx32, cid);
+		command_print(cmd, "\t\tInvalid CID 0x%08" PRIx32, cid);
 		return ERROR_OK; /* Don't abort recursion */
 	}
 
 	/* component may take multiple 4K pages */
 	uint32_t size = (pid >> 36) & 0xf;
 	if (size > 0)
-		command_print(cmd->ctx, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size));
+		command_print(cmd, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size));
 
-	command_print(cmd->ctx, "\t\tPeripheral ID 0x%010" PRIx64, pid);
+	command_print(cmd, "\t\tPeripheral ID 0x%010" PRIx64, pid);
 
 	uint8_t class = (cid >> 12) & 0xf;
 	uint16_t part_num = pid & 0xfff;
@@ -1233,12 +1233,12 @@ static int dap_rom_display(struct command_invocation *cmd,
 
 	if (designer_id & 0x80) {
 		/* JEP106 code */
-		command_print(cmd->ctx, "\t\tDesigner is 0x%03" PRIx16 ", %s",
+		command_print(cmd, "\t\tDesigner is 0x%03" PRIx16 ", %s",
 				designer_id, jep106_manufacturer(designer_id >> 8, designer_id & 0x7f));
 	} else {
 		/* Legacy ASCII ID, clear invalid bits */
 		designer_id &= 0x7f;
-		command_print(cmd->ctx, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
+		command_print(cmd, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
 				designer_id, designer_id == 0x41 ? "ARM" : "<unknown>");
 	}
 
@@ -1260,8 +1260,8 @@ static int dap_rom_display(struct command_invocation *cmd,
 		break;
 	}
 
-	command_print(cmd->ctx, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
-	command_print(cmd->ctx, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
+	command_print(cmd, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
+	command_print(cmd, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
 
 	if (class == 1) { /* ROM Table */
 		uint32_t memtype;
@@ -1270,9 +1270,9 @@ static int dap_rom_display(struct command_invocation *cmd,
 			return retval;
 
 		if (memtype & 0x01)
-			command_print(cmd->ctx, "\t\tMEMTYPE system memory present on bus");
+			command_print(cmd, "\t\tMEMTYPE system memory present on bus");
 		else
-			command_print(cmd->ctx, "\t\tMEMTYPE system memory not present: dedicated debug bus");
+			command_print(cmd, "\t\tMEMTYPE system memory not present: dedicated debug bus");
 
 		/* Read ROM table entries from base address until we get 0x00000000 or reach the reserved area */
 		for (uint16_t entry_offset = 0; entry_offset < 0xF00; entry_offset += 4) {
@@ -1280,7 +1280,7 @@ static int dap_rom_display(struct command_invocation *cmd,
 			retval = mem_ap_read_atomic_u32(ap, base_addr | entry_offset, &romentry);
 			if (retval != ERROR_OK)
 				return retval;
-			command_print(cmd->ctx, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
+			command_print(cmd, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
 					tabs, entry_offset, romentry);
 			if (romentry & 0x01) {
 				/* Recurse */
@@ -1288,9 +1288,9 @@ static int dap_rom_display(struct command_invocation *cmd,
 				if (retval != ERROR_OK)
 					return retval;
 			} else if (romentry != 0) {
-				command_print(cmd->ctx, "\t\tComponent not present");
+				command_print(cmd, "\t\tComponent not present");
 			} else {
-				command_print(cmd->ctx, "\t%s\tEnd of ROM table", tabs);
+				command_print(cmd, "\t%s\tEnd of ROM table", tabs);
 				break;
 			}
 		}
@@ -1435,7 +1435,7 @@ static int dap_rom_display(struct command_invocation *cmd,
 			}
 			break;
 		}
-		command_print(cmd->ctx, "\t\tType is 0x%02" PRIx8 ", %s, %s",
+		command_print(cmd, "\t\tType is 0x%02" PRIx8 ", %s, %s",
 				(uint8_t)(devtype & 0xff),
 				major, subtype);
 		/* REVISIT also show 0xfc8 DevId */
@@ -1456,27 +1456,27 @@ int dap_info_command(struct command_invocation *cmd,
 	if (retval != ERROR_OK)
 		return retval;
 
-	command_print(cmd->ctx, "AP ID register 0x%8.8" PRIx32, apid);
+	command_print(cmd, "AP ID register 0x%8.8" PRIx32, apid);
 	if (apid == 0) {
-		command_print(cmd->ctx, "No AP found at this ap 0x%x", ap->ap_num);
+		command_print(cmd, "No AP found at this ap 0x%x", ap->ap_num);
 		return ERROR_FAIL;
 	}
 
 	switch (apid & (IDR_JEP106 | IDR_TYPE)) {
 	case IDR_JEP106_ARM | AP_TYPE_JTAG_AP:
-		command_print(cmd->ctx, "\tType is JTAG-AP");
+		command_print(cmd, "\tType is JTAG-AP");
 		break;
 	case IDR_JEP106_ARM | AP_TYPE_AHB_AP:
-		command_print(cmd->ctx, "\tType is MEM-AP AHB");
+		command_print(cmd, "\tType is MEM-AP AHB");
 		break;
 	case IDR_JEP106_ARM | AP_TYPE_APB_AP:
-		command_print(cmd->ctx, "\tType is MEM-AP APB");
+		command_print(cmd, "\tType is MEM-AP APB");
 		break;
 	case IDR_JEP106_ARM | AP_TYPE_AXI_AP:
-		command_print(cmd->ctx, "\tType is MEM-AP AXI");
+		command_print(cmd, "\tType is MEM-AP AXI");
 		break;
 	default:
-		command_print(cmd->ctx, "\tUnknown AP type");
+		command_print(cmd, "\tUnknown AP type");
 		break;
 	}
 
@@ -1485,15 +1485,15 @@ int dap_info_command(struct command_invocation *cmd,
 	 */
 	mem_ap = (apid & IDR_CLASS) == AP_CLASS_MEM_AP;
 	if (mem_ap) {
-		command_print(cmd->ctx, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase);
+		command_print(cmd, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase);
 
 		if (dbgbase == 0xFFFFFFFF || (dbgbase & 0x3) == 0x2) {
-			command_print(cmd->ctx, "\tNo ROM table present");
+			command_print(cmd, "\tNo ROM table present");
 		} else {
 			if (dbgbase & 0x01)
-				command_print(cmd->ctx, "\tValid ROM table present");
+				command_print(cmd, "\tValid ROM table present");
 			else
-				command_print(cmd->ctx, "\tROM table in legacy format");
+				command_print(cmd, "\tROM table in legacy format");
 
 			dap_rom_display(cmd, ap, dbgbase & 0xFFFFF000, 0);
 		}
@@ -1681,7 +1681,7 @@ COMMAND_HANDLER(dap_baseaddr_command)
 	if (retval != ERROR_OK)
 		return retval;
 
-	command_print(CMD_CTX, "0x%8.8" PRIx32, baseaddr);
+	command_print(CMD, "0x%8.8" PRIx32, baseaddr);
 
 	return retval;
 }
@@ -1703,7 +1703,7 @@ COMMAND_HANDLER(dap_memaccess_command)
 	}
 	dap->ap[dap->apsel].memaccess_tck = memaccess_tck;
 
-	command_print(CMD_CTX, "memory bus access delay set to %" PRIi32 " tck",
+	command_print(CMD, "memory bus access delay set to %" PRIi32 " tck",
 			dap->ap[dap->apsel].memaccess_tck);
 
 	return ERROR_OK;
@@ -1716,7 +1716,7 @@ COMMAND_HANDLER(dap_apsel_command)
 
 	switch (CMD_ARGC) {
 	case 0:
-		command_print(CMD_CTX, "%" PRIi32, dap->apsel);
+		command_print(CMD, "%" PRIi32, dap->apsel);
 		return ERROR_OK;
 	case 1:
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
@@ -1740,7 +1740,7 @@ COMMAND_HANDLER(dap_apcsw_command)
 
 	switch (CMD_ARGC) {
 	case 0:
-		command_print(CMD_CTX, "ap %" PRIi32 " selected, csw 0x%8.8" PRIx32,
+		command_print(CMD, "ap %" PRIi32 " selected, csw 0x%8.8" PRIx32,
 			dap->apsel, apcsw);
 		return ERROR_OK;
 	case 1:
@@ -1801,7 +1801,7 @@ COMMAND_HANDLER(dap_apid_command)
 	if (retval != ERROR_OK)
 		return retval;
 
-	command_print(CMD_CTX, "0x%8.8" PRIx32, apid);
+	command_print(CMD, "0x%8.8" PRIx32, apid);
 
 	return retval;
 }
@@ -1853,7 +1853,7 @@ COMMAND_HANDLER(dap_apreg_command)
 		return retval;
 
 	if (CMD_ARGC == 2)
-		command_print(CMD_CTX, "0x%08" PRIx32, value);
+		command_print(CMD, "0x%08" PRIx32, value);
 
 	return retval;
 }
@@ -1884,7 +1884,7 @@ COMMAND_HANDLER(dap_dpreg_command)
 		return retval;
 
 	if (CMD_ARGC == 1)
-		command_print(CMD_CTX, "0x%08" PRIx32, value);
+		command_print(CMD, "0x%08" PRIx32, value);
 
 	return retval;
 }
@@ -1906,7 +1906,7 @@ COMMAND_HANDLER(dap_ti_be_32_quirks_command)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	dap->ti_be_32_quirks = enable;
-	command_print(CMD_CTX, "TI BE-32 quirks mode %s",
+	command_print(CMD, "TI BE-32 quirks mode %s",
 		enable ? "enabled" : "disabled");
 
 	return 0;
diff --git a/src/target/arm_cti.c b/src/target/arm_cti.c
index 3fa54d6..3f063b8 100644
--- a/src/target/arm_cti.c
+++ b/src/target/arm_cti.c
@@ -252,7 +252,7 @@ COMMAND_HANDLER(handle_cti_dump)
 		return JIM_ERR;
 
 	for (int i = 0; i < (int)ARRAY_SIZE(cti_names); i++)
-		command_print(CMD_CTX, "%8.8s (0x%04"PRIx32") 0x%08"PRIx32,
+		command_print(CMD, "%8.8s (0x%04"PRIx32") 0x%08"PRIx32,
 				cti_names[i].label, cti_names[i].offset, *cti_names[i].p_val);
 
 	return JIM_OK;
@@ -336,7 +336,7 @@ COMMAND_HANDLER(handle_cti_read)
 	if (retval != ERROR_OK)
 		return retval;
 
-	command_print(CMD_CTX, "0x%08"PRIx32, value);
+	command_print(CMD, "0x%08"PRIx32, value);
 
 	return ERROR_OK;
 }
diff --git a/src/target/armv4_5.c b/src/target/armv4_5.c
index d04b179..53a6b22 100644
--- a/src/target/armv4_5.c
+++ b/src/target/armv4_5.c
@@ -778,17 +778,17 @@ COMMAND_HANDLER(handle_armv4_5_reg_command)
 	struct reg *regs;
 
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "current target isn't an ARM");
+		command_print(CMD, "current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "error: target must be halted for register accesses");
+		command_print(CMD, "error: target must be halted for register accesses");
 		return ERROR_FAIL;
 	}
 
 	if (arm->core_type != ARM_MODE_ANY) {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"Microcontroller Profile not supported - use standard reg cmd");
 		return ERROR_OK;
 	}
@@ -799,7 +799,7 @@ COMMAND_HANDLER(handle_armv4_5_reg_command)
 	}
 
 	if (!arm->full_context) {
-		command_print(CMD_CTX, "error: target doesn't support %s",
+		command_print(CMD, "error: target doesn't support %s",
 			CMD_NAME);
 		return ERROR_FAIL;
 	}
@@ -828,7 +828,7 @@ COMMAND_HANDLER(handle_armv4_5_reg_command)
 				shadow = "shadow ";
 				break;
 		}
-		command_print(CMD_CTX, "%s%s mode %sregisters",
+		command_print(CMD, "%s%s mode %sregisters",
 			sep, name, shadow);
 
 		/* display N rows of up to 4 registers each */
@@ -855,7 +855,7 @@ COMMAND_HANDLER(handle_armv4_5_reg_command)
 						"%8s: %8.8" PRIx32 " ",
 						reg->name, value);
 			}
-			command_print(CMD_CTX, "%s", output);
+			command_print(CMD, "%s", output);
 		}
 	}
 
@@ -868,13 +868,13 @@ COMMAND_HANDLER(handle_armv4_5_core_state_command)
 	struct arm *arm = target_to_arm(target);
 
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "current target isn't an ARM");
+		command_print(CMD, "current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	if (arm->core_type == ARM_MODE_THREAD) {
 		/* armv7m not supported */
-		command_print(CMD_CTX, "Unsupported Command");
+		command_print(CMD, "Unsupported Command");
 		return ERROR_OK;
 	}
 
@@ -885,7 +885,7 @@ COMMAND_HANDLER(handle_armv4_5_core_state_command)
 			arm->core_state = ARM_STATE_THUMB;
 	}
 
-	command_print(CMD_CTX, "core state: %s", arm_state_strings[arm->core_state]);
+	command_print(CMD, "core state: %s", arm_state_strings[arm->core_state]);
 
 	return ERROR_OK;
 }
@@ -906,7 +906,7 @@ COMMAND_HANDLER(handle_arm_disassemble_command)
 	int thumb = 0;
 
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "current target isn't an ARM");
+		command_print(CMD, "current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
@@ -928,7 +928,7 @@ COMMAND_HANDLER(handle_arm_disassemble_command)
 			COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
 			if (address & 0x01) {
 				if (!thumb) {
-					command_print(CMD_CTX, "Disassemble as Thumb");
+					command_print(CMD, "Disassemble as Thumb");
 					thumb = 1;
 				}
 				address &= ~1;
@@ -963,7 +963,7 @@ usage:
 			if (retval != ERROR_OK)
 				break;
 		}
-		command_print(CMD_CTX, "%s", cur_instruction.text);
+		command_print(CMD, "%s", cur_instruction.text);
 		address += cur_instruction.instruction_size;
 	}
 
diff --git a/src/target/armv4_5_cache.c b/src/target/armv4_5_cache.c
index 6a16925..eda8cb7 100644
--- a/src/target/armv4_5_cache.c
+++ b/src/target/armv4_5_cache.c
@@ -79,20 +79,20 @@ int armv4_5_identify_cache(uint32_t cache_type_reg, struct armv4_5_cache_common
 int armv4_5_handle_cache_info_command(struct command_invocation *cmd, struct armv4_5_cache_common *armv4_5_cache)
 {
 	if (armv4_5_cache->ctype == -1) {
-		command_print(cmd->ctx, "cache not yet identified");
+		command_print(cmd, "cache not yet identified");
 		return ERROR_OK;
 	}
 
-	command_print(cmd->ctx, "cache type: 0x%1.1x, %s", armv4_5_cache->ctype,
+	command_print(cmd, "cache type: 0x%1.1x, %s", armv4_5_cache->ctype,
 		(armv4_5_cache->separate) ? "separate caches" : "unified cache");
 
-	command_print(cmd->ctx, "D-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x",
+	command_print(cmd, "D-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x",
 		armv4_5_cache->d_u_size.linelen,
 		armv4_5_cache->d_u_size.associativity,
 		armv4_5_cache->d_u_size.nsets,
 		armv4_5_cache->d_u_size.cachesize);
 
-	command_print(cmd->ctx, "I-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x",
+	command_print(cmd, "I-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x",
 		armv4_5_cache->i_size.linelen,
 		armv4_5_cache->i_size.associativity,
 		armv4_5_cache->i_size.nsets,
diff --git a/src/target/armv7a.c b/src/target/armv7a.c
index 7f51990..2be70b7 100644
--- a/src/target/armv7a.c
+++ b/src/target/armv7a.c
@@ -229,7 +229,7 @@ COMMAND_HANDLER(handle_cache_l2x)
 	if (CMD_ARGC != 2)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	/* command_print(CMD_CTX, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */
+	/* command_print(CMD, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], base);
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], way);
 
@@ -248,7 +248,7 @@ int armv7a_handle_cache_info_command(struct command_invocation *cmd,
 	int cl;
 
 	if (armv7a_cache->info == -1) {
-		command_print(cmd->ctx, "cache not yet identified");
+		command_print(cmd, "cache not yet identified");
 		return ERROR_OK;
 	}
 
@@ -256,7 +256,7 @@ int armv7a_handle_cache_info_command(struct command_invocation *cmd,
 		struct armv7a_arch_cache *arch = &(armv7a_cache->arch[cl]);
 
 		if (arch->ctype & 1) {
-			command_print(cmd->ctx,
+			command_print(cmd,
 				"L%d I-Cache: linelen %" PRIi32
 				", associativity %" PRIi32
 				", nsets %" PRIi32
@@ -269,7 +269,7 @@ int armv7a_handle_cache_info_command(struct command_invocation *cmd,
 		}
 
 		if (arch->ctype >= 2) {
-			command_print(cmd->ctx,
+			command_print(cmd,
 				"L%d D-Cache: linelen %" PRIi32
 				", associativity %" PRIi32
 				", nsets %" PRIi32
@@ -283,7 +283,7 @@ int armv7a_handle_cache_info_command(struct command_invocation *cmd,
 	}
 
 	if (l2x_cache != NULL)
-		command_print(cmd->ctx, "Outer unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways",
+		command_print(cmd, "Outer unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways",
 			l2x_cache->base, l2x_cache->way);
 
 	return ERROR_OK;
diff --git a/src/target/armv7a_cache.c b/src/target/armv7a_cache.c
index fca195c..921ba9b 100644
--- a/src/target/armv7a_cache.c
+++ b/src/target/armv7a_cache.c
@@ -513,7 +513,7 @@ COMMAND_HANDLER(arm7a_cache_disable_auto_cmd)
 	struct armv7a_common *armv7a = target_to_armv7a(target);
 
 	if (CMD_ARGC == 0) {
-		command_print(CMD_CTX, "auto cache is %s",
+		command_print(CMD, "auto cache is %s",
 			armv7a->armv7a_mmu.armv7a_cache.auto_cache_enabled ? "enabled" : "disabled");
 		return ERROR_OK;
 	}
diff --git a/src/target/armv7a_cache_l2x.c b/src/target/armv7a_cache_l2x.c
index 0aa6953..72e12b4 100644
--- a/src/target/armv7a_cache_l2x.c
+++ b/src/target/armv7a_cache_l2x.c
@@ -180,11 +180,11 @@ static int arm7a_handle_l2x_cache_info_command(struct command_invocation *cmd,
 		(armv7a_cache->outer_cache);
 
 	if (armv7a_cache->info == -1) {
-		command_print(cmd->ctx, "cache not yet identified");
+		command_print(cmd, "cache not yet identified");
 		return ERROR_OK;
 	}
 
-	command_print(cmd->ctx,
+	command_print(cmd,
 		      "L2 unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways",
 		      l2x_cache->base, l2x_cache->way);
 
@@ -312,7 +312,7 @@ COMMAND_HANDLER(armv7a_l2x_cache_conf_cmd)
 	if (CMD_ARGC != 2)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	/* command_print(CMD_CTX, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */
+	/* command_print(CMD, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], base);
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], way);
 
diff --git a/src/target/armv8.c b/src/target/armv8.c
index 4054c95..e736937 100644
--- a/src/target/armv8.c
+++ b/src/target/armv8.c
@@ -1054,7 +1054,7 @@ COMMAND_HANDLER(armv8_handle_exception_catch_command)
 			return ERROR_FAIL;
 		}
 
-		command_print(CMD_CTX, "Exception Catch: Secure: %s, Non-Secure: %s", sec, nsec);
+		command_print(CMD, "Exception Catch: Secure: %s, Non-Secure: %s", sec, nsec);
 		return ERROR_OK;
 	}
 
@@ -1083,7 +1083,7 @@ int armv8_handle_cache_info_command(struct command_invocation *cmd,
 	struct armv8_cache_common *armv8_cache)
 {
 	if (armv8_cache->info == -1) {
-		command_print(cmd->ctx, "cache not yet identified");
+		command_print(cmd, "cache not yet identified");
 		return ERROR_OK;
 	}
 
diff --git a/src/target/armv8_cache.c b/src/target/armv8_cache.c
index a641d04..41c85c9 100644
--- a/src/target/armv8_cache.c
+++ b/src/target/armv8_cache.c
@@ -194,7 +194,7 @@ static int armv8_handle_inner_cache_info_command(struct command_invocation *cmd,
 	int cl;
 
 	if (armv8_cache->info == -1) {
-		command_print(cmd->ctx, "cache not yet identified");
+		command_print(cmd, "cache not yet identified");
 		return ERROR_OK;
 	}
 
@@ -202,7 +202,7 @@ static int armv8_handle_inner_cache_info_command(struct command_invocation *cmd,
 		struct armv8_arch_cache *arch = &(armv8_cache->arch[cl]);
 
 		if (arch->ctype & 1) {
-			command_print(cmd->ctx,
+			command_print(cmd,
 				"L%d I-Cache: linelen %" PRIi32
 				", associativity %" PRIi32
 				", nsets %" PRIi32
@@ -215,7 +215,7 @@ static int armv8_handle_inner_cache_info_command(struct command_invocation *cmd,
 		}
 
 		if (arch->ctype >= 2) {
-			command_print(cmd->ctx,
+			command_print(cmd,
 				"L%d D-Cache: linelen %" PRIi32
 				", associativity %" PRIi32
 				", nsets %" PRIi32
diff --git a/src/target/cortex_a.c b/src/target/cortex_a.c
index 5d1d42a..9fc2652 100644
--- a/src/target/cortex_a.c
+++ b/src/target/cortex_a.c
@@ -2969,7 +2969,7 @@ COMMAND_HANDLER(handle_cortex_a_mask_interrupts_command)
 	}
 
 	n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, cortex_a->isrmasking_mode);
-	command_print(CMD_CTX, "cortex_a interrupt mask %s", n->name);
+	command_print(CMD, "cortex_a interrupt mask %s", n->name);
 
 	return ERROR_OK;
 }
@@ -2995,7 +2995,7 @@ COMMAND_HANDLER(handle_cortex_a_dacrfixup_command)
 	}
 
 	n = Jim_Nvp_value2name_simple(nvp_dacrfixup_modes, cortex_a->dacrfixup_mode);
-	command_print(CMD_CTX, "cortex_a domain access control fixup %s", n->name);
+	command_print(CMD, "cortex_a domain access control fixup %s", n->name);
 
 	return ERROR_OK;
 }
diff --git a/src/target/cortex_m.c b/src/target/cortex_m.c
index 639e09f..fba832c 100644
--- a/src/target/cortex_m.c
+++ b/src/target/cortex_m.c
@@ -2370,7 +2370,7 @@ static int cortex_m_verify_pointer(struct command_invocation *cmd,
 	struct cortex_m_common *cm)
 {
 	if (cm->common_magic != CORTEX_M_COMMON_MAGIC) {
-		command_print(cmd->ctx, "target is not a Cortex-M");
+		command_print(cmd, "target is not a Cortex-M");
 		return ERROR_TARGET_INVALID;
 	}
 	return ERROR_OK;
@@ -2459,7 +2459,7 @@ write:
 	}
 
 	for (unsigned i = 0; i < ARRAY_SIZE(vec_ids); i++) {
-		command_print(CMD_CTX, "%9s: %s", vec_ids[i].name,
+		command_print(CMD, "%9s: %s", vec_ids[i].name,
 			(demcr & vec_ids[i].mask) ? "catch" : "ignore");
 	}
 
@@ -2487,7 +2487,7 @@ COMMAND_HANDLER(handle_cortex_m_mask_interrupts_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -2500,7 +2500,7 @@ COMMAND_HANDLER(handle_cortex_m_mask_interrupts_command)
 	}
 
 	n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, cortex_m->isrmasking_mode);
-	command_print(CMD_CTX, "cortex_m interrupt mask %s", n->name);
+	command_print(CMD, "cortex_m interrupt mask %s", n->name);
 
 	return ERROR_OK;
 }
@@ -2545,7 +2545,7 @@ COMMAND_HANDLER(handle_cortex_m_reset_config_command)
 			break;
 	}
 
-	command_print(CMD_CTX, "cortex_m reset_config %s", reset_config);
+	command_print(CMD, "cortex_m reset_config %s", reset_config);
 
 	return ERROR_OK;
 }
diff --git a/src/target/dsp563xx.c b/src/target/dsp563xx.c
index 28fb859..d8285e4 100644
--- a/src/target/dsp563xx.c
+++ b/src/target/dsp563xx.c
@@ -1930,7 +1930,7 @@ static void handle_md_output(struct command_invocation *cmd,
 				value);
 
 		if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
-			command_print(cmd->ctx, "%s", output);
+			command_print(cmd, "%s", output);
 			output_len = 0;
 		}
 	}
diff --git a/src/target/esirisc.c b/src/target/esirisc.c
index 3d2954f..c928445 100644
--- a/src/target/esirisc.c
+++ b/src/target/esirisc.c
@@ -1680,7 +1680,7 @@ COMMAND_HANDLER(handle_esirisc_cache_arch_command)
 		}
 	}
 
-	command_print(CMD_CTX, "esirisc cache_arch %s", esirisc_cache_arch_name(esirisc));
+	command_print(CMD, "esirisc cache_arch %s", esirisc_cache_arch_name(esirisc));
 
 	return ERROR_OK;
 }
@@ -1698,7 +1698,7 @@ COMMAND_HANDLER(handle_esirisc_flush_caches_command)
 
 	retval = esirisc_flush_caches(target);
 
-	command_print(CMD_CTX, "cache flush %s",
+	command_print(CMD, "cache flush %s",
 			(retval == ERROR_OK) ? "successful" : "failed");
 
 	return retval;
@@ -1748,7 +1748,7 @@ COMMAND_HANDLER(handle_esirisc_hwdc_command)
 	}
 
 	for (size_t i = 0; i < ARRAY_SIZE(esirisc_hwdc_masks); ++i)
-		command_print(CMD_CTX, "%9s: %s", esirisc_hwdc_masks[i].name,
+		command_print(CMD, "%9s: %s", esirisc_hwdc_masks[i].name,
 				(esirisc->hwdc_save & esirisc_hwdc_masks[i].mask) ? "enabled" : "disabled");
 
 	return ERROR_OK;
diff --git a/src/target/esirisc_trace.c b/src/target/esirisc_trace.c
index d07a0da..6a7d5a2 100644
--- a/src/target/esirisc_trace.c
+++ b/src/target/esirisc_trace.c
@@ -403,7 +403,7 @@ static int esirisc_trace_analyze_full(struct command_invocation *cmd, uint8_t *b
 			case ESIRISC_TRACE_ID_EXECUTE:
 			case ESIRISC_TRACE_ID_STALL:
 			case ESIRISC_TRACE_ID_BRANCH:
-				command_print(cmd->ctx, "%s", esirisc_trace_id_strings[id]);
+				command_print(cmd, "%s", esirisc_trace_id_strings[id]);
 				break;
 
 			case ESIRISC_TRACE_ID_EXTENDED: {
@@ -417,7 +417,7 @@ static int esirisc_trace_analyze_full(struct command_invocation *cmd, uint8_t *b
 					case ESIRISC_TRACE_EXT_ID_STOP:
 					case ESIRISC_TRACE_EXT_ID_WAIT:
 					case ESIRISC_TRACE_EXT_ID_MULTICYCLE:
-						command_print(cmd->ctx, "%s", esirisc_trace_ext_id_strings[ext_id]);
+						command_print(cmd, "%s", esirisc_trace_ext_id_strings[ext_id]);
 						break;
 
 					case ESIRISC_TRACE_EXT_ID_ERET:
@@ -430,11 +430,11 @@ static int esirisc_trace_analyze_full(struct command_invocation *cmd, uint8_t *b
 						if (retval != ERROR_OK)
 							goto fail;
 
-						command_print(cmd->ctx, "%s PC: 0x%" PRIx32,
+						command_print(cmd, "%s PC: 0x%" PRIx32,
 								esirisc_trace_ext_id_strings[ext_id], pc);
 
 						if (ext_id == ESIRISC_TRACE_EXT_ID_END_PC) {
-							command_print(cmd->ctx, "--- end of trace ---");
+							command_print(cmd, "--- end of trace ---");
 							return ERROR_OK;
 						}
 						break;
@@ -450,7 +450,7 @@ static int esirisc_trace_analyze_full(struct command_invocation *cmd, uint8_t *b
 						if (retval != ERROR_OK)
 							goto fail;
 
-						command_print(cmd->ctx, "%s EID: 0x%" PRIx32 ", EPC: 0x%" PRIx32,
+						command_print(cmd, "%s EID: 0x%" PRIx32 ", EPC: 0x%" PRIx32,
 								esirisc_trace_ext_id_strings[ext_id], eid, epc);
 						break;
 					}
@@ -461,28 +461,28 @@ static int esirisc_trace_analyze_full(struct command_invocation *cmd, uint8_t *b
 						if (retval != ERROR_OK)
 							goto fail;
 
-						command_print(cmd->ctx, "repeats %" PRId32 " %s", count,
+						command_print(cmd, "repeats %" PRId32 " %s", count,
 								(count == 1) ? "time" : "times");
 						break;
 					}
 					case ESIRISC_TRACE_EXT_ID_END:
-						command_print(cmd->ctx, "--- end of trace ---");
+						command_print(cmd, "--- end of trace ---");
 						return ERROR_OK;
 
 					default:
-						command_print(cmd->ctx, "invalid extended trace ID: %" PRId32, ext_id);
+						command_print(cmd, "invalid extended trace ID: %" PRId32, ext_id);
 						return ERROR_FAIL;
 				}
 				break;
 			}
 			default:
-				command_print(cmd->ctx, "invalid trace ID: %" PRId32, id);
+				command_print(cmd, "invalid trace ID: %" PRId32, id);
 				return ERROR_FAIL;
 		}
 	}
 
 fail:
-	command_print(cmd->ctx, "trace buffer too small");
+	command_print(cmd, "trace buffer too small");
 	return ERROR_BUF_TOO_SMALL;
 }
 
@@ -504,14 +504,14 @@ static int esirisc_trace_analyze_simple(struct command_invocation *cmd, uint8_t
 			break;
 
 		if (pc == end_of_trace) {
-			command_print(cmd->ctx, "--- end of trace ---");
+			command_print(cmd, "--- end of trace ---");
 			return ERROR_OK;
 		}
 
-		command_print(cmd->ctx, "PC: 0x%" PRIx32, pc);
+		command_print(cmd, "PC: 0x%" PRIx32, pc);
 	}
 
-	command_print(cmd->ctx, "trace buffer too small");
+	command_print(cmd, "trace buffer too small");
 	return ERROR_BUF_TOO_SMALL;
 }
 
@@ -523,19 +523,19 @@ static int esirisc_trace_analyze(struct command_invocation *cmd, uint8_t *buffer
 
 	switch (trace_info->format) {
 		case ESIRISC_TRACE_FORMAT_FULL:
-			command_print(cmd->ctx, "--- full pipeline ---");
+			command_print(cmd, "--- full pipeline ---");
 			return esirisc_trace_analyze_full(cmd, buffer, size);
 
 		case ESIRISC_TRACE_FORMAT_BRANCH:
-			command_print(cmd->ctx, "--- branches taken ---");
+			command_print(cmd, "--- branches taken ---");
 			return esirisc_trace_analyze_full(cmd, buffer, size);
 
 		case ESIRISC_TRACE_FORMAT_ICACHE:
-			command_print(cmd->ctx, "--- icache misses ---");
+			command_print(cmd, "--- icache misses ---");
 			return esirisc_trace_analyze_simple(cmd, buffer, size);
 
 		default:
-			command_print(cmd->ctx, "invalid trace format: %i", trace_info->format);
+			command_print(cmd, "invalid trace format: %i", trace_info->format);
 			return ERROR_FAIL;
 	}
 }
@@ -552,7 +552,7 @@ static int esirisc_trace_analyze_buffer(struct command_invocation *cmd)
 	size = esirisc_trace_buffer_size(trace_info);
 	buffer = calloc(1, size);
 	if (buffer == NULL) {
-		command_print(cmd->ctx, "out of memory");
+		command_print(cmd, "out of memory");
 		return ERROR_FAIL;
 	}
 
@@ -577,7 +577,7 @@ static int esirisc_trace_analyze_memory(struct command_invocation *cmd,
 
 	buffer = calloc(1, size);
 	if (buffer == NULL) {
-		command_print(cmd->ctx, "out of memory");
+		command_print(cmd, "out of memory");
 		return ERROR_FAIL;
 	}
 
@@ -602,15 +602,15 @@ static int esirisc_trace_dump(struct command_invocation *cmd, const char *filena
 
 	retval = fileio_open(&fileio, filename, FILEIO_WRITE, FILEIO_BINARY);
 	if (retval != ERROR_OK) {
-		command_print(cmd->ctx, "could not open dump file: %s", filename);
+		command_print(cmd, "could not open dump file: %s", filename);
 		return retval;
 	}
 
 	retval = fileio_write(fileio, size, buffer, &size_written);
 	if (retval == ERROR_OK)
-		command_print(cmd->ctx, "trace data dumped to: %s", filename);
+		command_print(cmd, "trace data dumped to: %s", filename);
 	else
-		command_print(cmd->ctx, "could not write dump file: %s", filename);
+		command_print(cmd, "could not write dump file: %s", filename);
 
 	fileio_close(fileio);
 
@@ -629,7 +629,7 @@ static int esirisc_trace_dump_buffer(struct command_invocation *cmd, const char
 	size = esirisc_trace_buffer_size(trace_info);
 	buffer = calloc(1, size);
 	if (buffer == NULL) {
-		command_print(cmd->ctx, "out of memory");
+		command_print(cmd, "out of memory");
 		return ERROR_FAIL;
 	}
 
@@ -654,7 +654,7 @@ static int esirisc_trace_dump_memory(struct command_invocation *cmd, const char
 
 	buffer = calloc(1, size);
 	if (buffer == NULL) {
-		command_print(cmd->ctx, "out of memory");
+		command_print(cmd, "out of memory");
 		return ERROR_FAIL;
 	}
 
@@ -676,13 +676,13 @@ COMMAND_HANDLER(handle_esirisc_trace_init_command)
 	struct esirisc_common *esirisc = target_to_esirisc(target);
 
 	if (!esirisc->has_trace) {
-		command_print(CMD_CTX, "target does not support trace");
+		command_print(CMD, "target does not support trace");
 		return ERROR_FAIL;
 	}
 
 	int retval = esirisc_trace_init(target);
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "trace initialized");
+		command_print(CMD, "trace initialized");
 
 	return retval;
 }
@@ -694,42 +694,42 @@ COMMAND_HANDLER(handle_esirisc_trace_info_command)
 	struct esirisc_trace *trace_info = &esirisc->trace_info;
 
 	if (!esirisc->has_trace) {
-		command_print(CMD_CTX, "target does not support trace");
+		command_print(CMD, "target does not support trace");
 		return ERROR_FAIL;
 	}
 
 	if (esirisc_trace_is_fifo(trace_info))
-		command_print(CMD_CTX, "trace FIFO address: 0x%" TARGET_PRIxADDR,
+		command_print(CMD, "trace FIFO address: 0x%" TARGET_PRIxADDR,
 				trace_info->buffer_start);
 	else {
-		command_print(CMD_CTX, "trace buffer start: 0x%" TARGET_PRIxADDR,
+		command_print(CMD, "trace buffer start: 0x%" TARGET_PRIxADDR,
 				trace_info->buffer_start);
-		command_print(CMD_CTX, "trace buffer end: 0x%" TARGET_PRIxADDR,
+		command_print(CMD, "trace buffer end: 0x%" TARGET_PRIxADDR,
 				trace_info->buffer_end);
-		command_print(CMD_CTX, "trace buffer will %swrap",
+		command_print(CMD, "trace buffer will %swrap",
 				trace_info->buffer_wrap ? "" : "not ");
 	}
 
-	command_print(CMD_CTX, "flow control: %s",
+	command_print(CMD, "flow control: %s",
 			trace_info->flow_control ? "enabled" : "disabled");
 
-	command_print(CMD_CTX, "trace format: %s",
+	command_print(CMD, "trace format: %s",
 			esirisc_trace_format_strings[trace_info->format]);
-	command_print(CMD_CTX, "number of PC bits: %i", trace_info->pc_bits);
+	command_print(CMD, "number of PC bits: %i", trace_info->pc_bits);
 
-	command_print(CMD_CTX, "start trigger: %s",
+	command_print(CMD, "start trigger: %s",
 			esirisc_trace_trigger_strings[trace_info->start_trigger]);
-	command_print(CMD_CTX, "start data: 0x%" PRIx32, trace_info->start_data);
-	command_print(CMD_CTX, "start mask: 0x%" PRIx32, trace_info->start_mask);
+	command_print(CMD, "start data: 0x%" PRIx32, trace_info->start_data);
+	command_print(CMD, "start mask: 0x%" PRIx32, trace_info->start_mask);
 
-	command_print(CMD_CTX, "stop trigger: %s",
+	command_print(CMD, "stop trigger: %s",
 			esirisc_trace_trigger_strings[trace_info->stop_trigger]);
-	command_print(CMD_CTX, "stop data: 0x%" PRIx32, trace_info->stop_data);
-	command_print(CMD_CTX, "stop mask: 0x%" PRIx32, trace_info->stop_mask);
+	command_print(CMD, "stop data: 0x%" PRIx32, trace_info->stop_data);
+	command_print(CMD, "stop mask: 0x%" PRIx32, trace_info->stop_mask);
 
-	command_print(CMD_CTX, "trigger delay: %s",
+	command_print(CMD, "trigger delay: %s",
 			esirisc_trace_delay_strings[trace_info->delay]);
-	command_print(CMD_CTX, "trigger delay cycles: %i", trace_info->delay_cycles);
+	command_print(CMD, "trigger delay cycles: %i", trace_info->delay_cycles);
 
 	return ERROR_OK;
 }
@@ -741,7 +741,7 @@ COMMAND_HANDLER(handle_esirisc_trace_status_command)
 	uint32_t status;
 
 	if (!esirisc->has_trace) {
-		command_print(CMD_CTX, "target does not support trace");
+		command_print(CMD, "target does not support trace");
 		return ERROR_FAIL;
 	}
 
@@ -749,7 +749,7 @@ COMMAND_HANDLER(handle_esirisc_trace_status_command)
 	if (retval != ERROR_OK)
 		return retval;
 
-	command_print(CMD_CTX, "trace is %s%s%s%s",
+	command_print(CMD, "trace is %s%s%s%s",
 			(status & STATUS_T)  ? "started" : "stopped",
 			(status & STATUS_TD) ? ", disabled"   : "",
 			(status & STATUS_W)  ? ", wrapped"    : "",
@@ -764,13 +764,13 @@ COMMAND_HANDLER(handle_esirisc_trace_start_command)
 	struct esirisc_common *esirisc = target_to_esirisc(target);
 
 	if (!esirisc->has_trace) {
-		command_print(CMD_CTX, "target does not support trace");
+		command_print(CMD, "target does not support trace");
 		return ERROR_FAIL;
 	}
 
 	int retval = esirisc_trace_start(target);
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "trace started");
+		command_print(CMD, "trace started");
 
 	return retval;
 }
@@ -781,13 +781,13 @@ COMMAND_HANDLER(handle_esirisc_trace_stop_command)
 	struct esirisc_common *esirisc = target_to_esirisc(target);
 
 	if (!esirisc->has_trace) {
-		command_print(CMD_CTX, "target does not support trace");
+		command_print(CMD, "target does not support trace");
 		return ERROR_FAIL;
 	}
 
 	int retval = esirisc_trace_stop(target);
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "trace stopped");
+		command_print(CMD, "trace stopped");
 
 	return retval;
 }
@@ -801,7 +801,7 @@ COMMAND_HANDLER(handle_esirisc_trace_analyze_command)
 	uint32_t size;
 
 	if (!esirisc->has_trace) {
-		command_print(CMD_CTX, "target does not support trace");
+		command_print(CMD, "target does not support trace");
 		return ERROR_FAIL;
 	}
 
@@ -817,7 +817,7 @@ COMMAND_HANDLER(handle_esirisc_trace_analyze_command)
 		 * as arguments as a workaround.
 		 */
 		if (esirisc_trace_is_fifo(trace_info)) {
-			command_print(CMD_CTX, "analyze from FIFO not supported");
+			command_print(CMD, "analyze from FIFO not supported");
 			return ERROR_FAIL;
 		}
 
@@ -839,7 +839,7 @@ COMMAND_HANDLER(handle_esirisc_trace_dump_command)
 	uint32_t size;
 
 	if (!esirisc->has_trace) {
-		command_print(CMD_CTX, "target does not support trace");
+		command_print(CMD, "target does not support trace");
 		return ERROR_FAIL;
 	}
 
@@ -849,7 +849,7 @@ COMMAND_HANDLER(handle_esirisc_trace_dump_command)
 	if (CMD_ARGC == 1) {
 		/* also see: handle_esirisc_trace_analyze_command() */
 		if (esirisc_trace_is_fifo(trace_info)) {
-			command_print(CMD_CTX, "dump from FIFO not supported");
+			command_print(CMD, "dump from FIFO not supported");
 			return ERROR_FAIL;
 		}
 
@@ -946,7 +946,7 @@ COMMAND_HANDLER(handle_esirisc_trace_format_command)
 	COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], pc_bits);
 
 	if (pc_bits < 1 || pc_bits > 31) {
-		command_print(CMD_CTX, "invalid pc_bits: %i; must be 1..31", pc_bits);
+		command_print(CMD, "invalid pc_bits: %i; must be 1..31", pc_bits);
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
diff --git a/src/target/etb.c b/src/target/etb.c
index 7cd8b6c..392c6ad 100644
--- a/src/target/etb.c
+++ b/src/target/etb.c
@@ -344,13 +344,13 @@ COMMAND_HANDLER(handle_etb_config_command)
 
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETB: '%s' isn't an ARM", CMD_ARGV[0]);
+		command_print(CMD, "ETB: '%s' isn't an ARM", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
 	tap = jtag_tap_by_string(CMD_ARGV[1]);
 	if (tap == NULL) {
-		command_print(CMD_CTX, "ETB: TAP %s does not exist", CMD_ARGV[1]);
+		command_print(CMD, "ETB: TAP %s does not exist", CMD_ARGV[1]);
 		return ERROR_FAIL;
 	}
 
@@ -382,17 +382,17 @@ COMMAND_HANDLER(handle_etb_trigger_percent_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETB: current target isn't an ARM");
+		command_print(CMD, "ETB: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm = arm->etm;
 	if (!etm) {
-		command_print(CMD_CTX, "ETB: target has no ETM configured");
+		command_print(CMD, "ETB: target has no ETM configured");
 		return ERROR_FAIL;
 	}
 	if (etm->capture_driver != &etb_capture_driver) {
-		command_print(CMD_CTX, "ETB: target not using ETB");
+		command_print(CMD, "ETB: target not using ETB");
 		return ERROR_FAIL;
 	}
 	etb = arm->etm->capture_driver_priv;
@@ -402,13 +402,13 @@ COMMAND_HANDLER(handle_etb_trigger_percent_command)
 
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], new_value);
 		if ((new_value < 2) || (new_value > 100))
-			command_print(CMD_CTX,
+			command_print(CMD,
 				"valid percentages are 2%% to 100%%");
 		else
 			etb->trigger_percent = (unsigned) new_value;
 	}
 
-	command_print(CMD_CTX, "%d percent of tracebuffer fills after trigger",
+	command_print(CMD, "%d percent of tracebuffer fills after trigger",
 		etb->trigger_percent);
 
 	return ERROR_OK;
diff --git a/src/target/etm.c b/src/target/etm.c
index 4c95626..5751348 100644
--- a/src/target/etm.c
+++ b/src/target/etm.c
@@ -869,7 +869,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 		ctx->capture_driver->read_trace(ctx);
 
 	if (ctx->trace_depth == 0) {
-		command_print(cmd->ctx, "Trace is empty.");
+		command_print(cmd, "Trace is empty.");
 		return ERROR_OK;
 	}
 
@@ -893,7 +893,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 		int current_pc_ok = ctx->pc_ok;
 
 		if (ctx->trace_data[ctx->pipe_index].flags & ETMV1_TRIGGER_CYCLE)
-			command_print(cmd->ctx, "--- trigger ---");
+			command_print(cmd, "--- trigger ---");
 
 		/* instructions execute in IE/D or BE/D cycles */
 		if ((pipestat == STAT_IE) || (pipestat == STAT_ID))
@@ -942,7 +942,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					next_pc = ctx->last_branch;
 					break;
 				case 0x1:	/* tracing enabled */
-					command_print(cmd->ctx,
+					command_print(cmd,
 						"--- tracing enabled at 0x%8.8" PRIx32 " ---",
 						ctx->last_branch);
 					ctx->current_pc = ctx->last_branch;
@@ -950,7 +950,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					continue;
 					break;
 				case 0x2:	/* trace restarted after FIFO overflow */
-					command_print(cmd->ctx,
+					command_print(cmd,
 						"--- trace restarted after FIFO overflow at 0x%8.8" PRIx32 " ---",
 						ctx->last_branch);
 					ctx->current_pc = ctx->last_branch;
@@ -958,7 +958,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					continue;
 					break;
 				case 0x3:	/* exit from debug state */
-					command_print(cmd->ctx,
+					command_print(cmd,
 						"--- exit from debug state at 0x%8.8" PRIx32 " ---",
 						ctx->last_branch);
 					ctx->current_pc = ctx->last_branch;
@@ -971,7 +971,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					 * we have to move on with the next trace cycle
 					 */
 					if (!current_pc_ok) {
-						command_print(cmd->ctx,
+						command_print(cmd,
 							"--- periodic synchronization point at 0x%8.8" PRIx32 " ---",
 							next_pc);
 						ctx->current_pc = next_pc;
@@ -998,9 +998,9 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 				|| ((ctx->last_branch >= 0xffff0000) &&
 				(ctx->last_branch <= 0xffff0020))) {
 				if ((ctx->last_branch & 0xff) == 0x10)
-					command_print(cmd->ctx, "data abort");
+					command_print(cmd, "data abort");
 				else {
-					command_print(cmd->ctx,
+					command_print(cmd,
 						"exception vector 0x%2.2" PRIx32 "",
 						ctx->last_branch);
 					ctx->current_pc = ctx->last_branch;
@@ -1058,7 +1058,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					ctx->ptr_ok = 1;
 
 				if (ctx->ptr_ok)
-					command_print(cmd->ctx,
+					command_print(cmd,
 						"address: 0x%8.8" PRIx32 "",
 						ctx->last_ptr);
 			}
@@ -1073,7 +1073,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 							uint32_t data;
 							if (etmv1_data(ctx, 4, &data) != 0)
 								return ERROR_ETM_ANALYSIS_FAILED;
-							command_print(cmd->ctx,
+							command_print(cmd,
 								"data: 0x%8.8" PRIx32 "",
 								data);
 						}
@@ -1084,7 +1084,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					if (etmv1_data(ctx, arm_access_size(&instruction),
 						&data) != 0)
 						return ERROR_ETM_ANALYSIS_FAILED;
-					command_print(cmd->ctx, "data: 0x%8.8" PRIx32 "", data);
+					command_print(cmd, "data: 0x%8.8" PRIx32 "", data);
 				}
 			}
 
@@ -1119,7 +1119,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					(cycles == 1) ? "cycle" : "cycles");
 			}
 
-			command_print(cmd->ctx, "%s%s%s",
+			command_print(cmd, "%s%s%s",
 				instruction.text,
 				(pipestat == STAT_IN) ? " (not executed)" : "",
 				cycles_text);
@@ -1156,7 +1156,7 @@ static COMMAND_HELPER(handle_etm_tracemode_command_update,
 	else if (strcmp(CMD_ARGV[0], "all") == 0)
 		tracemode = ETM_CTRL_TRACE_DATA | ETM_CTRL_TRACE_ADDR;
 	else {
-		command_print(CMD_CTX, "invalid option '%s'", CMD_ARGV[0]);
+		command_print(CMD, "invalid option '%s'", CMD_ARGV[0]);
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1176,7 +1176,7 @@ static COMMAND_HELPER(handle_etm_tracemode_command_update,
 			tracemode |= ETM_CTRL_CONTEXTID_32;
 			break;
 		default:
-			command_print(CMD_CTX, "invalid option '%s'", CMD_ARGV[1]);
+			command_print(CMD, "invalid option '%s'", CMD_ARGV[1]);
 			return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
@@ -1207,13 +1207,13 @@ COMMAND_HANDLER(handle_etm_tracemode_command)
 	struct etm_context *etm;
 
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm = arm->etm;
 	if (!etm) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
@@ -1235,47 +1235,47 @@ COMMAND_HANDLER(handle_etm_tracemode_command)
 	 * or couldn't be written; display actual hardware state...
 	 */
 
-	command_print(CMD_CTX, "current tracemode configuration:");
+	command_print(CMD, "current tracemode configuration:");
 
 	switch (tracemode & ETM_CTRL_TRACE_MASK) {
 		default:
-			command_print(CMD_CTX, "data tracing: none");
+			command_print(CMD, "data tracing: none");
 			break;
 		case ETM_CTRL_TRACE_DATA:
-			command_print(CMD_CTX, "data tracing: data only");
+			command_print(CMD, "data tracing: data only");
 			break;
 		case ETM_CTRL_TRACE_ADDR:
-			command_print(CMD_CTX, "data tracing: address only");
+			command_print(CMD, "data tracing: address only");
 			break;
 		case ETM_CTRL_TRACE_DATA | ETM_CTRL_TRACE_ADDR:
-			command_print(CMD_CTX, "data tracing: address and data");
+			command_print(CMD, "data tracing: address and data");
 			break;
 	}
 
 	switch (tracemode & ETM_CTRL_CONTEXTID_MASK) {
 		case ETM_CTRL_CONTEXTID_NONE:
-			command_print(CMD_CTX, "contextid tracing: none");
+			command_print(CMD, "contextid tracing: none");
 			break;
 		case ETM_CTRL_CONTEXTID_8:
-			command_print(CMD_CTX, "contextid tracing: 8 bit");
+			command_print(CMD, "contextid tracing: 8 bit");
 			break;
 		case ETM_CTRL_CONTEXTID_16:
-			command_print(CMD_CTX, "contextid tracing: 16 bit");
+			command_print(CMD, "contextid tracing: 16 bit");
 			break;
 		case ETM_CTRL_CONTEXTID_32:
-			command_print(CMD_CTX, "contextid tracing: 32 bit");
+			command_print(CMD, "contextid tracing: 32 bit");
 			break;
 	}
 
 	if (tracemode & ETM_CTRL_CYCLE_ACCURATE)
-		command_print(CMD_CTX, "cycle-accurate tracing enabled");
+		command_print(CMD, "cycle-accurate tracing enabled");
 	else
-		command_print(CMD_CTX, "cycle-accurate tracing disabled");
+		command_print(CMD, "cycle-accurate tracing disabled");
 
 	if (tracemode & ETM_CTRL_BRANCH_OUTPUT)
-		command_print(CMD_CTX, "full branch address output enabled");
+		command_print(CMD, "full branch address output enabled");
 	else
-		command_print(CMD_CTX, "full branch address output disabled");
+		command_print(CMD, "full branch address output disabled");
 
 #define TRACEMODE_MASK ( \
 		ETM_CTRL_CONTEXTID_MASK	\
@@ -1331,7 +1331,7 @@ COMMAND_HANDLER(handle_etm_config_command)
 
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "target '%s' is '%s'; not an ARM",
+		command_print(CMD, "target '%s' is '%s'; not an ARM",
 			target_name(target),
 			target_type_name(target));
 		return ERROR_FAIL;
@@ -1382,7 +1382,7 @@ COMMAND_HANDLER(handle_etm_config_command)
 			portmode |= ETM_PORT_2BIT;
 			break;
 		default:
-			command_print(CMD_CTX,
+			command_print(CMD,
 				"unsupported ETM port width '%s'", CMD_ARGV[1]);
 			return ERROR_FAIL;
 	}
@@ -1394,7 +1394,7 @@ COMMAND_HANDLER(handle_etm_config_command)
 	else if (strcmp("demultiplexed", CMD_ARGV[2]) == 0)
 		portmode |= ETM_PORT_DEMUXED;
 	else {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"unsupported ETM port mode '%s', must be 'normal', 'multiplexed' or 'demultiplexed'",
 			CMD_ARGV[2]);
 		return ERROR_FAIL;
@@ -1405,7 +1405,7 @@ COMMAND_HANDLER(handle_etm_config_command)
 	else if (strcmp("full", CMD_ARGV[3]) == 0)
 		portmode |= ETM_PORT_FULL_CLOCK;
 	else {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"unsupported ETM port clocking '%s', must be 'full' or 'half'",
 			CMD_ARGV[3]);
 		return ERROR_FAIL;
@@ -1461,44 +1461,44 @@ COMMAND_HANDLER(handle_etm_info_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm = arm->etm;
 	if (!etm) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
-	command_print(CMD_CTX, "ETM v%d.%d",
+	command_print(CMD, "ETM v%d.%d",
 		etm->bcd_vers >> 4, etm->bcd_vers & 0xf);
-	command_print(CMD_CTX, "pairs of address comparators: %i",
+	command_print(CMD, "pairs of address comparators: %i",
 		(int) (etm->config >> 0) & 0x0f);
-	command_print(CMD_CTX, "data comparators: %i",
+	command_print(CMD, "data comparators: %i",
 		(int) (etm->config >> 4) & 0x0f);
-	command_print(CMD_CTX, "memory map decoders: %i",
+	command_print(CMD, "memory map decoders: %i",
 		(int) (etm->config >> 8) & 0x1f);
-	command_print(CMD_CTX, "number of counters: %i",
+	command_print(CMD, "number of counters: %i",
 		(int) (etm->config >> 13) & 0x07);
-	command_print(CMD_CTX, "sequencer %spresent",
+	command_print(CMD, "sequencer %spresent",
 		(int) (etm->config & (1 << 16)) ? "" : "not ");
-	command_print(CMD_CTX, "number of ext. inputs: %i",
+	command_print(CMD, "number of ext. inputs: %i",
 		(int) (etm->config >> 17) & 0x07);
-	command_print(CMD_CTX, "number of ext. outputs: %i",
+	command_print(CMD, "number of ext. outputs: %i",
 		(int) (etm->config >> 20) & 0x07);
-	command_print(CMD_CTX, "FIFO full %spresent",
+	command_print(CMD, "FIFO full %spresent",
 		(int) (etm->config & (1 << 23)) ? "" : "not ");
 	if (etm->bcd_vers < 0x20)
-		command_print(CMD_CTX, "protocol version: %i",
+		command_print(CMD, "protocol version: %i",
 			(int) (etm->config >> 28) & 0x07);
 	else {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"coprocessor and memory access %ssupported",
 			(etm->config & (1 << 26)) ? "" : "not ");
-		command_print(CMD_CTX, "trace start/stop %spresent",
+		command_print(CMD, "trace start/stop %spresent",
 			(etm->config & (1 << 26)) ? "" : "not ");
-		command_print(CMD_CTX, "number of context comparators: %i",
+		command_print(CMD, "number of context comparators: %i",
 			(int) (etm->config >> 24) & 0x03);
 	}
 
@@ -1549,30 +1549,30 @@ COMMAND_HANDLER(handle_etm_info_command)
 			LOG_ERROR("Illegal max_port_size");
 			return ERROR_FAIL;
 	}
-	command_print(CMD_CTX, "max. port size: %i", max_port_size);
+	command_print(CMD, "max. port size: %i", max_port_size);
 
 	if (etm->bcd_vers < 0x30) {
-		command_print(CMD_CTX, "half-rate clocking %ssupported",
+		command_print(CMD, "half-rate clocking %ssupported",
 			(config & (1 << 3)) ? "" : "not ");
-		command_print(CMD_CTX, "full-rate clocking %ssupported",
+		command_print(CMD, "full-rate clocking %ssupported",
 			(config & (1 << 4)) ? "" : "not ");
-		command_print(CMD_CTX, "normal trace format %ssupported",
+		command_print(CMD, "normal trace format %ssupported",
 			(config & (1 << 5)) ? "" : "not ");
-		command_print(CMD_CTX, "multiplex trace format %ssupported",
+		command_print(CMD, "multiplex trace format %ssupported",
 			(config & (1 << 6)) ? "" : "not ");
-		command_print(CMD_CTX, "demultiplex trace format %ssupported",
+		command_print(CMD, "demultiplex trace format %ssupported",
 			(config & (1 << 7)) ? "" : "not ");
 	} else {
 		/* REVISIT show which size and format are selected ... */
-		command_print(CMD_CTX, "current port size %ssupported",
+		command_print(CMD, "current port size %ssupported",
 			(config & (1 << 10)) ? "" : "not ");
-		command_print(CMD_CTX, "current trace format %ssupported",
+		command_print(CMD, "current trace format %ssupported",
 			(config & (1 << 11)) ? "" : "not ");
 	}
 	if (etm->bcd_vers >= 0x21)
-		command_print(CMD_CTX, "fetch comparisons %ssupported",
+		command_print(CMD, "fetch comparisons %ssupported",
 			(config & (1 << 17)) ? "not " : "");
-	command_print(CMD_CTX, "FIFO full %ssupported",
+	command_print(CMD, "FIFO full %ssupported",
 		(config & (1 << 8)) ? "" : "not ");
 
 	return ERROR_OK;
@@ -1588,13 +1588,13 @@ COMMAND_HANDLER(handle_etm_status_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm = arm->etm;
 	if (!etm) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
@@ -1608,7 +1608,7 @@ COMMAND_HANDLER(handle_etm_status_command)
 		if (etm_get_reg(reg) == ERROR_OK) {
 			unsigned s = buf_get_u32(reg->value, 0, reg->size);
 
-			command_print(CMD_CTX, "etm: %s%s%s%s",
+			command_print(CMD, "etm: %s%s%s%s",
 				/* bit(1) == progbit */
 				(etm->bcd_vers >= 0x12)
 				? ((s & (1 << 1))
@@ -1626,21 +1626,21 @@ COMMAND_HANDLER(handle_etm_status_command)
 	/* Trace Port Driver status */
 	trace_status = etm->capture_driver->status(etm);
 	if (trace_status == TRACE_IDLE)
-		command_print(CMD_CTX, "%s: idle", etm->capture_driver->name);
+		command_print(CMD, "%s: idle", etm->capture_driver->name);
 	else {
 		static char *completed = " completed";
 		static char *running = " is running";
 		static char *overflowed = ", overflowed";
 		static char *triggered = ", triggered";
 
-		command_print(CMD_CTX, "%s: trace collection%s%s%s",
+		command_print(CMD, "%s: trace collection%s%s%s",
 			etm->capture_driver->name,
 			(trace_status & TRACE_RUNNING) ? running : completed,
 			(trace_status & TRACE_OVERFLOWED) ? overflowed : "",
 			(trace_status & TRACE_TRIGGERED) ? triggered : "");
 
 		if (etm->trace_depth > 0) {
-			command_print(CMD_CTX, "%i frames of trace data read",
+			command_print(CMD, "%i frames of trace data read",
 				(int)(etm->trace_depth));
 		}
 	}
@@ -1660,20 +1660,20 @@ COMMAND_HANDLER(handle_etm_image_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm_ctx = arm->etm;
 	if (!etm_ctx) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
 	if (etm_ctx->image) {
 		image_close(etm_ctx->image);
 		free(etm_ctx->image);
-		command_print(CMD_CTX, "previously loaded image found and closed");
+		command_print(CMD, "previously loaded image found and closed");
 	}
 
 	etm_ctx->image = malloc(sizeof(struct image));
@@ -1711,24 +1711,24 @@ COMMAND_HANDLER(handle_etm_dump_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm_ctx = arm->etm;
 	if (!etm_ctx) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
 	if (etm_ctx->capture_driver->status == TRACE_IDLE) {
-		command_print(CMD_CTX, "trace capture wasn't enabled, no trace data captured");
+		command_print(CMD, "trace capture wasn't enabled, no trace data captured");
 		return ERROR_OK;
 	}
 
 	if (etm_ctx->capture_driver->status(etm_ctx) & TRACE_RUNNING) {
 		/* TODO: if on-the-fly capture is to be supported, this needs to be changed */
-		command_print(CMD_CTX, "trace capture not completed");
+		command_print(CMD, "trace capture not completed");
 		return ERROR_FAIL;
 	}
 
@@ -1768,18 +1768,18 @@ COMMAND_HANDLER(handle_etm_load_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm_ctx = arm->etm;
 	if (!etm_ctx) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
 	if (etm_ctx->capture_driver->status(etm_ctx) & TRACE_RUNNING) {
-		command_print(CMD_CTX, "trace capture running, stop first");
+		command_print(CMD, "trace capture running, stop first");
 		return ERROR_FAIL;
 	}
 
@@ -1794,7 +1794,7 @@ COMMAND_HANDLER(handle_etm_load_command)
 	}
 
 	if (filesize % 4) {
-		command_print(CMD_CTX, "size isn't a multiple of 4, no valid trace data");
+		command_print(CMD, "size isn't a multiple of 4, no valid trace data");
 		fileio_close(file);
 		return ERROR_FAIL;
 	}
@@ -1812,7 +1812,7 @@ COMMAND_HANDLER(handle_etm_load_command)
 	}
 	etm_ctx->trace_data = malloc(sizeof(struct etmv1_trace_data) * etm_ctx->trace_depth);
 	if (etm_ctx->trace_data == NULL) {
-		command_print(CMD_CTX, "not enough memory to perform operation");
+		command_print(CMD, "not enough memory to perform operation");
 		fileio_close(file);
 		return ERROR_FAIL;
 	}
@@ -1842,13 +1842,13 @@ COMMAND_HANDLER(handle_etm_start_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm_ctx = arm->etm;
 	if (!etm_ctx) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
@@ -1887,13 +1887,13 @@ COMMAND_HANDLER(handle_etm_stop_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm_ctx = arm->etm;
 	if (!etm_ctx) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
@@ -1923,14 +1923,14 @@ COMMAND_HANDLER(handle_etm_trigger_debug_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: %s isn't an ARM",
+		command_print(CMD, "ETM: %s isn't an ARM",
 			target_name(target));
 		return ERROR_FAIL;
 	}
 
 	etm = arm->etm;
 	if (!etm) {
-		command_print(CMD_CTX, "ETM: no ETM configured for %s",
+		command_print(CMD, "ETM: no ETM configured for %s",
 			target_name(target));
 		return ERROR_FAIL;
 	}
@@ -1955,7 +1955,7 @@ COMMAND_HANDLER(handle_etm_trigger_debug_command)
 		buf_set_u32(etm_ctrl_reg->value, 0, 32, etm->control);
 	}
 
-	command_print(CMD_CTX, "ETM: %s debug halt",
+	command_print(CMD, "ETM: %s debug halt",
 		(etm->control & ETM_CTRL_DBGRQ)
 		? "triggers"
 		: "does not trigger");
@@ -1972,13 +1972,13 @@ COMMAND_HANDLER(handle_etm_analyze_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "ETM: current target isn't an ARM");
+		command_print(CMD, "ETM: current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	etm_ctx = arm->etm;
 	if (!etm_ctx) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
@@ -1987,18 +1987,18 @@ COMMAND_HANDLER(handle_etm_analyze_command)
 		/* FIX! error should be reported inside etmv1_analyze_trace() */
 		switch (retval) {
 			case ERROR_ETM_ANALYSIS_FAILED:
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"further analysis failed (corrupted trace data or just end of data");
 				break;
 			case ERROR_TRACE_INSTRUCTION_UNAVAILABLE:
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"no instruction for current address available, analysis aborted");
 				break;
 			case ERROR_TRACE_IMAGE_UNAVAILABLE:
-				command_print(CMD_CTX, "no image available for trace analysis");
+				command_print(CMD, "no image available for trace analysis");
 				break;
 			default:
-				command_print(CMD_CTX, "unknown error");
+				command_print(CMD, "unknown error");
 		}
 	}
 
diff --git a/src/target/etm_dummy.c b/src/target/etm_dummy.c
index 9f18d84..ba53c7a 100644
--- a/src/target/etm_dummy.c
+++ b/src/target/etm_dummy.c
@@ -37,7 +37,7 @@ COMMAND_HANDLER(handle_etm_dummy_config_command)
 
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "target '%s' isn't an ARM", CMD_ARGV[0]);
+		command_print(CMD, "target '%s' isn't an ARM", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
diff --git a/src/target/mips32.c b/src/target/mips32.c
index 9cb24a4..5260032 100644
--- a/src/target/mips32.c
+++ b/src/target/mips32.c
@@ -909,7 +909,7 @@ static int mips32_verify_pointer(struct command_invocation *cmd,
 		struct mips32_common *mips32)
 {
 	if (mips32->common_magic != MIPS32_COMMON_MAGIC) {
-		command_print(cmd->ctx, "target is not an MIPS32");
+		command_print(cmd, "target is not an MIPS32");
 		return ERROR_TARGET_INVALID;
 	}
 	return ERROR_OK;
@@ -932,7 +932,7 @@ COMMAND_HANDLER(mips32_handle_cp0_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -949,12 +949,12 @@ COMMAND_HANDLER(mips32_handle_cp0_command)
 
 			retval = mips32_cp0_read(ejtag_info, &value, cp0_reg, cp0_sel);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 						"couldn't access reg %" PRIi32,
 						cp0_reg);
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
+			command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
 					cp0_reg, cp0_sel, value);
 
 		} else if (CMD_ARGC == 3) {
@@ -962,12 +962,12 @@ COMMAND_HANDLER(mips32_handle_cp0_command)
 			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
 			retval = mips32_cp0_write(ejtag_info, value, cp0_reg, cp0_sel);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 						"couldn't access cp0 reg %" PRIi32 ", select %" PRIi32,
 						cp0_reg,  cp0_sel);
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
+			command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
 					cp0_reg, cp0_sel, value);
 		}
 	}
@@ -986,13 +986,13 @@ COMMAND_HANDLER(mips32_handle_scan_delay_command)
 	else if (CMD_ARGC > 1)
 			return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX, "scan delay: %d nsec", ejtag_info->scan_delay);
+	command_print(CMD, "scan delay: %d nsec", ejtag_info->scan_delay);
 	if (ejtag_info->scan_delay >= MIPS32_SCAN_DELAY_LEGACY_MODE) {
 		ejtag_info->mode = 0;
-		command_print(CMD_CTX, "running in legacy mode");
+		command_print(CMD, "running in legacy mode");
 	} else {
 		ejtag_info->mode = 1;
-		command_print(CMD_CTX, "running in fast queued mode");
+		command_print(CMD, "running in fast queued mode");
 	}
 
 	return ERROR_OK;
diff --git a/src/target/mips_m4k.c b/src/target/mips_m4k.c
index 755ed72..ad27520 100644
--- a/src/target/mips_m4k.c
+++ b/src/target/mips_m4k.c
@@ -1274,7 +1274,7 @@ static int mips_m4k_verify_pointer(struct command_invocation *cmd,
 		struct mips_m4k_common *mips_m4k)
 {
 	if (mips_m4k->common_magic != MIPSM4K_COMMON_MAGIC) {
-		command_print(cmd->ctx, "target is not an MIPS_M4K");
+		command_print(cmd, "target is not an MIPS_M4K");
 		return ERROR_TARGET_INVALID;
 	}
 	return ERROR_OK;
@@ -1292,7 +1292,7 @@ COMMAND_HANDLER(mips_m4k_handle_cp0_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -1308,12 +1308,12 @@ COMMAND_HANDLER(mips_m4k_handle_cp0_command)
 			uint32_t value;
 			retval = mips32_cp0_read(ejtag_info, &value, cp0_reg, cp0_sel);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 						"couldn't access reg %" PRIi32,
 						cp0_reg);
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
+			command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
 					cp0_reg, cp0_sel, value);
 
 		} else if (CMD_ARGC == 3) {
@@ -1321,12 +1321,12 @@ COMMAND_HANDLER(mips_m4k_handle_cp0_command)
 			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
 			retval = mips32_cp0_write(ejtag_info, value, cp0_reg, cp0_sel);
 			if (retval != ERROR_OK) {
-				command_print(CMD_CTX,
+				command_print(CMD,
 						"couldn't access cp0 reg %" PRIi32 ", select %" PRIi32,
 						cp0_reg,  cp0_sel);
 				return ERROR_OK;
 			}
-			command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
+			command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
 					cp0_reg, cp0_sel, value);
 		}
 	}
@@ -1345,13 +1345,13 @@ COMMAND_HANDLER(mips_m4k_handle_scan_delay_command)
 	else if (CMD_ARGC > 1)
 			return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX, "scan delay: %d nsec", ejtag_info->scan_delay);
+	command_print(CMD, "scan delay: %d nsec", ejtag_info->scan_delay);
 	if (ejtag_info->scan_delay >= MIPS32_SCAN_DELAY_LEGACY_MODE) {
 		ejtag_info->mode = 0;
-		command_print(CMD_CTX, "running in legacy mode");
+		command_print(CMD, "running in legacy mode");
 	} else {
 		ejtag_info->mode = 1;
-		command_print(CMD_CTX, "running in fast queued mode");
+		command_print(CMD, "running in fast queued mode");
 	}
 
 	return ERROR_OK;
diff --git a/src/target/nds32_cmd.c b/src/target/nds32_cmd.c
index 500651d..1accf6f 100644
--- a/src/target/nds32_cmd.c
+++ b/src/target/nds32_cmd.c
@@ -46,7 +46,7 @@ COMMAND_HANDLER(handle_nds32_dssim_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -57,7 +57,7 @@ COMMAND_HANDLER(handle_nds32_dssim_command)
 			nds32->step_isr_enable = false;
 	}
 
-	command_print(CMD_CTX, "%s: $INT_MASK.DSSIM: %d", target_name(target),
+	command_print(CMD, "%s: $INT_MASK.DSSIM: %d", target_name(target),
 			nds32->step_isr_enable);
 
 	return ERROR_OK;
@@ -71,7 +71,7 @@ COMMAND_HANDLER(handle_nds32_memory_access_command)
 	struct nds32_memory *memory = &(nds32->memory);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -88,7 +88,7 @@ COMMAND_HANDLER(handle_nds32_memory_access_command)
 
 		aice_memory_access(aice, memory->access_channel);
 	} else {
-		command_print(CMD_CTX, "%s: memory access channel: %s",
+		command_print(CMD, "%s: memory access channel: %s",
 				target_name(target),
 				NDS_MEMORY_ACCESS_NAME[memory->access_channel]);
 	}
@@ -103,18 +103,18 @@ COMMAND_HANDLER(handle_nds32_memory_mode_command)
 	struct aice_port_s *aice = target_to_aice(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
 	if (CMD_ARGC > 0) {
 
 		if (nds32->edm.access_control == false) {
-			command_print(CMD_CTX, "%s does not support ACC_CTL. "
+			command_print(CMD, "%s does not support ACC_CTL. "
 					"Set memory mode to MEMORY", target_name(target));
 			nds32->memory.mode = NDS_MEMORY_SELECT_MEM;
 		} else if (nds32->edm.direct_access_local_memory == false) {
-			command_print(CMD_CTX, "%s does not support direct access "
+			command_print(CMD, "%s does not support direct access "
 					"local memory. Set memory mode to MEMORY",
 					target_name(target));
 			nds32->memory.mode = NDS_MEMORY_SELECT_MEM;
@@ -128,13 +128,13 @@ COMMAND_HANDLER(handle_nds32_memory_mode_command)
 				nds32->memory.mode = NDS_MEMORY_SELECT_MEM;
 			} else if (strcmp(CMD_ARGV[0], "ilm") == 0) {
 				if (nds32->memory.ilm_base == 0)
-					command_print(CMD_CTX, "%s does not support ILM",
+					command_print(CMD, "%s does not support ILM",
 							target_name(target));
 				else
 					nds32->memory.mode = NDS_MEMORY_SELECT_ILM;
 			} else if (strcmp(CMD_ARGV[0], "dlm") == 0) {
 				if (nds32->memory.dlm_base == 0)
-					command_print(CMD_CTX, "%s does not support DLM",
+					command_print(CMD, "%s does not support DLM",
 							target_name(target));
 				else
 					nds32->memory.mode = NDS_MEMORY_SELECT_DLM;
@@ -145,7 +145,7 @@ COMMAND_HANDLER(handle_nds32_memory_mode_command)
 		}
 	}
 
-	command_print(CMD_CTX, "%s: memory mode: %s",
+	command_print(CMD, "%s: memory mode: %s",
 			target_name(target),
 			NDS_MEMORY_SELECT_NAME[nds32->memory.mode]);
 
@@ -162,7 +162,7 @@ COMMAND_HANDLER(handle_nds32_cache_command)
 	int result;
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -173,30 +173,30 @@ COMMAND_HANDLER(handle_nds32_cache_command)
 				/* D$ write back */
 				result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_WBALL, 0);
 				if (result != ERROR_OK) {
-					command_print(CMD_CTX, "%s: Write back data cache...failed",
+					command_print(CMD, "%s: Write back data cache...failed",
 							target_name(target));
 					return result;
 				}
 
-				command_print(CMD_CTX, "%s: Write back data cache...done",
+				command_print(CMD, "%s: Write back data cache...done",
 						target_name(target));
 
 				/* D$ invalidate */
 				result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_INVALALL, 0);
 				if (result != ERROR_OK) {
-					command_print(CMD_CTX, "%s: Invalidate data cache...failed",
+					command_print(CMD, "%s: Invalidate data cache...failed",
 							target_name(target));
 					return result;
 				}
 
-				command_print(CMD_CTX, "%s: Invalidate data cache...done",
+				command_print(CMD, "%s: Invalidate data cache...done",
 						target_name(target));
 			} else {
 				if (dcache->line_size == 0)
-					command_print(CMD_CTX, "%s: No data cache",
+					command_print(CMD, "%s: No data cache",
 							target_name(target));
 				else
-					command_print(CMD_CTX, "%s: Data cache disabled",
+					command_print(CMD, "%s: Data cache disabled",
 							target_name(target));
 			}
 
@@ -204,23 +204,23 @@ COMMAND_HANDLER(handle_nds32_cache_command)
 				/* I$ invalidate */
 				result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1I_INVALALL, 0);
 				if (result != ERROR_OK) {
-					command_print(CMD_CTX, "%s: Invalidate instruction cache...failed",
+					command_print(CMD, "%s: Invalidate instruction cache...failed",
 							target_name(target));
 					return result;
 				}
 
-				command_print(CMD_CTX, "%s: Invalidate instruction cache...done",
+				command_print(CMD, "%s: Invalidate instruction cache...done",
 						target_name(target));
 			} else {
 				if (icache->line_size == 0)
-					command_print(CMD_CTX, "%s: No instruction cache",
+					command_print(CMD, "%s: No instruction cache",
 							target_name(target));
 				else
-					command_print(CMD_CTX, "%s: Instruction cache disabled",
+					command_print(CMD, "%s: Instruction cache disabled",
 							target_name(target));
 			}
 		} else
-			command_print(CMD_CTX, "No valid parameter");
+			command_print(CMD, "No valid parameter");
 	}
 
 	return ERROR_OK;
@@ -235,14 +235,14 @@ COMMAND_HANDLER(handle_nds32_icache_command)
 	int result;
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
 	if (CMD_ARGC > 0) {
 
 		if (icache->line_size == 0) {
-			command_print(CMD_CTX, "%s: No instruction cache",
+			command_print(CMD, "%s: No instruction cache",
 					target_name(target));
 			return ERROR_OK;
 		}
@@ -252,15 +252,15 @@ COMMAND_HANDLER(handle_nds32_icache_command)
 				/* I$ invalidate */
 				result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1I_INVALALL, 0);
 				if (result != ERROR_OK) {
-					command_print(CMD_CTX, "%s: Invalidate instruction cache...failed",
+					command_print(CMD, "%s: Invalidate instruction cache...failed",
 							target_name(target));
 					return result;
 				}
 
-				command_print(CMD_CTX, "%s: Invalidate instruction cache...done",
+				command_print(CMD, "%s: Invalidate instruction cache...done",
 						target_name(target));
 			} else {
-				command_print(CMD_CTX, "%s: Instruction cache disabled",
+				command_print(CMD, "%s: Instruction cache disabled",
 						target_name(target));
 			}
 		} else if (strcmp(CMD_ARGV[0], "enable") == 0) {
@@ -274,7 +274,7 @@ COMMAND_HANDLER(handle_nds32_icache_command)
 		} else if (strcmp(CMD_ARGV[0], "dump") == 0) {
 			/* TODO: dump cache content */
 		} else {
-			command_print(CMD_CTX, "%s: No valid parameter", target_name(target));
+			command_print(CMD, "%s: No valid parameter", target_name(target));
 		}
 	}
 
@@ -290,14 +290,14 @@ COMMAND_HANDLER(handle_nds32_dcache_command)
 	int result;
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
 	if (CMD_ARGC > 0) {
 
 		if (dcache->line_size == 0) {
-			command_print(CMD_CTX, "%s: No data cache", target_name(target));
+			command_print(CMD, "%s: No data cache", target_name(target));
 			return ERROR_OK;
 		}
 
@@ -306,26 +306,26 @@ COMMAND_HANDLER(handle_nds32_dcache_command)
 				/* D$ write back */
 				result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_WBALL, 0);
 				if (result != ERROR_OK) {
-					command_print(CMD_CTX, "%s: Write back data cache...failed",
+					command_print(CMD, "%s: Write back data cache...failed",
 							target_name(target));
 					return result;
 				}
 
-				command_print(CMD_CTX, "%s: Write back data cache...done",
+				command_print(CMD, "%s: Write back data cache...done",
 						target_name(target));
 
 				/* D$ invalidate */
 				result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_INVALALL, 0);
 				if (result != ERROR_OK) {
-					command_print(CMD_CTX, "%s: Invalidate data cache...failed",
+					command_print(CMD, "%s: Invalidate data cache...failed",
 							target_name(target));
 					return result;
 				}
 
-				command_print(CMD_CTX, "%s: Invalidate data cache...done",
+				command_print(CMD, "%s: Invalidate data cache...done",
 						target_name(target));
 			} else {
-				command_print(CMD_CTX, "%s: Data cache disabled",
+				command_print(CMD, "%s: Data cache disabled",
 						target_name(target));
 			}
 		} else if (strcmp(CMD_ARGV[0], "enable") == 0) {
@@ -339,7 +339,7 @@ COMMAND_HANDLER(handle_nds32_dcache_command)
 		} else if (strcmp(CMD_ARGV[0], "dump") == 0) {
 			/* TODO: dump cache content */
 		} else {
-			command_print(CMD_CTX, "%s: No valid parameter", target_name(target));
+			command_print(CMD, "%s: No valid parameter", target_name(target));
 		}
 	}
 
@@ -352,7 +352,7 @@ COMMAND_HANDLER(handle_nds32_auto_break_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -364,10 +364,10 @@ COMMAND_HANDLER(handle_nds32_auto_break_command)
 	}
 
 	if (nds32->auto_convert_hw_bp)
-		command_print(CMD_CTX, "%s: convert sw break to hw break on ROM: on",
+		command_print(CMD, "%s: convert sw break to hw break on ROM: on",
 				target_name(target));
 	else
-		command_print(CMD_CTX, "%s: convert sw break to hw break on ROM: off",
+		command_print(CMD, "%s: convert sw break to hw break on ROM: off",
 				target_name(target));
 
 	return ERROR_OK;
@@ -379,7 +379,7 @@ COMMAND_HANDLER(handle_nds32_virtual_hosting_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -391,9 +391,9 @@ COMMAND_HANDLER(handle_nds32_virtual_hosting_command)
 	}
 
 	if (nds32->virtual_hosting)
-		command_print(CMD_CTX, "%s: virtual hosting: on", target_name(target));
+		command_print(CMD, "%s: virtual hosting: on", target_name(target));
 	else
-		command_print(CMD_CTX, "%s: virtual hosting: off", target_name(target));
+		command_print(CMD, "%s: virtual hosting: off", target_name(target));
 
 	return ERROR_OK;
 }
@@ -404,7 +404,7 @@ COMMAND_HANDLER(handle_nds32_global_stop_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -429,7 +429,7 @@ COMMAND_HANDLER(handle_nds32_soft_reset_halt_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -454,7 +454,7 @@ COMMAND_HANDLER(handle_nds32_boot_time_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -470,7 +470,7 @@ COMMAND_HANDLER(handle_nds32_login_edm_passcode_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -485,7 +485,7 @@ COMMAND_HANDLER(handle_nds32_login_edm_operation_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -516,7 +516,7 @@ COMMAND_HANDLER(handle_nds32_reset_halt_as_init_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -536,7 +536,7 @@ COMMAND_HANDLER(handle_nds32_keep_target_edm_ctl_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -556,7 +556,7 @@ COMMAND_HANDLER(handle_nds32_decode_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -581,7 +581,7 @@ COMMAND_HANDLER(handle_nds32_decode_command)
 						read_addr, &instruction))
 				return ERROR_FAIL;
 
-			command_print(CMD_CTX, "%s", instruction.text);
+			command_print(CMD, "%s", instruction.text);
 
 			read_addr += instruction.instruction_size;
 			i++;
@@ -599,7 +599,7 @@ COMMAND_HANDLER(handle_nds32_decode_command)
 		if (ERROR_OK != nds32_evaluate_opcode(nds32, opcode, addr, &instruction))
 			return ERROR_FAIL;
 
-		command_print(CMD_CTX, "%s", instruction.text);
+		command_print(CMD, "%s", instruction.text);
 	} else
 		return ERROR_FAIL;
 
@@ -612,7 +612,7 @@ COMMAND_HANDLER(handle_nds32_word_access_mem_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -632,11 +632,11 @@ COMMAND_HANDLER(handle_nds32_query_target_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
-	command_print(CMD_CTX, "OCD");
+	command_print(CMD, "OCD");
 
 	return ERROR_OK;
 }
@@ -647,7 +647,7 @@ COMMAND_HANDLER(handle_nds32_query_endian_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
@@ -655,9 +655,9 @@ COMMAND_HANDLER(handle_nds32_query_endian_command)
 	nds32_get_mapped_reg(nds32, IR0, &value_psw);
 
 	if (value_psw & 0x20)
-		command_print(CMD_CTX, "%s: BE", target_name(target));
+		command_print(CMD, "%s: BE", target_name(target));
 	else
-		command_print(CMD_CTX, "%s: LE", target_name(target));
+		command_print(CMD, "%s: LE", target_name(target));
 
 	return ERROR_OK;
 }
@@ -668,11 +668,11 @@ COMMAND_HANDLER(handle_nds32_query_cpuid_command)
 	struct nds32 *nds32 = target_to_nds32(target);
 
 	if (!is_nds32(nds32)) {
-		command_print(CMD_CTX, "current target isn't an Andes core");
+		command_print(CMD, "current target isn't an Andes core");
 		return ERROR_FAIL;
 	}
 
-	command_print(CMD_CTX, "CPUID: %s", target_name(target));
+	command_print(CMD, "CPUID: %s", target_name(target));
 
 	return ERROR_OK;
 }
diff --git a/src/target/oocd_trace.c b/src/target/oocd_trace.c
index 627366d..f38916a 100644
--- a/src/target/oocd_trace.c
+++ b/src/target/oocd_trace.c
@@ -277,7 +277,7 @@ COMMAND_HANDLER(handle_oocd_trace_config_command)
 	target = get_current_target(CMD_CTX);
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "current target isn't an ARM");
+		command_print(CMD, "current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
@@ -306,17 +306,17 @@ COMMAND_HANDLER(handle_oocd_trace_status_command)
 
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "current target isn't an ARM");
+		command_print(CMD, "current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	if (!arm->etm) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
 	if (strcmp(arm->etm->capture_driver->name, "oocd_trace") != 0) {
-		command_print(CMD_CTX, "current target's ETM capture driver isn't 'oocd_trace'");
+		command_print(CMD, "current target's ETM capture driver isn't 'oocd_trace'");
 		return ERROR_FAIL;
 	}
 
@@ -325,9 +325,9 @@ COMMAND_HANDLER(handle_oocd_trace_status_command)
 	oocd_trace_read_reg(oocd_trace, OOCD_TRACE_STATUS, &status);
 
 	if (status & 0x8)
-		command_print(CMD_CTX, "trace clock locked");
+		command_print(CMD, "trace clock locked");
 	else
-		command_print(CMD_CTX, "no trace clock");
+		command_print(CMD, "no trace clock");
 
 	return ERROR_OK;
 }
@@ -344,17 +344,17 @@ COMMAND_HANDLER(handle_oocd_trace_resync_command)
 
 	arm = target_to_arm(target);
 	if (!is_arm(arm)) {
-		command_print(CMD_CTX, "current target isn't an ARM");
+		command_print(CMD, "current target isn't an ARM");
 		return ERROR_FAIL;
 	}
 
 	if (!arm->etm) {
-		command_print(CMD_CTX, "current target doesn't have an ETM configured");
+		command_print(CMD, "current target doesn't have an ETM configured");
 		return ERROR_FAIL;
 	}
 
 	if (strcmp(arm->etm->capture_driver->name, "oocd_trace") != 0) {
-		command_print(CMD_CTX, "current target's ETM capture driver isn't 'oocd_trace'");
+		command_print(CMD, "current target's ETM capture driver isn't 'oocd_trace'");
 		return ERROR_FAIL;
 	}
 
@@ -366,7 +366,7 @@ COMMAND_HANDLER(handle_oocd_trace_resync_command)
 	if (bytes_written < 1)
 		return ERROR_FAIL;
 
-	command_print(CMD_CTX, "requesting traceclock resync");
+	command_print(CMD, "requesting traceclock resync");
 	LOG_DEBUG("resyncing traceclk pll");
 
 	return ERROR_OK;
diff --git a/src/target/openrisc/or1k.c b/src/target/openrisc/or1k.c
index 1cecebd..1e5db8c 100644
--- a/src/target/openrisc/or1k.c
+++ b/src/target/openrisc/or1k.c
@@ -1291,7 +1291,7 @@ COMMAND_HANDLER(or1k_tap_list_command_handler)
 
 	list_for_each_entry(or1k_tap, &tap_list, list) {
 		if (or1k_tap->name)
-			command_print(CMD_CTX, "%s", or1k_tap->name);
+			command_print(CMD, "%s", or1k_tap->name);
 	}
 
 	return ERROR_OK;
@@ -1339,7 +1339,7 @@ COMMAND_HANDLER(or1k_du_list_command_handler)
 
 	list_for_each_entry(or1k_du, &du_list, list) {
 		if (or1k_du->name)
-			command_print(CMD_CTX, "%s", or1k_du->name);
+			command_print(CMD, "%s", or1k_du->name);
 	}
 
 	return ERROR_OK;
diff --git a/src/target/riscv/riscv.c b/src/target/riscv/riscv.c
index 44da5a9..8b5a361 100644
--- a/src/target/riscv/riscv.c
+++ b/src/target/riscv/riscv.c
@@ -1623,7 +1623,7 @@ COMMAND_HANDLER(riscv_authdata_read)
 		uint32_t value;
 		if (r->authdata_read(target, &value) != ERROR_OK)
 			return ERROR_FAIL;
-		command_print(CMD_CTX, "0x%" PRIx32, value);
+		command_print(CMD, "0x%" PRIx32, value);
 		return ERROR_OK;
 	} else {
 		LOG_ERROR("authdata_read is not implemented for this target.");
@@ -1676,7 +1676,7 @@ COMMAND_HANDLER(riscv_dmi_read)
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
 		if (r->dmi_read(target, &value, address) != ERROR_OK)
 			return ERROR_FAIL;
-		command_print(CMD_CTX, "0x%" PRIx32, value);
+		command_print(CMD, "0x%" PRIx32, value);
 		return ERROR_OK;
 	} else {
 		LOG_ERROR("dmi_read is not implemented for this target.");
diff --git a/src/target/semihosting_common.c b/src/target/semihosting_common.c
index 5920789..ce6a791 100644
--- a/src/target/semihosting_common.c
+++ b/src/target/semihosting_common.c
@@ -1470,7 +1470,7 @@ __COMMAND_HANDLER(handle_common_semihosting_command)
 
 	struct semihosting *semihosting = target->semihosting;
 	if (!semihosting) {
-		command_print(CMD_CTX, "semihosting not supported for current target");
+		command_print(CMD, "semihosting not supported for current target");
 		return ERROR_FAIL;
 	}
 
@@ -1493,7 +1493,7 @@ __COMMAND_HANDLER(handle_common_semihosting_command)
 		semihosting->is_active = is_active;
 	}
 
-	command_print(CMD_CTX, "semihosting is %s",
+	command_print(CMD, "semihosting is %s",
 		semihosting->is_active
 		? "enabled" : "disabled");
 
@@ -1512,19 +1512,19 @@ __COMMAND_HANDLER(handle_common_semihosting_fileio_command)
 
 	struct semihosting *semihosting = target->semihosting;
 	if (!semihosting) {
-		command_print(CMD_CTX, "semihosting not supported for current target");
+		command_print(CMD, "semihosting not supported for current target");
 		return ERROR_FAIL;
 	}
 
 	if (!semihosting->is_active) {
-		command_print(CMD_CTX, "semihosting not yet enabled for current target");
+		command_print(CMD, "semihosting not yet enabled for current target");
 		return ERROR_FAIL;
 	}
 
 	if (CMD_ARGC > 0)
 		COMMAND_PARSE_ENABLE(CMD_ARGV[0], semihosting->is_fileio);
 
-	command_print(CMD_CTX, "semihosting fileio is %s",
+	command_print(CMD, "semihosting fileio is %s",
 		semihosting->is_fileio
 		? "enabled" : "disabled");
 
@@ -1543,7 +1543,7 @@ __COMMAND_HANDLER(handle_common_semihosting_cmdline)
 
 	struct semihosting *semihosting = target->semihosting;
 	if (!semihosting) {
-		command_print(CMD_CTX, "semihosting not supported for current target");
+		command_print(CMD, "semihosting not supported for current target");
 		return ERROR_FAIL;
 	}
 
@@ -1558,7 +1558,7 @@ __COMMAND_HANDLER(handle_common_semihosting_cmdline)
 		semihosting->cmdline = cmdline;
 	}
 
-	command_print(CMD_CTX, "semihosting command line is [%s]",
+	command_print(CMD, "semihosting command line is [%s]",
 		semihosting->cmdline);
 
 	return ERROR_OK;
@@ -1575,19 +1575,19 @@ __COMMAND_HANDLER(handle_common_semihosting_resumable_exit_command)
 
 	struct semihosting *semihosting = target->semihosting;
 	if (!semihosting) {
-		command_print(CMD_CTX, "semihosting not supported for current target");
+		command_print(CMD, "semihosting not supported for current target");
 		return ERROR_FAIL;
 	}
 
 	if (!semihosting->is_active) {
-		command_print(CMD_CTX, "semihosting not yet enabled for current target");
+		command_print(CMD, "semihosting not yet enabled for current target");
 		return ERROR_FAIL;
 	}
 
 	if (CMD_ARGC > 0)
 		COMMAND_PARSE_ENABLE(CMD_ARGV[0], semihosting->has_resumable_exit);
 
-	command_print(CMD_CTX, "semihosting resumable exit is %s",
+	command_print(CMD, "semihosting resumable exit is %s",
 		semihosting->has_resumable_exit
 		? "enabled" : "disabled");
 
diff --git a/src/target/smp.c b/src/target/smp.c
index f42d8ab..acd4628 100644
--- a/src/target/smp.c
+++ b/src/target/smp.c
@@ -106,7 +106,7 @@ COMMAND_HANDLER(default_handle_smp_command)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	if (!CMD_ARGC) {
-		command_print(CMD_CTX, "%s", target->smp ? "on" : "off");
+		command_print(CMD, "%s", target->smp ? "on" : "off");
 		return ERROR_OK;
 	}
 
@@ -166,7 +166,7 @@ COMMAND_HANDLER(handle_smp_gdb_command)
 			target->gdb_service->core[1] = coreid;
 
 		}
-		command_print(CMD_CTX, "gdb coreid  %" PRId32 " -> %" PRId32, target->gdb_service->core[0]
+		command_print(CMD, "gdb coreid  %" PRId32 " -> %" PRId32, target->gdb_service->core[0]
 			, target->gdb_service->core[1]);
 	}
 	return ERROR_OK;
diff --git a/src/target/stm8.c b/src/target/stm8.c
index b62ff13..fcfc170 100644
--- a/src/target/stm8.c
+++ b/src/target/stm8.c
@@ -2147,7 +2147,7 @@ COMMAND_HANDLER(stm8_handle_enable_step_irq_command)
 		stm8->enable_step_irq = enable;
 	}
 	msg = stm8->enable_step_irq ? "enabled" : "disabled";
-	command_print(CMD_CTX, "enable_step_irq = %s", msg);
+	command_print(CMD, "enable_step_irq = %s", msg);
 	return ERROR_OK;
 }
 
@@ -2163,7 +2163,7 @@ COMMAND_HANDLER(stm8_handle_enable_stm8l_command)
 		stm8->enable_stm8l = enable;
 	}
 	msg = stm8->enable_stm8l ? "enabled" : "disabled";
-	command_print(CMD_CTX, "enable_stm8l = %s", msg);
+	command_print(CMD, "enable_stm8l = %s", msg);
 	stm8_init_flash_regs(stm8->enable_stm8l, stm8);
 	return ERROR_OK;
 }
diff --git a/src/target/target.c b/src/target/target.c
index 58864ce..20bf26b 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -670,7 +670,7 @@ static int target_process_reset(struct command_invocation *cmd, enum target_rese
 
 	if (retval != JIM_OK) {
 		Jim_MakeErrorMessage(cmd->ctx->interp);
-		command_print(cmd->ctx, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
+		command_print(cmd, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
 		return ERROR_FAIL;
 	}
 
@@ -2612,8 +2612,8 @@ COMMAND_HANDLER(handle_targets_command)
 	}
 
 	struct target *target = all_targets;
-	command_print(CMD_CTX, "    TargetName         Type       Endian TapName            State       ");
-	command_print(CMD_CTX, "--  ------------------ ---------- ------ ------------------ ------------");
+	command_print(CMD, "    TargetName         Type       Endian TapName            State       ");
+	command_print(CMD, "--  ------------------ ---------- ------ ------------------ ------------");
 	while (target) {
 		const char *state;
 		char marker = ' ';
@@ -2627,7 +2627,7 @@ COMMAND_HANDLER(handle_targets_command)
 			marker = '*';
 
 		/* keep columns lined up to match the headers above */
-		command_print(CMD_CTX,
+		command_print(CMD,
 				"%2d%c %-18s %-10s %-6s %-18s %s",
 				target->target_number,
 				marker,
@@ -2837,7 +2837,7 @@ COMMAND_HANDLER(handle_reg_command)
 		while (cache) {
 			unsigned i;
 
-			command_print(CMD_CTX, "===== %s", cache->name);
+			command_print(CMD, "===== %s", cache->name);
 
 			for (i = 0, reg = cache->reg_list;
 					i < cache->num_regs;
@@ -2848,7 +2848,7 @@ COMMAND_HANDLER(handle_reg_command)
 				if (reg->valid) {
 					value = buf_to_str(reg->value,
 							reg->size, 16);
-					command_print(CMD_CTX,
+					command_print(CMD,
 							"(%i) %s (/%" PRIu32 "): 0x%s%s",
 							count, reg->name,
 							reg->size, value,
@@ -2857,7 +2857,7 @@ COMMAND_HANDLER(handle_reg_command)
 								: "");
 					free(value);
 				} else {
-					command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")",
+					command_print(CMD, "(%i) %s (/%" PRIu32 ")",
 							  count, reg->name,
 							  reg->size) ;
 				}
@@ -2889,7 +2889,7 @@ COMMAND_HANDLER(handle_reg_command)
 		}
 
 		if (!reg) {
-			command_print(CMD_CTX, "%i is out of bounds, the current target "
+			command_print(CMD, "%i is out of bounds, the current target "
 					"has only %i registers (0 - %i)", num, count, count - 1);
 			return ERROR_OK;
 		}
@@ -2915,7 +2915,7 @@ COMMAND_HANDLER(handle_reg_command)
 		if (reg->valid == 0)
 			reg->type->get(reg);
 		value = buf_to_str(reg->value, reg->size, 16);
-		command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+		command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
 		free(value);
 		return ERROR_OK;
 	}
@@ -2930,7 +2930,7 @@ COMMAND_HANDLER(handle_reg_command)
 		reg->type->set(reg, buf);
 
 		value = buf_to_str(reg->value, reg->size, 16);
-		command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+		command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
 		free(value);
 
 		free(buf);
@@ -2941,7 +2941,7 @@ COMMAND_HANDLER(handle_reg_command)
 	return ERROR_COMMAND_SYNTAX_ERROR;
 
 not_found:
-	command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
+	command_print(CMD, "register %s not found in current target", CMD_ARGV[0]);
 	return ERROR_OK;
 }
 
@@ -2951,9 +2951,9 @@ COMMAND_HANDLER(handle_poll_command)
 	struct target *target = get_current_target(CMD_CTX);
 
 	if (CMD_ARGC == 0) {
-		command_print(CMD_CTX, "background polling: %s",
+		command_print(CMD, "background polling: %s",
 				jtag_poll_get_enabled() ? "on" : "off");
-		command_print(CMD_CTX, "TAP: %s (%s)",
+		command_print(CMD, "TAP: %s (%s)",
 				target->tap->dotted_name,
 				target->tap->enabled ? "enabled" : "disabled");
 		if (!target->tap->enabled)
@@ -3183,7 +3183,7 @@ static void handle_md_output(struct command_invocation *cmd,
 				value_fmt, value);
 
 		if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
-			command_print(cmd->ctx, "%s", output);
+			command_print(cmd, "%s", output);
 			output_len = 0;
 		}
 	}
@@ -3413,7 +3413,7 @@ COMMAND_HANDLER(handle_load_image_command)
 	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
 		if (buffer == NULL) {
-			command_print(CMD_CTX,
+			command_print(CMD,
 						  "error allocating buffer for section (%d bytes)",
 						  (int)(image.sections[i].size));
 			retval = ERROR_FAIL;
@@ -3450,7 +3450,7 @@ COMMAND_HANDLER(handle_load_image_command)
 				break;
 			}
 			image_size += length;
-			command_print(CMD_CTX, "%u bytes written at address " TARGET_ADDR_FMT "",
+			command_print(CMD, "%u bytes written at address " TARGET_ADDR_FMT "",
 					(unsigned int)length,
 					image.sections[i].base_address + offset);
 		}
@@ -3459,7 +3459,7 @@ COMMAND_HANDLER(handle_load_image_command)
 	}
 
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
+		command_print(CMD, "downloaded %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 	}
@@ -3520,7 +3520,7 @@ COMMAND_HANDLER(handle_dump_image_command)
 		retval = fileio_size(fileio, &filesize);
 		if (retval != ERROR_OK)
 			return retval;
-		command_print(CMD_CTX,
+		command_print(CMD,
 				"dumped %zu bytes in %fs (%0.3f KiB/s)", filesize,
 				duration_elapsed(&bench), duration_kbps(&bench, filesize));
 	}
@@ -3585,7 +3585,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
 		if (buffer == NULL) {
-			command_print(CMD_CTX,
+			command_print(CMD,
 					"error allocating buffer for section (%d bytes)",
 					(int)(image.sections[i].size));
 			break;
@@ -3636,14 +3636,14 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 					uint32_t t;
 					for (t = 0; t < buf_cnt; t++) {
 						if (data[t] != buffer[t]) {
-							command_print(CMD_CTX,
+							command_print(CMD,
 										  "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
 										  diffs,
 										  (unsigned)(t + image.sections[i].base_address),
 										  data[t],
 										  buffer[t]);
 							if (diffs++ >= 127) {
-								command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
+								command_print(CMD, "More than 128 errors, the rest are not printed.");
 								free(data);
 								free(buffer);
 								goto done;
@@ -3655,7 +3655,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 				free(data);
 			}
 		} else {
-			command_print(CMD_CTX, "address " TARGET_ADDR_FMT " length 0x%08zx",
+			command_print(CMD, "address " TARGET_ADDR_FMT " length 0x%08zx",
 						  image.sections[i].base_address,
 						  buf_cnt);
 		}
@@ -3664,12 +3664,12 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 		image_size += buf_cnt;
 	}
 	if (diffs > 0)
-		command_print(CMD_CTX, "No more differences found.");
+		command_print(CMD, "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 "
+		command_print(CMD, "verified %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 	}
@@ -3702,24 +3702,24 @@ static int handle_bp_command_list(struct command_invocation *cmd)
 		if (breakpoint->type == BKPT_SOFT) {
 			char *buf = buf_to_str(breakpoint->orig_instr,
 					breakpoint->length, 16);
-			command_print(cmd->ctx, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",
+			command_print(cmd, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",
 					breakpoint->address,
 					breakpoint->length,
 					breakpoint->set, buf);
 			free(buf);
 		} else {
 			if ((breakpoint->address == 0) && (breakpoint->asid != 0))
-				command_print(cmd->ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
+				command_print(cmd, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
 							breakpoint->asid,
 							breakpoint->length, breakpoint->set);
 			else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
-				command_print(cmd->ctx, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
+				command_print(cmd, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
 							breakpoint->address,
 							breakpoint->length, breakpoint->set);
-				command_print(cmd->ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
+				command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
 							breakpoint->asid);
 			} else
-				command_print(cmd->ctx, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
+				command_print(cmd, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
 							breakpoint->address,
 							breakpoint->length, breakpoint->set);
 		}
@@ -3739,7 +3739,7 @@ static int handle_bp_command_set(struct command_invocation *cmd,
 		retval = breakpoint_add(target, addr, length, hw);
 		/* error is always logged in breakpoint_add(), do not print it again */
 		if (ERROR_OK == retval)
-			command_print(cmd->ctx, "breakpoint set at " TARGET_ADDR_FMT "", addr);
+			command_print(cmd, "breakpoint set at " TARGET_ADDR_FMT "", addr);
 
 	} else if (addr == 0) {
 		if (target->type->add_context_breakpoint == NULL) {
@@ -3749,7 +3749,7 @@ static int handle_bp_command_set(struct command_invocation *cmd,
 		retval = context_breakpoint_add(target, asid, length, hw);
 		/* error is always logged in context_breakpoint_add(), do not print it again */
 		if (ERROR_OK == retval)
-			command_print(cmd->ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
+			command_print(cmd, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
 
 	} else {
 		if (target->type->add_hybrid_breakpoint == NULL) {
@@ -3759,7 +3759,7 @@ static int handle_bp_command_set(struct command_invocation *cmd,
 		retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
 		/* error is always logged in hybrid_breakpoint_add(), do not print it again */
 		if (ERROR_OK == retval)
-			command_print(cmd->ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
+			command_print(cmd, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
 	}
 	return retval;
 }
@@ -3830,7 +3830,7 @@ COMMAND_HANDLER(handle_wp_command)
 		struct watchpoint *watchpoint = target->watchpoints;
 
 		while (watchpoint) {
-			command_print(CMD_CTX, "address: " TARGET_ADDR_FMT
+			command_print(CMD, "address: " TARGET_ADDR_FMT
 					", len: 0x%8.8" PRIx32
 					", r/w/a: %i, value: 0x%8.8" PRIx32
 					", mask: 0x%8.8" PRIx32,
@@ -3922,7 +3922,7 @@ COMMAND_HANDLER(handle_virt2phys_command)
 	struct target *target = get_current_target(CMD_CTX);
 	int retval = target->type->virt2phys(target, va, &pa);
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "Physical address " TARGET_ADDR_FMT "", pa);
+		command_print(CMD, "Physical address " TARGET_ADDR_FMT "", pa);
 
 	return retval;
 }
@@ -4115,7 +4115,7 @@ COMMAND_HANDLER(handle_profile_command)
 
 	write_gmon(samples, num_of_samples, CMD_ARGV[1],
 		   with_range, start_address, end_address, target, duration_ms);
-	command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
+	command_print(CMD, "Wrote %s", CMD_ARGV[1]);
 
 	free(samples);
 	return retval;
@@ -5152,19 +5152,19 @@ COMMAND_HANDLER(handle_target_event_list)
 	struct target *target = get_current_target(CMD_CTX);
 	struct target_event_action *teap = target->event_action;
 
-	command_print(CMD_CTX, "Event actions for target (%d) %s\n",
+	command_print(CMD, "Event actions for target (%d) %s\n",
 				   target->target_number,
 				   target_name(target));
-	command_print(CMD_CTX, "%-25s | Body", "Event");
-	command_print(CMD_CTX, "------------------------- | "
+	command_print(CMD, "%-25s | Body", "Event");
+	command_print(CMD, "------------------------- | "
 			"----------------------------------------");
 	while (teap) {
 		Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
-		command_print(CMD_CTX, "%-25s | %s",
+		command_print(CMD, "%-25s | %s",
 				opt->name, Jim_GetString(teap->body, NULL));
 		teap = teap->next;
 	}
-	command_print(CMD_CTX, "***END***");
+	command_print(CMD, "***END***");
 	return ERROR_OK;
 }
 static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
@@ -5776,7 +5776,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	fastload_num = image.num_sections;
 	fastload = malloc(sizeof(struct FastLoad)*image.num_sections);
 	if (fastload == NULL) {
-		command_print(CMD_CTX, "out of memory");
+		command_print(CMD, "out of memory");
 		image_close(&image);
 		return ERROR_FAIL;
 	}
@@ -5784,7 +5784,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
 		if (buffer == NULL) {
-			command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
+			command_print(CMD, "error allocating buffer for section (%d bytes)",
 						  (int)(image.sections[i].size));
 			retval = ERROR_FAIL;
 			break;
@@ -5816,7 +5816,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 			fastload[i].data = malloc(length);
 			if (fastload[i].data == NULL) {
 				free(buffer);
-				command_print(CMD_CTX, "error allocating buffer for section (%" PRIu32 " bytes)",
+				command_print(CMD, "error allocating buffer for section (%" PRIu32 " bytes)",
 							  length);
 				retval = ERROR_FAIL;
 				break;
@@ -5825,7 +5825,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 			fastload[i].length = length;
 
 			image_size += length;
-			command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
+			command_print(CMD, "%u bytes written at address 0x%8.8x",
 						  (unsigned int)length,
 						  ((unsigned int)(image.sections[i].base_address + offset)));
 		}
@@ -5834,11 +5834,11 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	}
 
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
+		command_print(CMD, "Loaded %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 
-		command_print(CMD_CTX,
+		command_print(CMD,
 				"WARNING: image has not been loaded to target!"
 				"You can issue a 'fast_load' to finish loading.");
 	}
@@ -5865,7 +5865,7 @@ COMMAND_HANDLER(handle_fast_load_command)
 	int retval = ERROR_OK;
 	for (i = 0; i < fastload_num; i++) {
 		struct target *target = get_current_target(CMD_CTX);
-		command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
+		command_print(CMD, "Write to 0x%08x, length 0x%08x",
 					  (unsigned int)(fastload[i].address),
 					  (unsigned int)(fastload[i].length));
 		retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
@@ -5875,7 +5875,7 @@ COMMAND_HANDLER(handle_fast_load_command)
 	}
 	if (retval == ERROR_OK) {
 		int64_t after = timeval_ms();
-		command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
+		command_print(CMD, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
 	}
 	return retval;
 }
@@ -5930,7 +5930,7 @@ COMMAND_HANDLER(handle_ps_command)
 	if ((target->rtos) && (target->rtos->type)
 			&& (target->rtos->type->ps_command)) {
 		display = target->rtos->type->ps_command(target);
-		command_print(CMD_CTX, "%s", display);
+		command_print(CMD, "%s", display);
 		free(display);
 		return ERROR_OK;
 	} else {
@@ -5942,10 +5942,10 @@ COMMAND_HANDLER(handle_ps_command)
 static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size)
 {
 	if (text != NULL)
-		command_print_sameline(cmd->ctx, "%s", text);
+		command_print_sameline(cmd, "%s", text);
 	for (int i = 0; i < size; i++)
-		command_print_sameline(cmd->ctx, " %02x", buf[i]);
-	command_print(cmd->ctx, " ");
+		command_print_sameline(cmd, " %02x", buf[i]);
+	command_print(cmd, " ");
 }
 
 COMMAND_HANDLER(handle_test_mem_access_command)
@@ -5997,7 +5997,7 @@ COMMAND_HANDLER(handle_test_mem_access_command)
 					read_ref[i] = rand();
 					read_buf[i] = read_ref[i];
 				}
-				command_print_sameline(CMD_CTX,
+				command_print_sameline(CMD,
 						"Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count,
 						size, offset, host_offset ? "un" : "");
 
@@ -6010,10 +6010,10 @@ COMMAND_HANDLER(handle_test_mem_access_command)
 				duration_measure(&bench);
 
 				if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
-					command_print(CMD_CTX, "Unsupported alignment");
+					command_print(CMD, "Unsupported alignment");
 					goto next;
 				} else if (retval != ERROR_OK) {
-					command_print(CMD_CTX, "Memory read failed");
+					command_print(CMD, "Memory read failed");
 					goto next;
 				}
 
@@ -6023,11 +6023,11 @@ COMMAND_HANDLER(handle_test_mem_access_command)
 				/* check result */
 				int result = memcmp(read_ref, read_buf, host_bufsiz);
 				if (result == 0) {
-					command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+					command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
 							duration_elapsed(&bench),
 							duration_kbps(&bench, count * size));
 				} else {
-					command_print(CMD_CTX, "Compare failed");
+					command_print(CMD, "Compare failed");
 					binprint(CMD, "ref:", read_ref, host_bufsiz);
 					binprint(CMD, "buf:", read_buf, host_bufsiz);
 				}
@@ -6069,13 +6069,13 @@ out:
 
 				for (size_t i = 0; i < host_bufsiz; i++)
 					write_buf[i] = rand();
-				command_print_sameline(CMD_CTX,
+				command_print_sameline(CMD,
 						"Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count,
 						size, offset, host_offset ? "un" : "");
 
 				retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
 				if (retval != ERROR_OK) {
-					command_print(CMD_CTX, "Test pattern write failed");
+					command_print(CMD, "Test pattern write failed");
 					goto nextw;
 				}
 
@@ -6092,28 +6092,28 @@ out:
 				duration_measure(&bench);
 
 				if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
-					command_print(CMD_CTX, "Unsupported alignment");
+					command_print(CMD, "Unsupported alignment");
 					goto nextw;
 				} else if (retval != ERROR_OK) {
-					command_print(CMD_CTX, "Memory write failed");
+					command_print(CMD, "Memory write failed");
 					goto nextw;
 				}
 
 				/* read back */
 				retval = target_read_memory(target, wa->address, 1, num_bytes, read_buf);
 				if (retval != ERROR_OK) {
-					command_print(CMD_CTX, "Test pattern write failed");
+					command_print(CMD, "Test pattern write failed");
 					goto nextw;
 				}
 
 				/* check result */
 				int result = memcmp(read_ref, read_buf, num_bytes);
 				if (result == 0) {
-					command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+					command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
 							duration_elapsed(&bench),
 							duration_kbps(&bench, count * size));
 				} else {
-					command_print(CMD_CTX, "Compare failed");
+					command_print(CMD, "Compare failed");
 					binprint(CMD, "ref:", read_ref, num_bytes);
 					binprint(CMD, "buf:", read_buf, num_bytes);
 				}
diff --git a/src/target/target_request.c b/src/target/target_request.c
index 2df2958..c1da1a2 100644
--- a/src/target/target_request.c
+++ b/src/target/target_request.c
@@ -283,7 +283,7 @@ COMMAND_HANDLER(handle_target_request_debugmsgs_command)
 			return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	command_print(CMD_CTX, "receiving debug messages from current target %s",
+	command_print(CMD, "receiving debug messages from current target %s",
 			(receiving) ? (charmsg_mode ? "charmsg" : "enabled") : "disabled");
 	return ERROR_OK;
 }
diff --git a/src/target/trace.c b/src/target/trace.c
index 63c477f..943bf1f 100644
--- a/src/target/trace.c
+++ b/src/target/trace.c
@@ -53,7 +53,7 @@ COMMAND_HANDLER(handle_trace_point_command)
 		uint32_t i;
 
 		for (i = 0; i < trace->num_trace_points; i++) {
-			command_print(CMD_CTX, "trace point 0x%8.8" PRIx32 " (%lld times hit)",
+			command_print(CMD, "trace point 0x%8.8" PRIx32 " (%lld times hit)",
 					trace->trace_points[i].address,
 					(long long)trace->trace_points[i].hit_counter);
 		}
@@ -108,14 +108,14 @@ COMMAND_HANDLER(handle_trace_history_command)
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], trace->trace_history_size);
 		trace->trace_history = malloc(sizeof(uint32_t) * trace->trace_history_size);
 
-		command_print(CMD_CTX, "new trace history size: %i", (int)(trace->trace_history_size));
+		command_print(CMD, "new trace history size: %i", (int)(trace->trace_history_size));
 	} else {
 		uint32_t i;
 		uint32_t first = 0;
 		uint32_t last = trace->trace_history_pos;
 
 		if (!trace->trace_history_size) {
-			command_print(CMD_CTX, "trace history buffer is not allocated");
+			command_print(CMD, "trace history buffer is not allocated");
 			return ERROR_OK;
 		}
 
@@ -128,11 +128,11 @@ COMMAND_HANDLER(handle_trace_history_command)
 			if (trace->trace_history[i % trace->trace_history_size] < trace->num_trace_points) {
 				uint32_t address;
 				address = trace->trace_points[trace->trace_history[i % trace->trace_history_size]].address;
-				command_print(CMD_CTX, "trace point %i: 0x%8.8" PRIx32 "",
+				command_print(CMD, "trace point %i: 0x%8.8" PRIx32 "",
 						(int)(trace->trace_history[i % trace->trace_history_size]),
 						address);
 			} else
-				command_print(CMD_CTX, "trace point %i: -not defined-",
+				command_print(CMD, "trace point %i: -not defined-",
 						(int)(trace->trace_history[i % trace->trace_history_size]));
 		}
 	}
diff --git a/src/target/x86_32_common.c b/src/target/x86_32_common.c
index a641ca9..b85e451 100644
--- a/src/target/x86_32_common.c
+++ b/src/target/x86_32_common.c
@@ -1392,7 +1392,7 @@ static void handle_iod_output(struct command_invocation *cmd,
 				value_fmt, value);
 
 		if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
-			command_print(cmd->ctx, "%s", output);
+			command_print(cmd, "%s", output);
 			output_len = 0;
 		}
 	}
diff --git a/src/target/xscale.c b/src/target/xscale.c
index a090c4b..093925b 100644
--- a/src/target/xscale.c
+++ b/src/target/xscale.c
@@ -142,7 +142,7 @@ static int xscale_verify_pointer(struct command_invocation *cmd,
 	struct xscale_common *xscale)
 {
 	if (xscale->common_magic != XSCALE_COMMON_MAGIC) {
-		command_print(cmd->ctx, xscale_not);
+		command_print(cmd, xscale_not);
 		return ERROR_TARGET_INVALID;
 	}
 	return ERROR_OK;
@@ -2658,9 +2658,9 @@ static inline void xscale_display_instruction(struct target *target, uint32_t pc
 {
 	int retval = xscale_read_instruction(target, pc, instruction);
 	if (retval == ERROR_OK)
-		command_print(cmd->ctx, "%s", instruction->text);
+		command_print(cmd, "%s", instruction->text);
 	else
-		command_print(cmd->ctx, "0x%8.8" PRIx32 "\t<not found in image>", pc);
+		command_print(cmd, "0x%8.8" PRIx32 "\t<not found in image>", pc);
 }
 
 static int xscale_analyze_trace(struct target *target, struct command_invocation *cmd)
@@ -2787,7 +2787,7 @@ static int xscale_analyze_trace(struct target *target, struct command_invocation
 				continue;
 
 			if (exception) {
-				command_print(cmd->ctx, "--- exception %i ---", exception);
+				command_print(cmd, "--- exception %i ---", exception);
 				continue;
 			}
 
@@ -2813,7 +2813,7 @@ static int xscale_analyze_trace(struct target *target, struct command_invocation
 				}
 
 				if (current_pc == 0)
-					command_print(cmd->ctx, "address unknown");
+					command_print(cmd, "address unknown");
 
 				continue;
 			}
@@ -3136,7 +3136,7 @@ COMMAND_HANDLER(xscale_handle_mmu_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -3150,7 +3150,7 @@ COMMAND_HANDLER(xscale_handle_mmu_command)
 		xscale->armv4_5_mmu.mmu_enabled = enable;
 	}
 
-	command_print(CMD_CTX, "mmu %s",
+	command_print(CMD, "mmu %s",
 		(xscale->armv4_5_mmu.mmu_enabled) ? "enabled" : "disabled");
 
 	return ERROR_OK;
@@ -3166,7 +3166,7 @@ COMMAND_HANDLER(xscale_handle_idcache_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -3195,7 +3195,7 @@ COMMAND_HANDLER(xscale_handle_idcache_command)
 		xscale->armv4_5_mmu.armv4_5_cache.i_cache_enabled :
 		xscale->armv4_5_mmu.armv4_5_cache.d_u_cache_enabled;
 	const char *msg = enabled ? "enabled" : "disabled";
-	command_print(CMD_CTX, "%s %s", CMD_NAME, msg);
+	command_print(CMD, "%s %s", CMD_NAME, msg);
 
 	return ERROR_OK;
 }
@@ -3257,7 +3257,7 @@ COMMAND_HANDLER(xscale_handle_vector_catch_command)
 
 	dcsr_value = buf_get_u32(dcsr_reg->value, 0, 32);
 	for (unsigned i = 0; i < ARRAY_SIZE(vec_ids); i++) {
-		command_print(CMD_CTX, "%15s: %s", vec_ids[i].name,
+		command_print(CMD, "%15s: %s", vec_ids[i].name,
 			(dcsr_value & vec_ids[i].mask) ? "catch" : "ignore");
 	}
 
@@ -3279,16 +3279,16 @@ COMMAND_HANDLER(xscale_handle_vector_table_command)
 	if (CMD_ARGC == 0) {	/* print current settings */
 		int idx;
 
-		command_print(CMD_CTX, "active user-set static vectors:");
+		command_print(CMD, "active user-set static vectors:");
 		for (idx = 1; idx < 8; idx++)
 			if (xscale->static_low_vectors_set & (1 << idx))
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"low  %d: 0x%" PRIx32,
 					idx,
 					xscale->static_low_vectors[idx]);
 		for (idx = 1; idx < 8; idx++)
 			if (xscale->static_high_vectors_set & (1 << idx))
-				command_print(CMD_CTX,
+				command_print(CMD,
 					"high %d: 0x%" PRIx32,
 					idx,
 					xscale->static_high_vectors[idx]);
@@ -3335,7 +3335,7 @@ COMMAND_HANDLER(xscale_handle_trace_buffer_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -3354,7 +3354,7 @@ COMMAND_HANDLER(xscale_handle_trace_buffer_command)
 			if (CMD_ARGC >= 3)
 				COMMAND_PARSE_NUMBER(int, CMD_ARGV[2], buffcount);
 			if (buffcount < 1) {		/* invalid */
-				command_print(CMD_CTX, "fill buffer count must be > 0");
+				command_print(CMD, "fill buffer count must be > 0");
 				xscale->trace.mode = XSCALE_TRACE_DISABLED;
 				return ERROR_COMMAND_SYNTAX_ERROR;
 			}
@@ -3371,11 +3371,11 @@ COMMAND_HANDLER(xscale_handle_trace_buffer_command)
 	if (xscale->trace.mode != XSCALE_TRACE_DISABLED) {
 		char fill_string[12];
 		sprintf(fill_string, "fill %d", xscale->trace.buffer_fill);
-		command_print(CMD_CTX, "trace buffer enabled (%s)",
+		command_print(CMD, "trace buffer enabled (%s)",
 			(xscale->trace.mode == XSCALE_TRACE_FILL)
 			? fill_string : "wrap");
 	} else
-		command_print(CMD_CTX, "trace buffer disabled");
+		command_print(CMD, "trace buffer disabled");
 
 	dcsr_value = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 0, 32);
 	if (xscale->trace.mode == XSCALE_TRACE_FILL)
@@ -3402,7 +3402,7 @@ COMMAND_HANDLER(xscale_handle_trace_image_command)
 	if (xscale->trace.image) {
 		image_close(xscale->trace.image);
 		free(xscale->trace.image);
-		command_print(CMD_CTX, "previously loaded image found and closed");
+		command_print(CMD, "previously loaded image found and closed");
 	}
 
 	xscale->trace.image = malloc(sizeof(struct image));
@@ -3439,7 +3439,7 @@ COMMAND_HANDLER(xscale_handle_dump_trace_command)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 
@@ -3449,7 +3449,7 @@ COMMAND_HANDLER(xscale_handle_dump_trace_command)
 	trace_data = xscale->trace.data;
 
 	if (!trace_data) {
-		command_print(CMD_CTX, "no trace data collected");
+		command_print(CMD, "no trace data collected");
 		return ERROR_OK;
 	}
 
@@ -3502,7 +3502,7 @@ COMMAND_HANDLER(xscale_handle_cp15)
 		return retval;
 
 	if (target->state != TARGET_HALTED) {
-		command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+		command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
 		return ERROR_OK;
 	}
 	uint32_t reg_no = 0;
@@ -3536,7 +3536,7 @@ COMMAND_HANDLER(xscale_handle_cp15)
 				reg_no = XSCALE_CPACCESS;
 				break;
 			default:
-				command_print(CMD_CTX, "invalid register number");
+				command_print(CMD, "invalid register number");
 				return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 		reg = &xscale->reg_cache->reg_list[reg_no];
@@ -3548,7 +3548,7 @@ COMMAND_HANDLER(xscale_handle_cp15)
 		/* read cp15 control register */
 		xscale_get_reg(reg);
 		value = buf_get_u32(reg->value, 0, 32);
-		command_print(CMD_CTX, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size),
+		command_print(CMD, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size),
 			value);
 	} else if (CMD_ARGC == 2) {
 		uint32_t value;
diff --git a/src/transport/transport.c b/src/transport/transport.c
index 7085947..77db9e2 100644
--- a/src/transport/transport.c
+++ b/src/transport/transport.c
@@ -258,10 +258,10 @@ COMMAND_HANDLER(handle_transport_list)
 	if (CMD_ARGC != 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	command_print(CMD_CTX, "The following transports are available:");
+	command_print(CMD, "The following transports are available:");
 
 	for (struct transport *t = transport_list; t; t = t->next)
-		command_print(CMD_CTX, "\t%s", t->name);
+		command_print(CMD, "\t%s", t->name);
 
 	return ERROR_OK;
 }
diff --git a/src/xsvf/xsvf.c b/src/xsvf/xsvf.c
index 63c8915..e574c6f 100644
--- a/src/xsvf/xsvf.c
+++ b/src/xsvf/xsvf.c
@@ -249,14 +249,14 @@ COMMAND_HANDLER(handle_xsvf_command)
 	if (strcmp(CMD_ARGV[0], "plain") != 0) {
 		tap = jtag_tap_by_string(CMD_ARGV[0]);
 		if (!tap) {
-			command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[0]);
+			command_print(CMD, "Tap: %s unknown", CMD_ARGV[0]);
 			return ERROR_FAIL;
 		}
 	}
 
 	xsvf_fd = open(filename, O_RDONLY);
 	if (xsvf_fd < 0) {
-		command_print(CMD_CTX, "file \"%s\" not found", filename);
+		command_print(CMD, "file \"%s\" not found", filename);
 		return ERROR_FAIL;
 	}
 
@@ -1005,7 +1005,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 	}
 
 	if (tdo_mismatch) {
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
 			file_offset);
 
@@ -1014,14 +1014,14 @@ COMMAND_HANDLER(handle_xsvf_command)
 
 	if (unsupported) {
 		off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
-		command_print(CMD_CTX,
+		command_print(CMD,
 			"unsupported xsvf command (0x%02X) at offset %jd, aborting",
 			uc, (intmax_t)offset);
 		return ERROR_FAIL;
 	}
 
 	if (do_abort) {
-		command_print(CMD_CTX, "premature end of xsvf file detected, aborting");
+		command_print(CMD, "premature end of xsvf file detected, aborting");
 		return ERROR_FAIL;
 	}
 
@@ -1036,7 +1036,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 
 	close(xsvf_fd);
 
-	command_print(CMD_CTX, "XSVF file programmed successfully");
+	command_print(CMD, "XSVF file programmed successfully");
 
 	return ERROR_OK;
 }