cinoscopmodule.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSCOPMODULE_H
#define INC_CINOSCOPMODULE_H
 
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
 
#define DF_INOS_COP_MAX_MODULES         16
 
#define DF_INOS_COP_PORT_ADDRESS        0x80000000  
#define DF_INOS_COP_PORT_MEMORY_SIZE    256         
 
#define DF_INOS_COP_RAM_ADDRESS         0x00000000UL    
#define DF_INOS_COP_RAM_MEMORY_SIZE     512         
 
// port numbers
#define DF_INOS_COP_PORT_RAM_ADR        0xF8        
#define DF_INOS_COP_PORT_RAM_DAT        0xF9        
#define DF_INOS_COP_PORT_STATUS         0xFC        
#define DF_INOS_COP_PORT_APPREV         0xFE        
#define DF_INOS_COP_PORT_SEQREV         0xFF        
 
#define DF_INOS_COP_PORT_ENABLE_WRITE   0x4000      
 
#define DF_INOS_COP_FLAG_EEPROM_VALID   0x00000001
#define DF_INOS_COP_FLAG_XML_MOD_VALID  0x00000002
#define DF_INOS_COP_FLAG_RAM_PROTECT    0x00000004
#define DF_INOS_COP_FLAG_LITTLE_ENDIAN  0x00000008
#define DF_INOS_COP_FLAG_INFO_1         0x00000010
 
// startup action options
#define DF_INOS_COP_STRT_OPTION_SLOW    0x00000001  
 
 
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//  
// system
 
// C++
#include <vector>
//  
// project
#include <xmlparser.h>
 
class CINOSIncoAction;
 
 
//------------------------------------------------------------------------------
// structures 
//------------------------------------------------------------------------------
 
struct SINOSCOPModule
{
    enum {
        eOptSubName = 0x00000001
    };
    
    inosName32 m_cName;
    uint32 m_uAddress;
    uint32 m_uEepromSize;
    // channel names)
    uint32 m_uOptions;
    uint32 m_uVendorId;
    char m_cProductCode[16];
    char m_cRevision[16];
 
    DECLARE_DYNAMIC(SINOSCOPModule);
};
 
#if INOS_BYTE_ORDER == INOS_LITTLE_ENDIAN
struct SINOSCOPBoardInfo
{
    // --- start of header ---
    uint8 m_uChecksum;
    uint8 m_uDataOffset;
    uint16 m_uVersion;
    uint32 m_uCardNumber;
    char m_cCardName[24];
    char m_cRevision[4];
    uint32 m_uWorkNumber;
    uint64 m_uMacNumber;
    uint32 m_uSeriesNumber;
    uint32 m_uOptions;
};
#else
struct SINOSCOPBoardInfo
{
    // --- start of header ---
    uint16 m_uVersion;
    uint8 m_uDataOffset;
    uint8 m_uChecksum;
    uint32 m_uCardNumber;
    char m_cCardName[24];
    char m_cRevision[4];
    uint32 m_uWorkNumber;
    uint64 m_uMacNumber;
    uint32 m_uSeriesNumber;
    uint32 m_uOptions;
};
#endif
// version 2.00
struct SINOSCOPModuleEeprom:SINOSCOPBoardInfo
{
    uint8 m_uReserved[8];
 
    uint8 m_uData[1024-64];
 
    // methods
    uint8 GetChecksum(uint32 auLength);
    void SetChecksum();
    bool ChecksumOk();
    void Clear();
 
    DECLARE_DYNAMIC(SINOSCOPModuleEeprom);
};
//
//------------------------------------------------------------------------------
// forwards
//------------------------------------------------------------------------------
 
class CINCOCOPDevice;
class CINOSCOPMaster;
class CINOSBusPortHandlerRangeCondition;
 
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
 
class CINOSCOPModule
{
    //--- user interface ---------------------------------------------------
 
