CArcPCIe.h

Go to the documentation of this file.

// +------------------------------------------------------------------------------------------------------------------+
// |  FILE:  CArcPCIe.h                                                                                               |
// +------------------------------------------------------------------------------------------------------------------+
// |  PURPOSE: This file defines the ARC-66 PCIe device class.                                                        |
// |                                                                                                                  |
// |  AUTHOR:  Scott Streit         DATE: ?                                                                           |
// |                                                                                                                  |
// |  Copyright Astronomical Research Cameras, Inc. All rights reserved.                                              |
// +------------------------------------------------------------------------------------------------------------------+
#pragma once
 
#ifdef _WINDOWS
    #pragma warning( disable: 4251 )
#endif
 
#include <string_view>
#include <filesystem>
#include <charconv>
#include <string>
#include <vector>
#include <memory>
#include <list>
 
#include <CArcDeviceDllMain.h>
#include <CArcBase.h>
#include <CArcPCIBase.h>
#include <ArcDefs.h>
 
 
namespace arc
{
    namespace gen3
    {
 
        namespace device
        {
 
            typedef enum class PCIeRegs : std::uint32_t
            {
                LCL_CFG_BAR = 0x00,
                DEV_REG_BAR = 0x02
            } ePCIeRegs;
 
 
            typedef enum class PCIeRegOffsets : std::uint32_t
            {
                REG_CMD_HEADER          = 0x00,
                REG_CMD_COMMAND         = 0x04,
                REG_CMD_ARG0            = 0x08,
                REG_CMD_ARG1            = 0x0C,
                REG_CMD_ARG2            = 0x10,
                REG_CMD_ARG3            = 0x14,
                REG_CMD_ARG4            = 0x18,
                REG_CTLR_SPECIAL_CMD    = 0x1C,
                REG_RESET               = 0x20,
                REG_INIT_IMG_ADDR       = 0x38,
                REG_FIBER_2X_CTRL       = 0x5C,
                REG_STATUS              = 0x60,
                REG_CMD_REPLY           = 0x64,
                REG_CTLR_ARG1           = 0x68,
                REG_CTLR_ARG2           = 0x6C,
                REG_PIXEL_COUNT         = 0x70,
                REG_FRAME_COUNT         = 0x74,
                REG_ID_LO               = 0x78,
                REG_ID_HI               = 0x7C
            } ePCIeRegOffsets;
 
 
            typedef enum class RegCmds : std::uint32_t
            {
                CONTROLLER_GET_ID = 0x09,
                CONTROLLER_RESET  = 0x0B
            } eRegCmds;
 
 
            typedef enum class Fiber2x : std::uint32_t
            {
                FIBER_2X_DISABLE,
                FIBER_2X_ENABLE
            } eFiber2x;
 
 
            typedef enum class Fiber : std::uint32_t
            {
                FIBER_A,
                FIBER_B
            } eFiber;
 
        }   // end device namespace
 
 
        class GEN3_CARCDEVICE_API CArcPCIe : public CArcPCIBase
        {
            public:
 
                CArcPCIe( void );
 
                virtual ~CArcPCIe( void );
 
                constexpr std::string_view toString( void );
 
                //  PCI(e) configuration space access
                // +-------------------------------------------------+
 
                std::uint32_t getCfgSpByte( const std::uint32_t uiOffset );
                
                std::uint32_t getCfgSpWord( const std::uint32_t uiOffset );
 
                std::uint32_t getCfgSpDWord( const std::uint32_t uiOffset );
 
                void setCfgSpByte( const std::uint32_t uiOffset, const std::uint32_t uiValue );
 
                void setCfgSpWord( const std::uint32_t uiOffset, const std::uint32_t uiValue );
                
                void setCfgSpDWord( const std::uint32_t uiOffset, const std::uint32_t uiValue );
 
                void getCfgSp( void );
                
                void getBarSp( void );
 
 
                //  Device access
                // +-------------------------------------------------+
 
                static void findDevices( void );
 
                static std::uint32_t deviceCount( void ) noexcept;
 
                static const std::weak_ptr<std::string[]> getDeviceStringList( void ) noexcept;
 
                bool isOpen( void ) noexcept;
                
                void open( const std::uint32_t uiDeviceNumber = 0 );
                
                void open( const std::uint32_t uiDeviceNumber, const std::uint32_t uiBytes );
                
                void open( const std::uint32_t uiDeviceNumber, const std::uint32_t uiRows, const std::uint32_t uiCols );
                
                void close( void );
 
                void reset( void );
 
                bool getCommonBufferProperties( void );
 
                void mapCommonBuffer( std::size_t uiBytes = 0 );
                
