target/armv7m_trace: Fix typo in enum

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

diff --git a/src/jtag/drivers/jlink.c b/src/jtag/drivers/jlink.c
index 95c6d8db3068d3ab21f2dd3bef98c397c4585f9a..c078102a0a97c1b06071393727f05824c39972af 100644 (file)
--- a/src/jtag/drivers/jlink.c
+++ b/src/jtag/drivers/jlink.c
@@ -322,7 +322,7 @@ static int jlink_speed(int speed)
 
                if (ret != JAYLINK_OK) {
                        LOG_ERROR("jaylink_get_speeds() failed: %s.",
-                               jaylink_strerror_name(ret));
+                               jaylink_strerror(ret));
                        return ERROR_JTAG_DEVICE_ERROR;
                }
 
@@ -349,7 +349,7 @@ static int jlink_speed(int speed)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_set_speed() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_JTAG_DEVICE_ERROR;
        }
 
@@ -378,7 +378,7 @@ static bool read_device_config(struct device_config *cfg)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_read_raw_config() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return false;
        }
 
@@ -409,7 +409,7 @@ static int select_interface(void)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_get_available_interfaces() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_JTAG_INIT_FAILED;
        }
 
@@ -422,7 +422,7 @@ static int select_interface(void)
 
        if (ret < 0) {
                LOG_ERROR("jaylink_select_interface() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_JTAG_INIT_FAILED;
        }
 
@@ -442,8 +442,7 @@ static int jlink_register(void)
        ret = jaylink_register(devh, &conn, connlist, &count);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_register() failed: %s.",
-                       jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_register() failed: %s.", jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -482,7 +481,7 @@ static bool adjust_swd_buffer_size(void)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_get_free_memory() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return false;
        }
 
@@ -523,6 +522,9 @@ static int jaylink_log_handler(const struct jaylink_context *ctx,
        case JAYLINK_LOG_LEVEL_DEBUG:
                tmp = LOG_LVL_DEBUG;
                break;
+       case JAYLINK_LOG_LEVEL_DEBUG_IO:
+               tmp = LOG_LVL_DEBUG_IO;
+               break;
        default:
                tmp = LOG_LVL_WARNING;
        }
@@ -544,12 +546,21 @@ static int jlink_init(void)
        struct jaylink_hardware_status hwstatus;
        enum jaylink_usb_address address;
        size_t length;
+       size_t num_devices;
+       uint32_t host_interfaces;
+
+       LOG_DEBUG("Using libjaylink %s (compiled with %s).",
+               jaylink_version_package_get_string(), JAYLINK_VERSION_PACKAGE_STRING);
+
+       if (!jaylink_library_has_cap(JAYLINK_CAP_HIF_USB) && use_usb_address) {
+               LOG_ERROR("J-Link driver does not support USB devices.");
+               return ERROR_JTAG_INIT_FAILED;
+       }
 
        ret = jaylink_init(&jayctx);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_init() failed: %s.",
-                       jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_init() failed: %s.", jaylink_strerror(ret));
                return ERROR_JTAG_INIT_FAILED;
        }
 
@@ -557,33 +568,41 @@ static int jlink_init(void)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_log_set_callback() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                jaylink_exit(jayctx);
                return ERROR_JTAG_INIT_FAILED;
        }
 
-       ret = jaylink_discovery_scan(jayctx, 0);
+       host_interfaces = JAYLINK_HIF_USB;
+
+       if (use_serial_number)
+               host_interfaces |= JAYLINK_HIF_TCP;
+
+       ret = jaylink_discovery_scan(jayctx, host_interfaces);
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_discovery_scan() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                jaylink_exit(jayctx);
                return ERROR_JTAG_INIT_FAILED;
        }
 
-       ret = jaylink_get_devices(jayctx, &devs, NULL);
+       ret = jaylink_get_devices(jayctx, &devs, &num_devices);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_get_devices() failed: %s.",
-                       jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_get_devices() failed: %s.", jaylink_strerror(ret));
                jaylink_exit(jayctx);
                return ERROR_JTAG_INIT_FAILED;
        }
 
-       found_device = false;
+       if (!use_serial_number && !use_usb_address && num_devices > 1) {
+               LOG_ERROR("Multiple devices found, specify the desired device.");
+               jaylink_free_devices(devs, true);
+               jaylink_exit(jayctx);
+               return ERROR_JTAG_INIT_FAILED;
+       }
 
