// Copyright 2011 National Instruments
// License: NATIONAL INSTRUMENTS SOFTWARE LICENSE AGREEMENT
//   Refer to "MHDDK License Agreement.pdf" in the root of this distribution.

// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// This file is autogenerated!!!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!

#ifndef ___tBusInterface_ipp___
#define ___tBusInterface_ipp___

#ifndef ___tBusInterface_h___
#include "tBusInterface.h"
#endif

#ifndef ___nNIMXRegistermap_tStatus2Ptr_ipp___
#define ___nNIMXRegistermap_tStatus2Ptr_ipp___

typedef nMDBG::tStatus2 nNIMXRegisterMap120_tStatus2;


namespace nNIMXRegisterMap120 {
namespace {

typedef nNIMXRegisterMap120_tStatus2 tStatus2;

inline void setStatus(tStatus2* s, tStatus newStatus)
{
   if (s) s->setCode(newStatus);
}

inline tStatus* toPALStatusPtr(tStatus2* s)
{
   return s ? s->operator tStatus*() : ((tStatus*)NULL);
}

inline tBoolean statusIsFatal(tStatus2* s)
{
   return s && s->isFatal();
}

} // unnamed namespace
} // namespace nNIMXRegisterMap120

#endif // ___nNIMXRegistermap_tStatus2Ptr_ipp___


inline void tBusInterface::tReg16IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u16 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write16(offset, value);
}

inline u16 tBusInterface::tReg16IODirect32::read(
   tBusSpaceReference addrSpace,
   u32 offset,
   nMDBG::tStatus2* s)
{
   u16 value = (u16)~0;
   if (s && s->isFatal()) return value;
   value = (u16)addrSpace.read16(offset);
   return value;
}

inline void tBusInterface::tReg32IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u32 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write32(offset, value);
}

inline u32 tBusInterface::tReg32IODirect32::read(
   tBusSpaceReference addrSpace,
   u32 offset,
   nMDBG::tStatus2* s)
{
   u32 value = (u32)~0;
   if (s && s->isFatal()) return value;
   value = addrSpace.read32(offset);
   return value;
}

inline tBusSpaceReference tBusInterface::getBusSpaceReference(void) const
{
   return _addrSpace;
}

inline void tBusInterface::setAddressOffset(u32 value, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _addressOffset = value;
}
inline u32 tBusInterface::getAddressOffset(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return 0UL;
   return _addressOffset;
}
inline tBoolean tBusInterface::isDirty(tId id, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return kFalse;
   u32 regId = id&0x01FFFFFF;
   if (regId > kMaxRegisterId) {
      nNIMXRegisterMap120::setStatus(s, kStatusBadSelector);
      return kFalse;
   }

   return _dirtyVector[regId];
}

inline void tBusInterface::markDirty(tId id, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   u32 regId = id&0x01FFFFFF;

   if (regId > kMaxRegisterId) {
      nNIMXRegisterMap120::setStatus(s, kStatusBadSelector);
      return;
   }

   _dirtyVector[regId] = 1;
}

inline void tBusInterface::markClean(tId id, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   u32 regId = id&0x01FFFFFF;

   if (regId > kMaxRegisterId) {
      nNIMXRegisterMap120::setStatus(s, kStatusBadSelector);
      return;
   }

   _dirtyVector[regId] = 0;
}

inline void tBusInterface::markDirty(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   unsigned int i;
   for (i = 0; i < sizeof(_dirtyVector)/sizeof(_dirtyVector[0]); i++) {
      _dirtyVector[i] = 1;
   }
}

inline void tBusInterface::markClean(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   for (unsigned int i = 0; i < sizeof(_dirtyVector)/sizeof(_dirtyVector[0]); i++) {
      _dirtyVector[i] = 0;
   }
}

inline tBusInterface::tGlobalInterruptStatus_Register::tGlobalInterruptStatus_Register()
{
   _softCopy = u16(0x0);
}

