/*------------------------------------------------------------------------------
--  This file is a part of the SocExplorer Software
--  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
--
--  This program is free software; you can redistribute it and/or modify
--  it under the terms of the GNU General Public License as published by
--  the Free Software Foundation; either version 3 of the License, or
--  (at your option) any later version.
--
--  This program is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--  GNU General Public License for more details.
--
--  You should have received a copy of the GNU General Public License
--  along with this program; if not, write to the Free Software
--  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-------------------------------------------------------------------------------*/
/*--                  Author : Alexis Jeandet
--                     Mail : alexis.jeandet@member.fsf.org
----------------------------------------------------------------------------*/
#include "fakestardundeespwusb_lib.h"
#include <QDebug>


char  (*resolved_USBSpaceWire_Open)(star_device_handle *phDevice, int nDeviceNum)=NULL;
void  (*resolved_USBSpaceWire_Close)(star_device_handle hDevice)=NULL;
U32   (*resolved_USBSpaceWire_ListDevices)()=NULL;
char  (*resolved_USBSpaceWire_GetSerialNumber)(star_device_handle hDevice, U8 pSerialNumber[11])=NULL;
void  (*resolved_USBSpaceWire_EnableNetworkMode)(star_device_handle hDevice, char enable)=NULL;
char  (*resolved_USBSpaceWire_RegisterReceiveOnAllPorts)(star_device_handle hDevice)=NULL;
char  (*resolved_USBSpaceWire_UnregisterReceiveOnAllPorts)(star_device_handle hDevice)=NULL;
char  (*resolved_USBSpaceWire_ClearEndpoints)(star_device_handle hDevice)=NULL;
void  (*resolved_USBSpaceWire_SetTimeout)(star_device_handle hDevice, double timeout)=NULL;
char  (*resolved_USBSpaceWire_TC_Reset)(star_device_handle hDevice)=NULL;
char  (*resolved_USBSpaceWire_TC_EnableExternalTimecodeSelection)(star_device_handle hDevice,char enable)=NULL;
U32   (*resolved_USBSpaceWire_TC_GetClockFrequency)(star_device_handle hDevice)=NULL;
char  (*resolved_USBSpaceWire_TC_SetAutoTickInFrequency)(star_device_handle hDevice, U32 frequency)=NULL;
char  (*resolved_USBSpaceWire_TC_EnableAutoTickIn)(star_device_handle hDevice, char enableAutoTickIns, char enableAllPorts)=NULL;
char  (*resolved_USBSpaceWire_TC_PerformTickIn)(star_device_handle hDevice, U8 timein)=NULL;
U32   (*resolved_USBSpaceWire_GetDriverSendBufferSize)(star_device_handle hDevice)=NULL;
U32   (*resolved_USBSpaceWire_GetDriverReadBufferSize)(star_device_handle hDevice)=NULL;
char  (*resolved_USBSpaceWire_IsReadThrottling)(star_device_handle hDevice)=NULL;

char  (*resolved_USBSpaceWire_WaitOnReadPacketAvailable)(star_device_handle hDevice, double timeout)=NULL;
USB_SPACEWIRE_STATUS  (*resolved_USBSpaceWire_SendPacket)(star_device_handle hDevice, void *pBuffer, U32 nBufferSize, char bWait,USB_SPACEWIRE_ID *identifier)=NULL;
char  (*resolved_USBSpaceWire_FreeSend)(star_device_handle hDevice, USB_SPACEWIRE_ID identifier)=NULL;
USB_SPACEWIRE_STATUS  (*resolved_USBSpaceWire_ReadPackets)(star_device_handle hDevice, void *pBuffer, U32 nBufferSize,U32 nPacketNum, char bWait, PUSB_SPACEWIRE_PACKET_PROPERTIES properties,USB_SPACEWIRE_ID *identifier)=NULL;
char  (*resolved_USBSpaceWire_FreeRead)(star_device_handle hDevice, USB_SPACEWIRE_ID identifier)=NULL;
SPACEWIRE_TRAFFIC_TYPE 	(*resolved_USBSpaceWire_GetReadTrafficType)(PUSB_SPACEWIRE_PACKET_PROPERTIES pProperties, U32 nPacketNum)=NULL;
USB_SPACEWIRE_EOP_TYPE (*resolved_USBSpaceWire_GetReadEOPStatus)(PUSB_SPACEWIRE_PACKET_PROPERTIES pProperties,U32 nPacketNum)=NULL;

