// 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 ___tDI_ipp___
#define ___tDI_ipp___

#ifndef ___tDI_h___
#include "tDI.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 tDI::tReg8IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u8 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write8(offset, value);
}
inline u8 tDI::tReg8IODirect32::read(
   tBusSpaceReference addrSpace,
   u32 offset,
   nMDBG::tStatus2* s)
{
   u8 value = (u8)~0;
   if (s && s->isFatal()) return value;
   value = (u8)addrSpace.read8(offset);
   return value;
}

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

inline u16 tDI::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 tDI::tReg32IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u32 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write32(offset, value);
}

inline u32 tDI::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 tDI::getBusSpaceReference(void) const
{
   return _addrSpace;
}

inline void tDI::setAddressOffset(u32 value, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _addressOffset = value;
}
inline u32 tDI::getAddressOffset(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return 0UL;
   return _addressOffset;
}
inline tBoolean tDI::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 tDI::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 tDI::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 tDI::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 tDI::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 tDI::tDI_ChangeDetectStatusRegister::tDI_ChangeDetectStatusRegister()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_ChangeDetectStatusRegister::tRegisterMap* tDI::tDI_ChangeDetectStatusRegister::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_ChangeDetectStatusRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tDI::tDI_ChangeDetectStatusRegister& tDI::tDI_ChangeDetectStatusRegister::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u32 tDI::tDI_ChangeDetectStatusRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u32 tDI::tDI_ChangeDetectStatusRegister::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tDI::tDI_ChangeDetectStatusRegister& tDI::tDI_ChangeDetectStatusRegister::setDI_ChangeDetectStatus(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffe) | ((u32(fieldValue) << 0x0) & ~0xfffffffe);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_ChangeDetectStatusRegister::getDI_ChangeDetectStatus(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffffffe) >> 0x0);
}

inline u32 tDI::tDI_ChangeDetectStatusRegister::readDI_ChangeDetectStatus(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_ChangeDetectStatus(s);
}

inline tDI::tDI_ChangeDetectStatusRegister& tDI::tDI_ChangeDetectStatusRegister::setDI_ChangeDetectError(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffd) | ((u32(fieldValue) << 0x1) & ~0xfffffffd);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_ChangeDetectStatusRegister::getDI_ChangeDetectError(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffffffd) >> 0x1);
}

inline u32 tDI::tDI_ChangeDetectStatusRegister::readDI_ChangeDetectError(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_ChangeDetectError(s);
}