inline tBusInterface::tGlobalInterruptStatus_Register::tRegisterMap* tBusInterface::tGlobalInterruptStatus_Register::registerMap(void)
{
   return _regMap;
}

inline void tBusInterface::tGlobalInterruptStatus_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBusInterface::tGlobalInterruptStatus_Register::refresh(nMDBG::tStatus2* s)
{
   _softCopy = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setAI_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffe) | ((u16(fieldValue) << 0x0) & ~0xfffe);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getAI_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffe) >> 0x0);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readAI_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_Interrupt_Status(s);
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setAO_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffd) | ((u16(fieldValue) << 0x1) & ~0xfffd);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getAO_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffd) >> 0x1);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readAO_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_Interrupt_Status(s);
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setG0_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffb) | ((u16(fieldValue) << 0x2) & ~0xfffb);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getG0_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffb) >> 0x2);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readG0_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getG0_Interrupt_Status(s);
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setG1_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff7) | ((u16(fieldValue) << 0x3) & ~0xfff7);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getG1_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfff7) >> 0x3);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readG1_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getG1_Interrupt_Status(s);
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setG2_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffef) | ((u16(fieldValue) << 0x4) & ~0xffef);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getG2_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffef) >> 0x4);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readG2_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getG2_Interrupt_Status(s);
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setG3_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffdf) | ((u16(fieldValue) << 0x5) & ~0xffdf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getG3_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffdf) >> 0x5);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readG3_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getG3_Interrupt_Status(s);
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setDI_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffbf) | ((u16(fieldValue) << 0x6) & ~0xffbf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getDI_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffbf) >> 0x6);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readDI_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_Interrupt_Status(s);
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setDO_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff7f) | ((u16(fieldValue) << 0x7) & ~0xff7f);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getDO_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readDO_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_Interrupt_Status(s);
}

inline tBusInterface::tGlobalInterruptStatus_Register& tBusInterface::tGlobalInterruptStatus_Register::setGen_Interrupt_Status(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::getGen_Interrupt_Status(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfbff) >> 0xa);
}

inline u16 tBusInterface::tGlobalInterruptStatus_Register::readGen_Interrupt_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGen_Interrupt_Status(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register::tAI_Interrupt_Status_Register()
{
   _softCopy = u16(0x0);
}

inline tBusInterface::tAI_Interrupt_Status_Register::tRegisterMap* tBusInterface::tAI_Interrupt_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tBusInterface::tAI_Interrupt_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBusInterface::tAI_Interrupt_Status_Register::refresh(nMDBG::tStatus2* s)
{
   _softCopy = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_OverflowIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffbf) | ((u16(fieldValue) << 0x6) & ~0xffbf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_OverflowIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffbf) >> 0x6);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_OverflowIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_OverflowIrqSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_SC_PreWaitRollOverSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff7f) | ((u16(fieldValue) << 0x7) & ~0xff7f);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_SC_PreWaitRollOverSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_SC_PreWaitRollOverSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_SC_PreWaitRollOverSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_ScanOverrunIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfeff) | ((u16(fieldValue) << 0x8) & ~0xfeff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_ScanOverrunIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfeff) >> 0x8);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_ScanOverrunIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_ScanOverrunIrqSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_SC_TC_IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfdff) | ((u16(fieldValue) << 0x9) & ~0xfdff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_SC_TC_IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfdff) >> 0x9);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_SC_TC_IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_SC_TC_IrqSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_Start1IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_Start1IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfbff) >> 0xa);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_Start1IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_Start1IrqSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_Start2IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf7ff) | ((u16(fieldValue) << 0xb) & ~0xf7ff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_Start2IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf7ff) >> 0xb);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_Start2IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_Start2IrqSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_StartIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_StartIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xefff) >> 0xc);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_StartIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_StartIrqSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_StopIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xdfff) | ((u16(fieldValue) << 0xd) & ~0xdfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_StopIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xdfff) >> 0xd);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_StopIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_StopIrqSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_OverrunIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xbfff) | ((u16(fieldValue) << 0xe) & ~0xbfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_OverrunIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_OverrunIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_OverrunIrqSt(s);
}

