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

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

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

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

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

inline tAI::tAI_Config_FIFO_Status_Register::tRegisterMap* tAI::tAI_Config_FIFO_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tAI::tAI_Config_FIFO_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tAI::tAI_Config_FIFO_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tAI::tAI_Config_FIFO_Status_Register& tAI::tAI_Config_FIFO_Status_Register::setAI_Config_FIFO_Status(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 tAI::tAI_Config_FIFO_Status_Register::getAI_Config_FIFO_Status(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tAI::tAI_Config_FIFO_Status_Register::readAI_Config_FIFO_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_Config_FIFO_Status(s);
}

inline tAI::tAI_Data_FIFO_Status_Register::tAI_Data_FIFO_Status_Register()
{
   _softCopy = u32(0x0);
}

inline tAI::tAI_Data_FIFO_Status_Register::tRegisterMap* tAI::tAI_Data_FIFO_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tAI::tAI_Data_FIFO_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tAI::tAI_Data_FIFO_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tAI::tAI_Data_FIFO_Status_Register& tAI::tAI_Data_FIFO_Status_Register::setAI_Data_FIFO_Status(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 tAI::tAI_Data_FIFO_Status_Register::getAI_Data_FIFO_Status(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tAI::tAI_Data_FIFO_Status_Register::readAI_Data_FIFO_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_Data_FIFO_Status(s);
}

inline tAI::tAI_FIFO_Data_Register::tAI_FIFO_Data_Register()
{
}

inline tAI::tAI_FIFO_Data_Register::tRegisterMap* tAI::tAI_FIFO_Data_Register::registerMap(void)
{
   return _regMap;
}

inline void tAI::tAI_FIFO_Data_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline u32 tAI::tAI_FIFO_Data_Register::readRegister(nMDBG::tStatus2* s)
{
   u32 fieldValue;
   fieldValue = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
   return fieldValue;
}

inline u32 tAI::tAI_FIFO_Data_Register::readAI_FIFO_Data(nMDBG::tStatus2* s)
{
   u32 value = readRegister(s);
   return u32((value & ~0x0) >> 0x0);
}

inline tAI::tAI_FIFO_Data_Register16::tAI_FIFO_Data_Register16()
{
}

inline tAI::tAI_FIFO_Data_Register16::tRegisterMap* tAI::tAI_FIFO_Data_Register16::registerMap(void)
{
   return _regMap;
}

inline void tAI::tAI_FIFO_Data_Register16::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline u16 tAI::tAI_FIFO_Data_Register16::readRegister(nMDBG::tStatus2* s)
{
   u16 fieldValue;
   fieldValue = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
   return fieldValue;
}

inline u16 tAI::tAI_FIFO_Data_Register16::readAI_FIFO_Data16(nMDBG::tStatus2* s)
{
   u16 value = readRegister(s);
   return u16((value & ~0x0) >> 0x0);
}

inline tAI::tAI_Config_FIFO_Data_Register::tAI_Config_FIFO_Data_Register()
{
   _softCopy = u16(0x0);
}

inline tAI::tAI_Config_FIFO_Data_Register::tRegisterMap* tAI::tAI_Config_FIFO_Data_Register::registerMap(void)
{
   return _regMap;
}

inline void tAI::tAI_Config_FIFO_Data_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tAI::tAI_Config_FIFO_Data_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tAI::tAI_Config_FIFO_Data_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 tAI::tAI_Config_FIFO_Data_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 tAI::tAI_Config_FIFO_Data_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u16 tAI::tAI_Config_FIFO_Data_Register::getAI_Config_Channel(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfff0) >> 0x0);
}

inline void tAI::tAI_Config_FIFO_Data_Register::writeAI_Config_Channel(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_Config_Channel(fieldValue, s);
   flush(s, force);
}
inline u16 tAI::tAI_Config_FIFO_Data_Register::readAI_Config_Channel(nMDBG::tStatus2* s)
{
   return getAI_Config_Channel(s);
}