void  (*resolved_CFGSpaceWire_EnableRMAP)(char useRMAP)=NULL;
void  (*resolved_CFGSpaceWire_SetRMAPDestinationKey)(U8 destinationKey)=NULL;
void  (*resolved_CFGSpaceWire_StackClear)(void)=NULL;
void  (*resolved_CFGSpaceWire_AddrStackPush)(U8 dwAddress)=NULL;
void  (*resolved_CFGSpaceWire_RetAddrStackPush)(U8 dwAddress)=NULL;
int   (*resolved_CFGSpaceWire_SetBrickBaseTransmitRate)(star_device_handle hDevice, U32 dwBaseClk, U32 dwBaseDvdr, U32 dwEnableClk)=NULL;
int   (*resolved_CFGSpaceWire_GetLinkStatusControl)(star_device_handle hDevice, U32 dwLinkNum, U32 *dwStatusControl)=NULL;
void  (*resolved_CFGSpaceWire_LSEnableAutoStart)(U32 *dwStatusControl, char bEnabled)=NULL;
void  (*resolved_CFGSpaceWire_LSEnableStart)(U32 *dwStatusControl, char bEnabled)=NULL;
void  (*resolved_CFGSpaceWire_LSEnableDisabled)(U32 *dwStatusControl, char bEnabled)=NULL;
void  (*resolved_CFGSpaceWire_LSEnableTristate)(U32 *dwStatusControl, char bEnabled)=NULL;
void  (*resolved_CFGSpaceWire_LSPortType)(U32 dwStatusControl, U32 *dwPortType)=NULL;
void  (*resolved_CFGSpaceWire_LSSetOperatingSpeed)(U32 *dwStatusControl, U32 dwOperatingSpeed)=NULL;
void  (*resolved_CFGSpaceWire_LSConfigErrorStatus)(U32 dwStatusControl, U32 *dwErrorStatus)=NULL;
void  (*resolved_CFGSpaceWire_LSExternalErrorStatus)(U32 dwStatusControl, U32 *dwErrorStatus)=NULL;
void  (*resolved_CFGSpaceWire_LSErrorStatus)(U32 dwStatusControl, U32 *dwErrorStatus)=NULL;
void  (*resolved_CFGSpaceWire_LSLinkState)(U32 dwStatusControl, U32 *dwLinkStatus)=NULL;
void  (*resolved_CFGSpaceWire_LSIsLinkRunning)(U32 dwStatusControl, char *isLinkRunning)=NULL;
void  (*resolved_CFGSpaceWire_LSIsAutoStart)(U32 dwStatusControl, char *isAutoStart)=NULL;
void  (*resolved_CFGSpaceWire_LSIsStart)(U32 dwStatusControl, char *isStart)=NULL;
void  (*resolved_CFGSpaceWire_LSIsDisabled)(U32 dwStatusControl, char *isDisabled)=NULL;
void  (*resolved_CFGSpaceWire_LSIsTristate)(U32 dwStatusControl, char *isTristate)=NULL;
void  (*resolved_CFGSpaceWire_LSOperatingSpeed)(U32 dwStatusControl, U32 *dwOperatingSpeed)=NULL;
void  (*resolved_CFGSpaceWire_LSOutputPortConnection)(U32 dwStatusControl, U32 *dwOutputPortConnection)=NULL;
int   (*resolved_CFGSpaceWire_SetLinkStatusControl)(star_device_handle hDevice, U32 dwLinkNum, U32 dwStatusControl)=NULL;
int   (*resolved_CFGSpaceWire_SetAsInterface)(star_device_handle hDevice, char bEnabled, char bAddIdentifier)=NULL;
int   (*resolved_CFGSpaceWire_ClearRoutingTableEntry)(star_device_handle hDevice, U32 nLogicalAddress)=NULL;
void  (*resolved_CFGSpaceWire_RTBuildRoutingTableEntry)(U32 *dwRoutingTableEntry,U32 dwOutputPorts, char bDelHead, char bPriority)=NULL;
int   (*resolved_CFGSpaceWire_SetRoutingTableEntry)(star_device_handle hDevice, U32 nLogicalAddress, U32 dwRoutingTableEntry)=NULL;
int   (*resolved_CFGSpaceWire_GetRoutingTableEntry)(star_device_handle hDevice, U32 nLogicalAddress, U32 *dwRoutingTableEntry)=NULL;
void  (*resolved_CFGSpaceWire_RTIsEnabled)(U32 dwRoutingTableEntry, char *bEnabled)=NULL;
void  (*resolved_CFGSpaceWire_RTIsDelHead)(U32 dwRoutingTableEntry, char *bDelHead)=NULL;
void  (*resolved_CFGSpaceWire_RTIsPriority)(U32 dwRoutingTableEntry, char *bPriority)=NULL;
void  (*resolved_CFGSpaceWire_RTGetOutputPorts)(U32 dwRoutingTableEntry, U32 *dwOutputPorts)=NULL;
int   (*resolved_CFGSpaceWire_GetTickEnableStatus)(star_device_handle hDevice, U32 *dwTickEnableStatus)=NULL;
int   (*resolved_CFGSpaceWire_SetTickEnableStatus)(star_device_handle hDevice, U32 dwTickEnableStatus)=NULL;