inline tBusInterface::tAI_Interrupt_Status_Register& tBusInterface::tAI_Interrupt_Status_Register::setAI_FifoIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::getAI_FifoIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline u16 tBusInterface::tAI_Interrupt_Status_Register::readAI_FifoIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_FifoIrqSt(s);
}

inline tBusInterface::tAO_Interrupt_Status_Register::tAO_Interrupt_Status_Register()
{
   _softCopy = u16(0x0);
}

inline tBusInterface::tAO_Interrupt_Status_Register::tRegisterMap* tBusInterface::tAO_Interrupt_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tBusInterface::tAO_Interrupt_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBusInterface::tAO_Interrupt_Status_Register& tBusInterface::tAO_Interrupt_Status_Register::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBusInterface::tAO_Interrupt_Status_Register::refresh(nMDBG::tStatus2* s)
{
   _softCopy = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tBusInterface::tAO_Interrupt_Status_Register& tBusInterface::tAO_Interrupt_Status_Register::setAO_WriteTooFastIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfdff) | ((u16(fieldValue) << 0x9) & ~0xfdff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::getAO_WriteTooFastIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfdff) >> 0x9);
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::readAO_WriteTooFastIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_WriteTooFastIrqSt(s);
}

inline tBusInterface::tAO_Interrupt_Status_Register& tBusInterface::tAO_Interrupt_Status_Register::setAO_BC_TC_IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::getAO_BC_TC_IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfbff) >> 0xa);
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::readAO_BC_TC_IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_BC_TC_IrqSt(s);
}

inline tBusInterface::tAO_Interrupt_Status_Register& tBusInterface::tAO_Interrupt_Status_Register::setAO_Start1IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf7ff) | ((u16(fieldValue) << 0xb) & ~0xf7ff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::getAO_Start1IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf7ff) >> 0xb);
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::readAO_Start1IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_Start1IrqSt(s);
}

inline tBusInterface::tAO_Interrupt_Status_Register& tBusInterface::tAO_Interrupt_Status_Register::setAO_UpdateIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::getAO_UpdateIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xefff) >> 0xc);
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::readAO_UpdateIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UpdateIrqSt(s);
}

inline tBusInterface::tAO_Interrupt_Status_Register& tBusInterface::tAO_Interrupt_Status_Register::setAO_ErrorIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xdfff) | ((u16(fieldValue) << 0xd) & ~0xdfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::getAO_ErrorIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xdfff) >> 0xd);
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::readAO_ErrorIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_ErrorIrqSt(s);
}

inline tBusInterface::tAO_Interrupt_Status_Register& tBusInterface::tAO_Interrupt_Status_Register::setAO_UC_TC_IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xbfff) | ((u16(fieldValue) << 0xe) & ~0xbfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::getAO_UC_TC_IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::readAO_UC_TC_IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UC_TC_IrqSt(s);
}