inline tDI::tDI_ChangeIrqRE_Register::tDI_ChangeIrqRE_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_ChangeIrqRE_Register::tRegisterMap* tDI::tDI_ChangeIrqRE_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_ChangeIrqRE_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tDI_ChangeIrqRE_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_ChangeIrqRE_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_ChangeIrqRE_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tDI_ChangeIrqRE_Register& tDI::tDI_ChangeIrqRE_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDI::tDI_ChangeIrqRE_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tDI_ChangeIrqRE_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDI::tDI_ChangeIrqRE_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDI::tDI_ChangeIrqRE_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tDI_ChangeIrqRE_Register& tDI::tDI_ChangeIrqRE_Register::setDI_ChangeIrqRE(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_ChangeIrqRE_Register::getDI_ChangeIrqRE(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tDI::tDI_ChangeIrqRE_Register::writeDI_ChangeIrqRE(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_ChangeIrqRE(fieldValue, s);
   flush(s, force);
}
inline u32 tDI::tDI_ChangeIrqRE_Register::readDI_ChangeIrqRE(nMDBG::tStatus2* s)
{
   return getDI_ChangeIrqRE(s);
}

inline tDI::tDI_ChangeDetectLatchedDI_Register::tDI_ChangeDetectLatchedDI_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_ChangeDetectLatchedDI_Register::tRegisterMap* tDI::tDI_ChangeDetectLatchedDI_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_ChangeDetectLatchedDI_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tDI::tDI_ChangeDetectLatchedDI_Register& tDI::tDI_ChangeDetectLatchedDI_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u32 tDI::tDI_ChangeDetectLatchedDI_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u32 tDI::tDI_ChangeDetectLatchedDI_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tDI::tDI_ChangeDetectLatchedDI_Register& tDI::tDI_ChangeDetectLatchedDI_Register::setDI_ChangeDetectLatchedDI(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_ChangeDetectLatchedDI_Register::getDI_ChangeDetectLatchedDI(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tDI::tDI_ChangeDetectLatchedDI_Register::readDI_ChangeDetectLatchedDI(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_ChangeDetectLatchedDI(s);
}

inline tDI::tDI_ChangeIrqFE_Register::tDI_ChangeIrqFE_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_ChangeIrqFE_Register::tRegisterMap* tDI::tDI_ChangeIrqFE_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_ChangeIrqFE_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tDI_ChangeIrqFE_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_ChangeIrqFE_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_ChangeIrqFE_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tDI_ChangeIrqFE_Register& tDI::tDI_ChangeIrqFE_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDI::tDI_ChangeIrqFE_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tDI_ChangeIrqFE_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDI::tDI_ChangeIrqFE_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDI::tDI_ChangeIrqFE_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tDI_ChangeIrqFE_Register& tDI::tDI_ChangeIrqFE_Register::setDI_ChangeIrqFE(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_ChangeIrqFE_Register::getDI_ChangeIrqFE(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tDI::tDI_ChangeIrqFE_Register::writeDI_ChangeIrqFE(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_ChangeIrqFE(fieldValue, s);
   flush(s, force);
}
inline u32 tDI::tDI_ChangeIrqFE_Register::readDI_ChangeIrqFE(nMDBG::tStatus2* s)
{
   return getDI_ChangeIrqFE(s);
}

inline tDI::tDI_ChangeDetectLatchedPFI_Register::tDI_ChangeDetectLatchedPFI_Register()
{
   _softCopy = u16(0x0);
}

inline tDI::tDI_ChangeDetectLatchedPFI_Register::tRegisterMap* tDI::tDI_ChangeDetectLatchedPFI_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_ChangeDetectLatchedPFI_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u16 tDI::tDI_ChangeDetectLatchedPFI_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u16 tDI::tDI_ChangeDetectLatchedPFI_Register::getDI_ChangeDetectLatchedPFI(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x0) >> 0x0);
}

inline u16 tDI::tDI_ChangeDetectLatchedPFI_Register::readDI_ChangeDetectLatchedPFI(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_ChangeDetectLatchedPFI(s);
}

inline tDI::tPFI_ChangeIrq_Register::tPFI_ChangeIrq_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tPFI_ChangeIrq_Register::tRegisterMap* tDI::tPFI_ChangeIrq_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tPFI_ChangeIrq_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tPFI_ChangeIrq_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tPFI_ChangeIrq_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tPFI_ChangeIrq_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tPFI_ChangeIrq_Register& tDI::tPFI_ChangeIrq_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDI::tPFI_ChangeIrq_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tPFI_ChangeIrq_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDI::tPFI_ChangeIrq_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDI::tPFI_ChangeIrq_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tPFI_ChangeIrq_Register& tDI::tPFI_ChangeIrq_Register::setPFI_ChangeIrqRE(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff0000) | ((u32(fieldValue) << 0x0) & ~0xffff0000);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tPFI_ChangeIrq_Register::getPFI_ChangeIrqRE(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffff0000) >> 0x0);
}

inline void tDI::tPFI_ChangeIrq_Register::writePFI_ChangeIrqRE(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_ChangeIrqRE(fieldValue, s);
   flush(s, force);
}
inline u32 tDI::tPFI_ChangeIrq_Register::readPFI_ChangeIrqRE(nMDBG::tStatus2* s)
{
   return getPFI_ChangeIrqRE(s);
}

inline tDI::tPFI_ChangeIrq_Register& tDI::tPFI_ChangeIrq_Register::setPFI_ChangeIrqFE(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff) | ((u32(fieldValue) << 0x10) & ~0xffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tPFI_ChangeIrq_Register::getPFI_ChangeIrqFE(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffff) >> 0x10);
}

inline void tDI::tPFI_ChangeIrq_Register::writePFI_ChangeIrqFE(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_ChangeIrqFE(fieldValue, s);
   flush(s, force);
}
inline u32 tDI::tPFI_ChangeIrq_Register::readPFI_ChangeIrqFE(nMDBG::tStatus2* s)
{
   return getPFI_ChangeIrqFE(s);
}

inline tDI::tDI_ChangeDetectIRQ_Register::tDI_ChangeDetectIRQ_Register()
{
}

inline tDI::tDI_ChangeDetectIRQ_Register::tRegisterMap* tDI::tDI_ChangeDetectIRQ_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_ChangeDetectIRQ_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tDI::tDI_ChangeDetectIRQ_Register::writeChangeDetectIRQ_Acknowledge(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0xfffffffe,s);
}
inline void tDI::tDI_ChangeDetectIRQ_Register::writeChangeDetectErrorIRQ_Acknowledge(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1) & ~0xfffffffd,s);
}
inline void tDI::tDI_ChangeDetectIRQ_Register::writeChangeDetectIRQ_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x4) & ~0xffffffef,s);
}
inline void tDI::tDI_ChangeDetectIRQ_Register::writeChangeDetectIRQ_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x5) & ~0xffffffdf,s);
}
inline void tDI::tDI_ChangeDetectIRQ_Register::writeChangeDetectErrorIRQ_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x6) & ~0xffffffbf,s);
}
inline void tDI::tDI_ChangeDetectIRQ_Register::writeChangeDetectErrorIRQ_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x7) & ~0xffffff7f,s);
}
inline tDI::tDI_DMA_Select_Register::tDI_DMA_Select_Register()
{
   _softCopy = u8(0x0);
}

