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

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

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

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

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

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

inline tBrdServices::tGen_Interrupt1_Register::tRegisterMap* tBrdServices::tGen_Interrupt1_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tGen_Interrupt1_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline void tBrdServices::tGen_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 tBrdServices::tGen_Interrupt1_Register::writeWDT_TriggerIRQ_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0xfffffffe,s);
}
inline void tBrdServices::tGen_Interrupt1_Register::writePLL_OutOfLockIRQ_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1) & ~0xfffffffd,s);
}
inline void tBrdServices::tGen_Interrupt1_Register::writeWDT_TriggerIRQ_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x10) & ~0xfffeffff,s);
}
inline void tBrdServices::tGen_Interrupt1_Register::writePLL_OutOfLockIRQ_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x11) & ~0xfffdffff,s);
}
inline tBrdServices::tGen_Interrupt2_Register::tGen_Interrupt2_Register()
{
}

inline tBrdServices::tGen_Interrupt2_Register::tRegisterMap* tBrdServices::tGen_Interrupt2_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tGen_Interrupt2_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline void tBrdServices::tGen_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 tBrdServices::tGen_Interrupt2_Register::writeWDT_TriggerIRQ_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0xfffffffe,s);
}
inline void tBrdServices::tGen_Interrupt2_Register::writePLL_OutOfLockIRQ_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1) & ~0xfffffffd,s);
}
inline void tBrdServices::tGen_Interrupt2_Register::writeWDT_TriggerIRQ_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x10) & ~0xfffeffff,s);
}
inline void tBrdServices::tGen_Interrupt2_Register::writePLL_OutOfLockIRQ_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x11) & ~0xfffdffff,s);
}
inline tBrdServices::tScratchPadRegister::tScratchPadRegister()
{
   _softCopy = u32(0x0);
}

inline tBrdServices::tScratchPadRegister::tRegisterMap* tBrdServices::tScratchPadRegister::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tScratchPadRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tBrdServices::tScratchPadRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBrdServices::tScratchPadRegister::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 tBrdServices::tScratchPadRegister::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

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

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

