CArcPCIeBase.h

// +------------------------------------------------------------------------------------------------------------------+
// |  FILE:  ArcPCIBase.h                                                                                             |
// +------------------------------------------------------------------------------------------------------------------+
// |  PURPOSE: This file defines the ARC PCI device interface. All ARC PCI(e) devices use this class, which provides  |
// |           a set of standard PCI(e) Type 0 header get/set methods.                                                |
// |                                                                                                                  |
// |  AUTHOR:  Scott Streit         DATE: July 16, 2013                                                               |
// |                                                                                                                  |
// |  Copyright 2013 Astronomical Research Cameras, Inc. All rights reserved.                                         |
// +------------------------------------------------------------------------------------------------------------------+
#pragma once
 
#ifdef _WINDOWS
    #pragma warning( disable: 4251 )
#endif
 
#include <cstdint>
#include <vector>
#include <string>
#include <memory>
#include <iomanip>
#include <type_traits>
 
#include <CArcDeviceDllMain.h>
#include <CArcStringList.h>
#include <CArcBase.h>
 
using namespace std::string_literals;
 
 
 
namespace arc
{
    namespace gen4
    {
 
        // +-----------------------------------------------------------------------------------------------------+
        // |  PCIe Base Class                                                                                    |
        // +-----------------------------------------------------------------------------------------------------+
 
        class GEN4_CARCDEVICE_API CArcPCIeBase : public CArcBase
        {
            public:
 
                // */
                //CArcPCIeBase( void );
 
                virtual ~CArcPCIeBase( void ) = default;
 
                template<typename T = std::uint32_t> std::uint64_t readConfigSpaceRegister( std::uint64_t uiAddress );
 
                template<typename T = std::uint32_t> void writeConfigSpaceRegister( std::uint32_t uiAddress, std::uint32_t uiValue );
 
                const std::string readConfigSpace( void );
 
                const std::string readConfigSpaceExpanded( void );
 
            protected:
 
                CArcPCIeBase( void ) = default;
 
                CArcPCIeBase( const CArcPCIeBase& ) = delete;
 
                CArcPCIeBase( CArcPCIeBase&& ) = delete;
 
                CArcPCIeBase& operator=( const CArcPCIeBase& ) = delete;
 
                CArcPCIeBase& operator=( CArcPCIeBase&& ) = delete;
 
                void readPCIeCapabilitiesToStream( std::ostream& oss, bool bShowExtended = false, std::size_t uiDotLength = 58 );
 
                template<typename T = std::uint32_t> auto registerToStream( std::ostream& oss, const std::string& sRegName, std::uint64_t& uiAddress, std::size_t uiDotLength = 58 )
                {
                    auto uiRegValue = readConfigSpaceRegister<T>( uiAddress );
 
                    oss << "0x" << std::setfill( '0' ) << std::setw( 2 ) << uiAddress << setDots( ( "\t" + sRegName ), uiDotLength, ' ' )
                        << "0x" << std::uppercase << std::setw( 8 ) << std::hex << uiRegValue << std::endl;
                    
                    uiAddress += sizeof( T );
 
                    return uiRegValue;
                }
 
                virtual bool readConfigSpace8( std::uint64_t uiAddress, std::uint64_t* pRegValue ) const noexcept  = 0;
 
                virtual bool readConfigSpace16( std::uint64_t uiAddress, std::uint64_t* pRegValue ) const noexcept = 0;
 
                virtual bool readConfigSpace32( std::uint64_t uiAddress, std::uint64_t* pRegValue ) const noexcept = 0;
 
                virtual bool readConfigSpace64( std::uint64_t uiAddress, std::uint64_t* pRegValue ) const noexcept = 0;
 
                virtual bool writeConfigSpace8( const std::uint32_t uiAddress, const std::uint32_t uiValue ) const noexcept  = 0;
 
                virtual bool writeConfigSpace16( const std::uint32_t uiAddress, const std::uint32_t uiValue ) const noexcept = 0;
 
                virtual bool writeConfigSpace32( const std::uint32_t uiAddress, const std::uint32_t uiValue ) const noexcept = 0;
 
