dae2_card.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "isisvme.h"
#include "dae2_card.h"

template <class DAECardPolicy>
DAE2Card<DAECardPolicy>::DAE2Card(int position, ISISVME* vme, DAEstatus& status) : m_position(position), m_vme(vme)
{
        setLoggerName("DAE2CARD");
}

template <class DAECardPolicy>
std::string DAE2Card<DAECardPolicy>::daeDevice() const
{  
         return m_vme->device(); 
}



// registers are 32 bits on card, but only 16 bits used
// they are also BIG ENDIAN, hence bit shifts
template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::readRegister(unsigned long address, isisU32_t* value, DAEstatus& status, bool little_endian, bool retry)
{
        int stat;
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        *value = 0;
        address = makeAddress(address);
        if (retry)
        {
                stat = m_vme->readU32(address, value, props, status);
        }
        else
        {
                stat = m_vme->readU32noRetry(address, value, props, status);
        }
        if (stat == ISISVME::Success)
        {
//      *value = (*value >> 16);        // discard bottom 16 bits of junk
                return 1;
        }
        else
        {
                return 0;
        }
}

template <class DAECardPolicy>
void DAE2Card<DAECardPolicy>::printRegister(const char* name, unsigned long address, std::ostream& os, bool print_bits_set)
{
        isisU32_t value;
        DAEstatus status;
        readRegister(address, &value, status);
        os << name << " (0x" << std::hex << address << ") value 0x" << value << std::dec;
        if (print_bits_set)
        {
                std::bitset<8*sizeof(value)> value_bits((unsigned long long)value);
                // os << " " << value_bits.to_string();
                if (value_bits.any())
                {
                        os << " (bits set:";
                        for(int i=0; i < value_bits.size(); ++i)
                        {
                                if (value_bits.test(i))
                                {
                                        os << " " << i;
                                }
                        }
                        os << ")";
                }
        }
        os << std::endl; 
}

template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::readRegister(unsigned long address, isisU16_t* value, DAEstatus& status, bool little_endian, bool retry)
{
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        int stat;
//      isisU32_t temp = 0;
        *value = 0;
        address = makeAddress(address);
        if (retry)
        {
                stat = m_vme->readU16(address, value, props, status);
        }
        else
        {
                stat = m_vme->readU16noRetry(address, value, props, status);
        }
        if (stat == ISISVME::Success)
        {
//      *value = (isisU16_t)(temp >> 16);       // discard bottom 16 bits of junk
                return 1;
        }
        else
        {
                return 0;
        }
}

// Read a 32 bit value from two 32 bit registers that 
   // contain 16 bit numbers 
   // address0 is low bits, address1 higher 
template <class DAECardPolicy>
   int DAE2Card<DAECardPolicy>::readRegister16As32(unsigned long address0, unsigned long address1, isisU32_t* value, DAEstatus& status, bool little_endian) 
   { 
           if (address0 == address1)
           {
                   return readRegister(address0, value, status, little_endian);
           }
           else
           {
           isisU32_t value0, value1; 
           readRegister(address0, &value0, status, little_endian); 
           readRegister(address1, &value1, status, little_endian); 
           value0 &= 0xffff; 
           value1 &= 0xffff; 
           *value = (value1 << 16) | value0; 
           return 1; 
           }
   } 
    
   // write a 32 bit value to two 16 bit registers 
   // address0 is low bits, address1 higher 
template <class DAECardPolicy>
   int DAE2Card<DAECardPolicy>::writeRegister32As16(unsigned long address0, unsigned long address1, isisU32_t value, DAEstatus& status, bool little_endian) 
   {
           if (address0 == address1)
           {
                   return writeRegister(address0, value, status, little_endian);
           }
           else
           {
           isisU16_t value0, value1; 
           value0 = (isisU16_t)(value & 0xffff); 
           value1 = (isisU16_t)((value >> 16) & 0xffff); 
           writeRegister16(address0, value0, status, little_endian); 
           writeRegister16(address1, value1, status, little_endian); 
           return 1;
           }
   } 



template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::writeRegister(unsigned long address, isisU32_t value, DAEstatus& status, bool little_endian)
{
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        address = makeAddress(address);
//      reverseEndian(&value);          // registers are big endian
        m_vme->writeU32(address, value, props, status);
        return 1;
}