QList<funcToresolve> funcTable=QList<funcToresolve>()
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_Open,"USBSpaceWire_Open"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_Close,"USBSpaceWire_Close"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_ListDevices,"USBSpaceWire_ListDevices"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_GetSerialNumber,"USBSpaceWire_GetSerialNumber"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_EnableNetworkMode,"USBSpaceWire_EnableNetworkMode"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_RegisterReceiveOnAllPorts,"USBSpaceWire_RegisterReceiveOnAllPorts"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_UnregisterReceiveOnAllPorts,"USBSpaceWire_UnregisterReceiveOnAllPorts"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_ClearEndpoints,"USBSpaceWire_ClearEndpoints"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_SetTimeout,"USBSpaceWire_SetTimeout"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_TC_Reset,"USBSpaceWire_TC_Reset"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_TC_EnableExternalTimecodeSelection,"USBSpaceWire_TC_EnableExternalTimecodeSelection"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_TC_GetClockFrequency,"USBSpaceWire_TC_GetClockFrequency"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_TC_SetAutoTickInFrequency,"USBSpaceWire_TC_SetAutoTickInFrequency"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_TC_EnableAutoTickIn,"USBSpaceWire_TC_EnableAutoTickIn"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_TC_PerformTickIn,"USBSpaceWire_TC_PerformTickIn"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_GetDriverSendBufferSize,"USBSpaceWire_GetDriverSendBufferSize"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_GetDriverReadBufferSize,"USBSpaceWire_GetDriverReadBufferSize"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_IsReadThrottling,"USBSpaceWire_IsReadThrottling"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_WaitOnReadPacketAvailable,"USBSpaceWire_WaitOnReadPacketAvailable"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_SendPacket,"USBSpaceWire_SendPacket"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_FreeSend,"USBSpaceWire_FreeSend"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_ReadPackets,"USBSpaceWire_ReadPackets"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_FreeRead,"USBSpaceWire_FreeRead"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_GetReadTrafficType,"USBSpaceWire_GetReadTrafficType"}
<<funcToresolve{(void (**)())&resolved_USBSpaceWire_GetReadEOPStatus,"USBSpaceWire_GetReadEOPStatus"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_EnableRMAP,"CFGSpaceWire_EnableRMAP"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_SetRMAPDestinationKey,"CFGSpaceWire_SetRMAPDestinationKey"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_StackClear,"CFGSpaceWire_StackClear"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_AddrStackPush,"CFGSpaceWire_AddrStackPush"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_RetAddrStackPush,"CFGSpaceWire_RetAddrStackPush"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_SetBrickBaseTransmitRate,"CFGSpaceWire_SetBrickBaseTransmitRate"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_GetLinkStatusControl,"CFGSpaceWire_GetLinkStatusControl"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSEnableAutoStart,"CFGSpaceWire_LSEnableAutoStart"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSEnableStart,"CFGSpaceWire_LSEnableStart"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSEnableDisabled,"CFGSpaceWire_LSEnableDisabled"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSEnableTristate,"CFGSpaceWire_LSEnableTristate"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSPortType,"CFGSpaceWire_LSPortType"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSSetOperatingSpeed,"CFGSpaceWire_LSSetOperatingSpeed"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSConfigErrorStatus,"CFGSpaceWire_LSConfigErrorStatus"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSExternalErrorStatus,"CFGSpaceWire_LSExternalErrorStatus"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSErrorStatus,"CFGSpaceWire_LSErrorStatus"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSLinkState,"CFGSpaceWire_LSLinkState"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSIsLinkRunning,"CFGSpaceWire_LSIsLinkRunning"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSIsAutoStart,"CFGSpaceWire_LSIsAutoStart"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSIsStart,"CFGSpaceWire_LSIsStart"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSIsDisabled,"CFGSpaceWire_LSIsDisabled"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSIsTristate,"CFGSpaceWire_LSIsTristate"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSOperatingSpeed,"CFGSpaceWire_LSOperatingSpeed"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_LSOutputPortConnection,"CFGSpaceWire_LSOutputPortConnection"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_SetLinkStatusControl,"CFGSpaceWire_SetLinkStatusControl"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_SetAsInterface,"CFGSpaceWire_SetAsInterface"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_ClearRoutingTableEntry,"CFGSpaceWire_ClearRoutingTableEntry"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_RTBuildRoutingTableEntry,"CFGSpaceWire_RTBuildRoutingTableEntry"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_SetRoutingTableEntry,"CFGSpaceWire_SetRoutingTableEntry"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_GetRoutingTableEntry,"CFGSpaceWire_GetRoutingTableEntry"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_RTIsEnabled,"CFGSpaceWire_RTIsEnabled"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_RTIsDelHead,"CFGSpaceWire_RTIsDelHead"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_RTIsPriority,"CFGSpaceWire_RTIsPriority"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_RTGetOutputPorts,"CFGSpaceWire_RTGetOutputPorts"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_GetTickEnableStatus,"CFGSpaceWire_GetTickEnableStatus"}
<<funcToresolve{(void (**)())&resolved_CFGSpaceWire_SetTickEnableStatus,"CFGSpaceWire_SetTickEnableStatus"};