    public :
        const char* GetName()
            { return &m_pDesc->m_cName[0]; };
        const char* GetInfo()
            { return m_cTargetInfo; };
        const char* GetStateText();
        uint32 GetAddress()
            { return m_pDesc->m_uAddress; };
        void* GetEepromAddress(uint32 auOffset)
            { return (void*)((uintptr)&m_Eeprom+auOffset); };
        void* GetEepromAddress(const char* apName, uint32 auOffset);
        uint32 GetEepromSize()
            { return sizeof(m_Eeprom); };
        XMLNode GetXmlNode()
            { return m_CardNode; };
        CINCOObject* GetInco()
            { return m_pInco; };
        virtual const char* GetXmlCompressedAddr();
        virtual uint32 GetXmlSize();
        virtual uint32 GetXmlCompressedSize();
 
        bool HasRamPortsProtected() {
            return m_uFlags & DF_INOS_COP_FLAG_RAM_PROTECT;
        }
 
        bool IsRamLittleEndian() {
            return m_uFlags & DF_INOS_COP_FLAG_LITTLE_ENDIAN;
        }
 
        void GetBoardInfo(SINOSCOPModuleEeprom& aBoardInfo, bool& abEepromValid) {
            aBoardInfo=m_Eeprom;
            abEepromValid=((m_uFlags&DF_INOS_COP_FLAG_EEPROM_VALID)?true:false);
        };
        void SetBoardInfo(SINOSCOPModuleEeprom& aBoardInfo) {
            memcpy(&m_Eeprom, &aBoardInfo, sizeof(aBoardInfo));
            UpdateTargetString();
        };
 
        uint32 GetFpgaRevision() {
            return m_uFpgaRevision;
        }
        uint16 GetAddressSwitch() {
            return m_uAddressSwitch;
        }
 
        void FixPortRegistration();
 
        void Startup();
 
        CINOSCOPModule* GetNext()
            { return m_pNext;};
        void SetNext(CINOSCOPModule* apNext)
            { m_pNext = apNext;};
        void SetDistributionModule(CINOSCOPModule* apDist, char* apXml);
 
        uint32 PutBlock32(uint32 auDest, uint32* apSource, uint16 auNumber,
                uint32 auFlags = 0);
 
        uint32 GetBlock32(uint32 auSource, uint32* apDest, uint16 auNumber,
                uint32 auFlags = 0);
 
        uint32 PutBlock16(uint32 auDest, uint16* apSource, uint16 auNumber, uint32 auFlags = 0);
        uint32 GetBlock16(uint32 auSource, uint16* apDest, uint16 auNumber, uint32 auFlags = 0);
 
        uint32 PutBlock8(uint32 auDest, uint8* apSource, uint16 auNumber,
                uint32 auFlags = 0);
 
        uint32 GetBlock8(uint32 auSource, uint8* apDest, uint16 auNumber,
                uint32 auFlags = 0);
 
        uint32 PortPut16(uint16 auNumber, uint16 auValue);
        uint32 PortGet16(uint16 auNumber, uint16& auValue);
 
        uint32 PortPut32(uint16 auNumber, uint32 auValue);
        uint32 PortGet32(uint16 auNumber, uint32& auValue);
 
        #if defined(INOS_PORTS_64BIT)
        uint32 PortPut64(uint16 auNumber, uint64 auValue);
        uint32 PortGet64(uint16 auNumber, uint64& auValue);
        #endif
 
        uint32 GetVariable(const char* apName, real64& arValue);
        uint32 GetVariable(const char* apName, char* apValue, uint32 auLength);
 
        uint32 GetVariableEx(const char* apName, uint32 auIncoType, void* apValue, uint32 auSize);
 
        uint32 PutVariable(const char* apName, real64 arValue);
        uint32 PutVariable(const char* apName, const char* apValue);
 
        uint32 CallProcedure(const char* apName, long aiNrOfParameters,
                void* apParameters, void* apResult);
 
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSCOPMaster;
 
    // public member functions but just for internal use
    public :
        CINOSCOPModule(CINOSCOPMaster* apMaster, SINOSCOPModule* apDesc,
                SINOSCOPModuleEeprom* apEeprom, XMLNode aCardNode,
                CINCOCOPDevice* apDevice, bool abOnline);
        virtual ~CINOSCOPModule();
        
        CINCOCOPDevice* GetDevice() {
            return m_pDevice;
        };
 
        void RegisterRam();
 
