dae2_card.h

Go to the documentation of this file.

#ifndef DAE2CARD_H
#define DAE2CARD_H

#include "isisvme_types.h"
#include "isiscrpt_types.h"

#include "icp_interfaces.h"
#include "IsisBase.h"
#include "DAEstatus.h"

#include "dae2_policy.h"
#include "dae3_policy.h"

#include "isisvme.h"

struct firmware_version
{
        unsigned sub_ver : 8;
        unsigned minor_ver : 8;
        unsigned hard_ver : 8;
        unsigned hard_type : 6;
        unsigned main_func : 2;
};

typedef int CardOptions;

class DAE2CardIntf
{
public:
        DAE2CardIntf() { }
        enum CardType 
        {
                EmptySlot = 0, UnknownCard = 1, EnvCard = 2, 
                EnvPeriodCard = 3, NeutronDetectorCard = 4,
                MuonDetectorCard = 5, MuonPeriodCard = 6
        };
        virtual ~DAE2CardIntf() { }
        virtual int position() const = 0;
        virtual std::string daeDevice() const = 0;
};

template <class DAECardPolicy>
class DAE2Card : public ISIS::Base, public DAE2CardIntf, public DAECardPolicy
{
public:

        DAE2Card(int position, ISISVME* vme, DAEstatus& status);
        int setRegisterBits(unsigned long address, isisU32_t mask, bool preserve, DAEstatus& status, bool little_endian = false);
        int clearRegisterBits(unsigned long address, isisU32_t mask,DAEstatus& status, bool little_endian = false);
        int setAndClearRegisterBits(unsigned long address, isisU32_t mask, bool preserve,  DAEstatus& status, bool little_endian = false);
        int changeRegisterBits(unsigned long address, isisU32_t mask, bool set, bool check, DAEstatus& status, bool little_endian = false);
        bool registerBitsSet(unsigned long address, isisU32_t mask, DAEstatus& status, bool little_endian = false);
        bool registerBitsClear(unsigned long address, isisU32_t mask, DAEstatus& status, bool little_endian = false);
        int setAndClearRegisterBits(const unused_t& address, isisU32_t mask, bool preserve, DAEstatus& status, bool little_endian = false) { return DAEstatus::Success; }

        int readRegister(unsigned long address, isisU32_t* value, DAEstatus& status, bool little_endian = false, bool retry = true);
        int writeRegister(unsigned long address, isisU32_t value, DAEstatus& status, bool little_endian = false);
        int readRegister(unsigned long address, isisU16_t* value, DAEstatus& status, bool little_endian = false, bool retry = true);
        int writeRegister16(unsigned long address, isisU16_t value, DAEstatus& status, bool little_endian = false);
    int readRegister16As32(unsigned long address0, unsigned long address1, isisU32_t* value, DAEstatus& status, bool little_endian = false); 
    int writeRegister32As16(unsigned long address0, unsigned long address1, isisU32_t value, DAEstatus& status, bool little_endian = false); 
        int readRegister(const unused_t& address, isisU32_t* value, DAEstatus& status, bool little_endian = false, bool retry = true) { return DAEstatus::Success; }
        int writeRegister(const unused_t& address, isisU32_t value, DAEstatus& status, bool little_endian = false) { return DAEstatus::Success; }
        int writeRegister16(const unused_t& address, isisU16_t value, DAEstatus& status, bool little_endian = false) { return DAEstatus::Success; }

        // len is number of 32/64 bit items to write
//      template <typename T> int readMemory(unsigned long address, T* buffer, int len, ISISVME::TransferProps props, DAEstatus& status);
//      template <typename T> int readMemoryChunked(unsigned long address, T* buffer, int len, int chunk_len, ISISVME::TransferProps props, DAEstatus& status);
//      template <typename T> int writeMemory(unsigned long address, T* buffer, int len, uint64_t read_check_mask, ISISVME::TransferProps props, DAEstatus& status);
//      template <typename T> int zeroMemory(unsigned long start, int len, uint64_t read_check_mask, ISISVME::TransferProps props, DAEstatus& status);
        static bool isCardPresent(int position, ISISVME* vme, DAEstatus& status);
        int position() const { return m_position; };
        std::string daeDevice() const;
        virtual void printStatus(std::ostream& os, DAEstatus& dstatus);
        std::string getFirmwareVersionAsString(DAEstatus& status);
        static CardType getCardType(int position, ISISVME* vme, DAEstatus& dstatus);

        virtual ~DAE2Card() { }

        void printRegister(const char* name, unsigned long address, std::ostream& os, bool print_bits_set = false);

        virtual int resetCardState(DAEstatus& status) = 0;
        static unsigned long makeAddress(int position, unsigned long address)
        {
                return DAECardPolicy::makeAddress(position, address);
        }

protected:
        int m_position;                 // card number

