plx/Plx/src/Wrapper/PlxWrapper.cpp

#include <QDebug>
#include <QVector>

#include "include/Wrapper/PlxWrapper.h"

PlxWrapper::PlxWrapper()
{
}

/*************************************************************************************************/
bool PlxWrapper::deviceInit(quint32 devicekey)
{
    return PlxPci_9054_SelDevice(devicekey);
}

/*************************************************************************************************/
bool PlxWrapper::deviceOpen()
{
    return PlxPci_9054_Open();
}

/*************************************************************************************************/

bool PlxWrapper::deviceClose()
{
    return PlxPci_9054_Close();
}

/*************************************************************************************************/
bool PlxWrapper::deviceReset()
{
    return PlxPci_9054_Reset();
}

/*************************************************************************************************/
bool PlxWrapper::deviceLoadE2pToFPGA()
{
    return PlxPci_9054_LoadE2pToFPGA();
}

/*************************************************************************************************/
bool PlxWrapper::deviceReadEeprom(quint16 offset, quint32 length, QVector<quint32>& data)
{
    bool ret = true;
    data.clear();

    for(auto i = 0U; i < (length - 1) * 4; i += 4)
    {
        quint32 temp;
        ret &= PlxPci_9054_ReadEep(offset + i, &temp);
        data.append(temp);
    }

    return ret;
}

/*************************************************************************************************/
bool PlxWrapper::deviceWriteEeprom(quint16 offset, quint32 data)
{
    return PlxPci_9054_WriteEep(offset, data);
}

/*************************************************************************************************/
bool PlxWrapper::deviceReadRegister(quint32 address, QVector<quint32>& data, quint32 length)
{
    bool ret = true;
    data.clear();

    quint32 temp[length];
    ret &= PlxPci_9054_ReadBar(address, &temp, length * 4);
    if(ret == true)
    {
        for(auto i = 0U; i < length; i++)
        {
            data.append(temp[i]);
        }
    }

    return ret;
}

/*************************************************************************************************/
bool PlxWrapper::deviceReadRegister(quint32 address, quint32& data)
{
    return PlxPci_9054_ReadBar(address, &data, 4);
}

/*************************************************************************************************/
bool PlxWrapper::deviceWriteRegister(quint32 address, QVector<quint32>& data)
{
    bool ret = true;
    auto length = data.length();
    quint32 temp[length];

    for(auto i = 0U; i < length; i++)
        temp[i] = data.at(i);

    ret &= PlxPci_9054_WriteBar(address, &temp, length * 4);

    return ret;
}

/*************************************************************************************************/
bool PlxWrapper::deviceWriteRegister(quint32 address, quint32 data)
{
    return PlxPci_9054_WriteBar(address, &data, 4);
}

/*************************************************************************************************/
bool PlxWrapper::deviceReadMemory(quint32 localAddress, QVector<quint32>& data, quint32 length)
{
    bool ret = true;
    data.clear();

    quint32 temp[length];
    ret &= PlxPci_9054_DMATransfer(localAddress, &temp, (quint32)(length * 4));

    for(auto i = 0U; i < length; i++)
        data.append(temp[i]);

    return ret;
}

/*************************************************************************************************/
bool PlxWrapper::deviceOpenPCIChannel(void)
{
    return PlxPci_9054_DMAChannelOpen();
}

/*************************************************************************************************/
bool PlxWrapper::deviceClosePCIChannel(void)
{
    return PlxPci_9054_DMAChannelClose();
}

/*************************************************************************************************/

bool PlxWrapper::deviceEnableInterrupt(void)
{
    return PlxPci_9054_EnableInterrupt();
}

/*************************************************************************************************/
bool PlxWrapper::deviceDisableInterrupt(void)
{
    return PlxPci_9054_DisableInterrupt();
}

/*************************************************************************************************/
bool PlxWrapper::deviceWaitForInterrupt(quint32 timeout)
{
    return PlxPci_9054_WaitForInterrupt(timeout);
}

/*************************************************************************************************/
bool PlxWrapper::deviceGetChipType(quint8 revision, quint16 chipType)
{
    return PlxPci_9054_ChipTypeGet(revision, chipType);
}