inline tBusInterface::tAO_Interrupt_Status_Register& tBusInterface::tAO_Interrupt_Status_Register::setAO_FifoIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::getAO_FifoIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline u16 tBusInterface::tAO_Interrupt_Status_Register::readAO_FifoIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_FifoIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t::tTIO_Interrupt_Status_Register_t(u32 offset, u32 id)
 : kOffset(offset),
   kId(id)
{
   _softCopy = u16(0x0);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t::tTIO_Interrupt_Status_Register_t()
 : kOffset((u32)~0),
   kId((u32)~0)
{
   _softCopy = u16(0x0);
}

inline void tBusInterface::tTIO_Interrupt_Status_Register_t::initialize(u32 offset, u32 id)
{
   u32* mutableOffset = const_cast<u32*>(&this->kOffset);
   u32* mutableId     = const_cast<u32*>(&this->kId);
   *mutableOffset = offset;
   *mutableId = id;
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t::tRegisterMap* tBusInterface::tTIO_Interrupt_Status_Register_t::registerMap(void)
{
   return _regMap;
}

inline void tBusInterface::tTIO_Interrupt_Status_Register_t::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBusInterface::tTIO_Interrupt_Status_Register_t::refresh(nMDBG::tStatus2* s)
{
   _softCopy = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_DmaIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffe) | ((u16(fieldValue) << 0x0) & ~0xfffe);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_DmaIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffe) >> 0x0);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_DmaIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_DmaIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_GateIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffd) | ((u16(fieldValue) << 0x1) & ~0xfffd);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_GateIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffd) >> 0x1);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_GateIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_GateIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_TC_IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffb) | ((u16(fieldValue) << 0x2) & ~0xfffb);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_TC_IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffb) >> 0x2);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_TC_IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_TC_IrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_SampleClkErrorSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff7) | ((u16(fieldValue) << 0x3) & ~0xfff7);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_SampleClkErrorSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfff7) >> 0x3);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_SampleClkErrorSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_SampleClkErrorSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_GateErrorIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffef) | ((u16(fieldValue) << 0x4) & ~0xffef);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_GateErrorIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffef) >> 0x4);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_GateErrorIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_GateErrorIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_TC_ErrorIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffdf) | ((u16(fieldValue) << 0x5) & ~0xffdf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_TC_ErrorIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffdf) >> 0x5);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_TC_ErrorIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_TC_ErrorIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_DMA_ErrorIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffbf) | ((u16(fieldValue) << 0x6) & ~0xffbf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_DMA_ErrorIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffbf) >> 0x6);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_DMA_ErrorIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_DMA_ErrorIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_WritesTooFast(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff7f) | ((u16(fieldValue) << 0x7) & ~0xff7f);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_WritesTooFast(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_WritesTooFast(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_WritesTooFast(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setTIO_GateSwitchErrorIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfeff) | ((u16(fieldValue) << 0x8) & ~0xfeff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getTIO_GateSwitchErrorIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfeff) >> 0x8);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readTIO_GateSwitchErrorIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTIO_GateSwitchErrorIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setSampleClockIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfdff) | ((u16(fieldValue) << 0x9) & ~0xfdff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getSampleClockIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfdff) >> 0x9);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readSampleClockIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSampleClockIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setDisarmEventIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getDisarmEventIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfbff) >> 0xa);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readDisarmEventIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDisarmEventIrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setAuxCtrTC_IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf7ff) | ((u16(fieldValue) << 0xb) & ~0xf7ff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getAuxCtrTC_IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf7ff) >> 0xb);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readAuxCtrTC_IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAuxCtrTC_IrqSt(s);
}

inline tBusInterface::tTIO_Interrupt_Status_Register_t& tBusInterface::tTIO_Interrupt_Status_Register_t::setAuxCtrTC_ErrorIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::getAuxCtrTC_ErrorIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xefff) >> 0xc);
}

inline u16 tBusInterface::tTIO_Interrupt_Status_Register_t::readAuxCtrTC_ErrorIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAuxCtrTC_ErrorIrqSt(s);
}

inline tBusInterface::tGlobalInterruptEnable_Register::tGlobalInterruptEnable_Register()
{
}

inline tBusInterface::tGlobalInterruptEnable_Register::tRegisterMap* tBusInterface::tGlobalInterruptEnable_Register::registerMap(void)
{
   return _regMap;
}

inline void tBusInterface::tGlobalInterruptEnable_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline void tBusInterface::tGlobalInterruptEnable_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), fieldValue, s);
}

