sim_dae2_card.h

Go to the documentation of this file.

#ifndef SIMDAE2CARD_H
#define SIMDAE2CARD_H

#include "isisvme_types.h"
#include "DAEstatus.h"
#include "dae2_card.h"

class VMESimulationIface;

enum FaultMode { Working=0, DetectedButNotWorking=1 };

struct sim_mapping 
{
private:
        void* m_var;
public:
        ISISVME::TransferProps props;
        isisU32_t address;
        int n;
        int ws;  // word size in bytes
        template <typename T> T* var() { return static_cast<T*>(m_var); }
        const char* name;
        bool readable;
        bool writable;
        isisU32_t* access_reg;
        unsigned access_bit;            // bitmask
        bool wrap;
        bool sixteen_bit_access;
        FaultMode fault_mode;
        sim_mapping(ISISVME::TransferProps props_, isisU32_t address_, int n_, int ws_, void* var_, const char* name_, bool readable_,
                bool writable_, isisU32_t* access_reg_, unsigned access_bit_, bool wrap_, 
                bool sixteen_bit_access_, FaultMode fault_mode_) :
                  props(props_), address(address_), n(n_), ws(ws_), m_var(var_), name(name_), readable(readable_), writable(writable_), 
                        access_reg(access_reg_), access_bit(access_bit_), wrap(wrap_), 
                        sixteen_bit_access(sixteen_bit_access_), fault_mode(fault_mode_) {}

};

template <class DAECardPolicy>
class SIMDAE2Card : public ISIS::Base, public DAECardPolicy
{
public:
        enum CardType { UnknownCard=0, EnvCard=1, DetCard=2, PeriodCard=3, EnvPeriodCard=4 };
        SIMDAE2Card(int position, VMESimulationIface* vme, isisU32_t firmware, bool fw32, FaultMode fault_mode, DAEstatus& status);
        int position() { return m_position; };
        virtual ~SIMDAE2Card() { }
        virtual void printStatus(std::ostream& os) = 0;
        virtual void updateCardAfterWrite(DAEstatus& status) = 0;

        // Normally a card does not change after a read, but this is here to
        // allow you to set a debugger breakpoint on a card read
        virtual void updateCardAfterRead(DAEstatus& status) = 0;

        virtual void simulate(int delay) = 0;
        int read16(ISISVME::TransferProps props, unsigned long address, isisU16_t* data16, long nitems, DAEstatus& status);
        int read32(ISISVME::TransferProps props, unsigned long address, isisU32_t* data32, long nitems, DAEstatus& status);
        int write16(ISISVME::TransferProps props, unsigned long address, isisU16_t* data16, long nitems, DAEstatus& status);
        int write32(ISISVME::TransferProps props, unsigned long address, isisU32_t* data32, long nitems, DAEstatus& status);
        std::vector<sim_mapping>& mapping() { return m_mapping; }
        int addMapping(ISISVME::TransferProps props, isisU32_t address, int n, isisU32_t* var, const char* name, bool readable,
                                bool writable, isisU32_t* access_reg, unsigned access_bit, bool wrap, 
                                bool sixteen_bit_access, FaultMode fault_mode);
        int addMapping(ISISVME::TransferProps props, isisU32_t address, int n, uint64_t* var, const char* name, bool readable,
                                bool writable, isisU32_t* access_reg, unsigned access_bit, bool wrap, 
                                bool sixteen_bit_access, FaultMode fault_mode);
        int addMapping(ISISVME::TransferProps props, const unused_t& address, int n, isisU32_t* var, const char* name, bool readable,
                                bool writable, isisU32_t* access_reg, unsigned access_bit, bool wrap, 
                                bool sixteen_bit_access, FaultMode fault_mode) { return 0; }
        int addMapping(ISISVME::TransferProps props, const unused_t& address, int n, uint64_t* var, const char* name, bool readable,
                                bool writable, isisU32_t* access_reg, unsigned access_bit, bool wrap, 
                                bool sixteen_bit_access, FaultMode fault_mode) { return 0; }


        static void increment(int value, isisU32_t& low);
        static void increment2(int value, isisU32_t& low, isisU32_t& high);
        static void increment3(int value, isisU32_t& low, isisU32_t& middle, isisU32_t& high);
        static void increment32(int value, isisU32_t& low, isisU32_t& high);
        static void increment32(int value, uint64_t& low, isisU32_t& high);
        bool isVetoing() { return m_veto_raised; }
        bool isRunning() { return m_is_running; }
        CardType type() { return m_type; }

protected:
        int m_position;                 // card number
        CardType m_type;
        VMESimulationIface* m_vme;
        bool m_veto_raised;
        bool m_is_running;
        std::vector<sim_mapping> m_mapping;

        isisU32_t m_firmware;  // firmware register (new 32 bit style)


//      isisU32_t m_firmware0;  // firmware register (old 16 bit style, lower)
//      isisU32_t m_firmware1;  // firmware register (old 16 bit style, upper)
        std::string loggingPrefix() const { return Poco::format("(card %d) ", m_position); }
};


#endif /* SIMDAE2CARD_H */