inline tBrdServices::tScratchPadRegister& tBrdServices::tScratchPadRegister::setScratch_Pad(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 tBrdServices::tScratchPadRegister::getScratch_Pad(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tBrdServices::tScratchPadRegister::writeScratch_Pad(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setScratch_Pad(fieldValue, s);
   flush(s, force);
}
inline u32 tBrdServices::tScratchPadRegister::readScratch_Pad(nMDBG::tStatus2* s)
{
   refresh(s);
   return getScratch_Pad(s);
}

inline tBrdServices::tSignature_Register::tSignature_Register()
{
   _softCopy = u32(0x0);
}

inline tBrdServices::tSignature_Register::tRegisterMap* tBrdServices::tSignature_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tSignature_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tBrdServices::tSignature_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tBrdServices::tSignature_Register& tBrdServices::tSignature_Register::setSTC3_Revision(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 tBrdServices::tSignature_Register::getSTC3_Revision(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tBrdServices::tSignature_Register::readSTC3_Revision(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSTC3_Revision(s);
}

inline tBrdServices::tJoint_Reset_Register::tJoint_Reset_Register()
{
}

inline tBrdServices::tJoint_Reset_Register::tRegisterMap* tBrdServices::tJoint_Reset_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tJoint_Reset_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tBrdServices::tJoint_Reset_Register::writeSoftware_Reset(u16 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u16(fieldValue) << 0x0) & ~0xfffe,s);
}
inline tBrdServices::tTimeSincePowerUpRegister::tTimeSincePowerUpRegister()
{
   _softCopy = u32(0x0);
}

inline tBrdServices::tTimeSincePowerUpRegister::tRegisterMap* tBrdServices::tTimeSincePowerUpRegister::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tTimeSincePowerUpRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tBrdServices::tTimeSincePowerUpRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tBrdServices::tTimeSincePowerUpRegister& tBrdServices::tTimeSincePowerUpRegister::setTimeSincePowerUpValue(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 tBrdServices::tTimeSincePowerUpRegister::getTimeSincePowerUpValue(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tBrdServices::tTimeSincePowerUpRegister::readTimeSincePowerUpValue(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTimeSincePowerUpValue(s);
}

inline tBrdServices::tGenPwmPageSpec_i::tGenPwmPageSpec_i(u32 offset, u32 id)
 : kOffset(offset),
   kId(id)
{
   _softCopy = u8(0x0);
}

inline tBrdServices::tGenPwmPageSpec_i::tGenPwmPageSpec_i()
 : kOffset((u32)~0),
   kId((u32)~0)
{
   _softCopy = u8(0x0);
}

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

inline tBrdServices::tGenPwmPageSpec_i::tRegisterMap* tBrdServices::tGenPwmPageSpec_i::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tGenPwmPageSpec_i::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u8 tBrdServices::tGenPwmPageSpec_i::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline u8 tBrdServices::tGenPwmPageSpec_i::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u8 tBrdServices::tGenPwmPageSpec_i::getGenPwmNumPagesSpec_i(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0x0) >> 0x0);
}

inline void tBrdServices::tGenPwmPageSpec_i::writeGenPwmNumPagesSpec_i(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGenPwmNumPagesSpec_i(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tGenPwmPageSpec_i::readGenPwmNumPagesSpec_i(nMDBG::tStatus2* s)
{
   return getGenPwmNumPagesSpec_i(s);
}

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

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

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

inline tBrdServices::tGen_PWM_i::tRegisterMap* tBrdServices::tGen_PWM_i::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tGen_PWM_i::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tBrdServices::tGen_PWM_i::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBrdServices::tGen_PWM_i::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 tBrdServices::tGen_PWM_i::writeRegister(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u16 tBrdServices::tGen_PWM_i::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u16 tBrdServices::tGen_PWM_i::getGen_PWM_i_Duty_Cycle(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x0) >> 0x0);
}

inline void tBrdServices::tGen_PWM_i::writeGen_PWM_i_Duty_Cycle(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setGen_PWM_i_Duty_Cycle(fieldValue, s);
   flush(s, force);
}
inline u16 tBrdServices::tGen_PWM_i::readGen_PWM_i_Duty_Cycle(nMDBG::tStatus2* s)
{
   return getGen_PWM_i_Duty_Cycle(s);
}

inline tBrdServices::tSCXI_Serial_Data_In_Register::tSCXI_Serial_Data_In_Register()
{
   _softCopy = u8(0x0);
}

inline tBrdServices::tSCXI_Serial_Data_In_Register::tRegisterMap* tBrdServices::tSCXI_Serial_Data_In_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tSCXI_Serial_Data_In_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u8 tBrdServices::tSCXI_Serial_Data_In_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u8 tBrdServices::tSCXI_Serial_Data_In_Register::getSCXI_Data_In(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0x0) >> 0x0);
}

inline u8 tBrdServices::tSCXI_Serial_Data_In_Register::readSCXI_Data_In(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Data_In(s);
}

inline tBrdServices::tSCXI_Serial_Data_Out_Register::tSCXI_Serial_Data_Out_Register()
{
}

inline tBrdServices::tSCXI_Serial_Data_Out_Register::tRegisterMap* tBrdServices::tSCXI_Serial_Data_Out_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tSCXI_Serial_Data_Out_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tBrdServices::tSCXI_Serial_Data_Out_Register::writeSCXI_Data_Out(u8 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u8(fieldValue) << 0x0) & ~0x0,s);
}
inline tBrdServices::tSCXI_Control_Register::tSCXI_Control_Register()
{
   _softCopy = u8(0x0);
}

inline tBrdServices::tSCXI_Control_Register::tRegisterMap* tBrdServices::tSCXI_Control_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tSCXI_Control_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u8 tBrdServices::tSCXI_Control_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

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

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

inline u8 tBrdServices::tSCXI_Control_Register::getSCXI_SW_SPIClk(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfe) >> 0x0);
}

inline void tBrdServices::tSCXI_Control_Register::writeSCXI_SW_SPIClk(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_SW_SPIClk(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Control_Register::readSCXI_SW_SPIClk(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_SW_SPIClk(s);
}

inline tBrdServices::tSCXI_Control_Register& tBrdServices::tSCXI_Control_Register::setSCXI_Back_Plane_MISO_Enable(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xfd) | ((u8(fieldValue) << 0x1) & ~0xfd);
   setRegister(newValue, s);
   return *this;
}

inline u8 tBrdServices::tSCXI_Control_Register::getSCXI_Back_Plane_MISO_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfd) >> 0x1);
}

