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.
 *
 * Packet format:
 *             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 "uartmst.h"
#include "coreservices/isocinfo.h"
 
namespace debugger {
 
static const uint32_t UART_STATUS_TX_FULL     = 0x00000001;
static const uint32_t UART_STATUS_TX_EMPTY    = 0x00000002;
static const uint32_t UART_STATUS_RX_FULL     = 0x00000010;
static const uint32_t UART_STATUS_RX_EMPTY    = 0x00000020;
static const uint32_t UART_STATUS_ERR_PARITY  = 0x00000100;
static const uint32_t UART_STATUS_ERR_STOPBIT = 0x00000200;
static const uint32_t UART_CONTROL_RX_IRQ_ENA = 0x00002000;
static const uint32_t UART_CONTROL_TX_IRQ_ENA = 0x00004000;
static const uint32_t UART_CONTROL_PARITY_ENA = 0x00008000;
 
 
UartMst::UartMst(const char *name)  : IService(name) {
    registerInterface(static_cast<IThread *>(this));
    registerInterface(static_cast<IAxi4NbResponse *>(this));
    registerInterface(static_cast<ISerial *>(this));
    registerAttribute("Bus", &bus_);
 
    listeners_.make_list(0);
    bus_.make_string("");
 
    RISCV_event_create(&event_tap_, "UartMst_event_tap");
    RISCV_event_create(&event_request_, "UartMst_event_request");
    RISCV_event_create(&event_accept_, "UartMst_event_accept");
    RISCV_mutex_init(&mutexListeners_);
 
    memset(&regs_, 0, sizeof(regs_));
    regs_.status = UART_STATUS_TX_EMPTY | UART_STATUS_RX_EMPTY;
 
    txbuf_sz_ = 0;
    baudrate_detect_ = false;
}
 
UartMst::~UartMst() {
    RISCV_event_close(&event_tap_);
    RISCV_event_close(&event_request_);
    RISCV_event_close(&event_accept_);
    RISCV_mutex_destroy(&mutexListeners_);
}
 
void UartMst::postinitService() {
    ibus_ = static_cast<IMemoryOperation *>(
        RISCV_get_service_iface(bus_.to_string(), IFACE_MEMORY_OPERATION));
    if (!ibus_) {
        RISCV_error("Can't find IBus interface %s", bus_.to_string());
    }
    run();
}
 
void UartMst::busyLoop() {
    UartMstPacketType packet;
    RISCV_info("UartMst thread was started", NULL);
    trans_.source_idx = CFG_NASTI_MASTER_MSTUART;          // Hardcoded in VHDL value
 
    int burst_sz;
    while (isEnabled()) {
        if (RISCV_event_wait_ms(&event_request_, 50) != 0) {
            continue;
        }
        RISCV_event_clear(&event_request_);
        memcpy(&packet, txbuf_.buf, sizeof(packet));
        RISCV_event_set(&event_accept_);
        txbuf_sz_ = 0;
 
        if (!baudrate_detect_) {
            // Symbol 0x55 runs baudrate detector
            if (packet.cmd == 0x55) {
                baudrate_detect_ = true;
            }
            continue;
        }
 
        if ((packet.cmd & 0x80) == 0) {
            RISCV_error("Wrong request format", NULL);
            continue;
        }
 
        trans_.addr = packet.addr.val & 0xFFFFFFFF;
        trans_.xsize = 4;
        if ((packet.cmd & 0x40) == 0) {
            trans_.action = MemAction_Read;
        } else {
            trans_.action = MemAction_Write;
            trans_.wstrb = (1 << trans_.xsize) - 1;
        }
 
        burst_sz = (packet.cmd & 0x3F) + 1;
        for (int i = 0; i < burst_sz; i++) {
            if (trans_.action == MemAction_Write) {
                trans_.wpayload.b32[0] = packet.data[0].buf32[i];
            }
            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) {
                RISCV_mutex_lock(&mutexListeners_);
                for (unsigned n = 0; n < listeners_.size(); n++) {
                    IRawListener *lstn = static_cast<IRawListener *>(
                                        listeners_[n].to_iface());
                    lstn->updateData(
                        reinterpret_cast<char *>(trans_.rpayload.b8),
                        trans_.xsize);
                }
                RISCV_mutex_unlock(&mutexListeners_);
            }
            trans_.addr += 4;
        }
    }
}
 
int UartMst::writeData(const char *buf, int sz) {
    if (sz > static_cast<int>(sizeof(UartMstPacketType))) {
        RISCV_error("Request will be truncated", NULL);
        sz = sizeof(UartMstPacketType);
    }
    memcpy(txbuf_.buf, buf, sz);
    txbuf_sz_ = sz;
    RISCV_event_clear(&event_accept_);
    RISCV_event_set(&event_request_);
    RISCV_event_wait_ms(&event_accept_, 500);
    return sz;
}
 
void UartMst::registerRawListener(IFace *listener) {
    AttributeType lstn(listener);
    RISCV_mutex_lock(&mutexListeners_);
    listeners_.add_to_list(&lstn);
    RISCV_mutex_unlock(&mutexListeners_);
}
 
void UartMst::unregisterRawListener(IFace *listener) {
    RISCV_mutex_lock(&mutexListeners_);
    for (unsigned i = 0; i < listeners_.size(); i++) {
        IFace *iface = listeners_[i].to_iface();
        if (iface == listener) {
            listeners_.remove_from_list(i);
            break;
        }
    }
    RISCV_mutex_unlock(&mutexListeners_);
}
 
void UartMst::getListOfPorts(AttributeType *list) {
    list->make_list(0);
}
 
int UartMst::openPort(const char *port, AttributeType settings) {
    return 0;
}
 
void UartMst::closePort() {
}
 
void UartMst::nb_response(Axi4TransactionType *trans) {
    RISCV_event_set(&event_tap_);
}
 
}  // namespace debugger