FakeStarDundeeSpwUSB_Lib::FakeStarDundeeSpwUSB_Lib()
{

}

void FakeStarDundeeSpwUSB_Lib::resolve()
{
    QLibrary cfgLib;
    QLibrary usbLib;
    usbLib.setFileName("/home/spacewire/usb/spw_usb_driver_v2.68/lib/x86_64/libSpaceWireUSBAPI.so");
    cfgLib.setFileName("/home/spacewire/usb/spw_usb_driver_v2.68/lib/x86_64/libConfigLibraryUSB.so");
    usbLib.load();
    cfgLib.load();
    if(usbLib.isLoaded()&&cfgLib.isLoaded())
    {
        for(int i=0;i<funcTable.count();i++)
        {
            QString symbolName = funcTable[i].symbolName;
            if(!symbolName.contains("USBSpaceWire_"))
            {
                *(funcTable[i].function) = usbLib.resolve(funcTable[i].symbolName);
                if(*(funcTable[i].function)==NULL)
                    *(funcTable[i].function) = cfgLib.resolve(funcTable[i].symbolName);
            }
            else
            {
                *(funcTable[i].function) = cfgLib.resolve(funcTable[i].symbolName);
                if(*(funcTable[i].function)==NULL)
                    *(funcTable[i].function) = usbLib.resolve(funcTable[i].symbolName);
            }
        }
    }
}

bool FakeStarDundeeSpwUSB_Lib::fullresolved()
{
    bool success=true;
    for(int i=0;i<funcTable.count();i++)
    {
        if(*(funcTable[i].function)==NULL)
            success=false;
    }
    return success;
}

const QList<funcToresolve> &FakeStarDundeeSpwUSB_Lib::status()
{
    return funcTable;
}



char USBSpaceWire_Open(star_device_handle *phDevice, int nDeviceNum)
{
    if(resolved_USBSpaceWire_Open!=NULL)
        return resolved_USBSpaceWire_Open(phDevice, nDeviceNum);
    return 0;
}


void USBSpaceWire_Close(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_Close!=NULL)
        resolved_USBSpaceWire_Close(hDevice);
}


U32 USBSpaceWire_ListDevices()
{
    if(resolved_USBSpaceWire_ListDevices!=NULL)
        return resolved_USBSpaceWire_ListDevices();
    return 0;
}


char USBSpaceWire_GetSerialNumber(star_device_handle hDevice, U8 pSerialNumber[])
{
    if(resolved_USBSpaceWire_GetSerialNumber!=NULL)
        return resolved_USBSpaceWire_GetSerialNumber(hDevice,pSerialNumber);
    return 0;
}


void USBSpaceWire_EnableNetworkMode(star_device_handle hDevice, char enable)
{
    if(resolved_USBSpaceWire_EnableNetworkMode!=NULL)
        resolved_USBSpaceWire_EnableNetworkMode(hDevice,enable);
}