inline void tBrdServices::tSCXI_Control_Register::writeSCXI_Back_Plane_MISO_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_Back_Plane_MISO_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Control_Register::readSCXI_Back_Plane_MISO_Enable(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Back_Plane_MISO_Enable(s);
}

inline tBrdServices::tSCXI_Control_Register& tBrdServices::tSCXI_Control_Register::setSCXI_Front_Panel_MISO_Enable(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xfb) | ((u8(fieldValue) << 0x2) & ~0xfb);
   setRegister(newValue, s);
   return *this;
}

inline u8 tBrdServices::tSCXI_Control_Register::getSCXI_Front_Panel_MISO_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfb) >> 0x2);
}

inline void tBrdServices::tSCXI_Control_Register::writeSCXI_Front_Panel_MISO_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_Front_Panel_MISO_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Control_Register::readSCXI_Front_Panel_MISO_Enable(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Front_Panel_MISO_Enable(s);
}

inline tBrdServices::tSCXI_Control_Register& tBrdServices::tSCXI_Control_Register::setSCXI_Intr(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xf7) | ((u8(fieldValue) << 0x3) & ~0xf7);
   setRegister(newValue, s);
   return *this;
}

inline u8 tBrdServices::tSCXI_Control_Register::getSCXI_Intr(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xf7) >> 0x3);
}

inline void tBrdServices::tSCXI_Control_Register::writeSCXI_Intr(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_Intr(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Control_Register::readSCXI_Intr(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Intr(s);
}

inline tBrdServices::tSCXI_Control_Register& tBrdServices::tSCXI_Control_Register::setSCXI_D_A(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xef) | ((u8(fieldValue) << 0x4) & ~0xef);
   setRegister(newValue, s);
   return *this;
}

inline u8 tBrdServices::tSCXI_Control_Register::getSCXI_D_A(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xef) >> 0x4);
}

inline void tBrdServices::tSCXI_Control_Register::writeSCXI_D_A(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_D_A(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Control_Register::readSCXI_D_A(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_D_A(s);
}

inline tBrdServices::tSCXI_Control_Register& tBrdServices::tSCXI_Control_Register::setSCXI_HW_Serial_Timebase(nBrdServices::tBrdSrv_SCXI_HW_Serial_Timebase_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xdf) | ((u8(fieldValue) << 0x5) & ~0xdf);
   setRegister(newValue, s);
   return *this;
}

inline nBrdServices::tBrdSrv_SCXI_HW_Serial_Timebase_t tBrdServices::tSCXI_Control_Register::getSCXI_HW_Serial_Timebase(nMDBG::tStatus2*) const
{
   return nBrdServices::tBrdSrv_SCXI_HW_Serial_Timebase_t((_softCopy & ~0xdf) >> 0x5);
}

inline void tBrdServices::tSCXI_Control_Register::writeSCXI_HW_Serial_Timebase(nBrdServices::tBrdSrv_SCXI_HW_Serial_Timebase_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_HW_Serial_Timebase(fieldValue, s);
   flush(s, force);
}
inline nBrdServices::tBrdSrv_SCXI_HW_Serial_Timebase_t tBrdServices::tSCXI_Control_Register::readSCXI_HW_Serial_Timebase(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_HW_Serial_Timebase(s);
}

inline tBrdServices::tSCXI_Control_Register& tBrdServices::tSCXI_Control_Register::setSCXI_HW_Serial_Start(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xbf) | ((u8(fieldValue) << 0x6) & ~0xbf);
   setRegister(newValue, s);
   return *this;
}

inline u8 tBrdServices::tSCXI_Control_Register::getSCXI_HW_Serial_Start(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xbf) >> 0x6);
}

inline void tBrdServices::tSCXI_Control_Register::writeSCXI_HW_Serial_Start(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_HW_Serial_Start(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Control_Register::readSCXI_HW_Serial_Start(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_HW_Serial_Start(s);
}

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

inline u8 tBrdServices::tSCXI_Control_Register::getSCXI_HW_Serial_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0x7f) >> 0x7);
}

inline void tBrdServices::tSCXI_Control_Register::writeSCXI_HW_Serial_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_HW_Serial_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Control_Register::readSCXI_HW_Serial_Enable(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_HW_Serial_Enable(s);
}

