QxtrmInterface.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "QxtrmInterface.h"
#include "icputils.h"

QxtrmInterface::QxtrmInterface(DAEstatus& dstatus, uint32_t* dau_memory, uint32_t nwords_memory, uint32_t* dau_registers, uint32_t nwords_registers) 
        : ISISVME(), m_init_done(false), m_device(""), m_trigger_func(NULL), m_trigger_func_arg(NULL), m_qxtrm(NULL), 
        m_dau_memory(dau_memory), m_nwords_memory(nwords_memory), m_dau_registers(dau_registers), m_nwords_registers(nwords_registers)
{
        InitializeCriticalSection(&m_visa_critical);
        setLoggerName("QxtrmInterface");
        reinit(dstatus);
}

bool QxtrmInterface::initOK()
{
        return m_init_done;
}


int QxtrmInterface::reinit(DAEstatus& dstatus)
{
        ICPCritical cs(&m_visa_critical);
        m_init_done = false;
        LOGSTR_INFORMATION("Calling QxtrmInterface::reinit()");
        close(dstatus);

        std::string app_dir = Poco::Util::Application::instance().config().getString("application.dir");
                std::string config_file = app_dir + "..\\..\\..\\qxtrm_config.xml";
                if ( access(config_file.c_str(), 04) == -1 )
                {
                        config_file = app_dir + "qxtrm_config.xml";
                }
                std::cerr << "Using config file " << config_file << std::endl;
                std::cerr << "Initialising Qxtrm connection ... ";
                if (m_dau_memory == NULL)
                {
                        m_qxtrm = new Qxtrm_driver(config_file, "host", 0, 1, true);
                }
                else
                {
                        m_qxtrm = new Qxtrm_driver(config_file, "host_loopback", 0, 1, true);
                        std::cerr << "Creating channel eth1_RDMA1_loop ... ";
                        Poco::SharedPtr<Qxtrm_channel> rdma_mem_loop = m_qxtrm->createChannel("eth1_RDMA1_loop");
                        std::cerr << "Creating channel eth1_RDMA2_loop ... ";
                        Poco::SharedPtr<Qxtrm_channel> rdma_reg_loop = m_qxtrm->createChannel("eth1_RDMA2_loop");
                        rdma_mem_loop->RDMARegisterMemory(m_dau_memory, m_nwords_memory * 4, 0x0);
                        rdma_reg_loop->RDMARegisterMemory(m_dau_registers, m_nwords_registers * 4, 0x0);
                }
                std::cerr << "DONE" << std::endl;
                std::cerr << "Creating channel eth1_RDMA1 ... ";
                m_rdma_mem = m_qxtrm->createChannel("eth1_RDMA1");
                std::cerr << "DONE" << std::endl;
                std::cerr << "Creating channel eth1_RDMA2 ... ";
                m_rdma_reg = m_qxtrm->createChannel("eth1_RDMA2");
                std::cerr << "DONE" << std::endl;
                // reset interface
//              m_rdma_reg->RDMAWrite(1, 0x00030010);
//              m_rdma_reg->RDMAWrite(1, 0x00030014);
//              m_rdma_reg->RDMAWrite(1, 0x00030018);
//              m_rdma_reg->RDMAWrite(1, 0x0003001C);
                m_qxtrm->channelStatus(std::cerr);
                m_qxtrm->channelTransferStats(std::cerr);


                m_init_done = true;
        if (m_device != "")
        {
                open(m_device.c_str(), dstatus);
        }
        return ISISVME::Success;
}



int QxtrmInterface::open(const char* device, DAEstatus& dstatus)
{
        ICPCritical cs(&m_visa_critical);
        std::ostringstream message;
        m_device = device;
        return ISISVME::Success;
}

int QxtrmInterface::lockDevice(int timeout, DAEstatus& dstatus)
{
        return ISISVME::Success;
}

int QxtrmInterface::unlockDevice(DAEstatus& dstatus)
{
        return ISISVME::Success;
}

template <typename F, typename T>
int QxtrmInterface::retrySingle(F pFunc, unsigned long address, T data, TransferProps props, DAEstatus& dstatus)
{
        int current_sev = dstatus.severity();
        int i, stat = ISISVME::Error;
        for(i=0; i<m_tries; i++)
        {
                if (i > 0)
                {
                        Sleep(m_retry_time);
                        dstatus.resetSeverityToAtMost(SEV_WARNING);
                        if (i > 2)
                        {
                                LOGSTR_WARNING("retrySingle: address 0x" << std::hex << address << std::dec);
                                reinit(dstatus);
                        }
                }
                stat = (this->*pFunc)(address, data, props, dstatus);
                if (stat == ISISVME::Success)
                        break;
        }
        if ( !(dstatus >= current_sev) )
        {
                dstatus.resetSeverityToAtLeast(current_sev);
        }
        return stat;
}