inline tDI::tDI_DMA_Select_Register::tRegisterMap* tDI::tDI_DMA_Select_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_DMA_Select_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tDI_DMA_Select_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_DMA_Select_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_DMA_Select_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tDI_DMA_Select_Register& tDI::tDI_DMA_Select_Register::setRegister(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u8 tDI::tDI_DMA_Select_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tDI_DMA_Select_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u8(0xff);
      _softCopy |= u8(0x0);
      markClean(s);
   }
}

inline void tDI::tDI_DMA_Select_Register::writeRegister(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u8 tDI::tDI_DMA_Select_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tDI_DMA_Select_Register& tDI::tDI_DMA_Select_Register::setDI_DoneNotificationEnable(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0x7f) | ((u8(fieldValue) << 0x7) & ~0x7f);
   setRegister(newValue, s);
   return *this;
}

inline u8 tDI::tDI_DMA_Select_Register::getDI_DoneNotificationEnable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0x7f) >> 0x7);
}

inline void tDI::tDI_DMA_Select_Register::writeDI_DoneNotificationEnable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_DoneNotificationEnable(fieldValue, s);
   flush(s, force);
}
inline u8 tDI::tDI_DMA_Select_Register::readDI_DoneNotificationEnable(nMDBG::tStatus2* s)
{
   return getDI_DoneNotificationEnable(s);
}

inline tDI::tStatic_Digital_Input_Register::tStatic_Digital_Input_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tStatic_Digital_Input_Register::tRegisterMap* tDI::tStatic_Digital_Input_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tStatic_Digital_Input_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tDI::tStatic_Digital_Input_Register& tDI::tStatic_Digital_Input_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u32 tDI::tStatic_Digital_Input_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u32 tDI::tStatic_Digital_Input_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tDI::tStatic_Digital_Input_Register& tDI::tStatic_Digital_Input_Register::setDI_StaticValue(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tStatic_Digital_Input_Register::getDI_StaticValue(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tDI::tStatic_Digital_Input_Register::readDI_StaticValue(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDI_StaticValue(s);
}

inline tDI::tDI_FIFO_St_Register::tDI_FIFO_St_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_FIFO_St_Register::tRegisterMap* tDI::tDI_FIFO_St_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_FIFO_St_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tDI::tDI_FIFO_St_Register& tDI::tDI_FIFO_St_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u32 tDI::tDI_FIFO_St_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u32 tDI::tDI_FIFO_St_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tDI::tDI_FIFO_St_Register& tDI::tDI_FIFO_St_Register::setCDI_FIFO_FullCount(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff0000) | ((u32(fieldValue) << 0x0) & ~0xffff0000);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_FIFO_St_Register::getCDI_FIFO_FullCount(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffff0000) >> 0x0);
}

inline u32 tDI::tDI_FIFO_St_Register::readCDI_FIFO_FullCount(nMDBG::tStatus2* s)
{
   refresh(s);
   return getCDI_FIFO_FullCount(s);
}