inline void tBusInterface::tGlobalInterruptEnable_Register::writeAI_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0xfffffffe,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeAO_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1) & ~0xfffffffd,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeG0_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x2) & ~0xfffffffb,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeG1_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x3) & ~0xfffffff7,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeG2_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x4) & ~0xffffffef,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeG3_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x5) & ~0xffffffdf,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeDI_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x6) & ~0xffffffbf,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeDO_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x7) & ~0xffffff7f,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeGen_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xa) & ~0xfffffbff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeAI_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x10) & ~0xfffeffff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeAO_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x11) & ~0xfffdffff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeG0_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x12) & ~0xfffbffff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeG1_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x13) & ~0xfff7ffff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeG2_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x14) & ~0xffefffff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeG3_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x15) & ~0xffdfffff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeDI_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x16) & ~0xffbfffff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeDO_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x17) & ~0xff7fffff,s);
}
inline void tBusInterface::tGlobalInterruptEnable_Register::writeGen_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1a) & ~0xfbffffff,s);
}
inline tBusInterface::tDI_Interrupt_Status_Register::tDI_Interrupt_Status_Register()
{
   _softCopy = u16(0x0);
}

inline tBusInterface::tDI_Interrupt_Status_Register::tRegisterMap* tBusInterface::tDI_Interrupt_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tBusInterface::tDI_Interrupt_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBusInterface::tDI_Interrupt_Status_Register::refresh(nMDBG::tStatus2* s)
{
   _softCopy = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_ChangeDetectionIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffe) | ((u16(fieldValue) << 0x0) & ~0xfffe);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_ChangeDetectionIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffe) >> 0x0);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_ChangeDetectionIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_ChangeDetectionIrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_ChangeDetectionErrorIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffd) | ((u16(fieldValue) << 0x1) & ~0xfffd);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_ChangeDetectionErrorIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffd) >> 0x1);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_ChangeDetectionErrorIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_ChangeDetectionErrorIrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_OverflowIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffbf) | ((u16(fieldValue) << 0x6) & ~0xffbf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_OverflowIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffbf) >> 0x6);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_OverflowIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_OverflowIrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_SC_PreWaitRollOverSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff7f) | ((u16(fieldValue) << 0x7) & ~0xff7f);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_SC_PreWaitRollOverSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_SC_PreWaitRollOverSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_SC_PreWaitRollOverSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_ScanOverrunIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfeff) | ((u16(fieldValue) << 0x8) & ~0xfeff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_ScanOverrunIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfeff) >> 0x8);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_ScanOverrunIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_ScanOverrunIrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_SC_TC_IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfdff) | ((u16(fieldValue) << 0x9) & ~0xfdff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_SC_TC_IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfdff) >> 0x9);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_SC_TC_IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_SC_TC_IrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_Start1IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_Start1IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfbff) >> 0xa);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_Start1IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_Start1IrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_Start2IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf7ff) | ((u16(fieldValue) << 0xb) & ~0xf7ff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_Start2IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf7ff) >> 0xb);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_Start2IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_Start2IrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_StartIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_StartIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xefff) >> 0xc);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_StartIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_StartIrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_StopIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xdfff) | ((u16(fieldValue) << 0xd) & ~0xdfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_StopIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xdfff) >> 0xd);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_StopIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_StopIrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_OverrunIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xbfff) | ((u16(fieldValue) << 0xe) & ~0xbfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_OverrunIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_OverrunIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_OverrunIrqSt(s);
}

inline tBusInterface::tDI_Interrupt_Status_Register& tBusInterface::tDI_Interrupt_Status_Register::setDI_FifoIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::getDI_FifoIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline u16 tBusInterface::tDI_Interrupt_Status_Register::readDI_FifoIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_FifoIrqSt(s);
}

inline tBusInterface::tDO_Interrupt_Status_Register::tDO_Interrupt_Status_Register()
{
   _softCopy = u16(0x0);
}

inline tBusInterface::tDO_Interrupt_Status_Register::tRegisterMap* tBusInterface::tDO_Interrupt_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tBusInterface::tDO_Interrupt_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBusInterface::tDO_Interrupt_Status_Register& tBusInterface::tDO_Interrupt_Status_Register::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBusInterface::tDO_Interrupt_Status_Register::refresh(nMDBG::tStatus2* s)
{
   _softCopy = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tBusInterface::tDO_Interrupt_Status_Register& tBusInterface::tDO_Interrupt_Status_Register::setDO_WriteTooFastIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfdff) | ((u16(fieldValue) << 0x9) & ~0xfdff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::getDO_WriteTooFastIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfdff) >> 0x9);
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::readDO_WriteTooFastIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_WriteTooFastIrqSt(s);
}