inline tBrdServices::tSCXI_Output_Enable_Register::tSCXI_Output_Enable_Register()
{
   _softCopy = u8(0x0);
}

inline tBrdServices::tSCXI_Output_Enable_Register::tRegisterMap* tBrdServices::tSCXI_Output_Enable_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tSCXI_Output_Enable_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u8 tBrdServices::tSCXI_Output_Enable_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

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

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

inline u8 tBrdServices::tSCXI_Output_Enable_Register::getSCXI_Dedicated_Output_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfe) >> 0x0);
}

inline void tBrdServices::tSCXI_Output_Enable_Register::writeSCXI_Dedicated_Output_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_Dedicated_Output_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Output_Enable_Register::readSCXI_Dedicated_Output_Enable(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Dedicated_Output_Enable(s);
}

inline tBrdServices::tSCXI_Output_Enable_Register& tBrdServices::tSCXI_Output_Enable_Register::setSCXI_Trig1_Output_Enable(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xfd) | ((u8(fieldValue) << 0x1) & ~0xfd);
   setRegister(newValue, s);
   return *this;
}

inline u8 tBrdServices::tSCXI_Output_Enable_Register::getSCXI_Trig1_Output_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfd) >> 0x1);
}

inline void tBrdServices::tSCXI_Output_Enable_Register::writeSCXI_Trig1_Output_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_Trig1_Output_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Output_Enable_Register::readSCXI_Trig1_Output_Enable(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Trig1_Output_Enable(s);
}

inline tBrdServices::tSCXI_Output_Enable_Register& tBrdServices::tSCXI_Output_Enable_Register::setSCXI_Trig0_Output_Enable(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xfb) | ((u8(fieldValue) << 0x2) & ~0xfb);
   setRegister(newValue, s);
   return *this;
}

inline u8 tBrdServices::tSCXI_Output_Enable_Register::getSCXI_Trig0_Output_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfb) >> 0x2);
}

inline void tBrdServices::tSCXI_Output_Enable_Register::writeSCXI_Trig0_Output_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_Trig0_Output_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tBrdServices::tSCXI_Output_Enable_Register::readSCXI_Trig0_Output_Enable(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Trig0_Output_Enable(s);
}

inline tBrdServices::tSCXI_Output_Enable_Register& tBrdServices::tSCXI_Output_Enable_Register::setSCXI_Trig1_Output_Select(nBrdServices::tBrdSrv_SCXI_Trig1_Output_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0x7) | ((u8(fieldValue) << 0x3) & ~0x7);
   setRegister(newValue, s);
   return *this;
}

inline nBrdServices::tBrdSrv_SCXI_Trig1_Output_Select_t tBrdServices::tSCXI_Output_Enable_Register::getSCXI_Trig1_Output_Select(nMDBG::tStatus2*) const
{
   return nBrdServices::tBrdSrv_SCXI_Trig1_Output_Select_t((_softCopy & ~0x7) >> 0x3);
}

inline void tBrdServices::tSCXI_Output_Enable_Register::writeSCXI_Trig1_Output_Select(nBrdServices::tBrdSrv_SCXI_Trig1_Output_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_Trig1_Output_Select(fieldValue, s);
   flush(s, force);
}
inline nBrdServices::tBrdSrv_SCXI_Trig1_Output_Select_t tBrdServices::tSCXI_Output_Enable_Register::readSCXI_Trig1_Output_Select(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Trig1_Output_Select(s);
}

inline tBrdServices::tSCXI_Status_Register::tSCXI_Status_Register()
{
   _softCopy = u8(0x0);
}

inline tBrdServices::tSCXI_Status_Register::tRegisterMap* tBrdServices::tSCXI_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tSCXI_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u8 tBrdServices::tSCXI_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u8 tBrdServices::tSCXI_Status_Register::getSCXI_Shift_In_Prog(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfe) >> 0x0);
}

inline u8 tBrdServices::tSCXI_Status_Register::readSCXI_Shift_In_Prog(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSCXI_Shift_In_Prog(s);
}

inline tBrdServices::tSCXI_Mux_Clock_Register::tSCXI_Mux_Clock_Register()
{
   _softCopy = u8(0x0);
}