inline tDI::tDI_Mode_Register::tDI_Mode_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_Mode_Register::tRegisterMap* tDI::tDI_Mode_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_Mode_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tDI_Mode_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_Mode_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_Mode_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tDI_Mode_Register& tDI::tDI_Mode_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDI::tDI_Mode_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tDI_Mode_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDI::tDI_Mode_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDI::tDI_Mode_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tDI_Mode_Register& tDI::tDI_Mode_Register::setDI_DigitalFiltersMode(nDI::tDI_FilterMode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffff7ff) | ((u32(fieldValue) << 0xb) & ~0xfffff7ff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_FilterMode_t tDI::tDI_Mode_Register::getDI_DigitalFiltersMode(nMDBG::tStatus2*) const
{
   return nDI::tDI_FilterMode_t((_softCopy & ~0xfffff7ff) >> 0xb);
}

inline void tDI::tDI_Mode_Register::writeDI_DigitalFiltersMode(nDI::tDI_FilterMode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_DigitalFiltersMode(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_FilterMode_t tDI::tDI_Mode_Register::readDI_DigitalFiltersMode(nMDBG::tStatus2* s)
{
   return getDI_DigitalFiltersMode(s);
}

inline tDI::tDI_Mode_Register& tDI::tDI_Mode_Register::setDI_Data_Lane(nDI::tDI_Data_Lane_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffcfff) | ((u32(fieldValue) << 0xc) & ~0xffffcfff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Data_Lane_t tDI::tDI_Mode_Register::getDI_Data_Lane(nMDBG::tStatus2*) const
{
   return nDI::tDI_Data_Lane_t((_softCopy & ~0xffffcfff) >> 0xc);
}

inline void tDI::tDI_Mode_Register::writeDI_Data_Lane(nDI::tDI_Data_Lane_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_Data_Lane(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Data_Lane_t tDI::tDI_Mode_Register::readDI_Data_Lane(nMDBG::tStatus2* s)
{
   return getDI_Data_Lane(s);
}

inline tDI::tDI_Mode_Register& tDI::tDI_Mode_Register::setDI_DataWidth(nDI::tDI_DataWidth_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff3fff) | ((u32(fieldValue) << 0xe) & ~0xffff3fff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_DataWidth_t tDI::tDI_Mode_Register::getDI_DataWidth(nMDBG::tStatus2*) const
{
   return nDI::tDI_DataWidth_t((_softCopy & ~0xffff3fff) >> 0xe);
}

inline void tDI::tDI_Mode_Register::writeDI_DataWidth(nDI::tDI_DataWidth_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_DataWidth(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_DataWidth_t tDI::tDI_Mode_Register::readDI_DataWidth(nMDBG::tStatus2* s)
{
   return getDI_DataWidth(s);
}

inline tDI::tDI_FIFO_Data_Register::tDI_FIFO_Data_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_FIFO_Data_Register::tRegisterMap* tDI::tDI_FIFO_Data_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_FIFO_Data_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tDI::tDI_FIFO_Data_Register& tDI::tDI_FIFO_Data_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u32 tDI::tDI_FIFO_Data_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u32 tDI::tDI_FIFO_Data_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tDI::tDI_FIFO_Data_Register& tDI::tDI_FIFO_Data_Register::setCDI_FIFO_Data(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_FIFO_Data_Register::getCDI_FIFO_Data(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tDI::tDI_FIFO_Data_Register::readCDI_FIFO_Data(nMDBG::tStatus2* s)
{
   refresh(s);
   return getCDI_FIFO_Data(s);
}

inline tDI::tDI_FIFO_Data_Register16::tDI_FIFO_Data_Register16()
{
   _softCopy = u16(0x0);
}

inline tDI::tDI_FIFO_Data_Register16::tRegisterMap* tDI::tDI_FIFO_Data_Register16::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_FIFO_Data_Register16::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u16 tDI::tDI_FIFO_Data_Register16::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u16 tDI::tDI_FIFO_Data_Register16::getCDI_FIFO_Data16(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x0) >> 0x0);
}

inline u16 tDI::tDI_FIFO_Data_Register16::readCDI_FIFO_Data16(nMDBG::tStatus2* s)
{
   refresh(s);
   return getCDI_FIFO_Data16(s);
}

inline tDI::tDI_FIFO_Data_Register8::tDI_FIFO_Data_Register8()
{
   _softCopy = u8(0x0);
}

inline tDI::tDI_FIFO_Data_Register8::tRegisterMap* tDI::tDI_FIFO_Data_Register8::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_FIFO_Data_Register8::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tDI::tDI_FIFO_Data_Register8& tDI::tDI_FIFO_Data_Register8::setRegister(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u8 tDI::tDI_FIFO_Data_Register8::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u8 tDI::tDI_FIFO_Data_Register8::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tDI::tDI_FIFO_Data_Register8& tDI::tDI_FIFO_Data_Register8::setCDI_FIFO_Data8(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0x0) | ((u8(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u8 tDI::tDI_FIFO_Data_Register8::getCDI_FIFO_Data8(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0x0) >> 0x0);
}

inline u8 tDI::tDI_FIFO_Data_Register8::readCDI_FIFO_Data8(nMDBG::tStatus2* s)
{
   refresh(s);
   return getCDI_FIFO_Data8(s);
}

inline tDI::tDI_Mask_Enable_Register::tDI_Mask_Enable_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_Mask_Enable_Register::tRegisterMap* tDI::tDI_Mask_Enable_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_Mask_Enable_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tDI_Mask_Enable_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_Mask_Enable_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_Mask_Enable_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tDI_Mask_Enable_Register& tDI::tDI_Mask_Enable_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDI::tDI_Mask_Enable_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tDI_Mask_Enable_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDI::tDI_Mask_Enable_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDI::tDI_Mask_Enable_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tDI_Mask_Enable_Register& tDI::tDI_Mask_Enable_Register::setCDI_Mask(nDI::tDI_Mask_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Mask_t tDI::tDI_Mask_Enable_Register::getCDI_Mask(nMDBG::tStatus2*) const
{
   return nDI::tDI_Mask_t((_softCopy & ~0x0) >> 0x0);
}

inline void tDI::tDI_Mask_Enable_Register::writeCDI_Mask(nDI::tDI_Mask_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setCDI_Mask(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Mask_t tDI::tDI_Mask_Enable_Register::readCDI_Mask(nMDBG::tStatus2* s)
{
   return getCDI_Mask(s);
}

inline tDI::tDI_Trigger_Select_Register::tDI_Trigger_Select_Register()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_Trigger_Select_Register::tRegisterMap* tDI::tDI_Trigger_Select_Register::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_Trigger_Select_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tDI_Trigger_Select_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_Trigger_Select_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_Trigger_Select_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDI::tDI_Trigger_Select_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tDI_Trigger_Select_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDI::tDI_Trigger_Select_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDI::tDI_Trigger_Select_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_START1_Select(nDI::tDI_START1_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffc0) | ((u32(fieldValue) << 0x0) & ~0xffffffc0);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_START1_Select_t tDI::tDI_Trigger_Select_Register::getDI_START1_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_START1_Select_t((_softCopy & ~0xffffffc0) >> 0x0);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_START1_Select(nDI::tDI_START1_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_START1_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_START1_Select_t tDI::tDI_Trigger_Select_Register::readDI_START1_Select(nMDBG::tStatus2* s)
{
   return getDI_START1_Select(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_START1_Edge(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffbf) | ((u32(fieldValue) << 0x6) & ~0xffffffbf);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_Trigger_Select_Register::getDI_START1_Edge(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffffbf) >> 0x6);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_START1_Edge(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_START1_Edge(fieldValue, s);
   flush(s, force);
}
inline u32 tDI::tDI_Trigger_Select_Register::readDI_START1_Edge(nMDBG::tStatus2* s)
{
   return getDI_START1_Edge(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_START1_Polarity(nDI::tDI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff7f) | ((u32(fieldValue) << 0x7) & ~0xffffff7f);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Polarity_t tDI::tDI_Trigger_Select_Register::getDI_START1_Polarity(nMDBG::tStatus2*) const
{
   return nDI::tDI_Polarity_t((_softCopy & ~0xffffff7f) >> 0x7);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_START1_Polarity(nDI::tDI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_START1_Polarity(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Polarity_t tDI::tDI_Trigger_Select_Register::readDI_START1_Polarity(nMDBG::tStatus2* s)
{
   return getDI_START1_Polarity(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_START2_Select(nDI::tDI_START2_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffc0ff) | ((u32(fieldValue) << 0x8) & ~0xffffc0ff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_START2_Select_t tDI::tDI_Trigger_Select_Register::getDI_START2_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_START2_Select_t((_softCopy & ~0xffffc0ff) >> 0x8);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_START2_Select(nDI::tDI_START2_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_START2_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_START2_Select_t tDI::tDI_Trigger_Select_Register::readDI_START2_Select(nMDBG::tStatus2* s)
{
   return getDI_START2_Select(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_START2_Edge(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffbfff) | ((u32(fieldValue) << 0xe) & ~0xffffbfff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDI::tDI_Trigger_Select_Register::getDI_START2_Edge(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffbfff) >> 0xe);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_START2_Edge(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_START2_Edge(fieldValue, s);
   flush(s, force);
}
inline u32 tDI::tDI_Trigger_Select_Register::readDI_START2_Edge(nMDBG::tStatus2* s)
{
   return getDI_START2_Edge(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_START2_Polarity(nDI::tDI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff7fff) | ((u32(fieldValue) << 0xf) & ~0xffff7fff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Polarity_t tDI::tDI_Trigger_Select_Register::getDI_START2_Polarity(nMDBG::tStatus2*) const
{
   return nDI::tDI_Polarity_t((_softCopy & ~0xffff7fff) >> 0xf);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_START2_Polarity(nDI::tDI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_START2_Polarity(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Polarity_t tDI::tDI_Trigger_Select_Register::readDI_START2_Polarity(nMDBG::tStatus2* s)
{
   return getDI_START2_Polarity(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_External_Gate_Select(nDI::tDI_External_Gate_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffc0ffff) | ((u32(fieldValue) << 0x10) & ~0xffc0ffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_External_Gate_Select_t tDI::tDI_Trigger_Select_Register::getDI_External_Gate_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_External_Gate_Select_t((_softCopy & ~0xffc0ffff) >> 0x10);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_External_Gate_Select(nDI::tDI_External_Gate_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_External_Gate_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_External_Gate_Select_t tDI::tDI_Trigger_Select_Register::readDI_External_Gate_Select(nMDBG::tStatus2* s)
{
   return getDI_External_Gate_Select(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_External_Gate_Polarity(nDI::tDI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff7fffff) | ((u32(fieldValue) << 0x17) & ~0xff7fffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Polarity_t tDI::tDI_Trigger_Select_Register::getDI_External_Gate_Polarity(nMDBG::tStatus2*) const
{
   return nDI::tDI_Polarity_t((_softCopy & ~0xff7fffff) >> 0x17);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_External_Gate_Polarity(nDI::tDI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_External_Gate_Polarity(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Polarity_t tDI::tDI_Trigger_Select_Register::readDI_External_Gate_Polarity(nMDBG::tStatus2* s)
{
   return getDI_External_Gate_Polarity(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_CONVERT_Source_Select(nDI::tDI_StartConvertSelMux_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xc0ffffff) | ((u32(fieldValue) << 0x18) & ~0xc0ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_StartConvertSelMux_t tDI::tDI_Trigger_Select_Register::getDI_CONVERT_Source_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_StartConvertSelMux_t((_softCopy & ~0xc0ffffff) >> 0x18);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_CONVERT_Source_Select(nDI::tDI_StartConvertSelMux_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_CONVERT_Source_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_StartConvertSelMux_t tDI::tDI_Trigger_Select_Register::readDI_CONVERT_Source_Select(nMDBG::tStatus2* s)
{
   return getDI_CONVERT_Source_Select(s);
}

inline tDI::tDI_Trigger_Select_Register& tDI::tDI_Trigger_Select_Register::setDI_CONVERT_Source_Polarity(nDI::tDI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x7fffffff) | ((u32(fieldValue) << 0x1f) & ~0x7fffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Polarity_t tDI::tDI_Trigger_Select_Register::getDI_CONVERT_Source_Polarity(nMDBG::tStatus2*) const
{
   return nDI::tDI_Polarity_t((_softCopy & ~0x7fffffff) >> 0x1f);
}

inline void tDI::tDI_Trigger_Select_Register::writeDI_CONVERT_Source_Polarity(nDI::tDI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI_CONVERT_Source_Polarity(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Polarity_t tDI::tDI_Trigger_Select_Register::readDI_CONVERT_Source_Polarity(nMDBG::tStatus2* s)
{
   return getDI_CONVERT_Source_Polarity(s);
}

inline tDI::tDI_FilterRegisterLo::tDI_FilterRegisterLo()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_FilterRegisterLo::tRegisterMap* tDI::tDI_FilterRegisterLo::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_FilterRegisterLo::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tDI_FilterRegisterLo::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_FilterRegisterLo::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_FilterRegisterLo::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDI::tDI_FilterRegisterLo::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tDI_FilterRegisterLo::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDI::tDI_FilterRegisterLo::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDI::tDI_FilterRegisterLo::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI0_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffc) | ((u32(fieldValue) << 0x0) & ~0xfffffffc);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI0_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffffffc) >> 0x0);
}

inline void tDI::tDI_FilterRegisterLo::writeDI0_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI0_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI0_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI0_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI1_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff3) | ((u32(fieldValue) << 0x2) & ~0xfffffff3);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI1_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffffff3) >> 0x2);
}

inline void tDI::tDI_FilterRegisterLo::writeDI1_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI1_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI1_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI1_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI2_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffcf) | ((u32(fieldValue) << 0x4) & ~0xffffffcf);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI2_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffffffcf) >> 0x4);
}

inline void tDI::tDI_FilterRegisterLo::writeDI2_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI2_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI2_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI2_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI3_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff3f) | ((u32(fieldValue) << 0x6) & ~0xffffff3f);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI3_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffffff3f) >> 0x6);
}

inline void tDI::tDI_FilterRegisterLo::writeDI3_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI3_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI3_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI3_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI4_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffcff) | ((u32(fieldValue) << 0x8) & ~0xfffffcff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI4_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffffcff) >> 0x8);
}

inline void tDI::tDI_FilterRegisterLo::writeDI4_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI4_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI4_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI4_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI5_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffff3ff) | ((u32(fieldValue) << 0xa) & ~0xfffff3ff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI5_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffff3ff) >> 0xa);
}

inline void tDI::tDI_FilterRegisterLo::writeDI5_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI5_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI5_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI5_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI6_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffcfff) | ((u32(fieldValue) << 0xc) & ~0xffffcfff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI6_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffffcfff) >> 0xc);
}

inline void tDI::tDI_FilterRegisterLo::writeDI6_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI6_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI6_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI6_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI7_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff3fff) | ((u32(fieldValue) << 0xe) & ~0xffff3fff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI7_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffff3fff) >> 0xe);
}

inline void tDI::tDI_FilterRegisterLo::writeDI7_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI7_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI7_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI7_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI8_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffcffff) | ((u32(fieldValue) << 0x10) & ~0xfffcffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI8_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffcffff) >> 0x10);
}

inline void tDI::tDI_FilterRegisterLo::writeDI8_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI8_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI8_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI8_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI9_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfff3ffff) | ((u32(fieldValue) << 0x12) & ~0xfff3ffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI9_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfff3ffff) >> 0x12);
}

inline void tDI::tDI_FilterRegisterLo::writeDI9_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI9_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI9_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI9_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI10_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffcfffff) | ((u32(fieldValue) << 0x14) & ~0xffcfffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI10_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffcfffff) >> 0x14);
}

inline void tDI::tDI_FilterRegisterLo::writeDI10_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI10_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI10_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI10_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI11_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff3fffff) | ((u32(fieldValue) << 0x16) & ~0xff3fffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI11_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xff3fffff) >> 0x16);
}

inline void tDI::tDI_FilterRegisterLo::writeDI11_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI11_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI11_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI11_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI12_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfcffffff) | ((u32(fieldValue) << 0x18) & ~0xfcffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI12_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfcffffff) >> 0x18);
}

inline void tDI::tDI_FilterRegisterLo::writeDI12_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI12_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI12_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI12_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI13_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf3ffffff) | ((u32(fieldValue) << 0x1a) & ~0xf3ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI13_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xf3ffffff) >> 0x1a);
}

inline void tDI::tDI_FilterRegisterLo::writeDI13_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI13_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI13_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI13_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI14_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xcfffffff) | ((u32(fieldValue) << 0x1c) & ~0xcfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI14_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xcfffffff) >> 0x1c);
}

inline void tDI::tDI_FilterRegisterLo::writeDI14_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI14_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI14_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI14_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterLo& tDI::tDI_FilterRegisterLo::setDI15_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x3fffffff) | ((u32(fieldValue) << 0x1e) & ~0x3fffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::getDI15_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0x3fffffff) >> 0x1e);
}