-       if (!use_serial_number && !use_usb_address)
-               LOG_INFO("No device selected, using first device.");
+       found_device = false;
 
        for (i = 0; devs[i]; i++) {
                if (use_serial_number) {
@@ -593,7 +612,7 @@ static int jlink_init(void)
                                continue;
                        } else if (ret != JAYLINK_OK) {
                                LOG_WARNING("jaylink_device_get_serial_number() failed: %s.",
-                                       jaylink_strerror_name(ret));
+                                       jaylink_strerror(ret));
                                continue;
                        }
 
@@ -604,9 +623,11 @@ static int jlink_init(void)
                if (use_usb_address) {
                        ret = jaylink_device_get_usb_address(devs[i], &address);
 
-                       if (ret != JAYLINK_OK) {
+                       if (ret == JAYLINK_ERR_NOT_SUPPORTED) {
+                               continue;
+                       } else if (ret != JAYLINK_OK) {
                                LOG_WARNING("jaylink_device_get_usb_address() failed: %s.",
-                                       jaylink_strerror_name(ret));
+                                       jaylink_strerror(ret));
                                continue;
                        }
 
@@ -621,7 +642,7 @@ static int jlink_init(void)
                        break;
                }
 
-               LOG_ERROR("Failed to open device: %s.", jaylink_strerror_name(ret));
+               LOG_ERROR("Failed to open device: %s.", jaylink_strerror(ret));
        }
 
        jaylink_free_devices(devs, true);
@@ -641,7 +662,7 @@ static int jlink_init(void)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_get_firmware_version() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                jaylink_close(devh);
                jaylink_exit(jayctx);
                return ERROR_JTAG_INIT_FAILED;
@@ -656,7 +677,7 @@ static int jlink_init(void)
        ret = jaylink_get_caps(devh, caps);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_get_caps() failed: %s.", jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_get_caps() failed: %s.", jaylink_strerror(ret));
                jaylink_close(devh);
                jaylink_exit(jayctx);
                return ERROR_JTAG_INIT_FAILED;
@@ -667,21 +688,21 @@ static int jlink_init(void)
 
                if (ret != JAYLINK_OK) {
                        LOG_ERROR("jaylink_get_extended_caps() failed:  %s.",
-                               jaylink_strerror_name(ret));
+                               jaylink_strerror(ret));
                        jaylink_close(devh);
                        jaylink_exit(jayctx);
                        return ERROR_JTAG_INIT_FAILED;
                }
        }
 
-       jtag_command_version = JAYLINK_JTAG_V2;
+       jtag_command_version = JAYLINK_JTAG_VERSION_2;
 
        if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_HW_VERSION)) {
                ret = jaylink_get_hardware_version(devh, &hwver);
 
                if (ret != JAYLINK_OK) {
                        LOG_ERROR("Failed to retrieve hardware version: %s.",
-                               jaylink_strerror_name(ret));
+                               jaylink_strerror(ret));
                        jaylink_close(devh);
                        jaylink_exit(jayctx);
                        return ERROR_JTAG_INIT_FAILED;
@@ -690,7 +711,7 @@ static int jlink_init(void)
                LOG_INFO("Hardware version: %u.%02u", hwver.major, hwver.minor);
 
                if (hwver.major >= 5)
-                       jtag_command_version = JAYLINK_JTAG_V3;
+                       jtag_command_version = JAYLINK_JTAG_VERSION_3;
        }
 
        if (iface == JAYLINK_TIF_SWD) {
@@ -722,7 +743,7 @@ static int jlink_init(void)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_get_hardware_status() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                jaylink_close(devh);
                jaylink_exit(jayctx);
                return ERROR_JTAG_INIT_FAILED;
@@ -783,8 +804,7 @@ static int jlink_quit(void)
                ret = jaylink_swo_stop(devh);
 
                if (ret != JAYLINK_OK)
-                       LOG_ERROR("jaylink_swo_stop() failed: %s.",
-                               jaylink_strerror_name(ret));
+                       LOG_ERROR("jaylink_swo_stop() failed: %s.", jaylink_strerror(ret));
        }
 
        if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_REGISTER)) {
@@ -792,7 +812,7 @@ static int jlink_quit(void)
 
                if (ret != JAYLINK_OK)
                        LOG_ERROR("jaylink_unregister() failed: %s.",
-                               jaylink_strerror_name(ret));
+                               jaylink_strerror(ret));
        }
 
        jaylink_close(devh);
