jtag_dpi.c

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 
/*
 * JTAG to DPI driver
 *
 * Copyright (C) 2013 Franck Jullien, <elec4fun@gmail.com>
 *
 * Copyright (C) 2019-2020, Ampere Computing LLC
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 */
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include <jtag/interface.h>
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
 
#ifndef _WIN32
#include <netinet/tcp.h>
#endif
 
#define SERVER_ADDRESS  "127.0.0.1"
#define SERVER_PORT 5555
 
static uint16_t server_port = SERVER_PORT;
static char *server_address;
 
static int sockfd;
 
static uint8_t *last_ir_buf;
static int last_ir_num_bits;
 
static int write_sock(char *buf, size_t len)
{
    if (!buf) {
        LOG_ERROR("%s: NULL 'buf' argument, file %s, line %d",
            __func__, __FILE__, __LINE__);
        return ERROR_FAIL;
    }
    if (write(sockfd, buf, len) != (ssize_t)len) {
        LOG_ERROR("%s: %s, file %s, line %d", __func__,
            strerror(errno), __FILE__, __LINE__);
        return ERROR_FAIL;
    }
    return ERROR_OK;
}
 
static int read_sock(char *buf, size_t len)
{
    if (!buf) {
        LOG_ERROR("%s: NULL 'buf' argument, file %s, line %d",
            __func__, __FILE__, __LINE__);
        return ERROR_FAIL;
    }
    if (read(sockfd, buf, len) != (ssize_t)len) {
        LOG_ERROR("%s: %s, file %s, line %d", __func__,
            strerror(errno), __FILE__, __LINE__);
        return ERROR_FAIL;
    }
    return ERROR_OK;
}
 
static int jtag_dpi_reset(int trst, int srst)
{
    char *buf = "reset\n";
    int ret = ERROR_OK;
 
    LOG_DEBUG_IO("JTAG DRIVER DEBUG: reset trst: %i srst %i", trst, srst);
 
    if (trst == 1) {
        /* reset the JTAG TAP controller */
        ret = write_sock(buf, strlen(buf));
        if (ret != ERROR_OK) {
            LOG_ERROR("write_sock() fail, file %s, line %d",
                __FILE__, __LINE__);
        }
    }
 
    if (srst == 1) {
        /* System target reset not supported */
        LOG_ERROR("DPI SRST not supported");
        ret = ERROR_FAIL;
    }
 
    return ret;
}
 
static int jtag_dpi_scan(struct scan_command *cmd)
{
    char buf[20];
    uint8_t *data_buf;
    int num_bits, bytes;
    int ret = ERROR_OK;
 
    num_bits = jtag_build_buffer(cmd, &data_buf);
    if (!data_buf) {
        LOG_ERROR("jtag_build_buffer call failed, data_buf == NULL, "
            "file %s, line %d", __FILE__, __LINE__);
        return ERROR_FAIL;
    }
 
    bytes = DIV_ROUND_UP(num_bits, 8);
    if (cmd->ir_scan) {
        free(last_ir_buf);
        last_ir_buf = (uint8_t *)malloc(bytes * sizeof(uint8_t));
        if (!last_ir_buf) {
            LOG_ERROR("%s: malloc fail, file %s, line %d",
                __func__, __FILE__, __LINE__);
            ret = ERROR_FAIL;
            goto out;
        }
        memcpy(last_ir_buf, data_buf, bytes);
        last_ir_num_bits = num_bits;
    }
    snprintf(buf, sizeof(buf), "%s %d\n", cmd->ir_scan ? "ib" : "db", num_bits);
    ret = write_sock(buf, strlen(buf));
    if (ret != ERROR_OK) {
        LOG_ERROR("write_sock() fail, file %s, line %d",
            __FILE__, __LINE__);
        goto out;
    }
    ret = write_sock((char *)data_buf, bytes);
    if (ret != ERROR_OK) {
        LOG_ERROR("write_sock() fail, file %s, line %d",
            __FILE__, __LINE__);
        goto out;
    }
    ret = read_sock((char *)data_buf, bytes);
    if (ret != ERROR_OK) {
        LOG_ERROR("read_sock() fail, file %s, line %d",
            __FILE__, __LINE__);
        goto out;
    }
 
    ret = jtag_read_buffer(data_buf, cmd);
    if (ret != ERROR_OK) {
        LOG_ERROR("jtag_read_buffer() fail, file %s, line %d",
            __FILE__, __LINE__);
        goto out;
    }
 
out:
    free(data_buf);
    return ret;
}
 
