Hardware.h

Aller à la documentation de ce fichier.

// Product  OpenNet


#pragma once

// Includes

// ===== Includes ===========================================================
#include <OpenNetK/Adapter.h>
#include <OpenNetK/Adapter_Types.h>
#include <OpenNetK/SpinLock.h>
#include <OpenNetK/Types.h>

namespace OpenNetK
{

    class Packet;

    // Class

    class Hardware
    {

    public:

        void * operator new(size_t aSize_byte, void * aAddress);

        unsigned int GetCommonBufferSize() const;

        unsigned int GetPacketSize() const;

        virtual void GetState(Adapter_State * aState) = 0;

        virtual void ResetMemory();

        virtual void SetAdapter(Adapter * aAdapter);

        virtual void SetCommonBuffer(uint64_t aCommon_PA, void * aCommon_CA);

        virtual void SetConfig(const Adapter_Config & aConfig);

        virtual bool SetMemory(unsigned int aIndex, void * aMemory_MA, unsigned int aSize_byte);

        virtual void D0_Entry();

        virtual bool D0_Exit();

        virtual void Interrupt_Disable();

        virtual void Interrupt_Enable();

        virtual bool Interrupt_Process(unsigned int aMessageId, bool * aNeedMoreProcessing);

        virtual void Interrupt_Process2(bool * aNeedMoreProcessing);

        virtual void Interrupt_Process3();

        // TODO  OpenNetK.Hardware
        //       Normal (Optimisation) - Use two lock, one for Rx and one for
        //       Tx

        void Lock();

        // TODO  OpenNet.Hardware
        //       Normal (Feature) - Ajouter Lock_BeforeSend en passant un
        //       nombre de descripteurs necessaires. Cette fonction echouera
        //       s'il n'y a pas assez de descripteur disponible.

        void Unlock();

        void Unlock_AfterReceive_FromThread(volatile long * aCounter, unsigned int aPacketQty, uint32_t aFlags );

        void Unlock_AfterSend_FromThread(volatile long * aCounter, unsigned int aPacketQty, uint32_t aFlags );

        virtual bool Packet_Drop() = 0;

        // TODO  OpenNetK.Adapter
        //       Normal (Cleanup) - Pass the aCounter to Lock rather than at
        //       Packet_Receive_NoLock and Unlock_AfterSend and do not pass
        //       aPacketQty to Unlock_AfterSend. Replace it by an internal
        //       counter.

        virtual void Packet_Receive_NoLock(Packet * aPacket, volatile long * aCounter) = 0;

        virtual void Packet_Send_NoLock(uint64_t aPacket_PA, const void * aPacket_XA, unsigned int aSize_byte, volatile long * aCounter) = 0;

        virtual bool Packet_Send(const void * aPacket, unsigned int aSize_byte, bool aPriority, unsigned int aRepeatCount = 1) = 0;

        virtual unsigned int Statistics_Get(uint32_t * aOut, unsigned int aOutSize_byte, bool aReset);

        virtual void Statistics_Reset();

        bool Tx_IsEnabled() const;

        virtual void Tx_Disable();

        virtual void Tx_Enable();

    // internal:

        void Init(SpinLock * aZone0);

        void GetConfig(Adapter_Config * aConfig);
        void GetInfo  (Adapter_Info   * aInfo  );

        void Tick();

        void Unlock_AfterReceive(volatile long * aCounter, unsigned int aPacketQty);
        void Unlock_AfterSend   (volatile long * aCounter, unsigned int aPacketQty);

    protected:

        static void SkipDangerousBoundary(uint64_t * aIn_PA, uint8_t ** aIn_XA, unsigned int aSize_byte, uint64_t * aOut_PA, uint8_t ** aOut_XA);

        Hardware(OpenNetK::Adapter_Type aType, unsigned int aPacketSize_byte);

        virtual void Unlock_AfterReceive_Internal() = 0;

        virtual void Unlock_AfterSend_Internal() = 0;

        Adapter_Config mConfig;

        Adapter_Info   mInfo  ;

        mutable uint32_t mStatistics[64];

        // ===== Zone 0 =====================================================

        SpinLock * mZone0;

    private:

        Hardware(const Hardware &);

        const Hardware & operator = (const Hardware &);

        Adapter * mAdapter;

        bool mTx_Enabled;

    };

    // Public

    inline void Hardware::Lock()
    {
        mZone0->Lock();
    }

    inline void Hardware::Unlock()
    {
        mZone0->Unlock();
    }

    inline bool Hardware::Tx_IsEnabled() const
    {
        return mTx_Enabled;
    }

    // Internal

    inline void Hardware::Tick()
    {
        mAdapter->Tick();
    }

}