305 lines
7.4 KiB
C
305 lines
7.4 KiB
C
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/***************************************************************************
|
|
* Copyright (C) 2007 by Dominic Rath *
|
|
* Dominic.Rath@gmx.de *
|
|
* *
|
|
* Copyright (C) 2007,2008 Øyvind Harboe *
|
|
* oyvind.harboe@zylin.com *
|
|
* *
|
|
* Copyright (C) 2008 by Spencer Oliver *
|
|
* spen@spen-soft.co.uk *
|
|
***************************************************************************/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <helper/log.h>
|
|
#include <helper/binarybuffer.h>
|
|
|
|
#include "target.h"
|
|
#include "target_request.h"
|
|
#include "target_type.h"
|
|
#include "trace.h"
|
|
|
|
static bool got_message;
|
|
|
|
bool target_got_message(void)
|
|
{
|
|
bool t = got_message;
|
|
got_message = false;
|
|
return t;
|
|
}
|
|
|
|
static int charmsg_mode;
|
|
|
|
static int target_asciimsg(struct target *target, uint32_t length)
|
|
{
|
|
char *msg = malloc(DIV_ROUND_UP(length + 1, 4) * 4);
|
|
struct debug_msg_receiver *c = target->dbgmsg;
|
|
|
|
target->type->target_request_data(target, DIV_ROUND_UP(length, 4), (uint8_t *)msg);
|
|
msg[length] = 0;
|
|
|
|
LOG_DEBUG("%s", msg);
|
|
|
|
while (c) {
|
|
command_output_text(c->cmd_ctx, msg);
|
|
c = c->next;
|
|
}
|
|
|
|
return ERROR_OK;
|
|
}
|
|
|
|
static int target_charmsg(struct target *target, uint8_t msg)
|
|
{
|
|
LOG_USER_N("%c", msg);
|
|
|
|
return ERROR_OK;
|
|
}
|
|
|
|
static int target_hexmsg(struct target *target, int size, uint32_t length)
|
|
{
|
|
uint8_t *data = malloc(DIV_ROUND_UP(length * size, 4) * 4);
|
|
char line[128];
|
|
int line_len;
|
|
struct debug_msg_receiver *c = target->dbgmsg;
|
|
uint32_t i;
|
|
|
|
LOG_DEBUG("size: %i, length: %i", (int)size, (int)length);
|
|
|
|
target->type->target_request_data(target, DIV_ROUND_UP(length * size, 4), (uint8_t *)data);
|
|
|
|
line_len = 0;
|
|
for (i = 0; i < length; i++) {
|
|
switch (size) {
|
|
case 4:
|
|
line_len += snprintf(line + line_len, 128 - line_len, "%8.8" PRIx32 " ", le_to_h_u32(data + (4*i)));
|
|
break;
|
|
case 2:
|
|
line_len += snprintf(line + line_len, 128 - line_len, "%4.4x ", le_to_h_u16(data + (2*i)));
|
|
break;
|
|
case 1:
|
|
line_len += snprintf(line + line_len, 128 - line_len, "%2.2x ", data[i]);
|
|
break;
|
|
}
|
|
|
|
if ((i%8 == 7) || (i == length - 1)) {
|
|
LOG_DEBUG("%s", line);
|
|
|
|
while (c) {
|
|
command_output_text(c->cmd_ctx, line);
|
|
c = c->next;
|
|
}
|
|
c = target->dbgmsg;
|
|
line_len = 0;
|
|
}
|
|
}
|
|
|
|
free(data);
|
|
|
|
return ERROR_OK;
|
|
}
|
|
|
|
/* handle requests from the target received by a target specific
|
|
* side-band channel (e.g. ARM7/9 DCC)
|
|
*/
|
|
int target_request(struct target *target, uint32_t request)
|
|
{
|
|
target_req_cmd_t target_req_cmd = request & 0xff;
|
|
|
|
assert(target->type->target_request_data);
|
|
|
|
/* Record that we got a target message for back-off algorithm */
|
|
got_message = true;
|
|
|
|
if (charmsg_mode) {
|
|
target_charmsg(target, target_req_cmd);
|
|
return ERROR_OK;
|
|
}
|
|
|
|
switch (target_req_cmd) {
|
|
case TARGET_REQ_TRACEMSG:
|
|
trace_point(target, (request & 0xffffff00) >> 8);
|
|
break;
|
|
case TARGET_REQ_DEBUGMSG:
|
|
if (((request & 0xff00) >> 8) == 0)
|
|
target_asciimsg(target, (request & 0xffff0000) >> 16);
|
|
else
|
|
target_hexmsg(target, (request & 0xff00) >> 8, (request & 0xffff0000) >> 16);
|
|
break;
|
|
case TARGET_REQ_DEBUGCHAR:
|
|
target_charmsg(target, (request & 0x00ff0000) >> 16);
|
|
break;
|
|
/* case TARGET_REQ_SEMIHOSTING:
|
|
* break;
|
|
*/
|
|
default:
|
|
LOG_ERROR("unknown target request: %2.2x", target_req_cmd);
|
|
break;
|
|
}
|
|
|
|
return ERROR_OK;
|
|
}
|
|
|
|
static int add_debug_msg_receiver(struct command_context *cmd_ctx, struct target *target)
|
|
{
|
|
struct debug_msg_receiver **p = &target->dbgmsg;
|
|
|
|
if (!target)
|
|
return ERROR_COMMAND_SYNTAX_ERROR;
|
|
|
|
/* see if there's already a list */
|
|
if (*p) {
|
|
/* find end of linked list */
|
|
while ((*p)->next)
|
|
p = &((*p)->next);
|
|
p = &((*p)->next);
|
|
}
|
|
|
|
/* add new debug message receiver */
|
|
(*p) = malloc(sizeof(struct debug_msg_receiver));
|
|
(*p)->cmd_ctx = cmd_ctx;
|
|
(*p)->next = NULL;
|
|
|
|
/* enable callback */
|
|
target->dbg_msg_enabled = 1;
|
|
|
|
return ERROR_OK;
|
|
}
|
|
|
|
static struct debug_msg_receiver *find_debug_msg_receiver(struct command_context *cmd_ctx,
|
|
struct target *target)
|
|
{
|
|
int do_all_targets = 0;
|
|
|
|
/* if no target has been specified search all of them */
|
|
if (!target) {
|
|
/* if no targets haven been specified */
|
|
if (!all_targets)
|
|
return NULL;
|
|
|
|
target = all_targets;
|
|
do_all_targets = 1;
|
|
}
|
|
|
|
/* so we target != null */
|
|
struct debug_msg_receiver **p = &target->dbgmsg;
|
|
do {
|
|
while (*p) {
|
|
if ((*p)->cmd_ctx == cmd_ctx)
|
|
return *p;
|
|
p = &((*p)->next);
|
|
}
|
|
|
|
target = target->next;
|
|
} while (target && do_all_targets);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int delete_debug_msg_receiver(struct command_context *cmd_ctx, struct target *target)
|
|
{
|
|
struct debug_msg_receiver **p;
|
|
struct debug_msg_receiver *c;
|
|
int do_all_targets = 0;
|
|
|
|
/* if no target has been specified search all of them */
|
|
if (!target) {
|
|
/* if no targets haven been specified */
|
|
if (!all_targets)
|
|
return ERROR_OK;
|
|
|
|
target = all_targets;
|
|
do_all_targets = 1;
|
|
}
|
|
|
|
do {
|
|
p = &target->dbgmsg;
|
|
c = *p;
|
|
while (c) {
|
|
struct debug_msg_receiver *next = c->next;
|
|
if (c->cmd_ctx == cmd_ctx) {
|
|
*p = next;
|
|
free(c);
|
|
if (!*p) {
|
|
/* disable callback */
|
|
target->dbg_msg_enabled = 0;
|
|
}
|
|
return ERROR_OK;
|
|
} else
|
|
p = &(c->next);
|
|
c = next;
|
|
}
|
|
|
|
target = target->next;
|
|
} while (target && do_all_targets);
|
|
|
|
return ERROR_OK;
|
|
}
|
|
|
|
COMMAND_HANDLER(handle_target_request_debugmsgs_command)
|
|
{
|
|
struct target *target = get_current_target(CMD_CTX);
|
|
|
|
int receiving = 0;
|
|
|
|
if (!target->type->target_request_data) {
|
|
LOG_ERROR("Target %s does not support target requests", target_name(target));
|
|
return ERROR_OK;
|
|
}
|
|
|
|
/* see if receiver is already registered */
|
|
if (find_debug_msg_receiver(CMD_CTX, target))
|
|
receiving = 1;
|
|
|
|
if (CMD_ARGC > 0) {
|
|
if (!strcmp(CMD_ARGV[0], "enable") || !strcmp(CMD_ARGV[0], "charmsg")) {
|
|
/* don't register if this command context is already receiving */
|
|
if (!receiving) {
|
|
receiving = 1;
|
|
add_debug_msg_receiver(CMD_CTX, target);
|
|
}
|
|
charmsg_mode = !strcmp(CMD_ARGV[0], "charmsg");
|
|
} else if (!strcmp(CMD_ARGV[0], "disable")) {
|
|
/* no need to delete a receiver if none is registered */
|
|
if (receiving) {
|
|
receiving = 0;
|
|
delete_debug_msg_receiver(CMD_CTX, target);
|
|
}
|
|
} else
|
|
return ERROR_COMMAND_SYNTAX_ERROR;
|
|
}
|
|
|
|
command_print(CMD, "receiving debug messages from current target %s",
|
|
(receiving) ? (charmsg_mode ? "charmsg" : "enabled") : "disabled");
|
|
return ERROR_OK;
|
|
}
|
|
|
|
static const struct command_registration target_req_exec_command_handlers[] = {
|
|
{
|
|
.name = "debugmsgs",
|
|
.handler = handle_target_request_debugmsgs_command,
|
|
.mode = COMMAND_EXEC,
|
|
.help = "display and/or modify reception of debug messages from target",
|
|
.usage = "['enable'|'charmsg'|'disable']",
|
|
},
|
|
COMMAND_REGISTRATION_DONE
|
|
};
|
|
static const struct command_registration target_req_command_handlers[] = {
|
|
{
|
|
.name = "target_request",
|
|
.mode = COMMAND_ANY,
|
|
.help = "target request command group",
|
|
.usage = "",
|
|
.chain = target_req_exec_command_handlers,
|
|
},
|
|
COMMAND_REGISTRATION_DONE
|
|
};
|
|
|
|
int target_request_register_commands(struct command_context *cmd_ctx)
|
|
{
|
|
return register_commands(cmd_ctx, NULL, target_req_command_handlers);
|
|
}
|