static int jtag_dpi_runtest(unsigned int num_cycles)
{
    char buf[20];
    uint8_t *data_buf = last_ir_buf, *read_scan;
    int num_bits = last_ir_num_bits, bytes;
    int ret = ERROR_OK;
 
    if (!data_buf) {
        LOG_ERROR("%s: NULL 'data_buf' argument, file %s, line %d",
            __func__, __FILE__, __LINE__);
        return ERROR_FAIL;
    }
    if (num_bits <= 0) {
        LOG_ERROR("%s: 'num_bits' invalid value, file %s, line %d",
            __func__, __FILE__, __LINE__);
        return ERROR_FAIL;
    }
 
    bytes = DIV_ROUND_UP(num_bits, 8);
    read_scan = (uint8_t *)malloc(bytes * sizeof(uint8_t));
    if (!read_scan) {
        LOG_ERROR("%s: malloc fail, file %s, line %d",
            __func__, __FILE__, __LINE__);
        return ERROR_FAIL;
    }
    snprintf(buf, sizeof(buf), "ib %d\n", num_bits);
    for (unsigned int cycle = 0; cycle < num_cycles; cycle += num_bits + 6) {
        ret = write_sock(buf, strlen(buf));
        if (ret != ERROR_OK) {
            LOG_ERROR("write_sock() fail, file %s, line %d",
                __FILE__, __LINE__);
            goto out;
        }
        ret = write_sock((char *)data_buf, bytes);
        if (ret != ERROR_OK) {
            LOG_ERROR("write_sock() fail, file %s, line %d",
                __FILE__, __LINE__);
            goto out;
        }
        ret = read_sock((char *)read_scan, bytes);
        if (ret != ERROR_OK) {
            LOG_ERROR("read_sock() fail, file %s, line %d",
                __FILE__, __LINE__);
            goto out;
        }
    }
 
out:
    free(read_scan);
    return ret;
}
 
static int jtag_dpi_stableclocks(unsigned int num_cycles)
{
    return jtag_dpi_runtest(num_cycles);
}
 
static int jtag_dpi_execute_queue(struct jtag_command *cmd_queue)
{
    struct jtag_command *cmd;
    int ret = ERROR_OK;
 
    for (cmd = cmd_queue; ret == ERROR_OK && cmd;
         cmd = cmd->next) {
        switch (cmd->type) {
        case JTAG_RUNTEST:
            ret = jtag_dpi_runtest(cmd->cmd.runtest->num_cycles);
            break;
        case JTAG_STABLECLOCKS:
            ret = jtag_dpi_stableclocks(cmd->cmd.stableclocks->num_cycles);
            break;
        case JTAG_TLR_RESET:
            /* Enter Test-Logic-Reset state by asserting TRST */
            if (cmd->cmd.statemove->end_state == TAP_RESET)
                jtag_dpi_reset(1, 0);
            break;
        case JTAG_PATHMOVE:
            /* unsupported */
            break;
        case JTAG_TMS:
            /* unsupported */
            break;
        case JTAG_SLEEP:
            jtag_sleep(cmd->cmd.sleep->us);
            break;
        case JTAG_SCAN:
            ret = jtag_dpi_scan(cmd->cmd.scan);
            break;
        default:
            LOG_ERROR("BUG: unknown JTAG command type 0x%X",
                  cmd->type);
            ret = ERROR_FAIL;
            break;
        }
    }
 
    return ret;
}
 