        bool CheckRangeCondition(CINOSBusPortHandlerRangeCondition* apCond);
 
        void ResolveEepromValues(XMLNode& aAction);
 
        template<class T> T GetEepromValue(uint32 auOffset) {
            // get according address
            void* p = GetEepromAddress(auOffset);
            #if INOS_BYTE_ORDER == INOS_LITTLE_ENDIAN
            // check size
            switch (sizeof(T)){
                case 1 : return *((T*) ((uintptr)p^3));
                case 2 : return *((T*) ((uintptr)p^2));
                case 4 : return *((T*)p);
                case 8 : {
                    uint64 u = (uint64(*((T*)p))<<32) + *((T*)((uintptr)p+4));
                    return *((T*)&u);
                }
            }
            #else
            return *((T*)p);
            #endif
            // keep compiler happy
            return (T)0;
        }
 
        // eeprom handling routines
 
        virtual uint32 EepromRead();
        virtual uint32 EepromWrite();
        void UpdateTargetString();
 
        void SetXmlModValid(bool abXmlModValid) {
            m_uFlags=(m_uFlags&~DF_INOS_COP_FLAG_XML_MOD_VALID)|
                    (abXmlModValid?DF_INOS_COP_FLAG_XML_MOD_VALID:0);
        }
 
        void SetXmlMod(const char* apModXml) {
            m_pModXml=apModXml;
        }
 
        bool IsOnline();
 
        bool IsEepromValid()
            {
                return (m_uFlags&DF_INOS_COP_FLAG_EEPROM_VALID);
            }
 
        void FixPortRegistration(CINCOItem* apItem, uint32* apTable,
                uint32 auTableSize);
 
        void EnablePortCache();
 
        void DisablePortCache();
 
        void SetupPortCache(uint16 auNumber, uint8 auSize, const char* apType);
 
        void UpdatePortCache(uint16 auNumber, uint8 auSize);
 
        bool IsPortCachable(uint16 auNumber)
            { return m_uPortCachable[auNumber>>5] & (1<<(auNumber&0x1f)); }
 
        bool IsPortCached(uint16 auNumber)
            { return (m_ePortCache == ePortCacheEnabled) && (m_uPortCacheValid[auNumber>>5] & (1<<(auNumber&0x1f))); }
 
    // private members
    private :
 
        enum {
            eCnsUpdateCacheOk = 3,      // number of requested successful port reads
            eCnsUpdateCacheMax = 16,    // max. allowed reads
        };
 
        CINOSCOPMaster* m_pMaster;
        CINCOCOPDevice* m_pDevice;
        SINOSCOPModule* m_pDesc;
        SINOSCOPModuleEeprom m_Eeprom;
        uint32 m_uFlags;
        char m_cEepromInfo[256];
        uint32 m_uFpgaRevision;
        uint16 m_uAddressSwitch;
        char m_cTargetInfo[256];
        uint16 m_uMemoryPortSize;
        uint32 m_uMemoryPortBgn;
        uint32 m_uMemoryPortEnd;
        uint32 m_uMemoryRam16BitSize;
        uint32 m_uMemoryRamBgn;
        uint32 m_uMemoryRamEnd;
        enum EPortCacheState {
            ePortCacheDisabled,
            ePortCacheEnabled
        } m_ePortCache = ePortCacheEnabled;
        uint16 m_uPortCache[256]{};
        uint32 m_uPortCachable[8]{};
        uint32 m_uPortCacheValid[8]{};
        uint16 m_uPortStatus;
        XMLNode m_CardNode;
        CINOSIncoAction* m_pStartup;
        CINCOObject* m_pInco;
        std::vector<CINOSCOPModule *> m_Distribution;
        CINOSCOPModule* m_pNext;
        bool m_bOnline;
        const char* m_pModXml;
        const char* m_pCardNodeXml;
        uint32 m_uCardNodeXmlSize;
        char* m_pCardNodeXmlCompressed;
        uint32 m_uCardNodeXmlCompressedSize;
 
    DECLARE_DYNAMIC(CINOSCOPModule);
};
 
 
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSCOPMODULE_H
 
 
//------------------------------------------------------------------------------
// end of file