Subversion Repositories riscv_vhdl

/**

 * @file

 * @copyright  Copyright 2016 GNSS Sensor Ltd. All right reserved.

 * @author     Sergey Khabarov - sergeykhbr@gmail.com

 * @brief      Ethernet MAC device functional model.

 */

#include <api_core.h>

#include "greth.h"

#include "coreservices/isocinfo.h"

namespace debugger {

/** Class registration in the Core */

REGISTER_CLASS(Greth)

Greth::Greth(const char *name)

    : IService(name) {

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

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

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

    registerAttribute("IP", &ip_);

    registerAttribute("MAC", &mac_);

    registerAttribute("Bus", &bus_);

    registerAttribute("Transport", &transport_);

    registerAttribute("SysBusMasterID", &sysBusMasterID_);

    memset(txbuf_, 0, sizeof(txbuf_));

    seq_cnt_ = 35;

    RISCV_event_create(&event_tap_, "UART_event_tap");

}

Greth::~Greth() {

    RISCV_event_close(&event_tap_);

}

void Greth::postinitService() {

    ibus_ = static_cast<IMemoryOperation *>(

       RISCV_get_service_iface(bus_.to_string(), IFACE_MEMORY_OPERATION));

    if (!ibus_) {

        RISCV_error("Bus interface '%s' not found",

                    bus_.to_string());

        return;

    }

    itransport_ = static_cast<ILink *>(

        RISCV_get_service_iface(transport_.to_string(), IFACE_LINK));

    if (!itransport_) {

        RISCV_error("UDP interface '%s' not found",

                    bus_.to_string());

        return;

    }

    AttributeType clks;

    RISCV_get_clock_services(&clks);

    if (clks.size()) {

        iclk0_ = static_cast<IClock *>(clks[0u].to_iface());

    } else {

        RISCV_error("CPUs not found", NULL);

    }

    // Get global settings:

    const AttributeType *glb = RISCV_get_global_settings();

    if ((*glb)["SimEnable"].to_bool()) {

        if (!run()) {

            RISCV_error("Can't create thread.", NULL);

            return;

        }

    }

}

void Greth::busyLoop() {

    int bytes;

    uint8_t *tbuf;

    uint32_t bytes_to_read;

    UdpEdclCommonType req;

    RISCV_info("Ethernet thread was started", NULL);

    trans_.source_idx = sysBusMasterID_.to_int();

    while (isEnabled()) {

        bytes =

            itransport_->readData(rxbuf_, static_cast<int>(sizeof(rxbuf_)));

        if (bytes == 0) {

            continue;

        }

        req.control.word = read32(&rxbuf_[2]);

        req.address      = read32(&rxbuf_[6]);

        if (seq_cnt_ != req.control.request.seqidx) {

            sendNAK(&req);

            continue;

        }

        trans_.addr = req.address;

        if (req.control.request.write == 0) {

            trans_.action = MemAction_Read;

            trans_.wstrb = 0;

            tbuf = &txbuf_[10];

            bytes = sizeof(UdpEdclCommonType) + req.control.request.len;

        } else {

            trans_.action = MemAction_Write;

            tbuf = &rxbuf_[10];

            bytes = sizeof(UdpEdclCommonType);

        }

        bytes_to_read = req.control.request.len;

        while (bytes_to_read) {

            trans_.xsize = bytes_to_read;

            if (trans_.xsize > 8) {

                trans_.xsize = 8;

            }

            if (trans_.action == MemAction_Write) {

                memcpy(trans_.wpayload.b8, tbuf, trans_.xsize);

                trans_.wstrb = (1 << trans_.xsize) - 1;

            }

            RISCV_event_clear(&event_tap_);

            ibus_->nb_transport(&trans_, this);

            if (RISCV_event_wait_ms(&event_tap_, 500) != 0) {

                RISCV_error("CPU queue callback timeout", NULL);

            } else if (trans_.action == MemAction_Read) {

                memcpy(tbuf, trans_.rpayload.b8, trans_.xsize);

            }

            tbuf += trans_.xsize;

            trans_.addr += trans_.xsize;

            bytes_to_read -= trans_.xsize;

        }

        req.control.response.nak = 0;

        req.control.response.seqidx = seq_cnt_;

        write32(&txbuf_[2], req.control.word);

        seq_cnt_++;

        itransport_->sendData(txbuf_, bytes);

    }

}

void Greth::nb_response(Axi4TransactionType *trans) {

    RISCV_event_set(&event_tap_);

}

ETransStatus Greth::b_transport(Axi4TransactionType *trans) {

    RISCV_error("ETH Slave registers not implemented", NULL);

    return TRANS_OK;

}

void Greth::sendNAK(UdpEdclCommonType *req) {

    req->control.response.nak = 1;

    req->control.response.seqidx = seq_cnt_;

    req->control.response.len = 0;

    write32(&txbuf_[2], req->control.word);

    write32(&txbuf_[6], req->address);

    itransport_->sendData(txbuf_, sizeof(UdpEdclCommonType));

}

uint32_t Greth::read32(uint8_t *buf) {

    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | (buf[3] << 0);

}

void Greth::write32(uint8_t *buf, uint32_t v) {

    buf[0] = static_cast<char>((v >> 24) & 0xFF);

    buf[1] = static_cast<char>((v >> 16) & 0xFF);

    buf[2] = static_cast<char>((v >> 8) & 0xFF);

    buf[3] = static_cast<char>(v & 0xFF);

}

}  // namespace debugger