char USBSpaceWire_RegisterReceiveOnAllPorts(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_RegisterReceiveOnAllPorts!=NULL)
        return resolved_USBSpaceWire_RegisterReceiveOnAllPorts(hDevice);
    return 0;
}


char USBSpaceWire_UnregisterReceiveOnAllPorts(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_UnregisterReceiveOnAllPorts!=NULL)
        return resolved_USBSpaceWire_UnregisterReceiveOnAllPorts(hDevice);
    return 0;
}


char USBSpaceWire_ClearEndpoints(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_ClearEndpoints!=NULL)
        return resolved_USBSpaceWire_ClearEndpoints(hDevice);
    return 0;
}


void USBSpaceWire_SetTimeout(star_device_handle hDevice, double timeout)
{
    if(resolved_USBSpaceWire_SetTimeout!=NULL)
        resolved_USBSpaceWire_SetTimeout(hDevice,timeout);
}


char USBSpaceWire_TC_Reset(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_TC_Reset!=NULL)
        return resolved_USBSpaceWire_TC_Reset(hDevice);
    return 0;
}


char USBSpaceWire_TC_EnableExternalTimecodeSelection(star_device_handle hDevice, char enable)
{
    if(resolved_USBSpaceWire_TC_EnableExternalTimecodeSelection!=NULL)
        return resolved_USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,enable);
    return 0;
}


U32 USBSpaceWire_TC_GetClockFrequency(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_TC_GetClockFrequency!=NULL)
        return resolved_USBSpaceWire_TC_GetClockFrequency(hDevice);
    return 0;
}


char USBSpaceWire_TC_SetAutoTickInFrequency(star_device_handle hDevice, U32 frequency)
{
    if(resolved_USBSpaceWire_TC_SetAutoTickInFrequency!=NULL)
        return resolved_USBSpaceWire_TC_SetAutoTickInFrequency(hDevice,frequency);
    return 0;
}


char USBSpaceWire_TC_EnableAutoTickIn(star_device_handle hDevice, char enableAutoTickIns, char enableAllPorts)
{
    if(resolved_USBSpaceWire_TC_EnableAutoTickIn!=NULL)
        return resolved_USBSpaceWire_TC_EnableAutoTickIn(hDevice,enableAutoTickIns,enableAllPorts);
    return 0;
}


char USBSpaceWire_TC_PerformTickIn(star_device_handle hDevice, U8 timein)
{
    if(resolved_USBSpaceWire_TC_PerformTickIn!=NULL)
        return resolved_USBSpaceWire_TC_PerformTickIn(hDevice,timein);
    return 0;
}


U32 USBSpaceWire_GetDriverSendBufferSize(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_GetDriverSendBufferSize!=NULL)
        return resolved_USBSpaceWire_GetDriverSendBufferSize(hDevice);
    return 0;
}


U32 USBSpaceWire_GetDriverReadBufferSize(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_GetDriverReadBufferSize!=NULL)
        return resolved_USBSpaceWire_GetDriverReadBufferSize(hDevice);
    return 0;
}


char USBSpaceWire_IsReadThrottling(star_device_handle hDevice)
{
    if(resolved_USBSpaceWire_IsReadThrottling!=NULL)
        return resolved_USBSpaceWire_IsReadThrottling(hDevice);
    return 0;
}


char USBSpaceWire_WaitOnReadPacketAvailable(star_device_handle hDevice, double timeout)
{
    if(resolved_USBSpaceWire_WaitOnReadPacketAvailable!=NULL)
        return resolved_USBSpaceWire_WaitOnReadPacketAvailable(hDevice,timeout);
    return 0;
}


USB_SPACEWIRE_STATUS USBSpaceWire_SendPacket(star_device_handle hDevice, void *pBuffer, U32 nBufferSize, char bWait, USB_SPACEWIRE_ID *identifier)
{
    if(resolved_USBSpaceWire_SendPacket!=NULL)
        return resolved_USBSpaceWire_SendPacket(hDevice,pBuffer,nBufferSize,bWait,identifier);
    return TRANSFER_ERROR_USB_ERROR;
}


char USBSpaceWire_FreeSend(star_device_handle hDevice, USB_SPACEWIRE_ID identifier)
{
    if(resolved_USBSpaceWire_FreeSend!=NULL)
        return resolved_USBSpaceWire_FreeSend(hDevice,identifier);
    return 0;
}