inline void tDI::tDI_FilterRegisterLo::writeDI15_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI15_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterLo::readDI15_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI15_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi::tDI_FilterRegisterHi()
{
   _softCopy = u32(0x0);
}

inline tDI::tDI_FilterRegisterHi::tRegisterMap* tDI::tDI_FilterRegisterHi::registerMap(void)
{
   return _regMap;
}

inline void tDI::tDI_FilterRegisterHi::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDI::tDI_FilterRegisterHi::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_FilterRegisterHi::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDI::tId)kId, s);
}

inline void tDI::tDI_FilterRegisterHi::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDI::tId)kId, s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDI::tDI_FilterRegisterHi::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDI::tDI_FilterRegisterHi::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDI::tDI_FilterRegisterHi::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDI::tDI_FilterRegisterHi::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI16_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffc) | ((u32(fieldValue) << 0x0) & ~0xfffffffc);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI16_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffffffc) >> 0x0);
}

inline void tDI::tDI_FilterRegisterHi::writeDI16_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI16_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI16_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI16_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI17_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff3) | ((u32(fieldValue) << 0x2) & ~0xfffffff3);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI17_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffffff3) >> 0x2);
}

inline void tDI::tDI_FilterRegisterHi::writeDI17_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI17_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI17_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI17_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI18_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffcf) | ((u32(fieldValue) << 0x4) & ~0xffffffcf);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI18_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffffffcf) >> 0x4);
}

