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 <iostream>
#include <stdio.h>
#include <string.h>
#include "api_types.h"
#include "api_core.h"
#include "coreservices/iserial.h"
#include "comport.h"
 
 
namespace debugger {
 
/** Class registration in the Core */
REGISTER_CLASS(ComPortService)
 
ComPortService::ComPortService(const char *name) 
    : IService(name) {
    registerInterface(static_cast<IThread *>(this));
    registerInterface(static_cast<ISerial *>(this));
    registerInterface(static_cast<IRawListener *>(this));
    registerAttribute("Enable", &isEnable_);
    registerAttribute("UartSim", &uartSim_);
    registerAttribute("LogFile", &logFile_);
    registerAttribute("ComPortName", &comPortName_);
    registerAttribute("ComPortSpeed", &comPortSpeed_);
 
    isEnable_.make_boolean(true);
    uartSim_.make_string("");
    logFile_.make_string("uart0.log");
    logfile_ = NULL;
    comPortName_.make_string("");
    comPortSpeed_.make_int64(115200);
    portListeners_.make_list(0);
    iuartSim_ = 0;
    portOpened_ = false;
    RISCV_mutex_init(&mutexListeners_);
    prtHandler_ = 0;
}
 
ComPortService::~ComPortService() {
    RISCV_mutex_destroy(&mutexListeners_);
    if (logfile_) {
        fclose(logfile_);
        logfile_ = NULL;
    }
}
 
void ComPortService::postinitService() {
    const AttributeType *glb = RISCV_get_global_settings();
    isSimulation_ = (*glb)["SimEnable"].to_bool();
 
    if (isSimulation_) {
        iuartSim_ = static_cast<ISerial *>(
            RISCV_get_service_iface(uartSim_.to_string(), IFACE_SERIAL));
        if (!iuartSim_) {
            RISCV_error("Can't get serial interface of UART simulator",
                        uartSim_.to_string());
            return;
        } else {
            iuartSim_->registerRawListener(static_cast<IRawListener *>(this));
        }
    }
 
    if (isEnable_.to_bool()) {
        if (!run()) {
            RISCV_error("Can't create thread.", NULL);
            return;
        }
    }
 
    logfile_ = 0;
    if (logFile_.size()) {
        char tst[256];
        RISCV_sprintf(tst, sizeof(tst), "Can't open '%s' file",
                      logFile_.to_string());
        logfile_ = fopen(logFile_.to_string(), "w");
    }
}
 
void ComPortService::predeleteService() {
    if (isSimulation_ && iuartSim_) {
        iuartSim_->unregisterRawListener(static_cast<IRawListener *>(this));
    }
}
 
//#define READ_RAWDATA_FROM_FILE
void ComPortService::busyLoop() {
    char tbuf[4096];
    int tbuf_cnt;
#ifdef READ_RAWDATA_FROM_FILE
    FILE *script = fopen("e:/uart0.log", "r");
    char logbuf[1024];
    int logbuf_sz;
#endif
 
    while (isEnabled()) {
#ifdef READ_RAWDATA_FROM_FILE
        logbuf_sz = fread(logbuf, 1, sizeof(logbuf), script);
        if (logbuf_sz) {
            for (unsigned i = 0; i < portListeners_.size(); i++) {
                IRawListener *ilstn = static_cast<IRawListener *>(
                                portListeners_[i].to_iface());
                ilstn->updateData(logbuf, logbuf_sz);
            }
        } else {
            fseek(script, 0, SEEK_SET);
        }
#endif
        if (!isSimulation_ && !portOpened_) {
            AttributeType settings;
            settings.make_list(4);
            settings[0u].make_int64(comPortSpeed_.to_int());
            int err = openPort(comPortName_.to_string(), settings);
            if (err < 0) {
                RISCV_error("Openning %s at %d . . .failed",
                        comPortName_.to_string(), comPortSpeed_.to_int());
                RISCV_sleep_ms(1000);
                continue;
            } else {
                portOpened_ = true;
            }
        }
        // Sending...
        tbuf_cnt = 0;
        while (!txFifo_.isEmpty()) {
            tbuf[tbuf_cnt++] = txFifo_.get();
        }
        if (tbuf_cnt) {
            if (isSimulation_ && iuartSim_) {
                iuartSim_->writeData(tbuf, tbuf_cnt);
            } else if (!isSimulation_ && prtHandler_) {
                writeSerialPort(&prtHandler_, tbuf, tbuf_cnt);
            }
        }
 
        // Receiveing...
        if (!isSimulation_ && prtHandler_) {
            tbuf_cnt = readSerialPort(&prtHandler_, tbuf,
                                        sizeof(tbuf) - tbuf_cnt);
            if (tbuf_cnt < 0) { 
                closePort();
                portOpened_ = false;
                continue;
            }
        } else if (isSimulation_) {
            tbuf_cnt = 0;
            while (!rxFifo_.isEmpty()
                && tbuf_cnt < static_cast<int>(sizeof(tbuf) - 1)) {
                tbuf[tbuf_cnt++] = rxFifo_.get();
                tbuf[tbuf_cnt] = '\0';
            }
        }
        if (tbuf_cnt) {
            RISCV_mutex_lock(&mutexListeners_);
            for (unsigned i = 0; i < portListeners_.size(); i++) {
                IRawListener *ilstn = static_cast<IRawListener *>(
                                portListeners_[i].to_iface());
                ilstn->updateData(tbuf, tbuf_cnt);
            }
            RISCV_mutex_unlock(&mutexListeners_);
            if (logfile_) {
                fwrite(tbuf, tbuf_cnt, 1, logfile_);
                fflush(logfile_);
            }
        }
 
        RISCV_sleep_ms(50);
    }
}
 
int ComPortService::writeData(const char *buf, int sz) {
    // @todo: mutex
    for (int i = 0; i < sz; i++) {
        txFifo_.put(buf[i]);
    }
    return sz;
}
 
 
void ComPortService::registerRawListener(IFace *iface) {
    AttributeType t1(iface);
    RISCV_mutex_lock(&mutexListeners_);
    portListeners_.add_to_list(&t1);
    RISCV_mutex_unlock(&mutexListeners_);
}
 
void ComPortService::unregisterRawListener(IFace *iface) {
    RISCV_mutex_lock(&mutexListeners_);
    for (unsigned i = 0; i < portListeners_.size(); i++) {
        IFace *itmp = portListeners_[i].to_iface();
        if (itmp == iface) {
            portListeners_.remove_from_list(i);
            break;
        }
    }
    RISCV_mutex_unlock(&mutexListeners_);
}
 
void ComPortService::updateData(const char *buf, int buflen) {
    // Data from UART simulation:
    for (int i = 0; i < buflen; i++) {
        rxFifo_.put(buf[i]);
    }
}
 
}  // namespace debugger