template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::writeRegister16(unsigned long address, isisU16_t value, DAEstatus& status, bool little_endian)
{
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        address = makeAddress(address);
//      reverseEndian(&value);          // registers are big endian
        m_vme->writeU16(address, value, props, status);
        return 1;
}

template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::setRegisterBits(unsigned long address, isisU32_t mask, bool preserve, DAEstatus& status, bool little_endian)
{
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        isisU32_t old_value;
        address = makeAddress(address);
    if (preserve)
        {
                m_vme->readU32(address, &old_value, props, status);
                mask |= old_value;
        }
        return m_vme->writeU32(address, mask, props, status);
}

template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::clearRegisterBits(unsigned long address, isisU32_t mask, DAEstatus& status, bool little_endian)
{
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        isisU32_t old_value;
        address = makeAddress(address);
        m_vme->readU32(address, &old_value, props, status);
        mask = (old_value & ~mask);
        return m_vme->writeU32(address, mask, props, status);
}

template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::changeRegisterBits(unsigned long address, isisU32_t mask, bool set, bool check, DAEstatus& status, bool little_endian)
{
        int stat;
        if (set)
        {
                stat = setRegisterBits(address, mask, true, status, little_endian);
                while( check && !registerBitsSet(address, mask, status, little_endian) )
                {
                        status.addWarningVa(FAC_DAE, "retrying set of register %lu mask %lu", address, mask); 
                        Sleep(100);
                        stat = setRegisterBits(address, mask, true, status, little_endian);
                }
        }
        else
        {
                stat = clearRegisterBits(address, mask, status, little_endian);
                while( check && !registerBitsClear(address, mask, status, little_endian) )
                {
                        status.addWarningVa(FAC_DAE, "retrying clear of register %lu mask %lu", address, mask); 
                        Sleep(100);
                        stat = clearRegisterBits(address, mask, status, little_endian);
                }
        }
        return stat;
}

template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::setAndClearRegisterBits(unsigned long address, isisU32_t mask, bool preserve, DAEstatus& status, bool little_endian)
{
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        isisU32_t old_value, val;
        address = makeAddress(address);
        if (preserve)
        {
                m_vme->readU32(address, &old_value, props, status);
                val = mask | old_value;
                m_vme->writeU32(address, val, props, status);
            val = ~mask & old_value;
                m_vme->writeU32(address, val, props, status);
        }
        else
        {
                m_vme->writeU32(address, mask, props, status);
                m_vme->writeU32(address, 0, props, status);
        }
        return 0;
}

template <class DAECardPolicy>
bool DAE2Card<DAECardPolicy>::registerBitsSet(unsigned long address, isisU32_t mask, DAEstatus& status, bool little_endian)
{
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        isisU32_t value;
        address = makeAddress(address);
        m_vme->readU32(address, &value, props, status);
        if ((value & mask) == mask)
        {
                return true;
        }
        else
        {
                return false;
        }
}

template <class DAECardPolicy>
bool DAE2Card<DAECardPolicy>::registerBitsClear(unsigned long address, isisU32_t mask, DAEstatus& status, bool little_endian)
{
        ISISVME::TransferProps props = ISISVME::TransferIORegisterSpace;
        if (little_endian)
        {
                props |= ISISVME::TransferLittleEndian;
        }
        isisU32_t value;
        address = makeAddress(address);
        m_vme->readU32(address, &value, props, status);
        if ((value & mask) == 0)
        {
                return true;
        }
        else
        {
                return false;
        }
}