template <typename F, typename T>
int QxtrmInterface::retryBlock(F pFunc, unsigned long address, T data, long nitems, TransferProps props, DAEstatus& dstatus)
{
        int i, stat = ISISVME::Error;
        int current_sev = dstatus.severity();
        for(i=0; i<m_tries; i++)
        {
                if (i > 0)
                {
                        Sleep(m_retry_time);
                        dstatus.resetSeverityToAtMost(SEV_WARNING);
                        if (i > 2)
                        {
                                LOGSTR_WARNING("retryBlock: " << nitems << " items from address 0x" << std::hex << address << std::dec);
                                reinit(dstatus);
                        }
                }
                stat = (this->*pFunc)(address, data, nitems, props, dstatus);
                if (stat == ISISVME::Success)
                        break;
        }
        if ( !(dstatus >= current_sev) )
        {
                dstatus.resetSeverityToAtLeast(current_sev);
        }
        return stat;
}

int QxtrmInterface::readU16(unsigned long address, isisU16_t* data16, TransferProps props, DAEstatus& dstatus)
{
        return retrySingle(&QxtrmInterface::readU16impl, address, data16, props, dstatus);
}

int QxtrmInterface::readU16noRetry(unsigned long address, isisU16_t* data16, TransferProps props, DAEstatus& dstatus)
{
        return readU16impl(address, data16, props, dstatus);
}

template <typename T>
int QxtrmInterface::readUimpl(unsigned long address, T* data, int nitems, TransferProps props, DAEstatus& dstatus)
{
        ICPCritical cs(&m_visa_critical);   // just for safety - visa should be threadsafe
        int stat = ISISVME::Success;
        try
        {
                if (props & ISISVME::TransferIORegisterSpace)
                {
                        m_rdma_reg->RDMARead(data, nitems * sizeof(T), address);
                }
                else
                {
                        m_rdma_mem->RDMARead(data, nitems * sizeof(T), address);
                }
        }
        catch(const std::exception& ex)
        {
                dstatus.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, ex.what());
                stat = ISISVME::Error;
        }
        return stat;
}

int QxtrmInterface::readU16impl(unsigned long address, isisU16_t* data16, TransferProps props, DAEstatus& dstatus)
{
        return readUimpl(address, data16, 1, props, dstatus);
}

int QxtrmInterface::readU32(unsigned long address, isisU32_t* data32, TransferProps props, DAEstatus& dstatus)
{
        return retrySingle(&QxtrmInterface::readU32impl, address, data32, props, dstatus);
}

int QxtrmInterface::readU32noRetry(unsigned long address, isisU32_t* data32, TransferProps props, DAEstatus& dstatus)
{
        return readU32impl(address, data32, props, dstatus);
}

int QxtrmInterface::readU32impl(unsigned long address, isisU32_t* data32, TransferProps props, DAEstatus& dstatus)
{
        return readUimpl(address, data32, 1, props, dstatus);
}

int QxtrmInterface::readBlockU16(unsigned long address, isisU16_t* data16, 
                                                 long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&QxtrmInterface::readBlockU16impl, address, data16, nitems, props, dstatus);
}

// nove nitems of 2 bytes
// need to check the use of nitems_max in particular is address increment 2*n or 4*n?
int QxtrmInterface::readBlockU16impl(unsigned long address, isisU16_t* data16, 
                                                 long nitems, TransferProps props, DAEstatus& dstatus)
{
        return readUimpl(address, data16, nitems, props, dstatus);
}

int QxtrmInterface::readBlockU32(unsigned long address, isisU32_t* data32, 
                                                 long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&QxtrmInterface::readBlockU32impl, address, data32, nitems, props, dstatus);
}

// nove nitems of 4 bytes
int QxtrmInterface::readBlockU32impl(unsigned long address, isisU32_t* data32, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return readUimpl(address, data32, nitems, props, dstatus);
}

int QxtrmInterface::writeU16(unsigned long address, isisU16_t data16, TransferProps props, DAEstatus& dstatus)
{
        return retrySingle(&QxtrmInterface::writeU16impl, address, data16, props, dstatus);
}