inline void tDI::tDI_FilterRegisterHi::writeDI18_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI18_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI18_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI18_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI19_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff3f) | ((u32(fieldValue) << 0x6) & ~0xffffff3f);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI19_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffffff3f) >> 0x6);
}

inline void tDI::tDI_FilterRegisterHi::writeDI19_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI19_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI19_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI19_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI20_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffcff) | ((u32(fieldValue) << 0x8) & ~0xfffffcff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI20_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffffcff) >> 0x8);
}

inline void tDI::tDI_FilterRegisterHi::writeDI20_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI20_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI20_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI20_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI21_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffff3ff) | ((u32(fieldValue) << 0xa) & ~0xfffff3ff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI21_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffff3ff) >> 0xa);
}

inline void tDI::tDI_FilterRegisterHi::writeDI21_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI21_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI21_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI21_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI22_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffcfff) | ((u32(fieldValue) << 0xc) & ~0xffffcfff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI22_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffffcfff) >> 0xc);
}

inline void tDI::tDI_FilterRegisterHi::writeDI22_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI22_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI22_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI22_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI23_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff3fff) | ((u32(fieldValue) << 0xe) & ~0xffff3fff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI23_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffff3fff) >> 0xe);
}

inline void tDI::tDI_FilterRegisterHi::writeDI23_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI23_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI23_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI23_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI24_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffcffff) | ((u32(fieldValue) << 0x10) & ~0xfffcffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI24_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfffcffff) >> 0x10);
}