static int jtag_dpi_init(void)
{
    if (!server_address) {
        server_address = strdup(SERVER_ADDRESS);
        if (!server_address) {
            LOG_ERROR("%s: strdup fail, file %s, line %d",
                __func__, __FILE__, __LINE__);
            return ERROR_FAIL;
        }
    }
 
    const struct addrinfo hints = {
        .ai_family = AF_UNSPEC,
        .ai_socktype = SOCK_STREAM
    };
 
    char port_str[5 + 1];
    snprintf(port_str, sizeof(port_str), "%" PRIu16, server_port);
 
    struct addrinfo *result;
    int ret = getaddrinfo(server_address, port_str, &hints, &result);
 
    if (ret != 0) {
        LOG_ERROR("getaddrinfo: %s", gai_strerror(ret));
        return ERROR_FAIL;
    }
 
    struct addrinfo *rp;
    for (rp = result; rp ; rp = rp->ai_next) {
        sockfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
        if (sockfd == -1)
            continue;
 
        if (connect(sockfd, rp->ai_addr, rp->ai_addrlen) != -1)
            break;
 
        close(sockfd);
    }
 
    if (!rp) {
        LOG_ERROR("Can't connect to %s : %" PRIu16, server_address,
            server_port);
        freeaddrinfo(result);
        return ERROR_FAIL;
    }
 
    bool is_loopback = false;
    if (rp->ai_family == AF_INET) {
        struct sockaddr_in sa;
        memcpy(&sa, rp->ai_addr, sizeof(sa));
        is_loopback = (sa.sin_addr.s_addr == htonl(INADDR_LOOPBACK));
    } else if (rp->ai_family == AF_INET6) {
        struct sockaddr_in6 sa;
        memcpy(&sa, rp->ai_addr, sizeof(sa));
        is_loopback = IN6_IS_ADDR_LOOPBACK(&sa.sin6_addr);
    }
 
    if (is_loopback) {
        LOG_DEBUG("Enabling TCP_NODELAY to enhance the speed of local connections");
 
        /* This increases performance dramatically for local
        * connections, which is the most likely arrangement
        * for a DPI connection. */
        int flag = 1;
        setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char *)&flag,
            sizeof(int));
    }
 
    freeaddrinfo(result);
 
    LOG_INFO("Connection to %s : %" PRIu16 " succeed", server_address, server_port);
 
    return ERROR_OK;
}
 
static int jtag_dpi_quit(void)
{
    free(server_address);
    server_address = NULL;
 
    return close(sockfd);
}
 
COMMAND_HANDLER(jtag_dpi_set_port)
{
    if (CMD_ARGC > 1)
        return ERROR_COMMAND_SYNTAX_ERROR;
    else if (CMD_ARGC == 0)
        LOG_INFO("Using server port %" PRIu16, server_port);
    else {
        COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], server_port);
        LOG_INFO("Set server port to %" PRIu16, server_port);
    }
 
    return ERROR_OK;
}
 
COMMAND_HANDLER(jtag_dpi_set_address)
{
    if (CMD_ARGC > 1)
        return ERROR_COMMAND_SYNTAX_ERROR;
    else if (CMD_ARGC == 0) {
        if (!server_address) {
            server_address = strdup(SERVER_ADDRESS);
            if (!server_address) {
                LOG_ERROR("%s: strdup fail, file %s, line %d",
                    __func__, __FILE__, __LINE__);
                return ERROR_FAIL;
            }
        }
        LOG_INFO("Using server address %s", server_address);
    } else {
        free(server_address);
        server_address = strdup(CMD_ARGV[0]);
        if (!server_address) {
            LOG_ERROR("%s: strdup fail, file %s, line %d",
                __func__, __FILE__, __LINE__);
            return ERROR_FAIL;
        }
        LOG_INFO("Set server address to %s", server_address);
    }
 
    return ERROR_OK;
}
 
static const struct command_registration jtag_dpi_subcommand_handlers[] = {
    {
        .name = "set_port",
        .handler = &jtag_dpi_set_port,
        .mode = COMMAND_CONFIG,
        .help = "set the port of the DPI server",
        .usage = "[port]",
    },
    {
        .name = "set_address",
        .handler = &jtag_dpi_set_address,
        .mode = COMMAND_CONFIG,
        .help = "set the hostname or IP address of the DPI server",
        .usage = "[address]",
    },
    COMMAND_REGISTRATION_DONE
};
 
static const struct command_registration jtag_dpi_command_handlers[] = {
    {
        .name = "jtag_dpi",
        .mode = COMMAND_ANY,
        .help = "perform jtag_dpi management",
        .chain = jtag_dpi_subcommand_handlers,
        .usage = "",
    },
    COMMAND_REGISTRATION_DONE
};
 
static struct jtag_interface jtag_dpi_interface = {
    .supported = DEBUG_CAP_TMS_SEQ,
    .execute_queue = jtag_dpi_execute_queue,
};
 
struct adapter_driver jtag_dpi_adapter_driver = {
    .name = "jtag_dpi",
    .transport_ids = TRANSPORT_JTAG,
    .transport_preferred_id = TRANSPORT_JTAG,
    .commands = jtag_dpi_command_handlers,
    .init = jtag_dpi_init,
    .quit = jtag_dpi_quit,
    .reset = jtag_dpi_reset,
    .jtag_ops = &jtag_dpi_interface,
};