inline tBrdServices::tSCXI_Mux_Clock_Register::tRegisterMap* tBrdServices::tSCXI_Mux_Clock_Register::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tSCXI_Mux_Clock_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u8 tBrdServices::tSCXI_Mux_Clock_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline u8 tBrdServices::tSCXI_Mux_Clock_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tBrdServices::tSCXI_Mux_Clock_Register& tBrdServices::tSCXI_Mux_Clock_Register::setSCXI_Force_AI_EXTMUX_CLK_Width(nBrdServices::tBrdSrv_SCXI_Force_AI_EXTMUX_CLK_Width_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xfe) | ((u8(fieldValue) << 0x0) & ~0xfe);
   setRegister(newValue, s);
   return *this;
}

inline nBrdServices::tBrdSrv_SCXI_Force_AI_EXTMUX_CLK_Width_t tBrdServices::tSCXI_Mux_Clock_Register::getSCXI_Force_AI_EXTMUX_CLK_Width(nMDBG::tStatus2*) const
{
   return nBrdServices::tBrdSrv_SCXI_Force_AI_EXTMUX_CLK_Width_t((_softCopy & ~0xfe) >> 0x0);
}

inline void tBrdServices::tSCXI_Mux_Clock_Register::writeSCXI_Force_AI_EXTMUX_CLK_Width(nBrdServices::tBrdSrv_SCXI_Force_AI_EXTMUX_CLK_Width_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_Force_AI_EXTMUX_CLK_Width(fieldValue, s);
   flush(s, force);
}
inline nBrdServices::tBrdSrv_SCXI_Force_AI_EXTMUX_CLK_Width_t tBrdServices::tSCXI_Mux_Clock_Register::readSCXI_Force_AI_EXTMUX_CLK_Width(nMDBG::tStatus2* s)
{
   return getSCXI_Force_AI_EXTMUX_CLK_Width(s);
}

inline tBrdServices::tWatchdogStatusRegister::tWatchdogStatusRegister()
{
   _softCopy = u32(0x0);
}

inline tBrdServices::tWatchdogStatusRegister::tRegisterMap* tBrdServices::tWatchdogStatusRegister::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tWatchdogStatusRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tBrdServices::tWatchdogStatusRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tBrdServices::tWatchdogStatusRegister& tBrdServices::tWatchdogStatusRegister::setWatchdogSM_State(nBrdServices::tBrdSrv_WatchdogTimerStateMachineSt_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff8) | ((u32(fieldValue) << 0x0) & ~0xfffffff8);
   setRegister(newValue, s);
   return *this;
}

inline nBrdServices::tBrdSrv_WatchdogTimerStateMachineSt_t tBrdServices::tWatchdogStatusRegister::getWatchdogSM_State(nMDBG::tStatus2*) const
{
   return nBrdServices::tBrdSrv_WatchdogTimerStateMachineSt_t((_softCopy & ~0xfffffff8) >> 0x0);
}

inline nBrdServices::tBrdSrv_WatchdogTimerStateMachineSt_t tBrdServices::tWatchdogStatusRegister::readWatchdogSM_State(nMDBG::tStatus2* s)
{
   refresh(s);
   return getWatchdogSM_State(s);
}

inline tBrdServices::tWatchdogStatusRegister& tBrdServices::tWatchdogStatusRegister::setWatchdogExpiredCnt(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff00ff) | ((u32(fieldValue) << 0x8) & ~0xffff00ff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tBrdServices::tWatchdogStatusRegister::getWatchdogExpiredCnt(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffff00ff) >> 0x8);
}

inline u32 tBrdServices::tWatchdogStatusRegister::readWatchdogExpiredCnt(nMDBG::tStatus2* s)
{
   refresh(s);
   return getWatchdogExpiredCnt(s);
}

inline tBrdServices::tWatchdogTimeoutRegister::tWatchdogTimeoutRegister()
{
   _softCopy = u32(0x0);
}

