doxygen/t_t_i_o__auto_8cpp_source.html

00001 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
00002 // This file is autogenerated!!!
00003 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
00004
00005 #ifndef ___tTIO_ipp___
00006 #define ___tTIO_ipp___
00007
00008 #ifndef ___tTIO_h___
00009 #include "tTIO.h"
00010 #endif
00011
00012 #include "trace.h"
00013 inline void tTIO::tReg16IODirect32::write(
00014    tBusSpaceReference addrSpace,
00015    u32 offset,
00016    u16 value,
00017    nMDBG::tStatus2* s)
00018 {
00019    if (s && s->isFatal()) return;
00020    addrSpace.write16(offset, u16(value));
00021 }
00022
00023 inline u16 tTIO::tReg16IODirect32::read(
00024    tBusSpaceReference addrSpace,
00025    u32 offset,
00026    nMDBG::tStatus2* s)
00027 {
00028    u16 value;   if (s && s->isFatal()) return ~0;
00029    value = (u16)addrSpace.read16(offset);
00030    return value;
00031 }
00032
00033 inline void tTIO::tReg32IODirect32::write(
00034    tBusSpaceReference addrSpace,
00035    u32 offset,
00036    u32 value,
00037    nMDBG::tStatus2* s)
00038 {
00039    if (s && s->isFatal()) return;
00040    addrSpace.write32(offset, value);
00041 }
00042
00043 inline u32 tTIO::tReg32IODirect32::read(
00044    tBusSpaceReference addrSpace,
00045    u32 offset,
00046    nMDBG::tStatus2* s)
00047 {
00048    u32 value;   if (s && s->isFatal()) return ~0;
00049    value = addrSpace.read32(offset);
00050    return value;
00051 }
00052
00053 inline tBusSpaceReference tTIO::getBusSpaceReference(void) const
00054 {
00055    return _addrSpace;
00056 }
00057
00058 inline void tTIO::setAddressOffset(u32 value, nMDBG::tStatus2* s)
00059 {
00060    _addressOffset = value;
00061 }
00062 inline u32  tTIO::getAddressOffset(nMDBG::tStatus2* s)
00063 {
00064    return _addressOffset;
00065 }
00066 inline void tTIO::flushBus(nMDBG::tStatus2* s)
00067 {
00068
00069 }
00070
00071 inline tTIO::tG0_AutoIncrement::tG0_AutoIncrement()
00072 {
00073    _softCopy = 0;
00074 }
00075
00076 inline tTIO* tTIO::tG0_AutoIncrement::registerMap(void)
00077 {
00078    return _TIO;
00079 }
00080
00081 inline void tTIO::tG0_AutoIncrement::flushBus(nMDBG::tStatus2* s)
00082 {
00083    _TIO->flushBus(s);
00084 }
00085
00086 inline tTIO::tG0_AutoIncrement& tTIO::tG0_AutoIncrement::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
00087 {
00088    if (s && s->isFatal()) return *this;
00089    _softCopy = fieldValue;
00090    return *this;
00091 }
00092
00093 inline u16 tTIO::tG0_AutoIncrement::getRegister(nMDBG::tStatus2*) const
00094 {
00095    return _softCopy;
00096 }
00097
00098 inline void tTIO::tG0_AutoIncrement::flush(nMDBG::tStatus2* s)
00099 {
00100    if (s && s->isFatal()) return;
00101    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
00102    _softCopy &= (u16)(0xffffffff);
00103 }
00104
00105 inline void tTIO::tG0_AutoIncrement::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
00106 {
00107    if (s && s->isFatal()) return;
00108    _softCopy = fieldValue;
00109    flush(s);
00110 }
00111
00112 inline u16 tTIO::tG0_AutoIncrement::readRegister(nMDBG::tStatus2*)
00113 {
00114    return _softCopy;
00115 }
00116
00117
00118 inline tTIO::tG0_AutoIncrement& tTIO::tG0_AutoIncrement::set(u16 fieldValue, nMDBG::tStatus2* s)
00119 {
00120    if (s && s->isFatal()) return *this;
00121    u16 newValue;   newValue = ((u16)(_softCopy & 0xff00)) | (((u16)fieldValue << 0x0) & ~0xff00);
00122    setRegister(newValue, s);
00123    return *this;
00124 }
00125
00126 inline u16 tTIO::tG0_AutoIncrement::get(nMDBG::tStatus2*) const
00127 {
00128    return (u16)((_softCopy & ~0xff00) >> 0x0);
00129 }
00130
00131 inline void tTIO::tG0_AutoIncrement::write(u16 fieldValue, nMDBG::tStatus2* s)
00132 {
00133    set(fieldValue, s);
00134    flush(s);
00135 }
00136 inline u16 tTIO::tG0_AutoIncrement::read(nMDBG::tStatus2* s)
00137 {
00138    return get(s);
00139 }
00140
00141 inline void tTIO::tG0_AutoIncrement::setRegisterMap(tTIO* pTIO)
00142 {
00143    _TIO = pTIO;
00144 }
00145
00146 inline tTIO::tG0_Command::tG0_Command()
00147 {
00148    _softCopy = 0;
00149 }
00150
00151 inline tTIO* tTIO::tG0_Command::registerMap(void)
00152 {
00153    return _TIO;
00154 }
00155
00156 inline void tTIO::tG0_Command::flushBus(nMDBG::tStatus2* s)
00157 {
00158    _TIO->flushBus(s);
00159 }
00160
00161 inline tTIO::tG0_Command& tTIO::tG0_Command::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
00162 {
00163    if (s && s->isFatal()) return *this;
00164    _softCopy = fieldValue;
00165    return *this;
00166 }
00167
00168 inline u16 tTIO::tG0_Command::getRegister(nMDBG::tStatus2*) const
00169 {
00170    return _softCopy;
00171 }
00172
00173 inline void tTIO::tG0_Command::flush(nMDBG::tStatus2* s)
00174 {
00175    if (s && s->isFatal()) return;
00176    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
00177    _softCopy &= (u16)(0xffff5be2);
00178 }
00179
00180 inline void tTIO::tG0_Command::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
00181 {
00182    if (s && s->isFatal()) return;
00183    _softCopy = fieldValue;
00184    flush(s);
00185 }
00186
00187 inline u16 tTIO::tG0_Command::readRegister(nMDBG::tStatus2*)
00188 {
00189    return _softCopy;
00190 }
00191
00192
00193 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Arm(u16 fieldValue, nMDBG::tStatus2* s)
00194 {
00195    if (s && s->isFatal()) return *this;
00196    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
00197    setRegister(newValue, s);
00198    return *this;
00199 }
00200
00201 inline u16 tTIO::tG0_Command::getG0_Arm(nMDBG::tStatus2*) const
00202 {
00203    return (u16)((_softCopy & ~0xfffe) >> 0x0);
00204 }
00205
00206 inline void tTIO::tG0_Command::writeG0_Arm(u16 fieldValue, nMDBG::tStatus2* s)
00207 {
00208    setG0_Arm(fieldValue, s);
00209    flush(s);
00210 }
00211 inline u16 tTIO::tG0_Command::readG0_Arm(nMDBG::tStatus2* s)
00212 {
00213    return getG0_Arm(s);
00214 }
00215
00216 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Save_Trace(u16 fieldValue, nMDBG::tStatus2* s)
00217 {
00218    if (s && s->isFatal()) return *this;
00219    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
00220    setRegister(newValue, s);
00221    return *this;
00222 }
00223
00224 inline u16 tTIO::tG0_Command::getG0_Save_Trace(nMDBG::tStatus2*) const
00225 {
00226    return (u16)((_softCopy & ~0xfffd) >> 0x1);
00227 }
00228
00229 inline void tTIO::tG0_Command::writeG0_Save_Trace(u16 fieldValue, nMDBG::tStatus2* s)
00230 {
00231    setG0_Save_Trace(fieldValue, s);
00232    flush(s);
00233 }
00234 inline u16 tTIO::tG0_Command::readG0_Save_Trace(nMDBG::tStatus2* s)
00235 {
00236    return getG0_Save_Trace(s);
00237 }
00238
00239 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Load(u16 fieldValue, nMDBG::tStatus2* s)
00240 {
00241    if (s && s->isFatal()) return *this;
00242    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
00243    setRegister(newValue, s);
00244    return *this;
00245 }
00246
00247 inline u16 tTIO::tG0_Command::getG0_Load(nMDBG::tStatus2*) const
00248 {
00249    return (u16)((_softCopy & ~0xfffb) >> 0x2);
00250 }
00251
00252 inline void tTIO::tG0_Command::writeG0_Load(u16 fieldValue, nMDBG::tStatus2* s)
00253 {
00254    setG0_Load(fieldValue, s);
00255    flush(s);
00256 }
00257 inline u16 tTIO::tG0_Command::readG0_Load(nMDBG::tStatus2* s)
00258 {
00259    return getG0_Load(s);
00260 }
00261
00262 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Disarm(u16 fieldValue, nMDBG::tStatus2* s)
00263 {
00264    if (s && s->isFatal()) return *this;
00265    u16 newValue;   newValue = ((u16)(_softCopy & 0xffef)) | (((u16)fieldValue << 0x4) & ~0xffef);
00266    setRegister(newValue, s);
00267    return *this;
00268 }
00269
00270 inline u16 tTIO::tG0_Command::getG0_Disarm(nMDBG::tStatus2*) const
00271 {
00272    return (u16)((_softCopy & ~0xffef) >> 0x4);
00273 }
00274
00275 inline void tTIO::tG0_Command::writeG0_Disarm(u16 fieldValue, nMDBG::tStatus2* s)
00276 {
00277    setG0_Disarm(fieldValue, s);
00278    flush(s);
00279 }
00280 inline u16 tTIO::tG0_Command::readG0_Disarm(nMDBG::tStatus2* s)
00281 {
00282    return getG0_Disarm(s);
00283 }
00284
00285 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Up_Down(tG0_Up_Down fieldValue, nMDBG::tStatus2* s)
00286 {
00287    if (s && s->isFatal()) return *this;
00288    u16 newValue;   newValue = ((u16)(_softCopy & 0xff9f)) | (((u16)fieldValue << 0x5) & ~0xff9f);
00289    setRegister(newValue, s);
00290    return *this;
00291 }
00292
00293 inline tTIO::tG0_Command::tG0_Up_Down tTIO::tG0_Command::getG0_Up_Down(nMDBG::tStatus2*) const
00294 {
00295    return (tG0_Up_Down)((_softCopy & ~0xff9f) >> 0x5);
00296 }
00297
00298 inline void tTIO::tG0_Command::writeG0_Up_Down(tG0_Up_Down fieldValue, nMDBG::tStatus2* s)
00299 {
00300    setG0_Up_Down(fieldValue, s);
00301    flush(s);
00302 }
00303 inline tTIO::tG0_Command::tG0_Up_Down tTIO::tG0_Command::readG0_Up_Down(nMDBG::tStatus2* s)
00304 {
00305    return getG0_Up_Down(s);
00306 }
00307
00308 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Write_Switch(tG0_Write_Switch fieldValue, nMDBG::tStatus2* s)
00309 {
00310    if (s && s->isFatal()) return *this;
00311    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
00312    setRegister(newValue, s);
00313    return *this;
00314 }
00315
00316 inline tTIO::tG0_Command::tG0_Write_Switch tTIO::tG0_Command::getG0_Write_Switch(nMDBG::tStatus2*) const
00317 {
00318    return (tG0_Write_Switch)((_softCopy & ~0xff7f) >> 0x7);
00319 }
00320
00321 inline void tTIO::tG0_Command::writeG0_Write_Switch(tG0_Write_Switch fieldValue, nMDBG::tStatus2* s)
00322 {
00323    setG0_Write_Switch(fieldValue, s);
00324    flush(s);
00325 }
00326 inline tTIO::tG0_Command::tG0_Write_Switch tTIO::tG0_Command::readG0_Write_Switch(nMDBG::tStatus2* s)
00327 {
00328    return getG0_Write_Switch(s);
00329 }
00330
00331 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Synchronized_Gate(tG0_Synchronized_Gate fieldValue, nMDBG::tStatus2* s)
00332 {
00333    if (s && s->isFatal()) return *this;
00334    u16 newValue;   newValue = ((u16)(_softCopy & 0xfeff)) | (((u16)fieldValue << 0x8) & ~0xfeff);
00335    setRegister(newValue, s);
00336    return *this;
00337 }
00338
00339 inline tTIO::tG0_Command::tG0_Synchronized_Gate tTIO::tG0_Command::getG0_Synchronized_Gate(nMDBG::tStatus2*) const
00340 {
00341    return (tG0_Synchronized_Gate)((_softCopy & ~0xfeff) >> 0x8);
00342 }
00343
00344 inline void tTIO::tG0_Command::writeG0_Synchronized_Gate(tG0_Synchronized_Gate fieldValue, nMDBG::tStatus2* s)
00345 {
00346    setG0_Synchronized_Gate(fieldValue, s);
00347    flush(s);
00348 }
00349 inline tTIO::tG0_Command::tG0_Synchronized_Gate tTIO::tG0_Command::readG0_Synchronized_Gate(nMDBG::tStatus2* s)
00350 {
00351    return getG0_Synchronized_Gate(s);
00352 }
00353
00354 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Little_Big_Endian(tG0_Little_Big_Endian fieldValue, nMDBG::tStatus2* s)
00355 {
00356    if (s && s->isFatal()) return *this;
00357    u16 newValue;   newValue = ((u16)(_softCopy & 0xfdff)) | (((u16)fieldValue << 0x9) & ~0xfdff);
00358    setRegister(newValue, s);
00359    return *this;
00360 }
00361
00362 inline tTIO::tG0_Command::tG0_Little_Big_Endian tTIO::tG0_Command::getG0_Little_Big_Endian(nMDBG::tStatus2*) const
00363 {
00364    return (tG0_Little_Big_Endian)((_softCopy & ~0xfdff) >> 0x9);
00365 }
00366
00367 inline void tTIO::tG0_Command::writeG0_Little_Big_Endian(tG0_Little_Big_Endian fieldValue, nMDBG::tStatus2* s)
00368 {
00369    setG0_Little_Big_Endian(fieldValue, s);
00370    flush(s);
00371 }
00372 inline tTIO::tG0_Command::tG0_Little_Big_Endian tTIO::tG0_Command::readG0_Little_Big_Endian(nMDBG::tStatus2* s)
00373 {
00374    return getG0_Little_Big_Endian(s);
00375 }
00376
00377 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Bank_Switch_Start(u16 fieldValue, nMDBG::tStatus2* s)
00378 {
00379    if (s && s->isFatal()) return *this;
00380    u16 newValue;   newValue = ((u16)(_softCopy & 0xfbff)) | (((u16)fieldValue << 0xa) & ~0xfbff);
00381    setRegister(newValue, s);
00382    return *this;
00383 }
00384
00385 inline u16 tTIO::tG0_Command::getG0_Bank_Switch_Start(nMDBG::tStatus2*) const
00386 {
00387    return (u16)((_softCopy & ~0xfbff) >> 0xa);
00388 }
00389
00390 inline void tTIO::tG0_Command::writeG0_Bank_Switch_Start(u16 fieldValue, nMDBG::tStatus2* s)
00391 {
00392    setG0_Bank_Switch_Start(fieldValue, s);
00393    flush(s);
00394 }
00395 inline u16 tTIO::tG0_Command::readG0_Bank_Switch_Start(nMDBG::tStatus2* s)
00396 {
00397    return getG0_Bank_Switch_Start(s);
00398 }
00399
00400 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Bank_Switch_Mode(tG0_Bank_Switch_Mode fieldValue, nMDBG::tStatus2* s)
00401 {
00402    if (s && s->isFatal()) return *this;
00403    u16 newValue;   newValue = ((u16)(_softCopy & 0xf7ff)) | (((u16)fieldValue << 0xb) & ~0xf7ff);
00404    setRegister(newValue, s);
00405    return *this;
00406 }
00407
00408 inline tTIO::tG0_Command::tG0_Bank_Switch_Mode tTIO::tG0_Command::getG0_Bank_Switch_Mode(nMDBG::tStatus2*) const
00409 {
00410    return (tG0_Bank_Switch_Mode)((_softCopy & ~0xf7ff) >> 0xb);
00411 }
00412
00413 inline void tTIO::tG0_Command::writeG0_Bank_Switch_Mode(tG0_Bank_Switch_Mode fieldValue, nMDBG::tStatus2* s)
00414 {
00415    setG0_Bank_Switch_Mode(fieldValue, s);
00416    flush(s);
00417 }
00418 inline tTIO::tG0_Command::tG0_Bank_Switch_Mode tTIO::tG0_Command::readG0_Bank_Switch_Mode(nMDBG::tStatus2* s)
00419 {
00420    return getG0_Bank_Switch_Mode(s);
00421 }
00422
00423 inline tTIO::tG0_Command& tTIO::tG0_Command::setG0_Bank_Switch_Enable(tG0_Bank_Switch_Enable fieldValue, nMDBG::tStatus2* s)
00424 {
00425    if (s && s->isFatal()) return *this;
00426    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
00427    setRegister(newValue, s);
00428    return *this;
00429 }
00430
00431 inline tTIO::tG0_Command::tG0_Bank_Switch_Enable tTIO::tG0_Command::getG0_Bank_Switch_Enable(nMDBG::tStatus2*) const
00432 {
00433    return (tG0_Bank_Switch_Enable)((_softCopy & ~0xefff) >> 0xc);
00434 }
00435
00436 inline void tTIO::tG0_Command::writeG0_Bank_Switch_Enable(tG0_Bank_Switch_Enable fieldValue, nMDBG::tStatus2* s)
00437 {
00438    setG0_Bank_Switch_Enable(fieldValue, s);
00439    flush(s);
00440 }
00441 inline tTIO::tG0_Command::tG0_Bank_Switch_Enable tTIO::tG0_Command::readG0_Bank_Switch_Enable(nMDBG::tStatus2* s)
00442 {
00443    return getG0_Bank_Switch_Enable(s);
00444 }
00445
00446 inline tTIO::tG0_Command& tTIO::tG0_Command::setG1_Arm_Copy(u16 fieldValue, nMDBG::tStatus2* s)
00447 {
00448    if (s && s->isFatal()) return *this;
00449    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
00450    setRegister(newValue, s);
00451    return *this;
00452 }
00453
00454 inline u16 tTIO::tG0_Command::getG1_Arm_Copy(nMDBG::tStatus2*) const
00455 {
00456    return (u16)((_softCopy & ~0xdfff) >> 0xd);
00457 }
00458
00459 inline void tTIO::tG0_Command::writeG1_Arm_Copy(u16 fieldValue, nMDBG::tStatus2* s)
00460 {
00461    setG1_Arm_Copy(fieldValue, s);
00462    flush(s);
00463 }
00464 inline u16 tTIO::tG0_Command::readG1_Arm_Copy(nMDBG::tStatus2* s)
00465 {
00466    return getG1_Arm_Copy(s);
00467 }
00468
00469 inline tTIO::tG0_Command& tTIO::tG0_Command::setG1_Save_Trace_Copy(u16 fieldValue, nMDBG::tStatus2* s)
00470 {
00471    if (s && s->isFatal()) return *this;
00472    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
00473    setRegister(newValue, s);
00474    return *this;
00475 }
00476
00477 inline u16 tTIO::tG0_Command::getG1_Save_Trace_Copy(nMDBG::tStatus2*) const
00478 {
00479    return (u16)((_softCopy & ~0xbfff) >> 0xe);
00480 }
00481
00482 inline void tTIO::tG0_Command::writeG1_Save_Trace_Copy(u16 fieldValue, nMDBG::tStatus2* s)
00483 {
00484    setG1_Save_Trace_Copy(fieldValue, s);
00485    flush(s);
00486 }
00487 inline u16 tTIO::tG0_Command::readG1_Save_Trace_Copy(nMDBG::tStatus2* s)
00488 {
00489    return getG1_Save_Trace_Copy(s);
00490 }
00491
00492 inline tTIO::tG0_Command& tTIO::tG0_Command::setG1_Disarm_Copy(u16 fieldValue, nMDBG::tStatus2* s)
00493 {
00494    if (s && s->isFatal()) return *this;
00495    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
00496    setRegister(newValue, s);
00497    return *this;
00498 }
00499
00500 inline u16 tTIO::tG0_Command::getG1_Disarm_Copy(nMDBG::tStatus2*) const
00501 {
00502    return (u16)((_softCopy & ~0x7fff) >> 0xf);
00503 }
00504
00505 inline void tTIO::tG0_Command::writeG1_Disarm_Copy(u16 fieldValue, nMDBG::tStatus2* s)
00506 {
00507    setG1_Disarm_Copy(fieldValue, s);
00508    flush(s);
00509 }
00510 inline u16 tTIO::tG0_Command::readG1_Disarm_Copy(nMDBG::tStatus2* s)
00511 {
00512    return getG1_Disarm_Copy(s);
00513 }
00514
00515 inline void tTIO::tG0_Command::setRegisterMap(tTIO* pTIO)
00516 {
00517    _TIO = pTIO;
00518 }
00519
00520 inline tTIO::tG0_Counting_Mode::tG0_Counting_Mode()
00521 {
00522    _softCopy = 0;
00523 }
00524
00525 inline tTIO* tTIO::tG0_Counting_Mode::registerMap(void)
00526 {
00527    return _TIO;
00528 }
00529
00530 inline void tTIO::tG0_Counting_Mode::flushBus(nMDBG::tStatus2* s)
00531 {
00532    _TIO->flushBus(s);
00533 }
00534
00535 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
00536 {
00537    if (s && s->isFatal()) return *this;
00538    _softCopy = fieldValue;
00539    return *this;
00540 }
00541
00542 inline u16 tTIO::tG0_Counting_Mode::getRegister(nMDBG::tStatus2*) const
00543 {
00544    return _softCopy;
00545 }
00546
00547 inline void tTIO::tG0_Counting_Mode::flush(nMDBG::tStatus2* s)
00548 {
00549    if (s && s->isFatal()) return;
00550    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
00551    _softCopy &= (u16)(0xffffffff);
00552 }
00553
00554 inline void tTIO::tG0_Counting_Mode::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
00555 {
00556    if (s && s->isFatal()) return;
00557    _softCopy = fieldValue;
00558    flush(s);
00559 }
00560
00561 inline u16 tTIO::tG0_Counting_Mode::readRegister(nMDBG::tStatus2*)
00562 {
00563    return _softCopy;
00564 }
00565
00566
00567 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setG0_Encoder_Counting_Mode(u16 fieldValue, nMDBG::tStatus2* s)
00568 {
00569    if (s && s->isFatal()) return *this;
00570    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff8)) | (((u16)fieldValue << 0x0) & ~0xfff8);
00571    setRegister(newValue, s);
00572    return *this;
00573 }
00574
00575 inline u16 tTIO::tG0_Counting_Mode::getG0_Encoder_Counting_Mode(nMDBG::tStatus2*) const
00576 {
00577    return (u16)((_softCopy & ~0xfff8) >> 0x0);
00578 }
00579
00580 inline void tTIO::tG0_Counting_Mode::writeG0_Encoder_Counting_Mode(u16 fieldValue, nMDBG::tStatus2* s)
00581 {
00582    setG0_Encoder_Counting_Mode(fieldValue, s);
00583    flush(s);
00584 }
00585 inline u16 tTIO::tG0_Counting_Mode::readG0_Encoder_Counting_Mode(nMDBG::tStatus2* s)
00586 {
00587    return getG0_Encoder_Counting_Mode(s);
00588 }
00589
00590 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setG0_Index_Enable(u16 fieldValue, nMDBG::tStatus2* s)
00591 {
00592    if (s && s->isFatal()) return *this;
00593    u16 newValue;   newValue = ((u16)(_softCopy & 0xffef)) | (((u16)fieldValue << 0x4) & ~0xffef);
00594    setRegister(newValue, s);
00595    return *this;
00596 }
00597
00598 inline u16 tTIO::tG0_Counting_Mode::getG0_Index_Enable(nMDBG::tStatus2*) const
00599 {
00600    return (u16)((_softCopy & ~0xffef) >> 0x4);
00601 }
00602
00603 inline void tTIO::tG0_Counting_Mode::writeG0_Index_Enable(u16 fieldValue, nMDBG::tStatus2* s)
00604 {
00605    setG0_Index_Enable(fieldValue, s);
00606    flush(s);
00607 }
00608 inline u16 tTIO::tG0_Counting_Mode::readG0_Index_Enable(nMDBG::tStatus2* s)
00609 {
00610    return getG0_Index_Enable(s);
00611 }
00612
00613 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setG0_Index_Phase(u16 fieldValue, nMDBG::tStatus2* s)
00614 {
00615    if (s && s->isFatal()) return *this;
00616    u16 newValue;   newValue = ((u16)(_softCopy & 0xff9f)) | (((u16)fieldValue << 0x5) & ~0xff9f);
00617    setRegister(newValue, s);
00618    return *this;
00619 }
00620
00621 inline u16 tTIO::tG0_Counting_Mode::getG0_Index_Phase(nMDBG::tStatus2*) const
00622 {
00623    return (u16)((_softCopy & ~0xff9f) >> 0x5);
00624 }
00625
00626 inline void tTIO::tG0_Counting_Mode::writeG0_Index_Phase(u16 fieldValue, nMDBG::tStatus2* s)
00627 {
00628    setG0_Index_Phase(fieldValue, s);
00629    flush(s);
00630 }
00631 inline u16 tTIO::tG0_Counting_Mode::readG0_Index_Phase(nMDBG::tStatus2* s)
00632 {
00633    return getG0_Index_Phase(s);
00634 }
00635
00636 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setG0_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s)
00637 {
00638    if (s && s->isFatal()) return *this;
00639    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
00640    setRegister(newValue, s);
00641    return *this;
00642 }
00643
00644 inline u16 tTIO::tG0_Counting_Mode::getG0_HW_Arm_Enable(nMDBG::tStatus2*) const
00645 {
00646    return (u16)((_softCopy & ~0xff7f) >> 0x7);
00647 }
00648
00649 inline void tTIO::tG0_Counting_Mode::writeG0_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s)
00650 {
00651    setG0_HW_Arm_Enable(fieldValue, s);
00652    flush(s);
00653 }
00654 inline u16 tTIO::tG0_Counting_Mode::readG0_HW_Arm_Enable(nMDBG::tStatus2* s)
00655 {
00656    return getG0_HW_Arm_Enable(s);
00657 }
00658
00659 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setG0_HW_Arm_Select(u16 fieldValue, nMDBG::tStatus2* s)
00660 {
00661    if (s && s->isFatal()) return *this;
00662    u16 newValue;   newValue = ((u16)(_softCopy & 0xf8ff)) | (((u16)fieldValue << 0x8) & ~0xf8ff);
00663    setRegister(newValue, s);
00664    return *this;
00665 }
00666
00667 inline u16 tTIO::tG0_Counting_Mode::getG0_HW_Arm_Select(nMDBG::tStatus2*) const
00668 {
00669    return (u16)((_softCopy & ~0xf8ff) >> 0x8);
00670 }
00671
00672 inline void tTIO::tG0_Counting_Mode::writeG0_HW_Arm_Select(u16 fieldValue, nMDBG::tStatus2* s)
00673 {
00674    setG0_HW_Arm_Select(fieldValue, s);
00675    flush(s);
00676 }
00677 inline u16 tTIO::tG0_Counting_Mode::readG0_HW_Arm_Select(nMDBG::tStatus2* s)
00678 {
00679    return getG0_HW_Arm_Select(s);
00680 }
00681
00682 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setG0_Prescale(u16 fieldValue, nMDBG::tStatus2* s)
00683 {
00684    if (s && s->isFatal()) return *this;
00685    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
00686    setRegister(newValue, s);
00687    return *this;
00688 }
00689
00690 inline u16 tTIO::tG0_Counting_Mode::getG0_Prescale(nMDBG::tStatus2*) const
00691 {
00692    return (u16)((_softCopy & ~0xefff) >> 0xc);
00693 }
00694
00695 inline void tTIO::tG0_Counting_Mode::writeG0_Prescale(u16 fieldValue, nMDBG::tStatus2* s)
00696 {
00697    setG0_Prescale(fieldValue, s);
00698    flush(s);
00699 }
00700 inline u16 tTIO::tG0_Counting_Mode::readG0_Prescale(nMDBG::tStatus2* s)
00701 {
00702    return getG0_Prescale(s);
00703 }
00704
00705 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setG0_Alternate_Synchronization(u16 fieldValue, nMDBG::tStatus2* s)
00706 {
00707    if (s && s->isFatal()) return *this;
00708    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
00709    setRegister(newValue, s);
00710    return *this;
00711 }
00712
00713 inline u16 tTIO::tG0_Counting_Mode::getG0_Alternate_Synchronization(nMDBG::tStatus2*) const
00714 {
00715    return (u16)((_softCopy & ~0xdfff) >> 0xd);
00716 }
00717
00718 inline void tTIO::tG0_Counting_Mode::writeG0_Alternate_Synchronization(u16 fieldValue, nMDBG::tStatus2* s)
00719 {
00720    setG0_Alternate_Synchronization(fieldValue, s);
00721    flush(s);
00722 }
00723 inline u16 tTIO::tG0_Counting_Mode::readG0_Alternate_Synchronization(nMDBG::tStatus2* s)
00724 {
00725    return getG0_Alternate_Synchronization(s);
00726 }
00727
00728 inline tTIO::tG0_Counting_Mode& tTIO::tG0_Counting_Mode::setG0_Prescale_By_2(u16 fieldValue, nMDBG::tStatus2* s)
00729 {
00730    if (s && s->isFatal()) return *this;
00731    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
00732    setRegister(newValue, s);
00733    return *this;
00734 }
00735
00736 inline u16 tTIO::tG0_Counting_Mode::getG0_Prescale_By_2(nMDBG::tStatus2*) const
00737 {
00738    return (u16)((_softCopy & ~0xbfff) >> 0xe);
00739 }
00740
00741 inline void tTIO::tG0_Counting_Mode::writeG0_Prescale_By_2(u16 fieldValue, nMDBG::tStatus2* s)
00742 {
00743    setG0_Prescale_By_2(fieldValue, s);
00744    flush(s);
00745 }
00746 inline u16 tTIO::tG0_Counting_Mode::readG0_Prescale_By_2(nMDBG::tStatus2* s)
00747 {
00748    return getG0_Prescale_By_2(s);
00749 }
00750
00751 inline void tTIO::tG0_Counting_Mode::setRegisterMap(tTIO* pTIO)
00752 {
00753    _TIO = pTIO;
00754 }
00755
00756 inline tTIO::tG0_MSeries_Counting_Mode::tG0_MSeries_Counting_Mode()
00757 {
00758    _softCopy = 0;
00759 }
00760
00761 inline tTIO* tTIO::tG0_MSeries_Counting_Mode::registerMap(void)
00762 {
00763    return _TIO;
00764 }
00765
00766 inline void tTIO::tG0_MSeries_Counting_Mode::flushBus(nMDBG::tStatus2* s)
00767 {
00768    _TIO->flushBus(s);
00769 }
00770
00771 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
00772 {
00773    if (s && s->isFatal()) return *this;
00774    _softCopy = fieldValue;
00775    return *this;
00776 }
00777
00778 inline u16 tTIO::tG0_MSeries_Counting_Mode::getRegister(nMDBG::tStatus2*) const
00779 {
00780    return _softCopy;
00781 }
00782
00783 inline void tTIO::tG0_MSeries_Counting_Mode::flush(nMDBG::tStatus2* s)
00784 {
00785    if (s && s->isFatal()) return;
00786    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
00787    _softCopy &= (u16)(0xffffffff);
00788 }
00789
00790 inline void tTIO::tG0_MSeries_Counting_Mode::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
00791 {
00792    if (s && s->isFatal()) return;
00793    _softCopy = fieldValue;
00794    flush(s);
00795 }
00796
00797 inline u16 tTIO::tG0_MSeries_Counting_Mode::readRegister(nMDBG::tStatus2*)
00798 {
00799    return _softCopy;
00800 }
00801
00802
00803 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setG0_MSeries_Encoder_Counting_Mode(u16 fieldValue, nMDBG::tStatus2* s)
00804 {
00805    if (s && s->isFatal()) return *this;
00806    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff8)) | (((u16)fieldValue << 0x0) & ~0xfff8);
00807    setRegister(newValue, s);
00808    return *this;
00809 }
00810
00811 inline u16 tTIO::tG0_MSeries_Counting_Mode::getG0_MSeries_Encoder_Counting_Mode(nMDBG::tStatus2*) const
00812 {
00813    return (u16)((_softCopy & ~0xfff8) >> 0x0);
00814 }
00815
00816 inline void tTIO::tG0_MSeries_Counting_Mode::writeG0_MSeries_Encoder_Counting_Mode(u16 fieldValue, nMDBG::tStatus2* s)
00817 {
00818    setG0_MSeries_Encoder_Counting_Mode(fieldValue, s);
00819    flush(s);
00820 }
00821 inline u16 tTIO::tG0_MSeries_Counting_Mode::readG0_MSeries_Encoder_Counting_Mode(nMDBG::tStatus2* s)
00822 {
00823    return getG0_MSeries_Encoder_Counting_Mode(s);
00824 }
00825
00826 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setG0_MSeries_Index_Enable(u16 fieldValue, nMDBG::tStatus2* s)
00827 {
00828    if (s && s->isFatal()) return *this;
00829    u16 newValue;   newValue = ((u16)(_softCopy & 0xffef)) | (((u16)fieldValue << 0x4) & ~0xffef);
00830    setRegister(newValue, s);
00831    return *this;
00832 }
00833
00834 inline u16 tTIO::tG0_MSeries_Counting_Mode::getG0_MSeries_Index_Enable(nMDBG::tStatus2*) const
00835 {
00836    return (u16)((_softCopy & ~0xffef) >> 0x4);
00837 }
00838
00839 inline void tTIO::tG0_MSeries_Counting_Mode::writeG0_MSeries_Index_Enable(u16 fieldValue, nMDBG::tStatus2* s)
00840 {
00841    setG0_MSeries_Index_Enable(fieldValue, s);
00842    flush(s);
00843 }
00844 inline u16 tTIO::tG0_MSeries_Counting_Mode::readG0_MSeries_Index_Enable(nMDBG::tStatus2* s)
00845 {
00846    return getG0_MSeries_Index_Enable(s);
00847 }
00848
00849 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setG0_MSeries_Index_Phase(u16 fieldValue, nMDBG::tStatus2* s)
00850 {
00851    if (s && s->isFatal()) return *this;
00852    u16 newValue;   newValue = ((u16)(_softCopy & 0xff9f)) | (((u16)fieldValue << 0x5) & ~0xff9f);
00853    setRegister(newValue, s);
00854    return *this;
00855 }
00856
00857 inline u16 tTIO::tG0_MSeries_Counting_Mode::getG0_MSeries_Index_Phase(nMDBG::tStatus2*) const
00858 {
00859    return (u16)((_softCopy & ~0xff9f) >> 0x5);
00860 }
00861
00862 inline void tTIO::tG0_MSeries_Counting_Mode::writeG0_MSeries_Index_Phase(u16 fieldValue, nMDBG::tStatus2* s)
00863 {
00864    setG0_MSeries_Index_Phase(fieldValue, s);
00865    flush(s);
00866 }
00867 inline u16 tTIO::tG0_MSeries_Counting_Mode::readG0_MSeries_Index_Phase(nMDBG::tStatus2* s)
00868 {
00869    return getG0_MSeries_Index_Phase(s);
00870 }
00871
00872 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setG0_MSeries_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s)
00873 {
00874    if (s && s->isFatal()) return *this;
00875    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
00876    setRegister(newValue, s);
00877    return *this;
00878 }
00879
00880 inline u16 tTIO::tG0_MSeries_Counting_Mode::getG0_MSeries_HW_Arm_Enable(nMDBG::tStatus2*) const
00881 {
00882    return (u16)((_softCopy & ~0xff7f) >> 0x7);
00883 }
00884
00885 inline void tTIO::tG0_MSeries_Counting_Mode::writeG0_MSeries_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s)
00886 {
00887    setG0_MSeries_HW_Arm_Enable(fieldValue, s);
00888    flush(s);
00889 }
00890 inline u16 tTIO::tG0_MSeries_Counting_Mode::readG0_MSeries_HW_Arm_Enable(nMDBG::tStatus2* s)
00891 {
00892    return getG0_MSeries_HW_Arm_Enable(s);
00893 }
00894
00895 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setG0_MSeries_HW_Arm_Select(u16 fieldValue, nMDBG::tStatus2* s)
00896 {
00897    if (s && s->isFatal()) return *this;
00898    u16 newValue;   newValue = ((u16)(_softCopy & 0xe0ff)) | (((u16)fieldValue << 0x8) & ~0xe0ff);
00899    setRegister(newValue, s);
00900    return *this;
00901 }
00902
00903 inline u16 tTIO::tG0_MSeries_Counting_Mode::getG0_MSeries_HW_Arm_Select(nMDBG::tStatus2*) const
00904 {
00905    return (u16)((_softCopy & ~0xe0ff) >> 0x8);
00906 }
00907
00908 inline void tTIO::tG0_MSeries_Counting_Mode::writeG0_MSeries_HW_Arm_Select(u16 fieldValue, nMDBG::tStatus2* s)
00909 {
00910    setG0_MSeries_HW_Arm_Select(fieldValue, s);
00911    flush(s);
00912 }
00913 inline u16 tTIO::tG0_MSeries_Counting_Mode::readG0_MSeries_HW_Arm_Select(nMDBG::tStatus2* s)
00914 {
00915    return getG0_MSeries_HW_Arm_Select(s);
00916 }
00917
00918 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setG0_MSeries_Prescale(u16 fieldValue, nMDBG::tStatus2* s)
00919 {
00920    if (s && s->isFatal()) return *this;
00921    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
00922    setRegister(newValue, s);
00923    return *this;
00924 }
00925
00926 inline u16 tTIO::tG0_MSeries_Counting_Mode::getG0_MSeries_Prescale(nMDBG::tStatus2*) const
00927 {
00928    return (u16)((_softCopy & ~0xdfff) >> 0xd);
00929 }
00930
00931 inline void tTIO::tG0_MSeries_Counting_Mode::writeG0_MSeries_Prescale(u16 fieldValue, nMDBG::tStatus2* s)
00932 {
00933    setG0_MSeries_Prescale(fieldValue, s);
00934    flush(s);
00935 }
00936 inline u16 tTIO::tG0_MSeries_Counting_Mode::readG0_MSeries_Prescale(nMDBG::tStatus2* s)
00937 {
00938    return getG0_MSeries_Prescale(s);
00939 }
00940
00941 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setG0_MSeries_Alternate_Synchronization(u16 fieldValue, nMDBG::tStatus2* s)
00942 {
00943    if (s && s->isFatal()) return *this;
00944    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
00945    setRegister(newValue, s);
00946    return *this;
00947 }
00948
00949 inline u16 tTIO::tG0_MSeries_Counting_Mode::getG0_MSeries_Alternate_Synchronization(nMDBG::tStatus2*) const
00950 {
00951    return (u16)((_softCopy & ~0xbfff) >> 0xe);
00952 }
00953
00954 inline void tTIO::tG0_MSeries_Counting_Mode::writeG0_MSeries_Alternate_Synchronization(u16 fieldValue, nMDBG::tStatus2* s)
00955 {
00956    setG0_MSeries_Alternate_Synchronization(fieldValue, s);
00957    flush(s);
00958 }
00959 inline u16 tTIO::tG0_MSeries_Counting_Mode::readG0_MSeries_Alternate_Synchronization(nMDBG::tStatus2* s)
00960 {
00961    return getG0_MSeries_Alternate_Synchronization(s);
00962 }
00963
00964 inline tTIO::tG0_MSeries_Counting_Mode& tTIO::tG0_MSeries_Counting_Mode::setG0_MSeries_Prescale_By_2(u16 fieldValue, nMDBG::tStatus2* s)
00965 {
00966    if (s && s->isFatal()) return *this;
00967    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
00968    setRegister(newValue, s);
00969    return *this;
00970 }
00971
00972 inline u16 tTIO::tG0_MSeries_Counting_Mode::getG0_MSeries_Prescale_By_2(nMDBG::tStatus2*) const
00973 {
00974    return (u16)((_softCopy & ~0x7fff) >> 0xf);
00975 }
00976
00977 inline void tTIO::tG0_MSeries_Counting_Mode::writeG0_MSeries_Prescale_By_2(u16 fieldValue, nMDBG::tStatus2* s)
00978 {
00979    setG0_MSeries_Prescale_By_2(fieldValue, s);
00980    flush(s);
00981 }
00982 inline u16 tTIO::tG0_MSeries_Counting_Mode::readG0_MSeries_Prescale_By_2(nMDBG::tStatus2* s)
00983 {
00984    return getG0_MSeries_Prescale_By_2(s);
00985 }
00986
00987 inline void tTIO::tG0_MSeries_Counting_Mode::setRegisterMap(tTIO* pTIO)
00988 {
00989    _TIO = pTIO;
00990 }
00991
00992 inline tTIO::tG0_DMA_Control::tG0_DMA_Control()
00993 {
00994    _softCopy = 0;
00995 }
00996
00997 inline tTIO* tTIO::tG0_DMA_Control::registerMap(void)
00998 {
00999    return _TIO;
01000 }
01001
01002 inline void tTIO::tG0_DMA_Control::flushBus(nMDBG::tStatus2* s)
01003 {
01004    _TIO->flushBus(s);
01005 }
01006
01007 inline tTIO::tG0_DMA_Control& tTIO::tG0_DMA_Control::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
01008 {
01009    if (s && s->isFatal()) return *this;
01010    _softCopy = fieldValue;
01011    return *this;
01012 }
01013
01014 inline u16 tTIO::tG0_DMA_Control::getRegister(nMDBG::tStatus2*) const
01015 {
01016    return _softCopy;
01017 }
01018
01019 inline void tTIO::tG0_DMA_Control::flush(nMDBG::tStatus2* s)
01020 {
01021    if (s && s->isFatal()) return;
01022    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
01023    _softCopy &= (u16)(0xffffffff);
01024 }
01025
01026 inline void tTIO::tG0_DMA_Control::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
01027 {
01028    if (s && s->isFatal()) return;
01029    _softCopy = fieldValue;
01030    flush(s);
01031 }
01032
01033 inline u16 tTIO::tG0_DMA_Control::readRegister(nMDBG::tStatus2*)
01034 {
01035    return _softCopy;
01036 }
01037
01038
01039 inline tTIO::tG0_DMA_Control& tTIO::tG0_DMA_Control::setG0_DMA_Enable(tG0_DMA_Enable fieldValue, nMDBG::tStatus2* s)
01040 {
01041    if (s && s->isFatal()) return *this;
01042    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
01043    setRegister(newValue, s);
01044    return *this;
01045 }
01046
01047 inline tTIO::tG0_DMA_Control::tG0_DMA_Enable tTIO::tG0_DMA_Control::getG0_DMA_Enable(nMDBG::tStatus2*) const
01048 {
01049    return (tG0_DMA_Enable)((_softCopy & ~0xfffe) >> 0x0);
01050 }
01051
01052 inline void tTIO::tG0_DMA_Control::writeG0_DMA_Enable(tG0_DMA_Enable fieldValue, nMDBG::tStatus2* s)
01053 {
01054    setG0_DMA_Enable(fieldValue, s);
01055    flush(s);
01056 }
01057 inline tTIO::tG0_DMA_Control::tG0_DMA_Enable tTIO::tG0_DMA_Control::readG0_DMA_Enable(nMDBG::tStatus2* s)
01058 {
01059    return getG0_DMA_Enable(s);
01060 }
01061
01062 inline tTIO::tG0_DMA_Control& tTIO::tG0_DMA_Control::setG0_DMA_Output_Enable(u16 fieldValue, nMDBG::tStatus2* s)
01063 {
01064    if (s && s->isFatal()) return *this;
01065    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
01066    setRegister(newValue, s);
01067    return *this;
01068 }
01069
01070 inline u16 tTIO::tG0_DMA_Control::getG0_DMA_Output_Enable(nMDBG::tStatus2*) const
01071 {
01072    return (u16)((_softCopy & ~0xfffd) >> 0x1);
01073 }
01074
01075 inline void tTIO::tG0_DMA_Control::writeG0_DMA_Output_Enable(u16 fieldValue, nMDBG::tStatus2* s)
01076 {
01077    setG0_DMA_Output_Enable(fieldValue, s);
01078    flush(s);
01079 }
01080 inline u16 tTIO::tG0_DMA_Control::readG0_DMA_Output_Enable(nMDBG::tStatus2* s)
01081 {
01082    return getG0_DMA_Output_Enable(s);
01083 }
01084
01085 inline tTIO::tG0_DMA_Control& tTIO::tG0_DMA_Control::setG0_DMA_Int_Enable(u16 fieldValue, nMDBG::tStatus2* s)
01086 {
01087    if (s && s->isFatal()) return *this;
01088    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
01089    setRegister(newValue, s);
01090    return *this;
01091 }
01092
01093 inline u16 tTIO::tG0_DMA_Control::getG0_DMA_Int_Enable(nMDBG::tStatus2*) const
01094 {
01095    return (u16)((_softCopy & ~0xfffb) >> 0x2);
01096 }
01097
01098 inline void tTIO::tG0_DMA_Control::writeG0_DMA_Int_Enable(u16 fieldValue, nMDBG::tStatus2* s)
01099 {
01100    setG0_DMA_Int_Enable(fieldValue, s);
01101    flush(s);
01102 }
01103 inline u16 tTIO::tG0_DMA_Control::readG0_DMA_Int_Enable(nMDBG::tStatus2* s)
01104 {
01105    return getG0_DMA_Int_Enable(s);
01106 }
01107
01108 inline void tTIO::tG0_DMA_Control::setRegisterMap(tTIO* pTIO)
01109 {
01110    _TIO = pTIO;
01111 }
01112
01113 inline tTIO::tG0_Input_Select::tG0_Input_Select()
01114 {
01115    _softCopy = 0;
01116 }
01117
01118 inline tTIO* tTIO::tG0_Input_Select::registerMap(void)
01119 {
01120    return _TIO;
01121 }
01122
01123 inline void tTIO::tG0_Input_Select::flushBus(nMDBG::tStatus2* s)
01124 {
01125    _TIO->flushBus(s);
01126 }
01127
01128 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
01129 {
01130    if (s && s->isFatal()) return *this;
01131    _softCopy = fieldValue;
01132    return *this;
01133 }
01134
01135 inline u16 tTIO::tG0_Input_Select::getRegister(nMDBG::tStatus2*) const
01136 {
01137    return _softCopy;
01138 }
01139
01140 inline void tTIO::tG0_Input_Select::flush(nMDBG::tStatus2* s)
01141 {
01142    if (s && s->isFatal()) return;
01143    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
01144    _softCopy &= (u16)(0xffffffff);
01145 }
01146
01147 inline void tTIO::tG0_Input_Select::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
01148 {
01149    if (s && s->isFatal()) return;
01150    _softCopy = fieldValue;
01151    flush(s);
01152 }
01153
01154 inline u16 tTIO::tG0_Input_Select::readRegister(nMDBG::tStatus2*)
01155 {
01156    return _softCopy;
01157 }
01158
01159
01160 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setG0_Read_Acknowledges_Irq(u16 fieldValue, nMDBG::tStatus2* s)
01161 {
01162    if (s && s->isFatal()) return *this;
01163    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
01164    setRegister(newValue, s);
01165    return *this;
01166 }
01167
01168 inline u16 tTIO::tG0_Input_Select::getG0_Read_Acknowledges_Irq(nMDBG::tStatus2*) const
01169 {
01170    return (u16)((_softCopy & ~0xfffe) >> 0x0);
01171 }
01172
01173 inline void tTIO::tG0_Input_Select::writeG0_Read_Acknowledges_Irq(u16 fieldValue, nMDBG::tStatus2* s)
01174 {
01175    setG0_Read_Acknowledges_Irq(fieldValue, s);
01176    flush(s);
01177 }
01178 inline u16 tTIO::tG0_Input_Select::readG0_Read_Acknowledges_Irq(nMDBG::tStatus2* s)
01179 {
01180    return getG0_Read_Acknowledges_Irq(s);
01181 }
01182
01183 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setG0_Write_Acknowledges_Irq(u16 fieldValue, nMDBG::tStatus2* s)
01184 {
01185    if (s && s->isFatal()) return *this;
01186    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
01187    setRegister(newValue, s);
01188    return *this;
01189 }
01190
01191 inline u16 tTIO::tG0_Input_Select::getG0_Write_Acknowledges_Irq(nMDBG::tStatus2*) const
01192 {
01193    return (u16)((_softCopy & ~0xfffd) >> 0x1);
01194 }
01195
01196 inline void tTIO::tG0_Input_Select::writeG0_Write_Acknowledges_Irq(u16 fieldValue, nMDBG::tStatus2* s)
01197 {
01198    setG0_Write_Acknowledges_Irq(fieldValue, s);
01199    flush(s);
01200 }
01201 inline u16 tTIO::tG0_Input_Select::readG0_Write_Acknowledges_Irq(nMDBG::tStatus2* s)
01202 {
01203    return getG0_Write_Acknowledges_Irq(s);
01204 }
01205
01206 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setG0_Source_Select(u16 fieldValue, nMDBG::tStatus2* s)
01207 {
01208    if (s && s->isFatal()) return *this;
01209    u16 newValue;   newValue = ((u16)(_softCopy & 0xff83)) | (((u16)fieldValue << 0x2) & ~0xff83);
01210    setRegister(newValue, s);
01211    return *this;
01212 }
01213
01214 inline u16 tTIO::tG0_Input_Select::getG0_Source_Select(nMDBG::tStatus2*) const
01215 {
01216    return (u16)((_softCopy & ~0xff83) >> 0x2);
01217 }
01218
01219 inline void tTIO::tG0_Input_Select::writeG0_Source_Select(u16 fieldValue, nMDBG::tStatus2* s)
01220 {
01221    setG0_Source_Select(fieldValue, s);
01222    flush(s);
01223 }
01224 inline u16 tTIO::tG0_Input_Select::readG0_Source_Select(nMDBG::tStatus2* s)
01225 {
01226    return getG0_Source_Select(s);
01227 }
01228
01229 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setG0_Gate_Select(u16 fieldValue, nMDBG::tStatus2* s)
01230 {
01231    if (s && s->isFatal()) return *this;
01232    u16 newValue;   newValue = ((u16)(_softCopy & 0xf07f)) | (((u16)fieldValue << 0x7) & ~0xf07f);
01233    setRegister(newValue, s);
01234    return *this;
01235 }
01236
01237 inline u16 tTIO::tG0_Input_Select::getG0_Gate_Select(nMDBG::tStatus2*) const
01238 {
01239    return (u16)((_softCopy & ~0xf07f) >> 0x7);
01240 }
01241
01242 inline void tTIO::tG0_Input_Select::writeG0_Gate_Select(u16 fieldValue, nMDBG::tStatus2* s)
01243 {
01244    setG0_Gate_Select(fieldValue, s);
01245    flush(s);
01246 }
01247 inline u16 tTIO::tG0_Input_Select::readG0_Gate_Select(nMDBG::tStatus2* s)
01248 {
01249    return getG0_Gate_Select(s);
01250 }
01251
01252 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setG0_Gate_Select_Load_Source(u16 fieldValue, nMDBG::tStatus2* s)
01253 {
01254    if (s && s->isFatal()) return *this;
01255    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
01256    setRegister(newValue, s);
01257    return *this;
01258 }
01259
01260 inline u16 tTIO::tG0_Input_Select::getG0_Gate_Select_Load_Source(nMDBG::tStatus2*) const
01261 {
01262    return (u16)((_softCopy & ~0xefff) >> 0xc);
01263 }
01264
01265 inline void tTIO::tG0_Input_Select::writeG0_Gate_Select_Load_Source(u16 fieldValue, nMDBG::tStatus2* s)
01266 {
01267    setG0_Gate_Select_Load_Source(fieldValue, s);
01268    flush(s);
01269 }
01270 inline u16 tTIO::tG0_Input_Select::readG0_Gate_Select_Load_Source(nMDBG::tStatus2* s)
01271 {
01272    return getG0_Gate_Select_Load_Source(s);
01273 }
01274
01275 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setG0_OR_Gate(u16 fieldValue, nMDBG::tStatus2* s)
01276 {
01277    if (s && s->isFatal()) return *this;
01278    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
01279    setRegister(newValue, s);
01280    return *this;
01281 }
01282
01283 inline u16 tTIO::tG0_Input_Select::getG0_OR_Gate(nMDBG::tStatus2*) const
01284 {
01285    return (u16)((_softCopy & ~0xdfff) >> 0xd);
01286 }
01287
01288 inline void tTIO::tG0_Input_Select::writeG0_OR_Gate(u16 fieldValue, nMDBG::tStatus2* s)
01289 {
01290    setG0_OR_Gate(fieldValue, s);
01291    flush(s);
01292 }
01293 inline u16 tTIO::tG0_Input_Select::readG0_OR_Gate(nMDBG::tStatus2* s)
01294 {
01295    return getG0_OR_Gate(s);
01296 }
01297
01298 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setG0_Output_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
01299 {
01300    if (s && s->isFatal()) return *this;
01301    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
01302    setRegister(newValue, s);
01303    return *this;
01304 }
01305
01306 inline u16 tTIO::tG0_Input_Select::getG0_Output_Polarity(nMDBG::tStatus2*) const
01307 {
01308    return (u16)((_softCopy & ~0xbfff) >> 0xe);
01309 }
01310
01311 inline void tTIO::tG0_Input_Select::writeG0_Output_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
01312 {
01313    setG0_Output_Polarity(fieldValue, s);
01314    flush(s);
01315 }
01316 inline u16 tTIO::tG0_Input_Select::readG0_Output_Polarity(nMDBG::tStatus2* s)
01317 {
01318    return getG0_Output_Polarity(s);
01319 }
01320
01321 inline tTIO::tG0_Input_Select& tTIO::tG0_Input_Select::setG0_Source_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
01322 {
01323    if (s && s->isFatal()) return *this;
01324    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
01325    setRegister(newValue, s);
01326    return *this;
01327 }
01328
01329 inline u16 tTIO::tG0_Input_Select::getG0_Source_Polarity(nMDBG::tStatus2*) const
01330 {
01331    return (u16)((_softCopy & ~0x7fff) >> 0xf);
01332 }
01333
01334 inline void tTIO::tG0_Input_Select::writeG0_Source_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
01335 {
01336    setG0_Source_Polarity(fieldValue, s);
01337    flush(s);
01338 }
01339 inline u16 tTIO::tG0_Input_Select::readG0_Source_Polarity(nMDBG::tStatus2* s)
01340 {
01341    return getG0_Source_Polarity(s);
01342 }
01343
01344 inline void tTIO::tG0_Input_Select::setRegisterMap(tTIO* pTIO)
01345 {
01346    _TIO = pTIO;
01347 }
01348
01349 inline tTIO::tG0_Load_A::tG0_Load_A()
01350 {
01351    _softCopy = 0;
01352 }
01353
01354 inline tTIO* tTIO::tG0_Load_A::registerMap(void)
01355 {
01356    return _TIO;
01357 }
01358
01359 inline void tTIO::tG0_Load_A::flushBus(nMDBG::tStatus2* s)
01360 {
01361    _TIO->flushBus(s);
01362 }
01363
01364 inline tTIO::tG0_Load_A& tTIO::tG0_Load_A::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
01365 {
01366    if (s && s->isFatal()) return *this;
01367    _softCopy = fieldValue;
01368    return *this;
01369 }
01370
01371 inline u32 tTIO::tG0_Load_A::getRegister(nMDBG::tStatus2*) const
01372 {
01373    return _softCopy;
01374 }
01375
01376 inline void tTIO::tG0_Load_A::flush(nMDBG::tStatus2* s)
01377 {
01378    if (s && s->isFatal()) return;
01379    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
01380    _softCopy &= (u32)(0xffffffff);
01381 }
01382
01383 inline void tTIO::tG0_Load_A::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
01384 {
01385    if (s && s->isFatal()) return;
01386    _softCopy = fieldValue;
01387    flush(s);
01388 }
01389
01390 inline u32 tTIO::tG0_Load_A::readRegister(nMDBG::tStatus2*)
01391 {
01392    return _softCopy;
01393 }
01394
01395
01396 inline tTIO::tG0_Load_A& tTIO::tG0_Load_A::set(u32 fieldValue, nMDBG::tStatus2* s)
01397 {
01398    if (s && s->isFatal()) return *this;
01399    u32 newValue;   newValue = ((u32)(_softCopy & 0x0)) | (((u32)fieldValue << 0x0) & ~0x0);
01400    setRegister(newValue, s);
01401    return *this;
01402 }
01403
01404 inline u32 tTIO::tG0_Load_A::get(nMDBG::tStatus2*) const
01405 {
01406    return (u32)((_softCopy & ~0x0) >> 0x0);
01407 }
01408
01409 inline void tTIO::tG0_Load_A::write(u32 fieldValue, nMDBG::tStatus2* s)
01410 {
01411    set(fieldValue, s);
01412    flush(s);
01413 }
01414 inline u32 tTIO::tG0_Load_A::read(nMDBG::tStatus2* s)
01415 {
01416    return get(s);
01417 }
01418
01419 inline void tTIO::tG0_Load_A::setRegisterMap(tTIO* pTIO)
01420 {
01421    _TIO = pTIO;
01422 }
01423
01424 inline tTIO::tG0_Load_B::tG0_Load_B()
01425 {
01426    _softCopy = 0;
01427 }
01428
01429 inline tTIO* tTIO::tG0_Load_B::registerMap(void)
01430 {
01431    return _TIO;
01432 }
01433
01434 inline void tTIO::tG0_Load_B::flushBus(nMDBG::tStatus2* s)
01435 {
01436    _TIO->flushBus(s);
01437 }
01438
01439 inline tTIO::tG0_Load_B& tTIO::tG0_Load_B::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
01440 {
01441    if (s && s->isFatal()) return *this;
01442    _softCopy = fieldValue;
01443    return *this;
01444 }
01445
01446 inline u32 tTIO::tG0_Load_B::getRegister(nMDBG::tStatus2*) const
01447 {
01448    return _softCopy;
01449 }
01450
01451 inline void tTIO::tG0_Load_B::flush(nMDBG::tStatus2* s)
01452 {
01453    if (s && s->isFatal()) return;
01454    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
01455    _softCopy &= (u32)(0xffffffff);
01456 }
01457
01458 inline void tTIO::tG0_Load_B::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
01459 {
01460    if (s && s->isFatal()) return;
01461    _softCopy = fieldValue;
01462    flush(s);
01463 }
01464
01465 inline u32 tTIO::tG0_Load_B::readRegister(nMDBG::tStatus2*)
01466 {
01467    return _softCopy;
01468 }
01469
01470
01471 inline tTIO::tG0_Load_B& tTIO::tG0_Load_B::set(u32 fieldValue, nMDBG::tStatus2* s)
01472 {
01473    if (s && s->isFatal()) return *this;
01474    u32 newValue;   newValue = ((u32)(_softCopy & 0x0)) | (((u32)fieldValue << 0x0) & ~0x0);
01475    setRegister(newValue, s);
01476    return *this;
01477 }
01478
01479 inline u32 tTIO::tG0_Load_B::get(nMDBG::tStatus2*) const
01480 {
01481    return (u32)((_softCopy & ~0x0) >> 0x0);
01482 }
01483
01484 inline void tTIO::tG0_Load_B::write(u32 fieldValue, nMDBG::tStatus2* s)
01485 {
01486    set(fieldValue, s);
01487    flush(s);
01488 }
01489 inline u32 tTIO::tG0_Load_B::read(nMDBG::tStatus2* s)
01490 {
01491    return get(s);
01492 }
01493
01494 inline void tTIO::tG0_Load_B::setRegisterMap(tTIO* pTIO)
01495 {
01496    _TIO = pTIO;
01497 }
01498
01499 inline tTIO::tG0_Mode::tG0_Mode()
01500 {
01501    _softCopy = 0;
01502 }
01503
01504 inline tTIO* tTIO::tG0_Mode::registerMap(void)
01505 {
01506    return _TIO;
01507 }
01508
01509 inline void tTIO::tG0_Mode::flushBus(nMDBG::tStatus2* s)
01510 {
01511    _TIO->flushBus(s);
01512 }
01513
01514 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
01515 {
01516    if (s && s->isFatal()) return *this;
01517    _softCopy = fieldValue;
01518    return *this;
01519 }
01520
01521 inline u16 tTIO::tG0_Mode::getRegister(nMDBG::tStatus2*) const
01522 {
01523    return _softCopy;
01524 }
01525
01526 inline void tTIO::tG0_Mode::flush(nMDBG::tStatus2* s)
01527 {
01528    if (s && s->isFatal()) return;
01529    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
01530    _softCopy &= (u16)(0xffffffff);
01531 }
01532
01533 inline void tTIO::tG0_Mode::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
01534 {
01535    if (s && s->isFatal()) return;
01536    _softCopy = fieldValue;
01537    flush(s);
01538 }
01539
01540 inline u16 tTIO::tG0_Mode::readRegister(nMDBG::tStatus2*)
01541 {
01542    return _softCopy;
01543 }
01544
01545
01546 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Gating_Mode(tG0_Gating_Mode fieldValue, nMDBG::tStatus2* s)
01547 {
01548    if (s && s->isFatal()) return *this;
01549    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffc)) | (((u16)fieldValue << 0x0) & ~0xfffc);
01550    setRegister(newValue, s);
01551    return *this;
01552 }
01553
01554 inline tTIO::tG0_Mode::tG0_Gating_Mode tTIO::tG0_Mode::getG0_Gating_Mode(nMDBG::tStatus2*) const
01555 {
01556    return (tG0_Gating_Mode)((_softCopy & ~0xfffc) >> 0x0);
01557 }
01558
01559 inline void tTIO::tG0_Mode::writeG0_Gating_Mode(tG0_Gating_Mode fieldValue, nMDBG::tStatus2* s)
01560 {
01561    setG0_Gating_Mode(fieldValue, s);
01562    flush(s);
01563 }
01564 inline tTIO::tG0_Mode::tG0_Gating_Mode tTIO::tG0_Mode::readG0_Gating_Mode(nMDBG::tStatus2* s)
01565 {
01566    return getG0_Gating_Mode(s);
01567 }
01568
01569 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Gate_On_Both_Edges(tG0_Gate_On_Both_Edges fieldValue, nMDBG::tStatus2* s)
01570 {
01571    if (s && s->isFatal()) return *this;
01572    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
01573    setRegister(newValue, s);
01574    return *this;
01575 }
01576
01577 inline tTIO::tG0_Mode::tG0_Gate_On_Both_Edges tTIO::tG0_Mode::getG0_Gate_On_Both_Edges(nMDBG::tStatus2*) const
01578 {
01579    return (tG0_Gate_On_Both_Edges)((_softCopy & ~0xfffb) >> 0x2);
01580 }
01581
01582 inline void tTIO::tG0_Mode::writeG0_Gate_On_Both_Edges(tG0_Gate_On_Both_Edges fieldValue, nMDBG::tStatus2* s)
01583 {
01584    setG0_Gate_On_Both_Edges(fieldValue, s);
01585    flush(s);
01586 }
01587 inline tTIO::tG0_Mode::tG0_Gate_On_Both_Edges tTIO::tG0_Mode::readG0_Gate_On_Both_Edges(nMDBG::tStatus2* s)
01588 {
01589    return getG0_Gate_On_Both_Edges(s);
01590 }
01591
01592 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Trigger_Mode_For_Edge_Gate(tG0_Trigger_Mode_For_Edge_Gate fieldValue, nMDBG::tStatus2* s)
01593 {
01594    if (s && s->isFatal()) return *this;
01595    u16 newValue;   newValue = ((u16)(_softCopy & 0xffe7)) | (((u16)fieldValue << 0x3) & ~0xffe7);
01596    setRegister(newValue, s);
01597    return *this;
01598 }
01599
01600 inline tTIO::tG0_Mode::tG0_Trigger_Mode_For_Edge_Gate tTIO::tG0_Mode::getG0_Trigger_Mode_For_Edge_Gate(nMDBG::tStatus2*) const
01601 {
01602    return (tG0_Trigger_Mode_For_Edge_Gate)((_softCopy & ~0xffe7) >> 0x3);
01603 }
01604
01605 inline void tTIO::tG0_Mode::writeG0_Trigger_Mode_For_Edge_Gate(tG0_Trigger_Mode_For_Edge_Gate fieldValue, nMDBG::tStatus2* s)
01606 {
01607    setG0_Trigger_Mode_For_Edge_Gate(fieldValue, s);
01608    flush(s);
01609 }
01610 inline tTIO::tG0_Mode::tG0_Trigger_Mode_For_Edge_Gate tTIO::tG0_Mode::readG0_Trigger_Mode_For_Edge_Gate(nMDBG::tStatus2* s)
01611 {
01612    return getG0_Trigger_Mode_For_Edge_Gate(s);
01613 }
01614
01615 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Stop_Mode(tG0_Stop_Mode fieldValue, nMDBG::tStatus2* s)
01616 {
01617    if (s && s->isFatal()) return *this;
01618    u16 newValue;   newValue = ((u16)(_softCopy & 0xff9f)) | (((u16)fieldValue << 0x5) & ~0xff9f);
01619    setRegister(newValue, s);
01620    return *this;
01621 }
01622
01623 inline tTIO::tG0_Mode::tG0_Stop_Mode tTIO::tG0_Mode::getG0_Stop_Mode(nMDBG::tStatus2*) const
01624 {
01625    return (tG0_Stop_Mode)((_softCopy & ~0xff9f) >> 0x5);
01626 }
01627
01628 inline void tTIO::tG0_Mode::writeG0_Stop_Mode(tG0_Stop_Mode fieldValue, nMDBG::tStatus2* s)
01629 {
01630    setG0_Stop_Mode(fieldValue, s);
01631    flush(s);
01632 }
01633 inline tTIO::tG0_Mode::tG0_Stop_Mode tTIO::tG0_Mode::readG0_Stop_Mode(nMDBG::tStatus2* s)
01634 {
01635    return getG0_Stop_Mode(s);
01636 }
01637
01638 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Load_Source_Select(tG0_Load_Source_Select fieldValue, nMDBG::tStatus2* s)
01639 {
01640    if (s && s->isFatal()) return *this;
01641    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
01642    setRegister(newValue, s);
01643    return *this;
01644 }
01645
01646 inline tTIO::tG0_Mode::tG0_Load_Source_Select tTIO::tG0_Mode::getG0_Load_Source_Select(nMDBG::tStatus2*) const
01647 {
01648    return (tG0_Load_Source_Select)((_softCopy & ~0xff7f) >> 0x7);
01649 }
01650
01651 inline void tTIO::tG0_Mode::writeG0_Load_Source_Select(tG0_Load_Source_Select fieldValue, nMDBG::tStatus2* s)
01652 {
01653    setG0_Load_Source_Select(fieldValue, s);
01654    flush(s);
01655 }
01656 inline tTIO::tG0_Mode::tG0_Load_Source_Select tTIO::tG0_Mode::readG0_Load_Source_Select(nMDBG::tStatus2* s)
01657 {
01658    return getG0_Load_Source_Select(s);
01659 }
01660
01661 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Output_Mode(tG0_Output_Mode fieldValue, nMDBG::tStatus2* s)
01662 {
01663    if (s && s->isFatal()) return *this;
01664    u16 newValue;   newValue = ((u16)(_softCopy & 0xfcff)) | (((u16)fieldValue << 0x8) & ~0xfcff);
01665    setRegister(newValue, s);
01666    return *this;
01667 }
01668
01669 inline tTIO::tG0_Mode::tG0_Output_Mode tTIO::tG0_Mode::getG0_Output_Mode(nMDBG::tStatus2*) const
01670 {
01671    return (tG0_Output_Mode)((_softCopy & ~0xfcff) >> 0x8);
01672 }
01673
01674 inline void tTIO::tG0_Mode::writeG0_Output_Mode(tG0_Output_Mode fieldValue, nMDBG::tStatus2* s)
01675 {
01676    setG0_Output_Mode(fieldValue, s);
01677    flush(s);
01678 }
01679 inline tTIO::tG0_Mode::tG0_Output_Mode tTIO::tG0_Mode::readG0_Output_Mode(nMDBG::tStatus2* s)
01680 {
01681    return getG0_Output_Mode(s);
01682 }
01683
01684 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Counting_Once(tG0_Counting_Once fieldValue, nMDBG::tStatus2* s)
01685 {
01686    if (s && s->isFatal()) return *this;
01687    u16 newValue;   newValue = ((u16)(_softCopy & 0xf3ff)) | (((u16)fieldValue << 0xa) & ~0xf3ff);
01688    setRegister(newValue, s);
01689    return *this;
01690 }
01691
01692 inline tTIO::tG0_Mode::tG0_Counting_Once tTIO::tG0_Mode::getG0_Counting_Once(nMDBG::tStatus2*) const
01693 {
01694    return (tG0_Counting_Once)((_softCopy & ~0xf3ff) >> 0xa);
01695 }
01696
01697 inline void tTIO::tG0_Mode::writeG0_Counting_Once(tG0_Counting_Once fieldValue, nMDBG::tStatus2* s)
01698 {
01699    setG0_Counting_Once(fieldValue, s);
01700    flush(s);
01701 }
01702 inline tTIO::tG0_Mode::tG0_Counting_Once tTIO::tG0_Mode::readG0_Counting_Once(nMDBG::tStatus2* s)
01703 {
01704    return getG0_Counting_Once(s);
01705 }
01706
01707 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Loading_On_TC(tG0_Loading_On_TC fieldValue, nMDBG::tStatus2* s)
01708 {
01709    if (s && s->isFatal()) return *this;
01710    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
01711    setRegister(newValue, s);
01712    return *this;
01713 }
01714
01715 inline tTIO::tG0_Mode::tG0_Loading_On_TC tTIO::tG0_Mode::getG0_Loading_On_TC(nMDBG::tStatus2*) const
01716 {
01717    return (tG0_Loading_On_TC)((_softCopy & ~0xefff) >> 0xc);
01718 }
01719
01720 inline void tTIO::tG0_Mode::writeG0_Loading_On_TC(tG0_Loading_On_TC fieldValue, nMDBG::tStatus2* s)
01721 {
01722    setG0_Loading_On_TC(fieldValue, s);
01723    flush(s);
01724 }
01725 inline tTIO::tG0_Mode::tG0_Loading_On_TC tTIO::tG0_Mode::readG0_Loading_On_TC(nMDBG::tStatus2* s)
01726 {
01727    return getG0_Loading_On_TC(s);
01728 }
01729
01730 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Gate_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
01731 {
01732    if (s && s->isFatal()) return *this;
01733    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
01734    setRegister(newValue, s);
01735    return *this;
01736 }
01737
01738 inline u16 tTIO::tG0_Mode::getG0_Gate_Polarity(nMDBG::tStatus2*) const
01739 {
01740    return (u16)((_softCopy & ~0xdfff) >> 0xd);
01741 }
01742
01743 inline void tTIO::tG0_Mode::writeG0_Gate_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
01744 {
01745    setG0_Gate_Polarity(fieldValue, s);
01746    flush(s);
01747 }
01748 inline u16 tTIO::tG0_Mode::readG0_Gate_Polarity(nMDBG::tStatus2* s)
01749 {
01750    return getG0_Gate_Polarity(s);
01751 }
01752
01753 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Loading_On_Gate(tG0_Loading_On_Gate fieldValue, nMDBG::tStatus2* s)
01754 {
01755    if (s && s->isFatal()) return *this;
01756    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
01757    setRegister(newValue, s);
01758    return *this;
01759 }
01760
01761 inline tTIO::tG0_Mode::tG0_Loading_On_Gate tTIO::tG0_Mode::getG0_Loading_On_Gate(nMDBG::tStatus2*) const
01762 {
01763    return (tG0_Loading_On_Gate)((_softCopy & ~0xbfff) >> 0xe);
01764 }
01765
01766 inline void tTIO::tG0_Mode::writeG0_Loading_On_Gate(tG0_Loading_On_Gate fieldValue, nMDBG::tStatus2* s)
01767 {
01768    setG0_Loading_On_Gate(fieldValue, s);
01769    flush(s);
01770 }
01771 inline tTIO::tG0_Mode::tG0_Loading_On_Gate tTIO::tG0_Mode::readG0_Loading_On_Gate(nMDBG::tStatus2* s)
01772 {
01773    return getG0_Loading_On_Gate(s);
01774 }
01775
01776 inline tTIO::tG0_Mode& tTIO::tG0_Mode::setG0_Reload_Source_Switching(tG0_Reload_Source_Switching fieldValue, nMDBG::tStatus2* s)
01777 {
01778    if (s && s->isFatal()) return *this;
01779    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
01780    setRegister(newValue, s);
01781    return *this;
01782 }
01783
01784 inline tTIO::tG0_Mode::tG0_Reload_Source_Switching tTIO::tG0_Mode::getG0_Reload_Source_Switching(nMDBG::tStatus2*) const
01785 {
01786    return (tG0_Reload_Source_Switching)((_softCopy & ~0x7fff) >> 0xf);
01787 }
01788
01789 inline void tTIO::tG0_Mode::writeG0_Reload_Source_Switching(tG0_Reload_Source_Switching fieldValue, nMDBG::tStatus2* s)
01790 {
01791    setG0_Reload_Source_Switching(fieldValue, s);
01792    flush(s);
01793 }
01794 inline tTIO::tG0_Mode::tG0_Reload_Source_Switching tTIO::tG0_Mode::readG0_Reload_Source_Switching(nMDBG::tStatus2* s)
01795 {
01796    return getG0_Reload_Source_Switching(s);
01797 }
01798
01799 inline void tTIO::tG0_Mode::setRegisterMap(tTIO* pTIO)
01800 {
01801    _TIO = pTIO;
01802 }
01803
01804 inline tTIO::tG0_Second_Gate::tG0_Second_Gate()
01805 {
01806    _softCopy = 0;
01807 }
01808
01809 inline tTIO* tTIO::tG0_Second_Gate::registerMap(void)
01810 {
01811    return _TIO;
01812 }
01813
01814 inline void tTIO::tG0_Second_Gate::flushBus(nMDBG::tStatus2* s)
01815 {
01816    _TIO->flushBus(s);
01817 }
01818
01819 inline tTIO::tG0_Second_Gate& tTIO::tG0_Second_Gate::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
01820 {
01821    if (s && s->isFatal()) return *this;
01822    _softCopy = fieldValue;
01823    return *this;
01824 }
01825
01826 inline u16 tTIO::tG0_Second_Gate::getRegister(nMDBG::tStatus2*) const
01827 {
01828    return _softCopy;
01829 }
01830
01831 inline void tTIO::tG0_Second_Gate::flush(nMDBG::tStatus2* s)
01832 {
01833    if (s && s->isFatal()) return;
01834    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
01835    _softCopy &= (u16)(0xffffffff);
01836 }
01837
01838 inline void tTIO::tG0_Second_Gate::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
01839 {
01840    if (s && s->isFatal()) return;
01841    _softCopy = fieldValue;
01842    flush(s);
01843 }
01844
01845 inline u16 tTIO::tG0_Second_Gate::readRegister(nMDBG::tStatus2*)
01846 {
01847    return _softCopy;
01848 }
01849
01850
01851 inline tTIO::tG0_Second_Gate& tTIO::tG0_Second_Gate::setG0_Second_Gate_Gating_Mode(u16 fieldValue, nMDBG::tStatus2* s)
01852 {
01853    if (s && s->isFatal()) return *this;
01854    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
01855    setRegister(newValue, s);
01856    return *this;
01857 }
01858
01859 inline u16 tTIO::tG0_Second_Gate::getG0_Second_Gate_Gating_Mode(nMDBG::tStatus2*) const
01860 {
01861    return (u16)((_softCopy & ~0xfffe) >> 0x0);
01862 }
01863
01864 inline void tTIO::tG0_Second_Gate::writeG0_Second_Gate_Gating_Mode(u16 fieldValue, nMDBG::tStatus2* s)
01865 {
01866    setG0_Second_Gate_Gating_Mode(fieldValue, s);
01867    flush(s);
01868 }
01869 inline u16 tTIO::tG0_Second_Gate::readG0_Second_Gate_Gating_Mode(nMDBG::tStatus2* s)
01870 {
01871    return getG0_Second_Gate_Gating_Mode(s);
01872 }
01873
01874 inline tTIO::tG0_Second_Gate& tTIO::tG0_Second_Gate::setG0_Second_Gate_Select(u16 fieldValue, nMDBG::tStatus2* s)
01875 {
01876    if (s && s->isFatal()) return *this;
01877    u16 newValue;   newValue = ((u16)(_softCopy & 0xf07f)) | (((u16)fieldValue << 0x7) & ~0xf07f);
01878    setRegister(newValue, s);
01879    return *this;
01880 }
01881
01882 inline u16 tTIO::tG0_Second_Gate::getG0_Second_Gate_Select(nMDBG::tStatus2*) const
01883 {
01884    return (u16)((_softCopy & ~0xf07f) >> 0x7);
01885 }
01886
01887 inline void tTIO::tG0_Second_Gate::writeG0_Second_Gate_Select(u16 fieldValue, nMDBG::tStatus2* s)
01888 {
01889    setG0_Second_Gate_Select(fieldValue, s);
01890    flush(s);
01891 }
01892 inline u16 tTIO::tG0_Second_Gate::readG0_Second_Gate_Select(nMDBG::tStatus2* s)
01893 {
01894    return getG0_Second_Gate_Select(s);
01895 }
01896
01897 inline tTIO::tG0_Second_Gate& tTIO::tG0_Second_Gate::setG0_Second_Gate_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
01898 {
01899    if (s && s->isFatal()) return *this;
01900    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
01901    setRegister(newValue, s);
01902    return *this;
01903 }
01904
01905 inline u16 tTIO::tG0_Second_Gate::getG0_Second_Gate_Polarity(nMDBG::tStatus2*) const
01906 {
01907    return (u16)((_softCopy & ~0xdfff) >> 0xd);
01908 }
01909
01910 inline void tTIO::tG0_Second_Gate::writeG0_Second_Gate_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
01911 {
01912    setG0_Second_Gate_Polarity(fieldValue, s);
01913    flush(s);
01914 }
01915 inline u16 tTIO::tG0_Second_Gate::readG0_Second_Gate_Polarity(nMDBG::tStatus2* s)
01916 {
01917    return getG0_Second_Gate_Polarity(s);
01918 }
01919
01920 inline tTIO::tG0_Second_Gate& tTIO::tG0_Second_Gate::setG0_MSeries_Second_Gate_SubSelect(u16 fieldValue, nMDBG::tStatus2* s)
01921 {
01922    if (s && s->isFatal()) return *this;
01923    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
01924    setRegister(newValue, s);
01925    return *this;
01926 }
01927
01928 inline u16 tTIO::tG0_Second_Gate::getG0_MSeries_Second_Gate_SubSelect(nMDBG::tStatus2*) const
01929 {
01930    return (u16)((_softCopy & ~0xbfff) >> 0xe);
01931 }
01932
01933 inline void tTIO::tG0_Second_Gate::writeG0_MSeries_Second_Gate_SubSelect(u16 fieldValue, nMDBG::tStatus2* s)
01934 {
01935    setG0_MSeries_Second_Gate_SubSelect(fieldValue, s);
01936    flush(s);
01937 }
01938 inline u16 tTIO::tG0_Second_Gate::readG0_MSeries_Second_Gate_SubSelect(nMDBG::tStatus2* s)
01939 {
01940    return getG0_MSeries_Second_Gate_SubSelect(s);
01941 }
01942
01943 inline tTIO::tG0_Second_Gate& tTIO::tG0_Second_Gate::setG0_MSeries_Source_SubSelect(u16 fieldValue, nMDBG::tStatus2* s)
01944 {
01945    if (s && s->isFatal()) return *this;
01946    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
01947    setRegister(newValue, s);
01948    return *this;
01949 }
01950
01951 inline u16 tTIO::tG0_Second_Gate::getG0_MSeries_Source_SubSelect(nMDBG::tStatus2*) const
01952 {
01953    return (u16)((_softCopy & ~0x7fff) >> 0xf);
01954 }
01955
01956 inline void tTIO::tG0_Second_Gate::writeG0_MSeries_Source_SubSelect(u16 fieldValue, nMDBG::tStatus2* s)
01957 {
01958    setG0_MSeries_Source_SubSelect(fieldValue, s);
01959    flush(s);
01960 }
01961 inline u16 tTIO::tG0_Second_Gate::readG0_MSeries_Source_SubSelect(nMDBG::tStatus2* s)
01962 {
01963    return getG0_MSeries_Source_SubSelect(s);
01964 }
01965
01966 inline void tTIO::tG0_Second_Gate::setRegisterMap(tTIO* pTIO)
01967 {
01968    _TIO = pTIO;
01969 }
01970
01971 inline tTIO::tG0_MSeries_ABZ::tG0_MSeries_ABZ()
01972 {
01973    _softCopy = 0;
01974 }
01975
01976 inline tTIO* tTIO::tG0_MSeries_ABZ::registerMap(void)
01977 {
01978    return _TIO;
01979 }
01980
01981 inline void tTIO::tG0_MSeries_ABZ::flushBus(nMDBG::tStatus2* s)
01982 {
01983    _TIO->flushBus(s);
01984 }
01985
01986 inline tTIO::tG0_MSeries_ABZ& tTIO::tG0_MSeries_ABZ::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
01987 {
01988    if (s && s->isFatal()) return *this;
01989    _softCopy = fieldValue;
01990    return *this;
01991 }
01992
01993 inline u16 tTIO::tG0_MSeries_ABZ::getRegister(nMDBG::tStatus2*) const
01994 {
01995    return _softCopy;
01996 }
01997
01998 inline void tTIO::tG0_MSeries_ABZ::flush(nMDBG::tStatus2* s)
01999 {
02000    if (s && s->isFatal()) return;
02001    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
02002    _softCopy &= (u16)(0xffffffff);
02003 }
02004
02005 inline void tTIO::tG0_MSeries_ABZ::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
02006 {
02007    if (s && s->isFatal()) return;
02008    _softCopy = fieldValue;
02009    flush(s);
02010 }
02011
02012 inline u16 tTIO::tG0_MSeries_ABZ::readRegister(nMDBG::tStatus2*)
02013 {
02014    return _softCopy;
02015 }
02016
02017
02018 inline tTIO::tG0_MSeries_ABZ& tTIO::tG0_MSeries_ABZ::setG0_Z_Select(u16 fieldValue, nMDBG::tStatus2* s)
02019 {
02020    if (s && s->isFatal()) return *this;
02021    u16 newValue;   newValue = ((u16)(_softCopy & 0xffe0)) | (((u16)fieldValue << 0x0) & ~0xffe0);
02022    setRegister(newValue, s);
02023    return *this;
02024 }
02025
02026 inline u16 tTIO::tG0_MSeries_ABZ::getG0_Z_Select(nMDBG::tStatus2*) const
02027 {
02028    return (u16)((_softCopy & ~0xffe0) >> 0x0);
02029 }
02030
02031 inline void tTIO::tG0_MSeries_ABZ::writeG0_Z_Select(u16 fieldValue, nMDBG::tStatus2* s)
02032 {
02033    setG0_Z_Select(fieldValue, s);
02034    flush(s);
02035 }
02036 inline u16 tTIO::tG0_MSeries_ABZ::readG0_Z_Select(nMDBG::tStatus2* s)
02037 {
02038    return getG0_Z_Select(s);
02039 }
02040
02041 inline tTIO::tG0_MSeries_ABZ& tTIO::tG0_MSeries_ABZ::setG0_B_Select(u16 fieldValue, nMDBG::tStatus2* s)
02042 {
02043    if (s && s->isFatal()) return *this;
02044    u16 newValue;   newValue = ((u16)(_softCopy & 0xfc1f)) | (((u16)fieldValue << 0x5) & ~0xfc1f);
02045    setRegister(newValue, s);
02046    return *this;
02047 }
02048
02049 inline u16 tTIO::tG0_MSeries_ABZ::getG0_B_Select(nMDBG::tStatus2*) const
02050 {
02051    return (u16)((_softCopy & ~0xfc1f) >> 0x5);
02052 }
02053
02054 inline void tTIO::tG0_MSeries_ABZ::writeG0_B_Select(u16 fieldValue, nMDBG::tStatus2* s)
02055 {
02056    setG0_B_Select(fieldValue, s);
02057    flush(s);
02058 }
02059 inline u16 tTIO::tG0_MSeries_ABZ::readG0_B_Select(nMDBG::tStatus2* s)
02060 {
02061    return getG0_B_Select(s);
02062 }
02063
02064 inline tTIO::tG0_MSeries_ABZ& tTIO::tG0_MSeries_ABZ::setG0_A_Select(u16 fieldValue, nMDBG::tStatus2* s)
02065 {
02066    if (s && s->isFatal()) return *this;
02067    u16 newValue;   newValue = ((u16)(_softCopy & 0x83ff)) | (((u16)fieldValue << 0xa) & ~0x83ff);
02068    setRegister(newValue, s);
02069    return *this;
02070 }
02071
02072 inline u16 tTIO::tG0_MSeries_ABZ::getG0_A_Select(nMDBG::tStatus2*) const
02073 {
02074    return (u16)((_softCopy & ~0x83ff) >> 0xa);
02075 }
02076
02077 inline void tTIO::tG0_MSeries_ABZ::writeG0_A_Select(u16 fieldValue, nMDBG::tStatus2* s)
02078 {
02079    setG0_A_Select(fieldValue, s);
02080    flush(s);
02081 }
02082 inline u16 tTIO::tG0_MSeries_ABZ::readG0_A_Select(nMDBG::tStatus2* s)
02083 {
02084    return getG0_A_Select(s);
02085 }
02086
02087 inline void tTIO::tG0_MSeries_ABZ::setRegisterMap(tTIO* pTIO)
02088 {
02089    _TIO = pTIO;
02090 }
02091
02092 inline tTIO::tG01_Joint_Reset::tG01_Joint_Reset()
02093 {
02094    _softCopy = 0;
02095 }
02096
02097 inline tTIO* tTIO::tG01_Joint_Reset::registerMap(void)
02098 {
02099    return _TIO;
02100 }
02101
02102 inline void tTIO::tG01_Joint_Reset::flushBus(nMDBG::tStatus2* s)
02103 {
02104    _TIO->flushBus(s);
02105 }
02106
02107 inline tTIO::tG01_Joint_Reset& tTIO::tG01_Joint_Reset::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
02108 {
02109    if (s && s->isFatal()) return *this;
02110    _softCopy = fieldValue;
02111    return *this;
02112 }
02113
02114 inline u16 tTIO::tG01_Joint_Reset::getRegister(nMDBG::tStatus2*) const
02115 {
02116    return _softCopy;
02117 }
02118
02119 inline void tTIO::tG01_Joint_Reset::flush(nMDBG::tStatus2* s)
02120 {
02121    if (s && s->isFatal()) return;
02122    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
02123    _softCopy &= (u16)(0xfffffff3);
02124 }
02125
02126 inline void tTIO::tG01_Joint_Reset::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
02127 {
02128    if (s && s->isFatal()) return;
02129    _softCopy = fieldValue;
02130    flush(s);
02131 }
02132
02133 inline u16 tTIO::tG01_Joint_Reset::readRegister(nMDBG::tStatus2*)
02134 {
02135    return _softCopy;
02136 }
02137
02138
02139 inline tTIO::tG01_Joint_Reset& tTIO::tG01_Joint_Reset::setG0_Reset(u16 fieldValue, nMDBG::tStatus2* s)
02140 {
02141    if (s && s->isFatal()) return *this;
02142    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
02143    setRegister(newValue, s);
02144    return *this;
02145 }
02146
02147 inline u16 tTIO::tG01_Joint_Reset::getG0_Reset(nMDBG::tStatus2*) const
02148 {
02149    return (u16)((_softCopy & ~0xfffb) >> 0x2);
02150 }
02151
02152 inline void tTIO::tG01_Joint_Reset::writeG0_Reset(u16 fieldValue, nMDBG::tStatus2* s)
02153 {
02154    setG0_Reset(fieldValue, s);
02155    flush(s);
02156 }
02157 inline u16 tTIO::tG01_Joint_Reset::readG0_Reset(nMDBG::tStatus2* s)
02158 {
02159    return getG0_Reset(s);
02160 }
02161
02162 inline tTIO::tG01_Joint_Reset& tTIO::tG01_Joint_Reset::setG1_Reset(u16 fieldValue, nMDBG::tStatus2* s)
02163 {
02164    if (s && s->isFatal()) return *this;
02165    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff7)) | (((u16)fieldValue << 0x3) & ~0xfff7);
02166    setRegister(newValue, s);
02167    return *this;
02168 }
02169
02170 inline u16 tTIO::tG01_Joint_Reset::getG1_Reset(nMDBG::tStatus2*) const
02171 {
02172    return (u16)((_softCopy & ~0xfff7) >> 0x3);
02173 }
02174
02175 inline void tTIO::tG01_Joint_Reset::writeG1_Reset(u16 fieldValue, nMDBG::tStatus2* s)
02176 {
02177    setG1_Reset(fieldValue, s);
02178    flush(s);
02179 }
02180 inline u16 tTIO::tG01_Joint_Reset::readG1_Reset(nMDBG::tStatus2* s)
02181 {
02182    return getG1_Reset(s);
02183 }
02184
02185 inline void tTIO::tG01_Joint_Reset::setRegisterMap(tTIO* pTIO)
02186 {
02187    _TIO = pTIO;
02188 }
02189
02190 inline tTIO::tG1_AutoIncrement::tG1_AutoIncrement()
02191 {
02192    _softCopy = 0;
02193 }
02194
02195 inline tTIO* tTIO::tG1_AutoIncrement::registerMap(void)
02196 {
02197    return _TIO;
02198 }
02199
02200 inline void tTIO::tG1_AutoIncrement::flushBus(nMDBG::tStatus2* s)
02201 {
02202    _TIO->flushBus(s);
02203 }
02204
02205 inline tTIO::tG1_AutoIncrement& tTIO::tG1_AutoIncrement::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
02206 {
02207    if (s && s->isFatal()) return *this;
02208    _softCopy = fieldValue;
02209    return *this;
02210 }
02211
02212 inline u16 tTIO::tG1_AutoIncrement::getRegister(nMDBG::tStatus2*) const
02213 {
02214    return _softCopy;
02215 }
02216
02217 inline void tTIO::tG1_AutoIncrement::flush(nMDBG::tStatus2* s)
02218 {
02219    if (s && s->isFatal()) return;
02220    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
02221    _softCopy &= (u16)(0xffffffff);
02222 }
02223
02224 inline void tTIO::tG1_AutoIncrement::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
02225 {
02226    if (s && s->isFatal()) return;
02227    _softCopy = fieldValue;
02228    flush(s);
02229 }
02230
02231 inline u16 tTIO::tG1_AutoIncrement::readRegister(nMDBG::tStatus2*)
02232 {
02233    return _softCopy;
02234 }
02235
02236
02237 inline tTIO::tG1_AutoIncrement& tTIO::tG1_AutoIncrement::set(u16 fieldValue, nMDBG::tStatus2* s)
02238 {
02239    if (s && s->isFatal()) return *this;
02240    u16 newValue;   newValue = ((u16)(_softCopy & 0xff00)) | (((u16)fieldValue << 0x0) & ~0xff00);
02241    setRegister(newValue, s);
02242    return *this;
02243 }
02244
02245 inline u16 tTIO::tG1_AutoIncrement::get(nMDBG::tStatus2*) const
02246 {
02247    return (u16)((_softCopy & ~0xff00) >> 0x0);
02248 }
02249
02250 inline void tTIO::tG1_AutoIncrement::write(u16 fieldValue, nMDBG::tStatus2* s)
02251 {
02252    set(fieldValue, s);
02253    flush(s);
02254 }
02255 inline u16 tTIO::tG1_AutoIncrement::read(nMDBG::tStatus2* s)
02256 {
02257    return get(s);
02258 }
02259
02260 inline void tTIO::tG1_AutoIncrement::setRegisterMap(tTIO* pTIO)
02261 {
02262    _TIO = pTIO;
02263 }
02264
02265 inline tTIO::tG1_Command::tG1_Command()
02266 {
02267    _softCopy = 0;
02268 }
02269
02270 inline tTIO* tTIO::tG1_Command::registerMap(void)
02271 {
02272    return _TIO;
02273 }
02274
02275 inline void tTIO::tG1_Command::flushBus(nMDBG::tStatus2* s)
02276 {
02277    _TIO->flushBus(s);
02278 }
02279
02280 inline tTIO::tG1_Command& tTIO::tG1_Command::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
02281 {
02282    if (s && s->isFatal()) return *this;
02283    _softCopy = fieldValue;
02284    return *this;
02285 }
02286
02287 inline u16 tTIO::tG1_Command::getRegister(nMDBG::tStatus2*) const
02288 {
02289    return _softCopy;
02290 }
02291
02292 inline void tTIO::tG1_Command::flush(nMDBG::tStatus2* s)
02293 {
02294    if (s && s->isFatal()) return;
02295    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
02296    _softCopy &= (u16)(0xffff5bea);
02297 }
02298
02299 inline void tTIO::tG1_Command::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
02300 {
02301    if (s && s->isFatal()) return;
02302    _softCopy = fieldValue;
02303    flush(s);
02304 }
02305
02306 inline u16 tTIO::tG1_Command::readRegister(nMDBG::tStatus2*)
02307 {
02308    return _softCopy;
02309 }
02310
02311
02312 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Arm(u16 fieldValue, nMDBG::tStatus2* s)
02313 {
02314    if (s && s->isFatal()) return *this;
02315    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
02316    setRegister(newValue, s);
02317    return *this;
02318 }
02319
02320 inline u16 tTIO::tG1_Command::getG1_Arm(nMDBG::tStatus2*) const
02321 {
02322    return (u16)((_softCopy & ~0xfffe) >> 0x0);
02323 }
02324
02325 inline void tTIO::tG1_Command::writeG1_Arm(u16 fieldValue, nMDBG::tStatus2* s)
02326 {
02327    setG1_Arm(fieldValue, s);
02328    flush(s);
02329 }
02330 inline u16 tTIO::tG1_Command::readG1_Arm(nMDBG::tStatus2* s)
02331 {
02332    return getG1_Arm(s);
02333 }
02334
02335 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Save_Trace(u16 fieldValue, nMDBG::tStatus2* s)
02336 {
02337    if (s && s->isFatal()) return *this;
02338    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
02339    setRegister(newValue, s);
02340    return *this;
02341 }
02342
02343 inline u16 tTIO::tG1_Command::getG1_Save_Trace(nMDBG::tStatus2*) const
02344 {
02345    return (u16)((_softCopy & ~0xfffd) >> 0x1);
02346 }
02347
02348 inline void tTIO::tG1_Command::writeG1_Save_Trace(u16 fieldValue, nMDBG::tStatus2* s)
02349 {
02350    setG1_Save_Trace(fieldValue, s);
02351    flush(s);
02352 }
02353 inline u16 tTIO::tG1_Command::readG1_Save_Trace(nMDBG::tStatus2* s)
02354 {
02355    return getG1_Save_Trace(s);
02356 }
02357
02358 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Load(u16 fieldValue, nMDBG::tStatus2* s)
02359 {
02360    if (s && s->isFatal()) return *this;
02361    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
02362    setRegister(newValue, s);
02363    return *this;
02364 }
02365
02366 inline u16 tTIO::tG1_Command::getG1_Load(nMDBG::tStatus2*) const
02367 {
02368    return (u16)((_softCopy & ~0xfffb) >> 0x2);
02369 }
02370
02371 inline void tTIO::tG1_Command::writeG1_Load(u16 fieldValue, nMDBG::tStatus2* s)
02372 {
02373    setG1_Load(fieldValue, s);
02374    flush(s);
02375 }
02376 inline u16 tTIO::tG1_Command::readG1_Load(nMDBG::tStatus2* s)
02377 {
02378    return getG1_Load(s);
02379 }
02380
02381 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Disarm(u16 fieldValue, nMDBG::tStatus2* s)
02382 {
02383    if (s && s->isFatal()) return *this;
02384    u16 newValue;   newValue = ((u16)(_softCopy & 0xffef)) | (((u16)fieldValue << 0x4) & ~0xffef);
02385    setRegister(newValue, s);
02386    return *this;
02387 }
02388
02389 inline u16 tTIO::tG1_Command::getG1_Disarm(nMDBG::tStatus2*) const
02390 {
02391    return (u16)((_softCopy & ~0xffef) >> 0x4);
02392 }
02393
02394 inline void tTIO::tG1_Command::writeG1_Disarm(u16 fieldValue, nMDBG::tStatus2* s)
02395 {
02396    setG1_Disarm(fieldValue, s);
02397    flush(s);
02398 }
02399 inline u16 tTIO::tG1_Command::readG1_Disarm(nMDBG::tStatus2* s)
02400 {
02401    return getG1_Disarm(s);
02402 }
02403
02404 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Up_Down(tG1_Up_Down fieldValue, nMDBG::tStatus2* s)
02405 {
02406    if (s && s->isFatal()) return *this;
02407    u16 newValue;   newValue = ((u16)(_softCopy & 0xff9f)) | (((u16)fieldValue << 0x5) & ~0xff9f);
02408    setRegister(newValue, s);
02409    return *this;
02410 }
02411
02412 inline tTIO::tG1_Command::tG1_Up_Down tTIO::tG1_Command::getG1_Up_Down(nMDBG::tStatus2*) const
02413 {
02414    return (tG1_Up_Down)((_softCopy & ~0xff9f) >> 0x5);
02415 }
02416
02417 inline void tTIO::tG1_Command::writeG1_Up_Down(tG1_Up_Down fieldValue, nMDBG::tStatus2* s)
02418 {
02419    setG1_Up_Down(fieldValue, s);
02420    flush(s);
02421 }
02422 inline tTIO::tG1_Command::tG1_Up_Down tTIO::tG1_Command::readG1_Up_Down(nMDBG::tStatus2* s)
02423 {
02424    return getG1_Up_Down(s);
02425 }
02426
02427 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Write_Switch(tG1_Write_Switch fieldValue, nMDBG::tStatus2* s)
02428 {
02429    if (s && s->isFatal()) return *this;
02430    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
02431    setRegister(newValue, s);
02432    return *this;
02433 }
02434
02435 inline tTIO::tG1_Command::tG1_Write_Switch tTIO::tG1_Command::getG1_Write_Switch(nMDBG::tStatus2*) const
02436 {
02437    return (tG1_Write_Switch)((_softCopy & ~0xff7f) >> 0x7);
02438 }
02439
02440 inline void tTIO::tG1_Command::writeG1_Write_Switch(tG1_Write_Switch fieldValue, nMDBG::tStatus2* s)
02441 {
02442    setG1_Write_Switch(fieldValue, s);
02443    flush(s);
02444 }
02445 inline tTIO::tG1_Command::tG1_Write_Switch tTIO::tG1_Command::readG1_Write_Switch(nMDBG::tStatus2* s)
02446 {
02447    return getG1_Write_Switch(s);
02448 }
02449
02450 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Synchronized_Gate(tG1_Synchronized_Gate fieldValue, nMDBG::tStatus2* s)
02451 {
02452    if (s && s->isFatal()) return *this;
02453    u16 newValue;   newValue = ((u16)(_softCopy & 0xfeff)) | (((u16)fieldValue << 0x8) & ~0xfeff);
02454    setRegister(newValue, s);
02455    return *this;
02456 }
02457
02458 inline tTIO::tG1_Command::tG1_Synchronized_Gate tTIO::tG1_Command::getG1_Synchronized_Gate(nMDBG::tStatus2*) const
02459 {
02460    return (tG1_Synchronized_Gate)((_softCopy & ~0xfeff) >> 0x8);
02461 }
02462
02463 inline void tTIO::tG1_Command::writeG1_Synchronized_Gate(tG1_Synchronized_Gate fieldValue, nMDBG::tStatus2* s)
02464 {
02465    setG1_Synchronized_Gate(fieldValue, s);
02466    flush(s);
02467 }
02468 inline tTIO::tG1_Command::tG1_Synchronized_Gate tTIO::tG1_Command::readG1_Synchronized_Gate(nMDBG::tStatus2* s)
02469 {
02470    return getG1_Synchronized_Gate(s);
02471 }
02472
02473 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Little_Big_Endian(tG1_Little_Big_Endian fieldValue, nMDBG::tStatus2* s)
02474 {
02475    if (s && s->isFatal()) return *this;
02476    u16 newValue;   newValue = ((u16)(_softCopy & 0xfdff)) | (((u16)fieldValue << 0x9) & ~0xfdff);
02477    setRegister(newValue, s);
02478    return *this;
02479 }
02480
02481 inline tTIO::tG1_Command::tG1_Little_Big_Endian tTIO::tG1_Command::getG1_Little_Big_Endian(nMDBG::tStatus2*) const
02482 {
02483    return (tG1_Little_Big_Endian)((_softCopy & ~0xfdff) >> 0x9);
02484 }
02485
02486 inline void tTIO::tG1_Command::writeG1_Little_Big_Endian(tG1_Little_Big_Endian fieldValue, nMDBG::tStatus2* s)
02487 {
02488    setG1_Little_Big_Endian(fieldValue, s);
02489    flush(s);
02490 }
02491 inline tTIO::tG1_Command::tG1_Little_Big_Endian tTIO::tG1_Command::readG1_Little_Big_Endian(nMDBG::tStatus2* s)
02492 {
02493    return getG1_Little_Big_Endian(s);
02494 }
02495
02496 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Bank_Switch_Start(u16 fieldValue, nMDBG::tStatus2* s)
02497 {
02498    if (s && s->isFatal()) return *this;
02499    u16 newValue;   newValue = ((u16)(_softCopy & 0xfbff)) | (((u16)fieldValue << 0xa) & ~0xfbff);
02500    setRegister(newValue, s);
02501    return *this;
02502 }
02503
02504 inline u16 tTIO::tG1_Command::getG1_Bank_Switch_Start(nMDBG::tStatus2*) const
02505 {
02506    return (u16)((_softCopy & ~0xfbff) >> 0xa);
02507 }
02508
02509 inline void tTIO::tG1_Command::writeG1_Bank_Switch_Start(u16 fieldValue, nMDBG::tStatus2* s)
02510 {
02511    setG1_Bank_Switch_Start(fieldValue, s);
02512    flush(s);
02513 }
02514 inline u16 tTIO::tG1_Command::readG1_Bank_Switch_Start(nMDBG::tStatus2* s)
02515 {
02516    return getG1_Bank_Switch_Start(s);
02517 }
02518
02519 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Bank_Switch_Mode(tG1_Bank_Switch_Mode fieldValue, nMDBG::tStatus2* s)
02520 {
02521    if (s && s->isFatal()) return *this;
02522    u16 newValue;   newValue = ((u16)(_softCopy & 0xf7ff)) | (((u16)fieldValue << 0xb) & ~0xf7ff);
02523    setRegister(newValue, s);
02524    return *this;
02525 }
02526
02527 inline tTIO::tG1_Command::tG1_Bank_Switch_Mode tTIO::tG1_Command::getG1_Bank_Switch_Mode(nMDBG::tStatus2*) const
02528 {
02529    return (tG1_Bank_Switch_Mode)((_softCopy & ~0xf7ff) >> 0xb);
02530 }
02531
02532 inline void tTIO::tG1_Command::writeG1_Bank_Switch_Mode(tG1_Bank_Switch_Mode fieldValue, nMDBG::tStatus2* s)
02533 {
02534    setG1_Bank_Switch_Mode(fieldValue, s);
02535    flush(s);
02536 }
02537 inline tTIO::tG1_Command::tG1_Bank_Switch_Mode tTIO::tG1_Command::readG1_Bank_Switch_Mode(nMDBG::tStatus2* s)
02538 {
02539    return getG1_Bank_Switch_Mode(s);
02540 }
02541
02542 inline tTIO::tG1_Command& tTIO::tG1_Command::setG1_Bank_Switch_Enable(tG1_Bank_Switch_Enable fieldValue, nMDBG::tStatus2* s)
02543 {
02544    if (s && s->isFatal()) return *this;
02545    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
02546    setRegister(newValue, s);
02547    return *this;
02548 }
02549
02550 inline tTIO::tG1_Command::tG1_Bank_Switch_Enable tTIO::tG1_Command::getG1_Bank_Switch_Enable(nMDBG::tStatus2*) const
02551 {
02552    return (tG1_Bank_Switch_Enable)((_softCopy & ~0xefff) >> 0xc);
02553 }
02554
02555 inline void tTIO::tG1_Command::writeG1_Bank_Switch_Enable(tG1_Bank_Switch_Enable fieldValue, nMDBG::tStatus2* s)
02556 {
02557    setG1_Bank_Switch_Enable(fieldValue, s);
02558    flush(s);
02559 }
02560 inline tTIO::tG1_Command::tG1_Bank_Switch_Enable tTIO::tG1_Command::readG1_Bank_Switch_Enable(nMDBG::tStatus2* s)
02561 {
02562    return getG1_Bank_Switch_Enable(s);
02563 }
02564
02565 inline tTIO::tG1_Command& tTIO::tG1_Command::setG0_Arm_Copy(u16 fieldValue, nMDBG::tStatus2* s)
02566 {
02567    if (s && s->isFatal()) return *this;
02568    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
02569    setRegister(newValue, s);
02570    return *this;
02571 }
02572
02573 inline u16 tTIO::tG1_Command::getG0_Arm_Copy(nMDBG::tStatus2*) const
02574 {
02575    return (u16)((_softCopy & ~0xdfff) >> 0xd);
02576 }
02577
02578 inline void tTIO::tG1_Command::writeG0_Arm_Copy(u16 fieldValue, nMDBG::tStatus2* s)
02579 {
02580    setG0_Arm_Copy(fieldValue, s);
02581    flush(s);
02582 }
02583 inline u16 tTIO::tG1_Command::readG0_Arm_Copy(nMDBG::tStatus2* s)
02584 {
02585    return getG0_Arm_Copy(s);
02586 }
02587
02588 inline tTIO::tG1_Command& tTIO::tG1_Command::setG0_Save_Trace_Copy(u16 fieldValue, nMDBG::tStatus2* s)
02589 {
02590    if (s && s->isFatal()) return *this;
02591    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
02592    setRegister(newValue, s);
02593    return *this;
02594 }
02595
02596 inline u16 tTIO::tG1_Command::getG0_Save_Trace_Copy(nMDBG::tStatus2*) const
02597 {
02598    return (u16)((_softCopy & ~0xbfff) >> 0xe);
02599 }
02600
02601 inline void tTIO::tG1_Command::writeG0_Save_Trace_Copy(u16 fieldValue, nMDBG::tStatus2* s)
02602 {
02603    setG0_Save_Trace_Copy(fieldValue, s);
02604    flush(s);
02605 }
02606 inline u16 tTIO::tG1_Command::readG0_Save_Trace_Copy(nMDBG::tStatus2* s)
02607 {
02608    return getG0_Save_Trace_Copy(s);
02609 }
02610
02611 inline tTIO::tG1_Command& tTIO::tG1_Command::setG0_Disarm_Copy(u16 fieldValue, nMDBG::tStatus2* s)
02612 {
02613    if (s && s->isFatal()) return *this;
02614    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
02615    setRegister(newValue, s);
02616    return *this;
02617 }
02618
02619 inline u16 tTIO::tG1_Command::getG0_Disarm_Copy(nMDBG::tStatus2*) const
02620 {
02621    return (u16)((_softCopy & ~0x7fff) >> 0xf);
02622 }
02623
02624 inline void tTIO::tG1_Command::writeG0_Disarm_Copy(u16 fieldValue, nMDBG::tStatus2* s)
02625 {
02626    setG0_Disarm_Copy(fieldValue, s);
02627    flush(s);
02628 }
02629 inline u16 tTIO::tG1_Command::readG0_Disarm_Copy(nMDBG::tStatus2* s)
02630 {
02631    return getG0_Disarm_Copy(s);
02632 }
02633
02634 inline void tTIO::tG1_Command::setRegisterMap(tTIO* pTIO)
02635 {
02636    _TIO = pTIO;
02637 }
02638
02639 inline tTIO::tG1_Counting_Mode::tG1_Counting_Mode()
02640 {
02641    _softCopy = 0;
02642 }
02643
02644 inline tTIO* tTIO::tG1_Counting_Mode::registerMap(void)
02645 {
02646    return _TIO;
02647 }
02648
02649 inline void tTIO::tG1_Counting_Mode::flushBus(nMDBG::tStatus2* s)
02650 {
02651    _TIO->flushBus(s);
02652 }
02653
02654 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
02655 {
02656    if (s && s->isFatal()) return *this;
02657    _softCopy = fieldValue;
02658    return *this;
02659 }
02660
02661 inline u16 tTIO::tG1_Counting_Mode::getRegister(nMDBG::tStatus2*) const
02662 {
02663    return _softCopy;
02664 }
02665
02666 inline void tTIO::tG1_Counting_Mode::flush(nMDBG::tStatus2* s)
02667 {
02668    if (s && s->isFatal()) return;
02669    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
02670    _softCopy &= (u16)(0xffffffff);
02671 }
02672
02673 inline void tTIO::tG1_Counting_Mode::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
02674 {
02675    if (s && s->isFatal()) return;
02676    _softCopy = fieldValue;
02677    flush(s);
02678 }
02679
02680 inline u16 tTIO::tG1_Counting_Mode::readRegister(nMDBG::tStatus2*)
02681 {
02682    return _softCopy;
02683 }
02684
02685
02686 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setG1_Encoder_Counting_Mode(u16 fieldValue, nMDBG::tStatus2* s)
02687 {
02688    if (s && s->isFatal()) return *this;
02689    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff8)) | (((u16)fieldValue << 0x0) & ~0xfff8);
02690    setRegister(newValue, s);
02691    return *this;
02692 }
02693
02694 inline u16 tTIO::tG1_Counting_Mode::getG1_Encoder_Counting_Mode(nMDBG::tStatus2*) const
02695 {
02696    return (u16)((_softCopy & ~0xfff8) >> 0x0);
02697 }
02698
02699 inline void tTIO::tG1_Counting_Mode::writeG1_Encoder_Counting_Mode(u16 fieldValue, nMDBG::tStatus2* s)
02700 {
02701    setG1_Encoder_Counting_Mode(fieldValue, s);
02702    flush(s);
02703 }
02704 inline u16 tTIO::tG1_Counting_Mode::readG1_Encoder_Counting_Mode(nMDBG::tStatus2* s)
02705 {
02706    return getG1_Encoder_Counting_Mode(s);
02707 }
02708
02709 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setG1_Index_Enable(u16 fieldValue, nMDBG::tStatus2* s)
02710 {
02711    if (s && s->isFatal()) return *this;
02712    u16 newValue;   newValue = ((u16)(_softCopy & 0xffef)) | (((u16)fieldValue << 0x4) & ~0xffef);
02713    setRegister(newValue, s);
02714    return *this;
02715 }
02716
02717 inline u16 tTIO::tG1_Counting_Mode::getG1_Index_Enable(nMDBG::tStatus2*) const
02718 {
02719    return (u16)((_softCopy & ~0xffef) >> 0x4);
02720 }
02721
02722 inline void tTIO::tG1_Counting_Mode::writeG1_Index_Enable(u16 fieldValue, nMDBG::tStatus2* s)
02723 {
02724    setG1_Index_Enable(fieldValue, s);
02725    flush(s);
02726 }
02727 inline u16 tTIO::tG1_Counting_Mode::readG1_Index_Enable(nMDBG::tStatus2* s)
02728 {
02729    return getG1_Index_Enable(s);
02730 }
02731
02732 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setG1_Index_Phase(u16 fieldValue, nMDBG::tStatus2* s)
02733 {
02734    if (s && s->isFatal()) return *this;
02735    u16 newValue;   newValue = ((u16)(_softCopy & 0xff9f)) | (((u16)fieldValue << 0x5) & ~0xff9f);
02736    setRegister(newValue, s);
02737    return *this;
02738 }
02739
02740 inline u16 tTIO::tG1_Counting_Mode::getG1_Index_Phase(nMDBG::tStatus2*) const
02741 {
02742    return (u16)((_softCopy & ~0xff9f) >> 0x5);
02743 }
02744
02745 inline void tTIO::tG1_Counting_Mode::writeG1_Index_Phase(u16 fieldValue, nMDBG::tStatus2* s)
02746 {
02747    setG1_Index_Phase(fieldValue, s);
02748    flush(s);
02749 }
02750 inline u16 tTIO::tG1_Counting_Mode::readG1_Index_Phase(nMDBG::tStatus2* s)
02751 {
02752    return getG1_Index_Phase(s);
02753 }
02754
02755 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setG1_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s)
02756 {
02757    if (s && s->isFatal()) return *this;
02758    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
02759    setRegister(newValue, s);
02760    return *this;
02761 }
02762
02763 inline u16 tTIO::tG1_Counting_Mode::getG1_HW_Arm_Enable(nMDBG::tStatus2*) const
02764 {
02765    return (u16)((_softCopy & ~0xff7f) >> 0x7);
02766 }
02767
02768 inline void tTIO::tG1_Counting_Mode::writeG1_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s)
02769 {
02770    setG1_HW_Arm_Enable(fieldValue, s);
02771    flush(s);
02772 }
02773 inline u16 tTIO::tG1_Counting_Mode::readG1_HW_Arm_Enable(nMDBG::tStatus2* s)
02774 {
02775    return getG1_HW_Arm_Enable(s);
02776 }
02777
02778 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setG1_HW_Arm_Select(u16 fieldValue, nMDBG::tStatus2* s)
02779 {
02780    if (s && s->isFatal()) return *this;
02781    u16 newValue;   newValue = ((u16)(_softCopy & 0xf8ff)) | (((u16)fieldValue << 0x8) & ~0xf8ff);
02782    setRegister(newValue, s);
02783    return *this;
02784 }
02785
02786 inline u16 tTIO::tG1_Counting_Mode::getG1_HW_Arm_Select(nMDBG::tStatus2*) const
02787 {
02788    return (u16)((_softCopy & ~0xf8ff) >> 0x8);
02789 }
02790
02791 inline void tTIO::tG1_Counting_Mode::writeG1_HW_Arm_Select(u16 fieldValue, nMDBG::tStatus2* s)
02792 {
02793    setG1_HW_Arm_Select(fieldValue, s);
02794    flush(s);
02795 }
02796 inline u16 tTIO::tG1_Counting_Mode::readG1_HW_Arm_Select(nMDBG::tStatus2* s)
02797 {
02798    return getG1_HW_Arm_Select(s);
02799 }
02800
02801 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setG1_Prescale(u16 fieldValue, nMDBG::tStatus2* s)
02802 {
02803    if (s && s->isFatal()) return *this;
02804    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
02805    setRegister(newValue, s);
02806    return *this;
02807 }
02808
02809 inline u16 tTIO::tG1_Counting_Mode::getG1_Prescale(nMDBG::tStatus2*) const
02810 {
02811    return (u16)((_softCopy & ~0xefff) >> 0xc);
02812 }
02813
02814 inline void tTIO::tG1_Counting_Mode::writeG1_Prescale(u16 fieldValue, nMDBG::tStatus2* s)
02815 {
02816    setG1_Prescale(fieldValue, s);
02817    flush(s);
02818 }
02819 inline u16 tTIO::tG1_Counting_Mode::readG1_Prescale(nMDBG::tStatus2* s)
02820 {
02821    return getG1_Prescale(s);
02822 }
02823
02824 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setG1_Alternate_Synchronization(u16 fieldValue, nMDBG::tStatus2* s)
02825 {
02826    if (s && s->isFatal()) return *this;
02827    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
02828    setRegister(newValue, s);
02829    return *this;
02830 }
02831
02832 inline u16 tTIO::tG1_Counting_Mode::getG1_Alternate_Synchronization(nMDBG::tStatus2*) const
02833 {
02834    return (u16)((_softCopy & ~0xdfff) >> 0xd);
02835 }
02836
02837 inline void tTIO::tG1_Counting_Mode::writeG1_Alternate_Synchronization(u16 fieldValue, nMDBG::tStatus2* s)
02838 {
02839    setG1_Alternate_Synchronization(fieldValue, s);
02840    flush(s);
02841 }
02842 inline u16 tTIO::tG1_Counting_Mode::readG1_Alternate_Synchronization(nMDBG::tStatus2* s)
02843 {
02844    return getG1_Alternate_Synchronization(s);
02845 }
02846
02847 inline tTIO::tG1_Counting_Mode& tTIO::tG1_Counting_Mode::setG1_Prescale_By_2(u16 fieldValue, nMDBG::tStatus2* s)
02848 {
02849    if (s && s->isFatal()) return *this;
02850    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
02851    setRegister(newValue, s);
02852    return *this;
02853 }
02854
02855 inline u16 tTIO::tG1_Counting_Mode::getG1_Prescale_By_2(nMDBG::tStatus2*) const
02856 {
02857    return (u16)((_softCopy & ~0xbfff) >> 0xe);
02858 }
02859
02860 inline void tTIO::tG1_Counting_Mode::writeG1_Prescale_By_2(u16 fieldValue, nMDBG::tStatus2* s)
02861 {
02862    setG1_Prescale_By_2(fieldValue, s);
02863    flush(s);
02864 }
02865 inline u16 tTIO::tG1_Counting_Mode::readG1_Prescale_By_2(nMDBG::tStatus2* s)
02866 {
02867    return getG1_Prescale_By_2(s);
02868 }
02869
02870 inline void tTIO::tG1_Counting_Mode::setRegisterMap(tTIO* pTIO)
02871 {
02872    _TIO = pTIO;
02873 }
02874
02875 inline tTIO::tG1_MSeries_Counting_Mode::tG1_MSeries_Counting_Mode()
02876 {
02877    _softCopy = 0;
02878 }
02879
02880 inline tTIO* tTIO::tG1_MSeries_Counting_Mode::registerMap(void)
02881 {
02882    return _TIO;
02883 }
02884
02885 inline void tTIO::tG1_MSeries_Counting_Mode::flushBus(nMDBG::tStatus2* s)
02886 {
02887    _TIO->flushBus(s);
02888 }
02889
02890 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
02891 {
02892    if (s && s->isFatal()) return *this;
02893    _softCopy = fieldValue;
02894    return *this;
02895 }
02896
02897 inline u16 tTIO::tG1_MSeries_Counting_Mode::getRegister(nMDBG::tStatus2*) const
02898 {
02899    return _softCopy;
02900 }
02901
02902 inline void tTIO::tG1_MSeries_Counting_Mode::flush(nMDBG::tStatus2* s)
02903 {
02904    if (s && s->isFatal()) return;
02905    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
02906    _softCopy &= (u16)(0xffffffff);
02907 }
02908
02909 inline void tTIO::tG1_MSeries_Counting_Mode::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
02910 {
02911    if (s && s->isFatal()) return;
02912    _softCopy = fieldValue;
02913    flush(s);
02914 }
02915
02916 inline u16 tTIO::tG1_MSeries_Counting_Mode::readRegister(nMDBG::tStatus2*)
02917 {
02918    return _softCopy;
02919 }
02920
02921
02922 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setG1_MSeries_Encoder_Counting_Mode(u16 fieldValue, nMDBG::tStatus2* s)
02923 {
02924    if (s && s->isFatal()) return *this;
02925    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff8)) | (((u16)fieldValue << 0x0) & ~0xfff8);
02926    setRegister(newValue, s);
02927    return *this;
02928 }
02929
02930 inline u16 tTIO::tG1_MSeries_Counting_Mode::getG1_MSeries_Encoder_Counting_Mode(nMDBG::tStatus2*) const
02931 {
02932    return (u16)((_softCopy & ~0xfff8) >> 0x0);
02933 }
02934
02935 inline void tTIO::tG1_MSeries_Counting_Mode::writeG1_MSeries_Encoder_Counting_Mode(u16 fieldValue, nMDBG::tStatus2* s)
02936 {
02937    setG1_MSeries_Encoder_Counting_Mode(fieldValue, s);
02938    flush(s);
02939 }
02940 inline u16 tTIO::tG1_MSeries_Counting_Mode::readG1_MSeries_Encoder_Counting_Mode(nMDBG::tStatus2* s)
02941 {
02942    return getG1_MSeries_Encoder_Counting_Mode(s);
02943 }
02944
02945 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setG1_MSeries_Index_Enable(u16 fieldValue, nMDBG::tStatus2* s)
02946 {
02947    if (s && s->isFatal()) return *this;
02948    u16 newValue;   newValue = ((u16)(_softCopy & 0xffef)) | (((u16)fieldValue << 0x4) & ~0xffef);
02949    setRegister(newValue, s);
02950    return *this;
02951 }
02952
02953 inline u16 tTIO::tG1_MSeries_Counting_Mode::getG1_MSeries_Index_Enable(nMDBG::tStatus2*) const
02954 {
02955    return (u16)((_softCopy & ~0xffef) >> 0x4);
02956 }
02957
02958 inline void tTIO::tG1_MSeries_Counting_Mode::writeG1_MSeries_Index_Enable(u16 fieldValue, nMDBG::tStatus2* s)
02959 {
02960    setG1_MSeries_Index_Enable(fieldValue, s);
02961    flush(s);
02962 }
02963 inline u16 tTIO::tG1_MSeries_Counting_Mode::readG1_MSeries_Index_Enable(nMDBG::tStatus2* s)
02964 {
02965    return getG1_MSeries_Index_Enable(s);
02966 }
02967
02968 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setG1_MSeries_Index_Phase(u16 fieldValue, nMDBG::tStatus2* s)
02969 {
02970    if (s && s->isFatal()) return *this;
02971    u16 newValue;   newValue = ((u16)(_softCopy & 0xff9f)) | (((u16)fieldValue << 0x5) & ~0xff9f);
02972    setRegister(newValue, s);
02973    return *this;
02974 }
02975
02976 inline u16 tTIO::tG1_MSeries_Counting_Mode::getG1_MSeries_Index_Phase(nMDBG::tStatus2*) const
02977 {
02978    return (u16)((_softCopy & ~0xff9f) >> 0x5);
02979 }
02980
02981 inline void tTIO::tG1_MSeries_Counting_Mode::writeG1_MSeries_Index_Phase(u16 fieldValue, nMDBG::tStatus2* s)
02982 {
02983    setG1_MSeries_Index_Phase(fieldValue, s);
02984    flush(s);
02985 }
02986 inline u16 tTIO::tG1_MSeries_Counting_Mode::readG1_MSeries_Index_Phase(nMDBG::tStatus2* s)
02987 {
02988    return getG1_MSeries_Index_Phase(s);
02989 }
02990
02991 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setG1_MSeries_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s)
02992 {
02993    if (s && s->isFatal()) return *this;
02994    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
02995    setRegister(newValue, s);
02996    return *this;
02997 }
02998
02999 inline u16 tTIO::tG1_MSeries_Counting_Mode::getG1_MSeries_HW_Arm_Enable(nMDBG::tStatus2*) const
03000 {
03001    return (u16)((_softCopy & ~0xff7f) >> 0x7);
03002 }
03003
03004 inline void tTIO::tG1_MSeries_Counting_Mode::writeG1_MSeries_HW_Arm_Enable(u16 fieldValue, nMDBG::tStatus2* s)
03005 {
03006    setG1_MSeries_HW_Arm_Enable(fieldValue, s);
03007    flush(s);
03008 }
03009 inline u16 tTIO::tG1_MSeries_Counting_Mode::readG1_MSeries_HW_Arm_Enable(nMDBG::tStatus2* s)
03010 {
03011    return getG1_MSeries_HW_Arm_Enable(s);
03012 }
03013
03014 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setG1_MSeries_HW_Arm_Select(u16 fieldValue, nMDBG::tStatus2* s)
03015 {
03016    if (s && s->isFatal()) return *this;
03017    u16 newValue;   newValue = ((u16)(_softCopy & 0xe0ff)) | (((u16)fieldValue << 0x8) & ~0xe0ff);
03018    setRegister(newValue, s);
03019    return *this;
03020 }
03021
03022 inline u16 tTIO::tG1_MSeries_Counting_Mode::getG1_MSeries_HW_Arm_Select(nMDBG::tStatus2*) const
03023 {
03024    return (u16)((_softCopy & ~0xe0ff) >> 0x8);
03025 }
03026
03027 inline void tTIO::tG1_MSeries_Counting_Mode::writeG1_MSeries_HW_Arm_Select(u16 fieldValue, nMDBG::tStatus2* s)
03028 {
03029    setG1_MSeries_HW_Arm_Select(fieldValue, s);
03030    flush(s);
03031 }
03032 inline u16 tTIO::tG1_MSeries_Counting_Mode::readG1_MSeries_HW_Arm_Select(nMDBG::tStatus2* s)
03033 {
03034    return getG1_MSeries_HW_Arm_Select(s);
03035 }
03036
03037 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setG1_MSeries_Prescale(u16 fieldValue, nMDBG::tStatus2* s)
03038 {
03039    if (s && s->isFatal()) return *this;
03040    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
03041    setRegister(newValue, s);
03042    return *this;
03043 }
03044
03045 inline u16 tTIO::tG1_MSeries_Counting_Mode::getG1_MSeries_Prescale(nMDBG::tStatus2*) const
03046 {
03047    return (u16)((_softCopy & ~0xdfff) >> 0xd);
03048 }
03049
03050 inline void tTIO::tG1_MSeries_Counting_Mode::writeG1_MSeries_Prescale(u16 fieldValue, nMDBG::tStatus2* s)
03051 {
03052    setG1_MSeries_Prescale(fieldValue, s);
03053    flush(s);
03054 }
03055 inline u16 tTIO::tG1_MSeries_Counting_Mode::readG1_MSeries_Prescale(nMDBG::tStatus2* s)
03056 {
03057    return getG1_MSeries_Prescale(s);
03058 }
03059
03060 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setG1_MSeries_Alternate_Synchronization(u16 fieldValue, nMDBG::tStatus2* s)
03061 {
03062    if (s && s->isFatal()) return *this;
03063    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
03064    setRegister(newValue, s);
03065    return *this;
03066 }
03067
03068 inline u16 tTIO::tG1_MSeries_Counting_Mode::getG1_MSeries_Alternate_Synchronization(nMDBG::tStatus2*) const
03069 {
03070    return (u16)((_softCopy & ~0xbfff) >> 0xe);
03071 }
03072
03073 inline void tTIO::tG1_MSeries_Counting_Mode::writeG1_MSeries_Alternate_Synchronization(u16 fieldValue, nMDBG::tStatus2* s)
03074 {
03075    setG1_MSeries_Alternate_Synchronization(fieldValue, s);
03076    flush(s);
03077 }
03078 inline u16 tTIO::tG1_MSeries_Counting_Mode::readG1_MSeries_Alternate_Synchronization(nMDBG::tStatus2* s)
03079 {
03080    return getG1_MSeries_Alternate_Synchronization(s);
03081 }
03082
03083 inline tTIO::tG1_MSeries_Counting_Mode& tTIO::tG1_MSeries_Counting_Mode::setG1_MSeries_Prescale_By_2(u16 fieldValue, nMDBG::tStatus2* s)
03084 {
03085    if (s && s->isFatal()) return *this;
03086    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
03087    setRegister(newValue, s);
03088    return *this;
03089 }
03090
03091 inline u16 tTIO::tG1_MSeries_Counting_Mode::getG1_MSeries_Prescale_By_2(nMDBG::tStatus2*) const
03092 {
03093    return (u16)((_softCopy & ~0x7fff) >> 0xf);
03094 }
03095
03096 inline void tTIO::tG1_MSeries_Counting_Mode::writeG1_MSeries_Prescale_By_2(u16 fieldValue, nMDBG::tStatus2* s)
03097 {
03098    setG1_MSeries_Prescale_By_2(fieldValue, s);
03099    flush(s);
03100 }
03101 inline u16 tTIO::tG1_MSeries_Counting_Mode::readG1_MSeries_Prescale_By_2(nMDBG::tStatus2* s)
03102 {
03103    return getG1_MSeries_Prescale_By_2(s);
03104 }
03105
03106 inline void tTIO::tG1_MSeries_Counting_Mode::setRegisterMap(tTIO* pTIO)
03107 {
03108    _TIO = pTIO;
03109 }
03110
03111 inline tTIO::tG1_DMA_Control::tG1_DMA_Control()
03112 {
03113    _softCopy = 0;
03114 }
03115
03116 inline tTIO* tTIO::tG1_DMA_Control::registerMap(void)
03117 {
03118    return _TIO;
03119 }
03120
03121 inline void tTIO::tG1_DMA_Control::flushBus(nMDBG::tStatus2* s)
03122 {
03123    _TIO->flushBus(s);
03124 }
03125
03126 inline tTIO::tG1_DMA_Control& tTIO::tG1_DMA_Control::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
03127 {
03128    if (s && s->isFatal()) return *this;
03129    _softCopy = fieldValue;
03130    return *this;
03131 }
03132
03133 inline u16 tTIO::tG1_DMA_Control::getRegister(nMDBG::tStatus2*) const
03134 {
03135    return _softCopy;
03136 }
03137
03138 inline void tTIO::tG1_DMA_Control::flush(nMDBG::tStatus2* s)
03139 {
03140    if (s && s->isFatal()) return;
03141    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
03142    _softCopy &= (u16)(0xffffffff);
03143 }
03144
03145 inline void tTIO::tG1_DMA_Control::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
03146 {
03147    if (s && s->isFatal()) return;
03148    _softCopy = fieldValue;
03149    flush(s);
03150 }
03151
03152 inline u16 tTIO::tG1_DMA_Control::readRegister(nMDBG::tStatus2*)
03153 {
03154    return _softCopy;
03155 }
03156
03157
03158 inline tTIO::tG1_DMA_Control& tTIO::tG1_DMA_Control::setG1_DMA_Enable(tG1_DMA_Enable fieldValue, nMDBG::tStatus2* s)
03159 {
03160    if (s && s->isFatal()) return *this;
03161    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
03162    setRegister(newValue, s);
03163    return *this;
03164 }
03165
03166 inline tTIO::tG1_DMA_Control::tG1_DMA_Enable tTIO::tG1_DMA_Control::getG1_DMA_Enable(nMDBG::tStatus2*) const
03167 {
03168    return (tG1_DMA_Enable)((_softCopy & ~0xfffe) >> 0x0);
03169 }
03170
03171 inline void tTIO::tG1_DMA_Control::writeG1_DMA_Enable(tG1_DMA_Enable fieldValue, nMDBG::tStatus2* s)
03172 {
03173    setG1_DMA_Enable(fieldValue, s);
03174    flush(s);
03175 }
03176 inline tTIO::tG1_DMA_Control::tG1_DMA_Enable tTIO::tG1_DMA_Control::readG1_DMA_Enable(nMDBG::tStatus2* s)
03177 {
03178    return getG1_DMA_Enable(s);
03179 }
03180
03181 inline tTIO::tG1_DMA_Control& tTIO::tG1_DMA_Control::setG1_DMA_Output_Enable(u16 fieldValue, nMDBG::tStatus2* s)
03182 {
03183    if (s && s->isFatal()) return *this;
03184    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
03185    setRegister(newValue, s);
03186    return *this;
03187 }
03188
03189 inline u16 tTIO::tG1_DMA_Control::getG1_DMA_Output_Enable(nMDBG::tStatus2*) const
03190 {
03191    return (u16)((_softCopy & ~0xfffd) >> 0x1);
03192 }
03193
03194 inline void tTIO::tG1_DMA_Control::writeG1_DMA_Output_Enable(u16 fieldValue, nMDBG::tStatus2* s)
03195 {
03196    setG1_DMA_Output_Enable(fieldValue, s);
03197    flush(s);
03198 }
03199 inline u16 tTIO::tG1_DMA_Control::readG1_DMA_Output_Enable(nMDBG::tStatus2* s)
03200 {
03201    return getG1_DMA_Output_Enable(s);
03202 }
03203
03204 inline tTIO::tG1_DMA_Control& tTIO::tG1_DMA_Control::setG1_DMA_Int_Enable(u16 fieldValue, nMDBG::tStatus2* s)
03205 {
03206    if (s && s->isFatal()) return *this;
03207    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
03208    setRegister(newValue, s);
03209    return *this;
03210 }
03211
03212 inline u16 tTIO::tG1_DMA_Control::getG1_DMA_Int_Enable(nMDBG::tStatus2*) const
03213 {
03214    return (u16)((_softCopy & ~0xfffb) >> 0x2);
03215 }
03216
03217 inline void tTIO::tG1_DMA_Control::writeG1_DMA_Int_Enable(u16 fieldValue, nMDBG::tStatus2* s)
03218 {
03219    setG1_DMA_Int_Enable(fieldValue, s);
03220    flush(s);
03221 }
03222 inline u16 tTIO::tG1_DMA_Control::readG1_DMA_Int_Enable(nMDBG::tStatus2* s)
03223 {
03224    return getG1_DMA_Int_Enable(s);
03225 }
03226
03227 inline void tTIO::tG1_DMA_Control::setRegisterMap(tTIO* pTIO)
03228 {
03229    _TIO = pTIO;
03230 }
03231
03232 inline tTIO::tG1_Input_Select::tG1_Input_Select()
03233 {
03234    _softCopy = 0;
03235 }
03236
03237 inline tTIO* tTIO::tG1_Input_Select::registerMap(void)
03238 {
03239    return _TIO;
03240 }
03241
03242 inline void tTIO::tG1_Input_Select::flushBus(nMDBG::tStatus2* s)
03243 {
03244    _TIO->flushBus(s);
03245 }
03246
03247 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
03248 {
03249    if (s && s->isFatal()) return *this;
03250    _softCopy = fieldValue;
03251    return *this;
03252 }
03253
03254 inline u16 tTIO::tG1_Input_Select::getRegister(nMDBG::tStatus2*) const
03255 {
03256    return _softCopy;
03257 }
03258
03259 inline void tTIO::tG1_Input_Select::flush(nMDBG::tStatus2* s)
03260 {
03261    if (s && s->isFatal()) return;
03262    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
03263    _softCopy &= (u16)(0xffffffff);
03264 }
03265
03266 inline void tTIO::tG1_Input_Select::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
03267 {
03268    if (s && s->isFatal()) return;
03269    _softCopy = fieldValue;
03270    flush(s);
03271 }
03272
03273 inline u16 tTIO::tG1_Input_Select::readRegister(nMDBG::tStatus2*)
03274 {
03275    return _softCopy;
03276 }
03277
03278
03279 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setG1_Read_Acknowledges_Irq(u16 fieldValue, nMDBG::tStatus2* s)
03280 {
03281    if (s && s->isFatal()) return *this;
03282    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
03283    setRegister(newValue, s);
03284    return *this;
03285 }
03286
03287 inline u16 tTIO::tG1_Input_Select::getG1_Read_Acknowledges_Irq(nMDBG::tStatus2*) const
03288 {
03289    return (u16)((_softCopy & ~0xfffe) >> 0x0);
03290 }
03291
03292 inline void tTIO::tG1_Input_Select::writeG1_Read_Acknowledges_Irq(u16 fieldValue, nMDBG::tStatus2* s)
03293 {
03294    setG1_Read_Acknowledges_Irq(fieldValue, s);
03295    flush(s);
03296 }
03297 inline u16 tTIO::tG1_Input_Select::readG1_Read_Acknowledges_Irq(nMDBG::tStatus2* s)
03298 {
03299    return getG1_Read_Acknowledges_Irq(s);
03300 }
03301
03302 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setG1_Write_Acknowledges_Irq(u16 fieldValue, nMDBG::tStatus2* s)
03303 {
03304    if (s && s->isFatal()) return *this;
03305    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
03306    setRegister(newValue, s);
03307    return *this;
03308 }
03309
03310 inline u16 tTIO::tG1_Input_Select::getG1_Write_Acknowledges_Irq(nMDBG::tStatus2*) const
03311 {
03312    return (u16)((_softCopy & ~0xfffd) >> 0x1);
03313 }
03314
03315 inline void tTIO::tG1_Input_Select::writeG1_Write_Acknowledges_Irq(u16 fieldValue, nMDBG::tStatus2* s)
03316 {
03317    setG1_Write_Acknowledges_Irq(fieldValue, s);
03318    flush(s);
03319 }
03320 inline u16 tTIO::tG1_Input_Select::readG1_Write_Acknowledges_Irq(nMDBG::tStatus2* s)
03321 {
03322    return getG1_Write_Acknowledges_Irq(s);
03323 }
03324
03325 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setG1_Source_Select(u16 fieldValue, nMDBG::tStatus2* s)
03326 {
03327    if (s && s->isFatal()) return *this;
03328    u16 newValue;   newValue = ((u16)(_softCopy & 0xff83)) | (((u16)fieldValue << 0x2) & ~0xff83);
03329    setRegister(newValue, s);
03330    return *this;
03331 }
03332
03333 inline u16 tTIO::tG1_Input_Select::getG1_Source_Select(nMDBG::tStatus2*) const
03334 {
03335    return (u16)((_softCopy & ~0xff83) >> 0x2);
03336 }
03337
03338 inline void tTIO::tG1_Input_Select::writeG1_Source_Select(u16 fieldValue, nMDBG::tStatus2* s)
03339 {
03340    setG1_Source_Select(fieldValue, s);
03341    flush(s);
03342 }
03343 inline u16 tTIO::tG1_Input_Select::readG1_Source_Select(nMDBG::tStatus2* s)
03344 {
03345    return getG1_Source_Select(s);
03346 }
03347
03348 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setG1_Gate_Select(u16 fieldValue, nMDBG::tStatus2* s)
03349 {
03350    if (s && s->isFatal()) return *this;
03351    u16 newValue;   newValue = ((u16)(_softCopy & 0xf07f)) | (((u16)fieldValue << 0x7) & ~0xf07f);
03352    setRegister(newValue, s);
03353    return *this;
03354 }
03355
03356 inline u16 tTIO::tG1_Input_Select::getG1_Gate_Select(nMDBG::tStatus2*) const
03357 {
03358    return (u16)((_softCopy & ~0xf07f) >> 0x7);
03359 }
03360
03361 inline void tTIO::tG1_Input_Select::writeG1_Gate_Select(u16 fieldValue, nMDBG::tStatus2* s)
03362 {
03363    setG1_Gate_Select(fieldValue, s);
03364    flush(s);
03365 }
03366 inline u16 tTIO::tG1_Input_Select::readG1_Gate_Select(nMDBG::tStatus2* s)
03367 {
03368    return getG1_Gate_Select(s);
03369 }
03370
03371 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setG1_Gate_Select_Load_Source(u16 fieldValue, nMDBG::tStatus2* s)
03372 {
03373    if (s && s->isFatal()) return *this;
03374    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
03375    setRegister(newValue, s);
03376    return *this;
03377 }
03378
03379 inline u16 tTIO::tG1_Input_Select::getG1_Gate_Select_Load_Source(nMDBG::tStatus2*) const
03380 {
03381    return (u16)((_softCopy & ~0xefff) >> 0xc);
03382 }
03383
03384 inline void tTIO::tG1_Input_Select::writeG1_Gate_Select_Load_Source(u16 fieldValue, nMDBG::tStatus2* s)
03385 {
03386    setG1_Gate_Select_Load_Source(fieldValue, s);
03387    flush(s);
03388 }
03389 inline u16 tTIO::tG1_Input_Select::readG1_Gate_Select_Load_Source(nMDBG::tStatus2* s)
03390 {
03391    return getG1_Gate_Select_Load_Source(s);
03392 }
03393
03394 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setG1_OR_Gate(u16 fieldValue, nMDBG::tStatus2* s)
03395 {
03396    if (s && s->isFatal()) return *this;
03397    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
03398    setRegister(newValue, s);
03399    return *this;
03400 }
03401
03402 inline u16 tTIO::tG1_Input_Select::getG1_OR_Gate(nMDBG::tStatus2*) const
03403 {
03404    return (u16)((_softCopy & ~0xdfff) >> 0xd);
03405 }
03406
03407 inline void tTIO::tG1_Input_Select::writeG1_OR_Gate(u16 fieldValue, nMDBG::tStatus2* s)
03408 {
03409    setG1_OR_Gate(fieldValue, s);
03410    flush(s);
03411 }
03412 inline u16 tTIO::tG1_Input_Select::readG1_OR_Gate(nMDBG::tStatus2* s)
03413 {
03414    return getG1_OR_Gate(s);
03415 }
03416
03417 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setG1_Output_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
03418 {
03419    if (s && s->isFatal()) return *this;
03420    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
03421    setRegister(newValue, s);
03422    return *this;
03423 }
03424
03425 inline u16 tTIO::tG1_Input_Select::getG1_Output_Polarity(nMDBG::tStatus2*) const
03426 {
03427    return (u16)((_softCopy & ~0xbfff) >> 0xe);
03428 }
03429
03430 inline void tTIO::tG1_Input_Select::writeG1_Output_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
03431 {
03432    setG1_Output_Polarity(fieldValue, s);
03433    flush(s);
03434 }
03435 inline u16 tTIO::tG1_Input_Select::readG1_Output_Polarity(nMDBG::tStatus2* s)
03436 {
03437    return getG1_Output_Polarity(s);
03438 }
03439
03440 inline tTIO::tG1_Input_Select& tTIO::tG1_Input_Select::setG1_Source_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
03441 {
03442    if (s && s->isFatal()) return *this;
03443    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
03444    setRegister(newValue, s);
03445    return *this;
03446 }
03447
03448 inline u16 tTIO::tG1_Input_Select::getG1_Source_Polarity(nMDBG::tStatus2*) const
03449 {
03450    return (u16)((_softCopy & ~0x7fff) >> 0xf);
03451 }
03452
03453 inline void tTIO::tG1_Input_Select::writeG1_Source_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
03454 {
03455    setG1_Source_Polarity(fieldValue, s);
03456    flush(s);
03457 }
03458 inline u16 tTIO::tG1_Input_Select::readG1_Source_Polarity(nMDBG::tStatus2* s)
03459 {
03460    return getG1_Source_Polarity(s);
03461 }
03462
03463 inline void tTIO::tG1_Input_Select::setRegisterMap(tTIO* pTIO)
03464 {
03465    _TIO = pTIO;
03466 }
03467
03468 inline tTIO::tG1_Load_A::tG1_Load_A()
03469 {
03470    _softCopy = 0;
03471 }
03472
03473 inline tTIO* tTIO::tG1_Load_A::registerMap(void)
03474 {
03475    return _TIO;
03476 }
03477
03478 inline void tTIO::tG1_Load_A::flushBus(nMDBG::tStatus2* s)
03479 {
03480    _TIO->flushBus(s);
03481 }
03482
03483 inline tTIO::tG1_Load_A& tTIO::tG1_Load_A::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
03484 {
03485    if (s && s->isFatal()) return *this;
03486    _softCopy = fieldValue;
03487    return *this;
03488 }
03489
03490 inline u32 tTIO::tG1_Load_A::getRegister(nMDBG::tStatus2*) const
03491 {
03492    return _softCopy;
03493 }
03494
03495 inline void tTIO::tG1_Load_A::flush(nMDBG::tStatus2* s)
03496 {
03497    if (s && s->isFatal()) return;
03498    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
03499    _softCopy &= (u32)(0xffffffff);
03500 }
03501
03502 inline void tTIO::tG1_Load_A::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
03503 {
03504    if (s && s->isFatal()) return;
03505    _softCopy = fieldValue;
03506    flush(s);
03507 }
03508
03509 inline u32 tTIO::tG1_Load_A::readRegister(nMDBG::tStatus2*)
03510 {
03511    return _softCopy;
03512 }
03513
03514
03515 inline tTIO::tG1_Load_A& tTIO::tG1_Load_A::set(u32 fieldValue, nMDBG::tStatus2* s)
03516 {
03517    if (s && s->isFatal()) return *this;
03518    u32 newValue;   newValue = ((u32)(_softCopy & 0x0)) | (((u32)fieldValue << 0x0) & ~0x0);
03519    setRegister(newValue, s);
03520    return *this;
03521 }
03522
03523 inline u32 tTIO::tG1_Load_A::get(nMDBG::tStatus2*) const
03524 {
03525    return (u32)((_softCopy & ~0x0) >> 0x0);
03526 }
03527
03528 inline void tTIO::tG1_Load_A::write(u32 fieldValue, nMDBG::tStatus2* s)
03529 {
03530    set(fieldValue, s);
03531    flush(s);
03532 }
03533 inline u32 tTIO::tG1_Load_A::read(nMDBG::tStatus2* s)
03534 {
03535    return get(s);
03536 }
03537
03538 inline void tTIO::tG1_Load_A::setRegisterMap(tTIO* pTIO)
03539 {
03540    _TIO = pTIO;
03541 }
03542
03543 inline tTIO::tG1_Load_B::tG1_Load_B()
03544 {
03545    _softCopy = 0;
03546 }
03547
03548 inline tTIO* tTIO::tG1_Load_B::registerMap(void)
03549 {
03550    return _TIO;
03551 }
03552
03553 inline void tTIO::tG1_Load_B::flushBus(nMDBG::tStatus2* s)
03554 {
03555    _TIO->flushBus(s);
03556 }
03557
03558 inline tTIO::tG1_Load_B& tTIO::tG1_Load_B::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
03559 {
03560    if (s && s->isFatal()) return *this;
03561    _softCopy = fieldValue;
03562    return *this;
03563 }
03564
03565 inline u32 tTIO::tG1_Load_B::getRegister(nMDBG::tStatus2*) const
03566 {
03567    return _softCopy;
03568 }
03569
03570 inline void tTIO::tG1_Load_B::flush(nMDBG::tStatus2* s)
03571 {
03572    if (s && s->isFatal()) return;
03573    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
03574    _softCopy &= (u32)(0xffffffff);
03575 }
03576
03577 inline void tTIO::tG1_Load_B::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
03578 {
03579    if (s && s->isFatal()) return;
03580    _softCopy = fieldValue;
03581    flush(s);
03582 }
03583
03584 inline u32 tTIO::tG1_Load_B::readRegister(nMDBG::tStatus2*)
03585 {
03586    return _softCopy;
03587 }
03588
03589
03590 inline tTIO::tG1_Load_B& tTIO::tG1_Load_B::set(u32 fieldValue, nMDBG::tStatus2* s)
03591 {
03592    if (s && s->isFatal()) return *this;
03593    u32 newValue;   newValue = ((u32)(_softCopy & 0x0)) | (((u32)fieldValue << 0x0) & ~0x0);
03594    setRegister(newValue, s);
03595    return *this;
03596 }
03597
03598 inline u32 tTIO::tG1_Load_B::get(nMDBG::tStatus2*) const
03599 {
03600    return (u32)((_softCopy & ~0x0) >> 0x0);
03601 }
03602
03603 inline void tTIO::tG1_Load_B::write(u32 fieldValue, nMDBG::tStatus2* s)
03604 {
03605    set(fieldValue, s);
03606    flush(s);
03607 }
03608 inline u32 tTIO::tG1_Load_B::read(nMDBG::tStatus2* s)
03609 {
03610    return get(s);
03611 }
03612
03613 inline void tTIO::tG1_Load_B::setRegisterMap(tTIO* pTIO)
03614 {
03615    _TIO = pTIO;
03616 }
03617
03618 inline tTIO::tG1_Mode::tG1_Mode()
03619 {
03620    _softCopy = 0;
03621 }
03622
03623 inline tTIO* tTIO::tG1_Mode::registerMap(void)
03624 {
03625    return _TIO;
03626 }
03627
03628 inline void tTIO::tG1_Mode::flushBus(nMDBG::tStatus2* s)
03629 {
03630    _TIO->flushBus(s);
03631 }
03632
03633 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
03634 {
03635    if (s && s->isFatal()) return *this;
03636    _softCopy = fieldValue;
03637    return *this;
03638 }
03639
03640 inline u16 tTIO::tG1_Mode::getRegister(nMDBG::tStatus2*) const
03641 {
03642    return _softCopy;
03643 }
03644
03645 inline void tTIO::tG1_Mode::flush(nMDBG::tStatus2* s)
03646 {
03647    if (s && s->isFatal()) return;
03648    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
03649    _softCopy &= (u16)(0xffffffff);
03650 }
03651
03652 inline void tTIO::tG1_Mode::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
03653 {
03654    if (s && s->isFatal()) return;
03655    _softCopy = fieldValue;
03656    flush(s);
03657 }
03658
03659 inline u16 tTIO::tG1_Mode::readRegister(nMDBG::tStatus2*)
03660 {
03661    return _softCopy;
03662 }
03663
03664
03665 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Gating_Mode(tG1_Gating_Mode fieldValue, nMDBG::tStatus2* s)
03666 {
03667    if (s && s->isFatal()) return *this;
03668    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffc)) | (((u16)fieldValue << 0x0) & ~0xfffc);
03669    setRegister(newValue, s);
03670    return *this;
03671 }
03672
03673 inline tTIO::tG1_Mode::tG1_Gating_Mode tTIO::tG1_Mode::getG1_Gating_Mode(nMDBG::tStatus2*) const
03674 {
03675    return (tG1_Gating_Mode)((_softCopy & ~0xfffc) >> 0x0);
03676 }
03677
03678 inline void tTIO::tG1_Mode::writeG1_Gating_Mode(tG1_Gating_Mode fieldValue, nMDBG::tStatus2* s)
03679 {
03680    setG1_Gating_Mode(fieldValue, s);
03681    flush(s);
03682 }
03683 inline tTIO::tG1_Mode::tG1_Gating_Mode tTIO::tG1_Mode::readG1_Gating_Mode(nMDBG::tStatus2* s)
03684 {
03685    return getG1_Gating_Mode(s);
03686 }
03687
03688 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Gate_On_Both_Edges(tG1_Gate_On_Both_Edges fieldValue, nMDBG::tStatus2* s)
03689 {
03690    if (s && s->isFatal()) return *this;
03691    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
03692    setRegister(newValue, s);
03693    return *this;
03694 }
03695
03696 inline tTIO::tG1_Mode::tG1_Gate_On_Both_Edges tTIO::tG1_Mode::getG1_Gate_On_Both_Edges(nMDBG::tStatus2*) const
03697 {
03698    return (tG1_Gate_On_Both_Edges)((_softCopy & ~0xfffb) >> 0x2);
03699 }
03700
03701 inline void tTIO::tG1_Mode::writeG1_Gate_On_Both_Edges(tG1_Gate_On_Both_Edges fieldValue, nMDBG::tStatus2* s)
03702 {
03703    setG1_Gate_On_Both_Edges(fieldValue, s);
03704    flush(s);
03705 }
03706 inline tTIO::tG1_Mode::tG1_Gate_On_Both_Edges tTIO::tG1_Mode::readG1_Gate_On_Both_Edges(nMDBG::tStatus2* s)
03707 {
03708    return getG1_Gate_On_Both_Edges(s);
03709 }
03710
03711 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Trigger_Mode_For_Edge_Gate(tG1_Trigger_Mode_For_Edge_Gate fieldValue, nMDBG::tStatus2* s)
03712 {
03713    if (s && s->isFatal()) return *this;
03714    u16 newValue;   newValue = ((u16)(_softCopy & 0xffe7)) | (((u16)fieldValue << 0x3) & ~0xffe7);
03715    setRegister(newValue, s);
03716    return *this;
03717 }
03718
03719 inline tTIO::tG1_Mode::tG1_Trigger_Mode_For_Edge_Gate tTIO::tG1_Mode::getG1_Trigger_Mode_For_Edge_Gate(nMDBG::tStatus2*) const
03720 {
03721    return (tG1_Trigger_Mode_For_Edge_Gate)((_softCopy & ~0xffe7) >> 0x3);
03722 }
03723
03724 inline void tTIO::tG1_Mode::writeG1_Trigger_Mode_For_Edge_Gate(tG1_Trigger_Mode_For_Edge_Gate fieldValue, nMDBG::tStatus2* s)
03725 {
03726    setG1_Trigger_Mode_For_Edge_Gate(fieldValue, s);
03727    flush(s);
03728 }
03729 inline tTIO::tG1_Mode::tG1_Trigger_Mode_For_Edge_Gate tTIO::tG1_Mode::readG1_Trigger_Mode_For_Edge_Gate(nMDBG::tStatus2* s)
03730 {
03731    return getG1_Trigger_Mode_For_Edge_Gate(s);
03732 }
03733
03734 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Stop_Mode(tG1_Stop_Mode fieldValue, nMDBG::tStatus2* s)
03735 {
03736    if (s && s->isFatal()) return *this;
03737    u16 newValue;   newValue = ((u16)(_softCopy & 0xff9f)) | (((u16)fieldValue << 0x5) & ~0xff9f);
03738    setRegister(newValue, s);
03739    return *this;
03740 }
03741
03742 inline tTIO::tG1_Mode::tG1_Stop_Mode tTIO::tG1_Mode::getG1_Stop_Mode(nMDBG::tStatus2*) const
03743 {
03744    return (tG1_Stop_Mode)((_softCopy & ~0xff9f) >> 0x5);
03745 }
03746
03747 inline void tTIO::tG1_Mode::writeG1_Stop_Mode(tG1_Stop_Mode fieldValue, nMDBG::tStatus2* s)
03748 {
03749    setG1_Stop_Mode(fieldValue, s);
03750    flush(s);
03751 }
03752 inline tTIO::tG1_Mode::tG1_Stop_Mode tTIO::tG1_Mode::readG1_Stop_Mode(nMDBG::tStatus2* s)
03753 {
03754    return getG1_Stop_Mode(s);
03755 }
03756
03757 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Load_Source_Select(tG1_Load_Source_Select fieldValue, nMDBG::tStatus2* s)
03758 {
03759    if (s && s->isFatal()) return *this;
03760    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
03761    setRegister(newValue, s);
03762    return *this;
03763 }
03764
03765 inline tTIO::tG1_Mode::tG1_Load_Source_Select tTIO::tG1_Mode::getG1_Load_Source_Select(nMDBG::tStatus2*) const
03766 {
03767    return (tG1_Load_Source_Select)((_softCopy & ~0xff7f) >> 0x7);
03768 }
03769
03770 inline void tTIO::tG1_Mode::writeG1_Load_Source_Select(tG1_Load_Source_Select fieldValue, nMDBG::tStatus2* s)
03771 {
03772    setG1_Load_Source_Select(fieldValue, s);
03773    flush(s);
03774 }
03775 inline tTIO::tG1_Mode::tG1_Load_Source_Select tTIO::tG1_Mode::readG1_Load_Source_Select(nMDBG::tStatus2* s)
03776 {
03777    return getG1_Load_Source_Select(s);
03778 }
03779
03780 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Output_Mode(tG1_Output_Mode fieldValue, nMDBG::tStatus2* s)
03781 {
03782    if (s && s->isFatal()) return *this;
03783    u16 newValue;   newValue = ((u16)(_softCopy & 0xfcff)) | (((u16)fieldValue << 0x8) & ~0xfcff);
03784    setRegister(newValue, s);
03785    return *this;
03786 }
03787
03788 inline tTIO::tG1_Mode::tG1_Output_Mode tTIO::tG1_Mode::getG1_Output_Mode(nMDBG::tStatus2*) const
03789 {
03790    return (tG1_Output_Mode)((_softCopy & ~0xfcff) >> 0x8);
03791 }
03792
03793 inline void tTIO::tG1_Mode::writeG1_Output_Mode(tG1_Output_Mode fieldValue, nMDBG::tStatus2* s)
03794 {
03795    setG1_Output_Mode(fieldValue, s);
03796    flush(s);
03797 }
03798 inline tTIO::tG1_Mode::tG1_Output_Mode tTIO::tG1_Mode::readG1_Output_Mode(nMDBG::tStatus2* s)
03799 {
03800    return getG1_Output_Mode(s);
03801 }
03802
03803 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Counting_Once(tG1_Counting_Once fieldValue, nMDBG::tStatus2* s)
03804 {
03805    if (s && s->isFatal()) return *this;
03806    u16 newValue;   newValue = ((u16)(_softCopy & 0xf3ff)) | (((u16)fieldValue << 0xa) & ~0xf3ff);
03807    setRegister(newValue, s);
03808    return *this;
03809 }
03810
03811 inline tTIO::tG1_Mode::tG1_Counting_Once tTIO::tG1_Mode::getG1_Counting_Once(nMDBG::tStatus2*) const
03812 {
03813    return (tG1_Counting_Once)((_softCopy & ~0xf3ff) >> 0xa);
03814 }
03815
03816 inline void tTIO::tG1_Mode::writeG1_Counting_Once(tG1_Counting_Once fieldValue, nMDBG::tStatus2* s)
03817 {
03818    setG1_Counting_Once(fieldValue, s);
03819    flush(s);
03820 }
03821 inline tTIO::tG1_Mode::tG1_Counting_Once tTIO::tG1_Mode::readG1_Counting_Once(nMDBG::tStatus2* s)
03822 {
03823    return getG1_Counting_Once(s);
03824 }
03825
03826 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Loading_On_TC(tG1_Loading_On_TC fieldValue, nMDBG::tStatus2* s)
03827 {
03828    if (s && s->isFatal()) return *this;
03829    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
03830    setRegister(newValue, s);
03831    return *this;
03832 }
03833
03834 inline tTIO::tG1_Mode::tG1_Loading_On_TC tTIO::tG1_Mode::getG1_Loading_On_TC(nMDBG::tStatus2*) const
03835 {
03836    return (tG1_Loading_On_TC)((_softCopy & ~0xefff) >> 0xc);
03837 }
03838
03839 inline void tTIO::tG1_Mode::writeG1_Loading_On_TC(tG1_Loading_On_TC fieldValue, nMDBG::tStatus2* s)
03840 {
03841    setG1_Loading_On_TC(fieldValue, s);
03842    flush(s);
03843 }
03844 inline tTIO::tG1_Mode::tG1_Loading_On_TC tTIO::tG1_Mode::readG1_Loading_On_TC(nMDBG::tStatus2* s)
03845 {
03846    return getG1_Loading_On_TC(s);
03847 }
03848
03849 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Gate_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
03850 {
03851    if (s && s->isFatal()) return *this;
03852    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
03853    setRegister(newValue, s);
03854    return *this;
03855 }
03856
03857 inline u16 tTIO::tG1_Mode::getG1_Gate_Polarity(nMDBG::tStatus2*) const
03858 {
03859    return (u16)((_softCopy & ~0xdfff) >> 0xd);
03860 }
03861
03862 inline void tTIO::tG1_Mode::writeG1_Gate_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
03863 {
03864    setG1_Gate_Polarity(fieldValue, s);
03865    flush(s);
03866 }
03867 inline u16 tTIO::tG1_Mode::readG1_Gate_Polarity(nMDBG::tStatus2* s)
03868 {
03869    return getG1_Gate_Polarity(s);
03870 }
03871
03872 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Loading_On_Gate(tG1_Loading_On_Gate fieldValue, nMDBG::tStatus2* s)
03873 {
03874    if (s && s->isFatal()) return *this;
03875    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
03876    setRegister(newValue, s);
03877    return *this;
03878 }
03879
03880 inline tTIO::tG1_Mode::tG1_Loading_On_Gate tTIO::tG1_Mode::getG1_Loading_On_Gate(nMDBG::tStatus2*) const
03881 {
03882    return (tG1_Loading_On_Gate)((_softCopy & ~0xbfff) >> 0xe);
03883 }
03884
03885 inline void tTIO::tG1_Mode::writeG1_Loading_On_Gate(tG1_Loading_On_Gate fieldValue, nMDBG::tStatus2* s)
03886 {
03887    setG1_Loading_On_Gate(fieldValue, s);
03888    flush(s);
03889 }
03890 inline tTIO::tG1_Mode::tG1_Loading_On_Gate tTIO::tG1_Mode::readG1_Loading_On_Gate(nMDBG::tStatus2* s)
03891 {
03892    return getG1_Loading_On_Gate(s);
03893 }
03894
03895 inline tTIO::tG1_Mode& tTIO::tG1_Mode::setG1_Reload_Source_Switching(tG1_Reload_Source_Switching fieldValue, nMDBG::tStatus2* s)
03896 {
03897    if (s && s->isFatal()) return *this;
03898    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
03899    setRegister(newValue, s);
03900    return *this;
03901 }
03902
03903 inline tTIO::tG1_Mode::tG1_Reload_Source_Switching tTIO::tG1_Mode::getG1_Reload_Source_Switching(nMDBG::tStatus2*) const
03904 {
03905    return (tG1_Reload_Source_Switching)((_softCopy & ~0x7fff) >> 0xf);
03906 }
03907
03908 inline void tTIO::tG1_Mode::writeG1_Reload_Source_Switching(tG1_Reload_Source_Switching fieldValue, nMDBG::tStatus2* s)
03909 {
03910    setG1_Reload_Source_Switching(fieldValue, s);
03911    flush(s);
03912 }
03913 inline tTIO::tG1_Mode::tG1_Reload_Source_Switching tTIO::tG1_Mode::readG1_Reload_Source_Switching(nMDBG::tStatus2* s)
03914 {
03915    return getG1_Reload_Source_Switching(s);
03916 }
03917
03918 inline void tTIO::tG1_Mode::setRegisterMap(tTIO* pTIO)
03919 {
03920    _TIO = pTIO;
03921 }
03922
03923 inline tTIO::tG1_Second_Gate::tG1_Second_Gate()
03924 {
03925    _softCopy = 0;
03926 }
03927
03928 inline tTIO* tTIO::tG1_Second_Gate::registerMap(void)
03929 {
03930    return _TIO;
03931 }
03932
03933 inline void tTIO::tG1_Second_Gate::flushBus(nMDBG::tStatus2* s)
03934 {
03935    _TIO->flushBus(s);
03936 }
03937
03938 inline tTIO::tG1_Second_Gate& tTIO::tG1_Second_Gate::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
03939 {
03940    if (s && s->isFatal()) return *this;
03941    _softCopy = fieldValue;
03942    return *this;
03943 }
03944
03945 inline u16 tTIO::tG1_Second_Gate::getRegister(nMDBG::tStatus2*) const
03946 {
03947    return _softCopy;
03948 }
03949
03950 inline void tTIO::tG1_Second_Gate::flush(nMDBG::tStatus2* s)
03951 {
03952    if (s && s->isFatal()) return;
03953    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
03954    _softCopy &= (u16)(0xffffffff);
03955 }
03956
03957 inline void tTIO::tG1_Second_Gate::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
03958 {
03959    if (s && s->isFatal()) return;
03960    _softCopy = fieldValue;
03961    flush(s);
03962 }
03963
03964 inline u16 tTIO::tG1_Second_Gate::readRegister(nMDBG::tStatus2*)
03965 {
03966    return _softCopy;
03967 }
03968
03969
03970 inline tTIO::tG1_Second_Gate& tTIO::tG1_Second_Gate::setG1_Second_Gate_Gating_Mode(u16 fieldValue, nMDBG::tStatus2* s)
03971 {
03972    if (s && s->isFatal()) return *this;
03973    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
03974    setRegister(newValue, s);
03975    return *this;
03976 }
03977
03978 inline u16 tTIO::tG1_Second_Gate::getG1_Second_Gate_Gating_Mode(nMDBG::tStatus2*) const
03979 {
03980    return (u16)((_softCopy & ~0xfffe) >> 0x0);
03981 }
03982
03983 inline void tTIO::tG1_Second_Gate::writeG1_Second_Gate_Gating_Mode(u16 fieldValue, nMDBG::tStatus2* s)
03984 {
03985    setG1_Second_Gate_Gating_Mode(fieldValue, s);
03986    flush(s);
03987 }
03988 inline u16 tTIO::tG1_Second_Gate::readG1_Second_Gate_Gating_Mode(nMDBG::tStatus2* s)
03989 {
03990    return getG1_Second_Gate_Gating_Mode(s);
03991 }
03992
03993 inline tTIO::tG1_Second_Gate& tTIO::tG1_Second_Gate::setG1_Second_Gate_Select(u16 fieldValue, nMDBG::tStatus2* s)
03994 {
03995    if (s && s->isFatal()) return *this;
03996    u16 newValue;   newValue = ((u16)(_softCopy & 0xf07f)) | (((u16)fieldValue << 0x7) & ~0xf07f);
03997    setRegister(newValue, s);
03998    return *this;
03999 }
04000
04001 inline u16 tTIO::tG1_Second_Gate::getG1_Second_Gate_Select(nMDBG::tStatus2*) const
04002 {
04003    return (u16)((_softCopy & ~0xf07f) >> 0x7);
04004 }
04005
04006 inline void tTIO::tG1_Second_Gate::writeG1_Second_Gate_Select(u16 fieldValue, nMDBG::tStatus2* s)
04007 {
04008    setG1_Second_Gate_Select(fieldValue, s);
04009    flush(s);
04010 }
04011 inline u16 tTIO::tG1_Second_Gate::readG1_Second_Gate_Select(nMDBG::tStatus2* s)
04012 {
04013    return getG1_Second_Gate_Select(s);
04014 }
04015
04016 inline tTIO::tG1_Second_Gate& tTIO::tG1_Second_Gate::setG1_Second_Gate_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
04017 {
04018    if (s && s->isFatal()) return *this;
04019    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
04020    setRegister(newValue, s);
04021    return *this;
04022 }
04023
04024 inline u16 tTIO::tG1_Second_Gate::getG1_Second_Gate_Polarity(nMDBG::tStatus2*) const
04025 {
04026    return (u16)((_softCopy & ~0xdfff) >> 0xd);
04027 }
04028
04029 inline void tTIO::tG1_Second_Gate::writeG1_Second_Gate_Polarity(u16 fieldValue, nMDBG::tStatus2* s)
04030 {
04031    setG1_Second_Gate_Polarity(fieldValue, s);
04032    flush(s);
04033 }
04034 inline u16 tTIO::tG1_Second_Gate::readG1_Second_Gate_Polarity(nMDBG::tStatus2* s)
04035 {
04036    return getG1_Second_Gate_Polarity(s);
04037 }
04038
04039 inline tTIO::tG1_Second_Gate& tTIO::tG1_Second_Gate::setG1_MSeries_Second_Gate_SubSelect(u16 fieldValue, nMDBG::tStatus2* s)
04040 {
04041    if (s && s->isFatal()) return *this;
04042    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
04043    setRegister(newValue, s);
04044    return *this;
04045 }
04046
04047 inline u16 tTIO::tG1_Second_Gate::getG1_MSeries_Second_Gate_SubSelect(nMDBG::tStatus2*) const
04048 {
04049    return (u16)((_softCopy & ~0xbfff) >> 0xe);
04050 }
04051
04052 inline void tTIO::tG1_Second_Gate::writeG1_MSeries_Second_Gate_SubSelect(u16 fieldValue, nMDBG::tStatus2* s)
04053 {
04054    setG1_MSeries_Second_Gate_SubSelect(fieldValue, s);
04055    flush(s);
04056 }
04057 inline u16 tTIO::tG1_Second_Gate::readG1_MSeries_Second_Gate_SubSelect(nMDBG::tStatus2* s)
04058 {
04059    return getG1_MSeries_Second_Gate_SubSelect(s);
04060 }
04061
04062 inline tTIO::tG1_Second_Gate& tTIO::tG1_Second_Gate::setG1_MSeries_Source_SubSelect(u16 fieldValue, nMDBG::tStatus2* s)
04063 {
04064    if (s && s->isFatal()) return *this;
04065    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
04066    setRegister(newValue, s);
04067    return *this;
04068 }
04069
04070 inline u16 tTIO::tG1_Second_Gate::getG1_MSeries_Source_SubSelect(nMDBG::tStatus2*) const
04071 {
04072    return (u16)((_softCopy & ~0x7fff) >> 0xf);
04073 }
04074
04075 inline void tTIO::tG1_Second_Gate::writeG1_MSeries_Source_SubSelect(u16 fieldValue, nMDBG::tStatus2* s)
04076 {
04077    setG1_MSeries_Source_SubSelect(fieldValue, s);
04078    flush(s);
04079 }
04080 inline u16 tTIO::tG1_Second_Gate::readG1_MSeries_Source_SubSelect(nMDBG::tStatus2* s)
04081 {
04082    return getG1_MSeries_Source_SubSelect(s);
04083 }
04084
04085 inline void tTIO::tG1_Second_Gate::setRegisterMap(tTIO* pTIO)
04086 {
04087    _TIO = pTIO;
04088 }
04089
04090 inline tTIO::tG1_MSeries_ABZ::tG1_MSeries_ABZ()
04091 {
04092    _softCopy = 0;
04093 }
04094
04095 inline tTIO* tTIO::tG1_MSeries_ABZ::registerMap(void)
04096 {
04097    return _TIO;
04098 }
04099
04100 inline void tTIO::tG1_MSeries_ABZ::flushBus(nMDBG::tStatus2* s)
04101 {
04102    _TIO->flushBus(s);
04103 }
04104
04105 inline tTIO::tG1_MSeries_ABZ& tTIO::tG1_MSeries_ABZ::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
04106 {
04107    if (s && s->isFatal()) return *this;
04108    _softCopy = fieldValue;
04109    return *this;
04110 }
04111
04112 inline u16 tTIO::tG1_MSeries_ABZ::getRegister(nMDBG::tStatus2*) const
04113 {
04114    return _softCopy;
04115 }
04116
04117 inline void tTIO::tG1_MSeries_ABZ::flush(nMDBG::tStatus2* s)
04118 {
04119    if (s && s->isFatal()) return;
04120    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
04121    _softCopy &= (u16)(0xffffffff);
04122 }
04123
04124 inline void tTIO::tG1_MSeries_ABZ::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
04125 {
04126    if (s && s->isFatal()) return;
04127    _softCopy = fieldValue;
04128    flush(s);
04129 }
04130
04131 inline u16 tTIO::tG1_MSeries_ABZ::readRegister(nMDBG::tStatus2*)
04132 {
04133    return _softCopy;
04134 }
04135
04136
04137 inline tTIO::tG1_MSeries_ABZ& tTIO::tG1_MSeries_ABZ::setG1_Z_Select(u16 fieldValue, nMDBG::tStatus2* s)
04138 {
04139    if (s && s->isFatal()) return *this;
04140    u16 newValue;   newValue = ((u16)(_softCopy & 0xffe0)) | (((u16)fieldValue << 0x0) & ~0xffe0);
04141    setRegister(newValue, s);
04142    return *this;
04143 }
04144
04145 inline u16 tTIO::tG1_MSeries_ABZ::getG1_Z_Select(nMDBG::tStatus2*) const
04146 {
04147    return (u16)((_softCopy & ~0xffe0) >> 0x0);
04148 }
04149
04150 inline void tTIO::tG1_MSeries_ABZ::writeG1_Z_Select(u16 fieldValue, nMDBG::tStatus2* s)
04151 {
04152    setG1_Z_Select(fieldValue, s);
04153    flush(s);
04154 }
04155 inline u16 tTIO::tG1_MSeries_ABZ::readG1_Z_Select(nMDBG::tStatus2* s)
04156 {
04157    return getG1_Z_Select(s);
04158 }
04159
04160 inline tTIO::tG1_MSeries_ABZ& tTIO::tG1_MSeries_ABZ::setG1_B_Select(u16 fieldValue, nMDBG::tStatus2* s)
04161 {
04162    if (s && s->isFatal()) return *this;
04163    u16 newValue;   newValue = ((u16)(_softCopy & 0xfc1f)) | (((u16)fieldValue << 0x5) & ~0xfc1f);
04164    setRegister(newValue, s);
04165    return *this;
04166 }
04167
04168 inline u16 tTIO::tG1_MSeries_ABZ::getG1_B_Select(nMDBG::tStatus2*) const
04169 {
04170    return (u16)((_softCopy & ~0xfc1f) >> 0x5);
04171 }
04172
04173 inline void tTIO::tG1_MSeries_ABZ::writeG1_B_Select(u16 fieldValue, nMDBG::tStatus2* s)
04174 {
04175    setG1_B_Select(fieldValue, s);
04176    flush(s);
04177 }
04178 inline u16 tTIO::tG1_MSeries_ABZ::readG1_B_Select(nMDBG::tStatus2* s)
04179 {
04180    return getG1_B_Select(s);
04181 }
04182
04183 inline tTIO::tG1_MSeries_ABZ& tTIO::tG1_MSeries_ABZ::setG1_A_Select(u16 fieldValue, nMDBG::tStatus2* s)
04184 {
04185    if (s && s->isFatal()) return *this;
04186    u16 newValue;   newValue = ((u16)(_softCopy & 0x83ff)) | (((u16)fieldValue << 0xa) & ~0x83ff);
04187    setRegister(newValue, s);
04188    return *this;
04189 }
04190
04191 inline u16 tTIO::tG1_MSeries_ABZ::getG1_A_Select(nMDBG::tStatus2*) const
04192 {
04193    return (u16)((_softCopy & ~0x83ff) >> 0xa);
04194 }
04195
04196 inline void tTIO::tG1_MSeries_ABZ::writeG1_A_Select(u16 fieldValue, nMDBG::tStatus2* s)
04197 {
04198    setG1_A_Select(fieldValue, s);
04199    flush(s);
04200 }
04201 inline u16 tTIO::tG1_MSeries_ABZ::readG1_A_Select(nMDBG::tStatus2* s)
04202 {
04203    return getG1_A_Select(s);
04204 }
04205
04206 inline void tTIO::tG1_MSeries_ABZ::setRegisterMap(tTIO* pTIO)
04207 {
04208    _TIO = pTIO;
04209 }
04210
04211 inline tTIO::tInterrupt_G0_Ack::tInterrupt_G0_Ack()
04212 {
04213    _softCopy = 0;
04214 }
04215
04216 inline tTIO* tTIO::tInterrupt_G0_Ack::registerMap(void)
04217 {
04218    return _TIO;
04219 }
04220
04221 inline void tTIO::tInterrupt_G0_Ack::flushBus(nMDBG::tStatus2* s)
04222 {
04223    _TIO->flushBus(s);
04224 }
04225
04226 inline tTIO::tInterrupt_G0_Ack& tTIO::tInterrupt_G0_Ack::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
04227 {
04228    if (s && s->isFatal()) return *this;
04229    _softCopy = fieldValue;
04230    return *this;
04231 }
04232
04233 inline u16 tTIO::tInterrupt_G0_Ack::getRegister(nMDBG::tStatus2*) const
04234 {
04235    return _softCopy;
04236 }
04237
04238 inline void tTIO::tInterrupt_G0_Ack::flush(nMDBG::tStatus2* s)
04239 {
04240    if (s && s->isFatal()) return;
04241    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
04242    _softCopy &= (u16)(0xffff3f9f);
04243 }
04244
04245 inline void tTIO::tInterrupt_G0_Ack::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
04246 {
04247    if (s && s->isFatal()) return;
04248    _softCopy = fieldValue;
04249    flush(s);
04250 }
04251
04252 inline u16 tTIO::tInterrupt_G0_Ack::readRegister(nMDBG::tStatus2*)
04253 {
04254    return _softCopy;
04255 }
04256
04257
04258 inline tTIO::tInterrupt_G0_Ack& tTIO::tInterrupt_G0_Ack::setG0_Gate_Error_Confirm(u16 fieldValue, nMDBG::tStatus2* s)
04259 {
04260    if (s && s->isFatal()) return *this;
04261    u16 newValue;   newValue = ((u16)(_softCopy & 0xffdf)) | (((u16)fieldValue << 0x5) & ~0xffdf);
04262    setRegister(newValue, s);
04263    return *this;
04264 }
04265
04266 inline u16 tTIO::tInterrupt_G0_Ack::getG0_Gate_Error_Confirm(nMDBG::tStatus2*) const
04267 {
04268    return (u16)((_softCopy & ~0xffdf) >> 0x5);
04269 }
04270
04271 inline void tTIO::tInterrupt_G0_Ack::writeG0_Gate_Error_Confirm(u16 fieldValue, nMDBG::tStatus2* s)
04272 {
04273    setG0_Gate_Error_Confirm(fieldValue, s);
04274    flush(s);
04275 }
04276 inline u16 tTIO::tInterrupt_G0_Ack::readG0_Gate_Error_Confirm(nMDBG::tStatus2* s)
04277 {
04278    return getG0_Gate_Error_Confirm(s);
04279 }
04280
04281 inline tTIO::tInterrupt_G0_Ack& tTIO::tInterrupt_G0_Ack::setG0_TC_Error_Confirm(u16 fieldValue, nMDBG::tStatus2* s)
04282 {
04283    if (s && s->isFatal()) return *this;
04284    u16 newValue;   newValue = ((u16)(_softCopy & 0xffbf)) | (((u16)fieldValue << 0x6) & ~0xffbf);
04285    setRegister(newValue, s);
04286    return *this;
04287 }
04288
04289 inline u16 tTIO::tInterrupt_G0_Ack::getG0_TC_Error_Confirm(nMDBG::tStatus2*) const
04290 {
04291    return (u16)((_softCopy & ~0xffbf) >> 0x6);
04292 }
04293
04294 inline void tTIO::tInterrupt_G0_Ack::writeG0_TC_Error_Confirm(u16 fieldValue, nMDBG::tStatus2* s)
04295 {
04296    setG0_TC_Error_Confirm(fieldValue, s);
04297    flush(s);
04298 }
04299 inline u16 tTIO::tInterrupt_G0_Ack::readG0_TC_Error_Confirm(nMDBG::tStatus2* s)
04300 {
04301    return getG0_TC_Error_Confirm(s);
04302 }
04303
04304 inline tTIO::tInterrupt_G0_Ack& tTIO::tInterrupt_G0_Ack::setG0_TC_Interrupt_Ack(u16 fieldValue, nMDBG::tStatus2* s)
04305 {
04306    if (s && s->isFatal()) return *this;
04307    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
04308    setRegister(newValue, s);
04309    return *this;
04310 }
04311
04312 inline u16 tTIO::tInterrupt_G0_Ack::getG0_TC_Interrupt_Ack(nMDBG::tStatus2*) const
04313 {
04314    return (u16)((_softCopy & ~0xbfff) >> 0xe);
04315 }
04316
04317 inline void tTIO::tInterrupt_G0_Ack::writeG0_TC_Interrupt_Ack(u16 fieldValue, nMDBG::tStatus2* s)
04318 {
04319    setG0_TC_Interrupt_Ack(fieldValue, s);
04320    flush(s);
04321 }
04322 inline u16 tTIO::tInterrupt_G0_Ack::readG0_TC_Interrupt_Ack(nMDBG::tStatus2* s)
04323 {
04324    return getG0_TC_Interrupt_Ack(s);
04325 }
04326
04327 inline tTIO::tInterrupt_G0_Ack& tTIO::tInterrupt_G0_Ack::setG0_Gate_Interrupt_Ack(u16 fieldValue, nMDBG::tStatus2* s)
04328 {
04329    if (s && s->isFatal()) return *this;
04330    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
04331    setRegister(newValue, s);
04332    return *this;
04333 }
04334
04335 inline u16 tTIO::tInterrupt_G0_Ack::getG0_Gate_Interrupt_Ack(nMDBG::tStatus2*) const
04336 {
04337    return (u16)((_softCopy & ~0x7fff) >> 0xf);
04338 }
04339
04340 inline void tTIO::tInterrupt_G0_Ack::writeG0_Gate_Interrupt_Ack(u16 fieldValue, nMDBG::tStatus2* s)
04341 {
04342    setG0_Gate_Interrupt_Ack(fieldValue, s);
04343    flush(s);
04344 }
04345 inline u16 tTIO::tInterrupt_G0_Ack::readG0_Gate_Interrupt_Ack(nMDBG::tStatus2* s)
04346 {
04347    return getG0_Gate_Interrupt_Ack(s);
04348 }
04349
04350 inline void tTIO::tInterrupt_G0_Ack::setRegisterMap(tTIO* pTIO)
04351 {
04352    _TIO = pTIO;
04353 }
04354
04355 inline tTIO::tInterrupt_G0_Enable::tInterrupt_G0_Enable()
04356 {
04357    _softCopy = 0;
04358 }
04359
04360 inline tTIO* tTIO::tInterrupt_G0_Enable::registerMap(void)
04361 {
04362    return _TIO;
04363 }
04364
04365 inline void tTIO::tInterrupt_G0_Enable::flushBus(nMDBG::tStatus2* s)
04366 {
04367    _TIO->flushBus(s);
04368 }
04369
04370 inline tTIO::tInterrupt_G0_Enable& tTIO::tInterrupt_G0_Enable::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
04371 {
04372    if (s && s->isFatal()) return *this;
04373    _softCopy = fieldValue;
04374    return *this;
04375 }
04376
04377 inline u16 tTIO::tInterrupt_G0_Enable::getRegister(nMDBG::tStatus2*) const
04378 {
04379    return _softCopy;
04380 }
04381
04382 inline void tTIO::tInterrupt_G0_Enable::flush(nMDBG::tStatus2* s)
04383 {
04384    if (s && s->isFatal()) return;
04385    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
04386    _softCopy &= (u16)(0xffffffff);
04387 }
04388
04389 inline void tTIO::tInterrupt_G0_Enable::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
04390 {
04391    if (s && s->isFatal()) return;
04392    _softCopy = fieldValue;
04393    flush(s);
04394 }
04395
04396 inline u16 tTIO::tInterrupt_G0_Enable::readRegister(nMDBG::tStatus2*)
04397 {
04398    return _softCopy;
04399 }
04400
04401
04402 inline tTIO::tInterrupt_G0_Enable& tTIO::tInterrupt_G0_Enable::setG0_TC_Interrupt_Enable(u16 fieldValue, nMDBG::tStatus2* s)
04403 {
04404    if (s && s->isFatal()) return *this;
04405    u16 newValue;   newValue = ((u16)(_softCopy & 0xffbf)) | (((u16)fieldValue << 0x6) & ~0xffbf);
04406    setRegister(newValue, s);
04407    return *this;
04408 }
04409
04410 inline u16 tTIO::tInterrupt_G0_Enable::getG0_TC_Interrupt_Enable(nMDBG::tStatus2*) const
04411 {
04412    return (u16)((_softCopy & ~0xffbf) >> 0x6);
04413 }
04414
04415 inline void tTIO::tInterrupt_G0_Enable::writeG0_TC_Interrupt_Enable(u16 fieldValue, nMDBG::tStatus2* s)
04416 {
04417    setG0_TC_Interrupt_Enable(fieldValue, s);
04418    flush(s);
04419 }
04420 inline u16 tTIO::tInterrupt_G0_Enable::readG0_TC_Interrupt_Enable(nMDBG::tStatus2* s)
04421 {
04422    return getG0_TC_Interrupt_Enable(s);
04423 }
04424
04425 inline tTIO::tInterrupt_G0_Enable& tTIO::tInterrupt_G0_Enable::setG0_Gate_Interrupt_Enable(u16 fieldValue, nMDBG::tStatus2* s)
04426 {
04427    if (s && s->isFatal()) return *this;
04428    u16 newValue;   newValue = ((u16)(_softCopy & 0xfeff)) | (((u16)fieldValue << 0x8) & ~0xfeff);
04429    setRegister(newValue, s);
04430    return *this;
04431 }
04432
04433 inline u16 tTIO::tInterrupt_G0_Enable::getG0_Gate_Interrupt_Enable(nMDBG::tStatus2*) const
04434 {
04435    return (u16)((_softCopy & ~0xfeff) >> 0x8);
04436 }
04437
04438 inline void tTIO::tInterrupt_G0_Enable::writeG0_Gate_Interrupt_Enable(u16 fieldValue, nMDBG::tStatus2* s)
04439 {
04440    setG0_Gate_Interrupt_Enable(fieldValue, s);
04441    flush(s);
04442 }
04443 inline u16 tTIO::tInterrupt_G0_Enable::readG0_Gate_Interrupt_Enable(nMDBG::tStatus2* s)
04444 {
04445    return getG0_Gate_Interrupt_Enable(s);
04446 }
04447
04448 inline void tTIO::tInterrupt_G0_Enable::setRegisterMap(tTIO* pTIO)
04449 {
04450    _TIO = pTIO;
04451 }
04452
04453 inline tTIO::tInterrupt_G1_Ack::tInterrupt_G1_Ack()
04454 {
04455    _softCopy = 0;
04456 }
04457
04458 inline tTIO* tTIO::tInterrupt_G1_Ack::registerMap(void)
04459 {
04460    return _TIO;
04461 }
04462
04463 inline void tTIO::tInterrupt_G1_Ack::flushBus(nMDBG::tStatus2* s)
04464 {
04465    _TIO->flushBus(s);
04466 }
04467
04468 inline tTIO::tInterrupt_G1_Ack& tTIO::tInterrupt_G1_Ack::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
04469 {
04470    if (s && s->isFatal()) return *this;
04471    _softCopy = fieldValue;
04472    return *this;
04473 }
04474
04475 inline u16 tTIO::tInterrupt_G1_Ack::getRegister(nMDBG::tStatus2*) const
04476 {
04477    return _softCopy;
04478 }
04479
04480 inline void tTIO::tInterrupt_G1_Ack::flush(nMDBG::tStatus2* s)
04481 {
04482    if (s && s->isFatal()) return;
04483    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
04484    _softCopy &= (u16)(0xffff3ff9);
04485 }
04486
04487 inline void tTIO::tInterrupt_G1_Ack::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
04488 {
04489    if (s && s->isFatal()) return;
04490    _softCopy = fieldValue;
04491    flush(s);
04492 }
04493
04494 inline u16 tTIO::tInterrupt_G1_Ack::readRegister(nMDBG::tStatus2*)
04495 {
04496    return _softCopy;
04497 }
04498
04499
04500 inline tTIO::tInterrupt_G1_Ack& tTIO::tInterrupt_G1_Ack::setG1_Gate_Error_Confirm(u16 fieldValue, nMDBG::tStatus2* s)
04501 {
04502    if (s && s->isFatal()) return *this;
04503    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
04504    setRegister(newValue, s);
04505    return *this;
04506 }
04507
04508 inline u16 tTIO::tInterrupt_G1_Ack::getG1_Gate_Error_Confirm(nMDBG::tStatus2*) const
04509 {
04510    return (u16)((_softCopy & ~0xfffd) >> 0x1);
04511 }
04512
04513 inline void tTIO::tInterrupt_G1_Ack::writeG1_Gate_Error_Confirm(u16 fieldValue, nMDBG::tStatus2* s)
04514 {
04515    setG1_Gate_Error_Confirm(fieldValue, s);
04516    flush(s);
04517 }
04518 inline u16 tTIO::tInterrupt_G1_Ack::readG1_Gate_Error_Confirm(nMDBG::tStatus2* s)
04519 {
04520    return getG1_Gate_Error_Confirm(s);
04521 }
04522
04523 inline tTIO::tInterrupt_G1_Ack& tTIO::tInterrupt_G1_Ack::setG1_TC_Error_Confirm(u16 fieldValue, nMDBG::tStatus2* s)
04524 {
04525    if (s && s->isFatal()) return *this;
04526    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
04527    setRegister(newValue, s);
04528    return *this;
04529 }
04530
04531 inline u16 tTIO::tInterrupt_G1_Ack::getG1_TC_Error_Confirm(nMDBG::tStatus2*) const
04532 {
04533    return (u16)((_softCopy & ~0xfffb) >> 0x2);
04534 }
04535
04536 inline void tTIO::tInterrupt_G1_Ack::writeG1_TC_Error_Confirm(u16 fieldValue, nMDBG::tStatus2* s)
04537 {
04538    setG1_TC_Error_Confirm(fieldValue, s);
04539    flush(s);
04540 }
04541 inline u16 tTIO::tInterrupt_G1_Ack::readG1_TC_Error_Confirm(nMDBG::tStatus2* s)
04542 {
04543    return getG1_TC_Error_Confirm(s);
04544 }
04545
04546 inline tTIO::tInterrupt_G1_Ack& tTIO::tInterrupt_G1_Ack::setG1_TC_Interrupt_Ack(u16 fieldValue, nMDBG::tStatus2* s)
04547 {
04548    if (s && s->isFatal()) return *this;
04549    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
04550    setRegister(newValue, s);
04551    return *this;
04552 }
04553
04554 inline u16 tTIO::tInterrupt_G1_Ack::getG1_TC_Interrupt_Ack(nMDBG::tStatus2*) const
04555 {
04556    return (u16)((_softCopy & ~0xbfff) >> 0xe);
04557 }
04558
04559 inline void tTIO::tInterrupt_G1_Ack::writeG1_TC_Interrupt_Ack(u16 fieldValue, nMDBG::tStatus2* s)
04560 {
04561    setG1_TC_Interrupt_Ack(fieldValue, s);
04562    flush(s);
04563 }
04564 inline u16 tTIO::tInterrupt_G1_Ack::readG1_TC_Interrupt_Ack(nMDBG::tStatus2* s)
04565 {
04566    return getG1_TC_Interrupt_Ack(s);
04567 }
04568
04569 inline tTIO::tInterrupt_G1_Ack& tTIO::tInterrupt_G1_Ack::setG1_Gate_Interrupt_Ack(u16 fieldValue, nMDBG::tStatus2* s)
04570 {
04571    if (s && s->isFatal()) return *this;
04572    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
04573    setRegister(newValue, s);
04574    return *this;
04575 }
04576
04577 inline u16 tTIO::tInterrupt_G1_Ack::getG1_Gate_Interrupt_Ack(nMDBG::tStatus2*) const
04578 {
04579    return (u16)((_softCopy & ~0x7fff) >> 0xf);
04580 }
04581
04582 inline void tTIO::tInterrupt_G1_Ack::writeG1_Gate_Interrupt_Ack(u16 fieldValue, nMDBG::tStatus2* s)
04583 {
04584    setG1_Gate_Interrupt_Ack(fieldValue, s);
04585    flush(s);
04586 }
04587 inline u16 tTIO::tInterrupt_G1_Ack::readG1_Gate_Interrupt_Ack(nMDBG::tStatus2* s)
04588 {
04589    return getG1_Gate_Interrupt_Ack(s);
04590 }
04591
04592 inline void tTIO::tInterrupt_G1_Ack::setRegisterMap(tTIO* pTIO)
04593 {
04594    _TIO = pTIO;
04595 }
04596
04597 inline tTIO::tInterrupt_G1_Enable::tInterrupt_G1_Enable()
04598 {
04599    _softCopy = 0;
04600 }
04601
04602 inline tTIO* tTIO::tInterrupt_G1_Enable::registerMap(void)
04603 {
04604    return _TIO;
04605 }
04606
04607 inline void tTIO::tInterrupt_G1_Enable::flushBus(nMDBG::tStatus2* s)
04608 {
04609    _TIO->flushBus(s);
04610 }
04611
04612 inline tTIO::tInterrupt_G1_Enable& tTIO::tInterrupt_G1_Enable::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
04613 {
04614    if (s && s->isFatal()) return *this;
04615    _softCopy = fieldValue;
04616    return *this;
04617 }
04618
04619 inline u16 tTIO::tInterrupt_G1_Enable::getRegister(nMDBG::tStatus2*) const
04620 {
04621    return _softCopy;
04622 }
04623
04624 inline void tTIO::tInterrupt_G1_Enable::flush(nMDBG::tStatus2* s)
04625 {
04626    if (s && s->isFatal()) return;
04627    tIOStrategy::write(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), _softCopy, s);
04628    _softCopy &= (u16)(0xffffffff);
04629 }
04630
04631 inline void tTIO::tInterrupt_G1_Enable::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
04632 {
04633    if (s && s->isFatal()) return;
04634    _softCopy = fieldValue;
04635    flush(s);
04636 }
04637
04638 inline u16 tTIO::tInterrupt_G1_Enable::readRegister(nMDBG::tStatus2*)
04639 {
04640    return _softCopy;
04641 }
04642
04643
04644 inline tTIO::tInterrupt_G1_Enable& tTIO::tInterrupt_G1_Enable::setG1_TC_Interrupt_Enable(u16 fieldValue, nMDBG::tStatus2* s)
04645 {
04646    if (s && s->isFatal()) return *this;
04647    u16 newValue;   newValue = ((u16)(_softCopy & 0xfdff)) | (((u16)fieldValue << 0x9) & ~0xfdff);
04648    setRegister(newValue, s);
04649    return *this;
04650 }
04651
04652 inline u16 tTIO::tInterrupt_G1_Enable::getG1_TC_Interrupt_Enable(nMDBG::tStatus2*) const
04653 {
04654    return (u16)((_softCopy & ~0xfdff) >> 0x9);
04655 }
04656
04657 inline void tTIO::tInterrupt_G1_Enable::writeG1_TC_Interrupt_Enable(u16 fieldValue, nMDBG::tStatus2* s)
04658 {
04659    setG1_TC_Interrupt_Enable(fieldValue, s);
04660    flush(s);
04661 }
04662 inline u16 tTIO::tInterrupt_G1_Enable::readG1_TC_Interrupt_Enable(nMDBG::tStatus2* s)
04663 {
04664    return getG1_TC_Interrupt_Enable(s);
04665 }
04666
04667 inline tTIO::tInterrupt_G1_Enable& tTIO::tInterrupt_G1_Enable::setG1_Gate_Interrupt_Enable(u16 fieldValue, nMDBG::tStatus2* s)
04668 {
04669    if (s && s->isFatal()) return *this;
04670    u16 newValue;   newValue = ((u16)(_softCopy & 0xfbff)) | (((u16)fieldValue << 0xa) & ~0xfbff);
04671    setRegister(newValue, s);
04672    return *this;
04673 }
04674
04675 inline u16 tTIO::tInterrupt_G1_Enable::getG1_Gate_Interrupt_Enable(nMDBG::tStatus2*) const
04676 {
04677    return (u16)((_softCopy & ~0xfbff) >> 0xa);
04678 }
04679
04680 inline void tTIO::tInterrupt_G1_Enable::writeG1_Gate_Interrupt_Enable(u16 fieldValue, nMDBG::tStatus2* s)
04681 {
04682    setG1_Gate_Interrupt_Enable(fieldValue, s);
04683    flush(s);
04684 }
04685 inline u16 tTIO::tInterrupt_G1_Enable::readG1_Gate_Interrupt_Enable(nMDBG::tStatus2* s)
04686 {
04687    return getG1_Gate_Interrupt_Enable(s);
04688 }
04689
04690 inline void tTIO::tInterrupt_G1_Enable::setRegisterMap(tTIO* pTIO)
04691 {
04692    _TIO = pTIO;
04693 }
04694
04695 inline tTIO::tG0_DMA_Status::tG0_DMA_Status()
04696 {
04697    _softCopy = 0;
04698 }
04699
04700 inline tTIO* tTIO::tG0_DMA_Status::registerMap(void)
04701 {
04702    return _TIO;
04703 }
04704
04705 inline tTIO::tG0_DMA_Status& tTIO::tG0_DMA_Status::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
04706 {
04707    if (s && s->isFatal()) return *this;
04708    _softCopy = fieldValue;
04709    return *this;
04710 }
04711
04712 inline u16 tTIO::tG0_DMA_Status::getRegister(nMDBG::tStatus2*) const
04713 {
04714    return _softCopy;
04715 }
04716
04717 inline void tTIO::tG0_DMA_Status::refresh(nMDBG::tStatus2* s)
04718 {
04719    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
04720 }
04721
04722 inline u16 tTIO::tG0_DMA_Status::readRegister(nMDBG::tStatus2* s)
04723 {
04724    refresh(s);
04725    return _softCopy;
04726 }
04727
04728 inline tTIO::tG0_DMA_Status& tTIO::tG0_DMA_Status::setG0_DMA_Read_Value(u16 fieldValue, nMDBG::tStatus2* s)
04729 {
04730    if (s && s->isFatal()) return *this;
04731    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
04732    setRegister(newValue, s);
04733    return *this;
04734 }
04735
04736 inline u16 tTIO::tG0_DMA_Status::getG0_DMA_Read_Value(nMDBG::tStatus2*) const
04737 {
04738    return (u16)((_softCopy & ~0xdfff) >> 0xd);
04739 }
04740
04741 inline u16 tTIO::tG0_DMA_Status::readG0_DMA_Read_Value(nMDBG::tStatus2* s)
04742 {
04743    refresh(s);
04744    return getG0_DMA_Read_Value(s);
04745 }
04746
04747 inline tTIO::tG0_DMA_Status& tTIO::tG0_DMA_Status::setG0_DMA_Error_St(u16 fieldValue, nMDBG::tStatus2* s)
04748 {
04749    if (s && s->isFatal()) return *this;
04750    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
04751    setRegister(newValue, s);
04752    return *this;
04753 }
04754
04755 inline u16 tTIO::tG0_DMA_Status::getG0_DMA_Error_St(nMDBG::tStatus2*) const
04756 {
04757    return (u16)((_softCopy & ~0xbfff) >> 0xe);
04758 }
04759
04760 inline u16 tTIO::tG0_DMA_Status::readG0_DMA_Error_St(nMDBG::tStatus2* s)
04761 {
04762    refresh(s);
04763    return getG0_DMA_Error_St(s);
04764 }
04765
04766 inline tTIO::tG0_DMA_Status& tTIO::tG0_DMA_Status::setG0_DRQ_St(u16 fieldValue, nMDBG::tStatus2* s)
04767 {
04768    if (s && s->isFatal()) return *this;
04769    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
04770    setRegister(newValue, s);
04771    return *this;
04772 }
04773
04774 inline u16 tTIO::tG0_DMA_Status::getG0_DRQ_St(nMDBG::tStatus2*) const
04775 {
04776    return (u16)((_softCopy & ~0x7fff) >> 0xf);
04777 }
04778
04779 inline u16 tTIO::tG0_DMA_Status::readG0_DRQ_St(nMDBG::tStatus2* s)
04780 {
04781    refresh(s);
04782    return getG0_DRQ_St(s);
04783 }
04784
04785 inline void tTIO::tG0_DMA_Status::setRegisterMap(tTIO* pTIO)
04786 {
04787    _TIO = pTIO;
04788 }
04789
04790 inline tTIO::tG0_HW_Save::tG0_HW_Save()
04791 {
04792    _softCopy = 0;
04793 }
04794
04795 inline tTIO* tTIO::tG0_HW_Save::registerMap(void)
04796 {
04797    return _TIO;
04798 }
04799
04800 inline tTIO::tG0_HW_Save& tTIO::tG0_HW_Save::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
04801 {
04802    if (s && s->isFatal()) return *this;
04803    _softCopy = fieldValue;
04804    return *this;
04805 }
04806
04807 inline u32 tTIO::tG0_HW_Save::getRegister(nMDBG::tStatus2*) const
04808 {
04809    return _softCopy;
04810 }
04811
04812 inline void tTIO::tG0_HW_Save::refresh(nMDBG::tStatus2* s)
04813 {
04814    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
04815 }
04816
04817 inline u32 tTIO::tG0_HW_Save::readRegister(nMDBG::tStatus2* s)
04818 {
04819    refresh(s);
04820    return _softCopy;
04821 }
04822
04823 inline tTIO::tG0_HW_Save& tTIO::tG0_HW_Save::setG0_HW_Save_Value(u32 fieldValue, nMDBG::tStatus2* s)
04824 {
04825    if (s && s->isFatal()) return *this;
04826    u32 newValue;   newValue = ((u32)(_softCopy & 0x0)) | (((u32)fieldValue << 0x0) & ~0x0);
04827    setRegister(newValue, s);
04828    return *this;
04829 }
04830
04831 inline u32 tTIO::tG0_HW_Save::getG0_HW_Save_Value(nMDBG::tStatus2*) const
04832 {
04833    return (u32)((_softCopy & ~0x0) >> 0x0);
04834 }
04835
04836 inline u32 tTIO::tG0_HW_Save::readG0_HW_Save_Value(nMDBG::tStatus2* s)
04837 {
04838    refresh(s);
04839    return getG0_HW_Save_Value(s);
04840 }
04841
04842 inline void tTIO::tG0_HW_Save::setRegisterMap(tTIO* pTIO)
04843 {
04844    _TIO = pTIO;
04845 }
04846
04847 inline tTIO::tG0_HW_Save_High::tG0_HW_Save_High()
04848 {
04849    _softCopy = 0;
04850 }
04851
04852 inline tTIO* tTIO::tG0_HW_Save_High::registerMap(void)
04853 {
04854    return _TIO;
04855 }
04856
04857 inline tTIO::tG0_HW_Save_High& tTIO::tG0_HW_Save_High::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
04858 {
04859    if (s && s->isFatal()) return *this;
04860    _softCopy = fieldValue;
04861    return *this;
04862 }
04863
04864 inline u16 tTIO::tG0_HW_Save_High::getRegister(nMDBG::tStatus2*) const
04865 {
04866    return _softCopy;
04867 }
04868
04869 inline void tTIO::tG0_HW_Save_High::refresh(nMDBG::tStatus2* s)
04870 {
04871    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
04872 }
04873
04874 inline u16 tTIO::tG0_HW_Save_High::readRegister(nMDBG::tStatus2* s)
04875 {
04876    refresh(s);
04877    return _softCopy;
04878 }
04879
04880 inline tTIO::tG0_HW_Save_High& tTIO::tG0_HW_Save_High::setG0_HW_Save_High_Value(u16 fieldValue, nMDBG::tStatus2* s)
04881 {
04882    if (s && s->isFatal()) return *this;
04883    u16 newValue;   newValue = ((u16)(_softCopy & 0x0)) | (((u16)fieldValue << 0x0) & ~0x0);
04884    setRegister(newValue, s);
04885    return *this;
04886 }
04887
04888 inline u16 tTIO::tG0_HW_Save_High::getG0_HW_Save_High_Value(nMDBG::tStatus2*) const
04889 {
04890    return (u16)((_softCopy & ~0x0) >> 0x0);
04891 }
04892
04893 inline u16 tTIO::tG0_HW_Save_High::readG0_HW_Save_High_Value(nMDBG::tStatus2* s)
04894 {
04895    refresh(s);
04896    return getG0_HW_Save_High_Value(s);
04897 }
04898
04899 inline void tTIO::tG0_HW_Save_High::setRegisterMap(tTIO* pTIO)
04900 {
04901    _TIO = pTIO;
04902 }
04903
04904 inline tTIO::tG0_HW_Save_Low::tG0_HW_Save_Low()
04905 {
04906    _softCopy = 0;
04907 }
04908
04909 inline tTIO* tTIO::tG0_HW_Save_Low::registerMap(void)
04910 {
04911    return _TIO;
04912 }
04913
04914 inline tTIO::tG0_HW_Save_Low& tTIO::tG0_HW_Save_Low::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
04915 {
04916    if (s && s->isFatal()) return *this;
04917    _softCopy = fieldValue;
04918    return *this;
04919 }
04920
04921 inline u16 tTIO::tG0_HW_Save_Low::getRegister(nMDBG::tStatus2*) const
04922 {
04923    return _softCopy;
04924 }
04925
04926 inline void tTIO::tG0_HW_Save_Low::refresh(nMDBG::tStatus2* s)
04927 {
04928    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
04929 }
04930
04931 inline u16 tTIO::tG0_HW_Save_Low::readRegister(nMDBG::tStatus2* s)
04932 {
04933    refresh(s);
04934    return _softCopy;
04935 }
04936
04937 inline tTIO::tG0_HW_Save_Low& tTIO::tG0_HW_Save_Low::setG0_HW_Save_Low_Value(u16 fieldValue, nMDBG::tStatus2* s)
04938 {
04939    if (s && s->isFatal()) return *this;
04940    u16 newValue;   newValue = ((u16)(_softCopy & 0x0)) | (((u16)fieldValue << 0x0) & ~0x0);
04941    setRegister(newValue, s);
04942    return *this;
04943 }
04944
04945 inline u16 tTIO::tG0_HW_Save_Low::getG0_HW_Save_Low_Value(nMDBG::tStatus2*) const
04946 {
04947    return (u16)((_softCopy & ~0x0) >> 0x0);
04948 }
04949
04950 inline u16 tTIO::tG0_HW_Save_Low::readG0_HW_Save_Low_Value(nMDBG::tStatus2* s)
04951 {
04952    refresh(s);
04953    return getG0_HW_Save_Low_Value(s);
04954 }
04955
04956 inline void tTIO::tG0_HW_Save_Low::setRegisterMap(tTIO* pTIO)
04957 {
04958    _TIO = pTIO;
04959 }
04960
04961 inline tTIO::tG0_Save::tG0_Save()
04962 {
04963    _softCopy = 0;
04964 }
04965
04966 inline tTIO* tTIO::tG0_Save::registerMap(void)
04967 {
04968    return _TIO;
04969 }
04970
04971 inline tTIO::tG0_Save& tTIO::tG0_Save::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
04972 {
04973    if (s && s->isFatal()) return *this;
04974    _softCopy = fieldValue;
04975    return *this;
04976 }
04977
04978 inline u32 tTIO::tG0_Save::getRegister(nMDBG::tStatus2*) const
04979 {
04980    return _softCopy;
04981 }
04982
04983 inline void tTIO::tG0_Save::refresh(nMDBG::tStatus2* s)
04984 {
04985    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
04986 }
04987
04988 inline u32 tTIO::tG0_Save::readRegister(nMDBG::tStatus2* s)
04989 {
04990    refresh(s);
04991    return _softCopy;
04992 }
04993
04994 inline tTIO::tG0_Save& tTIO::tG0_Save::setG0_Save_Value(u32 fieldValue, nMDBG::tStatus2* s)
04995 {
04996    if (s && s->isFatal()) return *this;
04997    u32 newValue;   newValue = ((u32)(_softCopy & 0x0)) | (((u32)fieldValue << 0x0) & ~0x0);
04998    setRegister(newValue, s);
04999    return *this;
05000 }
05001
05002 inline u32 tTIO::tG0_Save::getG0_Save_Value(nMDBG::tStatus2*) const
05003 {
05004    return (u32)((_softCopy & ~0x0) >> 0x0);
05005 }
05006
05007 inline u32 tTIO::tG0_Save::readG0_Save_Value(nMDBG::tStatus2* s)
05008 {
05009    refresh(s);
05010    return getG0_Save_Value(s);
05011 }
05012
05013 inline void tTIO::tG0_Save::setRegisterMap(tTIO* pTIO)
05014 {
05015    _TIO = pTIO;
05016 }
05017
05018 inline tTIO::tG0_Save_High::tG0_Save_High()
05019 {
05020    _softCopy = 0;
05021 }
05022
05023 inline tTIO* tTIO::tG0_Save_High::registerMap(void)
05024 {
05025    return _TIO;
05026 }
05027
05028 inline tTIO::tG0_Save_High& tTIO::tG0_Save_High::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
05029 {
05030    if (s && s->isFatal()) return *this;
05031    _softCopy = fieldValue;
05032    return *this;
05033 }
05034
05035 inline u16 tTIO::tG0_Save_High::getRegister(nMDBG::tStatus2*) const
05036 {
05037    return _softCopy;
05038 }
05039
05040 inline void tTIO::tG0_Save_High::refresh(nMDBG::tStatus2* s)
05041 {
05042    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
05043 }
05044
05045 inline u16 tTIO::tG0_Save_High::readRegister(nMDBG::tStatus2* s)
05046 {
05047    refresh(s);
05048    return _softCopy;
05049 }
05050
05051 inline tTIO::tG0_Save_High& tTIO::tG0_Save_High::setG0_Save_High_Value(u16 fieldValue, nMDBG::tStatus2* s)
05052 {
05053    if (s && s->isFatal()) return *this;
05054    u16 newValue;   newValue = ((u16)(_softCopy & 0x0)) | (((u16)fieldValue << 0x0) & ~0x0);
05055    setRegister(newValue, s);
05056    return *this;
05057 }
05058
05059 inline u16 tTIO::tG0_Save_High::getG0_Save_High_Value(nMDBG::tStatus2*) const
05060 {
05061    return (u16)((_softCopy & ~0x0) >> 0x0);
05062 }
05063
05064 inline u16 tTIO::tG0_Save_High::readG0_Save_High_Value(nMDBG::tStatus2* s)
05065 {
05066    refresh(s);
05067    return getG0_Save_High_Value(s);
05068 }
05069
05070 inline void tTIO::tG0_Save_High::setRegisterMap(tTIO* pTIO)
05071 {
05072    _TIO = pTIO;
05073 }
05074
05075 inline tTIO::tG0_Save_Low::tG0_Save_Low()
05076 {
05077    _softCopy = 0;
05078 }
05079
05080 inline tTIO* tTIO::tG0_Save_Low::registerMap(void)
05081 {
05082    return _TIO;
05083 }
05084
05085 inline tTIO::tG0_Save_Low& tTIO::tG0_Save_Low::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
05086 {
05087    if (s && s->isFatal()) return *this;
05088    _softCopy = fieldValue;
05089    return *this;
05090 }
05091
05092 inline u16 tTIO::tG0_Save_Low::getRegister(nMDBG::tStatus2*) const
05093 {
05094    return _softCopy;
05095 }
05096
05097 inline void tTIO::tG0_Save_Low::refresh(nMDBG::tStatus2* s)
05098 {
05099    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
05100 }
05101
05102 inline u16 tTIO::tG0_Save_Low::readRegister(nMDBG::tStatus2* s)
05103 {
05104    refresh(s);
05105    return _softCopy;
05106 }
05107
05108 inline tTIO::tG0_Save_Low& tTIO::tG0_Save_Low::setG0_Save_Low_Value(u16 fieldValue, nMDBG::tStatus2* s)
05109 {
05110    if (s && s->isFatal()) return *this;
05111    u16 newValue;   newValue = ((u16)(_softCopy & 0x0)) | (((u16)fieldValue << 0x0) & ~0x0);
05112    setRegister(newValue, s);
05113    return *this;
05114 }
05115
05116 inline u16 tTIO::tG0_Save_Low::getG0_Save_Low_Value(nMDBG::tStatus2*) const
05117 {
05118    return (u16)((_softCopy & ~0x0) >> 0x0);
05119 }
05120
05121 inline u16 tTIO::tG0_Save_Low::readG0_Save_Low_Value(nMDBG::tStatus2* s)
05122 {
05123    refresh(s);
05124    return getG0_Save_Low_Value(s);
05125 }
05126
05127 inline void tTIO::tG0_Save_Low::setRegisterMap(tTIO* pTIO)
05128 {
05129    _TIO = pTIO;
05130 }
05131
05132 inline tTIO::tG0_Status_1::tG0_Status_1()
05133 {
05134    _softCopy = 0;
05135 }
05136
05137 inline tTIO* tTIO::tG0_Status_1::registerMap(void)
05138 {
05139    return _TIO;
05140 }
05141
05142 inline tTIO::tG0_Status_1& tTIO::tG0_Status_1::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
05143 {
05144    if (s && s->isFatal()) return *this;
05145    _softCopy = fieldValue;
05146    return *this;
05147 }
05148
05149 inline u16 tTIO::tG0_Status_1::getRegister(nMDBG::tStatus2*) const
05150 {
05151    return _softCopy;
05152 }
05153
05154 inline void tTIO::tG0_Status_1::refresh(nMDBG::tStatus2* s)
05155 {
05156    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
05157 }
05158
05159 inline u16 tTIO::tG0_Status_1::readRegister(nMDBG::tStatus2* s)
05160 {
05161    refresh(s);
05162    return _softCopy;
05163 }
05164
05165 inline tTIO::tG0_Status_1& tTIO::tG0_Status_1::setG0_Gate_Interrupt_St(u16 fieldValue, nMDBG::tStatus2* s)
05166 {
05167    if (s && s->isFatal()) return *this;
05168    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
05169    setRegister(newValue, s);
05170    return *this;
05171 }
05172
05173 inline u16 tTIO::tG0_Status_1::getG0_Gate_Interrupt_St(nMDBG::tStatus2*) const
05174 {
05175    return (u16)((_softCopy & ~0xfffb) >> 0x2);
05176 }
05177
05178 inline u16 tTIO::tG0_Status_1::readG0_Gate_Interrupt_St(nMDBG::tStatus2* s)
05179 {
05180    refresh(s);
05181    return getG0_Gate_Interrupt_St(s);
05182 }
05183
05184 inline tTIO::tG0_Status_1& tTIO::tG0_Status_1::setG0_TC_St(u16 fieldValue, nMDBG::tStatus2* s)
05185 {
05186    if (s && s->isFatal()) return *this;
05187    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff7)) | (((u16)fieldValue << 0x3) & ~0xfff7);
05188    setRegister(newValue, s);
05189    return *this;
05190 }
05191
05192 inline u16 tTIO::tG0_Status_1::getG0_TC_St(nMDBG::tStatus2*) const
05193 {
05194    return (u16)((_softCopy & ~0xfff7) >> 0x3);
05195 }
05196
05197 inline u16 tTIO::tG0_Status_1::readG0_TC_St(nMDBG::tStatus2* s)
05198 {
05199    refresh(s);
05200    return getG0_TC_St(s);
05201 }
05202
05203 inline tTIO::tG0_Status_1& tTIO::tG0_Status_1::setG0_Interrupt_St(u16 fieldValue, nMDBG::tStatus2* s)
05204 {
05205    if (s && s->isFatal()) return *this;
05206    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
05207    setRegister(newValue, s);
05208    return *this;
05209 }
05210
05211 inline u16 tTIO::tG0_Status_1::getG0_Interrupt_St(nMDBG::tStatus2*) const
05212 {
05213    return (u16)((_softCopy & ~0x7fff) >> 0xf);
05214 }
05215
05216 inline u16 tTIO::tG0_Status_1::readG0_Interrupt_St(nMDBG::tStatus2* s)
05217 {
05218    refresh(s);
05219    return getG0_Interrupt_St(s);
05220 }
05221
05222 inline void tTIO::tG0_Status_1::setRegisterMap(tTIO* pTIO)
05223 {
05224    _TIO = pTIO;
05225 }
05226
05227 inline tTIO::tG01_Joint_Status_1::tG01_Joint_Status_1()
05228 {
05229    _softCopy = 0;
05230 }
05231
05232 inline tTIO* tTIO::tG01_Joint_Status_1::registerMap(void)
05233 {
05234    return _TIO;
05235 }
05236
05237 inline tTIO::tG01_Joint_Status_1& tTIO::tG01_Joint_Status_1::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
05238 {
05239    if (s && s->isFatal()) return *this;
05240    _softCopy = fieldValue;
05241    return *this;
05242 }
05243
05244 inline u16 tTIO::tG01_Joint_Status_1::getRegister(nMDBG::tStatus2*) const
05245 {
05246    return _softCopy;
05247 }
05248
05249 inline void tTIO::tG01_Joint_Status_1::refresh(nMDBG::tStatus2* s)
05250 {
05251    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
05252 }
05253
05254 inline u16 tTIO::tG01_Joint_Status_1::readRegister(nMDBG::tStatus2* s)
05255 {
05256    refresh(s);
05257    return _softCopy;
05258 }
05259
05260 inline tTIO::tG01_Joint_Status_1& tTIO::tG01_Joint_Status_1::setG0_Bank_St(u16 fieldValue, nMDBG::tStatus2* s)
05261 {
05262    if (s && s->isFatal()) return *this;
05263    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
05264    setRegister(newValue, s);
05265    return *this;
05266 }
05267
05268 inline u16 tTIO::tG01_Joint_Status_1::getG0_Bank_St(nMDBG::tStatus2*) const
05269 {
05270    return (u16)((_softCopy & ~0xfffe) >> 0x0);
05271 }
05272
05273 inline u16 tTIO::tG01_Joint_Status_1::readG0_Bank_St(nMDBG::tStatus2* s)
05274 {
05275    refresh(s);
05276    return getG0_Bank_St(s);
05277 }
05278
05279 inline tTIO::tG01_Joint_Status_1& tTIO::tG01_Joint_Status_1::setG1_Bank_St(u16 fieldValue, nMDBG::tStatus2* s)
05280 {
05281    if (s && s->isFatal()) return *this;
05282    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
05283    setRegister(newValue, s);
05284    return *this;
05285 }
05286
05287 inline u16 tTIO::tG01_Joint_Status_1::getG1_Bank_St(nMDBG::tStatus2*) const
05288 {
05289    return (u16)((_softCopy & ~0xfffd) >> 0x1);
05290 }
05291
05292 inline u16 tTIO::tG01_Joint_Status_1::readG1_Bank_St(nMDBG::tStatus2* s)
05293 {
05294    refresh(s);
05295    return getG1_Bank_St(s);
05296 }
05297
05298 inline tTIO::tG01_Joint_Status_1& tTIO::tG01_Joint_Status_1::setG0_Gate_St(u16 fieldValue, nMDBG::tStatus2* s)
05299 {
05300    if (s && s->isFatal()) return *this;
05301    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
05302    setRegister(newValue, s);
05303    return *this;
05304 }
05305
05306 inline u16 tTIO::tG01_Joint_Status_1::getG0_Gate_St(nMDBG::tStatus2*) const
05307 {
05308    return (u16)((_softCopy & ~0xfffb) >> 0x2);
05309 }
05310
05311 inline u16 tTIO::tG01_Joint_Status_1::readG0_Gate_St(nMDBG::tStatus2* s)
05312 {
05313    refresh(s);
05314    return getG0_Gate_St(s);
05315 }
05316
05317 inline tTIO::tG01_Joint_Status_1& tTIO::tG01_Joint_Status_1::setG1_Gate_St(u16 fieldValue, nMDBG::tStatus2* s)
05318 {
05319    if (s && s->isFatal()) return *this;
05320    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff7)) | (((u16)fieldValue << 0x3) & ~0xfff7);
05321    setRegister(newValue, s);
05322    return *this;
05323 }
05324
05325 inline u16 tTIO::tG01_Joint_Status_1::getG1_Gate_St(nMDBG::tStatus2*) const
05326 {
05327    return (u16)((_softCopy & ~0xfff7) >> 0x3);
05328 }
05329
05330 inline u16 tTIO::tG01_Joint_Status_1::readG1_Gate_St(nMDBG::tStatus2* s)
05331 {
05332    refresh(s);
05333    return getG1_Gate_St(s);
05334 }
05335
05336 inline tTIO::tG01_Joint_Status_1& tTIO::tG01_Joint_Status_1::setG01_DIO_Serial_IO_In_Progress_St(u16 fieldValue, nMDBG::tStatus2* s)
05337 {
05338    if (s && s->isFatal()) return *this;
05339    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
05340    setRegister(newValue, s);
05341    return *this;
05342 }
05343
05344 inline u16 tTIO::tG01_Joint_Status_1::getG01_DIO_Serial_IO_In_Progress_St(nMDBG::tStatus2*) const
05345 {
05346    return (u16)((_softCopy & ~0xefff) >> 0xc);
05347 }
05348
05349 inline u16 tTIO::tG01_Joint_Status_1::readG01_DIO_Serial_IO_In_Progress_St(nMDBG::tStatus2* s)
05350 {
05351    refresh(s);
05352    return getG01_DIO_Serial_IO_In_Progress_St(s);
05353 }
05354
05355 inline void tTIO::tG01_Joint_Status_1::setRegisterMap(tTIO* pTIO)
05356 {
05357    _TIO = pTIO;
05358 }
05359
05360 inline tTIO::tG01_Joint_Status_2::tG01_Joint_Status_2()
05361 {
05362    _softCopy = 0;
05363 }
05364
05365 inline tTIO* tTIO::tG01_Joint_Status_2::registerMap(void)
05366 {
05367    return _TIO;
05368 }
05369
05370 inline tTIO::tG01_Joint_Status_2& tTIO::tG01_Joint_Status_2::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
05371 {
05372    if (s && s->isFatal()) return *this;
05373    _softCopy = fieldValue;
05374    return *this;
05375 }
05376
05377 inline u16 tTIO::tG01_Joint_Status_2::getRegister(nMDBG::tStatus2*) const
05378 {
05379    return _softCopy;
05380 }
05381
05382 inline void tTIO::tG01_Joint_Status_2::refresh(nMDBG::tStatus2* s)
05383 {
05384    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
05385 }
05386
05387 inline u16 tTIO::tG01_Joint_Status_2::readRegister(nMDBG::tStatus2* s)
05388 {
05389    refresh(s);
05390    return _softCopy;
05391 }
05392
05393 inline tTIO::tG01_Joint_Status_2& tTIO::tG01_Joint_Status_2::setG0_Output_St(u16 fieldValue, nMDBG::tStatus2* s)
05394 {
05395    if (s && s->isFatal()) return *this;
05396    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
05397    setRegister(newValue, s);
05398    return *this;
05399 }
05400
05401 inline u16 tTIO::tG01_Joint_Status_2::getG0_Output_St(nMDBG::tStatus2*) const
05402 {
05403    return (u16)((_softCopy & ~0xfffe) >> 0x0);
05404 }
05405
05406 inline u16 tTIO::tG01_Joint_Status_2::readG0_Output_St(nMDBG::tStatus2* s)
05407 {
05408    refresh(s);
05409    return getG0_Output_St(s);
05410 }
05411
05412 inline tTIO::tG01_Joint_Status_2& tTIO::tG01_Joint_Status_2::setG1_Output_St(u16 fieldValue, nMDBG::tStatus2* s)
05413 {
05414    if (s && s->isFatal()) return *this;
05415    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
05416    setRegister(newValue, s);
05417    return *this;
05418 }
05419
05420 inline u16 tTIO::tG01_Joint_Status_2::getG1_Output_St(nMDBG::tStatus2*) const
05421 {
05422    return (u16)((_softCopy & ~0xfffd) >> 0x1);
05423 }
05424
05425 inline u16 tTIO::tG01_Joint_Status_2::readG1_Output_St(nMDBG::tStatus2* s)
05426 {
05427    refresh(s);
05428    return getG1_Output_St(s);
05429 }
05430
05431 inline tTIO::tG01_Joint_Status_2& tTIO::tG01_Joint_Status_2::setG0_HW_Save_St(u16 fieldValue, nMDBG::tStatus2* s)
05432 {
05433    if (s && s->isFatal()) return *this;
05434    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
05435    setRegister(newValue, s);
05436    return *this;
05437 }
05438
05439 inline u16 tTIO::tG01_Joint_Status_2::getG0_HW_Save_St(nMDBG::tStatus2*) const
05440 {
05441    return (u16)((_softCopy & ~0xefff) >> 0xc);
05442 }
05443
05444 inline u16 tTIO::tG01_Joint_Status_2::readG0_HW_Save_St(nMDBG::tStatus2* s)
05445 {
05446    refresh(s);
05447    return getG0_HW_Save_St(s);
05448 }
05449
05450 inline tTIO::tG01_Joint_Status_2& tTIO::tG01_Joint_Status_2::setG1_HW_Save_St(u16 fieldValue, nMDBG::tStatus2* s)
05451 {
05452    if (s && s->isFatal()) return *this;
05453    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
05454    setRegister(newValue, s);
05455    return *this;
05456 }
05457
05458 inline u16 tTIO::tG01_Joint_Status_2::getG1_HW_Save_St(nMDBG::tStatus2*) const
05459 {
05460    return (u16)((_softCopy & ~0xdfff) >> 0xd);
05461 }
05462
05463 inline u16 tTIO::tG01_Joint_Status_2::readG1_HW_Save_St(nMDBG::tStatus2* s)
05464 {
05465    refresh(s);
05466    return getG1_HW_Save_St(s);
05467 }
05468
05469 inline tTIO::tG01_Joint_Status_2& tTIO::tG01_Joint_Status_2::setG0_Permanent_Stale_Data_St(u16 fieldValue, nMDBG::tStatus2* s)
05470 {
05471    if (s && s->isFatal()) return *this;
05472    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
05473    setRegister(newValue, s);
05474    return *this;
05475 }
05476
05477 inline u16 tTIO::tG01_Joint_Status_2::getG0_Permanent_Stale_Data_St(nMDBG::tStatus2*) const
05478 {
05479    return (u16)((_softCopy & ~0xbfff) >> 0xe);
05480 }
05481
05482 inline u16 tTIO::tG01_Joint_Status_2::readG0_Permanent_Stale_Data_St(nMDBG::tStatus2* s)
05483 {
05484    refresh(s);
05485    return getG0_Permanent_Stale_Data_St(s);
05486 }
05487
05488 inline tTIO::tG01_Joint_Status_2& tTIO::tG01_Joint_Status_2::setG1_Permanent_Stale_Data_St(u16 fieldValue, nMDBG::tStatus2* s)
05489 {
05490    if (s && s->isFatal()) return *this;
05491    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
05492    setRegister(newValue, s);
05493    return *this;
05494 }
05495
05496 inline u16 tTIO::tG01_Joint_Status_2::getG1_Permanent_Stale_Data_St(nMDBG::tStatus2*) const
05497 {
05498    return (u16)((_softCopy & ~0x7fff) >> 0xf);
05499 }
05500
05501 inline u16 tTIO::tG01_Joint_Status_2::readG1_Permanent_Stale_Data_St(nMDBG::tStatus2* s)
05502 {
05503    refresh(s);
05504    return getG1_Permanent_Stale_Data_St(s);
05505 }
05506
05507 inline void tTIO::tG01_Joint_Status_2::setRegisterMap(tTIO* pTIO)
05508 {
05509    _TIO = pTIO;
05510 }
05511
05512 inline tTIO::tG01_Status::tG01_Status()
05513 {
05514    _softCopy = 0;
05515 }
05516
05517 inline tTIO* tTIO::tG01_Status::registerMap(void)
05518 {
05519    return _TIO;
05520 }
05521
05522 inline tTIO::tG01_Status& tTIO::tG01_Status::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
05523 {
05524    if (s && s->isFatal()) return *this;
05525    _softCopy = fieldValue;
05526    return *this;
05527 }
05528
05529 inline u16 tTIO::tG01_Status::getRegister(nMDBG::tStatus2*) const
05530 {
05531    return _softCopy;
05532 }
05533
05534 inline void tTIO::tG01_Status::refresh(nMDBG::tStatus2* s)
05535 {
05536    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
05537 }
05538
05539 inline u16 tTIO::tG01_Status::readRegister(nMDBG::tStatus2* s)
05540 {
05541    refresh(s);
05542    return _softCopy;
05543 }
05544
05545 inline tTIO::tG01_Status& tTIO::tG01_Status::setG0_Save_St(u16 fieldValue, nMDBG::tStatus2* s)
05546 {
05547    if (s && s->isFatal()) return *this;
05548    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffe)) | (((u16)fieldValue << 0x0) & ~0xfffe);
05549    setRegister(newValue, s);
05550    return *this;
05551 }
05552
05553 inline u16 tTIO::tG01_Status::getG0_Save_St(nMDBG::tStatus2*) const
05554 {
05555    return (u16)((_softCopy & ~0xfffe) >> 0x0);
05556 }
05557
05558 inline u16 tTIO::tG01_Status::readG0_Save_St(nMDBG::tStatus2* s)
05559 {
05560    refresh(s);
05561    return getG0_Save_St(s);
05562 }
05563
05564 inline tTIO::tG01_Status& tTIO::tG01_Status::setG1_Save_St(u16 fieldValue, nMDBG::tStatus2* s)
05565 {
05566    if (s && s->isFatal()) return *this;
05567    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffd)) | (((u16)fieldValue << 0x1) & ~0xfffd);
05568    setRegister(newValue, s);
05569    return *this;
05570 }
05571
05572 inline u16 tTIO::tG01_Status::getG1_Save_St(nMDBG::tStatus2*) const
05573 {
05574    return (u16)((_softCopy & ~0xfffd) >> 0x1);
05575 }
05576
05577 inline u16 tTIO::tG01_Status::readG1_Save_St(nMDBG::tStatus2* s)
05578 {
05579    refresh(s);
05580    return getG1_Save_St(s);
05581 }
05582
05583 inline tTIO::tG01_Status& tTIO::tG01_Status::setG0_Counting_St(u16 fieldValue, nMDBG::tStatus2* s)
05584 {
05585    if (s && s->isFatal()) return *this;
05586    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
05587    setRegister(newValue, s);
05588    return *this;
05589 }
05590
05591 inline u16 tTIO::tG01_Status::getG0_Counting_St(nMDBG::tStatus2*) const
05592 {
05593    return (u16)((_softCopy & ~0xfffb) >> 0x2);
05594 }
05595
05596 inline u16 tTIO::tG01_Status::readG0_Counting_St(nMDBG::tStatus2* s)
05597 {
05598    refresh(s);
05599    return getG0_Counting_St(s);
05600 }
05601
05602 inline tTIO::tG01_Status& tTIO::tG01_Status::setG1_Counting_St(u16 fieldValue, nMDBG::tStatus2* s)
05603 {
05604    if (s && s->isFatal()) return *this;
05605    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff7)) | (((u16)fieldValue << 0x3) & ~0xfff7);
05606    setRegister(newValue, s);
05607    return *this;
05608 }
05609
05610 inline u16 tTIO::tG01_Status::getG1_Counting_St(nMDBG::tStatus2*) const
05611 {
05612    return (u16)((_softCopy & ~0xfff7) >> 0x3);
05613 }
05614
05615 inline u16 tTIO::tG01_Status::readG1_Counting_St(nMDBG::tStatus2* s)
05616 {
05617    refresh(s);
05618    return getG1_Counting_St(s);
05619 }
05620
05621 inline tTIO::tG01_Status& tTIO::tG01_Status::setG0_Next_Load_Source_St(u16 fieldValue, nMDBG::tStatus2* s)
05622 {
05623    if (s && s->isFatal()) return *this;
05624    u16 newValue;   newValue = ((u16)(_softCopy & 0xffef)) | (((u16)fieldValue << 0x4) & ~0xffef);
05625    setRegister(newValue, s);
05626    return *this;
05627 }
05628
05629 inline u16 tTIO::tG01_Status::getG0_Next_Load_Source_St(nMDBG::tStatus2*) const
05630 {
05631    return (u16)((_softCopy & ~0xffef) >> 0x4);
05632 }
05633
05634 inline u16 tTIO::tG01_Status::readG0_Next_Load_Source_St(nMDBG::tStatus2* s)
05635 {
05636    refresh(s);
05637    return getG0_Next_Load_Source_St(s);
05638 }
05639
05640 inline tTIO::tG01_Status& tTIO::tG01_Status::setG1_Next_Load_Source_St(u16 fieldValue, nMDBG::tStatus2* s)
05641 {
05642    if (s && s->isFatal()) return *this;
05643    u16 newValue;   newValue = ((u16)(_softCopy & 0xffdf)) | (((u16)fieldValue << 0x5) & ~0xffdf);
05644    setRegister(newValue, s);
05645    return *this;
05646 }
05647
05648 inline u16 tTIO::tG01_Status::getG1_Next_Load_Source_St(nMDBG::tStatus2*) const
05649 {
05650    return (u16)((_softCopy & ~0xffdf) >> 0x5);
05651 }
05652
05653 inline u16 tTIO::tG01_Status::readG1_Next_Load_Source_St(nMDBG::tStatus2* s)
05654 {
05655    refresh(s);
05656    return getG1_Next_Load_Source_St(s);
05657 }
05658
05659 inline tTIO::tG01_Status& tTIO::tG01_Status::setG0_Stale_Data_St(u16 fieldValue, nMDBG::tStatus2* s)
05660 {
05661    if (s && s->isFatal()) return *this;
05662    u16 newValue;   newValue = ((u16)(_softCopy & 0xffbf)) | (((u16)fieldValue << 0x6) & ~0xffbf);
05663    setRegister(newValue, s);
05664    return *this;
05665 }
05666
05667 inline u16 tTIO::tG01_Status::getG0_Stale_Data_St(nMDBG::tStatus2*) const
05668 {
05669    return (u16)((_softCopy & ~0xffbf) >> 0x6);
05670 }
05671
05672 inline u16 tTIO::tG01_Status::readG0_Stale_Data_St(nMDBG::tStatus2* s)
05673 {
05674    refresh(s);
05675    return getG0_Stale_Data_St(s);
05676 }
05677
05678 inline tTIO::tG01_Status& tTIO::tG01_Status::setG1_Stale_Data_St(u16 fieldValue, nMDBG::tStatus2* s)
05679 {
05680    if (s && s->isFatal()) return *this;
05681    u16 newValue;   newValue = ((u16)(_softCopy & 0xff7f)) | (((u16)fieldValue << 0x7) & ~0xff7f);
05682    setRegister(newValue, s);
05683    return *this;
05684 }
05685
05686 inline u16 tTIO::tG01_Status::getG1_Stale_Data_St(nMDBG::tStatus2*) const
05687 {
05688    return (u16)((_softCopy & ~0xff7f) >> 0x7);
05689 }
05690
05691 inline u16 tTIO::tG01_Status::readG1_Stale_Data_St(nMDBG::tStatus2* s)
05692 {
05693    refresh(s);
05694    return getG1_Stale_Data_St(s);
05695 }
05696
05697 inline tTIO::tG01_Status& tTIO::tG01_Status::setG0_Armed_St(u16 fieldValue, nMDBG::tStatus2* s)
05698 {
05699    if (s && s->isFatal()) return *this;
05700    u16 newValue;   newValue = ((u16)(_softCopy & 0xfeff)) | (((u16)fieldValue << 0x8) & ~0xfeff);
05701    setRegister(newValue, s);
05702    return *this;
05703 }
05704
05705 inline u16 tTIO::tG01_Status::getG0_Armed_St(nMDBG::tStatus2*) const
05706 {
05707    return (u16)((_softCopy & ~0xfeff) >> 0x8);
05708 }
05709
05710 inline u16 tTIO::tG01_Status::readG0_Armed_St(nMDBG::tStatus2* s)
05711 {
05712    refresh(s);
05713    return getG0_Armed_St(s);
05714 }
05715
05716 inline tTIO::tG01_Status& tTIO::tG01_Status::setG1_Armed_St(u16 fieldValue, nMDBG::tStatus2* s)
05717 {
05718    if (s && s->isFatal()) return *this;
05719    u16 newValue;   newValue = ((u16)(_softCopy & 0xfdff)) | (((u16)fieldValue << 0x9) & ~0xfdff);
05720    setRegister(newValue, s);
05721    return *this;
05722 }
05723
05724 inline u16 tTIO::tG01_Status::getG1_Armed_St(nMDBG::tStatus2*) const
05725 {
05726    return (u16)((_softCopy & ~0xfdff) >> 0x9);
05727 }
05728
05729 inline u16 tTIO::tG01_Status::readG1_Armed_St(nMDBG::tStatus2* s)
05730 {
05731    refresh(s);
05732    return getG1_Armed_St(s);
05733 }
05734
05735 inline tTIO::tG01_Status& tTIO::tG01_Status::setG0_No_Load_Between_Gates_St(u16 fieldValue, nMDBG::tStatus2* s)
05736 {
05737    if (s && s->isFatal()) return *this;
05738    u16 newValue;   newValue = ((u16)(_softCopy & 0xfbff)) | (((u16)fieldValue << 0xa) & ~0xfbff);
05739    setRegister(newValue, s);
05740    return *this;
05741 }
05742
05743 inline u16 tTIO::tG01_Status::getG0_No_Load_Between_Gates_St(nMDBG::tStatus2*) const
05744 {
05745    return (u16)((_softCopy & ~0xfbff) >> 0xa);
05746 }
05747
05748 inline u16 tTIO::tG01_Status::readG0_No_Load_Between_Gates_St(nMDBG::tStatus2* s)
05749 {
05750    refresh(s);
05751    return getG0_No_Load_Between_Gates_St(s);
05752 }
05753
05754 inline tTIO::tG01_Status& tTIO::tG01_Status::setG1_No_Load_Between_Gates_St(u16 fieldValue, nMDBG::tStatus2* s)
05755 {
05756    if (s && s->isFatal()) return *this;
05757    u16 newValue;   newValue = ((u16)(_softCopy & 0xf7ff)) | (((u16)fieldValue << 0xb) & ~0xf7ff);
05758    setRegister(newValue, s);
05759    return *this;
05760 }
05761
05762 inline u16 tTIO::tG01_Status::getG1_No_Load_Between_Gates_St(nMDBG::tStatus2*) const
05763 {
05764    return (u16)((_softCopy & ~0xf7ff) >> 0xb);
05765 }
05766
05767 inline u16 tTIO::tG01_Status::readG1_No_Load_Between_Gates_St(nMDBG::tStatus2* s)
05768 {
05769    refresh(s);
05770    return getG1_No_Load_Between_Gates_St(s);
05771 }
05772
05773 inline tTIO::tG01_Status& tTIO::tG01_Status::setG0_TC_Error_St(u16 fieldValue, nMDBG::tStatus2* s)
05774 {
05775    if (s && s->isFatal()) return *this;
05776    u16 newValue;   newValue = ((u16)(_softCopy & 0xefff)) | (((u16)fieldValue << 0xc) & ~0xefff);
05777    setRegister(newValue, s);
05778    return *this;
05779 }
05780
05781 inline u16 tTIO::tG01_Status::getG0_TC_Error_St(nMDBG::tStatus2*) const
05782 {
05783    return (u16)((_softCopy & ~0xefff) >> 0xc);
05784 }
05785
05786 inline u16 tTIO::tG01_Status::readG0_TC_Error_St(nMDBG::tStatus2* s)
05787 {
05788    refresh(s);
05789    return getG0_TC_Error_St(s);
05790 }
05791
05792 inline tTIO::tG01_Status& tTIO::tG01_Status::setG1_TC_Error_St(u16 fieldValue, nMDBG::tStatus2* s)
05793 {
05794    if (s && s->isFatal()) return *this;
05795    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
05796    setRegister(newValue, s);
05797    return *this;
05798 }
05799
05800 inline u16 tTIO::tG01_Status::getG1_TC_Error_St(nMDBG::tStatus2*) const
05801 {
05802    return (u16)((_softCopy & ~0xdfff) >> 0xd);
05803 }
05804
05805 inline u16 tTIO::tG01_Status::readG1_TC_Error_St(nMDBG::tStatus2* s)
05806 {
05807    refresh(s);
05808    return getG1_TC_Error_St(s);
05809 }
05810
05811 inline tTIO::tG01_Status& tTIO::tG01_Status::setG0_Gate_Error_St(u16 fieldValue, nMDBG::tStatus2* s)
05812 {
05813    if (s && s->isFatal()) return *this;
05814    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
05815    setRegister(newValue, s);
05816    return *this;
05817 }
05818
05819 inline u16 tTIO::tG01_Status::getG0_Gate_Error_St(nMDBG::tStatus2*) const
05820 {
05821    return (u16)((_softCopy & ~0xbfff) >> 0xe);
05822 }
05823
05824 inline u16 tTIO::tG01_Status::readG0_Gate_Error_St(nMDBG::tStatus2* s)
05825 {
05826    refresh(s);
05827    return getG0_Gate_Error_St(s);
05828 }
05829
05830 inline tTIO::tG01_Status& tTIO::tG01_Status::setG1_Gate_Error_St(u16 fieldValue, nMDBG::tStatus2* s)
05831 {
05832    if (s && s->isFatal()) return *this;
05833    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
05834    setRegister(newValue, s);
05835    return *this;
05836 }
05837
05838 inline u16 tTIO::tG01_Status::getG1_Gate_Error_St(nMDBG::tStatus2*) const
05839 {
05840    return (u16)((_softCopy & ~0x7fff) >> 0xf);
05841 }
05842
05843 inline u16 tTIO::tG01_Status::readG1_Gate_Error_St(nMDBG::tStatus2* s)
05844 {
05845    refresh(s);
05846    return getG1_Gate_Error_St(s);
05847 }
05848
05849 inline void tTIO::tG01_Status::setRegisterMap(tTIO* pTIO)
05850 {
05851    _TIO = pTIO;
05852 }
05853
05854 inline tTIO::tG1_DMA_Status::tG1_DMA_Status()
05855 {
05856    _softCopy = 0;
05857 }
05858
05859 inline tTIO* tTIO::tG1_DMA_Status::registerMap(void)
05860 {
05861    return _TIO;
05862 }
05863
05864 inline tTIO::tG1_DMA_Status& tTIO::tG1_DMA_Status::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
05865 {
05866    if (s && s->isFatal()) return *this;
05867    _softCopy = fieldValue;
05868    return *this;
05869 }
05870
05871 inline u16 tTIO::tG1_DMA_Status::getRegister(nMDBG::tStatus2*) const
05872 {
05873    return _softCopy;
05874 }
05875
05876 inline void tTIO::tG1_DMA_Status::refresh(nMDBG::tStatus2* s)
05877 {
05878    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
05879 }
05880
05881 inline u16 tTIO::tG1_DMA_Status::readRegister(nMDBG::tStatus2* s)
05882 {
05883    refresh(s);
05884    return _softCopy;
05885 }
05886
05887 inline tTIO::tG1_DMA_Status& tTIO::tG1_DMA_Status::setG1_DMA_Read_Value(u16 fieldValue, nMDBG::tStatus2* s)
05888 {
05889    if (s && s->isFatal()) return *this;
05890    u16 newValue;   newValue = ((u16)(_softCopy & 0xdfff)) | (((u16)fieldValue << 0xd) & ~0xdfff);
05891    setRegister(newValue, s);
05892    return *this;
05893 }
05894
05895 inline u16 tTIO::tG1_DMA_Status::getG1_DMA_Read_Value(nMDBG::tStatus2*) const
05896 {
05897    return (u16)((_softCopy & ~0xdfff) >> 0xd);
05898 }
05899
05900 inline u16 tTIO::tG1_DMA_Status::readG1_DMA_Read_Value(nMDBG::tStatus2* s)
05901 {
05902    refresh(s);
05903    return getG1_DMA_Read_Value(s);
05904 }
05905
05906 inline tTIO::tG1_DMA_Status& tTIO::tG1_DMA_Status::setG1_DMA_Error_St(u16 fieldValue, nMDBG::tStatus2* s)
05907 {
05908    if (s && s->isFatal()) return *this;
05909    u16 newValue;   newValue = ((u16)(_softCopy & 0xbfff)) | (((u16)fieldValue << 0xe) & ~0xbfff);
05910    setRegister(newValue, s);
05911    return *this;
05912 }
05913
05914 inline u16 tTIO::tG1_DMA_Status::getG1_DMA_Error_St(nMDBG::tStatus2*) const
05915 {
05916    return (u16)((_softCopy & ~0xbfff) >> 0xe);
05917 }
05918
05919 inline u16 tTIO::tG1_DMA_Status::readG1_DMA_Error_St(nMDBG::tStatus2* s)
05920 {
05921    refresh(s);
05922    return getG1_DMA_Error_St(s);
05923 }
05924
05925 inline tTIO::tG1_DMA_Status& tTIO::tG1_DMA_Status::setG1_DRQ_St(u16 fieldValue, nMDBG::tStatus2* s)
05926 {
05927    if (s && s->isFatal()) return *this;
05928    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
05929    setRegister(newValue, s);
05930    return *this;
05931 }
05932
05933 inline u16 tTIO::tG1_DMA_Status::getG1_DRQ_St(nMDBG::tStatus2*) const
05934 {
05935    return (u16)((_softCopy & ~0x7fff) >> 0xf);
05936 }
05937
05938 inline u16 tTIO::tG1_DMA_Status::readG1_DRQ_St(nMDBG::tStatus2* s)
05939 {
05940    refresh(s);
05941    return getG1_DRQ_St(s);
05942 }
05943
05944 inline void tTIO::tG1_DMA_Status::setRegisterMap(tTIO* pTIO)
05945 {
05946    _TIO = pTIO;
05947 }
05948
05949 inline tTIO::tG1_HW_Save::tG1_HW_Save()
05950 {
05951    _softCopy = 0;
05952 }
05953
05954 inline tTIO* tTIO::tG1_HW_Save::registerMap(void)
05955 {
05956    return _TIO;
05957 }
05958
05959 inline tTIO::tG1_HW_Save& tTIO::tG1_HW_Save::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
05960 {
05961    if (s && s->isFatal()) return *this;
05962    _softCopy = fieldValue;
05963    return *this;
05964 }
05965
05966 inline u32 tTIO::tG1_HW_Save::getRegister(nMDBG::tStatus2*) const
05967 {
05968    return _softCopy;
05969 }
05970
05971 inline void tTIO::tG1_HW_Save::refresh(nMDBG::tStatus2* s)
05972 {
05973    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
05974 }
05975
05976 inline u32 tTIO::tG1_HW_Save::readRegister(nMDBG::tStatus2* s)
05977 {
05978    refresh(s);
05979    return _softCopy;
05980 }
05981
05982 inline tTIO::tG1_HW_Save& tTIO::tG1_HW_Save::setG1_HW_Save_Value(u32 fieldValue, nMDBG::tStatus2* s)
05983 {
05984    if (s && s->isFatal()) return *this;
05985    u32 newValue;   newValue = ((u32)(_softCopy & 0x0)) | (((u32)fieldValue << 0x0) & ~0x0);
05986    setRegister(newValue, s);
05987    return *this;
05988 }
05989
05990 inline u32 tTIO::tG1_HW_Save::getG1_HW_Save_Value(nMDBG::tStatus2*) const
05991 {
05992    return (u32)((_softCopy & ~0x0) >> 0x0);
05993 }
05994
05995 inline u32 tTIO::tG1_HW_Save::readG1_HW_Save_Value(nMDBG::tStatus2* s)
05996 {
05997    refresh(s);
05998    return getG1_HW_Save_Value(s);
05999 }
06000
06001 inline void tTIO::tG1_HW_Save::setRegisterMap(tTIO* pTIO)
06002 {
06003    _TIO = pTIO;
06004 }
06005
06006 inline tTIO::tG1_HW_Save_High::tG1_HW_Save_High()
06007 {
06008    _softCopy = 0;
06009 }
06010
06011 inline tTIO* tTIO::tG1_HW_Save_High::registerMap(void)
06012 {
06013    return _TIO;
06014 }
06015
06016 inline tTIO::tG1_HW_Save_High& tTIO::tG1_HW_Save_High::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
06017 {
06018    if (s && s->isFatal()) return *this;
06019    _softCopy = fieldValue;
06020    return *this;
06021 }
06022
06023 inline u16 tTIO::tG1_HW_Save_High::getRegister(nMDBG::tStatus2*) const
06024 {
06025    return _softCopy;
06026 }
06027
06028 inline void tTIO::tG1_HW_Save_High::refresh(nMDBG::tStatus2* s)
06029 {
06030    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
06031 }
06032
06033 inline u16 tTIO::tG1_HW_Save_High::readRegister(nMDBG::tStatus2* s)
06034 {
06035    refresh(s);
06036    return _softCopy;
06037 }
06038
06039 inline tTIO::tG1_HW_Save_High& tTIO::tG1_HW_Save_High::setG1_HW_Save_High_Value(u16 fieldValue, nMDBG::tStatus2* s)
06040 {
06041    if (s && s->isFatal()) return *this;
06042    u16 newValue;   newValue = ((u16)(_softCopy & 0x0)) | (((u16)fieldValue << 0x0) & ~0x0);
06043    setRegister(newValue, s);
06044    return *this;
06045 }
06046
06047 inline u16 tTIO::tG1_HW_Save_High::getG1_HW_Save_High_Value(nMDBG::tStatus2*) const
06048 {
06049    return (u16)((_softCopy & ~0x0) >> 0x0);
06050 }
06051
06052 inline u16 tTIO::tG1_HW_Save_High::readG1_HW_Save_High_Value(nMDBG::tStatus2* s)
06053 {
06054    refresh(s);
06055    return getG1_HW_Save_High_Value(s);
06056 }
06057
06058 inline void tTIO::tG1_HW_Save_High::setRegisterMap(tTIO* pTIO)
06059 {
06060    _TIO = pTIO;
06061 }
06062
06063 inline tTIO::tG1_HW_Save_Low::tG1_HW_Save_Low()
06064 {
06065    _softCopy = 0;
06066 }
06067
06068 inline tTIO* tTIO::tG1_HW_Save_Low::registerMap(void)
06069 {
06070    return _TIO;
06071 }
06072
06073 inline tTIO::tG1_HW_Save_Low& tTIO::tG1_HW_Save_Low::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
06074 {
06075    if (s && s->isFatal()) return *this;
06076    _softCopy = fieldValue;
06077    return *this;
06078 }
06079
06080 inline u16 tTIO::tG1_HW_Save_Low::getRegister(nMDBG::tStatus2*) const
06081 {
06082    return _softCopy;
06083 }
06084
06085 inline void tTIO::tG1_HW_Save_Low::refresh(nMDBG::tStatus2* s)
06086 {
06087    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
06088 }
06089
06090 inline u16 tTIO::tG1_HW_Save_Low::readRegister(nMDBG::tStatus2* s)
06091 {
06092    refresh(s);
06093    return _softCopy;
06094 }
06095
06096 inline tTIO::tG1_HW_Save_Low& tTIO::tG1_HW_Save_Low::setG1_HW_Save_Low_Value(u16 fieldValue, nMDBG::tStatus2* s)
06097 {
06098    if (s && s->isFatal()) return *this;
06099    u16 newValue;   newValue = ((u16)(_softCopy & 0x0)) | (((u16)fieldValue << 0x0) & ~0x0);
06100    setRegister(newValue, s);
06101    return *this;
06102 }
06103
06104 inline u16 tTIO::tG1_HW_Save_Low::getG1_HW_Save_Low_Value(nMDBG::tStatus2*) const
06105 {
06106    return (u16)((_softCopy & ~0x0) >> 0x0);
06107 }
06108
06109 inline u16 tTIO::tG1_HW_Save_Low::readG1_HW_Save_Low_Value(nMDBG::tStatus2* s)
06110 {
06111    refresh(s);
06112    return getG1_HW_Save_Low_Value(s);
06113 }
06114
06115 inline void tTIO::tG1_HW_Save_Low::setRegisterMap(tTIO* pTIO)
06116 {
06117    _TIO = pTIO;
06118 }
06119
06120 inline tTIO::tG1_Save::tG1_Save()
06121 {
06122    _softCopy = 0;
06123 }
06124
06125 inline tTIO* tTIO::tG1_Save::registerMap(void)
06126 {
06127    return _TIO;
06128 }
06129
06130 inline tTIO::tG1_Save& tTIO::tG1_Save::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
06131 {
06132    if (s && s->isFatal()) return *this;
06133    _softCopy = fieldValue;
06134    return *this;
06135 }
06136
06137 inline u32 tTIO::tG1_Save::getRegister(nMDBG::tStatus2*) const
06138 {
06139    return _softCopy;
06140 }
06141
06142 inline void tTIO::tG1_Save::refresh(nMDBG::tStatus2* s)
06143 {
06144    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
06145 }
06146
06147 inline u32 tTIO::tG1_Save::readRegister(nMDBG::tStatus2* s)
06148 {
06149    refresh(s);
06150    return _softCopy;
06151 }
06152
06153 inline tTIO::tG1_Save& tTIO::tG1_Save::setG1_Save_Value(u32 fieldValue, nMDBG::tStatus2* s)
06154 {
06155    if (s && s->isFatal()) return *this;
06156    u32 newValue;   newValue = ((u32)(_softCopy & 0x0)) | (((u32)fieldValue << 0x0) & ~0x0);
06157    setRegister(newValue, s);
06158    return *this;
06159 }
06160
06161 inline u32 tTIO::tG1_Save::getG1_Save_Value(nMDBG::tStatus2*) const
06162 {
06163    return (u32)((_softCopy & ~0x0) >> 0x0);
06164 }
06165
06166 inline u32 tTIO::tG1_Save::readG1_Save_Value(nMDBG::tStatus2* s)
06167 {
06168    refresh(s);
06169    return getG1_Save_Value(s);
06170 }
06171
06172 inline void tTIO::tG1_Save::setRegisterMap(tTIO* pTIO)
06173 {
06174    _TIO = pTIO;
06175 }
06176
06177 inline tTIO::tG1_Save_High::tG1_Save_High()
06178 {
06179    _softCopy = 0;
06180 }
06181
06182 inline tTIO* tTIO::tG1_Save_High::registerMap(void)
06183 {
06184    return _TIO;
06185 }
06186
06187 inline tTIO::tG1_Save_High& tTIO::tG1_Save_High::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
06188 {
06189    if (s && s->isFatal()) return *this;
06190    _softCopy = fieldValue;
06191    return *this;
06192 }
06193
06194 inline u16 tTIO::tG1_Save_High::getRegister(nMDBG::tStatus2*) const
06195 {
06196    return _softCopy;
06197 }
06198
06199 inline void tTIO::tG1_Save_High::refresh(nMDBG::tStatus2* s)
06200 {
06201    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
06202 }
06203
06204 inline u16 tTIO::tG1_Save_High::readRegister(nMDBG::tStatus2* s)
06205 {
06206    refresh(s);
06207    return _softCopy;
06208 }
06209
06210 inline tTIO::tG1_Save_High& tTIO::tG1_Save_High::setG1_Save_High_Value(u16 fieldValue, nMDBG::tStatus2* s)
06211 {
06212    if (s && s->isFatal()) return *this;
06213    u16 newValue;   newValue = ((u16)(_softCopy & 0x0)) | (((u16)fieldValue << 0x0) & ~0x0);
06214    setRegister(newValue, s);
06215    return *this;
06216 }
06217
06218 inline u16 tTIO::tG1_Save_High::getG1_Save_High_Value(nMDBG::tStatus2*) const
06219 {
06220    return (u16)((_softCopy & ~0x0) >> 0x0);
06221 }
06222
06223 inline u16 tTIO::tG1_Save_High::readG1_Save_High_Value(nMDBG::tStatus2* s)
06224 {
06225    refresh(s);
06226    return getG1_Save_High_Value(s);
06227 }
06228
06229 inline void tTIO::tG1_Save_High::setRegisterMap(tTIO* pTIO)
06230 {
06231    _TIO = pTIO;
06232 }
06233
06234 inline tTIO::tG1_Save_Low::tG1_Save_Low()
06235 {
06236    _softCopy = 0;
06237 }
06238
06239 inline tTIO* tTIO::tG1_Save_Low::registerMap(void)
06240 {
06241    return _TIO;
06242 }
06243
06244 inline tTIO::tG1_Save_Low& tTIO::tG1_Save_Low::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
06245 {
06246    if (s && s->isFatal()) return *this;
06247    _softCopy = fieldValue;
06248    return *this;
06249 }
06250
06251 inline u16 tTIO::tG1_Save_Low::getRegister(nMDBG::tStatus2*) const
06252 {
06253    return _softCopy;
06254 }
06255
06256 inline void tTIO::tG1_Save_Low::refresh(nMDBG::tStatus2* s)
06257 {
06258    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
06259 }
06260
06261 inline u16 tTIO::tG1_Save_Low::readRegister(nMDBG::tStatus2* s)
06262 {
06263    refresh(s);
06264    return _softCopy;
06265 }
06266
06267 inline tTIO::tG1_Save_Low& tTIO::tG1_Save_Low::setG1_Save_Low_Value(u16 fieldValue, nMDBG::tStatus2* s)
06268 {
06269    if (s && s->isFatal()) return *this;
06270    u16 newValue;   newValue = ((u16)(_softCopy & 0x0)) | (((u16)fieldValue << 0x0) & ~0x0);
06271    setRegister(newValue, s);
06272    return *this;
06273 }
06274
06275 inline u16 tTIO::tG1_Save_Low::getG1_Save_Low_Value(nMDBG::tStatus2*) const
06276 {
06277    return (u16)((_softCopy & ~0x0) >> 0x0);
06278 }
06279
06280 inline u16 tTIO::tG1_Save_Low::readG1_Save_Low_Value(nMDBG::tStatus2* s)
06281 {
06282    refresh(s);
06283    return getG1_Save_Low_Value(s);
06284 }
06285
06286 inline void tTIO::tG1_Save_Low::setRegisterMap(tTIO* pTIO)
06287 {
06288    _TIO = pTIO;
06289 }
06290
06291 inline tTIO::tG1_Status_1::tG1_Status_1()
06292 {
06293    _softCopy = 0;
06294 }
06295
06296 inline tTIO* tTIO::tG1_Status_1::registerMap(void)
06297 {
06298    return _TIO;
06299 }
06300
06301 inline tTIO::tG1_Status_1& tTIO::tG1_Status_1::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
06302 {
06303    if (s && s->isFatal()) return *this;
06304    _softCopy = fieldValue;
06305    return *this;
06306 }
06307
06308 inline u16 tTIO::tG1_Status_1::getRegister(nMDBG::tStatus2*) const
06309 {
06310    return _softCopy;
06311 }
06312
06313 inline void tTIO::tG1_Status_1::refresh(nMDBG::tStatus2* s)
06314 {
06315    _softCopy = tIOStrategy::read(_TIO->getBusSpaceReference(), kOffset + _TIO->getAddressOffset(s), s);
06316 }
06317
06318 inline u16 tTIO::tG1_Status_1::readRegister(nMDBG::tStatus2* s)
06319 {
06320    refresh(s);
06321    return _softCopy;
06322 }
06323
06324 inline tTIO::tG1_Status_1& tTIO::tG1_Status_1::setG1_Gate_Interrupt_St(u16 fieldValue, nMDBG::tStatus2* s)
06325 {
06326    if (s && s->isFatal()) return *this;
06327    u16 newValue;   newValue = ((u16)(_softCopy & 0xfffb)) | (((u16)fieldValue << 0x2) & ~0xfffb);
06328    setRegister(newValue, s);
06329    return *this;
06330 }
06331
06332 inline u16 tTIO::tG1_Status_1::getG1_Gate_Interrupt_St(nMDBG::tStatus2*) const
06333 {
06334    return (u16)((_softCopy & ~0xfffb) >> 0x2);
06335 }
06336
06337 inline u16 tTIO::tG1_Status_1::readG1_Gate_Interrupt_St(nMDBG::tStatus2* s)
06338 {
06339    refresh(s);
06340    return getG1_Gate_Interrupt_St(s);
06341 }
06342
06343 inline tTIO::tG1_Status_1& tTIO::tG1_Status_1::setG1_TC_St(u16 fieldValue, nMDBG::tStatus2* s)
06344 {
06345    if (s && s->isFatal()) return *this;
06346    u16 newValue;   newValue = ((u16)(_softCopy & 0xfff7)) | (((u16)fieldValue << 0x3) & ~0xfff7);
06347    setRegister(newValue, s);
06348    return *this;
06349 }
06350
06351 inline u16 tTIO::tG1_Status_1::getG1_TC_St(nMDBG::tStatus2*) const
06352 {
06353    return (u16)((_softCopy & ~0xfff7) >> 0x3);
06354 }
06355
06356 inline u16 tTIO::tG1_Status_1::readG1_TC_St(nMDBG::tStatus2* s)
06357 {
06358    refresh(s);
06359    return getG1_TC_St(s);
06360 }
06361
06362 inline tTIO::tG1_Status_1& tTIO::tG1_Status_1::setG1_Interrupt_St(u16 fieldValue, nMDBG::tStatus2* s)
06363 {
06364    if (s && s->isFatal()) return *this;
06365    u16 newValue;   newValue = ((u16)(_softCopy & 0x7fff)) | (((u16)fieldValue << 0xf) & ~0x7fff);
06366    setRegister(newValue, s);
06367    return *this;
06368 }
06369
06370 inline u16 tTIO::tG1_Status_1::getG1_Interrupt_St(nMDBG::tStatus2*) const
06371 {
06372    return (u16)((_softCopy & ~0x7fff) >> 0xf);
06373 }
06374
06375 inline u16 tTIO::tG1_Status_1::readG1_Interrupt_St(nMDBG::tStatus2* s)
06376 {
06377    refresh(s);
06378    return getG1_Interrupt_St(s);
06379 }
06380
06381 inline void tTIO::tG1_Status_1::setRegisterMap(tTIO* pTIO)
06382 {
06383    _TIO = pTIO;
06384 }
06385
06386 #endif
06387
06388
06389 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
06390 // This file is autogenerated!!!
06391 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
06392