// look for TCG Time Bin Limit Register address, which should
// exist on all cards 
// env card (run control register) and det card (tcg time bin limit)
// both at 0x40084
// period card has period register at 0x40088
template <class DAECardPolicy>
bool DAE2Card<DAECardPolicy>::isCardPresent(int position, ISISVME* vme, DAEstatus& dstatus)
{
                isisU32_t value;
                isisU16_t value16;
                int status;
                DAEstatus temp_stat;
                unsigned long addr = makeAddress(position, FIRMVERS);
                status = vme->readU32noRetry(addr, &value, ISISVME::TransferIORegisterSpace, temp_stat);
                if ( (status == ISISVME::Success) )
                {
                        return true;
                }
                temp_stat.clear(SEV_ERROR, SEV_GE);
                addr = makeAddress(position, 0x8000000);
                status = vme->readU32noRetry(addr, &value, ISISVME::TransferMemorySpace, temp_stat);
                if (status == ISISVME::Success)
                {
                        return true;
                }
// this is TCG register, but it is not checked for in the getCardType
// whihc used memeory check instead, so change here to use just memory
// check otherwise may detect a card but not know its type
//              temp_stat.clear(SEV_ERROR, SEV_GE);
//              addr = makeAddress(position, 0x40084);
//              status = vme->readU32noRetry(addr, &value, ISISVME::TransferIORegisterSpace, temp_stat);
//              if ( (status == ISISVME::Success) )
//              {
//                      return true;
//              }
                temp_stat.clear(SEV_ERROR, SEV_GE);
                addr = makeAddress(position, 0x40088); // period card?
                status = vme->readU16noRetry(addr, &value16, false, temp_stat);
                if ( (status == ISISVME::Success) )
                {
                        return true;
                }
                else
                {
                        temp_stat.clear(SEV_ERROR, SEV_GE);
                        return false;
                }
}

template <class DAECardPolicy>
typename DAE2Card<DAECardPolicy>::CardType DAE2Card<DAECardPolicy>::getCardType(int position, ISISVME* vme, DAEstatus& dstatus)
{
        int status;
        unsigned long addr;
        isisU32_t value32;
        isisU16_t value16;
        CardType card_type;
        firmware_version fw;
    getFirmwareVersion(position, vme, &fw, dstatus);
        card_type = DAE2Card::UnknownCard;
        switch(fw.main_func)
        {
                case 0x1: // environment card
                        switch(fw.hard_type)
                        {
                                case 0x0:
                                case 0x1:
                                        card_type = DAE2Card::EnvCard;
                                        break;

                                case 0x2:
                                        card_type = DAE2Card::EnvPeriodCard;
                                        break;
                        }
                        break;

                case 0x2: // detector card
                        switch(fw.hard_type)
                        {
                                case 0x0:
                                case 0x1:
                                case 0x2:
                                case 0x4:
                                        card_type = DAE2Card::NeutronDetectorCard;
                                        break;

                                case 0x3:
                                        card_type = DAE2Card::MuonDetectorCard;
                                        break;
                        }
                        break;

                case 0x3: // Other (defined)
                        switch(fw.hard_type)
                        {
                                case 0x0:
                                        card_type = DAE2Card::MuonPeriodCard;
                                        break;
                        }
                        break;
        }
        if (card_type != DAE2Card::UnknownCard)
        {
                return card_type;
        }
        // old detector card maybe?
    addr = makeAddress(position, 0x8000000);
        status = vme->readU32noRetry(addr, &value32, ISISVME::TransferMemorySpace, dstatus);
        if (status == ISISVME::Success)
        {
                return DAE2Card::NeutronDetectorCard;
        }
        else
        {
                dstatus.clear(SEV_ERROR, SEV_GE);
        }
        // old period card maybe?
        addr = makeAddress(position, 0x40088);
        status = vme->readU16noRetry(addr, &value16, true, dstatus);
        if (status == ISISVME::Success)
        {
                return DAE2Card::MuonPeriodCard;
        }
        else
        {
                dstatus.clear(SEV_ERROR, SEV_GE);
        }
        // old environment card maybe?
//      addr = makeAddress(position, 0x14);
//      status = vme->readU16noRetry(addr, &value16, true, dstatus);
//      if (status == ISISVME::Success)
//      {
//              return DAE2Card::EnvCard;
//      }
//      else
//      {
//              dstatus.clear(SEV_ERROR, SEV_GE);
//      }
        return DAE2Card::UnknownCard;
}

template <class DAECardPolicy>
void DAE2Card<DAECardPolicy>::printStatus(std::ostream& os, DAEstatus& dstatus)
{
        os << "--- DAE2 card with address/position/number = " << m_position << " ---" << std::endl;
        os << getFirmwareVersionAsString(dstatus) << std::endl;
}