inline tBrdServices::tWatchdogTimeoutRegister::tRegisterMap* tBrdServices::tWatchdogTimeoutRegister::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tWatchdogTimeoutRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tBrdServices::tWatchdogTimeoutRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBrdServices::tWatchdogTimeoutRegister::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 tBrdServices::tWatchdogTimeoutRegister::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tBrdServices::tWatchdogTimeoutRegister::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tBrdServices::tWatchdogTimeoutRegister& tBrdServices::tWatchdogTimeoutRegister::setWatchdogTimeoutValue(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 tBrdServices::tWatchdogTimeoutRegister::getWatchdogTimeoutValue(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tBrdServices::tWatchdogTimeoutRegister::writeWatchdogTimeoutValue(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setWatchdogTimeoutValue(fieldValue, s);
   flush(s, force);
}
inline u32 tBrdServices::tWatchdogTimeoutRegister::readWatchdogTimeoutValue(nMDBG::tStatus2* s)
{
   return getWatchdogTimeoutValue(s);
}

inline tBrdServices::tWatchdogConfiguration::tWatchdogConfiguration()
{
   _softCopy = u16(0x0);
}

inline tBrdServices::tWatchdogConfiguration::tRegisterMap* tBrdServices::tWatchdogConfiguration::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tWatchdogConfiguration::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tBrdServices::tWatchdogConfiguration::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tBrdServices::tWatchdogConfiguration::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 tBrdServices::tWatchdogConfiguration::writeRegister(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u16 tBrdServices::tWatchdogConfiguration::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tBrdServices::tWatchdogConfiguration& tBrdServices::tWatchdogConfiguration::setWatchdogExtTrigSel(nBrdServices::tBrdSrv_WatchdogTimerExtSrcSel_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 nBrdServices::tBrdSrv_WatchdogTimerExtSrcSel_t tBrdServices::tWatchdogConfiguration::getWatchdogExtTrigSel(nMDBG::tStatus2*) const
{
   return nBrdServices::tBrdSrv_WatchdogTimerExtSrcSel_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tBrdServices::tWatchdogConfiguration::writeWatchdogExtTrigSel(nBrdServices::tBrdSrv_WatchdogTimerExtSrcSel_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setWatchdogExtTrigSel(fieldValue, s);
   flush(s, force);
}
inline nBrdServices::tBrdSrv_WatchdogTimerExtSrcSel_t tBrdServices::tWatchdogConfiguration::readWatchdogExtTrigSel(nMDBG::tStatus2* s)
{
   return getWatchdogExtTrigSel(s);
}

inline tBrdServices::tWatchdogConfiguration& tBrdServices::tWatchdogConfiguration::setWatchdogExtTrigPol(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 tBrdServices::tWatchdogConfiguration::getWatchdogExtTrigPol(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline void tBrdServices::tWatchdogConfiguration::writeWatchdogExtTrigPol(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setWatchdogExtTrigPol(fieldValue, s);
   flush(s, force);
}
inline u16 tBrdServices::tWatchdogConfiguration::readWatchdogExtTrigPol(nMDBG::tStatus2* s)
{
   return getWatchdogExtTrigPol(s);
}

inline tBrdServices::tWatchdogConfiguration& tBrdServices::tWatchdogConfiguration::setWatchdogExtTrigEn(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 tBrdServices::tWatchdogConfiguration::getWatchdogExtTrigEn(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfeff) >> 0x8);
}

inline void tBrdServices::tWatchdogConfiguration::writeWatchdogExtTrigEn(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setWatchdogExtTrigEn(fieldValue, s);
   flush(s, force);
}
inline u16 tBrdServices::tWatchdogConfiguration::readWatchdogExtTrigEn(nMDBG::tStatus2* s)
{
   return getWatchdogExtTrigEn(s);
}

inline tBrdServices::tWatchdogConfiguration& tBrdServices::tWatchdogConfiguration::setWatchdogIntTrigEn(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 tBrdServices::tWatchdogConfiguration::getWatchdogIntTrigEn(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfdff) >> 0x9);
}

inline void tBrdServices::tWatchdogConfiguration::writeWatchdogIntTrigEn(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setWatchdogIntTrigEn(fieldValue, s);
   flush(s, force);
}
inline u16 tBrdServices::tWatchdogConfiguration::readWatchdogIntTrigEn(nMDBG::tStatus2* s)
{
   return getWatchdogIntTrigEn(s);
}

inline tBrdServices::tWatchdogControl::tWatchdogControl()
{
}

inline tBrdServices::tWatchdogControl::tRegisterMap* tBrdServices::tWatchdogControl::registerMap(void)
{
   return _regMap;
}

inline void tBrdServices::tWatchdogControl::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tBrdServices::tWatchdogControl::writeWatchdogCommand(u16 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u16(fieldValue) << 0x0) & ~0x0,s);
}
#endif


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