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.
 */
 
#include <api_core.h>
#include "iotypes.h"
 
namespace debugger {
 
IOReg8Type::IOReg8Type(IService *parent, const char *name,
                  uint16_t addr, uint16_t len, int priority) {
    if (parent == NULL) {
    } else {
        parent->registerPortInterface(name,
                static_cast<IMemoryOperation *>(this));
        parent->registerPortInterface(name, static_cast<IIOPort *>(this));
        parent->registerPortInterface(name,
                static_cast<IResetListener *>(this));
    }
    parent_ = parent;
    portListeners_.make_list(0);
    regname_.make_string(name);
    baseAddress_.make_uint64(addr);
    length_.make_uint64(len);
    priority_.make_int64(priority);
    value.byte = 0;
    hard_reset_value_ = 0;
}
 
IFace *IOReg8Type::getInterface(const char *name) {
    if (strcmp(name, IFACE_MEMORY_OPERATION) == 0) {
        return static_cast<IMemoryOperation *>(this);
    }
    return parent_->getInterface(name);
}
 
void IOReg8Type::reset(bool active) {
    if (!active) {
        return;
    }
    write(hard_reset_value_);
}
 
ETransStatus IOReg8Type::b_transport(Axi4TransactionType *trans) {
    uint16_t addr = static_cast<uint16_t>(trans->addr);
    if (trans->action == MemAction_Read) {
        trans->rpayload.b8[0] = read();
        RISCV_debug("Read %s [%02x] => %02x",
                    regName(), addr, trans->rpayload.b8[0]);
    } else {
        write(trans->wpayload.b8[0]);
        RISCV_debug("Write %s [%02x] <= %02x",
                    regName(), addr, trans->wpayload.b8[0]);
    }
    return TRANS_OK;
}
 
uint8_t IOReg8Type::read() {
    IIOPortListener *lstn;
    uint8_t odata = value.byte;
    for (unsigned i = 0; i < portListeners_.size(); i++) {
        lstn = static_cast<IIOPortListener *>(portListeners_[i].to_iface());
        lstn->readData(&odata, get_direction());
    }
    return odata;
}
 
void IOReg8Type::write(uint8_t data) {
    IIOPortListener *lstn;
    value.byte = data;
    for (unsigned i = 0; i < portListeners_.size(); i++) {
        lstn = static_cast<IIOPortListener *>(portListeners_[i].to_iface());
        lstn->writeData(data, get_direction());
    }
    for (unsigned i = 0; i < portListeners_.size(); i++) {
        lstn = static_cast<IIOPortListener *>(portListeners_[i].to_iface());
        lstn->latch();
    }
}
 
void IOReg8Type::registerPortListener(IFace *listener) {
    AttributeType item;
    item.make_iface(listener);
    portListeners_.add_to_list(&item);
}
 
void IOReg8Type::unregisterPortListener(IFace *listener) {
    for (unsigned i = 0; i < portListeners_.size(); i++) {
        if (listener == portListeners_[i].to_iface()) {
            portListeners_.remove_from_list(i);
            break;
        }
    }
}
 
/** */
IOPinType::IOPinType(IService *parent, const char *name) : parent_(parent) {
    pinName_.make_string(name);
    iwire_ = 0;
    value_ = 0;
    bitIdx_ = 0;
    access_ = 0;
 
    char tstr[256];
    RISCV_sprintf(tstr, sizeof(tstr), "pin_%s", name);
    parent_->registerAttribute(tstr, &IOPinTypeCfg_);
}
 
// Memory access use direction xDD register value (IN/OUT)
void IOPinType::readData(uint8_t *val, uint8_t mask) {
    uint8_t v;
    if (iwire_ && (access_ & READ_MASK)) {
        v = iwire_->getLevel();
    } else {
        v = aboutToRead(value_);
    }
    *val &= ~(1 << bitIdx_);
    *val |= (v << bitIdx_);
}
 
void IOPinType::writeData(uint8_t val, uint8_t mask) {
    prelatch_ = (val >> bitIdx_) & 0x1;
    if (iwire_ && (access_ & WRITE_MASK) && (mask & (1u << bitIdx_))) {
        iwire_->setLevel(prelatch_ == 0 ? false : true);
    } else {
        aboutToWrite(value_, prelatch_);
    }
}
 
// Direct access to wire doesn't use Direction xDD mask register
uint8_t IOPinType::get_bit() {
    if (iwire_ && (access_ & READ_MASK)) {
        return iwire_->getLevel() ? 1u : 0;
    }
    return value_;
}
 
void IOPinType::set_bit(uint8_t v) {
    if (iwire_ && (access_ & WRITE_MASK)) {
        iwire_->setLevel(v == 0 ? false : true);
    }
    prelatch_ = v;
    value_ = prelatch_;
}
 
 
void IOPinType::latch() {
    value_ = prelatch_;
}
 
void IOPinType::postinit() {
    connectToBit(IOPinTypeCfg_);
    if (IOPinTypeCfg_.size() >= 3) {
        connectToWire(IOPinTypeCfg_[2]);
    }
}
 
void IOPinType::connectToBit(const AttributeType &cfg) {
    if (!cfg.is_list() || cfg.size() < 2) {
        RISCV_printf(NULL, LOG_ERROR,
            "Cannot connect IOPinType %s: Wrong format of port attribute",
            pinName_.to_string());
        return;
    }
    IIOPort *iport = 0;
    if (cfg[0u].is_string()) {
        iport = static_cast<IIOPort *>(RISCV_get_service_iface(
                cfg[0u].to_string(), IFACE_IOPORT));
    } else if (cfg[0u].is_list()) {
        const AttributeType &prt = cfg[0u];
        iport = static_cast<IIOPort *>(RISCV_get_service_port_iface(
                prt[0u].to_string(), prt[1].to_string(), IFACE_IOPORT));
    }
    bitIdx_ = cfg[1].to_int();
 
    if (iport == 0) {
        RISCV_printf(NULL, LOG_ERROR,
            "Cannot connect IOPinType: Can't get port interface %s",
             cfg[0u].to_string());
        return;
    }
    iport->registerPortListener(static_cast<IIOPortListener *>(this));
}
 
void IOPinType::connectToWire(const AttributeType &cfg) {
    if (!cfg.is_list() || cfg.size() < 2) {
        RISCV_printf(NULL, LOG_ERROR,
            "[%s] Cannot connect IWire input: wrong attribute",
            pinName_.to_string());
        return;
    }
    const char *rw;
    if (cfg.size() == 2) {
        iwire_ = static_cast<IWire *>(RISCV_get_service_iface(
                cfg[0u].to_string(), IFACE_WIRE));
        rw = cfg[1].to_string();
    } else {
        iwire_ = static_cast<IWire *>(RISCV_get_service_port_iface(
                cfg[0u].to_string(), cfg[1].to_string(), IFACE_WIRE));
        rw = cfg[2].to_string();
    }
    if (!iwire_) {
        RISCV_printf(NULL, LOG_ERROR,
            "[%s] Cannot find IWire interface in %s",
            pinName_.to_string(), cfg[0u].to_string());
        return;
    }
 
    access_ = 0;
    if (strstr(rw, "r")) {
        access_ |= READ_MASK;
        prelatch_ = iwire_->getLevel();
        value_ = prelatch_;
    }
    if (strstr(rw, "w")) {
        access_ |= WRITE_MASK;
    }
}
 
}  // namespace debugger