Subversion Repositories riscv_vhdl

/*

 *  Copyright 2018 Sergey Khabarov, sergeykhbr@gmail.com

 *

 *  Licensed under the Apache License, Version 2.0 (the "License");

 *  you may not use this file except in compliance with the License.

 *  You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 *  Unless required by applicable law or agreed to in writing, software

 *  distributed under the License is distributed on an "AS IS" BASIS,

 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *  See the License for the specific language governing permissions and

 *  limitations under the License.

 *

 * @details

 *             Write command:

 *                 Send     [11.Length-1].Addr[63:0].Data[31:0]*(x Length)

 *             Read command:

 *                 Send     [10.Length-1].Addr[63:0]

 *                 Receive  Data[31:0]*(x Length)

 */

#include "api_core.h"

#include "serial_dbglink.h"

namespace debugger {

/** Class registration in the Core */

REGISTER_CLASS(SerialDbgService)

SerialDbgService::SerialDbgService(const char *name)

    : IService(name) {

    registerInterface(static_cast<ITap *>(this));

    registerAttribute("Timeout", &timeout_);

    registerAttribute("Port", &port_);

    RISCV_event_create(&event_block_, "SerialDbg_event_block");

}

SerialDbgService::~SerialDbgService() {

    RISCV_event_close(&event_block_);

}

void SerialDbgService::postinitService() {

    iserial_ = static_cast<ISerial *>(

        RISCV_get_service_iface(port_.to_string(), IFACE_SERIAL));

    if (!iserial_) {

        RISCV_error("Can't find ISerial interface %s", port_.to_string());

        return;

    }

    iserial_->registerRawListener(static_cast<IRawListener *>(this));

#if 1  // hardcoded scale in tapuart, no need in clock detection

    /** Automatic baudrate definition on hardware side:

     *    [0] 0x55 - to init baud rate detector

     *    [1] 0x55 - to confirm baud rate value.

     */

    char tbuf[5] = {0x55, 0x55, 0x55, 0x55};

    iserial_->writeData(tbuf, 4);

#endif

}

void SerialDbgService::predeleteService() {

    if (iserial_) {

        iserial_->unregisterRawListener(static_cast<IRawListener *>(this));

    }

}

int SerialDbgService::read(uint64_t addr, int bytes, uint8_t *obuf) {

    if (!iserial_) {

        return TAP_ERROR;

    }

    if (bytes <= 0 || (bytes & 0x3) != 0) {

        RISCV_error("Unaligned read %d", bytes);

        return TAP_ERROR;

    }

    addr &= 0xFFFFFFFFull;

    int bytes_to_read = bytes;

    uint8_t *tout = obuf;

    pkt_.fields.magic = MAGIC_ID;

    pkt_.fields.addr = addr;

    while (bytes_to_read) {

        pkt_.fields.cmd = (0x2 << 6);

        if (bytes_to_read > 4 * UART_MST_BURST_MAX) {

            req_count_ = 4 * UART_MST_BURST_MAX;

            pkt_.fields.cmd |= 0x3F;

        } else {

            req_count_ = bytes_to_read;

            pkt_.fields.cmd |= ((bytes_to_read / 4) - 1) & 0x3F;

        }

        rd_count_ = 0;

        wait_bytes_ = req_count_;

        RISCV_event_clear(&event_block_);

        iserial_->writeData(pkt_.buf, UART_REQ_HEADER_SZ);

        if (RISCV_event_wait_ms(&event_block_, timeout_.to_int()) != 0) {

            RISCV_error("Reading [%08" RV_PRI64 "x] failed", addr);

            return TAP_ERROR;

        }

        if (rd_count_ != req_count_) {

            RISCV_error("Read bytes %d of %d", rd_count_, req_count_);

            return TAP_ERROR;

        }

        memcpy(tout, rxbuf_[0].buf, rd_count_);

        tout += rd_count_;

        pkt_.fields.addr += static_cast<unsigned>(rd_count_);

        bytes_to_read -= rd_count_;

    }

    return bytes;

}

int SerialDbgService::write(uint64_t addr, int bytes, uint8_t *ibuf) {

    if (!iserial_) {

        return TAP_ERROR;

    }

    if (bytes <= 0 || (bytes & 0x3) != 0) {

        RISCV_error("Unaligned write %d", bytes);

        return TAP_ERROR;

    }

    addr &= 0xFFFFFFFFull;

    int bytes_to_write = bytes;

    uint8_t *tin = ibuf;

    pkt_.fields.magic = MAGIC_ID;

    pkt_.fields.addr = addr;

    while (bytes_to_write) {

        pkt_.fields.cmd = (0x3 << 6);

        if (bytes_to_write > 4 * UART_MST_BURST_MAX) {

            req_count_ = 4 * UART_MST_BURST_MAX;

            pkt_.fields.cmd |= 0x3F;

        } else {

            req_count_ = bytes_to_write;

            pkt_.fields.cmd |= ((bytes_to_write / 4) - 1) & 0x3F;

        }

        memcpy(pkt_.fields.data, tin, req_count_);

        wait_bytes_ = 4;

        rd_count_ = 0;

        RISCV_event_clear(&event_block_);

        iserial_->writeData(pkt_.buf, UART_REQ_HEADER_SZ + req_count_);

        // Waiting "ACK\n" handshake

        if (RISCV_event_wait_ms(&event_block_, timeout_.to_int()) != 0) {

            RISCV_error("Writing [%08" RV_PRI64 "x] failed", addr);

            return TAP_ERROR;

        }

        tin += req_count_;

        bytes_to_write -= req_count_;

        pkt_.fields.addr += static_cast<unsigned>(req_count_);

    }

    return bytes;

}

void SerialDbgService::updateData(const char *buf, int buflen) {

    uint8_t *tbuf = &rxbuf_[0].buf[rd_count_];

    memcpy(tbuf, buf, buflen);

    rd_count_ += buflen;

    if (rd_count_ < wait_bytes_) {

        return;

    }

    RISCV_event_set(&event_block_);

}

}  // namespace debugger