inline tAI::tAI_Config_FIFO_Data_Register& tAI::tAI_Config_FIFO_Data_Register::setAI_Config_Bank(nAI::tAI_Config_Bank_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffcf) | ((u16(fieldValue) << 0x4) & ~0xffcf);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_Config_Bank_t tAI::tAI_Config_FIFO_Data_Register::getAI_Config_Bank(nMDBG::tStatus2*) const
{
   return nAI::tAI_Config_Bank_t((_softCopy & ~0xffcf) >> 0x4);
}

inline void tAI::tAI_Config_FIFO_Data_Register::writeAI_Config_Bank(nAI::tAI_Config_Bank_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_Config_Bank(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_Config_Bank_t tAI::tAI_Config_FIFO_Data_Register::readAI_Config_Bank(nMDBG::tStatus2* s)
{
   return getAI_Config_Bank(s);
}

inline tAI::tAI_Config_FIFO_Data_Register& tAI::tAI_Config_FIFO_Data_Register::setAI_Config_Channel_Type(nAI::tAI_Config_Channel_Type_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfe3f) | ((u16(fieldValue) << 0x6) & ~0xfe3f);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_Config_Channel_Type_t tAI::tAI_Config_FIFO_Data_Register::getAI_Config_Channel_Type(nMDBG::tStatus2*) const
{
   return nAI::tAI_Config_Channel_Type_t((_softCopy & ~0xfe3f) >> 0x6);
}

inline void tAI::tAI_Config_FIFO_Data_Register::writeAI_Config_Channel_Type(nAI::tAI_Config_Channel_Type_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_Config_Channel_Type(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_Config_Channel_Type_t tAI::tAI_Config_FIFO_Data_Register::readAI_Config_Channel_Type(nMDBG::tStatus2* s)
{
   return getAI_Config_Channel_Type(s);
}

inline tAI::tAI_Config_FIFO_Data_Register& tAI::tAI_Config_FIFO_Data_Register::setAI_Config_Gain(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf1ff) | ((u16(fieldValue) << 0x9) & ~0xf1ff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tAI::tAI_Config_FIFO_Data_Register::getAI_Config_Gain(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf1ff) >> 0x9);
}

inline void tAI::tAI_Config_FIFO_Data_Register::writeAI_Config_Gain(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_Config_Gain(fieldValue, s);
   flush(s, force);
}
inline u16 tAI::tAI_Config_FIFO_Data_Register::readAI_Config_Gain(nMDBG::tStatus2* s)
{
   return getAI_Config_Gain(s);
}

inline tAI::tAI_Config_FIFO_Data_Register& tAI::tAI_Config_FIFO_Data_Register::setAI_Config_Dither(nAI::tAI_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 nAI::tAI_Disabled_Enabled_t tAI::tAI_Config_FIFO_Data_Register::getAI_Config_Dither(nMDBG::tStatus2*) const
{
   return nAI::tAI_Disabled_Enabled_t((_softCopy & ~0xdfff) >> 0xd);
}

inline void tAI::tAI_Config_FIFO_Data_Register::writeAI_Config_Dither(nAI::tAI_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_Config_Dither(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_Disabled_Enabled_t tAI::tAI_Config_FIFO_Data_Register::readAI_Config_Dither(nMDBG::tStatus2* s)
{
   return getAI_Config_Dither(s);
}

inline tAI::tAI_Config_FIFO_Data_Register& tAI::tAI_Config_FIFO_Data_Register::setAI_Config_Last_Channel(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 tAI::tAI_Config_FIFO_Data_Register::getAI_Config_Last_Channel(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline void tAI::tAI_Config_FIFO_Data_Register::writeAI_Config_Last_Channel(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_Config_Last_Channel(fieldValue, s);
   flush(s, force);
}
inline u16 tAI::tAI_Config_FIFO_Data_Register::readAI_Config_Last_Channel(nMDBG::tStatus2* s)
{
   return getAI_Config_Last_Channel(s);
}

inline tAI::tAI_Data_Mode_Register::tAI_Data_Mode_Register()
{
   _softCopy = u32(0x0);
}

inline tAI::tAI_Data_Mode_Register::tRegisterMap* tAI::tAI_Data_Mode_Register::registerMap(void)
{
   return _regMap;
}

inline void tAI::tAI_Data_Mode_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tAI::tAI_Data_Mode_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline u32 tAI::tAI_Data_Mode_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tAI::tAI_Data_Mode_Register& tAI::tAI_Data_Mode_Register::setAI_DoneNotificationEnable(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff7f) | ((u32(fieldValue) << 0x7) & ~0xffffff7f);
   setRegister(newValue, s);
   return *this;
}

inline u32 tAI::tAI_Data_Mode_Register::getAI_DoneNotificationEnable(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffff7f) >> 0x7);
}

inline void tAI::tAI_Data_Mode_Register::writeAI_DoneNotificationEnable(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_DoneNotificationEnable(fieldValue, s);
   flush(s, force);
}
inline u32 tAI::tAI_Data_Mode_Register::readAI_DoneNotificationEnable(nMDBG::tStatus2* s)
{
   return getAI_DoneNotificationEnable(s);
}

inline tAI::tAI_Data_Mode_Register& tAI::tAI_Data_Mode_Register::setAI_FifoWidth(nAI::tAI_FifoWidth_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 nAI::tAI_FifoWidth_t tAI::tAI_Data_Mode_Register::getAI_FifoWidth(nMDBG::tStatus2*) const
{
   return nAI::tAI_FifoWidth_t((_softCopy & ~0xfffffeff) >> 0x8);
}

inline void tAI::tAI_Data_Mode_Register::writeAI_FifoWidth(nAI::tAI_FifoWidth_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_FifoWidth(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_FifoWidth_t tAI::tAI_Data_Mode_Register::readAI_FifoWidth(nMDBG::tStatus2* s)
{
   return getAI_FifoWidth(s);
}

inline tAI::tAI_Trigger_Select_Register::tAI_Trigger_Select_Register()
{
   _softCopy = u32(0x0);
}

inline tAI::tAI_Trigger_Select_Register::tRegisterMap* tAI::tAI_Trigger_Select_Register::registerMap(void)
{
   return _regMap;
}

inline void tAI::tAI_Trigger_Select_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tAI::tAI_Trigger_Select_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline u32 tAI::tAI_Trigger_Select_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tAI::tAI_Trigger_Select_Register& tAI::tAI_Trigger_Select_Register::setAI_START1_Select(nAI::tAI_START1_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffc0) | ((u32(fieldValue) << 0x0) & ~0xffffffc0);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_START1_Select_t tAI::tAI_Trigger_Select_Register::getAI_START1_Select(nMDBG::tStatus2*) const
{
   return nAI::tAI_START1_Select_t((_softCopy & ~0xffffffc0) >> 0x0);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_START1_Select(nAI::tAI_START1_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START1_Select(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_START1_Select_t tAI::tAI_Trigger_Select_Register::readAI_START1_Select(nMDBG::tStatus2* s)
{
   return getAI_START1_Select(s);
}

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

inline u32 tAI::tAI_Trigger_Select_Register::getAI_START1_Edge(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffffbf) >> 0x6);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_START1_Edge(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START1_Edge(fieldValue, s);
   flush(s, force);
}
inline u32 tAI::tAI_Trigger_Select_Register::readAI_START1_Edge(nMDBG::tStatus2* s)
{
   return getAI_START1_Edge(s);
}

inline tAI::tAI_Trigger_Select_Register& tAI::tAI_Trigger_Select_Register::setAI_START1_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff7f) | ((u32(fieldValue) << 0x7) & ~0xffffff7f);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register::getAI_START1_Polarity(nMDBG::tStatus2*) const
{
   return nAI::tAI_Polarity_t((_softCopy & ~0xffffff7f) >> 0x7);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_START1_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START1_Polarity(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register::readAI_START1_Polarity(nMDBG::tStatus2* s)
{
   return getAI_START1_Polarity(s);
}

inline tAI::tAI_Trigger_Select_Register& tAI::tAI_Trigger_Select_Register::setAI_START2_Select(nAI::tAI_START2_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffc0ff) | ((u32(fieldValue) << 0x8) & ~0xffffc0ff);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_START2_Select_t tAI::tAI_Trigger_Select_Register::getAI_START2_Select(nMDBG::tStatus2*) const
{
   return nAI::tAI_START2_Select_t((_softCopy & ~0xffffc0ff) >> 0x8);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_START2_Select(nAI::tAI_START2_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START2_Select(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_START2_Select_t tAI::tAI_Trigger_Select_Register::readAI_START2_Select(nMDBG::tStatus2* s)
{
   return getAI_START2_Select(s);
}

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

inline u32 tAI::tAI_Trigger_Select_Register::getAI_START2_Edge(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffbfff) >> 0xe);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_START2_Edge(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START2_Edge(fieldValue, s);
   flush(s, force);
}
inline u32 tAI::tAI_Trigger_Select_Register::readAI_START2_Edge(nMDBG::tStatus2* s)
{
   return getAI_START2_Edge(s);
}

inline tAI::tAI_Trigger_Select_Register& tAI::tAI_Trigger_Select_Register::setAI_START2_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff7fff) | ((u32(fieldValue) << 0xf) & ~0xffff7fff);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register::getAI_START2_Polarity(nMDBG::tStatus2*) const
{
   return nAI::tAI_Polarity_t((_softCopy & ~0xffff7fff) >> 0xf);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_START2_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START2_Polarity(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register::readAI_START2_Polarity(nMDBG::tStatus2* s)
{
   return getAI_START2_Polarity(s);
}

inline tAI::tAI_Trigger_Select_Register& tAI::tAI_Trigger_Select_Register::setAI_External_Gate_Select(nAI::tAI_External_Gate_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffc0ffff) | ((u32(fieldValue) << 0x10) & ~0xffc0ffff);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_External_Gate_Select_t tAI::tAI_Trigger_Select_Register::getAI_External_Gate_Select(nMDBG::tStatus2*) const
{
   return nAI::tAI_External_Gate_Select_t((_softCopy & ~0xffc0ffff) >> 0x10);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_External_Gate_Select(nAI::tAI_External_Gate_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_External_Gate_Select(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_External_Gate_Select_t tAI::tAI_Trigger_Select_Register::readAI_External_Gate_Select(nMDBG::tStatus2* s)
{
   return getAI_External_Gate_Select(s);
}

inline tAI::tAI_Trigger_Select_Register& tAI::tAI_Trigger_Select_Register::setAI_External_Gate_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff7fffff) | ((u32(fieldValue) << 0x17) & ~0xff7fffff);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register::getAI_External_Gate_Polarity(nMDBG::tStatus2*) const
{
   return nAI::tAI_Polarity_t((_softCopy & ~0xff7fffff) >> 0x17);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_External_Gate_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_External_Gate_Polarity(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register::readAI_External_Gate_Polarity(nMDBG::tStatus2* s)
{
   return getAI_External_Gate_Polarity(s);
}

inline tAI::tAI_Trigger_Select_Register& tAI::tAI_Trigger_Select_Register::setAI_CONVERT_Source_Select(nAI::tAI_StartConvertSelMux_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xc0ffffff) | ((u32(fieldValue) << 0x18) & ~0xc0ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_StartConvertSelMux_t tAI::tAI_Trigger_Select_Register::getAI_CONVERT_Source_Select(nMDBG::tStatus2*) const
{
   return nAI::tAI_StartConvertSelMux_t((_softCopy & ~0xc0ffffff) >> 0x18);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_CONVERT_Source_Select(nAI::tAI_StartConvertSelMux_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_CONVERT_Source_Select(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_StartConvertSelMux_t tAI::tAI_Trigger_Select_Register::readAI_CONVERT_Source_Select(nMDBG::tStatus2* s)
{
   return getAI_CONVERT_Source_Select(s);
}

inline tAI::tAI_Trigger_Select_Register& tAI::tAI_Trigger_Select_Register::setAI_Convert_Source_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x7fffffff) | ((u32(fieldValue) << 0x1f) & ~0x7fffffff);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register::getAI_Convert_Source_Polarity(nMDBG::tStatus2*) const
{
   return nAI::tAI_Polarity_t((_softCopy & ~0x7fffffff) >> 0x1f);
}

inline void tAI::tAI_Trigger_Select_Register::writeAI_Convert_Source_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_Convert_Source_Polarity(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register::readAI_Convert_Source_Polarity(nMDBG::tStatus2* s)
{
   return getAI_Convert_Source_Polarity(s);
}

inline tAI::tAI_Trigger_Select_Register2::tAI_Trigger_Select_Register2()
{
   _softCopy = u32(0x0);
}

inline tAI::tAI_Trigger_Select_Register2::tRegisterMap* tAI::tAI_Trigger_Select_Register2::registerMap(void)
{
   return _regMap;
}

inline void tAI::tAI_Trigger_Select_Register2::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tAI::tAI_Trigger_Select_Register2::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u32 tAI::tAI_Trigger_Select_Register2::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tAI::tAI_Trigger_Select_Register2& tAI::tAI_Trigger_Select_Register2::setAI_START_Select(nAI::tAI_StartConvertSelMux_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 nAI::tAI_StartConvertSelMux_t tAI::tAI_Trigger_Select_Register2::getAI_START_Select(nMDBG::tStatus2*) const
{
   return nAI::tAI_StartConvertSelMux_t((_softCopy & ~0xffc0ffff) >> 0x10);
}

inline void tAI::tAI_Trigger_Select_Register2::writeAI_START_Select(nAI::tAI_StartConvertSelMux_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START_Select(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_StartConvertSelMux_t tAI::tAI_Trigger_Select_Register2::readAI_START_Select(nMDBG::tStatus2* s)
{
   return getAI_START_Select(s);
}

inline tAI::tAI_Trigger_Select_Register2& tAI::tAI_Trigger_Select_Register2::setAI_START_Edge(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffbfffff) | ((u32(fieldValue) << 0x16) & ~0xffbfffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tAI::tAI_Trigger_Select_Register2::getAI_START_Edge(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffbfffff) >> 0x16);
}

inline void tAI::tAI_Trigger_Select_Register2::writeAI_START_Edge(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START_Edge(fieldValue, s);
   flush(s, force);
}
inline u32 tAI::tAI_Trigger_Select_Register2::readAI_START_Edge(nMDBG::tStatus2* s)
{
   return getAI_START_Edge(s);
}

inline tAI::tAI_Trigger_Select_Register2& tAI::tAI_Trigger_Select_Register2::setAI_START_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff7fffff) | ((u32(fieldValue) << 0x17) & ~0xff7fffff);
   setRegister(newValue, s);
   return *this;
}

inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register2::getAI_START_Polarity(nMDBG::tStatus2*) const
{
   return nAI::tAI_Polarity_t((_softCopy & ~0xff7fffff) >> 0x17);
}

inline void tAI::tAI_Trigger_Select_Register2::writeAI_START_Polarity(nAI::tAI_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAI_START_Polarity(fieldValue, s);
   flush(s, force);
}
inline nAI::tAI_Polarity_t tAI::tAI_Trigger_Select_Register2::readAI_START_Polarity(nMDBG::tStatus2* s)
{
   return getAI_START_Polarity(s);
}

#endif


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