7b641d3d4e
Real Time Transfer (RTT) is an interface specified by SEGGER based on basic memory reads and writes to transfer data bidirectionally between target and host. Every target that supports so called "background memory access", which means that the target memory can be accessed by the debugger while the target is running, can be used. RTT is especially of interest for targets which do not support Serial Wire Output (SWO) (e.g. ARM Cortex-M0) or where using semihosting is not possible (e.g. real-time applications) [1]. The data transfer is organized in channels where each channel consists of an up- and/or down-channel. See [2] for more details. Channels are exposed via TCP connections. One or more RTT server can be assigned to each channel to make them accessible to an unlimited number of TCP connections. The current implementation does not respect buffer flags which are used to determine what happens when writing to a full buffer. Note that the implementation is designed in a way that the RTT operations can be directly performed by an adapter (e.g. J-Link). [1] https://devzone.nordicsemi.com/tutorials/6/ [2] https://www.segger.com/jlink-rtt.html Change-Id: I8bc8a1b381fb74e08b8752d5cf53804cc573c1e0 Signed-off-by: Marc Schink <dev@zapb.de> Reviewed-on: http://openocd.zylin.com/4055 Tested-by: jenkins Reviewed-by: Tomas Vanek <vanekt@fbl.cz> Reviewed-by: Antonio Borneo <borneo.antonio@gmail.com>
312 lines
7.0 KiB
C
312 lines
7.0 KiB
C
/*
|
|
* Copyright (C) 2019-2020 by Marc Schink <dev@zapb.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#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;
|
|
}
|
|
|
|
static int jim_channel_list(Jim_Interp *interp, int argc,
|
|
Jim_Obj * const *argv)
|
|
{
|
|
Jim_Obj *list;
|
|
Jim_Obj *channel_list;
|
|
char channel_name[CHANNEL_NAME_SIZE];
|
|
const struct rtt_control *ctrl;
|
|
struct rtt_channel_info info;
|
|
|
|
if (!rtt_found_cb()) {
|
|
Jim_SetResultFormatted(interp, "rtt: Control block not available");
|
|
return ERROR_FAIL;
|
|
}
|
|
|
|
ctrl = rtt_get_control();
|
|
|
|
info.name = channel_name;
|
|
info.name_length = sizeof(channel_name);
|
|
|
|
list = Jim_NewListObj(interp, NULL, 0);
|
|
channel_list = Jim_NewListObj(interp, NULL, 0);
|
|
|
|
for (unsigned int i = 0; i < ctrl->num_up_channels; i++) {
|
|
int ret;
|
|
Jim_Obj *tmp;
|
|
|
|
ret = rtt_read_channel_info(i, RTT_CHANNEL_TYPE_UP, &info);
|
|
|
|
if (ret != ERROR_OK)
|
|
return ret;
|
|
|
|
if (!info.size)
|
|
continue;
|
|
|
|
tmp = Jim_NewListObj(interp, NULL, 0);
|
|
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewStringObj(interp,
|
|
"name", -1));
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewStringObj(interp,
|
|
info.name, -1));
|
|
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewStringObj(interp,
|
|
"size", -1));
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewIntObj(interp,
|
|
info.size));
|
|
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewStringObj(interp,
|
|
"flags", -1));
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewIntObj(interp,
|
|
info.flags));
|
|
|
|
Jim_ListAppendElement(interp, channel_list, tmp);
|
|
}
|
|
|
|
Jim_ListAppendElement(interp, list, channel_list);
|
|
|
|
channel_list = Jim_NewListObj(interp, NULL, 0);
|
|
|
|
for (unsigned int i = 0; i < ctrl->num_down_channels; i++) {
|
|
int ret;
|
|
Jim_Obj *tmp;
|
|
|
|
ret = rtt_read_channel_info(i, RTT_CHANNEL_TYPE_DOWN, &info);
|
|
|
|
if (ret != ERROR_OK)
|
|
return ret;
|
|
|
|
if (!info.size)
|
|
continue;
|
|
|
|
tmp = Jim_NewListObj(interp, NULL, 0);
|
|
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewStringObj(interp,
|
|
"name", -1));
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewStringObj(interp,
|
|
info.name, -1));
|
|
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewStringObj(interp,
|
|
"size", -1));
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewIntObj(interp,
|
|
info.size));
|
|
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewStringObj(interp,
|
|
"flags", -1));
|
|
Jim_ListAppendElement(interp, tmp, Jim_NewIntObj(interp,
|
|
info.flags));
|
|
|
|
Jim_ListAppendElement(interp, channel_list, tmp);
|
|
}
|
|
|
|
Jim_ListAppendElement(interp, list, channel_list);
|
|
Jim_SetResult(interp, list);
|
|
|
|
return JIM_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",
|
|
.jim_handler = jim_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
|
|
};
|