template <typename T>
int QxtrmInterface::writeUimpl(unsigned long address, T* data, int nitems, TransferProps props, DAEstatus& dstatus)
{
        ICPCritical cs(&m_visa_critical);   // just for safety - visa should be threadsafe
        int stat = ISISVME::Success;
        try
        {
                if (props & ISISVME::TransferIORegisterSpace)
                {
                        m_rdma_reg->RDMAWrite(data, nitems * sizeof(T), address);
                }
                else
                {
                        m_rdma_mem->RDMAWrite(data, nitems * sizeof(T), address);
                }
        }
        catch(const std::exception& ex)
        {
                dstatus.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, ex.what());
                stat = ISISVME::Error;
        }
        return stat;
}

int QxtrmInterface::writeU16impl(unsigned long address, isisU16_t data16, TransferProps props, DAEstatus& dstatus)
{
        return writeUimpl(address, &data16, 1, props, dstatus);
}

int QxtrmInterface::writeU32(unsigned long address, isisU32_t data32, TransferProps props, DAEstatus& dstatus)
{
        return retrySingle(&QxtrmInterface::writeU32impl, address, data32, props, dstatus);
}

int QxtrmInterface::writeU32impl(unsigned long address, isisU32_t data32, TransferProps props, DAEstatus& dstatus)
{
        return writeUimpl(address, &data32, 1, props, dstatus);
}


int QxtrmInterface::writeBlockU16(unsigned long address, isisU16_t* data16, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&QxtrmInterface::writeBlockU16impl, address, data16, nitems, props, dstatus);
}


// nove nitems of 2 bytes
// need to check the use of nitems_max in particular is address increment 2*n or 4*n?
int QxtrmInterface::writeBlockU16impl(unsigned long address, isisU16_t* data16, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return writeUimpl(address, data16, nitems, props, dstatus);
}


int QxtrmInterface::writeBlockU32(unsigned long address, isisU32_t* data32, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&QxtrmInterface::writeBlockU32impl, address, data32, nitems, props, dstatus);
}

// nove nitems of 4 bytes
int QxtrmInterface::writeBlockU32impl(unsigned long address, isisU32_t* data32, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return writeUimpl(address, data32, nitems, props, dstatus);
}

int QxtrmInterface::writeBlockU64(unsigned long address, uint64_t* data64, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&QxtrmInterface::writeBlockU64impl, address, data64, nitems, props, dstatus);
}

int QxtrmInterface::writeBlockU64impl(unsigned long address, uint64_t* data64, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return writeBlockU32impl(address, reinterpret_cast<isisU32_t*>(data64), 2 * nitems, props, dstatus);
}

int QxtrmInterface::readBlockU64(unsigned long address, uint64_t* data64, 
                                                 long nitems, TransferProps props, DAEstatus& dstatus)
{
        return retryBlock(&QxtrmInterface::readBlockU64impl, address, data64, nitems, props, dstatus);
}

int QxtrmInterface::readBlockU64impl(unsigned long address, uint64_t* data64, long nitems, TransferProps props, DAEstatus& dstatus)
{
        return readBlockU32impl(address, reinterpret_cast<isisU32_t*>(data64), 2 * nitems, props, dstatus); 
}

int QxtrmInterface::writeBlock(unsigned long address, isisU32_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return writeBlockU32(address, data, nitems, props, status);
}

int QxtrmInterface::writeBlock(unsigned long address, uint64_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return writeBlockU64(address, data, nitems, props, status);
}

int QxtrmInterface::readBlock(unsigned long address, isisU32_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return readBlockU32(address, data, nitems, props, status);
}

int QxtrmInterface::readBlock(unsigned long address, uint64_t* data, long nitems, TransferProps props, DAEstatus& status)
{
        return readBlockU64(address, data, nitems, props, status);
}

int QxtrmInterface::close(DAEstatus& dstatus)
{
        ICPCritical cs(&m_visa_critical);
        unlockDevice(dstatus);
        m_rdma_mem = NULL;
        m_rdma_reg = NULL;
        if (m_qxtrm != NULL)
        {
                delete m_qxtrm;
                m_qxtrm = NULL;
        }
        m_init_done = false;
        return ISISVME::Success;
}



QxtrmInterface::~QxtrmInterface()
{
        DAEstatus dstatus;
    close(dstatus);
        DeleteCriticalSection(&m_visa_critical);
}

const int QxtrmInterface::m_tries = 5;
const int QxtrmInterface::m_retry_time = 1000;