                void unMapCommonBuffer( void );
 
                std::uint32_t getId( void );
                
                std::uint32_t getStatus( void );
                
                void clearStatus( void );
 
                void set2xFOTransmitter( bool bOnOff );
 
                void loadDeviceFile( const std::filesystem::path& tFile );
 
    
                //  Setup & General commands
                // +-------------------------------------------------+
 
                std::uint32_t command( const std::initializer_list<const std::uint32_t>& tCmdList );
 
                std::uint32_t getControllerId( void );
                
                void resetController( void );
                
                bool isControllerConnected( void );
 
                bool isFiberConnected( arc::gen3::device::eFiber eFiberId = arc::gen3::device::eFiber::FIBER_A );
 
                //  Expose commands
                // +-------------------------------------------------+
 
                void stopExposure( void );
                
                bool isReadout( void );
                
                std::uint32_t getPixelCount( void );
                
                std::uint32_t getCRPixelCount( void );
                
                std::uint32_t getFrameCount( void );
 
                //  PCIe only methods
                // +-------------------------------------------------+
 
                void writeBar( arc::gen3::device::ePCIeRegs eBar, const std::uint32_t uiOffset, const std::uint32_t uiValue );
 
                std::uint32_t readBar( arc::gen3::device::ePCIeRegs eBar, const std::uint32_t uiOffset );
 
                std::uint32_t readReply( double fTimeOutSecs = 1.5 );
 
                //  PCIe Board ID Constant
                // +-------------------------------------------------+
 
                static constexpr auto ID                = static_cast< std::uint32_t >( 0x41524336 );
 
                //  Driver ioctl commands                                                      
                // +-----------------------------------------------------------------------------+
 
                static constexpr auto ARC_READ_BAR      = static_cast< std::uint32_t >( 0x01 );
 
                static constexpr auto ARC_WRITE_BAR     = static_cast< std::uint32_t >( 0x02 );
    
                static constexpr auto ARC_BAR_SIZE      = static_cast< std::uint32_t >( 0x03 );
 
                static constexpr auto ARC_READ_CFG_8    = static_cast< std::uint32_t >( 0x04 );
                
                static constexpr auto ARC_READ_CFG_16   = static_cast< std::uint32_t >( 0x05 );
                
                static constexpr auto ARC_READ_CFG_32   = static_cast< std::uint32_t >( 0x06 );
 
                static constexpr auto ARC_WRITE_CFG_8   = static_cast< std::uint32_t >( 0x07 );
                
                static constexpr auto ARC_WRITE_CFG_16  = static_cast< std::uint32_t >( 0x08 );
                
                static constexpr auto ARC_WRITE_CFG_32  = static_cast< std::uint32_t >( 0x09 );
 
                static constexpr auto ARC_BUFFER_PROP   = static_cast< std::uint32_t >( 0x0A );
 
                static constexpr auto ARC_MEM_MAP       = static_cast< std::uint32_t >( 0x0C );
 
                static constexpr auto ARC_MEM_UNMAP     = static_cast< std::uint32_t >( 0x0D );
 
                // +----------------------------------------------------------------------------
                // |  Status register definitions and functions
                // +----------------------------------------------------------------------------
 
                static constexpr auto PCIe_STATUS_CLEAR_ALL = static_cast< std::uint32_t >( 0x7F );
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusReplyRecvd;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusControllerReset;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusReadout;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusIdle;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusCmdSent;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusImageReadTimeOut;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusHeaderError;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusFiber2xReceiver;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusFiberAConnected;
 
                std::function<bool( const std::uint32_t )> fnPCIeStatusFiberBConnected;
 
            protected:
 
                static constexpr auto ARC_MIN_BAR = static_cast< std::uint32_t >( 0 );
                
                static constexpr auto ARC_MAX_BAR = static_cast< std::uint32_t >( 5 );
 
                std::uint32_t getContinuousImageSize( const std::uint32_t uiImageSize );
 
                std::uint32_t smallCamDLoad( const std::uint32_t uiBoardId, const std::vector<std::uint32_t>* pvData );
 
                void loadGen23ControllerFile( const std::filesystem::path& tFilename, bool bValidate, bool* pAbort = nullptr );
 
                void setByteSwapping( void );
 
                void getLocalConfiguration( void );
 
                std::function<std::uint32_t( const std::uint16_t )> m_fnValidDeviceVendorId;
 
                std::function<void( const std::uint32_t )>  m_fnVerify24Bits;
 
                static std::unique_ptr<std::vector<arc::gen3::arcDev_t>> m_pvDevList;
 
                static std::shared_ptr<std::string[]> m_psDevList;
        };
 
    }   // end gen3 namespace
}   // end arc namespace