auracaster/openocd
3
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

armv7m_trace: get rid of the old tpiu code

Browse Source 
Remove all the old tpiu code and replace it with a wrapper that
uses the new commands, prints-out the new commands and informs
about the deprecation.

All the code that handles the deprecated tpiu commands is enclosed
between the comments
	/* START_DEPRECATED_TPIU */
and
	/* END_DEPRECATED_TPIU */
so will be easy to remove it in the future.

Change-Id: I70b0486770128203b923346382d9a90b8ec08439
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-on: http://openocd.zylin.com/6030
Tested-by: jenkins
Reviewed-by: Adrian M Negreanu <adrian.negreanu@nxp.com>
This commit is contained in:
Antonio Borneo
2020-11-13 23:36:24 +01:00
parent c945d6e616
commit dc7b32ea4a
9 changed files with 223 additions and 432 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
src/target/arm_tpiu_swo.c
View File

@@ -38,6 +38,12 @@
#include <transport/transport.h>
#include "arm_tpiu_swo.h"
/* START_DEPRECATED_TPIU */
#include <target/cortex_m.h>
#include <target/target_type.h>
#define MSG "DEPRECATED \'tpiu config\' command: "
/* END_DEPRECATED_TPIU */
#define TCP_SERVICE_NAME "tpiu_swo_trace"
/* default for Cortex-M3 and Cortex-M4 specific TPIU */
@@ -53,9 +59,9 @@
#define TPIU_DEVID_OFFSET 0xfc8
#define TPIU_ACPR_MAX_PRESCALER 0x1fff
#define TPIU_SPPR_PROTOCOL_SYNC 0x0 /**< synchronous trace output */
#define TPIU_SPPR_PROTOCOL_MANCHESTER 0x1 /**< asynchronous output with NRZ coding */
#define TPIU_SPPR_PROTOCOL_UART 0x2 /**< asynchronous output with Manchester coding */
#define TPIU_SPPR_PROTOCOL_SYNC (TPIU_PIN_PROTOCOL_SYNC)
#define TPIU_SPPR_PROTOCOL_MANCHESTER (TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER)
#define TPIU_SPPR_PROTOCOL_UART (TPIU_PIN_PROTOCOL_ASYNC_UART)
#define TPIU_DEVID_NOSUPPORT_SYNC BIT(9)
#define TPIU_DEVID_SUPPORT_MANCHESTER BIT(10)
#define TPIU_DEVID_SUPPORT_UART BIT(11)
@@ -106,6 +112,9 @@ struct arm_tpiu_swo_object {
char *out_filename;
/** track TCP connections */
struct list_head connections;
/* START_DEPRECATED_TPIU */
bool recheck_ap_cur_target;
/* END_DEPRECATED_TPIU */
};
struct arm_tpiu_swo_connection {
@@ -612,6 +621,31 @@ static int jim_arm_tpiu_swo_enable(Jim_Interp *interp, int argc, Jim_Obj *const
struct target *target = get_current_target(cmd_ctx);
/* START_DEPRECATED_TPIU */
if (obj->recheck_ap_cur_target) {
if (strcmp(target->type->name, "cortex_m") &&
strcmp(target->type->name, "hla_target")) {
LOG_ERROR(MSG "Current target is not a Cortex-M nor a HLA");
return JIM_ERR;
}
if (!target_was_examined(target)) {
LOG_ERROR(MSG "Current target not examined yet");
return JIM_ERR;
}
struct cortex_m_common *cm = target_to_cm(target);
obj->recheck_ap_cur_target = false;
obj->spot.ap_num = cm->armv7m.debug_ap->ap_num;
tpiu_ap = dap_ap(obj->spot.dap, obj->spot.ap_num);
if (obj->spot.ap_num == 0)
LOG_INFO(MSG "Confirmed TPIU %s is on AP 0", obj->name);
else
LOG_INFO(MSG "Target %s is on AP %d. Revised command is "
"\'tpiu create %s -dap %s -ap-num %d\'",
target_name(target), obj->spot.ap_num,
obj->name, adiv5_dap_name(obj->spot.dap), obj->spot.ap_num);
}
/* END_DEPRECATED_TPIU */
/* trigger the event before any attempt to R/W in the TPIU/SWO */
arm_tpiu_swo_handle_event(obj, TPIU_SWO_EVENT_PRE_ENABLE);
@@ -951,6 +985,163 @@ static int jim_arm_tpiu_swo_init(Jim_Interp *interp, int argc, Jim_Obj *const *a
return retval;
}
/* START_DEPRECATED_TPIU */
/* DEPRECATED: emulation of old command 'tpiu config' */
COMMAND_HANDLER(handle_tpiu_deprecated_config_command)
{
struct target *target = get_current_target(CMD_CTX);
struct arm_tpiu_swo_object *obj = NULL;
int retval;
if (strcmp(target->type->name, "cortex_m") &&
strcmp(target->type->name, "hla_target")) {
LOG_ERROR(MSG "Current target is not a Cortex-M nor a HLA");
return ERROR_FAIL;
}
if (!list_empty(&all_tpiu_swo)) {
obj = list_first_entry(&all_tpiu_swo, typeof(*obj), lh);
LOG_INFO(MSG "Using %s", obj->name);
} else {
struct cortex_m_common *cm = target_to_cm(target);
struct adiv5_private_config *pc = target->private_config;
struct adiv5_dap *dap = pc->dap;
int ap_num = pc->ap_num;
bool set_recheck_ap_cur_target = false;
LOG_INFO(MSG "Adding a TPIU \'%s.tpiu\' in the configuration", target_name(target));
if (ap_num == DP_APSEL_INVALID && transport_is_hla())
ap_num = 0; /* HLA should only support AP 0 */
if (ap_num == DP_APSEL_INVALID && target_was_examined(target))
ap_num = cm->armv7m.debug_ap->ap_num;
if (ap_num == DP_APSEL_INVALID) {
LOG_INFO(MSG "Target %s uses AP autodetection. Adding TPIU on AP 0; can be revised later",
target_name(target));
ap_num = 0;
set_recheck_ap_cur_target = true;
}
LOG_INFO(MSG "Running: \'tpiu create %s.tpiu -dap %s -ap-num %d\'",
target_name(target), adiv5_dap_name(dap), ap_num);
retval = command_run_linef(CMD_CTX, "tpiu create %s.tpiu -dap %s -ap-num %d",
target_name(target), adiv5_dap_name(dap), ap_num);
if (retval != ERROR_OK)
return retval;
obj = list_first_entry(&all_tpiu_swo, typeof(*obj), lh);
if (set_recheck_ap_cur_target)
obj->recheck_ap_cur_target = true;
}
unsigned int cmd_idx = 0;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
if (!strcmp(CMD_ARGV[cmd_idx], "disable")) {
if (CMD_ARGC != cmd_idx + 1)
return ERROR_COMMAND_SYNTAX_ERROR;
LOG_INFO(MSG "Running: \'%s disable\'", obj->name);
return command_run_linef(CMD_CTX, "%s disable", obj->name);
}
const char *output = NULL;
const char *protocol;
const char *formatter = NULL;
const char *port_width = NULL;
const char *trace_clk;
const char *pin_clk = NULL;
if (!strcmp(CMD_ARGV[cmd_idx], "internal")) {
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
output = CMD_ARGV[cmd_idx];
} else if (strcmp(CMD_ARGV[cmd_idx], "external"))
return ERROR_COMMAND_SYNTAX_ERROR;
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
if (!strcmp(CMD_ARGV[cmd_idx], "sync")) {
protocol = CMD_ARGV[cmd_idx];
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
port_width = CMD_ARGV[cmd_idx];
} else {
if (strcmp(CMD_ARGV[cmd_idx], "manchester") && strcmp(CMD_ARGV[cmd_idx], "uart"))
return ERROR_COMMAND_SYNTAX_ERROR;
protocol = CMD_ARGV[cmd_idx];
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
formatter = CMD_ARGV[cmd_idx];
}
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
trace_clk = CMD_ARGV[cmd_idx];
cmd_idx++;
if (CMD_ARGC != cmd_idx) {
pin_clk = CMD_ARGV[cmd_idx];
cmd_idx++;
}
if (CMD_ARGC != cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
LOG_INFO(MSG "Running: \'%s configure -protocol %s -traceclk %s" "%s%s" "%s%s" "%s%s" "%s%s\'",
obj->name, protocol, trace_clk,
pin_clk ? " -pin-freq " : "", pin_clk ? pin_clk : "",
output ? " -output " : "", output ? output : "",
formatter ? " -formatter " : "", formatter ? formatter : "",
port_width ? " -port-width " : "", port_width ? port_width : "");
retval = command_run_linef(CMD_CTX,
"%s configure -protocol %s -traceclk %s" "%s%s" "%s%s" "%s%s" "%s%s",
obj->name, protocol, trace_clk,
pin_clk ? " -pin-freq " : "", pin_clk ? pin_clk : "",
output ? " -output " : "", output ? output : "",
formatter ? " -formatter " : "", formatter ? formatter : "",
port_width ? " -port-width " : "", port_width ? port_width : "");
if (retval != ERROR_OK)
return retval;
LOG_INFO(MSG "Running: \'%s enable\'", obj->name);
retval = command_run_linef(CMD_CTX, "%s enable", obj->name);
if (retval != ERROR_OK)
return retval;
target_handle_event(target, TARGET_EVENT_TRACE_CONFIG);
return ERROR_OK;
}
static const struct command_registration arm_tpiu_deprecated_subcommand_handlers[] = {
{
.name = "config",
.handler = handle_tpiu_deprecated_config_command,
.mode = COMMAND_ANY,
.help = "Configure TPIU features, DEPRECATED, use \'tpiu create\'",
.usage = "(disable | "
"((external | internal (<filename> | <:port> | -)) "
"(sync <port width> | ((manchester | uart) <formatter enable>)) "
"<TRACECLKIN freq> [<trace freq>]))",
},
COMMAND_REGISTRATION_DONE
};
const struct command_registration arm_tpiu_deprecated_command_handlers[] = {
{
.name = "tpiu",
.chain = arm_tpiu_deprecated_subcommand_handlers,
.usage = "",
.help = "tpiu command group",
},
COMMAND_REGISTRATION_DONE
};
/* END_DEPRECATED_TPIU */
static const struct command_registration arm_tpiu_swo_subcommand_handlers[] = {
{
.name = "create",

12
src/target/arm_tpiu_swo.h
View File

@@ -3,6 +3,18 @@
#ifndef OPENOCD_TARGET_ARM_TPIU_SWO_H
#define OPENOCD_TARGET_ARM_TPIU_SWO_H
/* Values should match TPIU_SPPR_PROTOCOL_xxx */
enum tpiu_pin_protocol {
TPIU_PIN_PROTOCOL_SYNC = 0, /**< synchronous trace output */
TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER = 1, /**< asynchronous output with Manchester coding */
TPIU_PIN_PROTOCOL_ASYNC_UART = 2, /**< asynchronous output with NRZ coding */
};
/* START_DEPRECATED_TPIU */
/* DEPRECATED: emulation of old command 'tpiu config' */
extern const struct command_registration arm_tpiu_deprecated_command_handlers[];
/* END_DEPRECATED_TPIU */
int arm_tpiu_swo_register_commands(struct command_context *cmd_ctx);
int arm_tpiu_swo_cleanup_all(void);

324
src/target/armv7m_trace.c
View File

@@ -26,133 +26,6 @@
#include <jtag/interface.h>
#include <helper/time_support.h>
#define TRACE_BUF_SIZE 4096
static int armv7m_poll_trace(void *target)
{
struct armv7m_common *armv7m = target_to_armv7m(target);
uint8_t buf[TRACE_BUF_SIZE];
size_t size = sizeof(buf);
int retval;
retval = adapter_poll_trace(buf, &size);
if (retval != ERROR_OK || !size)
return retval;
target_call_trace_callbacks(target, size, buf);
switch (armv7m->trace_config.internal_channel) {
case TRACE_INTERNAL_CHANNEL_FILE:
if (armv7m->trace_config.trace_file != NULL) {
if (fwrite(buf, 1, size, armv7m->trace_config.trace_file) == size)
fflush(armv7m->trace_config.trace_file);
else {
LOG_ERROR("Error writing to the trace destination file");
return ERROR_FAIL;
}
}
break;
case TRACE_INTERNAL_CHANNEL_TCP:
if (armv7m->trace_config.trace_service != NULL) {
/* broadcast to all service connections */
struct connection *connection = armv7m->trace_config.trace_service->connections;
retval = ERROR_OK;
while (connection) {
if (connection_write(connection, buf, size) != (int) size)
retval = ERROR_FAIL;
connection = connection->next;
}
if (retval != ERROR_OK) {
LOG_ERROR("Error streaming the trace to TCP/IP port");
return ERROR_FAIL;
}
}
break;
case TRACE_INTERNAL_CHANNEL_TCL_ONLY:
/* nothing to do :
* the trace data is sent to TCL by calling the target_call_trace_callbacks
**/
break;
default:
LOG_ERROR("unsupported trace internal channel");
return ERROR_FAIL;
}
return ERROR_OK;
}
int armv7m_trace_tpiu_config(struct target *target)
{
struct armv7m_common *armv7m = target_to_armv7m(target);
struct armv7m_trace_config *trace_config = &armv7m->trace_config;
uint16_t prescaler = TPIU_ACPR_MAX_SWOSCALER + 1;
int retval;
target_unregister_timer_callback(armv7m_poll_trace, target);
retval = adapter_config_trace(trace_config->config_type == TRACE_CONFIG_TYPE_INTERNAL,
trace_config->pin_protocol, trace_config->port_size,
&trace_config->trace_freq, trace_config->traceclkin_freq, &prescaler);
if (retval != ERROR_OK)
return retval;
if (trace_config->config_type == TRACE_CONFIG_TYPE_EXTERNAL) {
prescaler = trace_config->traceclkin_freq / trace_config->trace_freq;
if (trace_config->traceclkin_freq % trace_config->trace_freq) {
prescaler++;
int trace_freq = trace_config->traceclkin_freq / prescaler;
LOG_INFO("Can not obtain %u trace port frequency from %u "
"TRACECLKIN frequency, using %u instead",
trace_config->trace_freq, trace_config->traceclkin_freq,
trace_freq);
trace_config->trace_freq = trace_freq;
}
}
if (!trace_config->trace_freq) {
LOG_ERROR("Trace port frequency is 0, can't enable TPIU");
return ERROR_FAIL;
}
retval = target_write_u32(target, TPIU_CSPSR, 1 << trace_config->port_size);
if (retval != ERROR_OK)
return retval;
retval = target_write_u32(target, TPIU_ACPR, prescaler - 1);
if (retval != ERROR_OK)
return retval;
retval = target_write_u32(target, TPIU_SPPR, trace_config->pin_protocol);
if (retval != ERROR_OK)
return retval;
uint32_t ffcr;
retval = target_read_u32(target, TPIU_FFCR, &ffcr);
if (retval != ERROR_OK)
return retval;
if (trace_config->formatter)
ffcr |= (1 << 1);
else
ffcr &= ~(1 << 1);
retval = target_write_u32(target, TPIU_FFCR, ffcr);
if (retval != ERROR_OK)
return retval;
if (trace_config->config_type == TRACE_CONFIG_TYPE_INTERNAL)
target_register_timer_callback(armv7m_poll_trace, 1,
TARGET_TIMER_TYPE_PERIODIC, target);
target_call_event_callbacks(target, TARGET_EVENT_TRACE_CONFIG);
return ERROR_OK;
}
int armv7m_trace_itm_config(struct target *target)
{
struct armv7m_common *armv7m = target_to_armv7m(target);
@@ -210,182 +83,6 @@ int armv7m_trace_itm_config(struct target *target)
return ERROR_OK;
}
static void close_trace_channel(struct armv7m_common *armv7m)
{
switch (armv7m->trace_config.internal_channel) {
case TRACE_INTERNAL_CHANNEL_FILE:
if (armv7m->trace_config.trace_file)
fclose(armv7m->trace_config.trace_file);
armv7m->trace_config.trace_file = NULL;
break;
case TRACE_INTERNAL_CHANNEL_TCP:
if (armv7m->trace_config.trace_service)
remove_service(armv7m->trace_config.trace_service->name, armv7m->trace_config.trace_service->port);
armv7m->trace_config.trace_service = NULL;
break;
case TRACE_INTERNAL_CHANNEL_TCL_ONLY:
/* nothing to do:
* the trace polling is disabled in the beginning of armv7m_trace_tpiu_config
**/
break;
default:
LOG_ERROR("unsupported trace internal channel");
}
}
static int trace_new_connection(struct connection *connection)
{
/* nothing to do */
return ERROR_OK;
}
static int trace_input(struct connection *connection)
{
/* create a dummy buffer to check if the connection is still active */
const int buf_len = 100;
unsigned char buf[buf_len];
int bytes_read = connection_read(connection, buf, buf_len);
if (bytes_read == 0)
return ERROR_SERVER_REMOTE_CLOSED;
else if (bytes_read == -1) {
LOG_ERROR("error during read: %s", strerror(errno));
return ERROR_SERVER_REMOTE_CLOSED;
}
return ERROR_OK;
}
static int trace_connection_closed(struct connection *connection)
{
/* nothing to do, no connection->priv to free */
return ERROR_OK;
}
extern struct command_context *global_cmd_ctx;
int armv7m_trace_tpiu_exit(struct target *target)
{
struct armv7m_common *armv7m = target_to_armv7m(target);
if (global_cmd_ctx->mode == COMMAND_CONFIG ||
armv7m->trace_config.config_type == TRACE_CONFIG_TYPE_DISABLED)
return ERROR_OK;
close_trace_channel(armv7m);
armv7m->trace_config.config_type = TRACE_CONFIG_TYPE_DISABLED;
return armv7m_trace_tpiu_config(target);
}
COMMAND_HANDLER(handle_tpiu_config_command)
{
struct target *target = get_current_target(CMD_CTX);
struct armv7m_common *armv7m = target_to_armv7m(target);
unsigned int cmd_idx = 0;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
if (!strcmp(CMD_ARGV[cmd_idx], "disable")) {
if (CMD_ARGC == cmd_idx + 1) {
close_trace_channel(armv7m);
armv7m->trace_config.config_type = TRACE_CONFIG_TYPE_DISABLED;
if (CMD_CTX->mode == COMMAND_EXEC)
return armv7m_trace_tpiu_config(target);
else
return ERROR_OK;
}
} else if (!strcmp(CMD_ARGV[cmd_idx], "external") ||
!strcmp(CMD_ARGV[cmd_idx], "internal")) {
close_trace_channel(armv7m);
armv7m->trace_config.config_type = TRACE_CONFIG_TYPE_EXTERNAL;
if (!strcmp(CMD_ARGV[cmd_idx], "internal")) {
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
armv7m->trace_config.config_type = TRACE_CONFIG_TYPE_INTERNAL;
armv7m->trace_config.internal_channel = TRACE_INTERNAL_CHANNEL_TCL_ONLY;
if (strcmp(CMD_ARGV[cmd_idx], "-") != 0) {
if (CMD_ARGV[cmd_idx][0] == ':') {
armv7m->trace_config.internal_channel = TRACE_INTERNAL_CHANNEL_TCP;
int ret = add_service("armv7m_trace", &(CMD_ARGV[cmd_idx][1]),
CONNECTION_LIMIT_UNLIMITED, trace_new_connection, trace_input,
trace_connection_closed, NULL, &armv7m->trace_config.trace_service);
if (ret != ERROR_OK) {
LOG_ERROR("Can't configure trace TCP port");
return ERROR_FAIL;
}
} else {
armv7m->trace_config.internal_channel = TRACE_INTERNAL_CHANNEL_FILE;
armv7m->trace_config.trace_file = fopen(CMD_ARGV[cmd_idx], "ab");
if (!armv7m->trace_config.trace_file) {
LOG_ERROR("Can't open trace destination file");
return ERROR_FAIL;
}
}
}
}
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
if (!strcmp(CMD_ARGV[cmd_idx], "sync")) {
armv7m->trace_config.pin_protocol = TPIU_PIN_PROTOCOL_SYNC;
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[cmd_idx], armv7m->trace_config.port_size);
} else {
if (!strcmp(CMD_ARGV[cmd_idx], "manchester"))
armv7m->trace_config.pin_protocol = TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER;
else if (!strcmp(CMD_ARGV[cmd_idx], "uart"))
armv7m->trace_config.pin_protocol = TPIU_PIN_PROTOCOL_ASYNC_UART;
else
return ERROR_COMMAND_SYNTAX_ERROR;
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_ON_OFF(CMD_ARGV[cmd_idx], armv7m->trace_config.formatter);
}
cmd_idx++;
if (CMD_ARGC == cmd_idx)
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[cmd_idx], armv7m->trace_config.traceclkin_freq);
cmd_idx++;
if (CMD_ARGC != cmd_idx) {
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[cmd_idx], armv7m->trace_config.trace_freq);
cmd_idx++;
} else {
if (armv7m->trace_config.config_type != TRACE_CONFIG_TYPE_INTERNAL) {
LOG_ERROR("Trace port frequency can't be omitted in external capture mode");
return ERROR_COMMAND_SYNTAX_ERROR;
}
armv7m->trace_config.trace_freq = 0;
}
if (CMD_ARGC == cmd_idx) {
if (CMD_CTX->mode == COMMAND_EXEC)
return armv7m_trace_tpiu_config(target);
else
return ERROR_OK;
}
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
COMMAND_HANDLER(handle_itm_port_command)
{
struct target *target = get_current_target(CMD_CTX);
@@ -433,20 +130,6 @@ COMMAND_HANDLER(handle_itm_ports_command)
return ERROR_OK;
}
static const struct command_registration tpiu_command_handlers[] = {
{
.name = "config",
.handler = handle_tpiu_config_command,
.mode = COMMAND_ANY,
.help = "Configure TPIU features",
.usage = "(disable | "
"((external | internal (<filename> | <:port> | -)) "
"(sync <port width> | ((manchester | uart) <formatter enable>)) "
"<TRACECLKIN freq> [<trace freq>]))",
},
COMMAND_REGISTRATION_DONE
};
static const struct command_registration itm_command_handlers[] = {
{
.name = "port",
@@ -466,13 +149,6 @@ static const struct command_registration itm_command_handlers[] = {
};
const struct command_registration armv7m_trace_command_handlers[] = {
{
.name = "tpiu",
.mode = COMMAND_ANY,
.help = "tpiu command group",
.usage = "",
.chain = tpiu_command_handlers,
},
{
.name = "itm",
.mode = COMMAND_ANY,

51
src/target/armv7m_trace.h
View File

@@ -18,33 +18,14 @@
#ifndef OPENOCD_TARGET_ARMV7M_TRACE_H
#define OPENOCD_TARGET_ARMV7M_TRACE_H
#include <server/server.h>
#include <target/target.h>
#include <command.h>
/**
* @file
* Holds the interface to TPIU, ITM and DWT configuration functions.
* Holds the interface to ITM and DWT configuration functions.
*/
enum trace_config_type {
TRACE_CONFIG_TYPE_DISABLED, /**< tracing is disabled */
TRACE_CONFIG_TYPE_EXTERNAL, /**< trace output is captured externally */
TRACE_CONFIG_TYPE_INTERNAL /**< trace output is handled by OpenOCD adapter driver */
};
enum trace_internal_channel {
TRACE_INTERNAL_CHANNEL_TCL_ONLY, /** trace data is sent only to 'tcl_trace' */
TRACE_INTERNAL_CHANNEL_FILE, /** trace data is appended to a file */
TRACE_INTERNAL_CHANNEL_TCP /** trace data is appended to a TCP/IP port*/
};
enum tpiu_pin_protocol {
TPIU_PIN_PROTOCOL_SYNC, /**< synchronous trace output */
TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER, /**< asynchronous output with Manchester coding */
TPIU_PIN_PROTOCOL_ASYNC_UART /**< asynchronous output with NRZ coding */
};
enum itm_ts_prescaler {
ITM_TS_PRESCALE1, /**< no prescaling for the timestamp counter */
ITM_TS_PRESCALE4, /**< refclock divided by 4 for the timestamp counter */
@@ -53,19 +34,6 @@ enum itm_ts_prescaler {
};
struct armv7m_trace_config {
/** Currently active trace capture mode */
enum trace_config_type config_type;
/** The used channel when internal mode is selected */
enum trace_internal_channel internal_channel;
/** Currently active trace output mode */
enum tpiu_pin_protocol pin_protocol;
/** TPIU formatter enable/disable (in async mode) */
bool formatter;
/** Synchronous output port width */
uint32_t port_size;
/** Bitmask of currently enabled ITM stimuli */
uint32_t itm_ter[8];
/** Identifier for multi-source trace stream formatting */
@@ -80,27 +48,10 @@ struct armv7m_trace_config {
bool itm_synchro_packets;
/** Config ITM after target examine */
bool itm_deferred_config;
/** Current frequency of TRACECLKIN (usually matches HCLK) */
unsigned int traceclkin_freq;
/** Current frequency of trace port */
unsigned int trace_freq;
/** Handle to output trace data in INTERNAL capture mode via file */
FILE *trace_file;
/** Handle to output trace data in INTERNAL capture mode via tcp */
struct service *trace_service;
};
extern const struct command_registration armv7m_trace_command_handlers[];
/**
* Configure hardware accordingly to the current TPIU target settings
*/
int armv7m_trace_tpiu_config(struct target *target);
/**
* Disable TPIU data gathering at exit
*/
int armv7m_trace_tpiu_exit(struct target *target);
/**
* Configure hardware accordingly to the current ITM target settings
*/

10
src/target/cortex_m.c
View File

@@ -1648,8 +1648,6 @@ void cortex_m_deinit_target(struct target *target)
{
struct cortex_m_common *cortex_m = target_to_cm(target);
armv7m_trace_tpiu_exit(target);
free(cortex_m->fp_comparator_list);
cortex_m_dwt_free(target);
@@ -2082,9 +2080,6 @@ int cortex_m_examine(struct target *target)
if (retval != ERROR_OK)
return retval;
if (armv7m->trace_config.config_type != TRACE_CONFIG_TYPE_DISABLED)
armv7m_trace_tpiu_config(target);
if (armv7m->trace_config.itm_deferred_config)
armv7m_trace_itm_config(target);
@@ -2486,6 +2481,11 @@ static const struct command_registration cortex_m_command_handlers[] = {
{
.chain = armv7m_trace_command_handlers,
},
/* START_DEPRECATED_TPIU */
{
.chain = arm_tpiu_deprecated_command_handlers,
},
/* END_DEPRECATED_TPIU */
{
.name = "cortex_m",
.mode = COMMAND_EXEC,

5
src/target/hla_target.c
View File

@@ -630,6 +630,11 @@ static const struct command_registration adapter_command_handlers[] = {
{
.chain = rtt_target_command_handlers,
},
/* START_DEPRECATED_TPIU */
{
.chain = arm_tpiu_deprecated_command_handlers,
},
/* END_DEPRECATED_TPIU */
COMMAND_REGISTRATION_DONE
};

5
src/target/target.c
View File

@@ -4945,6 +4945,11 @@ no_params:
}
if (goi->isconfigure) {
/* START_DEPRECATED_TPIU */
if (n->value == TARGET_EVENT_TRACE_CONFIG)
LOG_INFO("DEPRECATED target event %s", n->name);
/* END_DEPRECATED_TPIU */
bool replace = true;
if (teap == NULL) {
/* create new */