template <class DAECardPolicy>
std::string DAE2Card<DAECardPolicy>::getFirmwareVersionAsString(DAEstatus& dstatus)
{
        std::stringstream sstr;
        firmware_version fw;
        getFirmwareVersion(m_position, m_vme, &fw, dstatus);
        sstr << "Firmware register: 0x" << std::hex << *(isisU32_t*)&fw << std::dec << "\n";
        switch(fw.main_func)
        {
                case 0x0: // other (not defined)
                        sstr << "Hardware type: OTHER CARD (Not Defined)\n";
                        break;

                case 0x1: // environment card
                        switch(fw.hard_type)
                        {
                                case 0x0:
                                        sstr << "Hardware type: ENVIRONMENT CARD (Dedicated)\n";
                                        break;
                                case 0x1:
                                        sstr << "Hardware type: ENVIRONMENT CARD (Configured from detector card)\n";
                                        break;
                                case 0x2:
                                        sstr << "Hardware type: ENVIRONMENT CARD (With period functions)\n";
                                        break;
                                default:
                                        sstr << "Hardware type: ENVIRONMENT CARD (UNKNOWN)\n";
                                        break;
                        }
                        break;

                case 0x2: // detector card
                        switch(fw.hard_type)
                        {
                                case 0x0:
                                        sstr << "Hardware type: DETECTOR CARD (Neutron, 1 DIM)\n";
                                        break;
                                case 0x1:
                                        sstr << "Hardware type: DETECTOR CARD (Neutron, 2 DIM)\n";
                                        break;
                                case 0x2:
                                        sstr << "Hardware type: DETECTOR CARD (Neutron, 16 DIM)\n";
                                        break;
                                case 0x3:
                                        sstr << "Hardware type: DETECTOR CARD (Muon, 4 DIM)\n";
                                        break;
                                case 0x4:
                                        sstr << "Hardware type: DETECTOR CARD (Neutron, 32 DIM)\n";
                                        break;
                                default:
                                        sstr << "Hardware type: DETECTOR CARD (UNKNOWN)\n";
                                        break;
                        }
                        break;

                case 0x3:
                        switch(fw.hard_type)
                        {
                                case 0x0:
                                        sstr << "Hardware type: OTHER CARD (Muon Period Card)\n";
                                        break;
                                default:
                                        sstr << "Hardware type: OTHER CARD (Defined, but UNKNOWN)\n";
                                        break;
                        }
                        break;

                default: // should never get here as all cases covered above
                        sstr << "Hardware type: ERROR\n";
                        break;
        }
        sstr << "Firmware sub version = " << fw.sub_ver << "\n";
        sstr << "Firmware minor version = " << fw.minor_ver << "\n";
        sstr << "Firmware hardware version = " << fw.hard_ver;
        return sstr.str();
}

template <class DAECardPolicy>
int DAE2Card<DAECardPolicy>::getFirmwareVersion(int position, ISISVME* vme, firmware_version* fw, DAEstatus& dstatus)
{
                unsigned long addr = makeAddress(position, FIRMVERS);
                int status = vme->readU32noRetry(addr, (isisU32_t*)fw, ISISVME::TransferIORegisterSpace, dstatus);
                if (status == ISISVME::Success)
                {
                        return 1;
                }
                else
                {
                        // zero the structure ... this will set 
                        // fw->hard_type = 0 which is "Other (not defined)"
                        memset(fw, 0, sizeof(firmware_version));
                        dstatus.clear(SEV_ERROR, SEV_GE);
                }
                return 0;
}


template class DAE2Card<DAE2CardPolicy>;
template class DAE2Card<DAE2DetCardPolicy>;
template class DAE2Card<DAE2EnvPeriodPolicy>;

template class DAE2Card<DAE3CardPolicy>;
template class DAE2Card<DAE3DetCardPolicy>;
template class DAE2Card<DAE3EnvPeriodPolicy>;

const std::string DAE2CardPolicy::card_policy_name = "DAE2CardPolicy";
const std::string DAE2DetCardPolicy::det_card_policy_name = "DAE2DetCardPolicy";
const std::string DAE2EnvPeriodPolicy::env_period_policy_name = "DAE2EnvPeriodPolicy";

const std::string DAE3CardPolicy::card_policy_name = "DAE3CardPolicy";
const std::string DAE3DetCardPolicy::det_card_policy_name = "DAE3DetCardPolicy";
const std::string DAE3EnvPeriodPolicy::env_period_policy_name = "DAE3EnvPeriodPolicy";

const std::string DAE2Policy::policy_name = "DAE2Policy";
const std::string DAE3Policy::policy_name = "DAE3Policy";

const std::string DAE2CardPolicy::card_type = "DAE2";
const std::string DAE3CardPolicy::card_type = "DAE3";