inline void tDI::tDI_FilterRegisterHi::writeDI24_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI24_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI24_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI24_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI25_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfff3ffff) | ((u32(fieldValue) << 0x12) & ~0xfff3ffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI25_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfff3ffff) >> 0x12);
}

inline void tDI::tDI_FilterRegisterHi::writeDI25_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI25_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI25_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI25_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI26_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffcfffff) | ((u32(fieldValue) << 0x14) & ~0xffcfffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI26_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xffcfffff) >> 0x14);
}

inline void tDI::tDI_FilterRegisterHi::writeDI26_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI26_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI26_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI26_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI27_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff3fffff) | ((u32(fieldValue) << 0x16) & ~0xff3fffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI27_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xff3fffff) >> 0x16);
}

inline void tDI::tDI_FilterRegisterHi::writeDI27_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI27_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI27_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI27_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI28_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfcffffff) | ((u32(fieldValue) << 0x18) & ~0xfcffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI28_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xfcffffff) >> 0x18);
}

inline void tDI::tDI_FilterRegisterHi::writeDI28_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI28_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI28_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI28_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI29_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf3ffffff) | ((u32(fieldValue) << 0x1a) & ~0xf3ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI29_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xf3ffffff) >> 0x1a);
}

inline void tDI::tDI_FilterRegisterHi::writeDI29_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI29_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI29_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI29_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI30_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xcfffffff) | ((u32(fieldValue) << 0x1c) & ~0xcfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI30_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0xcfffffff) >> 0x1c);
}

inline void tDI::tDI_FilterRegisterHi::writeDI30_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI30_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI30_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI30_Filter_Select(s);
}

inline tDI::tDI_FilterRegisterHi& tDI::tDI_FilterRegisterHi::setDI31_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x3fffffff) | ((u32(fieldValue) << 0x1e) & ~0x3fffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::getDI31_Filter_Select(nMDBG::tStatus2*) const
{
   return nDI::tDI_Filter_Select_t((_softCopy & ~0x3fffffff) >> 0x1e);
}

inline void tDI::tDI_FilterRegisterHi::writeDI31_Filter_Select(nDI::tDI_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDI31_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nDI::tDI_Filter_Select_t tDI::tDI_FilterRegisterHi::readDI31_Filter_Select(nMDBG::tStatus2* s)
{
   return getDI31_Filter_Select(s);
}

#endif


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