Subversion Repositories riscv_vhdl

/**
 * @file
 * @copyright  Copyright 2016 GNSS Sensor Ltd. All right reserved.
 * @author     Sergey Khabarov - sergeykhbr@gmail.com
 * @brief      GUI for the RISC-V debugger.
 */
 
#include "api_core.h"
#include "gui_plugin.h"
#include "coreservices/iserial.h"
#include "coreservices/irawlistener.h"
#include <string>
#include <QtWidgets/QApplication>
 
namespace debugger {
 
void GuiPlugin::UiThreadType::busyLoop() {
    int argc = 0;
    char *argv[] = {0};
 
    // Only one instance of QApplication is possible that is accessible
    // via global pointer qApp for all widgets.
    if (!qApp) {
        // Creating GUI thread
        QApplication app(argc, argv);
        app.setQuitOnLastWindowClosed(true);
 
        mainWindow_ = new DbgMainWindow(igui_, eventInitDone_);
        mainWindow_->show();
 
        // Start its'own event thread
        app.exec();
        QMainWindow *t = mainWindow_;
        mainWindow_ = 0;
        delete t;
    }
    threadInit_.Handle = 0;
    RISCV_break_simulation();
}
 
GuiPlugin::GuiPlugin(const char *name) 
    : IService(name), IHap(HAP_ConfigDone) {
    registerInterface(static_cast<IGui *>(this));
    registerInterface(static_cast<IThread *>(this));
    registerInterface(static_cast<IHap *>(this));
    registerAttribute("WidgetsConfig", &guiConfig_);
    registerAttribute("SocInfo", &socInfo_);
    registerAttribute("CommandExecutor", &cmdExecutor_);
 
    guiConfig_.make_dict();
    socInfo_.make_string("");
    cmdExecutor_.make_string("");
 
    char coredir[4096];
    RISCV_get_core_folder(coredir, sizeof(coredir));
    QString topDir(coredir);
    QResource::registerResource(
        topDir + "resources/gui.rcc");
 
    info_ = 0;
    ui_ = NULL;
    RISCV_event_create(&eventUiInitDone_, "eventUiInitDone_");
    RISCV_event_create(&eventCommandAvailable_, "eventCommandAvailable_");
    RISCV_event_create(&config_done_, "eventGuiGonfigGone");
    RISCV_register_hap(static_cast<IHap *>(this));
    RISCV_mutex_init(&mutexCommand_);
 
    cmdQueueWrPos_ = 0;
    cmdQueueRdPos_ = 0;
    cmdQueueCntTotal_ = 0;
 
    // Adding path to platform libraries:
    char core_path[1024];
    RISCV_get_core_folder(core_path, sizeof(core_path));
    QStringList paths = QApplication::libraryPaths();
    std::string qt_path = std::string(core_path);
    std::string qt_lib_path = qt_path;
    paths.append(QString(qt_lib_path.c_str()));
    qt_lib_path += "qtlib/";
    paths.append(QString(qt_lib_path.c_str()));
    qt_lib_path += "platforms";
    paths.append(QString(qt_lib_path.c_str()));
 
    paths.append(QString("platforms"));
    QApplication::setLibraryPaths(paths);
 
    ui_ = new UiThreadType(static_cast<IGui *>(this),
                            &eventUiInitDone_);
    ui_->run();
}
 
GuiPlugin::~GuiPlugin() {
    if (ui_) {
        delete ui_;
    }
    RISCV_event_close(&config_done_);
    RISCV_event_close(&eventUiInitDone_);
    RISCV_event_close(&eventCommandAvailable_);
    RISCV_mutex_destroy(&mutexCommand_);
}
 
void GuiPlugin::initService(const AttributeType *args) {
    IService::initService(args);
    RISCV_event_wait(&eventUiInitDone_);
}
 
void GuiPlugin::postinitService() {
    iexec_ = static_cast<ICmdExecutor *>(
        RISCV_get_service_iface(cmdExecutor_.to_string(), IFACE_CMD_EXECUTOR));
    if (!iexec_) {
        RISCV_error("ICmdExecutor interface of %s not found.", 
                    cmdExecutor_.to_string());
    }
 
    info_ = static_cast<ISocInfo *>(
        RISCV_get_service_iface(socInfo_.to_string(), IFACE_SOC_INFO));
    if (!iexec_) {
        RISCV_error("ISocInfo interface of %s not found.", 
                    socInfo_.to_string());
    }
 
    if (ui_->mainWindow()) {
        ui_->mainWindow()->postInit(&guiConfig_);
    }
    run();
}
 
IFace *GuiPlugin::getSocInfo() {
    return info_;
}
 
void GuiPlugin::getWidgetsAttribute(const char *name, AttributeType *out) {
    out->make_nil();
    if (guiConfig_.has_key(name)) {
        *out = guiConfig_[name];
    }   
}
 
void GuiPlugin::registerCommand(IGuiCmdHandler *src,
                                AttributeType *cmd,
                                bool silent) {
 
    if (cmdQueueCntTotal_ >= CMD_QUEUE_SIZE) {
        RISCV_error("Command queue size %d overflow. Target not responding",
                    cmdQueueCntTotal_);
        return;
    }
    //RISCV_info("CMD %s", cmd->to_string());
    if (cmdQueueWrPos_ == CMD_QUEUE_SIZE) {
        cmdQueueWrPos_ = 0;
    }
    RISCV_mutex_lock(&mutexCommand_);
    cmdQueue_[cmdQueueWrPos_].silent = silent;
    cmdQueue_[cmdQueueWrPos_].src = src;
    cmdQueue_[cmdQueueWrPos_++].cmd = *cmd;
    cmdQueueCntTotal_++;
    RISCV_mutex_unlock(&mutexCommand_);
    RISCV_event_set(&eventCommandAvailable_);
}
 
void GuiPlugin::removeFromQueue(IFace *iface) {
    RISCV_mutex_lock(&mutexCommand_);
    for (unsigned i = 0; i < CMD_QUEUE_SIZE; i++) {
        if (iface == cmdQueue_[i].src) {
            cmdQueue_[i].src = NULL;
        }
    }
    RISCV_mutex_unlock(&mutexCommand_);
}
 
void GuiPlugin::hapTriggered(IFace *isrc, EHapType type, 
                                  const char *descr) {
    RISCV_event_set(&config_done_);
}
 
void GuiPlugin::busyLoop() {
    RISCV_event_wait(&config_done_);
 
    while (isEnabled()) {
        if (RISCV_event_wait_ms(&eventCommandAvailable_, 500)) {
            RISCV_event_clear(&eventCommandAvailable_);
            continue;
        }
 
        processCmdQueue();
    }
}
 
bool GuiPlugin::processCmdQueue() {
    AttributeType resp;
    while (cmdQueueCntTotal_ > 0) {
        AttributeType &cmd = cmdQueue_[cmdQueueRdPos_].cmd;
 
        iexec_->exec(cmd.to_string(), &resp, cmdQueue_[cmdQueueRdPos_].silent);
 
        RISCV_mutex_lock(&mutexCommand_);
        if (cmdQueue_[cmdQueueRdPos_].src) {
            cmdQueue_[cmdQueueRdPos_].src->handleResponse(
                        const_cast<AttributeType *>(&cmd), &resp);
        }
        if ((++cmdQueueRdPos_) >= CMD_QUEUE_SIZE) {
            cmdQueueRdPos_ = 0;
        }
        cmdQueueCntTotal_--;
        RISCV_mutex_unlock(&mutexCommand_);
    }
    return false;
}
 
void GuiPlugin::stop() {
    if (ui_->mainWindow()) {
        ui_->mainWindow()->callExit();
    }
    ui_->stop();
    IThread::stop();
}
 
extern "C" void plugin_init(void) {
    REGISTER_CLASS(GuiPlugin);
}
 
}  // namespace debugger