                static const std::string m_printSeperator;      
        };
 
 
        template<typename T> std::uint64_t arc::gen4::CArcPCIeBase::readConfigSpaceRegister( const std::uint64_t uiAddress )
        {
            std::uint64_t uiRegValue = 0;
 
            if constexpr ( std::is_same_v<T, std::uint8_t> )
            {
                if ( !readConfigSpace8( uiAddress, &uiRegValue ) )
                {
                    #ifdef __cpp_lib_format
 
                        throwArcGen4Error( "Failed to read BYTE value at PCIe configuration space address: {}. {}"sv, uiAddress, CArcBase::getSystemErrorMessage() );
 
                    #else
 
                        throwArcGen4Error( arc::gen4::CArcBase::formatString( "Failed to read BYTE value at PCIe configuration space address: %u. %e", uiAddress, CArcBase::getSystemError() ) );
 
                    #endif
                }
            }
 
            else if constexpr ( std::is_same_v<T, std::uint16_t> )
            {
                if ( !readConfigSpace16( uiAddress, &uiRegValue ) )
                {
                    #ifdef __cpp_lib_format
 
                        throwArcGen4Error( "Failed to read WORD value at PCIe configuration space address: {}. {}"sv, uiAddress, CArcBase::getSystemErrorMessage() );
 
                    #else
 
                        throwArcGen4Error( arc::gen4::CArcBase::formatString( "Failed to read WORD value at PCIe configuration space address: %u. %e", uiAddress, CArcBase::getSystemError() ) );
 
                    #endif
                }
            }
 
            else if constexpr ( std::is_same_v<T, std::uint32_t> )
            {
                if ( !readConfigSpace32( uiAddress, &uiRegValue ) )
                {
                    #ifdef __cpp_lib_format
 
                        throwArcGen4Error( "Failed to read DWORD value at PCIe configuration space address: {}. {}"sv, uiAddress, CArcBase::getSystemErrorMessage() );
 
                    #else
 
                        throwArcGen4Error( arc::gen4::CArcBase::formatString( "Failed to read DWORD value at PCIe configuration space address: %u. %e", uiAddress, CArcBase::getSystemError() ) );
 
                    #endif
                }
            }
 
            else if constexpr ( std::is_same_v<T, std::uint64_t> )
            {
                if ( !readConfigSpace64( uiAddress, &uiRegValue ) )
                {
                    #ifdef __cpp_lib_format
 
                        throwArcGen4Error( "Failed to read QWORD value at PCIe configuration space address: {}. {}"sv, uiAddress, CArcBase::getSystemErrorMessage() );
 
                    #else
                    
                        throwArcGen4Error( arc::gen4::CArcBase::formatString( "Failed to read QWORD value at PCIe configuration space address: %u. %e", uiAddress, CArcBase::getSystemError() ) );
 
                    #endif
                }
            }
 
            else
            {
                throwArcGen4Error( "Invalid type for reading PCIe configuration space! Can only be one of std::uint8/16/32/64_t"sv );
            }
 
            return uiRegValue;
        }
 
 
        template<typename T> void arc::gen4::CArcPCIeBase::writeConfigSpaceRegister( std::uint32_t uiAddress, std::uint32_t uiValue )
        {
            if constexpr ( std::is_same_v<T, std::uint8_t> )
            {
                if ( !writeConfigSpace8( uiAddress, uiValue ) )
                {
                    #ifdef __cpp_lib_format
 
                        throwArcGen4Error( "Failed to write BYTE value to PCIe configuration space address: {}. {}"sv, uiAddress, CArcBase::getSystemErrorMessage() );
 
                    #else
 
                        throwArcGen4Error( arc::gen4::CArcBase::formatString( "Failed to write BYTE value to PCIe configuration space address: %u. %e", uiAddress, CArcBase::getSystemError() ) );
 
                    #endif
                }
            }
 
            else if constexpr ( std::is_same_v<T, std::uint16_t> )
            {
                if ( !writeConfigSpace16( uiAddress, uiValue ) )
                {
                    #ifdef __cpp_lib_format
 
                        throwArcGen4Error( "Failed to write WORD value to PCIe configuration space address: {}. {}"sv, uiAddress, CArcBase::getSystemErrorMessage() );
 
                    #else
 
                        throwArcGen4Error( arc::gen4::CArcBase::formatString( "Failed to write WORD value to PCIe configuration space address: %u. %e", uiAddress, CArcBase::getSystemError() ) );
 
                    #endif
                }
            }
 
            else if constexpr ( std::is_same_v<T, std::uint32_t> )
            {
                if ( !writeConfigSpace32( uiAddress, uiValue ) )
                {
                    #ifdef __cpp_lib_format
 
                        throwArcGen4Error( "Failed to write DWORD value to PCIe configuration space address: {}. {}"sv, uiAddress, CArcBase::getSystemErrorMessage() );
 
                    #else
 
                        throwArcGen4Error( arc::gen4::CArcBase::formatString( "Failed to write DWORD value to PCIe configuration space address: %u. %e", uiAddress, CArcBase::getSystemError() ) );
 
                    #endif
                }
            }
 
            else
            {
                throwArcGen4Error( "Invalid type for writing PCIe configuration space! Can only be one of std::uint8/16/32_t"sv );
            }
        }
 
    }   // end gen4 namespace
}       // end arc namespace