        ISISVME* m_vme;

protected:
        void reverseEndian(isisU32_t* value);
        void reverseEndian(isisU16_t* value);
        static int getFirmwareVersion(int position, ISISVME* vme, firmware_version* fw, DAEstatus& status);
        static const char* yesNoStr(bool b) { return (b ? "yes" : "no"); } 
        std::string loggingPrefix() const { return Poco::format("(card %d on %s) ", m_position, daeDevice()); }
        virtual unsigned long makeAddress(unsigned long address)
        { 
                return makeAddress(m_position, address);
        }
public:
// memory is 32 bit and little endian; len is number of 32 bit items
        template <typename T>
        int readMemory(unsigned long address, typename T* buffer, int len, ISISVME::TransferProps props, DAEstatus& status)
        {
                address = makeAddress(address);
                return m_vme->readBlock(address, buffer, len, props, status);
        }
        template <typename T>
        int readMemoryChunked(unsigned long address, T* buffer, int len, int chunk_len, ISISVME::TransferProps props, DAEstatus& status)
        {
                int n, stat;
                stat = ISISVME::Success;
                while((stat == ISISVME::Success) && (len > 0))
                {
                        n = (len > chunk_len ? chunk_len : len);
                        stat = readMemory(address, buffer, n, props, status);
                        address += sizeof(T) * n;
                        buffer += n;
                        len -= n;
                }
                return stat;
        }

        template <typename T>
        int writeMemory(unsigned long address, T* buffer, int len, uint64_t read_check_mask, ISISVME::TransferProps props, DAEstatus& status)
        {
                int stat, i;
                bool little_endian = (props & ISISVME::TransferLittleEndian ? true : false);
                bool block_transfer = (props & ISISVME::TransferBlock ? true : false);
                address = makeAddress(address);
                if (read_check_mask == 0)
                {
                        return m_vme->writeBlock(address, buffer, len, props, status);
                }
                bool done = false;
                T* read_buffer = new T[len];
                std::list<int> failed_elements;
                stat = m_vme->writeBlock(address, buffer, len, props, status);
                stat = m_vme->readBlock(address, read_buffer, len, props, status);
                for(i=0; i<len; i++)
                {
                        if ( (buffer[i] & read_check_mask) != (read_buffer[i] & read_check_mask) )
                        {
                                failed_elements.push_back(i);
                        }
                }
                if (failed_elements.size() == 0)
                {
                        delete[] read_buffer;
                        return DAEstatus::Success;
                }
                status.addInfoVa(FAC_DAE, "DAE2Card::writeMemory: %d errors - retrying write of %d words to 0x%x (BT=%s,LE=%s,check_mask=0x%llx)", 
                        failed_elements.size(), len, address, yesNoStr(block_transfer),  yesNoStr(little_endian), read_check_mask);
                Sleep(10);
                std::list<int>::const_iterator iter = failed_elements.begin();
                while(iter != failed_elements.end())
                {
                        i = *iter;
                        stat = m_vme->writeBlock(address + 4 * i, buffer + i, 1, props, status);        
                        stat = m_vme->readBlock(address + 4 * i, read_buffer + i, 1, props, status);
                        if ( (buffer[i] & read_check_mask) == (read_buffer[i] & read_check_mask) )
                        {
                                iter++;
                        }
                        else
                        {
                                status.addInfoVa(FAC_DAE, "DAE2Card::writeMemory: retry failed to address 0x%x (write=0x%x, read=0x%x, mask=0x%llx)", address + 4 * i, buffer[i], read_buffer[i], read_check_mask);
                                Sleep(10);
                        }
                }
                delete[] read_buffer;
                return stat;
        }

        template <typename T>
        int zeroMemory(unsigned long start, int len, uint64_t read_check_mask, ISISVME::TransferProps props, DAEstatus& status)
        {
                int l, buflen = 64*1024;
                T* buffer = new T[buflen];
                memset(buffer, 0, buflen*sizeof(T));
                while(len > 0)
                {
                        l = (len > buflen ? buflen : len);
                        writeMemory(start, buffer, l, read_check_mask, props, status);
                        start += sizeof(T) * l;
                        len -= l;
                }
                delete []buffer;
                return 0;
        }

};



template <class DAECardPolicy>
inline void DAE2Card<DAECardPolicy>::reverseEndian(isisU32_t* value)
{
        *value = (((*value) << 24) & 0xff000000) | 
                 (((*value) <<  8) & 0x00ff0000) |
                         (((*value) >>  8) & 0x0000ff00) |
                         (((*value) >> 24) & 0x000000ff);
}

template <class DAECardPolicy>
inline void DAE2Card<DAECardPolicy>::reverseEndian(isisU16_t* value)
{
        *value = (((*value) & 0xff) << 8) | ((*value) >> 8);
}

template <class DAECardPolicy>
class DAE2Register
{
protected:
        typedef DAE2Card<DAECardPolicy> MyDAE2Card;
        MyDAE2Card* m_card;
        isisU32_t m_address;

public:
        DAE2Register(MyDAE2Card* card, isisU32_t address) : m_card(card), m_address(address) {}
        virtual ~DAE2Register() {}
        int setBits(isisU32_t mask, bool preserve, DAEstatus& status, bool little_endian = false)
        {
                return m_card->setRegisterBits(m_address, mask, preserve, status, little_endian);
        }
        int clearBits(isisU32_t mask, DAEstatus& status, bool little_endian = false)
        {
                return m_card->clearRegisterBits(m_address, mask, status, little_endian);
        }
        int enable(bool choice, isisU32_t mask, DAEstatus& status, bool little_endian = false)
        {
                return m_card->changeRegisterBits(m_address, mask, choice, true, status, little_endian);
        }
        isisU32_t read(DAEstatus& status, bool little_endian = false, bool retry = true)
        {
                isisU32_t value = 0;
                m_card->readRegister(m_address, &value, status, little_endian, retry);
                return value;
        }

private:
        DAE2Register() {}
};

#endif /* DAE2CARD_H */