inline tBusInterface::tDO_Interrupt_Status_Register& tBusInterface::tDO_Interrupt_Status_Register::setDO_BC_TC_IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::getDO_BC_TC_IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfbff) >> 0xa);
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::readDO_BC_TC_IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_BC_TC_IrqSt(s);
}

inline tBusInterface::tDO_Interrupt_Status_Register& tBusInterface::tDO_Interrupt_Status_Register::setDO_Start1IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf7ff) | ((u16(fieldValue) << 0xb) & ~0xf7ff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::getDO_Start1IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf7ff) >> 0xb);
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::readDO_Start1IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_Start1IrqSt(s);
}

inline tBusInterface::tDO_Interrupt_Status_Register& tBusInterface::tDO_Interrupt_Status_Register::setDO_UpdateIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::getDO_UpdateIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xefff) >> 0xc);
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::readDO_UpdateIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_UpdateIrqSt(s);
}

inline tBusInterface::tDO_Interrupt_Status_Register& tBusInterface::tDO_Interrupt_Status_Register::setDO_ErrorIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xdfff) | ((u16(fieldValue) << 0xd) & ~0xdfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::getDO_ErrorIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xdfff) >> 0xd);
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::readDO_ErrorIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_ErrorIrqSt(s);
}

inline tBusInterface::tDO_Interrupt_Status_Register& tBusInterface::tDO_Interrupt_Status_Register::setDO_UC_TC_IrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xbfff) | ((u16(fieldValue) << 0xe) & ~0xbfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::getDO_UC_TC_IrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::readDO_UC_TC_IrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_UC_TC_IrqSt(s);
}

inline tBusInterface::tDO_Interrupt_Status_Register& tBusInterface::tDO_Interrupt_Status_Register::setDO_FifoIrqSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::getDO_FifoIrqSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline u16 tBusInterface::tDO_Interrupt_Status_Register::readDO_FifoIrqSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_FifoIrqSt(s);
}

inline tBusInterface::tGen_Interrupt_Status_Register::tGen_Interrupt_Status_Register()
{
   _softCopy = u16(0x0);
}

inline tBusInterface::tGen_Interrupt_Status_Register::tRegisterMap* tBusInterface::tGen_Interrupt_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tBusInterface::tGen_Interrupt_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBusInterface::tGen_Interrupt_Status_Register& tBusInterface::tGen_Interrupt_Status_Register::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tBusInterface::tGen_Interrupt_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBusInterface::tGen_Interrupt_Status_Register::refresh(nMDBG::tStatus2* s)
{
   _softCopy = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
}

inline u16 tBusInterface::tGen_Interrupt_Status_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tBusInterface::tGen_Interrupt_Status_Register& tBusInterface::tGen_Interrupt_Status_Register::setWatchdogTimerTriggerSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffe) | ((u16(fieldValue) << 0x0) & ~0xfffe);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGen_Interrupt_Status_Register::getWatchdogTimerTriggerSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffe) >> 0x0);
}

inline u16 tBusInterface::tGen_Interrupt_Status_Register::readWatchdogTimerTriggerSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getWatchdogTimerTriggerSt(s);
}

inline tBusInterface::tGen_Interrupt_Status_Register& tBusInterface::tGen_Interrupt_Status_Register::setPLL_OutOfLockEventSt(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffd) | ((u16(fieldValue) << 0x1) & ~0xfffd);
   setRegister(newValue, s);
   return *this;
}

inline u16 tBusInterface::tGen_Interrupt_Status_Register::getPLL_OutOfLockEventSt(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffd) >> 0x1);
}

inline u16 tBusInterface::tGen_Interrupt_Status_Register::readPLL_OutOfLockEventSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPLL_OutOfLockEventSt(s);
}

#endif


// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// This file is autogenerated!!!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!