USB_SPACEWIRE_STATUS USBSpaceWire_ReadPackets(star_device_handle hDevice, void *pBuffer, U32 nBufferSize, U32 nPacketNum, char bWait, PUSB_SPACEWIRE_PACKET_PROPERTIES properties, USB_SPACEWIRE_ID *identifier)
{
    if(resolved_USBSpaceWire_ReadPackets!=NULL)
        return resolved_USBSpaceWire_ReadPackets(hDevice,pBuffer,nBufferSize, nPacketNum,bWait, properties,identifier);
    return TRANSFER_ERROR_USB_ERROR;
}


char USBSpaceWire_FreeRead(star_device_handle hDevice, USB_SPACEWIRE_ID identifier)
{
    if(resolved_USBSpaceWire_FreeRead!=NULL)
        return resolved_USBSpaceWire_FreeRead(hDevice,identifier);
    return 0;
}


SPACEWIRE_TRAFFIC_TYPE USBSpaceWire_GetReadTrafficType(PUSB_SPACEWIRE_PACKET_PROPERTIES pProperties, U32 nPacketNum)
{
    if(resolved_USBSpaceWire_GetReadTrafficType!=NULL)
        return resolved_USBSpaceWire_GetReadTrafficType(pProperties,nPacketNum);
    return SPACEWIRE_TRAFFIC_UNKNOWN;
}


USB_SPACEWIRE_EOP_TYPE USBSpaceWire_GetReadEOPStatus(PUSB_SPACEWIRE_PACKET_PROPERTIES pProperties, U32 nPacketNum)
{
    if(resolved_USBSpaceWire_GetReadEOPStatus!=NULL)
        return resolved_USBSpaceWire_GetReadEOPStatus(pProperties,nPacketNum);
    return SPACEWIRE_USB_NO_EOP;
}


void CFGSpaceWire_EnableRMAP(char useRMAP)
{
    if(resolved_CFGSpaceWire_EnableRMAP!=NULL)
        resolved_CFGSpaceWire_EnableRMAP(useRMAP);
}


void CFGSpaceWire_SetRMAPDestinationKey(U8 destinationKey)
{
    if(resolved_CFGSpaceWire_SetRMAPDestinationKey!=NULL)
        resolved_CFGSpaceWire_SetRMAPDestinationKey(destinationKey);
}


void CFGSpaceWire_StackClear()
{
    if(resolved_CFGSpaceWire_StackClear!=NULL)
        resolved_CFGSpaceWire_StackClear();
}


void CFGSpaceWire_AddrStackPush(U8 dwAddress)
{
    if(resolved_CFGSpaceWire_AddrStackPush!=NULL)
        resolved_CFGSpaceWire_AddrStackPush(dwAddress);
}


void CFGSpaceWire_RetAddrStackPush(U8 dwAddress)
{
    if(resolved_CFGSpaceWire_RetAddrStackPush!=NULL)
        resolved_CFGSpaceWire_RetAddrStackPush(dwAddress);
}


int CFGSpaceWire_SetBrickBaseTransmitRate(star_device_handle hDevice, U32 dwBaseClk, U32 dwBaseDvdr, U32 dwEnableClk)
{
    if(resolved_CFGSpaceWire_SetBrickBaseTransmitRate!=NULL)
        return resolved_CFGSpaceWire_SetBrickBaseTransmitRate(hDevice, dwBaseClk, dwBaseDvdr, dwEnableClk);
    return 0;
}


int CFGSpaceWire_GetLinkStatusControl(star_device_handle hDevice, U32 dwLinkNum, U32 *dwStatusControl)
{
    if(resolved_CFGSpaceWire_GetLinkStatusControl!=NULL)
        return resolved_CFGSpaceWire_GetLinkStatusControl(hDevice, dwLinkNum, dwStatusControl);
    return 0;
}


void CFGSpaceWire_LSEnableAutoStart(U32 *dwStatusControl, char bEnabled)
{
    if(resolved_CFGSpaceWire_LSEnableAutoStart!=NULL)
        resolved_CFGSpaceWire_LSEnableAutoStart(dwStatusControl, bEnabled);
}


void CFGSpaceWire_LSEnableStart(U32 *dwStatusControl, char bEnabled)
{
    if(resolved_CFGSpaceWire_LSEnableStart!=NULL)
        resolved_CFGSpaceWire_LSEnableStart(dwStatusControl, bEnabled);
}


