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

#ifndef ___tCounter_h___
#include "tCounter.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 tCounter::tReg16IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u16 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write16(offset, value);
}

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

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

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

inline tCounter::tGi_Command_Register::tRegisterMap* tCounter::tGi_Command_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Command_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_Command_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Command_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 &= u16(0x1d6a);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_Command_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Command_Register& tCounter::tGi_Command_Register::setGi_Arm(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 tCounter::tGi_Command_Register::getGi_Arm(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffe) >> 0x0);
}

inline void tCounter::tGi_Command_Register::writeGi_Arm(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Arm(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Command_Register::readGi_Arm(nMDBG::tStatus2* s)
{
   return getGi_Arm(s);
}

inline tCounter::tGi_Command_Register& tCounter::tGi_Command_Register::setGi_Load(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 tCounter::tGi_Command_Register::getGi_Load(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffb) >> 0x2);
}

inline void tCounter::tGi_Command_Register::writeGi_Load(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Load(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Command_Register::readGi_Load(nMDBG::tStatus2* s)
{
   return getGi_Load(s);
}

inline tCounter::tGi_Command_Register& tCounter::tGi_Command_Register::setGi_Disarm(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 tCounter::tGi_Command_Register::getGi_Disarm(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffef) >> 0x4);
}

inline void tCounter::tGi_Command_Register::writeGi_Disarm(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Disarm(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Command_Register::readGi_Disarm(nMDBG::tStatus2* s)
{
   return getGi_Disarm(s);
}

inline tCounter::tGi_Command_Register& tCounter::tGi_Command_Register::setGi_WrLoadRegsFromFifo(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 tCounter::tGi_Command_Register::getGi_WrLoadRegsFromFifo(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline void tCounter::tGi_Command_Register::writeGi_WrLoadRegsFromFifo(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_WrLoadRegsFromFifo(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Command_Register::readGi_WrLoadRegsFromFifo(nMDBG::tStatus2* s)
{
   return getGi_WrLoadRegsFromFifo(s);
}

inline tCounter::tGi_Command_Register& tCounter::tGi_Command_Register::setGi_Bank_Switch_Start(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 tCounter::tGi_Command_Register::getGi_Bank_Switch_Start(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfdff) >> 0x9);
}

inline void tCounter::tGi_Command_Register::writeGi_Bank_Switch_Start(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Bank_Switch_Start(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Command_Register::readGi_Bank_Switch_Start(nMDBG::tStatus2* s)
{
   return getGi_Bank_Switch_Start(s);
}

inline tCounter::tGi_Command_Register& tCounter::tGi_Command_Register::setGi_Arm_Paired_Counter(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 tCounter::tGi_Command_Register::getGi_Arm_Paired_Counter(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xdfff) >> 0xd);
}

inline void tCounter::tGi_Command_Register::writeGi_Arm_Paired_Counter(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Arm_Paired_Counter(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Command_Register::readGi_Arm_Paired_Counter(nMDBG::tStatus2* s)
{
   return getGi_Arm_Paired_Counter(s);
}

inline tCounter::tGi_Command_Register& tCounter::tGi_Command_Register::setGi_Reset(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 tCounter::tGi_Command_Register::getGi_Reset(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline void tCounter::tGi_Command_Register::writeGi_Reset(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Reset(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Command_Register::readGi_Reset(nMDBG::tStatus2* s)
{
   return getGi_Reset(s);
}

inline tCounter::tGi_Command_Register& tCounter::tGi_Command_Register::setGi_Disarm_Paired_Counter(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 tCounter::tGi_Command_Register::getGi_Disarm_Paired_Counter(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline void tCounter::tGi_Command_Register::writeGi_Disarm_Paired_Counter(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Disarm_Paired_Counter(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Command_Register::readGi_Disarm_Paired_Counter(nMDBG::tStatus2* s)
{
   return getGi_Disarm_Paired_Counter(s);
}

inline tCounter::tGi_Mode_Register::tGi_Mode_Register()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_Mode_Register::tRegisterMap* tCounter::tGi_Mode_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Mode_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_Mode_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_Mode_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Gating_Mode(nCounter::tGi_GatingMode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffc) | ((u16(fieldValue) << 0x0) & ~0xfffc);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_GatingMode_t tCounter::tGi_Mode_Register::getGi_Gating_Mode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_GatingMode_t((_softCopy & ~0xfffc) >> 0x0);
}

inline void tCounter::tGi_Mode_Register::writeGi_Gating_Mode(nCounter::tGi_GatingMode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Gating_Mode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_GatingMode_t tCounter::tGi_Mode_Register::readGi_Gating_Mode(nMDBG::tStatus2* s)
{
   return getGi_Gating_Mode(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Gate_On_Both_Edges(nCounter::tGi_Disabled_Enabled_t 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 nCounter::tGi_Disabled_Enabled_t tCounter::tGi_Mode_Register::getGi_Gate_On_Both_Edges(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Disabled_Enabled_t((_softCopy & ~0xfffb) >> 0x2);
}

inline void tCounter::tGi_Mode_Register::writeGi_Gate_On_Both_Edges(nCounter::tGi_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Gate_On_Both_Edges(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Disabled_Enabled_t tCounter::tGi_Mode_Register::readGi_Gate_On_Both_Edges(nMDBG::tStatus2* s)
{
   return getGi_Gate_On_Both_Edges(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Trigger_Mode_For_Edge_Gate(nCounter::tGi_Trigger_Mode_For_Edge_Gate_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffe7) | ((u16(fieldValue) << 0x3) & ~0xffe7);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Trigger_Mode_For_Edge_Gate_t tCounter::tGi_Mode_Register::getGi_Trigger_Mode_For_Edge_Gate(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Trigger_Mode_For_Edge_Gate_t((_softCopy & ~0xffe7) >> 0x3);
}

inline void tCounter::tGi_Mode_Register::writeGi_Trigger_Mode_For_Edge_Gate(nCounter::tGi_Trigger_Mode_For_Edge_Gate_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Trigger_Mode_For_Edge_Gate(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Trigger_Mode_For_Edge_Gate_t tCounter::tGi_Mode_Register::readGi_Trigger_Mode_For_Edge_Gate(nMDBG::tStatus2* s)
{
   return getGi_Trigger_Mode_For_Edge_Gate(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Stop_Mode(nCounter::tGi_Stop_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff9f) | ((u16(fieldValue) << 0x5) & ~0xff9f);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Stop_Mode_t tCounter::tGi_Mode_Register::getGi_Stop_Mode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Stop_Mode_t((_softCopy & ~0xff9f) >> 0x5);
}

inline void tCounter::tGi_Mode_Register::writeGi_Stop_Mode(nCounter::tGi_Stop_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Stop_Mode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Stop_Mode_t tCounter::tGi_Mode_Register::readGi_Stop_Mode(nMDBG::tStatus2* s)
{
   return getGi_Stop_Mode(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Load_Source_Select(nCounter::tGi_Load_Source_Select_t 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 nCounter::tGi_Load_Source_Select_t tCounter::tGi_Mode_Register::getGi_Load_Source_Select(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Load_Source_Select_t((_softCopy & ~0xff7f) >> 0x7);
}

inline void tCounter::tGi_Mode_Register::writeGi_Load_Source_Select(nCounter::tGi_Load_Source_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Load_Source_Select(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Load_Source_Select_t tCounter::tGi_Mode_Register::readGi_Load_Source_Select(nMDBG::tStatus2* s)
{
   return getGi_Load_Source_Select(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Output_Mode(nCounter::tGi_Output_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfcff) | ((u16(fieldValue) << 0x8) & ~0xfcff);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Output_Mode_t tCounter::tGi_Mode_Register::getGi_Output_Mode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Output_Mode_t((_softCopy & ~0xfcff) >> 0x8);
}

inline void tCounter::tGi_Mode_Register::writeGi_Output_Mode(nCounter::tGi_Output_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Output_Mode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Output_Mode_t tCounter::tGi_Mode_Register::readGi_Output_Mode(nMDBG::tStatus2* s)
{
   return getGi_Output_Mode(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Counting_Once(nCounter::tGi_Counting_Once_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf3ff) | ((u16(fieldValue) << 0xa) & ~0xf3ff);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Counting_Once_t tCounter::tGi_Mode_Register::getGi_Counting_Once(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Counting_Once_t((_softCopy & ~0xf3ff) >> 0xa);
}

inline void tCounter::tGi_Mode_Register::writeGi_Counting_Once(nCounter::tGi_Counting_Once_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Counting_Once(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Counting_Once_t tCounter::tGi_Mode_Register::readGi_Counting_Once(nMDBG::tStatus2* s)
{
   return getGi_Counting_Once(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Loading_On_TC(nCounter::tGi_Loading_On_TC_t 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 nCounter::tGi_Loading_On_TC_t tCounter::tGi_Mode_Register::getGi_Loading_On_TC(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Loading_On_TC_t((_softCopy & ~0xefff) >> 0xc);
}

inline void tCounter::tGi_Mode_Register::writeGi_Loading_On_TC(nCounter::tGi_Loading_On_TC_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Loading_On_TC(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Loading_On_TC_t tCounter::tGi_Mode_Register::readGi_Loading_On_TC(nMDBG::tStatus2* s)
{
   return getGi_Loading_On_TC(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_ForceSourceEqualToTimebase(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 tCounter::tGi_Mode_Register::getGi_ForceSourceEqualToTimebase(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xdfff) >> 0xd);
}

inline void tCounter::tGi_Mode_Register::writeGi_ForceSourceEqualToTimebase(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_ForceSourceEqualToTimebase(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Mode_Register::readGi_ForceSourceEqualToTimebase(nMDBG::tStatus2* s)
{
   return getGi_ForceSourceEqualToTimebase(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Loading_On_Gate(nCounter::tGi_Loading_On_Gate_t 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 nCounter::tGi_Loading_On_Gate_t tCounter::tGi_Mode_Register::getGi_Loading_On_Gate(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Loading_On_Gate_t((_softCopy & ~0xbfff) >> 0xe);
}

inline void tCounter::tGi_Mode_Register::writeGi_Loading_On_Gate(nCounter::tGi_Loading_On_Gate_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Loading_On_Gate(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Loading_On_Gate_t tCounter::tGi_Mode_Register::readGi_Loading_On_Gate(nMDBG::tStatus2* s)
{
   return getGi_Loading_On_Gate(s);
}

inline tCounter::tGi_Mode_Register& tCounter::tGi_Mode_Register::setGi_Reload_Source_Switching(nCounter::tGi_Reload_Source_Switching_t 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 nCounter::tGi_Reload_Source_Switching_t tCounter::tGi_Mode_Register::getGi_Reload_Source_Switching(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Reload_Source_Switching_t((_softCopy & ~0x7fff) >> 0xf);
}

inline void tCounter::tGi_Mode_Register::writeGi_Reload_Source_Switching(nCounter::tGi_Reload_Source_Switching_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Reload_Source_Switching(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Reload_Source_Switching_t tCounter::tGi_Mode_Register::readGi_Reload_Source_Switching(nMDBG::tStatus2* s)
{
   return getGi_Reload_Source_Switching(s);
}

inline tCounter::tGi_HW_Save_Register::tGi_HW_Save_Register()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_HW_Save_Register::tRegisterMap* tCounter::tGi_HW_Save_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_HW_Save_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tCounter::tGi_HW_Save_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tCounter::tGi_HW_Save_Register& tCounter::tGi_HW_Save_Register::setGi_HW_Save_Value(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 tCounter::tGi_HW_Save_Register::getGi_HW_Save_Value(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tCounter::tGi_HW_Save_Register::readGi_HW_Save_Value(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_HW_Save_Value(s);
}

inline tCounter::tGi_Load_A_Register::tGi_Load_A_Register()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_Load_A_Register::tRegisterMap* tCounter::tGi_Load_A_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Load_A_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tCounter::tGi_Load_A_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Load_A_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 tCounter::tGi_Load_A_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 tCounter::tGi_Load_A_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Load_A_Register& tCounter::tGi_Load_A_Register::setGi_Load_A(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 tCounter::tGi_Load_A_Register::getGi_Load_A(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tCounter::tGi_Load_A_Register::writeGi_Load_A(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Load_A(fieldValue, s);
   flush(s, force);
}
inline u32 tCounter::tGi_Load_A_Register::readGi_Load_A(nMDBG::tStatus2* s)
{
   return getGi_Load_A(s);
}

inline tCounter::tGi_Load_B_Register::tGi_Load_B_Register()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_Load_B_Register::tRegisterMap* tCounter::tGi_Load_B_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Load_B_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tCounter::tGi_Load_B_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Load_B_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 tCounter::tGi_Load_B_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 tCounter::tGi_Load_B_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Load_B_Register& tCounter::tGi_Load_B_Register::setGi_Load_B(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 tCounter::tGi_Load_B_Register::getGi_Load_B(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tCounter::tGi_Load_B_Register::writeGi_Load_B(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Load_B(fieldValue, s);
   flush(s, force);
}
inline u32 tCounter::tGi_Load_B_Register::readGi_Load_B(nMDBG::tStatus2* s)
{
   return getGi_Load_B(s);
}

inline tCounter::tGi_Save_Register::tGi_Save_Register()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_Save_Register::tRegisterMap* tCounter::tGi_Save_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Save_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tCounter::tGi_Save_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tCounter::tGi_Save_Register& tCounter::tGi_Save_Register::setGi_Save_Value(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 tCounter::tGi_Save_Register::getGi_Save_Value(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tCounter::tGi_Save_Register::readGi_Save_Value(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Save_Value(s);
}

inline tCounter::tGi_Input_Select_Register::tGi_Input_Select_Register()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_Input_Select_Register::tRegisterMap* tCounter::tGi_Input_Select_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Input_Select_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_Input_Select_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Input_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_Input_Select_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Input_Select_Register& tCounter::tGi_Input_Select_Register::setGi_Gate_Polarity(nCounter::tGi_Polarity_t 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 nCounter::tGi_Polarity_t tCounter::tGi_Input_Select_Register::getGi_Gate_Polarity(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Polarity_t((_softCopy & ~0xfffe) >> 0x0);
}

inline void tCounter::tGi_Input_Select_Register::writeGi_Gate_Polarity(nCounter::tGi_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Gate_Polarity(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Polarity_t tCounter::tGi_Input_Select_Register::readGi_Gate_Polarity(nMDBG::tStatus2* s)
{
   return getGi_Gate_Polarity(s);
}

inline tCounter::tGi_Input_Select_Register& tCounter::tGi_Input_Select_Register::setGi_Source_Select(nCounter::tGi_Source_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff81) | ((u16(fieldValue) << 0x1) & ~0xff81);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Source_Select_t tCounter::tGi_Input_Select_Register::getGi_Source_Select(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Source_Select_t((_softCopy & ~0xff81) >> 0x1);
}

inline void tCounter::tGi_Input_Select_Register::writeGi_Source_Select(nCounter::tGi_Source_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Source_Select(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Source_Select_t tCounter::tGi_Input_Select_Register::readGi_Source_Select(nMDBG::tStatus2* s)
{
   return getGi_Source_Select(s);
}

inline tCounter::tGi_Input_Select_Register& tCounter::tGi_Input_Select_Register::setGi_Gate_Select(nCounter::tGi_Gate_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xe07f) | ((u16(fieldValue) << 0x7) & ~0xe07f);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Gate_Select_t tCounter::tGi_Input_Select_Register::getGi_Gate_Select(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Gate_Select_t((_softCopy & ~0xe07f) >> 0x7);
}

inline void tCounter::tGi_Input_Select_Register::writeGi_Gate_Select(nCounter::tGi_Gate_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Gate_Select(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Gate_Select_t tCounter::tGi_Input_Select_Register::readGi_Gate_Select(nMDBG::tStatus2* s)
{
   return getGi_Gate_Select(s);
}

inline tCounter::tGi_Input_Select_Register& tCounter::tGi_Input_Select_Register::setGi_Gate_Select_Load_Source(nCounter::tGi_Disabled_Enabled_t 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 nCounter::tGi_Disabled_Enabled_t tCounter::tGi_Input_Select_Register::getGi_Gate_Select_Load_Source(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Disabled_Enabled_t((_softCopy & ~0xdfff) >> 0xd);
}

inline void tCounter::tGi_Input_Select_Register::writeGi_Gate_Select_Load_Source(nCounter::tGi_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Gate_Select_Load_Source(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Disabled_Enabled_t tCounter::tGi_Input_Select_Register::readGi_Gate_Select_Load_Source(nMDBG::tStatus2* s)
{
   return getGi_Gate_Select_Load_Source(s);
}

inline tCounter::tGi_Input_Select_Register& tCounter::tGi_Input_Select_Register::setGi_Output_Polarity(nCounter::tGi_Polarity_t 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 nCounter::tGi_Polarity_t tCounter::tGi_Input_Select_Register::getGi_Output_Polarity(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Polarity_t((_softCopy & ~0xbfff) >> 0xe);
}

inline void tCounter::tGi_Input_Select_Register::writeGi_Output_Polarity(nCounter::tGi_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Output_Polarity(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Polarity_t tCounter::tGi_Input_Select_Register::readGi_Output_Polarity(nMDBG::tStatus2* s)
{
   return getGi_Output_Polarity(s);
}

inline tCounter::tGi_Input_Select_Register& tCounter::tGi_Input_Select_Register::setGi_Source_Polarity(nCounter::tGi_Polarity_t 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 nCounter::tGi_Polarity_t tCounter::tGi_Input_Select_Register::getGi_Source_Polarity(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Polarity_t((_softCopy & ~0x7fff) >> 0xf);
}

inline void tCounter::tGi_Input_Select_Register::writeGi_Source_Polarity(nCounter::tGi_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Source_Polarity(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Polarity_t tCounter::tGi_Input_Select_Register::readGi_Source_Polarity(nMDBG::tStatus2* s)
{
   return getGi_Source_Polarity(s);
}

inline tCounter::tGi_Status_Register::tGi_Status_Register()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_Status_Register::tRegisterMap* tCounter::tGi_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tCounter::tGi_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_Output_St(nCounter::tGi_Output_St_t 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 nCounter::tGi_Output_St_t tCounter::tGi_Status_Register::getGi_Output_St(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Output_St_t((_softCopy & ~0xfffffffe) >> 0x0);
}

inline nCounter::tGi_Output_St_t tCounter::tGi_Status_Register::readGi_Output_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Output_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_Counting_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffb) | ((u32(fieldValue) << 0x2) & ~0xfffffffb);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_Counting_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffffffb) >> 0x2);
}

inline u32 tCounter::tGi_Status_Register::readGi_Counting_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Counting_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_Next_Load_Source_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffef) | ((u32(fieldValue) << 0x4) & ~0xffffffef);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_Next_Load_Source_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffffef) >> 0x4);
}

inline u32 tCounter::tGi_Status_Register::readGi_Next_Load_Source_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Next_Load_Source_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_Armed_St(nCounter::tGi_Armed_St_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffeff) | ((u32(fieldValue) << 0x8) & ~0xfffffeff);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Armed_St_t tCounter::tGi_Status_Register::getGi_Armed_St(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Armed_St_t((_softCopy & ~0xfffffeff) >> 0x8);
}

inline nCounter::tGi_Armed_St_t tCounter::tGi_Status_Register::readGi_Armed_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Armed_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_No_Load_Between_Gates_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffbff) | ((u32(fieldValue) << 0xa) & ~0xfffffbff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_No_Load_Between_Gates_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffffbff) >> 0xa);
}

inline u32 tCounter::tGi_Status_Register::readGi_No_Load_Between_Gates_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_No_Load_Between_Gates_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_DRQ_Error(u32 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 u32 tCounter::tGi_Status_Register::getGi_DRQ_Error(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffff7ff) >> 0xb);
}

inline u32 tCounter::tGi_Status_Register::readGi_DRQ_Error(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_DRQ_Error(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_TC_Error_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffefff) | ((u32(fieldValue) << 0xc) & ~0xffffefff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_TC_Error_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffefff) >> 0xc);
}

inline u32 tCounter::tGi_Status_Register::readGi_TC_Error_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_TC_Error_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_Gate_Error_St(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 tCounter::tGi_Status_Register::getGi_Gate_Error_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffbfff) >> 0xe);
}

inline u32 tCounter::tGi_Status_Register::readGi_Gate_Error_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Gate_Error_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_DRQ_St(u32 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 u32 tCounter::tGi_Status_Register::getGi_DRQ_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffff7fff) >> 0xf);
}

inline u32 tCounter::tGi_Status_Register::readGi_DRQ_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_DRQ_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_SampleClockOverrun_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffeffff) | ((u32(fieldValue) << 0x10) & ~0xfffeffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_SampleClockOverrun_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffeffff) >> 0x10);
}

inline u32 tCounter::tGi_Status_Register::readGi_SampleClockOverrun_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_SampleClockOverrun_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_SampleClockInterruptSt(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffdffff) | ((u32(fieldValue) << 0x11) & ~0xfffdffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_SampleClockInterruptSt(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffdffff) >> 0x11);
}

inline u32 tCounter::tGi_Status_Register::readGi_SampleClockInterruptSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_SampleClockInterruptSt(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_Bank_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffbffff) | ((u32(fieldValue) << 0x12) & ~0xfffbffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_Bank_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffbffff) >> 0x12);
}

inline u32 tCounter::tGi_Status_Register::readGi_Bank_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Bank_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_Gate_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffefffff) | ((u32(fieldValue) << 0x14) & ~0xffefffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_Gate_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffefffff) >> 0x14);
}

inline u32 tCounter::tGi_Status_Register::readGi_Gate_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Gate_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_Gate_Interrupt_St(u32 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 u32 tCounter::tGi_Status_Register::getGi_Gate_Interrupt_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xff7fffff) >> 0x17);
}

inline u32 tCounter::tGi_Status_Register::readGi_Gate_Interrupt_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_Gate_Interrupt_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_TC_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfeffffff) | ((u32(fieldValue) << 0x18) & ~0xfeffffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_TC_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfeffffff) >> 0x18);
}

inline u32 tCounter::tGi_Status_Register::readGi_TC_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_TC_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_GateSwitchError_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfdffffff) | ((u32(fieldValue) << 0x19) & ~0xfdffffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_GateSwitchError_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfdffffff) >> 0x19);
}

inline u32 tCounter::tGi_Status_Register::readGi_GateSwitchError_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_GateSwitchError_St(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_DisarmEventInterruptSt(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfbffffff) | ((u32(fieldValue) << 0x1a) & ~0xfbffffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_DisarmEventInterruptSt(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfbffffff) >> 0x1a);
}

inline u32 tCounter::tGi_Status_Register::readGi_DisarmEventInterruptSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_DisarmEventInterruptSt(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_ForcedWrFromFifoInProgSt(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf7ffffff) | ((u32(fieldValue) << 0x1b) & ~0xf7ffffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_ForcedWrFromFifoInProgSt(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xf7ffffff) >> 0x1b);
}

inline u32 tCounter::tGi_Status_Register::readGi_ForcedWrFromFifoInProgSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_ForcedWrFromFifoInProgSt(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_WritesTooFastErrorSt(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xefffffff) | ((u32(fieldValue) << 0x1c) & ~0xefffffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_WritesTooFastErrorSt(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xefffffff) >> 0x1c);
}

inline u32 tCounter::tGi_Status_Register::readGi_WritesTooFastErrorSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_WritesTooFastErrorSt(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_AuxTC_ErrorEventSt(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xdfffffff) | ((u32(fieldValue) << 0x1d) & ~0xdfffffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_AuxTC_ErrorEventSt(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xdfffffff) >> 0x1d);
}

inline u32 tCounter::tGi_Status_Register::readGi_AuxTC_ErrorEventSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_AuxTC_ErrorEventSt(s);
}

inline tCounter::tGi_Status_Register& tCounter::tGi_Status_Register::setGi_AuxTC_EventSt(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xbfffffff) | ((u32(fieldValue) << 0x1e) & ~0xbfffffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tCounter::tGi_Status_Register::getGi_AuxTC_EventSt(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xbfffffff) >> 0x1e);
}

inline u32 tCounter::tGi_Status_Register::readGi_AuxTC_EventSt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_AuxTC_EventSt(s);
}

inline tCounter::tGi_Autoincrement_Register::tGi_Autoincrement_Register()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_Autoincrement_Register::tRegisterMap* tCounter::tGi_Autoincrement_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Autoincrement_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_Autoincrement_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Autoincrement_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_Autoincrement_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u16 tCounter::tGi_Autoincrement_Register::getGi_Autoincrement(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff00) >> 0x0);
}

inline void tCounter::tGi_Autoincrement_Register::writeGi_Autoincrement(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Autoincrement(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Autoincrement_Register::readGi_Autoincrement(nMDBG::tStatus2* s)
{
   return getGi_Autoincrement(s);
}

inline tCounter::tGi_Counting_Mode_Register::tGi_Counting_Mode_Register()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_Counting_Mode_Register::tRegisterMap* tCounter::tGi_Counting_Mode_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Counting_Mode_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_Counting_Mode_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Counting_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_Counting_Mode_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Counting_Mode_Register& tCounter::tGi_Counting_Mode_Register::setGi_Counting_Mode(nCounter::tGi_CountingMode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_CountingMode_t tCounter::tGi_Counting_Mode_Register::getGi_Counting_Mode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_CountingMode_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tCounter::tGi_Counting_Mode_Register::writeGi_Counting_Mode(nCounter::tGi_CountingMode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Counting_Mode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_CountingMode_t tCounter::tGi_Counting_Mode_Register::readGi_Counting_Mode(nMDBG::tStatus2* s)
{
   return getGi_Counting_Mode(s);
}

inline tCounter::tGi_Counting_Mode_Register& tCounter::tGi_Counting_Mode_Register::setGi_HW_Arm_Polarity(nCounter::tGi_Polarity_t 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 nCounter::tGi_Polarity_t tCounter::tGi_Counting_Mode_Register::getGi_HW_Arm_Polarity(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Polarity_t((_softCopy & ~0xfff7) >> 0x3);
}

inline void tCounter::tGi_Counting_Mode_Register::writeGi_HW_Arm_Polarity(nCounter::tGi_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_HW_Arm_Polarity(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Polarity_t tCounter::tGi_Counting_Mode_Register::readGi_HW_Arm_Polarity(nMDBG::tStatus2* s)
{
   return getGi_HW_Arm_Polarity(s);
}

inline tCounter::tGi_Counting_Mode_Register& tCounter::tGi_Counting_Mode_Register::setGi_Index_Mode(nCounter::tGi_Index_Mode_t 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 nCounter::tGi_Index_Mode_t tCounter::tGi_Counting_Mode_Register::getGi_Index_Mode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Index_Mode_t((_softCopy & ~0xffef) >> 0x4);
}

inline void tCounter::tGi_Counting_Mode_Register::writeGi_Index_Mode(nCounter::tGi_Index_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Index_Mode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Index_Mode_t tCounter::tGi_Counting_Mode_Register::readGi_Index_Mode(nMDBG::tStatus2* s)
{
   return getGi_Index_Mode(s);
}

inline tCounter::tGi_Counting_Mode_Register& tCounter::tGi_Counting_Mode_Register::setGi_Index_Phase(nCounter::tGi_Index_Phase_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff9f) | ((u16(fieldValue) << 0x5) & ~0xff9f);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Index_Phase_t tCounter::tGi_Counting_Mode_Register::getGi_Index_Phase(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Index_Phase_t((_softCopy & ~0xff9f) >> 0x5);
}

inline void tCounter::tGi_Counting_Mode_Register::writeGi_Index_Phase(nCounter::tGi_Index_Phase_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Index_Phase(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Index_Phase_t tCounter::tGi_Counting_Mode_Register::readGi_Index_Phase(nMDBG::tStatus2* s)
{
   return getGi_Index_Phase(s);
}

inline tCounter::tGi_Counting_Mode_Register& tCounter::tGi_Counting_Mode_Register::setGi_HW_Arm_Enable(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 tCounter::tGi_Counting_Mode_Register::getGi_HW_Arm_Enable(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline void tCounter::tGi_Counting_Mode_Register::writeGi_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_HW_Arm_Enable(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Counting_Mode_Register::readGi_HW_Arm_Enable(nMDBG::tStatus2* s)
{
   return getGi_HW_Arm_Enable(s);
}

inline tCounter::tGi_Counting_Mode_Register& tCounter::tGi_Counting_Mode_Register::setGi_HW_Arm_Select(nCounter::tGi_HW_Arm_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xc0ff) | ((u16(fieldValue) << 0x8) & ~0xc0ff);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_HW_Arm_Select_t tCounter::tGi_Counting_Mode_Register::getGi_HW_Arm_Select(nMDBG::tStatus2*) const
{
   return nCounter::tGi_HW_Arm_Select_t((_softCopy & ~0xc0ff) >> 0x8);
}

inline void tCounter::tGi_Counting_Mode_Register::writeGi_HW_Arm_Select(nCounter::tGi_HW_Arm_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_HW_Arm_Select(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_HW_Arm_Select_t tCounter::tGi_Counting_Mode_Register::readGi_HW_Arm_Select(nMDBG::tStatus2* s)
{
   return getGi_HW_Arm_Select(s);
}

inline tCounter::tGi_Counting_Mode_Register& tCounter::tGi_Counting_Mode_Register::setGi_Prescale(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 tCounter::tGi_Counting_Mode_Register::getGi_Prescale(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline void tCounter::tGi_Counting_Mode_Register::writeGi_Prescale(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Prescale(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Counting_Mode_Register::readGi_Prescale(nMDBG::tStatus2* s)
{
   return getGi_Prescale(s);
}

inline tCounter::tGi_Counting_Mode_Register& tCounter::tGi_Counting_Mode_Register::setGi_Prescale_Div_2(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 tCounter::tGi_Counting_Mode_Register::getGi_Prescale_Div_2(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline void tCounter::tGi_Counting_Mode_Register::writeGi_Prescale_Div_2(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Prescale_Div_2(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Counting_Mode_Register::readGi_Prescale_Div_2(nMDBG::tStatus2* s)
{
   return getGi_Prescale_Div_2(s);
}

inline tCounter::tGi_FifoStatusRegister::tGi_FifoStatusRegister()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_FifoStatusRegister::tRegisterMap* tCounter::tGi_FifoStatusRegister::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_FifoStatusRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tCounter::tGi_FifoStatusRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tCounter::tGi_FifoStatusRegister& tCounter::tGi_FifoStatusRegister::setGi_FifoStatus(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 tCounter::tGi_FifoStatusRegister::getGi_FifoStatus(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tCounter::tGi_FifoStatusRegister::readGi_FifoStatus(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_FifoStatus(s);
}

inline tCounter::tGi_Second_Gate_Register::tGi_Second_Gate_Register()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_Second_Gate_Register::tRegisterMap* tCounter::tGi_Second_Gate_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Second_Gate_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_Second_Gate_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Second_Gate_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_Second_Gate_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Second_Gate_Register& tCounter::tGi_Second_Gate_Register::setGi_Second_Gate_Mode(nCounter::tGi_Second_Gate_Mode_t 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 nCounter::tGi_Second_Gate_Mode_t tCounter::tGi_Second_Gate_Register::getGi_Second_Gate_Mode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Second_Gate_Mode_t((_softCopy & ~0xfffe) >> 0x0);
}

inline void tCounter::tGi_Second_Gate_Register::writeGi_Second_Gate_Mode(nCounter::tGi_Second_Gate_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Second_Gate_Mode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Second_Gate_Mode_t tCounter::tGi_Second_Gate_Register::readGi_Second_Gate_Mode(nMDBG::tStatus2* s)
{
   return getGi_Second_Gate_Mode(s);
}

inline tCounter::tGi_Second_Gate_Register& tCounter::tGi_Second_Gate_Register::setGi_Second_Gate_Select(nCounter::tGi_Second_Gate_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xe07f) | ((u16(fieldValue) << 0x7) & ~0xe07f);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Second_Gate_Select_t tCounter::tGi_Second_Gate_Register::getGi_Second_Gate_Select(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Second_Gate_Select_t((_softCopy & ~0xe07f) >> 0x7);
}

inline void tCounter::tGi_Second_Gate_Register::writeGi_Second_Gate_Select(nCounter::tGi_Second_Gate_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Second_Gate_Select(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Second_Gate_Select_t tCounter::tGi_Second_Gate_Register::readGi_Second_Gate_Select(nMDBG::tStatus2* s)
{
   return getGi_Second_Gate_Select(s);
}

inline tCounter::tGi_Second_Gate_Register& tCounter::tGi_Second_Gate_Register::setGi_Second_Gate_Polarity(nCounter::tGi_Polarity_t 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 nCounter::tGi_Polarity_t tCounter::tGi_Second_Gate_Register::getGi_Second_Gate_Polarity(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Polarity_t((_softCopy & ~0xdfff) >> 0xd);
}

inline void tCounter::tGi_Second_Gate_Register::writeGi_Second_Gate_Polarity(nCounter::tGi_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Second_Gate_Polarity(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Polarity_t tCounter::tGi_Second_Gate_Register::readGi_Second_Gate_Polarity(nMDBG::tStatus2* s)
{
   return getGi_Second_Gate_Polarity(s);
}

inline tCounter::tGi_DMA_Config_Register::tGi_DMA_Config_Register()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_DMA_Config_Register::tRegisterMap* tCounter::tGi_DMA_Config_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_DMA_Config_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_DMA_Config_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_DMA_Config_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 &= u16(0xfff7);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_DMA_Config_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_DMA_Config_Register& tCounter::tGi_DMA_Config_Register::setGi_DMA_Enable(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 tCounter::tGi_DMA_Config_Register::getGi_DMA_Enable(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffe) >> 0x0);
}

inline void tCounter::tGi_DMA_Config_Register::writeGi_DMA_Enable(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_DMA_Enable(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_DMA_Config_Register::readGi_DMA_Enable(nMDBG::tStatus2* s)
{
   return getGi_DMA_Enable(s);
}

inline tCounter::tGi_DMA_Config_Register& tCounter::tGi_DMA_Config_Register::setGi_DMA_Write(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 tCounter::tGi_DMA_Config_Register::getGi_DMA_Write(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffd) >> 0x1);
}

inline void tCounter::tGi_DMA_Config_Register::writeGi_DMA_Write(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_DMA_Write(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_DMA_Config_Register::readGi_DMA_Write(nMDBG::tStatus2* s)
{
   return getGi_DMA_Write(s);
}

inline tCounter::tGi_DMA_Config_Register& tCounter::tGi_DMA_Config_Register::setGi_DMA_Reset(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 tCounter::tGi_DMA_Config_Register::getGi_DMA_Reset(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfff7) >> 0x3);
}

inline void tCounter::tGi_DMA_Config_Register::writeGi_DMA_Reset(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_DMA_Reset(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_DMA_Config_Register::readGi_DMA_Reset(nMDBG::tStatus2* s)
{
   return getGi_DMA_Reset(s);
}

inline tCounter::tGi_DMA_Config_Register& tCounter::tGi_DMA_Config_Register::setGi_WaitForFirstEventOnGate(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf3ff) | ((u16(fieldValue) << 0xa) & ~0xf3ff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tCounter::tGi_DMA_Config_Register::getGi_WaitForFirstEventOnGate(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf3ff) >> 0xa);
}

inline void tCounter::tGi_DMA_Config_Register::writeGi_WaitForFirstEventOnGate(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_WaitForFirstEventOnGate(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_DMA_Config_Register::readGi_WaitForFirstEventOnGate(nMDBG::tStatus2* s)
{
   return getGi_WaitForFirstEventOnGate(s);
}

inline tCounter::tGi_DMA_Config_Register& tCounter::tGi_DMA_Config_Register::setGi_WrFifoEnable(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 tCounter::tGi_DMA_Config_Register::getGi_WrFifoEnable(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xdfff) >> 0xd);
}

inline void tCounter::tGi_DMA_Config_Register::writeGi_WrFifoEnable(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_WrFifoEnable(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_DMA_Config_Register::readGi_WrFifoEnable(nMDBG::tStatus2* s)
{
   return getGi_WrFifoEnable(s);
}

inline tCounter::tGi_DMA_Config_Register& tCounter::tGi_DMA_Config_Register::setGi_DoneNotificationEnable(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 tCounter::tGi_DMA_Config_Register::getGi_DoneNotificationEnable(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline void tCounter::tGi_DMA_Config_Register::writeGi_DoneNotificationEnable(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_DoneNotificationEnable(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_DMA_Config_Register::readGi_DoneNotificationEnable(nMDBG::tStatus2* s)
{
   return getGi_DoneNotificationEnable(s);
}

inline tCounter::tGi_SampleClockCountRegister::tGi_SampleClockCountRegister()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_SampleClockCountRegister::tRegisterMap* tCounter::tGi_SampleClockCountRegister::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_SampleClockCountRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tCounter::tGi_SampleClockCountRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u32 tCounter::tGi_SampleClockCountRegister::getGi_SampleClockCount(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xff000000) >> 0x0);
}

inline u32 tCounter::tGi_SampleClockCountRegister::readGi_SampleClockCount(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_SampleClockCount(s);
}

inline tCounter::tGi_RdFifoRegister::tGi_RdFifoRegister()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_RdFifoRegister::tRegisterMap* tCounter::tGi_RdFifoRegister::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_RdFifoRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tCounter::tGi_RdFifoRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tCounter::tGi_RdFifoRegister& tCounter::tGi_RdFifoRegister::setGi_RdFifoData(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 tCounter::tGi_RdFifoRegister::getGi_RdFifoData(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tCounter::tGi_RdFifoRegister::readGi_RdFifoData(nMDBG::tStatus2* s)
{
   refresh(s);
   return getGi_RdFifoData(s);
}

inline tCounter::tGi_WrFifoRegister::tGi_WrFifoRegister()
{
}

inline tCounter::tGi_WrFifoRegister::tRegisterMap* tCounter::tGi_WrFifoRegister::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_WrFifoRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tCounter::tGi_WrFifoRegister::writeGi_WrFifoData(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0x0,s);
}
inline tCounter::tGi_SampleClockRegister::tGi_SampleClockRegister()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_SampleClockRegister::tRegisterMap* tCounter::tGi_SampleClockRegister::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_SampleClockRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_SampleClockRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_SampleClockRegister::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 &= u16(0xf7ff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_SampleClockRegister::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_SampleClockRegister& tCounter::tGi_SampleClockRegister::setGi_SampleClockSelect(nCounter::tGi_SampleClockSelect_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffc0) | ((u16(fieldValue) << 0x0) & ~0xffc0);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_SampleClockSelect_t tCounter::tGi_SampleClockRegister::getGi_SampleClockSelect(nMDBG::tStatus2*) const
{
   return nCounter::tGi_SampleClockSelect_t((_softCopy & ~0xffc0) >> 0x0);
}

inline void tCounter::tGi_SampleClockRegister::writeGi_SampleClockSelect(nCounter::tGi_SampleClockSelect_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_SampleClockSelect(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_SampleClockSelect_t tCounter::tGi_SampleClockRegister::readGi_SampleClockSelect(nMDBG::tStatus2* s)
{
   return getGi_SampleClockSelect(s);
}

inline tCounter::tGi_SampleClockRegister& tCounter::tGi_SampleClockRegister::setGi_SampleClockPolarity(nCounter::tGi_Polarity_t 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 nCounter::tGi_Polarity_t tCounter::tGi_SampleClockRegister::getGi_SampleClockPolarity(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Polarity_t((_softCopy & ~0xffbf) >> 0x6);
}

inline void tCounter::tGi_SampleClockRegister::writeGi_SampleClockPolarity(nCounter::tGi_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_SampleClockPolarity(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Polarity_t tCounter::tGi_SampleClockRegister::readGi_SampleClockPolarity(nMDBG::tStatus2* s)
{
   return getGi_SampleClockPolarity(s);
}

inline tCounter::tGi_SampleClockRegister& tCounter::tGi_SampleClockRegister::setGi_SampleClockLevelMode(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 tCounter::tGi_SampleClockRegister::getGi_SampleClockLevelMode(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline void tCounter::tGi_SampleClockRegister::writeGi_SampleClockLevelMode(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_SampleClockLevelMode(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_SampleClockRegister::readGi_SampleClockLevelMode(nMDBG::tStatus2* s)
{
   return getGi_SampleClockLevelMode(s);
}

inline tCounter::tGi_SampleClockRegister& tCounter::tGi_SampleClockRegister::setGi_SampleClockMode(nCounter::tGi_SampleClockMode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf8ff) | ((u16(fieldValue) << 0x8) & ~0xf8ff);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_SampleClockMode_t tCounter::tGi_SampleClockRegister::getGi_SampleClockMode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_SampleClockMode_t((_softCopy & ~0xf8ff) >> 0x8);
}

inline void tCounter::tGi_SampleClockRegister::writeGi_SampleClockMode(nCounter::tGi_SampleClockMode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_SampleClockMode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_SampleClockMode_t tCounter::tGi_SampleClockRegister::readGi_SampleClockMode(nMDBG::tStatus2* s)
{
   return getGi_SampleClockMode(s);
}

inline tCounter::tGi_SampleClockRegister& tCounter::tGi_SampleClockRegister::setGi_SampleClockPulse(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 tCounter::tGi_SampleClockRegister::getGi_SampleClockPulse(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tCounter::tGi_SampleClockRegister::writeGi_SampleClockPulse(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_SampleClockPulse(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_SampleClockRegister::readGi_SampleClockPulse(nMDBG::tStatus2* s)
{
   return getGi_SampleClockPulse(s);
}

inline tCounter::tGi_SampleClockRegister& tCounter::tGi_SampleClockRegister::setGi_SampleClockSampleMode(nCounter::tGi_SampleClkSampleMode_t 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 nCounter::tGi_SampleClkSampleMode_t tCounter::tGi_SampleClockRegister::getGi_SampleClockSampleMode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_SampleClkSampleMode_t((_softCopy & ~0xefff) >> 0xc);
}

inline void tCounter::tGi_SampleClockRegister::writeGi_SampleClockSampleMode(nCounter::tGi_SampleClkSampleMode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_SampleClockSampleMode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_SampleClkSampleMode_t tCounter::tGi_SampleClockRegister::readGi_SampleClockSampleMode(nMDBG::tStatus2* s)
{
   return getGi_SampleClockSampleMode(s);
}

inline tCounter::tGi_SampleClockRegister& tCounter::tGi_SampleClockRegister::setGi_SampleClockGateIndependent(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 tCounter::tGi_SampleClockRegister::getGi_SampleClockGateIndependent(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline void tCounter::tGi_SampleClockRegister::writeGi_SampleClockGateIndependent(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_SampleClockGateIndependent(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_SampleClockRegister::readGi_SampleClockGateIndependent(nMDBG::tStatus2* s)
{
   return getGi_SampleClockGateIndependent(s);
}

inline tCounter::tGi_AuxCtrRegister::tGi_AuxCtrRegister()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_AuxCtrRegister::tRegisterMap* tCounter::tGi_AuxCtrRegister::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_AuxCtrRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_AuxCtrRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_AuxCtrRegister::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 &= u16(0xfeff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_AuxCtrRegister::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_AuxCtrRegister& tCounter::tGi_AuxCtrRegister::setGi_AuxCtrMode(nCounter::tGi_AuxCtrMode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_AuxCtrMode_t tCounter::tGi_AuxCtrRegister::getGi_AuxCtrMode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_AuxCtrMode_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tCounter::tGi_AuxCtrRegister::writeGi_AuxCtrMode(nCounter::tGi_AuxCtrMode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_AuxCtrMode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_AuxCtrMode_t tCounter::tGi_AuxCtrRegister::readGi_AuxCtrMode(nMDBG::tStatus2* s)
{
   return getGi_AuxCtrMode(s);
}

inline tCounter::tGi_AuxCtrRegister& tCounter::tGi_AuxCtrRegister::setGi_AuxCtrLoad(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 tCounter::tGi_AuxCtrRegister::getGi_AuxCtrLoad(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfeff) >> 0x8);
}

inline void tCounter::tGi_AuxCtrRegister::writeGi_AuxCtrLoad(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_AuxCtrLoad(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_AuxCtrRegister::readGi_AuxCtrLoad(nMDBG::tStatus2* s)
{
   return getGi_AuxCtrLoad(s);
}

inline tCounter::tGi_AuxCtrLoadA_Register::tGi_AuxCtrLoadA_Register()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_AuxCtrLoadA_Register::tRegisterMap* tCounter::tGi_AuxCtrLoadA_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_AuxCtrLoadA_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tCounter::tGi_AuxCtrLoadA_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_AuxCtrLoadA_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 tCounter::tGi_AuxCtrLoadA_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 tCounter::tGi_AuxCtrLoadA_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_AuxCtrLoadA_Register& tCounter::tGi_AuxCtrLoadA_Register::setGi_AuxCtrLoadA(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 tCounter::tGi_AuxCtrLoadA_Register::getGi_AuxCtrLoadA(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tCounter::tGi_AuxCtrLoadA_Register::writeGi_AuxCtrLoadA(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_AuxCtrLoadA(fieldValue, s);
   flush(s, force);
}
inline u32 tCounter::tGi_AuxCtrLoadA_Register::readGi_AuxCtrLoadA(nMDBG::tStatus2* s)
{
   return getGi_AuxCtrLoadA(s);
}

inline tCounter::tGi_AuxCtrLoadB_Register::tGi_AuxCtrLoadB_Register()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_AuxCtrLoadB_Register::tRegisterMap* tCounter::tGi_AuxCtrLoadB_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_AuxCtrLoadB_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tCounter::tGi_AuxCtrLoadB_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_AuxCtrLoadB_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 tCounter::tGi_AuxCtrLoadB_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 tCounter::tGi_AuxCtrLoadB_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_AuxCtrLoadB_Register& tCounter::tGi_AuxCtrLoadB_Register::setGi_AuxCtrLoadB(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 tCounter::tGi_AuxCtrLoadB_Register::getGi_AuxCtrLoadB(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tCounter::tGi_AuxCtrLoadB_Register::writeGi_AuxCtrLoadB(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_AuxCtrLoadB(fieldValue, s);
   flush(s, force);
}
inline u32 tCounter::tGi_AuxCtrLoadB_Register::readGi_AuxCtrLoadB(nMDBG::tStatus2* s)
{
   return getGi_AuxCtrLoadB(s);
}

inline tCounter::tGi_AutomaticLoadRegister::tGi_AutomaticLoadRegister()
{
}

inline tCounter::tGi_AutomaticLoadRegister::tRegisterMap* tCounter::tGi_AutomaticLoadRegister::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_AutomaticLoadRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tCounter::tGi_AutomaticLoadRegister::writeGi_AutoLdRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0x0,s);
}
inline tCounter::tGi_Interrupt1_Register::tGi_Interrupt1_Register()
{
}

inline tCounter::tGi_Interrupt1_Register::tRegisterMap* tCounter::tGi_Interrupt1_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Interrupt1_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tCounter::tGi_Interrupt1_Register::writeGi_Aux_Ctr_TC_Error_Interrupt_En(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x3) & ~0xfffffff7,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Aux_Ctr_TC_Interrupt_En(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x4) & ~0xffffffef,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Disarm_Interrupt_En(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x5) & ~0xffffffdf,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_SampleClockInterruptEn(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x6) & ~0xffffffbf,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_GateSwitchErrorInt_En(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x7) & ~0xffffff7f,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_WritesTooFastErrorEn(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x8) & ~0xfffffeff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_DMA_Int_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x9) & ~0xfffffdff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Gate_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xa) & ~0xfffffbff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_TC_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xb) & ~0xfffff7ff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_SampleClockOverrunIntEn(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xc) & ~0xffffefff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Gate_Error_Interrupt_Enabled(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xd) & ~0xffffdfff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_TC_Error_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xe) & ~0xffffbfff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_DMA_Error_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xf) & ~0xffff7fff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_SampleClockOverrunErrorAck(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x13) & ~0xfff7ffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_SampleClockInterruptAck(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x14) & ~0xffefffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Gate_Error_Confirm(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x15) & ~0xffdfffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_TC_Error_Confirm(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x16) & ~0xffbfffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Aux_Ctr_TC_Error_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x18) & ~0xfeffffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Aux_Ctr_TC_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x19) & ~0xfdffffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Disarm_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1a) & ~0xfbffffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_WritesTooFastErrorAck(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1b) & ~0xf7ffffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_GateSwitchError_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1c) & ~0xefffffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_DMA_Error_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1d) & ~0xdfffffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_TC_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1e) & ~0xbfffffff,s);
}
inline void tCounter::tGi_Interrupt1_Register::writeGi_Gate_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1f) & ~0x7fffffff,s);
}
inline tCounter::tGi_Interrupt2_Register::tGi_Interrupt2_Register()
{
}

inline tCounter::tGi_Interrupt2_Register::tRegisterMap* tCounter::tGi_Interrupt2_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Interrupt2_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tCounter::tGi_Interrupt2_Register::writeGi_Aux_Ctr_TC_Error_Interrupt_Dis(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x3) & ~0xfffffff7,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Aux_Ctr_TC_Interrupt_Dis(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x4) & ~0xffffffef,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Disarm_Interrupt_Dis(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x5) & ~0xffffffdf,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_SampleClockInterruptDis(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x6) & ~0xffffffbf,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_GateSwitchErrorInt_Dis(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x7) & ~0xffffff7f,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_WritesTooFastErrorDis(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x8) & ~0xfffffeff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_DMA_Int_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x9) & ~0xfffffdff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Gate_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xa) & ~0xfffffbff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_TC_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xb) & ~0xfffff7ff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_SampleClockOverrunIntDis(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xc) & ~0xffffefff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Gate_Error_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xd) & ~0xffffdfff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_TC_Error_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xe) & ~0xffffbfff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_DMA_Error_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xf) & ~0xffff7fff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_SampleClockOverrunErrorAck2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x13) & ~0xfff7ffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_SampleClockInterruptAck2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x14) & ~0xffefffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Gate_Error_Confirm2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x15) & ~0xffdfffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_TC_Error_Confirm2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x16) & ~0xffbfffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Aux_Ctr_TC_Error_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x18) & ~0xfeffffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Aux_Ctr_TC_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x19) & ~0xfdffffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Disarm_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1a) & ~0xfbffffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_WritesTooFastErrorAck2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1b) & ~0xf7ffffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_GateSwitchError_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1c) & ~0xefffffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_DMA_Error_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1d) & ~0xdfffffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_TC_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1e) & ~0xbfffffff,s);
}
inline void tCounter::tGi_Interrupt2_Register::writeGi_Gate_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1f) & ~0x7fffffff,s);
}
inline tCounter::tGi_ABZ_Select_Register::tGi_ABZ_Select_Register()
{
   _softCopy = u32(0x0);
}

inline tCounter::tGi_ABZ_Select_Register::tRegisterMap* tCounter::tGi_ABZ_Select_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_ABZ_Select_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

inline tCounter::tGi_ABZ_Select_Register& tCounter::tGi_ABZ_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 tCounter::tGi_ABZ_Select_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_ABZ_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 tCounter::tGi_ABZ_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 tCounter::tGi_ABZ_Select_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_ABZ_Select_Register& tCounter::tGi_ABZ_Select_Register::setGi_Z_Select(nCounter::tGi_Z_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 nCounter::tGi_Z_Select_t tCounter::tGi_ABZ_Select_Register::getGi_Z_Select(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Z_Select_t((_softCopy & ~0xffffffc0) >> 0x0);
}

inline void tCounter::tGi_ABZ_Select_Register::writeGi_Z_Select(nCounter::tGi_Z_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Z_Select(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Z_Select_t tCounter::tGi_ABZ_Select_Register::readGi_Z_Select(nMDBG::tStatus2* s)
{
   return getGi_Z_Select(s);
}

inline tCounter::tGi_ABZ_Select_Register& tCounter::tGi_ABZ_Select_Register::setGi_B_Select(nCounter::tGi_B_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 nCounter::tGi_B_Select_t tCounter::tGi_ABZ_Select_Register::getGi_B_Select(nMDBG::tStatus2*) const
{
   return nCounter::tGi_B_Select_t((_softCopy & ~0xffffc0ff) >> 0x8);
}

inline void tCounter::tGi_ABZ_Select_Register::writeGi_B_Select(nCounter::tGi_B_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_B_Select(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_B_Select_t tCounter::tGi_ABZ_Select_Register::readGi_B_Select(nMDBG::tStatus2* s)
{
   return getGi_B_Select(s);
}

inline tCounter::tGi_ABZ_Select_Register& tCounter::tGi_ABZ_Select_Register::setGi_A_Select(nCounter::tGi_A_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 nCounter::tGi_A_Select_t tCounter::tGi_ABZ_Select_Register::getGi_A_Select(nMDBG::tStatus2*) const
{
   return nCounter::tGi_A_Select_t((_softCopy & ~0xffc0ffff) >> 0x10);
}

inline void tCounter::tGi_ABZ_Select_Register::writeGi_A_Select(nCounter::tGi_A_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_A_Select(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_A_Select_t tCounter::tGi_ABZ_Select_Register::readGi_A_Select(nMDBG::tStatus2* s)
{
   return getGi_A_Select(s);
}

inline tCounter::tGi_Mode3_Register::tGi_Mode3_Register()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_Mode3_Register::tRegisterMap* tCounter::tGi_Mode3_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Mode3_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_Mode3_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Mode3_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_Mode3_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Mode3_Register& tCounter::tGi_Mode3_Register::setGi_TimeCoherentSemiperiod(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 tCounter::tGi_Mode3_Register::getGi_TimeCoherentSemiperiod(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffb) >> 0x2);
}

inline void tCounter::tGi_Mode3_Register::writeGi_TimeCoherentSemiperiod(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_TimeCoherentSemiperiod(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Mode3_Register::readGi_TimeCoherentSemiperiod(nMDBG::tStatus2* s)
{
   return getGi_TimeCoherentSemiperiod(s);
}

inline tCounter::tGi_Mode2_Register::tGi_Mode2_Register()
{
   _softCopy = u16(0x0);
}

inline tCounter::tGi_Mode2_Register::tRegisterMap* tCounter::tGi_Mode2_Register::registerMap(void)
{
   return _regMap;
}

inline void tCounter::tGi_Mode2_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tCounter::tGi_Mode2_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tCounter::tGi_Mode2_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tCounter::tGi_Mode2_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tCounter::tGi_Mode2_Register& tCounter::tGi_Mode2_Register::setGi_HwArmSyncMode(nCounter::tGi_HwArmSyncMode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffc) | ((u16(fieldValue) << 0x0) & ~0xfffc);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_HwArmSyncMode_t tCounter::tGi_Mode2_Register::getGi_HwArmSyncMode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_HwArmSyncMode_t((_softCopy & ~0xfffc) >> 0x0);
}

inline void tCounter::tGi_Mode2_Register::writeGi_HwArmSyncMode(nCounter::tGi_HwArmSyncMode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_HwArmSyncMode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_HwArmSyncMode_t tCounter::tGi_Mode2_Register::readGi_HwArmSyncMode(nMDBG::tStatus2* s)
{
   return getGi_HwArmSyncMode(s);
}

inline tCounter::tGi_Mode2_Register& tCounter::tGi_Mode2_Register::setGi_CtrOutFifoRegenerationEn(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 tCounter::tGi_Mode2_Register::getGi_CtrOutFifoRegenerationEn(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffb) >> 0x2);
}

inline void tCounter::tGi_Mode2_Register::writeGi_CtrOutFifoRegenerationEn(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_CtrOutFifoRegenerationEn(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Mode2_Register::readGi_CtrOutFifoRegenerationEn(nMDBG::tStatus2* s)
{
   return getGi_CtrOutFifoRegenerationEn(s);
}

inline tCounter::tGi_Mode2_Register& tCounter::tGi_Mode2_Register::setGi_StopOnError(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 tCounter::tGi_Mode2_Register::getGi_StopOnError(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfff7) >> 0x3);
}

inline void tCounter::tGi_Mode2_Register::writeGi_StopOnError(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_StopOnError(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Mode2_Register::readGi_StopOnError(nMDBG::tStatus2* s)
{
   return getGi_StopOnError(s);
}

inline tCounter::tGi_Mode2_Register& tCounter::tGi_Mode2_Register::setGi_WriteOnSwitchRequest(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 tCounter::tGi_Mode2_Register::getGi_WriteOnSwitchRequest(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfeff) >> 0x8);
}

inline void tCounter::tGi_Mode2_Register::writeGi_WriteOnSwitchRequest(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_WriteOnSwitchRequest(fieldValue, s);
   flush(s, force);
}
inline u16 tCounter::tGi_Mode2_Register::readGi_WriteOnSwitchRequest(nMDBG::tStatus2* s)
{
   return getGi_WriteOnSwitchRequest(s);
}

inline tCounter::tGi_Mode2_Register& tCounter::tGi_Mode2_Register::setGi_Bank_Switch_Mode(nCounter::tGi_Bank_Switch_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf3ff) | ((u16(fieldValue) << 0xa) & ~0xf3ff);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Bank_Switch_Mode_t tCounter::tGi_Mode2_Register::getGi_Bank_Switch_Mode(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Bank_Switch_Mode_t((_softCopy & ~0xf3ff) >> 0xa);
}

inline void tCounter::tGi_Mode2_Register::writeGi_Bank_Switch_Mode(nCounter::tGi_Bank_Switch_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Bank_Switch_Mode(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Bank_Switch_Mode_t tCounter::tGi_Mode2_Register::readGi_Bank_Switch_Mode(nMDBG::tStatus2* s)
{
   return getGi_Bank_Switch_Mode(s);
}

inline tCounter::tGi_Mode2_Register& tCounter::tGi_Mode2_Register::setGi_Bank_Switch_Enable(nCounter::tGi_Bank_Switch_Enable_t 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 nCounter::tGi_Bank_Switch_Enable_t tCounter::tGi_Mode2_Register::getGi_Bank_Switch_Enable(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Bank_Switch_Enable_t((_softCopy & ~0xefff) >> 0xc);
}

inline void tCounter::tGi_Mode2_Register::writeGi_Bank_Switch_Enable(nCounter::tGi_Bank_Switch_Enable_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Bank_Switch_Enable(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Bank_Switch_Enable_t tCounter::tGi_Mode2_Register::readGi_Bank_Switch_Enable(nMDBG::tStatus2* s)
{
   return getGi_Bank_Switch_Enable(s);
}

inline tCounter::tGi_Mode2_Register& tCounter::tGi_Mode2_Register::setGi_Up_Down(nCounter::tGi_Up_Down_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x3fff) | ((u16(fieldValue) << 0xe) & ~0x3fff);
   setRegister(newValue, s);
   return *this;
}

inline nCounter::tGi_Up_Down_t tCounter::tGi_Mode2_Register::getGi_Up_Down(nMDBG::tStatus2*) const
{
   return nCounter::tGi_Up_Down_t((_softCopy & ~0x3fff) >> 0xe);
}

inline void tCounter::tGi_Mode2_Register::writeGi_Up_Down(nCounter::tGi_Up_Down_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGi_Up_Down(fieldValue, s);
   flush(s, force);
}
inline nCounter::tGi_Up_Down_t tCounter::tGi_Mode2_Register::readGi_Up_Down(nMDBG::tStatus2* s)
{
   return getGi_Up_Down(s);
}

#endif


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