@@ -941,7 +961,7 @@ COMMAND_HANDLER(jlink_serial_command)
                return ERROR_FAIL;
        } else if (ret != JAYLINK_OK) {
                command_print(CMD_CTX, "jaylink_parse_serial_number() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -960,7 +980,7 @@ COMMAND_HANDLER(jlink_handle_hwstatus_command)
 
        if (ret != JAYLINK_OK) {
                command_print(CMD_CTX, "jaylink_get_hardware_status() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -992,7 +1012,7 @@ COMMAND_HANDLER(jlink_handle_free_memory_command)
 
        if (ret != JAYLINK_OK) {
                command_print(CMD_CTX, "jaylink_get_free_memory() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -1008,10 +1028,10 @@ COMMAND_HANDLER(jlink_handle_jlink_jtag_command)
 
        if (!CMD_ARGC) {
                switch (jtag_command_version) {
-                       case JAYLINK_JTAG_V2:
+                       case JAYLINK_JTAG_VERSION_2:
                                version = 2;
                                break;
-                       case JAYLINK_JTAG_V3:
+                       case JAYLINK_JTAG_VERSION_3:
                                version = 3;
                                break;
                        default:
@@ -1027,10 +1047,10 @@ COMMAND_HANDLER(jlink_handle_jlink_jtag_command)
 
                switch (tmp) {
                        case 2:
-                               jtag_command_version = JAYLINK_JTAG_V2;
+                               jtag_command_version = JAYLINK_JTAG_VERSION_2;
                                break;
                        case 3:
-                               jtag_command_version = JAYLINK_JTAG_V3;
+                               jtag_command_version = JAYLINK_JTAG_VERSION_3;
                                break;
                        default:
                                command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
@@ -1074,7 +1094,7 @@ COMMAND_HANDLER(jlink_handle_target_power_command)
 
        if (ret != JAYLINK_OK) {
                command_print(CMD_CTX, "jaylink_set_target_power() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -1180,7 +1200,7 @@ static int poll_trace(uint8_t *buf, size_t *size)
        ret = jaylink_swo_read(devh, buf, &length);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_swo_read() failed: %s.", jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_swo_read() failed: %s.", jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -1201,7 +1221,7 @@ static uint32_t calculate_trace_buffer_size(void)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_get_free_memory() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -1243,7 +1263,7 @@ static bool check_trace_freq(struct jaylink_swo_speed speed,
        return false;
 }
 
-static int config_trace(bool enabled, enum tpio_pin_protocol pin_protocol,
+static int config_trace(bool enabled, enum tpiu_pin_protocol pin_protocol,
                uint32_t port_size, unsigned int *trace_freq)
 {
        int ret;
@@ -1265,7 +1285,7 @@ static int config_trace(bool enabled, enum tpio_pin_protocol pin_protocol,
        ret = jaylink_swo_stop(devh);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_swo_stop() failed: %s.", jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_swo_stop() failed: %s.", jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -1291,7 +1311,7 @@ static int config_trace(bool enabled, enum tpio_pin_protocol pin_protocol,
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_swo_get_speeds() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -1307,8 +1327,7 @@ static int config_trace(bool enabled, enum tpio_pin_protocol pin_protocol,
                buffer_size);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_start_swo() failed: %s.",
-                       jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_start_swo() failed: %s.", jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -1567,7 +1586,7 @@ COMMAND_HANDLER(jlink_handle_config_write_command)
 
        if (ret != JAYLINK_OK) {
                LOG_ERROR("jaylink_write_raw_config() failed: %s.",
-                       jaylink_strerror_name(ret));
+                       jaylink_strerror(ret));
                return ERROR_FAIL;
        }
 
@@ -1602,6 +1621,123 @@ COMMAND_HANDLER(jlink_handle_config_command)
        return ERROR_OK;
 }
 
+COMMAND_HANDLER(jlink_handle_emucom_write_command)
+{
+       int ret;
+       size_t tmp;
+       uint32_t channel;
+       uint32_t length;
+       uint8_t *buf;
+       size_t dummy;
+
+       if (CMD_ARGC != 2)
+               return ERROR_COMMAND_SYNTAX_ERROR;
+
+       if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_EMUCOM)) {
+               LOG_ERROR("Device does not support EMUCOM.");
+               return ERROR_FAIL;
+       }
+
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], channel);
+
+       tmp = strlen(CMD_ARGV[1]);
+
+       if (tmp % 2 != 0) {
+               LOG_ERROR("Data must be encoded as hexadecimal pairs.");
+               return ERROR_COMMAND_ARGUMENT_INVALID;
+       }
+
+       buf = malloc(tmp / 2);
+
+       if (!buf) {
+               LOG_ERROR("Failed to allocate buffer.");
+               return ERROR_FAIL;
+       }
+
+       dummy = unhexify(buf, CMD_ARGV[1], tmp / 2);
+
+       if (dummy != (tmp / 2)) {
+               LOG_ERROR("Data must be encoded as hexadecimal pairs.");
+               free(buf);
+               return ERROR_COMMAND_ARGUMENT_INVALID;
+       }
+
+       length = tmp / 2;
+       ret = jaylink_emucom_write(devh, channel, buf, &length);
+
+       free(buf);
+
+       if (ret == JAYLINK_ERR_DEV_NOT_SUPPORTED) {
+               LOG_ERROR("Channel not supported by the device.");
+               return ERROR_FAIL;
+       } else if (ret != JAYLINK_OK) {
+               LOG_ERROR("Failed to write to channel: %s.", jaylink_strerror(ret));
+               return ERROR_FAIL;
+       }
+
+       if (length != (tmp / 2))
+               LOG_WARNING("Only %" PRIu32 " bytes written to the channel.", length);
+
+       return ERROR_OK;
+}
+
+COMMAND_HANDLER(jlink_handle_emucom_read_command)
+{
+       int ret;
+       uint32_t channel;
+       uint32_t length;
+       uint8_t *buf;
+       size_t tmp;
+
+       if (CMD_ARGC != 2)
+               return ERROR_COMMAND_SYNTAX_ERROR;
+
+       if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_EMUCOM)) {
+               LOG_ERROR("Device does not support EMUCOM.");
+               return ERROR_FAIL;
+       }
+
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], channel);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
+
+       buf = malloc(length * 3 + 1);
+
+       if (!buf) {
+               LOG_ERROR("Failed to allocate buffer.");
+               return ERROR_FAIL;
+       }
+
+       ret = jaylink_emucom_read(devh, channel, buf, &length);
+
+       if (ret == JAYLINK_ERR_DEV_NOT_SUPPORTED) {
+               LOG_ERROR("Channel is not supported by the device.");
+               free(buf);
+               return ERROR_FAIL;
+       } else if (ret == JAYLINK_ERR_DEV_NOT_AVAILABLE) {
+               LOG_ERROR("Channel is not available for the requested amount of data. "
+                       "%" PRIu32 " bytes are avilable.", length);
+               free(buf);
+               return ERROR_FAIL;
+       } else if (ret != JAYLINK_OK) {
+               LOG_ERROR("Failed to read from channel: %s.", jaylink_strerror(ret));
+               free(buf);
+               return ERROR_FAIL;
+       }
+
+       tmp = hexify((char *)buf + length, buf, length, 2 * length + 1);
+
+       if (tmp != 2 * length) {
+               LOG_ERROR("Failed to convert data into hexadecimal string.");
+               free(buf);
+               return ERROR_FAIL;
+       }
+
+       command_print(CMD_CTX, "%s", buf + length);
+       free(buf);
+
+       return ERROR_OK;
+}
+
 static const struct command_registration jlink_config_subcommand_handlers[] = {
        {
                .name = "usb",
@@ -1647,6 +1783,24 @@ static const struct command_registration jlink_config_subcommand_handlers[] = {
        COMMAND_REGISTRATION_DONE
 };
 
+static const struct command_registration jlink_emucom_subcommand_handlers[] = {
+       {
+               .name = "write",
+               .handler = &jlink_handle_emucom_write_command,
+               .mode = COMMAND_EXEC,
+               .help = "write to a channel",
+               .usage = "<channel> <data>",
+       },
+       {
+               .name = "read",
+               .handler = &jlink_handle_emucom_read_command,
+               .mode = COMMAND_EXEC,
+               .help = "read from a channel",
+               .usage = "<channel> <length>"
+       },
+       COMMAND_REGISTRATION_DONE
+};
+
 static const struct command_registration jlink_subcommand_handlers[] = {
        {
                .name = "jtag",
@@ -1696,6 +1850,12 @@ static const struct command_registration jlink_subcommand_handlers[] = {
                        "this will show the device configuration",
                .chain = jlink_config_subcommand_handlers,
        },
+       {
+               .name = "emucom",
+               .mode = COMMAND_EXEC,
+               .help = "access EMUCOM channel",
+               .chain = jlink_emucom_subcommand_handlers
+       },
        COMMAND_REGISTRATION_DONE
 };
 
@@ -1826,7 +1986,7 @@ static int jlink_flush(void)
                tap_length, jtag_command_version);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_jtag_io() failed: %s.", jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_jtag_io() failed: %s.", jaylink_strerror(ret));
                jlink_tap_init();
                return ERROR_JTAG_QUEUE_FAILED;
        }
@@ -1932,7 +2092,7 @@ static int jlink_swd_run_queue(void)
        ret = jaylink_swd_io(devh, tms_buffer, tdi_buffer, tdo_buffer, tap_length);
 
        if (ret != JAYLINK_OK) {
-               LOG_ERROR("jaylink_swd_io() failed: %s.", jaylink_strerror_name(ret));
+               LOG_ERROR("jaylink_swd_io() failed: %s.", jaylink_strerror(ret));
                goto skip;
        }