# HG changeset patch
# User Paul LEROY <paul.leroy@lpp.polytechnique.fr>
# Date 2013-04-11 06:23:00
# Node ID f17b38784f5e94e31b2082dae46ee2658fcb8a81
# Parent  304f5a6ad6b44315e86239399647213d4735ed1b

stardundee headers added to the repository

diff --git a/spw_usb_driver_v2.62/inc/rmap_packet_library.h b/spw_usb_driver_v2.62/inc/rmap_packet_library.h
new file mode 100644
--- /dev/null
+++ b/spw_usb_driver_v2.62/inc/rmap_packet_library.h
@@ -0,0 +1,690 @@
+/**
+ * \file rmap_packet_library.h
+ * \brief Declarations of the functions provided by the STAR-Dundee RMAP Packet
+ *        Library.
+ *         STAR-Dundee\n
+ *         Unit 12, Dundee University Incubator\n
+ *         James Lindsay Place\n
+ *         Dundee Technopole\n
+ *         Dundee, DD1 5JJ\n
+ *         Scotland, UK\n
+ *         e-mail: support@star-dundee.com
+ *
+ * This file contains the declarations of the functions provided by the
+ * STAR-Dundee RMAP Packet Library, along with constants and types used by the
+ * library.  The RMAP Packet Library provides functions for building and
+ * interpreting RMAP packets.
+ *
+ * <b>IMPORTANT NOTE:</b>
+ * \note            If you are experiencing compilation errors indicating that
+ *                  U8 is already defined, for example, please add the following
+ *                  line to your code prior to including this file:\n
+ *                      <code>\#define NO_STAR_TYPES</code>\n
+ *                  Alternatively you can compile your code with a flag of
+ *                  <code>-DNO_STAR_TYPES</code>.\n
+ *                  (Copied from star_dundee_types.h)
+ *
+ * \version 3.2 - June 19th 2012\n
+ *          Fixed bug when checking a write command packet or read reply packet
+ *          has a data length of 0.
+ *          Updates to documentation.
+ *
+ * \version 3.1 - February 10th 2012\n
+ *          Minor updates to packet types to avoid errors in static
+ *          analysers.\n\n
+ * 
+ * \version 3.0 - October 14th 2011\n
+ *          Updated linking process on Windows.\n
+ *          Updated library file name.\n\n
+ * 
+ * \version 2.1 - August 22nd 2011\n
+ *          Made minor improvements to the internal structure.\n\n
+ * 
+ * \version 2.0 - October 28th 2009\n
+ *          Changed internal architecture to minimise memory allocations.\n
+ *          Restored __stdcall calling convention on Windows.\n
+ *          Updated names to be consistent with terminology in latest RMAP
+ *          standard.\n
+ *          Added functions to calculate the length of different packet types
+ *          and to fill a buffer with specific packets.\n\n
+ * 
+ * \version 1.9 - July 29th 2009\n
+ *          Fixed problem with byte ordering in return value of
+ *          RMAP_GetAddress.\n
+ *          Fixed bug when creating read and write reply packets, with a packet
+ *          structure provided.\n\n
+ *
+ * \version 1.8 - February 26th 2009\n
+ *          Updated the calling convention used in the function declaration to
+ *          __stdcall on Windows.\n\n
+ *
+ * \version 1.7 - November 20th 2008\n
+ *          Fixed problem with naming of RMAP_IsCRCValid in header file.\n
+ *          Added function to calculate a CRC starting from a CRC seed
+ *          value.\n\n
+ *
+ * \version 1.6 - October 29th 2007\n
+ *          Added support for SpaceCube.\n\n
+ *
+ * \version 1.5 - March 23rd 2007\n
+ *          Used star_dundee_types.h to represent integer values of 1, 2 and 4
+ *          bytes in a cross-platform manner.\n
+ *          Fixed problems encountered on big endian machines.\n\n
+ *
+ * \version 1.4 - March 19th 2007\n
+ *          Improved freeing of memory following errors.\n\n
+ *
+ * \version 1.3 - November 7th 2006\n
+ *          Updated to be multi-platform.\n
+ *          Using new CRC table.\n
+ *          Fixed error when checking the format of read-modify-write command
+ *          packets, data length incorrect.\n
+ *          Fixed error when identifying the start of the extended and normal
+ *          read/write address.\n
+ *          Fixed error when reading the data length in a read command.\n\n
+ *
+ * \version 1.2 - April 3rd 2006\n
+ *          Fixed potential problems with RMAP_PACKET_STATUS enum being an
+ *          undefined size (no change to this file required).\n\n
+ *
+ * \version 1.1 - March 9th 2006\n
+ *          Added support for different byte alignment requirements.\n\n
+ *
+ * \version 1.0 - December 20th 2005\n
+ *          Initial version.\n\n
+ *
+ * Copyright &copy; 2009 STAR-Dundee Ltd
+ */
+
+
+
+#ifndef RMAP_PACKET_LIBRARY_H
+#define RMAP_PACKET_LIBRARY_H
+
+
+
+#include "star-dundee_types.h"
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#if defined(_WIN32) || defined(_WIN64)
+    #ifdef  _WIN64
+        #define RMAPPACKETLIBRARY_CC
+    #else
+        #define RMAPPACKETLIBRARY_CC __stdcall
+    #endif
+#else
+    #define RMAPPACKETLIBRARY_CC
+#endif
+
+
+
+typedef enum
+{
+    RMAP_SUCCESS								= 0x00,
+    RMAP_GENERAL_ERROR							= 0x01,
+    RMAP_UNUSED_PACKET_TYPE_OR_COMMAND_CODE		= 0x02,
+    RMAP_INVALID_KEY							= 0x03,
+    RMAP_INVALID_DATA_CRC						= 0x04,
+    RMAP_EARLY_EOP								= 0x05,
+    RMAP_TOO_MUCH_DATA							= 0x06,
+    RMAP_EEP									= 0x07,
+    RMAP_VERIFY_BUFFER_OVERRUN					= 0x09,
+    RMAP_COMMAND_NOT_IMPLEMENTED_OR_AUTHORISED	= 0x0a,
+    RMAP_RMW_DATA_LENGTH_ERROR					= 0x0b,
+    RMAP_INVALID_TARGET_LOGICAL_ADDRESS			= 0x0c,
+    RMAP_INVALID_STATUS							= 0xff
+} RMAP_STATUS;
+
+
+
+#define RMAP_PROTOCOL_IDENTIFIER	1
+
+#define RMAP_RESERVED_BIT				0x80
+#define RMAP_COMMAND_BIT				0x40
+#define RMAP_WRITE_OPERATION_BIT		0x20
+#define RMAP_VERIFY_BEFORE_WRITE_BIT	0x10
+#define RMAP_REPLY_BIT					0x08
+#define RMAP_INCREMENT_ADDRESS_BIT		0x04
+#define RMAP_REPLY_ADDRESS_LENGTH_BITS	0x03
+
+
+
+typedef enum
+{
+    RMAP_WRITE_COMMAND				= (RMAP_COMMAND_BIT |
+                                        RMAP_WRITE_OPERATION_BIT),
+    RMAP_WRITE_REPLY				= (RMAP_WRITE_OPERATION_BIT),
+    RMAP_READ_COMMAND				= (RMAP_COMMAND_BIT),
+    RMAP_READ_REPLY					= (0),
+    RMAP_READ_MODIFY_WRITE_COMMAND	= (RMAP_COMMAND_BIT |
+                                        RMAP_VERIFY_BEFORE_WRITE_BIT),
+    RMAP_READ_MODIFY_WRITE_REPLY	= (RMAP_VERIFY_BEFORE_WRITE_BIT),
+    RMAP_INVALID_PACKET_TYPE		= (0xff)
+} RMAP_PACKET_TYPE;
+
+
+
+typedef struct
+{
+    RMAP_PACKET_TYPE	packetType;
+    U8					*pTargetAddress;
+    unsigned long		targetAddressLength;
+    U8					*pReplyAddress;
+    unsigned long		replyAddressLength;
+    U8					*pProtocolIdentifier;
+    U8					*pInstruction;
+    char				verifyBeforeWrite;
+    char				acknowledge;
+    char				incrementAddress;
+    U8					*pKey;
+    U16					*pTransactionIdentifier;
+    U32					*pReadWriteAddress;
+    U8					*pExtendedReadWriteAddress;
+    U8					*pStatus;
+    U8					*pHeader;
+    unsigned long		headerLength;
+    U8					*pHeaderCRC;
+    U8					*pData;
+    void				*pDataLength;
+    U32					dataLength;
+    U8					*pDataCRC;
+    U8					*pMask;
+    U8					maskLength;
+    U8					*pRawPacket;
+    unsigned long		rawPacketLength;
+} RMAP_PACKET;
+
+
+
+/* Declarations of the functions provided by the RMAP Packet Library */
+
+U32
+RMAPPACKETLIBRARY_CC
+RMAP_GetVersion(
+    void
+    );
+
+U8
+RMAPPACKETLIBRARY_CC
+RMAP_CalculateCRC(
+    void			*pBuffer,
+    unsigned long	len
+    );
+
+U8
+RMAPPACKETLIBRARY_CC
+RMAP_CalculateCRCWithSeed(
+    void			*pBuffer,
+    unsigned long	len,
+    U8				crc
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_IsCRCValid(
+    void			*pBuffer,
+    unsigned long	len,
+    U8				crc
+    );
+
+RMAP_STATUS
+RMAPPACKETLIBRARY_CC
+RMAP_CheckPacketValid(
+    void			*pRawPacket,
+    unsigned long	packetLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			checkPacketTooLong
+    );
+
+RMAP_PACKET_TYPE
+RMAPPACKETLIBRARY_CC
+RMAP_GetPacketType(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+U8 *
+RMAPPACKETLIBRARY_CC
+RMAP_GetTargetAddress(
+    RMAP_PACKET	*pPacketStruct,
+    unsigned long	*pTargetAddressLength
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_GetVerifyBeforeWrite(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_GetPerformAcknowledgement(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_GetIncrementAddress(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+U8
+RMAPPACKETLIBRARY_CC
+RMAP_GetKey(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+U8 *
+RMAPPACKETLIBRARY_CC
+RMAP_GetReplyAddress(
+    RMAP_PACKET		*pPacketStruct,
+    unsigned long	*pReplyAddressLength
+    );
+
+U16
+RMAPPACKETLIBRARY_CC
+RMAP_GetTransactionID(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+U32
+RMAPPACKETLIBRARY_CC
+RMAP_GetAddress(
+    RMAP_PACKET	*pPacketStruct,
+    U8			*pExtendedAddress
+    );
+
+U8 *
+RMAPPACKETLIBRARY_CC
+RMAP_GetData(
+    RMAP_PACKET	*pPacketStruct,
+    U32			*pDataLength
+    );
+
+U32
+RMAPPACKETLIBRARY_CC
+RMAP_GetReadLength(
+    RMAP_PACKET* pPacketStruct
+    );
+
+RMAP_STATUS
+RMAPPACKETLIBRARY_CC
+RMAP_GetStatus(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+U8
+RMAPPACKETLIBRARY_CC
+RMAP_GetHeaderCRC(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+U8
+RMAPPACKETLIBRARY_CC
+RMAP_GetDataCRC(
+    RMAP_PACKET	*pPacketStruct
+    );
+
+U8 *
+RMAPPACKETLIBRARY_CC
+RMAP_GetMask(
+    RMAP_PACKET	*pPacketStruct,
+    U8			*pMaskLength
+    );
+
+unsigned long
+RMAPPACKETLIBRARY_CC
+RMAP_CalculateWriteCommandPacketLength(
+    unsigned long	targetAddressLength,
+    unsigned long	replyAddressLength,
+    U32				dataLength,
+    char			alignment
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_FillWriteCommandPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    char			verifyBeforeWrite,
+    char			acknowledge,
+    char			incrementAddress,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				writeAddress,
+    U8				extendedWriteAddress,
+    U8				*pData,
+    U32				dataLength,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment,
+    U8				*pRawPacket,
+    unsigned long	rawPacketLength
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildWriteCommandPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    char			verifyBeforeWrite,
+    char			acknowledge,
+    char			incrementAddress,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				writeAddress,
+    U8				extendedWriteAddress,
+    U8				*pData,
+    U32				dataLength,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildWriteRegisterPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    char			verifyBeforeWrite,
+    char			acknowledge,
+    char			incrementAddress,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				writeAddress,
+    U8				extendedWriteAddress,
+    U32				registerValue,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+unsigned long
+RMAPPACKETLIBRARY_CC
+RMAP_CalculateWriteReplyPacketLength(
+    unsigned long	initiatorAddressLength,
+    char			alignment
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_FillWriteReplyPacket(
+    U8				*pInitiatorAddress,
+    unsigned long	initiatorAddressLength,
+    U8				targetAddress,
+    char			verifyBeforeWrite,
+    char			incrementAddress,
+    RMAP_STATUS		status,
+    U16				transactionIdentifier,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment,
+    U8				*pRawPacket,
+    unsigned long	rawPacketLength
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildWriteReplyPacket(
+    U8				*pInitiatorAddress,
+    unsigned long	initiatorAddressLength,
+    U8				targetAddress,
+    char			verifyBeforeWrite,
+    char			incrementAddress,
+    RMAP_STATUS		status,
+    U16				transactionIdentifier,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+unsigned long
+RMAPPACKETLIBRARY_CC
+RMAP_CalculateReadCommandPacketLength(
+    unsigned long	targetAddressLength,
+    unsigned long	replyAddressLength,
+    char			alignment
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_FillReadCommandPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    char			incrementAddress,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				readAddress,
+    U8				extendedReadAddress,
+    U32				dataLength,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment,
+    U8				*pRawPacket,
+    unsigned long	rawPacketLength
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildReadCommandPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    char			incrementAddress,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				readAddress,
+    U8				extendedReadAddress,
+    U32				dataLength,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildReadRegisterPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    char			incrementAddress,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				readAddress,
+    U8				extendedReadAddress,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+unsigned long
+RMAPPACKETLIBRARY_CC
+RMAP_CalculateReadReplyPacketLength(
+    unsigned long	initiatorAddressLength,
+    U32				dataLength,
+    char			alignment
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_FillReadReplyPacket(
+    U8				*pInitiatorAddress,
+    unsigned long	initiatorAddressLength,
+    U8				targetAddress,
+    char			incrementAddress,
+    RMAP_STATUS		status,
+    U16				transactionIdentifier,
+    U8				*pData,
+    U32				dataLength,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment,
+    U8				*pRawPacket,
+    unsigned long	rawPacketLength
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildReadReplyPacket(
+    U8				*pInitiatorAddress,
+    unsigned long	initiatorAddressLength,
+    U8				targetAddress,
+    char			incrementAddress,
+    RMAP_STATUS		status,
+    U16				transactionIdentifier,
+    U8				*pData,
+    U32				dataLength,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+unsigned long
+RMAPPACKETLIBRARY_CC
+RMAP_CalculateReadModifyWriteCommandPacketLength(
+    unsigned long	targetAddressLength,
+    unsigned long	replyAddressLength,
+    U32				dataAndMaskLength,
+    char			alignment
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_FillReadModifyWriteCommandPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				readModifyWriteAddress,
+    U8				extendedReadModifyWriteAddress,
+    U8				dataAndMaskLength,
+    U8				*pData,
+    U8				*pMask,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment,
+    U8				*pRawPacket,
+    unsigned long	rawPacketLength
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildReadModifyWriteCommandPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				readModifyWriteAddress,
+    U8				extendedReadModifyWriteAddress,
+    U8				dataAndMaskLength,
+    U8				*pData,
+    U8				*mask,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildReadModifyWriteRegisterPacket(
+    U8				*pTargetAddress,
+    unsigned long	targetAddressLength,
+    U8				*pReplyAddress,
+    unsigned long	replyAddressLength,
+    U8				key,
+    U16				transactionIdentifier,
+    U32				readModifyWriteAddress,
+    U8				extendedReadModifyWriteAddress,
+    U32				registerValue,
+    U32				mask,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+unsigned long
+RMAPPACKETLIBRARY_CC
+RMAP_CalculateReadModifyWriteReplyPacketLength(
+    unsigned long	initiatorAddressLength,
+    U32				dataLength,
+    char			alignment
+    );
+
+char
+RMAPPACKETLIBRARY_CC
+RMAP_FillReadModifyWriteReplyPacket(
+    U8				*pInitiatorAddress,
+    unsigned long	initiatorAddressLength,
+    U8				targetAddress,
+    RMAP_STATUS		status,
+    U16				transactionIdentifier,
+    unsigned long	dataLength,
+    U8				*pData,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment,
+    U8				*pRawPacket,
+    unsigned long	rawPacketLength
+    );
+
+void *
+RMAPPACKETLIBRARY_CC
+RMAP_BuildReadModifyWriteReplyPacket(
+    U8				*pInitiatorAddress,
+    unsigned long	initiatorAddressLength,
+    U8				targetAddress,
+    RMAP_STATUS		status,
+    U16				transactionIdentifier,
+    unsigned long	dataLength,
+    U8				*pData,
+    unsigned long	*pRawPacketLength,
+    RMAP_PACKET		*pPacketStruct,
+    char			alignment
+    );
+
+void
+RMAPPACKETLIBRARY_CC
+RMAP_FreeBuffer(
+    void	*pBuffer
+    );
+
+
+/* Macros for accessing the version */
+
+#define RMAP_GET_VERSION_MAJOR(versionInfo)	(((version) & 0xff000000) >> 24)
+#define RMAP_GET_VERSION_MINOR(versionInfo)	(((version) & 0x00ff0000) >> 16)
+#define RMAP_GET_VERSION_EDIT(versionInfo)	(((version) & 0x0000ffc0) >> 6)
+#define RMAP_GET_VERSION_PATCH(versionInfo)	((version) & 0x0000003f)
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif	/* RMAP_PACKET_LIBRARY_H */
+
+
+
diff --git a/spw_usb_driver_v2.62/inc/spacewire_usb.h b/spw_usb_driver_v2.62/inc/spacewire_usb.h
new file mode 100755
--- /dev/null
+++ b/spw_usb_driver_v2.62/inc/spacewire_usb.h
@@ -0,0 +1,205 @@
+/******************************************************************************/
+/*                                                                            */
+/*  spacewire_usb.h                                                           */
+/*                                                                            */
+/*  Header file for all constants which may be used with the STAR-Dundee      */
+/*  SpaceWire USB driver.                                                     */
+/*                                                                            */
+/*  Version 2.61, September 17th 2012                                         */
+/*                                                                            */
+/*      Version 2.61, 17/09/12                                                */
+/*      ======================                                                */
+/*      Added support for STAR Fire and WBS II.                               */
+/*                                                                            */
+/*      Version 2.60, 04/01/12                                                */
+/*      ======================                                                */
+/*      Added support for EGSE and SPLT.                                      */
+/*                                                                            */
+/*      Version 2.59, 15/08/11                                                */
+/*      ======================                                                */
+/*      Added support for RTC.                                                */
+/*                                                                            */
+/*      Version 2.58, 12/10/10                                                */
+/*      =====================                                                 */
+/*      Added support for Link Analyser Mk2.                                  */
+/*                                                                            */
+/*      Version 2.51                                                          */
+/*      ============                                                          */
+/*      Added use of star_dundee_types.h.                                     */
+/*                                                                            */
+/*      Version 2.5                                                           */
+/*      ===========                                                           */
+/*      Initial version, following change to new architecture.                */
+/*                                                                            */
+/*  Copyright (2012), STAR-Dundee Ltd.,                                       */
+/*                    STAR House,                                             */
+/*                    166 Nethergate,                                         */
+/*                    Dundee, DD1 4EE,                                        */
+/*                    Scotland, UK.                                           */
+/*            e-mail: support@star-dundee.com                                 */
+/*                                                                            */
+/******************************************************************************/
+
+
+
+#ifndef SPACEWIRE_USB_H
+#define SPACEWIRE_USB_H
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* The types used by the API */
+#include "star_dundee_types.h"
+
+
+/* End of packet marker types */
+#define SPACEWIRE_USB_EOP_CHAR		((U8)0x80)
+#define SPACEWIRE_USB_EEP_CHAR		((U8)0x40)
+
+/* The protocol byte used to identify LODI packets */
+#define SPACEWIRE_USB_LODI_PROTOCOL	(0xd1)
+
+
+
+/* Possible results of read and send operations */
+typedef enum 
+{
+	TRANSFER_NOT_STARTED				= 0,
+	TRANSFER_STARTED				= 1,
+	TRANSFER_SUCCESS				= 2,
+	TRANSFER_ERROR_DISCONNECT			= 3,
+	TRANSFER_ERROR_PARITY				= 4,
+	TRANSFER_ERROR_UNKNOWN				= 5,
+	TRANSFER_ERROR_TIMEOUT				= 6,
+	TRANSFER_ERROR_LINK_NOT_STARTED			= 7,
+	TRANSFER_ERROR_USER_BUFFER_LOCK_FAILED		= 8,
+	TRANSFER_ERROR_LINK_ALREADY_IN_USE		= 9,
+	TRANSFER_ERROR_RECEIVE_BUFFER_FULL		= 0xa,
+	TRANSFER_ERROR_OUT_OF_MEMORY			= 0xb,
+	TRANSFER_ERROR_NOT_FOUND			= 0xc,
+	TRANSFER_ERROR_USB_ERROR			= 0xd,
+	TRANSFER_ERROR_NOT_REGISTERED_TO_RECEIVE	= 0xe
+} USB_SPACEWIRE_STATUS, *PUSB_SPACEWIRE_STATUS;
+
+
+
+/* Possible traffic types */
+typedef enum
+{
+	SPACEWIRE_TRAFFIC_UNKNOWN	= -1,
+	SPACEWIRE_TRAFFIC_PACKET	= 0,
+	SPACEWIRE_TRAFFIC_TIMECODE	= 1,
+	SPACEWIRE_TRAFFIC_CONTROL	= 2
+} SPACEWIRE_TRAFFIC_TYPE, *PSPACEWIRE_TRAFFIC_TYPE;
+
+
+
+/* The different end of packet marker types */
+typedef enum 
+{
+	SPACEWIRE_USB_NO_EOP	= 0,
+	SPACEWIRE_USB_EOP	= SPACEWIRE_USB_EOP_CHAR,
+	SPACEWIRE_USB_EEP	= SPACEWIRE_USB_EEP_CHAR
+} USB_SPACEWIRE_EOP_TYPE, *PUSB_SPACEWIRE_EOP_TYPE;
+
+
+
+/* Possible device types */
+typedef enum
+{
+	SPACEWIRE_DEVICE_UNKNOWN    	= -1,
+	SPACEWIRE_ROUTER_USB    		= 0,
+	SPACEWIRE_BRICK     		    = 1,
+	SPACEWIRE_LINK_ANALYSER		    = 2,
+	SPACEWIRE_CONFORMANCE_TESTER	= 3,
+	SPACEWIRE_TUNNEL_BRICK		    = 4,
+	SPACEWIRE_LINK_ANALYSER_MK2		= 5,
+	SPACEWIRE_RTC	        		= 6,
+	SPACEWIRE_EGSE			        = 7,
+	SPACEWIRE_PHYSICAL_LAYER_TESTER = 8,
+    STAR_FIRE                       = 9,
+    WBS_II                          = 10
+} SPACEWIRE_DEVICE_TYPE, *PSPACEWIRE_DEVICE_TYPE;
+
+
+
+
+/* Structure used to store packet lengths and EOPs for a read request */
+typedef struct
+{
+	unsigned long		len;
+	USB_SPACEWIRE_EOP_TYPE	eop;
+	SPACEWIRE_TRAFFIC_TYPE	type;
+} USB_SPACEWIRE_PACKET_PROPERTIES, *PUSB_SPACEWIRE_PACKET_PROPERTIES;
+
+
+
+/* The type of all send and receive identifiers */
+typedef void * USB_SPACEWIRE_ID;
+
+
+
+/* Structure used to represent the firmware version of a device */
+typedef struct
+{
+	U8	major;
+	U8	minor;
+	U16	edit;
+	U8	patch;
+} SPACEWIRE_FIRMWARE_VERSION;
+
+
+/* The product ID used by each STAR-Dundee SpaceWire device */
+
+/** The product ID used by a device with no EEPROM */
+#define SPACEWIRE_PRODUCT_ID_NO_EEPROM		            (0x8613)
+/** The product ID used by an old device in the power check state */
+#define SPACEWIRE_PRODUCT_ID_POWER_CHECK				(0x461f)
+/** The product ID used by an old device with no ID set */
+#define SPACEWIRE_PRODUCT_ID_NO_ID					    (0x1002)
+/** The product ID used by the SpaceWire Router-USB */
+#define SPACEWIRE_PRODUCT_ID_ROUTER_USB					(0x1011)
+/** The product ID used by the SpaceWire-USB Brick */
+#define SPACEWIRE_PRODUCT_ID_BRICK						(0x1012)
+/** The product ID used by the SpaceWire Link Analyser */
+#define SPACEWIRE_PRODUCT_ID_LINK_ANALYSER				(0x1013)
+/** The product ID used by the SpaceWire Conformance Tester */
+#define SPACEWIRE_PRODUCT_ID_CONFORMANCE_TESTER			(0x1014)
+/** The product ID used by the SpaceWire-IP Tunnel */
+#define SPACEWIRE_PRODUCT_ID_TUNNEL_BRICK				(0x1015)
+/** The product ID used by the SpaceWire Router-USB with multiple channels */
+#define SPACEWIRE_PRODUCT_ID_ROUTER_MULTIPLE_CHANNELS	(0x1016)
+/** The product ID used by the SpaceWire Router-USB II Rev 4 */
+#define SPACEWIRE_PRODUCT_ID_ROUTER_USB_II_REV4			(0x1017)
+/** The product ID used by the SpaceWire Link Analyser Mk2 */
+#define SPACEWIRE_PRODUCT_ID_LINK_ANALYSER_MK2			(0x1018)
+/** The product ID used by the SpaceWire RTC */
+#define SPACEWIRE_PRODUCT_ID_RTC						(0x1019)
+/** The product ID used by the SpaceWire EGSE */
+#define SPACEWIRE_PRODUCT_ID_EGSE						(0x101a)
+/** The product ID used by the SpaceWire SPLT */
+#define SPACEWIRE_PRODUCT_ID_SPLT						(0x101b)
+/** The product ID used by the STAR Fire device */
+#define SPACEWIRE_PRODUCT_ID_STAR_FIRE					(0x101c)
+/** The product ID used by the WBS II device */
+#define SPACEWIRE_PRODUCT_ID_WBS_II						(0x101d)
+/** A product ID to be used by a future device */
+#define SPACEWIRE_PRODUCT_ID_FUTURE_101E		        (0x101e)
+/** A product ID to be used by a future device */
+#define SPACEWIRE_PRODUCT_ID_FUTURE_101F		        (0x101f)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif	/* SPACEWIRE_USB_H */
+
+
+
diff --git a/spw_usb_driver_v2.62/inc/spw_config_library.h b/spw_usb_driver_v2.62/inc/spw_config_library.h
new file mode 100755
--- /dev/null
+++ b/spw_usb_driver_v2.62/inc/spw_config_library.h
@@ -0,0 +1,659 @@
+/******************************************************************************/
+/*                                                                            */
+/*  spw_config_library.h                                                      */
+/*                                                                            */
+/*  Declaration of the functions, and definition of macros  provided by the   */
+/*  SpaceWire Router Configuration Library for the SpaceWire USB and          */
+/*  SpaceWire PCI drivers.                                                    */
+/*                                                                            */
+/*  Version 2.62 - November 7th 2012                                          */
+/*                                                                            */
+/*      Version 2.62 - 07/11/12                                               */
+/*      =======================                                               */
+/*      Removed commas at end of enumerators.                                 */
+/*                                                                            */
+/*      Version 2.60 - 05/04/12                                               */
+/*      =======================                                               */
+/*      Updated declarations to replace CFGSpaceWire_EnableReadOnAllPorts     */
+/*      with CFGSpaceWire_EnableReceiveOnAllPorts and                         */
+/*      CFGSpaceWire_IsReadingOnAllPortsEnabled with                          */
+/*      CFGSpaceWire_IsReceiveOnAllPortsEnabled.                              */
+/*                                                                            */
+/*      Version 2.54 - 10/12/10                                               */
+/*      =======================                                               */
+/*      Replaced CFGSpaceWire_RTOutputPorts with                              */
+/*      CFGSpaceWire_RTGetOutputPorts, which doesn't unnecessarily shift the  */
+/*      output port bits and is consistent with                               */
+/*      CFGSpaceWire_RTBuildRoutingTableEntry.                                */
+/*                                                                            */
+/*      Version 2.53 - 26/02/09                                               */
+/*      =======================                                               */
+/*      Updated the calling convention used in the function declarations to   */
+/*      __stdcall on Windows.                                                 */
+/*                                                                            */
+/*      Version 2.52, 04/11/08                                                */
+/*      ======================                                                */
+/*      Added support for precision transmit rate on new Router-USB.          */
+/*      Added chip ID values.                                                 */
+/*                                                                            */
+/*      Version 2.51, 21/10/08                                                */
+/*      ======================                                                */
+/*      Updated to support Windows.                                           */
+/*                                                                            */
+/*      Version 2.50, 08/11/06                                                */
+/*      ======================                                                */
+/*      Initial version, following change to new structure.                   */
+/*                                                                            */
+/*  Copyright (c) 2012, STAR-Dundee Ltd.,                                     */
+/*                      STAR House,                                           */
+/*                      166 Nethergate,                                       */
+/*                      Dundee, DD1 4EE,                                      */
+/*                      Scotland, UK.                                         */
+/*                      http://www.star-dundee.com                            */
+/*              e-mail: support@star-dundee.com                               */
+/*                                                                            */
+/******************************************************************************/
+
+
+
+#ifndef SPACEWIRE_ROUTER_LIBRARY
+#define SPACEWIRE_ROUTER_LIBRARY
+
+
+#include "star_dundee_types.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#if defined(_WIN32) || defined(_WIN64)
+
+
+/* Windows specifc functions and macros */
+
+#ifdef ROUTERCONFIGURATIONLIBRARY_EXPORTS
+#define ROUTER_CONFIG_LIBRARY __declspec(dllexport)
+#else
+#define ROUTER_CONFIG_LIBRARY __declspec(dllimport)
+#endif
+
+/* The calling convention to be used */
+#ifdef  _WIN64
+#define ROUTER_CONFIG_CC
+#else
+#define ROUTER_CONFIG_CC __stdcall
+#endif	/* WIN64 */
+
+
+#include "windows.h"
+
+	
+#else	/* _WIN32 */
+
+
+/* Linux specific functions and macros */
+
+#define ROUTER_CONFIG_LIBRARY
+#define ROUTER_CONFIG_CC
+
+
+#endif	/* _WIN32 */
+
+
+
+/* Possible bit values */
+#define BIT0	(0x00000001)
+#define BIT1	(0x00000002)
+#define BIT2	(0x00000004)
+#define BIT3	(0x00000008)
+#define BIT4	(0x00000010)
+#define BIT5	(0x00000020)
+#define BIT6	(0x00000040)
+#define BIT7	(0x00000080)
+#define BIT8	(0x00000100)
+#define BIT9	(0x00000200)
+#define BIT10	(0x00000400)
+#define BIT11	(0x00000800)
+#define BIT12	(0x00001000)
+#define BIT13	(0x00002000)
+#define BIT14	(0x00004000)
+#define BIT15	(0x00008000)
+#define BIT16	(0x00010000)
+#define BIT17	(0x00020000)
+#define BIT18	(0x00040000)
+#define BIT19	(0x00080000)
+#define BIT20	(0x00100000)
+#define BIT21	(0x00200000)
+#define BIT22	(0x00400000)
+#define BIT23	(0x00800000)
+#define BIT24	(0x01000000)
+#define BIT25	(0x02000000)
+#define BIT26	(0x04000000)
+#define BIT27	(0x08000000)
+#define BIT28	(0x10000000)
+#define BIT29	(0x20000000)
+#define BIT30	(0x40000000)
+#define BIT31	(0x80000000)
+
+
+
+/* Exported enums and structs */
+
+
+
+/* Read write address errors */
+typedef enum
+{
+	CFG_TRANSFER_SUCCESS		= 0x00,
+	CFG_TRANSMIT_PACKET_FAILURE	= 0x01,
+	CFG_REPLY_PACKET_FAILURE	= 0x02,
+	CFG_REPLY_PACKET_TOO_BIG	= 0x03,
+	CFG_REPLY_PACKET_TOO_SMALL	= 0x04,
+	CFG_REPLY_PACKET_NAK		= 0x05,
+	CFG_REPLY_PACKET_CHECKSUM_ERROR	= 0x06
+} CFG_SPACEWIRE_STATUS;
+
+
+
+/* Length of port timeout */
+typedef enum
+{
+	CFG_PORT_TIMEOUT_100US     = 0x0,
+	CFG_PORT_TIMEOUT_1MS       = 0x1,
+	CFG_PORT_TIMEOUT_10MS      = 0x2,
+	CFG_PORT_TIMEOUT_100MS     = 0x3,
+	CFG_PORT_TIMEOUT_1S        = 0x4
+} CFG_SPACEWIRE_PORT_TIMEOUT;
+
+
+
+/* SpaceWire Port errors */
+#define CFG_SPACEWIRE_NO_ERRORS			(0)
+#define CFG_SPACEWIRE_ERROR_ACTIVE		(BIT0)
+#define CFG_SPACEWIRE_PACKET_ADDRESS_ERROR	(BIT1)
+#define CFG_SPACEWIRE_PORT_TIMEOUT_ERROR	(BIT2)
+#define CFG_SPACEWIRE_DISCONNECT_ERROR		(BIT3)
+#define CFG_SPACEWIRE_PARITY_ERROR		(BIT4)
+#define CFG_SPACEWIRE_ESCAPE_ERROR		(BIT5)
+#define CFG_SPACEWIRE_CREDIT_ERROR		(BIT6)
+#define CFG_SPACEWIRE_CHARACTER_SEQUENCE_ERROR	(BIT7)
+#define CFG_SPACEWIRE_ERROR_BITS		(BIT0 | BIT1 | BIT2 | BIT3 | \
+						BIT4 | BIT5 | BIT6 | BIT7)
+
+/* Config Port errors */
+#define CFG_CONFIG_NO_ERRORS			(0)
+#define CFG_CONFIG_ERROR_ACTIVE			(BIT0)
+
+/* Config Port errors (non-RMAP) */
+#define CFG_CONFIG_PACKET_ADDRESS_ERROR		(BIT1)
+#define CFG_CONFIG_PORT_TIMEOUT_ERROR		(BIT2)
+#define CFG_CONFIG_CHECKSUM_ERROR		(BIT3)
+#define CFG_CONFIG_TOO_SHORT_ERROR		(BIT4)
+#define CFG_CONFIG_TOO_LONG_ERROR		(BIT5)
+#define CFG_CONFIG_PACKET_EEP_ERROR		(BIT6)
+#define CFG_CONFIG_PROTOCOL_BYTE_ERROR		(BIT7)
+#define CFG_CONFIG_INVALID_REGISTER_ERROR	(BIT8)
+#define CFG_CONFIG_ERROR_BITS			(BIT0 | BIT1 | BIT2 | BIT3 | \
+						 BIT4 | BIT5 | BIT6 | BIT7 | \
+						 BIT8)
+
+/* Config Port errors (RMAP) */
+#define CFG_CONFIG_RMAP_PORT_TIMEOUT_ERROR			(BIT1)
+#define CFG_CONFIG_RMAP_INVALID_HEADER_CRC			(BIT2)
+#define CFG_CONFIG_RMAP_INVALID_DATA_CRC			(BIT3)
+#define CFG_CONFIG_RMAP_INVALID_DESTINATION_KEY			(BIT4)
+#define CFG_CONFIG_RMAP_COMMAND_NOT_IMPLEMENTED			(BIT5)
+#define CFG_CONFIG_RMAP_INVALID_DATA_LENGTH			(BIT6)
+#define CFG_CONFIG_RMAP_INVALID_RMW_DATA_LENGTH			(BIT7)
+#define CFG_CONFIG_RMAP_INVALID_DESTINATION_ADDRESS		(BIT8)
+#define CFG_CONFIG_RMAP_EARLY_EOP				(BIT9)
+#define CFG_CONFIG_RMAP_LATE_EOP				(BIT10)
+#define CFG_CONFIG_RMAP_EARLY_EEP				(BIT11)
+#define CFG_CONFIG_RMAP_LATE_EEP				(BIT12)
+#define CFG_CONFIG_RMAP_VERIFY_BUFFER_OVERRUN_ERROR		(BIT13)
+#define CFG_CONFIG_RMAP_INVALID_REGISTER_ADDRESS		(BIT14)
+#define CFG_CONFIG_RMAP_UNSUPPORTED_PROTOCOL_ERROR		(BIT15)
+#define CFG_CONFIG_RMAP_SOURCE_LOGICAL_ADDRESS_ERROR		(BIT16)
+#define CFG_CONFIG_RMAP_SOURCE_PATH_ADDRESS_ERROR		(BIT17)
+#define CFG_CONFIG_RMAP_CARGO_TOO_LARGE				(BIT18)
+#define CFG_CONFIG_RMAP_UNUSED_COMMAND_OR_PACKET_TYPE		(BIT19)
+#define CFG_CONFIG_RMAP_ERROR_BITS	(BIT0 | BIT1 | BIT2 | BIT3 | BIT4 | \
+					 BIT5 | BIT6 | BIT7 | BIT8 | BIT9 | \
+					 BIT10 | BIT11 | BIT12 | BIT13 | \
+					 BIT14 | BIT15 | BIT16 | BIT17 | \
+					 BIT18 | BIT19)
+
+/* External Port errors */
+#define CFG_EXTERNAL_NO_ERRORS			(0)
+#define CFG_EXTERNAL_ERROR_ACTIVE		(BIT0)
+#define CFG_EXTERNAL_PACKET_ADDRESS_ERROR	(BIT1)
+#define CFG_EXTERNAL_PORT_TIMEOUT_ERROR		(BIT2)
+#define CFG_EXTERNAL_INPUT_BUFFER_EMPTY_ERROR	(BIT3)
+#define CFG_EXTERNAL_INPUT_BUFFER_FULL_ERROR	(BIT4)
+#define CFG_EXTERNAL_OUTPUT_BUFFER_EMPTY_ERROR	(BIT5)
+#define CFG_EXTERNAL_OUTPUT_BUFFER_FULL_ERROR	(BIT6)
+#define CFG_EXTERNAL_ERROR_BITS			(BIT0 | BIT1 | BIT2 | BIT3 | \
+						 BIT4 | BIT5 | BIT6)
+
+/* SpaceWire Port interface state */
+#define CFG_SPACEWIRE_ERROR_RESET	(0)
+#define CFG_SPACEWIRE_ERROR_WAIT	(BIT0)
+#define CFG_SPACEWIRE_READY		(BIT1)
+#define CFG_SPACEWIRE_STARTED		(BIT1 | BIT0)
+#define CFG_SPACEWIRE_CONNECTING	(BIT2)
+#define CFG_SPACEWIRE_RUN		(BIT2 | BIT0)
+
+/* Port type */
+#define CFG_CONFIGURATION_PORT		(0)
+#define CFG_SPACEWIRE_SERIAL_PORT	(BIT0)
+#define CFG_SPACEWIRE_EXTERNAL_PORT	(BIT1)
+
+/* SpaceWire Port control bits */
+#define CFG_SPACEWIRE_INTERFACE_STATE_START	(8)
+#define CFG_SPACEWIRE_INTERFACE_STATE		(BIT8 | BIT9 | BIT10)
+#define CFG_SPACEWIRE_RUNNING			(BIT11)
+#define CFG_SPACEWIRE_AUTOSTART			(BIT12)
+#define CFG_SPACEWIRE_START			(BIT13)
+#define CFG_SPACEWIRE_DISABLE			(BIT14)
+#define CFG_SPACEWIRE_TRISTATE			(BIT15)
+#define CFG_SPACEWIRE_RATE			(BIT16 | BIT17 | BIT18 | \
+						 BIT19 | BIT20 | BIT21 | BIT22)
+#define CFG_SPACEWIRE_RATE_START		(16)
+
+/* Bits in the GAR Table */
+#define CFG_GAR_OUTPUT_PORTS_START	(1)
+#define CFG_GAR_OUTPUT_PORTS		(BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | \
+	BIT6 | BIT7 | BIT8 | BIT9 | BIT10 | BIT11 | BIT12 | BIT13 | BIT14 | \
+	BIT15 | BIT16 | BIT17 | BIT18 | BIT19 | BIT20 | BIT21 | BIT22 | \
+	BIT23 | BIT24 | BIT25 | BIT26 | BIT27 | BIT28)
+#define CFG_GAR_DEL_HEAD		(BIT29)
+#define CFG_GAR_PRIORITY		(BIT30)
+#define CFG_GAR_INVALID_ADDR		(BIT31)
+
+/* Bits in the router control register */
+#define CFG_RC_TIMEOUT_ENABLE_START	(0)
+#define CFG_RC_TIMEOUT_ENABLE		(BIT0)
+#define CFG_RC_TIMEOUT_VALUE_START	(1)
+#define CFG_RC_TIMEOUT_VALUE		(BIT1 | BIT2 | BIT3)
+#define CFG_RC_DISABLE_ON_SILENCE	(BIT4)
+#define CFG_RC_DISABLE_ON_SILENCE_START	(4)
+#define CFG_RC_START_ON_REQUEST		(BIT5)
+#define CFG_RC_START_ON_REQUEST_START	(5)
+#define CFG_RC_SELF_ADDRESSING		(BIT6)
+#define CFG_RC_SELF_ADDRESSING_START	(6)
+#define CFG_RC_INTERFACE		(BIT7)
+#define CFG_RC_INTERFACE_START		(7)
+#define CFG_RC_INTERFACE_IDENT		(BIT8)
+#define CFG_RC_INTERFACE_IDENT_START	(8)
+
+/* The bits shared by all ports */
+#define CFG_PORT_CONNECTION		(BIT24 | BIT25 | BIT26 | BIT27 | BIT28)
+#define CFG_PORT_CONNECTION_START	(24)
+#define CFG_PORT_TYPE			(BIT29 | BIT30 | BIT31)
+#define CFG_PORT_TYPE_START		(29)
+
+/* Network discovery register values */
+#define CFG_NETD_TYPE			(BIT0 | BIT1 | BIT2 | BIT3)
+#define CFG_NETD_TYPE_START		(0)
+#define CFG_NETD_RETURN_PORT		(BIT4 | BIT5 | BIT6 | BIT7)
+#define CFG_NETD_RETURN_PORT_START	(4)
+#define CFG_NETD_RUNNING_PORTS		(BIT8 | BIT9 | BIT10 | BIT11 | BIT12 | \
+	BIT13 | BIT14 | BIT15 | BIT16 | BIT17 | BIT18 | BIT19 | BIT20 | \
+	BIT21 | BIT22 | BIT23 | BIT24 | BIT25 | BIT26 | BIT27 | BIT28 | \
+	BIT29 | BIT30 | BIT31)
+#define CFG_NETD_RUNNING_PORTS_START	(8)
+
+/* Values in the ID register */
+#define CFG_ID_VERSION			(BIT0 | BIT1 | BIT2 | BIT3 | BIT4 | \
+					 BIT5 | BIT6 | BIT7)
+#define CFG_ID_VERSION_START		(0)
+#define CFG_ID_CHIP			(BIT8 | BIT9 | BIT10 | BIT11 | BIT12 | \
+					 BIT13 | BIT14 | BIT15)
+#define CFG_ID_CHIP_START		(8)
+#define CFG_ID_MANUFACTURER		(BIT16 | BIT17 | BIT18 | BIT19 | \
+					 BIT20 | BIT21 | BIT22 | BIT23)
+#define CFG_ID_MANUFACTURER_START	(16)
+
+/* Values in the Time-Code register */
+#define CFG_TC_VALUE			(BIT0 | BIT1 | BIT2 | BIT3 | BIT4 | \
+					 BIT5)
+#define CFG_TC_VALUE_START		(0)
+#define CFG_TC_FLAGS			(BIT6 | BIT7)
+#define CFG_TC_FLAGS_START		(6)
+
+/* Values for the Router Base Clock Select */
+#define CFG_RTR_CLK_100_MBITS		(0)
+#define CFG_RTR_CLK_200_MBITS		(BIT0)
+
+/* Values for the Brick Base Clock */
+#define CFG_BRK_CLK_100_MHZ		(0)
+#define CFG_BRK_CLK_120_MHZ		(BIT0)
+#define CFG_BRK_CLK_140_MHZ		(BIT1)
+#define CFG_BRK_CLK_160_MHZ		(BIT0 | BIT1)
+#define CFG_BRK_CLK_180_MHZ		(BIT2)
+#define CFG_BRK_CLK_200_MHZ		(BIT2 | BIT0)
+
+/* Values for the Brick Base Divider */
+#define CFG_BRK_DVDR_1			(0)
+#define CFG_BRK_DVDR_2			(BIT0)
+#define CFG_BRK_DVDR_4			(BIT1)
+
+/* Values in the Tx register */
+#define CFG_TX_BRICK_2MBITS		(BIT27)
+#define CFG_TX_BRICK_2MBITS_START	(27)
+
+/* Values in the Precision Transmit Rate register */
+#define CFG_PT_ENABLE		(BIT16)
+#define CFG_PT_ENABLE_START	(16)
+#define CFG_PT_READY		(BIT17)
+#define CFG_PT_READY_START	(17)
+#define CFG_PT_IN_USE		(BIT20)
+#define CFG_PT_IN_USE_START	(20)
+#define CFG_PT_RATE_BITS	(BIT0 | BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | BIT6 | \
+							 BIT7 | BIT8 | BIT9 | BIT10 | BIT11 | BIT12 | \
+							 BIT13 | BIT14 | BIT15 )
+#define CFG_PT_DIVIDER_CONSTANT	((double)(pow((double)2, (double)48) / (double)600))
+
+/* Chip ID values */
+#define CFG_CID_ROUTER_ASIC		    (0)		/* SpaceWire Router ASIC and IP */
+#define CFG_CID_ROUTER_USB	    	(1)		/* Original SpaceWire Router-USB */
+#define CFG_CID_USB_BRICK   		(2)		/* SpaceWire-USB Brick */
+#define CFG_CID_FEIC    			(4)		/* The FEIC chip */
+#define CFG_CID_ROUTER_USB_2	    (5)		/* New SpaceWire Router-USB */
+#define CFG_CID_PCI_MK2	            (7)		/* SpaceWire PCI Mk2 */
+#define CFG_CID_PCI_EXPRESS  	    (8)		/* SpaceWire PCI Express */
+#define CFG_CID_RTC         	    (9)		/* RTC Development Unit */
+#define CFG_CID_CONFORMANCE_TESTER	(10)	/* SpaceWire Conformance Tester */
+#define CFG_CID_EGSE            	(11)	/* SpaceWire EGSE */
+#define CFG_CID_STAR_FIRE       	(12)	/* STAR Fire */
+#define CFG_CID_WBS_MK2         	(14)	/* WBS Mk2 */
+
+
+/* Addresses which can be read from and written to */
+#define CFG_EXTENDED_ADDRESS	(0x100)
+#define CFG_ADDR_NET_DISC		(CFG_EXTENDED_ADDRESS + 0)
+#define CFG_ADDR_NET_DISC_IDENT	(CFG_EXTENDED_ADDRESS + 1)
+#define CFG_ADDR_ROUTER_CONTROL	(CFG_EXTENDED_ADDRESS + 2)
+#define CFG_ADDR_ERRORS			(CFG_EXTENDED_ADDRESS + 3)
+#define CFG_ADDR_TIMECODE		(CFG_EXTENDED_ADDRESS + 4)
+#define CFG_ADDR_IDS			(CFG_EXTENDED_ADDRESS + 5)
+#define CFG_ADDR_GP				(CFG_EXTENDED_ADDRESS + 6)
+#define CFG_ADDR_TICK			(CFG_EXTENDED_ADDRESS + 7)
+#define CFG_ADDR_TX_RATE		(CFG_EXTENDED_ADDRESS + 8)
+#define CFG_ADDR_PRECISION_1	(CFG_EXTENDED_ADDRESS + 0xC)
+#define CFG_ADDR_PRECISION_2	(CFG_EXTENDED_ADDRESS + 0xD)
+
+
+/* Exported functions */
+
+/* Version information */
+ROUTER_CONFIG_LIBRARY double ROUTER_CONFIG_CC CFGSpaceWire_GetAPIVersion(void);
+
+/* Configuration address stack manipulation functions */
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_StackClear(void);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_AddrStackPush(
+	U8 dwAddress);
+ROUTER_CONFIG_LIBRARY U8   ROUTER_CONFIG_CC CFGSpaceWire_AddrStackPop(void);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RetAddrStackPush(
+	U8 dwAddress);
+ROUTER_CONFIG_LIBRARY U8   ROUTER_CONFIG_CC CFGSpaceWire_RetAddrStackPop(void);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_SetProtocolByte(
+	U8 ProtocolByte);
+ROUTER_CONFIG_LIBRARY U8   ROUTER_CONFIG_CC CFGSpaceWire_GetProtocolByte(void);
+
+/* RMAP functions */
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_EnableRMAP(
+	char useRMAP);
+ROUTER_CONFIG_LIBRARY char ROUTER_CONFIG_CC CFGSpaceWire_IsRMAPEnabled();
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_SetRMAPDestinationKey(
+	U8 destinationKey);
+ROUTER_CONFIG_LIBRARY U8 ROUTER_CONFIG_CC CFGSpaceWire_GetRMAPDestinationKey();
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_SetRMAPAlignment(
+	U8 alignment);
+ROUTER_CONFIG_LIBRARY U8 ROUTER_CONFIG_CC CFGSpaceWire_GetRMAPAlignment();
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC
+	CFGSpaceWire_EnableReceiveOnAllPorts(char enable);
+ROUTER_CONFIG_LIBRARY char ROUTER_CONFIG_CC
+	CFGSpaceWire_IsReceiveOnAllPortsEnabled();
+
+/* Ignoring replies to write commands functions */
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_IgnoreWriteReplies(
+	char ignore);
+ROUTER_CONFIG_LIBRARY char ROUTER_CONFIG_CC
+	CFGSpaceWire_AreWriteRepliesIgnored();
+
+/* Configuration address read and write functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_ReadAddress(
+	star_device_handle hDevice, U32 dwAddress, U32 *dwData);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_WriteAddress(
+	star_device_handle hDevice, U32 dwAddress, U32 dwData);
+
+/* Router link functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_StartLink(
+	star_device_handle hDevice, U32 dwLinkNum);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_StopLink(
+	star_device_handle hDevice, U32 dwLinkNum);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_TriStateLink(
+	star_device_handle hDevice, U32 dwLinkNum, char bEnabled);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_SetLinkSpeed(
+	star_device_handle hDevice, U32 dwLinkNum, U32 dwSpeed);
+
+/* Routing table functions */
+ROUTER_CONFIG_LIBRARY int  ROUTER_CONFIG_CC CFGSpaceWire_GetRoutingTableEntry(
+	star_device_handle hDevice, U32 nLogicalAddress, U32 *dwRoutingTableEntry);
+ROUTER_CONFIG_LIBRARY int  ROUTER_CONFIG_CC CFGSpaceWire_SetRoutingTableEntry(
+	star_device_handle hDevice, U32 nLogicalAddress, U32 dwRoutingTableEntry);
+ROUTER_CONFIG_LIBRARY int  ROUTER_CONFIG_CC CFGSpaceWire_ClearRoutingTableEntry(
+	star_device_handle hDevice, U32 nLogicalAddress);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RTIsEnabled(
+	U32 dwRoutingTableEntry, char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RTIsDelHead(
+	U32 dwRoutingTableEntry, char *bDelHead);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RTIsPriority(
+	U32 dwRoutingTableEntry, char *bPriority);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RTOutputPorts(
+	U32 dwRoutingTableEntry, U32 *dwOutputPorts);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RTGetOutputPorts(
+	U32 dwRoutingTableEntry, U32 *dwOutputPorts);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC
+	CFGSpaceWire_RTBuildRoutingTableEntry(U32 *dwRoutingTableEntry,
+		U32 dwOutputPorts, char bDelHead, char bPriority);
+
+/* Link status control functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetLinkStatusControl(
+	star_device_handle hDevice, U32 dwLinkNum, U32 *dwStatusControl);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_SetLinkStatusControl(
+	star_device_handle hDevice, U32 dwLinkNum, U32 dwStatusControl);
+
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSErrorStatus(
+	U32 dwStatusControl, U32 *dwErrorStatus);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSConfigErrorStatus(
+	U32 dwStatusControl, U32 *dwErrorStatus);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSExternalErrorStatus(
+	U32 dwStatusControl, U32 *dwErrorStatus);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSLinkState(
+	U32 dwStatusControl, U32 *dwLinkStatus);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSIsLinkRunning(
+	U32 dwStatusControl, char *isLinkRunning);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSIsAutoStart(
+	U32 dwStatusControl, char *isAutoStart);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSEnableAutoStart(
+	U32 *dwStatusControl, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSIsStart(
+	U32 dwStatusControl, char *isStart);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSEnableStart(
+	U32 *dwStatusControl, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSIsDisabled(
+	U32 dwStatusControl, char *isDisabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSEnableDisabled(
+	U32 *dwStatusControl, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSIsTristate(
+	U32 dwStatusControl, char *isTristate);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSEnableTristate(
+	U32 *dwStatusControl, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSOperatingSpeed(
+	U32 dwStatusControl, U32 *dwOperatingSpeed);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSSetOperatingSpeed(
+	U32 *dwStatusControl, U32 dwOperatingSpeed);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSOutputPortConnection(
+	U32 dwStatusControl, U32 *dwOutputPortConnection);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_LSPortType(
+	U32 dwStatusControl, U32 *dwPortType);
+
+/* Network discovery information retreival */
+ROUTER_CONFIG_LIBRARY int  ROUTER_CONFIG_CC
+	CFGSpaceWire_GetNetworkDiscoveryValue(star_device_handle hDevice,
+		U32 *dwNetworkDiscovery);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_NDDeviceType(
+	U32 dwNetDisc, U32 *dwDeviceType);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_NDReturnPort(
+	U32 dwNetDisc, U32 *dwReturnPort);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_NDRunningLinks(
+	U32 dwNetDisc, U32 *dwRunningLinks);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_NDNumberLinks(
+	U32 dwNetDisc, U32 *dwNumberLinks);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetNumberLinks(
+	star_device_handle hDevice, U32 *dwNumLinks);
+
+/* Router identity register functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_SetNetworkID(
+	star_device_handle hDevice, U32 dwNetworkID);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetNetworkID(
+	star_device_handle hDevice, U32 *dwNetworkID);
+
+/* Router control register functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_SetPortTimeout(
+	star_device_handle hDevice, char bEnabled,
+	CFG_SPACEWIRE_PORT_TIMEOUT timeout);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetPortTimeout(
+	star_device_handle hDevice, char *bEnabled,
+	CFG_SPACEWIRE_PORT_TIMEOUT *timeout);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_IsPortTimeoutEnabled(
+	star_device_handle hDevice, char *bEnabled);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_SetAsInterface(
+	star_device_handle hDevice, char bEnabled, char bAddIdentifier);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_GetRouterControlRegister(star_device_handle hDevice,
+		U32 *dwRouterCtrlReg);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_SetRouterControlRegister(star_device_handle hDevice,
+		U32 dwRouterCtrlReg);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCGetTimeoutEnabled(
+	U32 dwRouterCtrlReg, char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCSetTimeoutEnabled(
+	U32 *dwRouterCtrlReg, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCGetTimeoutSelection(
+	U32 dwRouterCtrlReg, U32 *dwSelection);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCSetTimeoutSelection(
+	U32 *dwRouterCtrlReg, U32 dwSelection);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCGetDisableOnSilence(
+	U32 dwRouterCtrlReg, char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCSetDisableOnSilence(
+	U32 *dwRouterCtrlReg, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCGetStartOnRequest(
+	U32 dwRouterCtrlReg, char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCSetStartOnRequest(
+	U32 *dwRouterCtrlReg, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCGetSelfAddressing(
+	U32 dwRouterCtrlReg, char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCSetSelfAddressing(
+	U32 *dwRouterCtrlReg, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCGetInterface(
+	U32 dwRouterCtrlReg, char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_RCSetInterface(
+	U32 *dwRouterCtrlReg, char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC
+	CFGSpaceWire_RCGetInterfaceIdentifier(U32 dwRouterCtrlReg, char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC
+	CFGSpaceWire_RCSetInterfaceIdentifier(U32 *dwRouterCtrlReg, char bEnabled);
+
+/* Error active register functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetErrorStatus(
+	star_device_handle hDevice, U32 *dwErrorStatus);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_ClearErrorStatus(
+	star_device_handle hDevice, U32 dwPorts);
+
+/* Time-Code register functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetTimecodeRegister(
+	star_device_handle hDevice, U32 *dwTimecodeReg);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_TCGetValue(
+	U32 dwTimecodeReg, U32 *dwValue);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_TCGetFlags(
+	U32 dwTimecodeReg, U32 *dwValue);
+
+/* Manufacturer and Chip ID register functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetIDRegister(
+	star_device_handle hDevice, U32 *dwIDs);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_IDGetManufacturer(
+	U32 dwIDs, U32 *dwManufacturerID);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_IDGetChipID(U32 dwIDs,
+	U32 *dwChipID);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC CFGSpaceWire_IDGetVersion(U32 dwIDs,
+	U32 *dwVersion);
+
+/* General purpose register functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetGeneralPurposeStatus(
+	star_device_handle hDevice, U32 *dwGeneralPurposeStatus);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_SetGeneralPurposeStatus(
+	star_device_handle hDevice, U32 dwGeneralPurposeStatus);
+
+/* Tick enable register functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_GetTickEnableStatus(
+	star_device_handle hDevice, U32 *dwTickEnableStatus);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC CFGSpaceWire_SetTickEnableStatus(
+	star_device_handle hDevice, U32 dwTickEnableStatus);
+
+
+/* Base Transmit Rate functions */
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_SetRouterBaseTransmitRate(star_device_handle hDevice,
+		U32 dwBaseClkSel);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_GetRouterBaseTransmitRate(star_device_handle hDevice,
+		U32 *dwBaseClkSel);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_SetBrickBaseTransmitRate(star_device_handle hDevice,
+		U32 dwBaseClk, U32 dwBaseDvdr, U32 dwEnableClk);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_GetBrickBaseTransmitRate(star_device_handle hDevice,
+		U32 *dwBaseClk, U32 *dwBaseDvdr, U32 *dwEnableClk);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_GetPrecisionTransmitRegister(star_device_handle hDevice,
+		U32 *dwPrecisionTransmit);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_SetPrecisionTransmitRegister(star_device_handle hDevice,
+		U32 dwPrecisionTransmit);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC
+	CFGSpaceWire_PTGetPrecisionTransmitEnabled(U32 dwPrecisionTransmit,
+		char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC
+	CFGSpaceWire_PTSetPrecisionTransmitEnabled(U32 *dwPrecisionTransmit,
+		char bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC
+	CFGSpaceWire_PTGetPrecisionTransmitReady(U32 dwPrecisionTransmit,
+		char *bEnabled);
+ROUTER_CONFIG_LIBRARY void ROUTER_CONFIG_CC
+	CFGSpaceWire_PTGetPrecisionTransmitInUse(U32 dwPrecisionTransmit,
+		char *bEnabled);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_GetPrecisionTransmitRate(star_device_handle hDevice,
+		double *PrecisionTransmitRate);
+ROUTER_CONFIG_LIBRARY int ROUTER_CONFIG_CC
+	CFGSpaceWire_SetPrecisionTransmitRate(star_device_handle hDevice,
+		double PrecisionTransmitRate);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif	/* SPACEWIRE_ROUTER_LIBRARY */
+
+
+
diff --git a/spw_usb_driver_v2.62/inc/spw_usb_api.h b/spw_usb_driver_v2.62/inc/spw_usb_api.h
new file mode 100755
--- /dev/null
+++ b/spw_usb_driver_v2.62/inc/spw_usb_api.h
@@ -0,0 +1,330 @@
+/******************************************************************************/
+/*                                                                            */
+/*  spw_usb_api.h                                                             */
+/*                                                                            */
+/*  Declaration of the functions provided by the SpaceWire USB API Library    */
+/*  for the SpaceWire USB devices.                                            */
+/*                                                                            */
+/*  Version 2.62, March 11th 2013                                             */
+/*                                                                            */
+/*      Version 2.62, 11/03/13                                                */
+/*      ======================                                                */
+/*      Fixed bug dealing with received traffic which is not a packet.        */
+/*                                                                            */
+/*      Version 2.61, 21/09/12                                                */
+/*      ======================                                                */
+/*      Added support for STAR Fire and WBS II.                               */
+/*                                                                            */
+/*      Version 2.60, 04/01/12                                                */
+/*      ======================                                                */
+/*      Added support for EGSE and SPLT.                                      */
+/*                                                                            */
+/*      Version 2.59, 15/08/11                                                */
+/*      ======================                                                */
+/*      Added support for RTC.                                                */
+/*                                                                            */
+/*      Version 2.5, 12/10/10                                                 */
+/*      =====================                                                 */
+/*      Added support for Link Analyser Mk2.                                  */
+/*                                                                            */
+/*      Version 1.5, 12/03/10                                                 */
+/*      =====================                                                 */
+/*      Added GetFirmwareVersionExtended and restored GetFirmwareVersion to   */
+/*      its original form.                                                    */
+/*                                                                            */
+/*      Version 1.4, 03/03/10                                                 */
+/*      =====================                                                 */
+/*      Fixed bug waiting on a receive to complete.                           */
+/*      Added support for multiple send channels.                             */
+/*      Added functions to get serial number and product ID.                  */
+/*                                                                            */
+/*      Version 1.3, 26/2/09                                                  */
+/*      ====================                                                  */
+/*      Updated the calling convention used in the function declaration to    */
+/*      __stdcall on Windows.                                                 */
+/*                                                                            */
+/*      Version 1.2, 21/1/09                                                  */
+/*      ====================                                                  */
+/*      Updated to compile on both Windows and Linux.                         */
+/*                                                                            */
+/*      Version 1.1, 8/10/06                                                  */
+/*      ====================                                                  */
+/*      Linux release.                                                        */
+/*                                                                            */
+/*      Version 1.0, 24/4/06                                                  */
+/*      ====================                                                  */
+/*      Initial version.                                                      */
+/*                                                                            */
+/*  Copyright (2013), STAR-Dundee Ltd.,                                       */
+/*                    STAR House,                                             */
+/*                    166 Nethergate,                                         */
+/*                    Dundee, DD1 4EE,                                        */
+/*                    Scotland, UK.                                           */
+/*            e-mail: support@star-dundee.com                                 */
+/*                                                                            */
+/******************************************************************************/
+
+
+
+#ifndef SPACEWIRE_USB_API_H
+#define SPACEWIRE_USB_API_H
+
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#include "spacewire_usb.h"
+
+
+
+#if defined(_WIN32) || defined(_WIN64)
+
+
+/* Windows specifc functions and macros */
+
+#ifdef SPACEWIREUSBAPI_EXPORTS
+#define SPACEWIREUSB_API __declspec(dllexport)
+#else
+#define SPACEWIREUSB_API __declspec(dllimport)
+#endif
+
+#ifdef  _WIN64
+#define SPW_USB_API_CC
+#else
+#define SPW_USB_API_CC __stdcall
+#endif	/* WIN64 */
+
+
+#include "windows.h"
+
+	
+#else	/* _WIN32 */
+
+
+/* Linux specific functions and macros */
+
+#define SPACEWIREUSB_API
+#define SPW_USB_API_CC
+
+
+#endif	/* _WIN32 */
+
+
+
+/* Functions provided by the API */
+
+/* General functions */
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_Open(
+	star_device_handle *phDevice, int nDeviceNum);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_Close(
+	star_device_handle hDevice);
+SPACEWIREUSB_API U8 SPW_USB_API_CC USBSpaceWire_CountDevices();
+SPACEWIREUSB_API U32 SPW_USB_API_CC USBSpaceWire_ListDevices();
+SPACEWIREUSB_API double SPW_USB_API_CC USBSpaceWire_GetDriverVersion();
+SPACEWIREUSB_API double SPW_USB_API_CC USBSpaceWire_GetIFVersion();
+SPACEWIREUSB_API double SPW_USB_API_CC USBSpaceWire_GetAPIVersion();
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_SetTimeout(
+	star_device_handle hDevice, double timeout);
+SPACEWIREUSB_API double SPW_USB_API_CC USBSpaceWire_GetTimeout(
+	star_device_handle hDevice);
+SPACEWIREUSB_API U8 SPW_USB_API_CC USBSpaceWire_GetSpaceWireAddress(
+	star_device_handle hDevice);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_SetSpaceWireAddress(
+	star_device_handle hDevice, U8 address);
+SPACEWIREUSB_API U16 SPW_USB_API_CC USBSpaceWire_GetFirmwareVersion(
+	star_device_handle hDevice);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_GetFirmwareVersionExtended(
+	star_device_handle hDevice, SPACEWIRE_FIRMWARE_VERSION *pVersion);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_ClearEndpoints(
+	star_device_handle hDevice);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_ResetDevice(
+	star_device_handle hDevice);
+SPACEWIREUSB_API SPACEWIRE_DEVICE_TYPE SPW_USB_API_CC
+	USBSpaceWire_GetDeviceType(star_device_handle hDevice);
+SPACEWIREUSB_API SPACEWIRE_DEVICE_TYPE SPW_USB_API_CC
+	USBSpaceWire_GetUnopenedDeviceType(int deviceNum);
+SPACEWIREUSB_API U16 SPW_USB_API_CC USBSpaceWire_GetDeviceProductID(
+	star_device_handle hDevice);
+SPACEWIREUSB_API U16 SPW_USB_API_CC USBSpaceWire_GetUnopenedDeviceProductID(
+	int deviceNum);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_EnableHeaderMode(
+	star_device_handle hDevice, char enable);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_IsHeaderModeEnabled(
+	star_device_handle hDevice);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_EnableNetworkMode(
+	star_device_handle hDevice, char enable);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_IsNetworkModeEnabled(
+	star_device_handle hDevice);
+SPACEWIREUSB_API double SPW_USB_API_CC USBSpaceWire_GetUSBVersion(
+	star_device_handle hDevice);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_GetAPIString(char *str);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_GetSerialNumber(
+	star_device_handle hDevice, U8 pSerialNumber[11]);
+
+/* Receive functions */
+SPACEWIREUSB_API unsigned long SPW_USB_API_CC
+	USBSpaceWire_GetDriverDroppedPackets(star_device_handle hDevice);
+SPACEWIREUSB_API unsigned long SPW_USB_API_CC
+	USBSpaceWire_GetDriverDroppedBytes(star_device_handle hDevice);
+SPACEWIREUSB_API unsigned long SPW_USB_API_CC USBSpaceWire_GetDroppedPackets(
+	star_device_handle hDevice);
+SPACEWIREUSB_API unsigned long SPW_USB_API_CC USBSpaceWire_GetDroppedBytes(
+	star_device_handle hDevice);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_RegisterReceiveOnPort(
+	star_device_handle hDevice, U8 port);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_UnregisterReceiveOnPort(
+	star_device_handle hDevice, U8 port);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_RegisterReceiveOnAllPorts(
+	star_device_handle hDevice);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_UnregisterReceiveOnAllPorts(
+	star_device_handle hDevice);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC USBSpaceWire_ReadPackets(
+	star_device_handle hDevice, void *pBuffer, U32 nBufferSize,
+	U32 nPacketNum, char bWait, PUSB_SPACEWIRE_PACKET_PROPERTIES properties,
+	USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_FreeRead(
+	star_device_handle hDevice, USB_SPACEWIRE_ID identifier);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_FreeAllReads(
+	star_device_handle hDevice);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC USBSpaceWire_GetReadStatus(
+	star_device_handle hDevice, USB_SPACEWIRE_ID identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_WaitOnReadCompleting(star_device_handle hDevice,
+		USB_SPACEWIRE_ID identifier, char bWaitIndefinitely);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_EnableReadThrottling(
+	star_device_handle hDevice, char enable);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_IsReadThrottling(
+	star_device_handle hDevice);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_SetDriverReadBufferSize(
+	star_device_handle hDevice, unsigned long nBufferSize);
+SPACEWIREUSB_API unsigned long SPW_USB_API_CC
+	USBSpaceWire_GetDriverReadBufferSize(star_device_handle hDevice);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_SetDriverReadStructsNum(
+	star_device_handle hDevice, unsigned long nStructsNum);
+SPACEWIREUSB_API unsigned long SPW_USB_API_CC
+	USBSpaceWire_GetDriverReadStructsNum(star_device_handle hDevice);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_WaitOnReadPacketAvailable(
+	star_device_handle hDevice, double timeout);
+SPACEWIREUSB_API U32 SPW_USB_API_CC USBSpaceWire_GetReadLength(
+	PUSB_SPACEWIRE_PACKET_PROPERTIES pProperties, U32 nPacketNum);
+SPACEWIREUSB_API USB_SPACEWIRE_EOP_TYPE SPW_USB_API_CC
+	USBSpaceWire_GetReadEOPStatus(PUSB_SPACEWIRE_PACKET_PROPERTIES pProperties,
+		U32 nPacketNum);
+SPACEWIREUSB_API SPACEWIRE_TRAFFIC_TYPE SPW_USB_API_CC
+	USBSpaceWire_GetReadTrafficType(
+		PUSB_SPACEWIRE_PACKET_PROPERTIES pProperties, U32 nPacketNum);
+
+/* Send functions */
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_GetNumberOfSendChannels(
+	star_device_handle hDevice);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC USBSpaceWire_SendPacketTo(
+	star_device_handle hDevice, void *pBuffer, U32 nBufferSize,
+	U8 *pAddress, U32 nAddressLen, char bWait,
+	USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendPacketToOverChannel(star_device_handle hDevice, U8 channel,
+		void *pBuffer, U32 nBufferSize, U8 *pAddress, U32 nAddressLen,
+		char bWait, USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendMultiplePacketsTo(star_device_handle hDevice,
+		void *pBuffer, U32 nPacketSize, U32 nBufferSize, U8 *pAddress,
+		U32 nAddressLen, char bWait, USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendMultiplePacketsToOverChannel(star_device_handle hDevice,
+		U8 channel, void *pBuffer, U32 nPacketSize, U32 nBufferSize,
+		U8 *pAddress, U32 nAddressLen, char bWait,
+		USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendMultiplePacketLengthsTo(star_device_handle hDevice,
+		void **pBuffers, U32 *pPacketSizes, U32 nNumberOfPackets, U8 *pAddress,
+		U32 nAddressLen, char bWait, USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendMultiplePacketLengthsToOverChannel(
+		star_device_handle hDevice, U8 channel, void **pBuffers,
+		U32 *pPacketSizes, U32 nNumberOfPackets, U8 *pAddress, U32 nAddressLen,
+		char bWait, USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC USBSpaceWire_SendPacket(
+	star_device_handle hDevice, void *pBuffer, U32 nBufferSize, char bWait,
+	USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendPacketOverChannel(star_device_handle hDevice, U8 channel,
+		void *pBuffer, U32 nBufferSize, char bWait,
+		USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendMultiplePackets(star_device_handle hDevice, void *pBuffer,
+		U32 nPacketSize, U32 nBufferSize, char bWait,
+		USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendMultiplePacketsOverChannel(star_device_handle hDevice,
+		U8 channel, void *pBuffer, U32 nPacketSize, U32 nBufferSize, char bWait,
+		USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendMultiplePacketLengths(star_device_handle hDevice,
+		void **pBuffers, U32 *pPacketSizes, U32 nNumberOfPackets, char bWait,
+		USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_SendMultiplePacketLengthsOverChannel(
+		star_device_handle hDevice, U8 channel, void **pBuffers,
+		U32 *pPacketSizes, U32 nNumberOfPackets, char bWait,
+		USB_SPACEWIRE_ID *identifier);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_FreeSend(
+	star_device_handle hDevice, USB_SPACEWIRE_ID identifier);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_FreeAllSends(
+	star_device_handle hDevice);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC USBSpaceWire_GetSendStatus(
+	star_device_handle hDevice, USB_SPACEWIRE_ID identifier);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_WaitOnSendCompleting(star_device_handle hDevice,
+		USB_SPACEWIRE_ID identifier, char bWaitIndefinitely);
+SPACEWIREUSB_API U32 SPW_USB_API_CC USBSpaceWire_GetSendSize(
+	star_device_handle hDevice, USB_SPACEWIRE_ID identifier);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_SetDriverSendBufferSize(
+	star_device_handle hDevice, U32 nBufferSize);
+SPACEWIREUSB_API U32 SPW_USB_API_CC USBSpaceWire_GetDriverSendBufferSize(
+	star_device_handle hDevice);
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_EnableSendEEPs(
+	star_device_handle hDevice, char enable);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_IsSendEEPsEnabled(
+	star_device_handle hDevice);
+SPACEWIREUSB_API USB_SPACEWIRE_STATUS SPW_USB_API_CC
+	USBSpaceWire_TunnelSendTraffic(star_device_handle hDevice,
+		SPACEWIRE_TRAFFIC_TYPE type, void *pBuffer, U32 nBufferSize,
+		USB_SPACEWIRE_EOP_TYPE eop, U8 port, char bWait,
+		USB_SPACEWIRE_ID *identifier);
+
+/* Time-code functions */
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_TC_PerformTickIn(
+	star_device_handle hDevice, U8 timein);
+SPACEWIREUSB_API char SPW_USB_API_CC
+	USBSpaceWire_TC_EnableExternalTimecodeSelection(star_device_handle hDevice,
+		char enable);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_TC_Reset(
+	star_device_handle hDevice);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_TC_EnableAutoTickIn(
+	star_device_handle hDevice, char enableAutoTickIns, char enableAllPorts);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_TC_SetAutoTickInFrequency(
+	star_device_handle hDevice, U32 frequency);
+SPACEWIREUSB_API char SPW_USB_API_CC USBSpaceWire_TC_StartReadingTimecodes(
+	star_device_handle hDevice, void *arg, void (*callbackfunc)(
+	star_device_handle hDevice, U8 timecode, void *arg));
+SPACEWIREUSB_API void SPW_USB_API_CC USBSpaceWire_TC_StopReadingTimecodes(
+	star_device_handle hDevice);
+SPACEWIREUSB_API U32 SPW_USB_API_CC USBSpaceWire_TC_GetClockFrequency(
+	star_device_handle hDevice);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif	/* SPACEWIRE_USB_API_H */
+
+
diff --git a/spw_usb_driver_v2.62/inc/star-dundee_types.h b/spw_usb_driver_v2.62/inc/star-dundee_types.h
new file mode 100644
--- /dev/null
+++ b/spw_usb_driver_v2.62/inc/star-dundee_types.h
@@ -0,0 +1,161 @@
+/**
+ * \file star-dundee_types.h
+ * \brief Definitions of STAR-Dundee commonly used types.
+ * \author Stuart Mills\n
+ *         STAR-Dundee\n
+ *         c/o School of Computing\n
+ *         University of Dundee\n
+ *         Dundee, DD1 4HN\n
+ *         Scotland, UK\n
+ *         e-mail: support@star-dundee.com
+ *
+ * This file contains the definitions of common types used by STAR-Dundee
+ * software drivers and APIs.
+ *
+ * <b>IMPORTANT NOTE:</b>
+ * \note            If you are experiencing compilation errors indicating that
+ *                  U8 is already defined, for example, please add the following
+ *                  line to your code prior to including this file:\n
+ *                      <code>\#define NO_STAR_TYPES</code>\n
+ *                  Alternatively you can compile your code with a flag of
+ *                  <code>-DNO_STAR_TYPES</code>.\n
+ *
+ * \version 1.1 - August 22nd 2011\n
+ *          Removed star_device_handle, not required by STAR-System.\n\n
+ *
+ * \version 1.0 - March 22nd 2007\n
+ *          Initial version.\n\n
+ *
+ * Copyright &copy; 2009 STAR-Dundee Ltd
+ */
+
+
+/**
+ * \defgroup STARDundeeTypes STAR-Dundee Types
+ * This section contains the definitions of types used in STAR-Dundee software
+ * drivers and APIs.
+ */
+
+/**
+ * \def TRUE
+ * \ingroup STARDundeeTypes
+ * A value that can be used to represent the boolean value of true.
+ */
+
+/**
+ * \def FALSE
+ * \ingroup STARDundeeTypes
+ * A value that can be used to represent the boolean value of false.
+ */
+
+/**
+ * \typedef U8
+ * \ingroup STARDundeeTypes
+ * A type that can be used to represent an unsigned 8-bit number.
+ */
+
+/**
+ * \typedef U16
+ * \ingroup STARDundeeTypes
+ * A type that can be used to represent an unsigned 16-bit number.
+ */
+
+/**
+ * \typedef U32
+ * \ingroup STARDundeeTypes
+ * A type that can be used to represent an unsigned 32-bit number.
+ */
+
+/**
+ * \typedef REGISTER
+ * \ingroup STARDundeeTypes
+ * A type that can be used to represent a 4-byte register.
+ */
+
+
+#ifndef STAR_DUNDEE_TYPES
+#define STAR_DUNDEE_TYPES
+
+/* Define TRUE and FALSE */
+#ifndef TRUE
+    #define TRUE  1
+#endif
+#ifndef FALSE
+    #define FALSE 0
+#endif
+
+#ifndef NO_STAR_TYPES
+
+#if (defined(__linux__) || defined(LINUX) || defined(__LINUX__) || \
+    defined(__CYGWIN__)) && defined(__KERNEL__)
+
+    #include <linux/types.h>
+
+    /* Define U8, U16 and U32 in the Linux kernel */
+    #ifndef U8
+        typedef u8	U8;
+    #endif
+    #ifndef U16
+        typedef u16	U16;
+    #endif
+    #ifndef U32
+        typedef u32	U32;
+    #endif
+    
+#else
+    
+    #include <limits.h>
+
+    /* Define U8 */
+    #ifndef U8
+        #if (UCHAR_MAX == 0xff)
+            typedef unsigned char	U8;
+        #elif (UINT_MAX == 0xff)
+            typedef unsigned int	U8;
+        #else
+            #error "No valid definition of U8 available"
+        #endif
+    #endif
+
+    /* Define U16 */
+    #ifndef U16
+        #if (USHRT_MAX == 0xffff)
+            typedef unsigned short	U16;
+        #elif (UINT_MAX == 0xffff)
+            typedef unsigned int	U16;
+        #elif (UCHAR_MAX == 0xffff)
+            typedef unsigned char	U16;
+        #else
+            #error "No valid definition of U16 available"
+        #endif
+    #endif
+
+    /* Define U32 */
+    #ifndef U32
+        #if (UINT_MAX == 0xffffffff)
+            typedef unsigned int	U32;
+        #elif (ULONG_MAX == 0xffffffff)
+            typedef unsigned long	U32;
+        #elif (USHRT_MAX == 0xffffffff)
+            typedef unsigned short	U32;
+        #elif (UCHAR_MAX == 0xffffffff)
+            typedef unsigned char	U32;
+        #else
+            #error "No valid definition of U32 available"
+        #endif
+    #endif
+
+#endif /* Linux kernel test */
+        
+
+#endif	/* NO_STAR_TYPES */
+
+/* Define REGISTER */
+#ifndef REGISTER
+    typedef U32 REGISTER;
+#endif
+
+
+#endif	/* STAR_DUNDEE_TYPES */
+
+
diff --git a/spw_usb_driver_v2.62/inc/star_dundee_types.h b/spw_usb_driver_v2.62/inc/star_dundee_types.h
new file mode 100755
--- /dev/null
+++ b/spw_usb_driver_v2.62/inc/star_dundee_types.h
@@ -0,0 +1,97 @@
+/******************************************************************************/
+/*                                                                            */
+/*  star_dundee_types.h                                                       */
+/*                                                                            */
+/*  This file contains the definitions of common types used by STAR-Dundee    */
+/*  drivers and APIs.                                                         */
+/*                                                                            */
+/*  IMPORTANT NOTE: If you are experiencing compilation errors indicating     */
+/*                  that U8 is already defined, for example, please add the   */
+/*                  following line to your code prior to including this       */
+/*                  file:                                                     */
+/*                      #define NO_STAR_TYPES                                 */
+/*                  Alternatively you can compile your code with a flag of    */
+/*                  -DNO_STAR_TYPES.                                          */
+/*                                                                            */
+/*  Version 1.0, March 22nd 2007                                              */
+/*                                                                            */
+/*          Version 1.0 - March 22nd 2007                                     */
+/*          ===========                                                       */
+/*          Initial version.                                                  */
+/*                                                                            */
+/*  Copyright (2012), STAR-Dundee Ltd.,                                       */
+/*                    STAR House,                                             */
+/*                    166 Nethergate,                                         */
+/*                    Dundee, DD1 4EE,                                        */
+/*                    Scotland, UK.                                           */
+/*            e-mail: support@star-dundee.com                                 */
+/*                                                                            */
+/******************************************************************************/
+
+
+
+#ifndef STAR_DUNDEE_TYPES
+#define STAR_DUNDEE_TYPES
+
+
+typedef void *star_device_handle;
+
+
+#ifndef NO_STAR_TYPES
+
+#if (defined(__linux__) || defined(LINUX) || defined(__LINUX__)) && \
+	defined(__KERNEL__)
+
+	#include <linux/types.h>
+
+	/* Define U8, U16 and U32 in the Linux kernel */
+	typedef u8	U8;
+	typedef u16	U16;
+	typedef u32	U32;
+	
+#else
+	
+	#include <limits.h>
+
+	/* Define U8 */
+	#if (UCHAR_MAX == 0xff)
+		typedef unsigned char	U8;
+	#elif (UINT_MAX == 0xff)
+		typedef unsigned int	U8;
+	#else
+		#error "No valid definition of U8 available"
+	#endif
+
+	/* Define U16 */
+	#if (USHRT_MAX == 0xffff)
+		typedef unsigned short	U16;
+	#elif (UINT_MAX == 0xffff)
+		typedef unsigned int	U16;
+	#elif (UCHAR_MAX == 0xffff)
+		typedef unsigned char	U16;
+	#else
+		#error "No valid definition of U16 available"
+	#endif
+
+	/* Define U32 */
+	#if (UINT_MAX == 0xffffffff)
+		typedef unsigned int	U32;
+	#elif (ULONG_MAX == 0xffffffff)
+		typedef unsigned long	U32;
+	#elif (USHRT_MAX == 0xffffffff)
+		typedef unsigned short	U32;
+	#elif (UCHAR_MAX == 0xffffffff)
+		typedef unsigned char	U32;
+	#else
+		#error "No valid definition of U32 available"
+	#endif
+
+#endif /* Linux kernel test */
+		
+
+#endif	/* NO_STAR_TYPES */
+
+
+#endif	/* STAR_DUNDEE_TYPES */
+
+
diff --git a/spw_usb_driver_v2.62/lib/i386/spacewire_cuba_software b/spw_usb_driver_v2.62/lib/i386/spacewire_cuba_software
new file mode 100755
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..b688714265809f1a96871a0774c9e91bf18f3075
GIT binary patch
literal 71192
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
U^D@uOWQ2^ZfrcouK$&g)AKz(7nE(I)

diff --git a/spw_usb_driver_v2.62/lib/x86_64/spacewire_cuba_software b/spw_usb_driver_v2.62/lib/x86_64/spacewire_cuba_software
new file mode 100755
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..4058ad6f47b920a85413bd85f6826d3599014a53
GIT binary patch
literal 80878
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
Ee?JjWr~m)}