rtt/tcl.c

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 
/*
 * Copyright (C) 2019-2020 by Marc Schink <dev@zapb.de>
 */
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include <helper/log.h>
#include <target/rtt.h>
 
#include "rtt.h"
 
#define CHANNEL_NAME_SIZE   128
 
COMMAND_HANDLER(handle_rtt_setup_command)
{
    struct rtt_source source;
 
    if (CMD_ARGC != 3)
        return ERROR_COMMAND_SYNTAX_ERROR;
 
    source.find_cb = &target_rtt_find_control_block;
    source.read_cb = &target_rtt_read_control_block;
    source.start = &target_rtt_start;
    source.stop = &target_rtt_stop;
    source.read = &target_rtt_read_callback;
    source.write = &target_rtt_write_callback;
    source.read_channel_info = &target_rtt_read_channel_info;
 
    target_addr_t address;
    uint32_t size;
 
    COMMAND_PARSE_NUMBER(target_addr, CMD_ARGV[0], address);
    COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], size);
 
    rtt_register_source(source, get_current_target(CMD_CTX));
 
    if (rtt_setup(address, size, CMD_ARGV[2]) != ERROR_OK)
        return ERROR_FAIL;
 
    return ERROR_OK;
}
 
COMMAND_HANDLER(handle_rtt_start_command)
{
    if (CMD_ARGC > 0)
        return ERROR_COMMAND_SYNTAX_ERROR;
 
    if (!rtt_configured()) {
        command_print(CMD, "RTT is not configured");
        return ERROR_FAIL;
    }
 
    return rtt_start();
}
 
COMMAND_HANDLER(handle_rtt_stop_command)
{
    if (CMD_ARGC > 0)
        return ERROR_COMMAND_SYNTAX_ERROR;
 
    return rtt_stop();
}
 
COMMAND_HANDLER(handle_rtt_polling_interval_command)
{
    if (CMD_ARGC == 0) {
        int ret;
        unsigned int interval;
 
        ret = rtt_get_polling_interval(&interval);
 
        if (ret != ERROR_OK) {
            command_print(CMD, "Failed to get polling interval");
            return ret;
        }
 
        command_print(CMD, "%u ms", interval);
    } else if (CMD_ARGC == 1) {
        int ret;
        unsigned int interval;
 
        COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], interval);
        ret = rtt_set_polling_interval(interval);
 
        if (ret != ERROR_OK) {
            command_print(CMD, "Failed to set polling interval");
            return ret;
        }
    } else {
        return ERROR_COMMAND_SYNTAX_ERROR;
    }
 
    return ERROR_OK;
}
 
COMMAND_HANDLER(handle_rtt_channels_command)
{
    int ret;
    char channel_name[CHANNEL_NAME_SIZE];
    const struct rtt_control *ctrl;
    struct rtt_channel_info info;
 
    if (!rtt_found_cb()) {
        command_print(CMD, "rtt: Control block not available");
        return ERROR_FAIL;
    }
 
    ctrl = rtt_get_control();
 
    command_print(CMD, "Channels: up=%u, down=%u", ctrl->num_up_channels,
        ctrl->num_down_channels);
 
    command_print(CMD, "Up-channels:");
 
    info.name = channel_name;
    info.name_length = sizeof(channel_name);
 
    for (unsigned int i = 0; i < ctrl->num_up_channels; i++) {
        ret = rtt_read_channel_info(i, RTT_CHANNEL_TYPE_UP, &info);
 
        if (ret != ERROR_OK)
            return ret;
 
        if (!info.size)
            continue;
 
        command_print(CMD, "%u: %s %u %u", i, info.name, info.size,
            info.flags);
    }
 
    command_print(CMD, "Down-channels:");
 
    for (unsigned int i = 0; i < ctrl->num_down_channels; i++) {
        ret = rtt_read_channel_info(i, RTT_CHANNEL_TYPE_DOWN, &info);
 
        if (ret != ERROR_OK)
            return ret;
 
        if (!info.size)
            continue;
 
        command_print(CMD, "%u: %s %u %u", i, info.name, info.size,
            info.flags);
    }
 
    return ERROR_OK;
}
 
COMMAND_HANDLER(handle_channel_list)
{
    char channel_name[CHANNEL_NAME_SIZE];
    const struct rtt_control *ctrl;
    struct rtt_channel_info info;
 
    if (CMD_ARGC != 0)
        return ERROR_COMMAND_SYNTAX_ERROR;
 
    if (!rtt_found_cb()) {
        command_print(CMD, "rtt: Control block not available");
        return ERROR_FAIL;
    }
 
    ctrl = rtt_get_control();
 
    info.name = channel_name;
    info.name_length = sizeof(channel_name);
 
    command_print(CMD, "{");
 
    for (unsigned int i = 0; i < ctrl->num_up_channels; i++) {
        int ret = rtt_read_channel_info(i, RTT_CHANNEL_TYPE_UP, &info);
        if (ret != ERROR_OK)
            return ret;
 
        if (!info.size)
            continue;
 
        command_print(CMD,
            "    {\n"
            "        name  %s\n"
            "        size  0x%" PRIx32 "\n"
            "        flags 0x%" PRIx32 "\n"
            "    }",
            info.name, info.size, info.flags);
    }
 
    command_print(CMD, "}\n{");
 
    for (unsigned int i = 0; i < ctrl->num_down_channels; i++) {
        int ret = rtt_read_channel_info(i, RTT_CHANNEL_TYPE_DOWN, &info);
        if (ret != ERROR_OK)
            return ret;
 
        if (!info.size)
            continue;
 
        command_print(CMD,
            "    {\n"
            "        name  %s\n"
            "        size  0x%" PRIx32 "\n"
            "        flags 0x%" PRIx32 "\n"
            "    }",
            info.name, info.size, info.flags);
    }
 
    command_print(CMD, "}");
 
    return ERROR_OK;
}
 
static const struct command_registration rtt_subcommand_handlers[] = {
    {
        .name = "setup",
        .handler = handle_rtt_setup_command,
        .mode = COMMAND_ANY,
        .help = "setup RTT",
        .usage = "<address> <size> <ID>"
    },
    {
        .name = "start",
        .handler = handle_rtt_start_command,
        .mode = COMMAND_EXEC,
        .help = "start RTT",
        .usage = ""
    },
    {
        .name = "stop",
        .handler = handle_rtt_stop_command,
        .mode = COMMAND_EXEC,
        .help = "stop RTT",
        .usage = ""
    },
    {
        .name = "polling_interval",
        .handler = handle_rtt_polling_interval_command,
        .mode = COMMAND_EXEC,
        .help = "show or set polling interval in ms",
        .usage = "[interval]"
    },
    {
        .name = "channels",
        .handler = handle_rtt_channels_command,
        .mode = COMMAND_EXEC,
        .help = "list available channels",
        .usage = ""
    },
    {
        .name = "channellist",
        .handler = handle_channel_list,
        .mode = COMMAND_EXEC,
        .help = "list available channels",
        .usage = ""
    },
    COMMAND_REGISTRATION_DONE
};
 
const struct command_registration rtt_target_command_handlers[] = {
    {
        .name = "rtt",
        .mode = COMMAND_EXEC,
        .help = "RTT target commands",
        .usage = "",
        .chain = rtt_subcommand_handlers
    },
    COMMAND_REGISTRATION_DONE
};