Convert DEBUG_JTAG_IO to LOG_DEBUG_IO

[openocd.git] / src / jtag / drivers / jlink.c

diff --git a/src/jtag/drivers/jlink.c b/src/jtag/drivers/jlink.c
index 090eeaa6400509f92ac8a407b6cc9e6cb2f18927..dd074937c9206131463c9792904ab882a84fe81e 100644 (file)
--- a/src/jtag/drivers/jlink.c
+++ b/src/jtag/drivers/jlink.c
@@ -38,6 +38,7 @@
 #include <jtag/interface.h>
 #include <jtag/swd.h>
 #include <jtag/commands.h>
+#include <jtag/drivers/jtag_usb_common.h>
 
 #include <libjaylink/libjaylink.h>
 
@@ -50,6 +51,7 @@ static uint8_t caps[JAYLINK_DEV_EXT_CAPS_SIZE];
 
 static uint32_t serial_number;
 static bool use_serial_number;
+static bool use_usb_location;
 static enum jaylink_usb_address usb_address;
 static bool use_usb_address;
 static enum jaylink_target_interface iface = JAYLINK_TIF_JTAG;
@@ -122,13 +124,13 @@ static int queued_retval;
 
 static void jlink_execute_stableclocks(struct jtag_command *cmd)
 {
-       DEBUG_JTAG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles);
+       LOG_DEBUG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles);
        jlink_stableclocks(cmd->cmd.runtest->num_cycles);
 }
 
 static void jlink_execute_runtest(struct jtag_command *cmd)
 {
-       DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles,
+       LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles,
                cmd->cmd.runtest->end_state);
 
        jlink_end_state(cmd->cmd.runtest->end_state);
@@ -137,7 +139,7 @@ static void jlink_execute_runtest(struct jtag_command *cmd)
 
 static void jlink_execute_statemove(struct jtag_command *cmd)
 {
-       DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
+       LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
 
        jlink_end_state(cmd->cmd.statemove->end_state);
        jlink_state_move();
@@ -145,7 +147,7 @@ static void jlink_execute_statemove(struct jtag_command *cmd)
 
 static void jlink_execute_pathmove(struct jtag_command *cmd)
 {
-       DEBUG_JTAG_IO("pathmove: %i states, end in %i",
+       LOG_DEBUG_IO("pathmove: %i states, end in %i",
                cmd->cmd.pathmove->num_states,
                cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
 
@@ -154,7 +156,7 @@ static void jlink_execute_pathmove(struct jtag_command *cmd)
 
 static void jlink_execute_scan(struct jtag_command *cmd)
 {
-       DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
+       LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
                jtag_scan_type(cmd->cmd.scan));
 
        /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
@@ -188,7 +190,7 @@ static void jlink_execute_scan(struct jtag_command *cmd)
 
        for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) {
                scan_size += field->num_bits;
-               DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
+               LOG_DEBUG_IO("%s%s field %d/%d %d bits",
                        field->in_value ? "in" : "",
                        field->out_value ? "out" : "",
                        i,
@@ -240,14 +242,14 @@ static void jlink_execute_scan(struct jtag_command *cmd)
                jlink_state_move();
        }
 
-       DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
+       LOG_DEBUG_IO("%s scan, %i bits, end in %s",
                (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
                tap_state_name(tap_get_end_state()));
 }
 
 static void jlink_execute_reset(struct jtag_command *cmd)
 {
-       DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst,
+       LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst,
                cmd->cmd.reset->srst);
 
        jlink_flush();
@@ -257,7 +259,7 @@ static void jlink_execute_reset(struct jtag_command *cmd)
 
 static void jlink_execute_sleep(struct jtag_command *cmd)
 {
-       DEBUG_JTAG_IO("sleep %" PRIi32 "", cmd->cmd.sleep->us);
+       LOG_DEBUG_IO("sleep %" PRIi32 "", cmd->cmd.sleep->us);
        jlink_flush();
        jtag_sleep(cmd->cmd.sleep->us);
 }
@@ -534,6 +536,31 @@ static int jaylink_log_handler(const struct jaylink_context *ctx,
        return 0;
 }
 
+static bool jlink_usb_location_equal(struct jaylink_device *dev)
+{
+       int retval;
+       uint8_t bus;
+       uint8_t *ports;
+       size_t num_ports;
+       bool equal = false;
+
+       retval = jaylink_device_get_usb_bus_ports(dev, &bus, &ports, &num_ports);
+
+       if (retval == JAYLINK_ERR_NOT_SUPPORTED) {
+               return false;
+       } else if (retval != JAYLINK_OK) {
+               LOG_WARNING("jaylink_device_get_usb_bus_ports() failed: %s.",
+                       jaylink_strerror(retval));
+               return false;
+       }
+
+       equal = jtag_usb_location_equal(bus, ports,     num_ports);
+       free(ports);
+
+       return equal;
+}
+
+
 static int jlink_init(void)
 {
        int ret;
@@ -595,7 +622,9 @@ static int jlink_init(void)
                return ERROR_JTAG_INIT_FAILED;
        }
 
-       if (!use_serial_number && !use_usb_address && num_devices > 1) {
+       use_usb_location = (jtag_usb_get_location() != NULL);
+
+       if (!use_serial_number && !use_usb_address && !use_usb_location && num_devices > 1) {
                LOG_ERROR("Multiple devices found, specify the desired device.");
                jaylink_free_devices(devs, true);
                jaylink_exit(jayctx);
@@ -605,8 +634,10 @@ static int jlink_init(void)
        found_device = false;
 
        for (i = 0; devs[i]; i++) {
+               struct jaylink_device *dev = devs[i];
+
                if (use_serial_number) {
-                       ret = jaylink_device_get_serial_number(devs[i], &tmp);
+                       ret = jaylink_device_get_serial_number(dev, &tmp);
 
                        if (ret == JAYLINK_ERR_NOT_AVAILABLE) {
                                continue;
@@ -621,7 +652,7 @@ static int jlink_init(void)
                }
 
                if (use_usb_address) {
-                       ret = jaylink_device_get_usb_address(devs[i], &address);
+                       ret = jaylink_device_get_usb_address(dev, &address);
 
                        if (ret == JAYLINK_ERR_NOT_SUPPORTED) {
                                continue;
@@ -635,7 +666,10 @@ static int jlink_init(void)
                                continue;
                }
 
-               ret = jaylink_open(devs[i], &devh);
+               if (use_usb_location && !jlink_usb_location_equal(dev))
+                       continue;
+
+               ret = jaylink_open(dev, &devh);
 
                if (ret == JAYLINK_OK) {
                        found_device = true;
@@ -923,17 +957,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 +984,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 +1013,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 +1037,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 +1045,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 +1072,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 +1087,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 +1104,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 +1120,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 +1138,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 +1172,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 +1203,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 +1380,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 +1389,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 +1413,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 +1432,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 +1454,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 +1472,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 +1482,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 +1542,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 +1599,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 +1636,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 +1645,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 +1766,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;
@@ -2004,7 +2038,7 @@ static int jlink_flush(void)
                buf_set_buf(tdo_buffer, p->first, p->buffer,
                            p->buffer_offset, p->length);
 
-               DEBUG_JTAG_IO("Pending scan result, length = %d.", p->length);
+               LOG_DEBUG_IO("Pending scan result, length = %d.", p->length);
        }
 
        jlink_tap_init();