void CFGSpaceWire_LSEnableDisabled(U32 *dwStatusControl, char bEnabled)
{
    if(resolved_CFGSpaceWire_LSEnableDisabled!=NULL)
        resolved_CFGSpaceWire_LSEnableDisabled(dwStatusControl, bEnabled);
}


void CFGSpaceWire_LSEnableTristate(U32 *dwStatusControl, char bEnabled)
{
    if(resolved_CFGSpaceWire_LSEnableTristate!=NULL)
        resolved_CFGSpaceWire_LSEnableTristate(dwStatusControl, bEnabled);
}


void CFGSpaceWire_LSPortType(U32 dwStatusControl, U32 *dwPortType)
{
    if(resolved_CFGSpaceWire_LSPortType!=NULL)
        resolved_CFGSpaceWire_LSPortType(dwStatusControl, dwPortType);
}


void CFGSpaceWire_LSSetOperatingSpeed(U32 *dwStatusControl, U32 dwOperatingSpeed)
{
    if(resolved_CFGSpaceWire_LSSetOperatingSpeed!=NULL)
        resolved_CFGSpaceWire_LSSetOperatingSpeed(dwStatusControl, dwOperatingSpeed);
}


void CFGSpaceWire_LSConfigErrorStatus(U32 dwStatusControl, U32 *dwErrorStatus)
{
    if(resolved_CFGSpaceWire_LSConfigErrorStatus!=NULL)
        resolved_CFGSpaceWire_LSConfigErrorStatus(dwStatusControl, dwErrorStatus);
}


void CFGSpaceWire_LSExternalErrorStatus(U32 dwStatusControl, U32 *dwErrorStatus)
{
    if(resolved_CFGSpaceWire_LSExternalErrorStatus!=NULL)
        resolved_CFGSpaceWire_LSExternalErrorStatus(dwStatusControl, dwErrorStatus);
}


void CFGSpaceWire_LSErrorStatus(U32 dwStatusControl, U32 *dwErrorStatus)
{
    if(resolved_CFGSpaceWire_LSErrorStatus!=NULL)
        resolved_CFGSpaceWire_LSErrorStatus(dwStatusControl, dwErrorStatus);
}


void CFGSpaceWire_LSLinkState(U32 dwStatusControl, U32 *dwLinkStatus)
{
    if(resolved_CFGSpaceWire_LSLinkState!=NULL)
        resolved_CFGSpaceWire_LSLinkState(dwStatusControl, dwLinkStatus);
}


void CFGSpaceWire_LSIsLinkRunning(U32 dwStatusControl, char *isLinkRunning)
{
    if(resolved_CFGSpaceWire_LSIsLinkRunning!=NULL)
        resolved_CFGSpaceWire_LSIsLinkRunning(dwStatusControl, isLinkRunning);
}


void CFGSpaceWire_LSIsAutoStart(U32 dwStatusControl, char *isAutoStart)
{
    if(resolved_CFGSpaceWire_LSIsAutoStart!=NULL)
        resolved_CFGSpaceWire_LSIsAutoStart(dwStatusControl, isAutoStart);
}


void CFGSpaceWire_LSIsStart(U32 dwStatusControl, char *isStart)
{
    if(resolved_CFGSpaceWire_LSIsStart!=NULL)
        resolved_CFGSpaceWire_LSIsStart(dwStatusControl, isStart);
}


void CFGSpaceWire_LSIsDisabled(U32 dwStatusControl, char *isDisabled)
{
    if(resolved_CFGSpaceWire_LSIsDisabled!=NULL)
        resolved_CFGSpaceWire_LSIsDisabled(dwStatusControl, isDisabled);
}


void CFGSpaceWire_LSIsTristate(U32 dwStatusControl, char *isTristate)
{
    if(resolved_CFGSpaceWire_LSIsTristate!=NULL)
        resolved_CFGSpaceWire_LSIsTristate(dwStatusControl, isTristate);
}


void CFGSpaceWire_LSOperatingSpeed(U32 dwStatusControl, U32 *dwOperatingSpeed)
{
    if(resolved_CFGSpaceWire_LSOperatingSpeed!=NULL)
        resolved_CFGSpaceWire_LSOperatingSpeed(dwStatusControl, dwOperatingSpeed);
}


void CFGSpaceWire_LSOutputPortConnection(U32 dwStatusControl, U32 *dwOutputPortConnection)
{
    if(resolved_CFGSpaceWire_LSOutputPortConnection!=NULL)
        resolved_CFGSpaceWire_LSOutputPortConnection(dwStatusControl, dwOutputPortConnection);
}


int CFGSpaceWire_SetLinkStatusControl(star_device_handle hDevice, U32 dwLinkNum, U32 dwStatusControl)
{
    if(resolved_CFGSpaceWire_SetLinkStatusControl!=NULL)
        return resolved_CFGSpaceWire_SetLinkStatusControl(hDevice, dwLinkNum, dwStatusControl);
    return 0;
}


int CFGSpaceWire_SetAsInterface(star_device_handle hDevice, char bEnabled, char bAddIdentifier)
{
    if(resolved_CFGSpaceWire_SetAsInterface!=NULL)
        return resolved_CFGSpaceWire_SetAsInterface(hDevice, bEnabled, bAddIdentifier);
    return 0;
}


int CFGSpaceWire_ClearRoutingTableEntry(star_device_handle hDevice, U32 nLogicalAddress)
{
    if(resolved_CFGSpaceWire_ClearRoutingTableEntry!=NULL)
        return resolved_CFGSpaceWire_ClearRoutingTableEntry(hDevice,nLogicalAddress);
    return 0;
}


void CFGSpaceWire_RTBuildRoutingTableEntry(U32 *dwRoutingTableEntry, U32 dwOutputPorts, char bDelHead, char bPriority)
{
    if(resolved_CFGSpaceWire_RTBuildRoutingTableEntry!=NULL)
        resolved_CFGSpaceWire_RTBuildRoutingTableEntry(dwRoutingTableEntry, dwOutputPorts, bDelHead, bPriority);
}


int CFGSpaceWire_SetRoutingTableEntry(star_device_handle hDevice, U32 nLogicalAddress, U32 dwRoutingTableEntry)
{
    if(resolved_CFGSpaceWire_SetRoutingTableEntry!=NULL)
        return resolved_CFGSpaceWire_SetRoutingTableEntry(hDevice,nLogicalAddress, dwRoutingTableEntry);
    return 0;
}


int CFGSpaceWire_GetRoutingTableEntry(star_device_handle hDevice, U32 nLogicalAddress, U32 *dwRoutingTableEntry)
{
    if(resolved_CFGSpaceWire_GetRoutingTableEntry!=NULL)
        return resolved_CFGSpaceWire_GetRoutingTableEntry(hDevice,nLogicalAddress, dwRoutingTableEntry);
    return 0;
}


void CFGSpaceWire_RTIsEnabled(U32 dwRoutingTableEntry, char *bEnabled)
{
    if(resolved_CFGSpaceWire_RTIsEnabled!=NULL)
        resolved_CFGSpaceWire_RTIsEnabled( dwRoutingTableEntry, bEnabled);
}


void CFGSpaceWire_RTIsDelHead(U32 dwRoutingTableEntry, char *bDelHead)
{
    if(resolved_CFGSpaceWire_RTIsDelHead!=NULL)
        resolved_CFGSpaceWire_RTIsDelHead( dwRoutingTableEntry, bDelHead);
}


void CFGSpaceWire_RTIsPriority(U32 dwRoutingTableEntry, char *bPriority)
{
    if(resolved_CFGSpaceWire_RTIsPriority!=NULL)
        resolved_CFGSpaceWire_RTIsPriority( dwRoutingTableEntry, bPriority);
}


void CFGSpaceWire_RTGetOutputPorts(U32 dwRoutingTableEntry, U32 *dwOutputPorts)
{
    if(resolved_CFGSpaceWire_RTGetOutputPorts!=NULL)
        resolved_CFGSpaceWire_RTGetOutputPorts( dwRoutingTableEntry, dwOutputPorts);
}


int CFGSpaceWire_GetTickEnableStatus(star_device_handle hDevice, U32 *dwTickEnableStatus)
{
    if(resolved_CFGSpaceWire_GetTickEnableStatus!=NULL)
        return resolved_CFGSpaceWire_GetTickEnableStatus( hDevice, dwTickEnableStatus);
    return 0;
}


int CFGSpaceWire_SetTickEnableStatus(star_device_handle hDevice, U32 dwTickEnableStatus)
{
    if(resolved_CFGSpaceWire_SetTickEnableStatus!=NULL)
        return resolved_CFGSpaceWire_SetTickEnableStatus( hDevice, dwTickEnableStatus);
    return 0;
}