GLAST / LAT > DAQ and FSW > FSW > Doxygen Index> QLRA / dev > qlra / rhel5-64
#include <QLRA/QLRA.h>
#include <LRA/LRA.h>
#include <PBI/Check.h>
#include <PBI/Ofs.h>
Classes | |
| struct | _QLRA_blkDesc |
| Structure for register block descriptor. More... | |
| struct | _QLRA_cmptDesc |
| Structure for component descriptor. More... | |
Typedefs | |
| typedef struct _QLRA_blkDesc | QLRA_blkDesc |
| Structure for register block descriptor. | |
| typedef struct _QLRA_cmptDesc | QLRA_cmptDesc |
| Structure for component descriptor. | |
Functions | |
| CHECK (Enum_wild, QLRA_WILD==LRA_WILD) | |
| CHECK (Enum_active, QLRA_ACTIVE==LRA_ACTIVE) | |
| CHECK (Enum_cpt_gem, QLRA_CPT_GEM==LRA_CPT_GEM) | |
| CHECK (Enum_cpt_ebm, QLRA_CPT_EBM==LRA_CPT_EBM) | |
| CHECK (Enum_cpt_pdu0, QLRA_CPT_PDU0==LRA_CPT_PDU0) | |
| CHECK (Enum_cpt_pdu1, QLRA_CPT_PDU1==LRA_CPT_PDU1) | |
| CHECK (Enum_cpt_cru, QLRA_CPT_CRU==LRA_CPT_CRU) | |
| CHECK (Enum_cpt_tem, QLRA_CPT_TEM==LRA_CPT_TEM) | |
| CHECK (Enum_cpt_tic, QLRA_CPT_TIC==LRA_CPT_TIC) | |
| CHECK (Enum_cpt_ccc, QLRA_CPT_CCC==LRA_CPT_CCC) | |
| CHECK (Enum_cpt_crc, QLRA_CPT_CRC==LRA_CPT_CRC) | |
| CHECK (Enum_cpt_cfe, QLRA_CPT_CFE==LRA_CPT_CFE) | |
| CHECK (Enum_cpt_tcc, QLRA_CPT_TCC==LRA_CPT_TCC) | |
| CHECK (Enum_cpt_trc, QLRA_CPT_TRC==LRA_CPT_TRC) | |
| CHECK (Enum_cpt_tfe, QLRA_CPT_TFE==LRA_CPT_TFE) | |
| CHECK (Enum_cpt_aem, QLRA_CPT_AEM==LRA_CPT_AEM) | |
| CHECK (Enum_cpt_arc, QLRA_CPT_ARC==LRA_CPT_ARC) | |
| CHECK (Enum_cpt_afe, QLRA_CPT_AFE==LRA_CPT_AFE) | |
| CHECK (Enum_cpt_siue, QLRA_CPT_SIUE==LRA_CPT_SIUE) | |
| CHECK (Enum_cpt_siu0, QLRA_CPT_SIU0==LRA_CPT_SIU0) | |
| CHECK (Enum_cpt_siu1, QLRA_CPT_SIU1==LRA_CPT_SIU1) | |
| CHECK (Enum_cpt_epu0, QLRA_CPT_EPU0==LRA_CPT_EPU0) | |
| CHECK (Enum_cpt_epu1, QLRA_CPT_EPU1==LRA_CPT_EPU1) | |
| CHECK (Enum_cpt_epu2, QLRA_CPT_EPU2==LRA_CPT_EPU2) | |
| CHECK (Enum_cpt_bcst, QLRA_CPT_BCST==LRA_CPT_BCST) | |
| CHECK (Enum_n_tem, QLRA_N_TEM==LRA_N_TEM) | |
| CHECK (Enum_n_ccc, QLRA_N_CCC==LRA_N_CCC) | |
| CHECK (Enum_n_tcc, QLRA_N_TCC==LRA_N_TCC) | |
| CHECK (Enum_n_crc, QLRA_N_CRC==LRA_N_CRC) | |
| CHECK (Enum_n_trc, QLRA_N_TRC==LRA_N_TRC) | |
| CHECK (Enum_n_arc, QLRA_N_ARC==LRA_N_ARC) | |
| CHECK (Enum_n_cfe, QLRA_N_CFE==LRA_N_CFE) | |
| CHECK (Enum_n_tfe, QLRA_N_TFE==LRA_N_TFE) | |
| CHECK (Enum_n_afe, QLRA_N_AFE==LRA_N_AFE) | |
| CHECK (Enum_stats_major, QLRA_STATS_MAJOR==LRA_STATS_MAJOR) | |
| CHECK (Enum_stats_minor, QLRA_STATS_MINOR==LRA_STATS_MINOR) | |
| CHECK (Size_regSpec, sizeof(QLRA_regSpec)==sizeof(LRA_regSpec)) | |
| CHECK (Size_regSpec_cmpnt, SIZE_OF(QLRA_regSpec, cmpnt)==SIZE_OF(LRA_regSpec, cmpnt)) | |
| CHECK (Size_regSpec_block, SIZE_OF(QLRA_regSpec, block)==SIZE_OF(LRA_regSpec, block)) | |
| CHECK (Size_regSpec_tem, SIZE_OF(QLRA_regSpec, tem)==SIZE_OF(LRA_regSpec, tem)) | |
| CHECK (Size_regSpec_cc, SIZE_OF(QLRA_regSpec, cc)==SIZE_OF(LRA_regSpec, cc)) | |
| CHECK (Size_regSpec_rc, SIZE_OF(QLRA_regSpec, rc)==SIZE_OF(LRA_regSpec, rc)) | |
| CHECK (Size_regSpec_fe, SIZE_OF(QLRA_regSpec, fe)==SIZE_OF(LRA_regSpec, fe)) | |
| CHECK (Size_regSpec_reg, OFFSET_OF(QLRA_regSpec, reg)==OFFSET_OF(LRA_regSpec, reg)) | |
| CHECK (Offset_regSpec_cmpnt, OFFSET_OF(QLRA_regSpec, cmpnt)==OFFSET_OF(LRA_regSpec, cmpnt)) | |
| CHECK (Offset_regSpec_block, OFFSET_OF(QLRA_regSpec, block)==OFFSET_OF(LRA_regSpec, block)) | |
| CHECK (Offset_regSpec_tem, OFFSET_OF(QLRA_regSpec, tem)==OFFSET_OF(LRA_regSpec, tem)) | |
| CHECK (Offset_regSpec_cc, OFFSET_OF(QLRA_regSpec, cc)==OFFSET_OF(LRA_regSpec, cc)) | |
| CHECK (Offset_regSpec_rc, OFFSET_OF(QLRA_regSpec, rc)==OFFSET_OF(LRA_regSpec, rc)) | |
| CHECK (Offset_regSpec_fe, OFFSET_OF(QLRA_regSpec, fe)==OFFSET_OF(LRA_regSpec, fe)) | |
| CHECK (Offset_regSpec_reg, OFFSET_OF(QLRA_regSpec, reg)==OFFSET_OF(LRA_regSpec, reg)) | |
| CHECK (Size_regData, sizeof(QLRA_regData)==sizeof(LRA_regData)) | |
| CHECK (Size_regData_rSpec, SIZE_OF(QLRA_regData, rSpec)==SIZE_OF(LRA_regData, rSpec)) | |
| CHECK (Size_regData_tMask, SIZE_OF(QLRA_regData, tMask)==SIZE_OF(LRA_regData, tMask)) | |
| CHECK (Size_regData_nTem, SIZE_OF(QLRA_regData, nTem)==SIZE_OF(LRA_regData, nTem)) | |
| CHECK (Size_regData_nCc, SIZE_OF(QLRA_regData, nCc)==SIZE_OF(LRA_regData, nCc)) | |
| CHECK (Size_regData_nRc, SIZE_OF(QLRA_regData, nRc)==SIZE_OF(LRA_regData, nRc)) | |
| CHECK (Size_regData_nFe, SIZE_OF(QLRA_regData, nFe)==SIZE_OF(LRA_regData, nFe)) | |
| CHECK (Size_regData_nReg, SIZE_OF(QLRA_regData, nReg)==SIZE_OF(LRA_regData, nReg)) | |
| CHECK (Size_regData_width, SIZE_OF(QLRA_regData, width)==SIZE_OF(LRA_regData, width)) | |
| CHECK (Offset_regData_rSpec, OFFSET_OF(QLRA_regData, rSpec)==OFFSET_OF(LRA_regData, rSpec)) | |
| CHECK (Offset_regData_tMask, OFFSET_OF(QLRA_regData, tMask)==OFFSET_OF(LRA_regData, tMask)) | |
| CHECK (Offset_regData_nTem, OFFSET_OF(QLRA_regData, nTem)==OFFSET_OF(LRA_regData, nTem)) | |
| CHECK (Offset_regData_nCc, OFFSET_OF(QLRA_regData, nCc)==OFFSET_OF(LRA_regData, nCc)) | |
| CHECK (Offset_regData_nRc, OFFSET_OF(QLRA_regData, nRc)==OFFSET_OF(LRA_regData, nRc)) | |
| CHECK (Offset_regData_nFe, OFFSET_OF(QLRA_regData, nFe)==OFFSET_OF(LRA_regData, nFe)) | |
| CHECK (Offset_regData_nReg, OFFSET_OF(QLRA_regData, nReg)==OFFSET_OF(LRA_regData, nReg)) | |
| CHECK (Offset_regData_width, OFFSET_OF(QLRA_regData, width)==OFFSET_OF(LRA_regData, width)) | |
| CHECK (Offset_regData_value, OFFSET_OF(QLRA_regData, value)==OFFSET_OF(LRA_regData, value)) | |
| CHECK (Size_esrData, sizeof(QLRA_esrData)==sizeof(LRA_esrData)) | |
| CHECK (Size_esrData_arc, SIZE_OF(QLRA_esrData, arc)==SIZE_OF(LRA_esrData, arc)) | |
| CHECK (Size_esrData_afe, SIZE_OF(QLRA_esrData, afe)==SIZE_OF(LRA_esrData, afe)) | |
| CHECK (Size_esrData_crc, SIZE_OF(QLRA_esrData, crc)==SIZE_OF(LRA_esrData, crc)) | |
| CHECK (Size_esrData_trc, SIZE_OF(QLRA_esrData, trc)==SIZE_OF(LRA_esrData, trc)) | |
| CHECK (Offset_esrData_arc, OFFSET_OF(QLRA_esrData, arc)==OFFSET_OF(LRA_esrData, arc)) | |
| CHECK (Offset_esrData_afe, OFFSET_OF(QLRA_esrData, afe)==OFFSET_OF(LRA_esrData, afe)) | |
| CHECK (Offset_esrData_crc, OFFSET_OF(QLRA_esrData, crc)==OFFSET_OF(LRA_esrData, crc)) | |
| CHECK (Offset_esrData_trc, OFFSET_OF(QLRA_esrData, trc)==OFFSET_OF(LRA_esrData, trc)) | |
| CHECK (Size_cmdStats, sizeof(QLRA_cmdStats)==sizeof(LRA_cmdStats)) | |
| CHECK (Size_cmdStats_nOper, SIZE_OF(QLRA_cmdStats, nOper)==SIZE_OF(LRA_cmdStats, nOper)) | |
| CHECK (Size_cmdStats_nOflow, SIZE_OF(QLRA_cmdStats, nOflow)==SIZE_OF(LRA_cmdStats, nOflow)) | |
| CHECK (Size_cmdStats_nHdrPerr, SIZE_OF(QLRA_cmdStats, nHdrPerr)==SIZE_OF(LRA_cmdStats, nHdrPerr)) | |
| CHECK (Size_cmdStats_nDatPerr, SIZE_OF(QLRA_cmdStats, nDatPerr)==SIZE_OF(LRA_cmdStats, nDatPerr)) | |
| CHECK (Size_cmdStats_nAccPerr, SIZE_OF(QLRA_cmdStats, nAccPerr)==SIZE_OF(LRA_cmdStats, nAccPerr)) | |
| CHECK (Offset_cmdStats_nOper, OFFSET_OF(QLRA_cmdStats, nOper)==OFFSET_OF(LRA_cmdStats, nOper)) | |
| CHECK (Offset_cmdStats_nOflow, OFFSET_OF(QLRA_cmdStats, nOflow)==OFFSET_OF(LRA_cmdStats, nOflow)) | |
| CHECK (Offset_cmdStats_nHdrPerr, OFFSET_OF(QLRA_cmdStats, nHdrPerr)==OFFSET_OF(LRA_cmdStats, nHdrPerr)) | |
| CHECK (Offset_cmdStats_nDatPerr, OFFSET_OF(QLRA_cmdStats, nDatPerr)==OFFSET_OF(LRA_cmdStats, nDatPerr)) | |
| CHECK (Offset_cmdStats_nAccPerr, OFFSET_OF(QLRA_cmdStats, nAccPerr)==OFFSET_OF(LRA_cmdStats, nAccPerr)) | |
| CHECK (Size_rcvStats, sizeof(QLRA_rcvStats)==sizeof(LRA_rcvStats)) | |
| CHECK (Size_rcvStats_nOper, SIZE_OF(QLRA_rcvStats, nOper)==SIZE_OF(LRA_rcvStats, nOper)) | |
| CHECK (Size_rcvStats_nOflow, SIZE_OF(QLRA_rcvStats, nOflow)==SIZE_OF(LRA_rcvStats, nOflow)) | |
| CHECK (Size_rcvStats_nRdErr, SIZE_OF(QLRA_rcvStats, nRdErr)==SIZE_OF(LRA_rcvStats, nRdErr)) | |
| CHECK (Size_rcvStats_nHdrPerr, SIZE_OF(QLRA_rcvStats, nHdrPerr)==SIZE_OF(LRA_rcvStats, nHdrPerr)) | |
| CHECK (Size_rcvStats_nDatPerr, SIZE_OF(QLRA_rcvStats, nDatPerr)==SIZE_OF(LRA_rcvStats, nDatPerr)) | |
| CHECK (Size_rcvStats_nEmpty, SIZE_OF(QLRA_rcvStats, nEmpty)==SIZE_OF(LRA_rcvStats, nEmpty)) | |
| CHECK (Size_rcvStats_nFull, SIZE_OF(QLRA_rcvStats, nFull)==SIZE_OF(LRA_rcvStats, nFull)) | |
| CHECK (Offset_rcvStats_nOper, OFFSET_OF(QLRA_rcvStats, nOper)==OFFSET_OF(LRA_rcvStats, nOper)) | |
| CHECK (Offset_rcvStats_nOflow, OFFSET_OF(QLRA_rcvStats, nOflow)==OFFSET_OF(LRA_rcvStats, nOflow)) | |
| CHECK (Offset_rcvStats_nRdErr, OFFSET_OF(QLRA_rcvStats, nRdErr)==OFFSET_OF(LRA_rcvStats, nRdErr)) | |
| CHECK (Offset_rcvStats_nHdrPerr, OFFSET_OF(QLRA_rcvStats, nHdrPerr)==OFFSET_OF(LRA_rcvStats, nHdrPerr)) | |
| CHECK (Offset_rcvStats_nDatPerr, OFFSET_OF(QLRA_rcvStats, nDatPerr)==OFFSET_OF(LRA_rcvStats, nDatPerr)) | |
| CHECK (Offset_rcvStats_nEmpty, OFFSET_OF(QLRA_rcvStats, nEmpty)==OFFSET_OF(LRA_rcvStats, nEmpty)) | |
| CHECK (Offset_rcvStats_nFull, OFFSET_OF(QLRA_rcvStats, nFull)==OFFSET_OF(LRA_rcvStats, nFull)) | |
| CHECK (Size_trcvStats, sizeof(QLRA_trcvStats)==sizeof(LRA_trcvStats)) | |
| CHECK (Size_trcvStats_nOper, SIZE_OF(QLRA_trcvStats, nOper)==SIZE_OF(LRA_trcvStats, nOper)) | |
| CHECK (Size_trcvStats_period, SIZE_OF(QLRA_trcvStats, period)==SIZE_OF(LRA_trcvStats, period)) | |
| CHECK (Size_trcvStats_nOflow, SIZE_OF(QLRA_trcvStats, nOflow)==SIZE_OF(LRA_trcvStats, nOflow)) | |
| CHECK (Size_trcvStats_nRdErr, SIZE_OF(QLRA_trcvStats, nRdErr)==SIZE_OF(LRA_trcvStats, nRdErr)) | |
| CHECK (Size_trcvStats_nHdrPerr, SIZE_OF(QLRA_trcvStats, nHdrPerr)==SIZE_OF(LRA_trcvStats, nHdrPerr)) | |
| CHECK (Size_trcvStats_nDatPerr, SIZE_OF(QLRA_trcvStats, nDatPerr)==SIZE_OF(LRA_trcvStats, nDatPerr)) | |
| CHECK (Size_trcvStats_nEmpty, SIZE_OF(QLRA_trcvStats, nEmpty)==SIZE_OF(LRA_trcvStats, nEmpty)) | |
| CHECK (Size_trcvStats_nFull, SIZE_OF(QLRA_trcvStats, nFull)==SIZE_OF(LRA_trcvStats, nFull)) | |
| CHECK (Offset_trcvStats_nOper, OFFSET_OF(QLRA_trcvStats, nOper)==OFFSET_OF(LRA_trcvStats, nOper)) | |
| CHECK (Offset_trcvStats_period, OFFSET_OF(QLRA_trcvStats, period)==OFFSET_OF(LRA_trcvStats, period)) | |
| CHECK (Offset_trcvStats_nOflow, OFFSET_OF(QLRA_trcvStats, nOflow)==OFFSET_OF(LRA_trcvStats, nOflow)) | |
| CHECK (Offset_trcvStats_nRdErr, OFFSET_OF(QLRA_trcvStats, nRdErr)==OFFSET_OF(LRA_trcvStats, nRdErr)) | |
| CHECK (Offset_trcvStats_nHdrPerr, OFFSET_OF(QLRA_trcvStats, nHdrPerr)==OFFSET_OF(LRA_trcvStats, nHdrPerr)) | |
| CHECK (Offset_trcvStats_nDatPerr, OFFSET_OF(QLRA_trcvStats, nDatPerr)==OFFSET_OF(LRA_trcvStats, nDatPerr)) | |
| CHECK (Offset_trcvStats_nEmpty, OFFSET_OF(QLRA_trcvStats, nEmpty)==OFFSET_OF(LRA_trcvStats, nEmpty)) | |
| CHECK (Offset_trcvStats_nFull, OFFSET_OF(QLRA_trcvStats, nFull)==OFFSET_OF(LRA_trcvStats, nFull)) | |
| CHECK (Size_xmtStats, sizeof(QLRA_xmtStats)==sizeof(LRA_xmtStats)) | |
| CHECK (Size_xmtStats_nOper, SIZE_OF(QLRA_xmtStats, nOper)==SIZE_OF(LRA_xmtStats, nOper)) | |
| CHECK (Size_xmtStats_nOflow, SIZE_OF(QLRA_xmtStats, nOflow)==SIZE_OF(LRA_xmtStats, nOflow)) | |
| CHECK (Size_xmtStats_nRdErr, SIZE_OF(QLRA_xmtStats, nRdErr)==SIZE_OF(LRA_xmtStats, nRdErr)) | |
| CHECK (Size_xmtStats_nPause, SIZE_OF(QLRA_xmtStats, nPause)==SIZE_OF(LRA_xmtStats, nPause)) | |
| CHECK (Offset_xmtStats_nOper, OFFSET_OF(QLRA_xmtStats, nOper)==OFFSET_OF(LRA_xmtStats, nOper)) | |
| CHECK (Offset_xmtStats_nOflow, OFFSET_OF(QLRA_xmtStats, nOflow)==OFFSET_OF(LRA_xmtStats, nOflow)) | |
| CHECK (Offset_xmtStats_nRdErr, OFFSET_OF(QLRA_xmtStats, nRdErr)==OFFSET_OF(LRA_xmtStats, nRdErr)) | |
| CHECK (Offset_xmtStats_nPause, OFFSET_OF(QLRA_xmtStats, nPause)==OFFSET_OF(LRA_xmtStats, nPause)) | |
| CHECK (Size_aemTrgStats, sizeof(QLRA_aemTrgStats)==sizeof(LRA_aemTrgStats)) | |
| CHECK (Size_aemTrgStatsnOper, SIZE_OF(QLRA_aemTrgStats, nOper)==SIZE_OF(LRA_aemTrgStats, nOper)) | |
| CHECK (Size_aemTrgStatsnOflow, SIZE_OF(QLRA_aemTrgStats, nOflow)==SIZE_OF(LRA_aemTrgStats, nOflow)) | |
| CHECK (Size_aemTrgStatsnRdErr, SIZE_OF(QLRA_aemTrgStats, nRdErr)==SIZE_OF(LRA_aemTrgStats, nRdErr)) | |
| CHECK (Size_aemTrgStatsnFault, SIZE_OF(QLRA_aemTrgStats, nFault)==SIZE_OF(LRA_aemTrgStats, nFault)) | |
| CHECK (Offset_aemTrgStats_nOper, OFFSET_OF(QLRA_aemTrgStats, nOper)==OFFSET_OF(LRA_aemTrgStats, nOper)) | |
| CHECK (Offset_aemTrgStats_nOflow, OFFSET_OF(QLRA_aemTrgStats, nOflow)==OFFSET_OF(LRA_aemTrgStats, nOflow)) | |
| CHECK (Offset_aemTrgStats_nRdErr, OFFSET_OF(QLRA_aemTrgStats, nRdErr)==OFFSET_OF(LRA_aemTrgStats, nRdErr)) | |
| CHECK (Offset_aemTrgStats_nFault, OFFSET_OF(QLRA_aemTrgStats, nFault)==OFFSET_OF(LRA_aemTrgStats, nFault)) | |
| CHECK (Size_arcErrStats, sizeof(QLRA_arcErrStats)==sizeof(LRA_arcErrStats)) | |
| CHECK (Size_arcErrStatsnParity, SIZE_OF(QLRA_arcErrStats, nParity)==SIZE_OF(LRA_arcErrStats, nParity)) | |
| CHECK (Size_arcErrStatsnNoSbit, SIZE_OF(QLRA_arcErrStats, nNoSbit)==SIZE_OF(LRA_arcErrStats, nNoSbit)) | |
| CHECK (Offset_arcErrStats_nParity, OFFSET_OF(QLRA_arcErrStats, nParity)==OFFSET_OF(LRA_arcErrStats, nParity)) | |
| CHECK (Offset_arcErrStats_nNoSbit, OFFSET_OF(QLRA_arcErrStats, nNoSbit)==OFFSET_OF(LRA_arcErrStats, nNoSbit)) | |
| CHECK (Size_fifoStats, sizeof(QLRA_fifoStats)==sizeof(LRA_fifoStats)) | |
| CHECK (Size_fifoStats_nFull, SIZE_OF(QLRA_fifoStats, nFull)==SIZE_OF(LRA_fifoStats, nFull)) | |
| CHECK (Size_fifoStats_nAFull, SIZE_OF(QLRA_fifoStats, nAFull)==SIZE_OF(LRA_fifoStats, nAFull)) | |
| CHECK (Size_fifoStats_nEmpty, SIZE_OF(QLRA_fifoStats, nEmpty)==SIZE_OF(LRA_fifoStats, nEmpty)) | |
| CHECK (Offset_fifoStats_nFull, OFFSET_OF(QLRA_fifoStats, nFull)==OFFSET_OF(LRA_fifoStats, nFull)) | |
| CHECK (Offset_fifoStats_nAFull, OFFSET_OF(QLRA_fifoStats, nAFull)==OFFSET_OF(LRA_fifoStats, nAFull)) | |
| CHECK (Offset_fifoStats_nEmpty, OFFSET_OF(QLRA_fifoStats, nEmpty)==OFFSET_OF(LRA_fifoStats, nEmpty)) | |
| CHECK (Size_cntrStats, sizeof(QLRA_cntrStats)==sizeof(LRA_cntrStats)) | |
| CHECK (Size_cntrStats_nCount, SIZE_OF(QLRA_cntrStats, nCount)==SIZE_OF(LRA_cntrStats, nCount)) | |
| CHECK (Size_cntrStats_nRdErr, SIZE_OF(QLRA_cntrStats, nRdErr)==SIZE_OF(LRA_cntrStats, nRdErr)) | |
| CHECK (Offset_cntrStats_nCount, OFFSET_OF(QLRA_cntrStats, nCount)==OFFSET_OF(LRA_cntrStats, nCount)) | |
| CHECK (Offset_cntrStats_nRdErr, OFFSET_OF(QLRA_cntrStats, nRdErr)==OFFSET_OF(LRA_cntrStats, nRdErr)) | |
| CHECK (Size_gemStats, sizeof(QLRA_gemStats)==sizeof(LRA_gemStats)) | |
| CHECK (Size_gemStats_cmd, SIZE_OF(QLRA_gemStats, cmd)==SIZE_OF(LRA_gemStats, cmd)) | |
| CHECK (Size_gemStats_rsp, SIZE_OF(QLRA_gemStats, rsp)==SIZE_OF(LRA_gemStats, rsp)) | |
| CHECK (Size_gemStats_evt, SIZE_OF(QLRA_gemStats, evt)==SIZE_OF(LRA_gemStats, evt)) | |
| CHECK (Size_gemStats_base, SIZE_OF(QLRA_gemStats, base)==SIZE_OF(LRA_gemStats, base)) | |
| CHECK (Size_gemStats_live, SIZE_OF(QLRA_gemStats, live)==SIZE_OF(LRA_gemStats, live)) | |
| CHECK (Size_gemStats_pres, SIZE_OF(QLRA_gemStats, pres)==SIZE_OF(LRA_gemStats, pres)) | |
| CHECK (Size_gemStats_disc, SIZE_OF(QLRA_gemStats, disc)==SIZE_OF(LRA_gemStats, disc)) | |
| CHECK (Size_gemStats_sent, SIZE_OF(QLRA_gemStats, sent)==SIZE_OF(LRA_gemStats, sent)) | |
| CHECK (Size_gemStats_dead, SIZE_OF(QLRA_gemStats, dead)==SIZE_OF(LRA_gemStats, dead)) | |
| CHECK (Offset_gemStats_cmd, OFFSET_OF(QLRA_gemStats, cmd)==OFFSET_OF(LRA_gemStats, cmd)) | |
| CHECK (Offset_gemStats_rsp, OFFSET_OF(QLRA_gemStats, rsp)==OFFSET_OF(LRA_gemStats, rsp)) | |
| CHECK (Offset_gemStats_evt, OFFSET_OF(QLRA_gemStats, evt)==OFFSET_OF(LRA_gemStats, evt)) | |
| CHECK (Offset_gemStats_base, OFFSET_OF(QLRA_gemStats, base)==OFFSET_OF(LRA_gemStats, base)) | |
| CHECK (Offset_gemStats_live, OFFSET_OF(QLRA_gemStats, live)==OFFSET_OF(LRA_gemStats, live)) | |
| CHECK (Offset_gemStats_pres, OFFSET_OF(QLRA_gemStats, pres)==OFFSET_OF(LRA_gemStats, pres)) | |
| CHECK (Offset_gemStats_disc, OFFSET_OF(QLRA_gemStats, disc)==OFFSET_OF(LRA_gemStats, disc)) | |
| CHECK (Offset_gemStats_sent, OFFSET_OF(QLRA_gemStats, sent)==OFFSET_OF(LRA_gemStats, sent)) | |
| CHECK (Offset_gemStats_dead, OFFSET_OF(QLRA_gemStats, dead)==OFFSET_OF(LRA_gemStats, dead)) | |
| CHECK (Size_cruStats, sizeof(QLRA_cruStats)==sizeof(LRA_cruStats)) | |
| CHECK (Size_cruStats_cmd, SIZE_OF(QLRA_cruStats, cmd)==SIZE_OF(LRA_cruStats, cmd)) | |
| CHECK (Size_cruStats_rsp, SIZE_OF(QLRA_cruStats, rsp)==SIZE_OF(LRA_cruStats, rsp)) | |
| CHECK (Offset_cruStats_cmd, OFFSET_OF(QLRA_cruStats, cmd)==OFFSET_OF(LRA_cruStats, cmd)) | |
| CHECK (Offset_cruStats_rsp, OFFSET_OF(QLRA_cruStats, rsp)==OFFSET_OF(LRA_cruStats, rsp)) | |
| CHECK (Size_pduStats, sizeof(QLRA_pduStats)==sizeof(LRA_pduStats)) | |
| CHECK (Size_pduStats_cmd, SIZE_OF(QLRA_pduStats, cmd)==SIZE_OF(LRA_pduStats, cmd)) | |
| CHECK (Size_pduStats_rsp, SIZE_OF(QLRA_pduStats, rsp)==SIZE_OF(LRA_pduStats, rsp)) | |
| CHECK (Offset_pduStats_cmd, OFFSET_OF(QLRA_pduStats, cmd)==OFFSET_OF(LRA_pduStats, cmd)) | |
| CHECK (Offset_pduStats_rsp, OFFSET_OF(QLRA_pduStats, rsp)==OFFSET_OF(LRA_pduStats, rsp)) | |
| CHECK (Size_ebmStats, sizeof(QLRA_ebmStats)==sizeof(LRA_ebmStats)) | |
| CHECK (Size_ebmStats_cmd, SIZE_OF(QLRA_ebmStats, cmd)==SIZE_OF(LRA_ebmStats, cmd)) | |
| CHECK (Size_ebmStats_rsp, SIZE_OF(QLRA_ebmStats, rsp)==SIZE_OF(LRA_ebmStats, rsp)) | |
| CHECK (Size_ebmStats_gemR, SIZE_OF(QLRA_ebmStats, gemR)==SIZE_OF(LRA_ebmStats, gemR)) | |
| CHECK (Size_ebmStats_aemR, SIZE_OF(QLRA_ebmStats, aemR)==SIZE_OF(LRA_ebmStats, aemR)) | |
| CHECK (Size_ebmStats_siu0R, SIZE_OF(QLRA_ebmStats, siu0R)==SIZE_OF(LRA_ebmStats, siu0R)) | |
| CHECK (Size_ebmStats_siu1R, SIZE_OF(QLRA_ebmStats, siu1R)==SIZE_OF(LRA_ebmStats, siu1R)) | |
| CHECK (Size_ebmStats_siueR, SIZE_OF(QLRA_ebmStats, siueR)==SIZE_OF(LRA_ebmStats, siueR)) | |
| CHECK (Size_ebmStats_epu0R, SIZE_OF(QLRA_ebmStats, epu0R)==SIZE_OF(LRA_ebmStats, epu0R)) | |
| CHECK (Size_ebmStats_epu1R, SIZE_OF(QLRA_ebmStats, epu1R)==SIZE_OF(LRA_ebmStats, epu1R)) | |
| CHECK (Size_ebmStats_epu2R, SIZE_OF(QLRA_ebmStats, epu2R)==SIZE_OF(LRA_ebmStats, epu2R)) | |
| CHECK (Size_ebmStats_temR, SIZE_OF(QLRA_ebmStats, temR)==SIZE_OF(LRA_ebmStats, temR)) | |
| CHECK (Size_ebmStats_siu0S, SIZE_OF(QLRA_ebmStats, siu0S)==SIZE_OF(LRA_ebmStats, siu0S)) | |
| CHECK (Size_ebmStats_siu1S, SIZE_OF(QLRA_ebmStats, siu1S)==SIZE_OF(LRA_ebmStats, siu1S)) | |
| CHECK (Size_ebmStats_siueS, SIZE_OF(QLRA_ebmStats, siueS)==SIZE_OF(LRA_ebmStats, siueS)) | |
| CHECK (Size_ebmStats_epu0S, SIZE_OF(QLRA_ebmStats, epu0S)==SIZE_OF(LRA_ebmStats, epu0S)) | |
| CHECK (Size_ebmStats_epu1S, SIZE_OF(QLRA_ebmStats, epu1S)==SIZE_OF(LRA_ebmStats, epu1S)) | |
| CHECK (Size_ebmStats_epu2S, SIZE_OF(QLRA_ebmStats, epu2S)==SIZE_OF(LRA_ebmStats, epu2S)) | |
| CHECK (Size_ebmStats_ssrS, SIZE_OF(QLRA_ebmStats, ssrS)==SIZE_OF(LRA_ebmStats, ssrS)) | |
| CHECK (Offset_ebmStats_cmd, OFFSET_OF(QLRA_ebmStats, cmd)==OFFSET_OF(LRA_ebmStats, cmd)) | |
| CHECK (Offset_ebmStats_rsp, OFFSET_OF(QLRA_ebmStats, rsp)==OFFSET_OF(LRA_ebmStats, rsp)) | |
| CHECK (Offset_ebmStats_gemR, OFFSET_OF(QLRA_ebmStats, gemR)==OFFSET_OF(LRA_ebmStats, gemR)) | |
| CHECK (Offset_ebmStats_aemR, OFFSET_OF(QLRA_ebmStats, aemR)==OFFSET_OF(LRA_ebmStats, aemR)) | |
| CHECK (Offset_ebmStats_siu0R, OFFSET_OF(QLRA_ebmStats, siu0R)==OFFSET_OF(LRA_ebmStats, siu0R)) | |
| CHECK (Offset_ebmStats_siu1R, OFFSET_OF(QLRA_ebmStats, siu1R)==OFFSET_OF(LRA_ebmStats, siu1R)) | |
| CHECK (Offset_ebmStats_siueR, OFFSET_OF(QLRA_ebmStats, siueR)==OFFSET_OF(LRA_ebmStats, siueR)) | |
| CHECK (Offset_ebmStats_epu0R, OFFSET_OF(QLRA_ebmStats, epu0R)==OFFSET_OF(LRA_ebmStats, epu0R)) | |
| CHECK (Offset_ebmStats_epu1R, OFFSET_OF(QLRA_ebmStats, epu1R)==OFFSET_OF(LRA_ebmStats, epu1R)) | |
| CHECK (Offset_ebmStats_epu2R, OFFSET_OF(QLRA_ebmStats, epu2R)==OFFSET_OF(LRA_ebmStats, epu2R)) | |
| CHECK (Offset_ebmStats_temR, OFFSET_OF(QLRA_ebmStats, temR)==OFFSET_OF(LRA_ebmStats, temR)) | |
| CHECK (Offset_ebmStats_siu0S, OFFSET_OF(QLRA_ebmStats, siu0S)==OFFSET_OF(LRA_ebmStats, siu0S)) | |
| CHECK (Offset_ebmStats_siu1S, OFFSET_OF(QLRA_ebmStats, siu1S)==OFFSET_OF(LRA_ebmStats, siu1S)) | |
| CHECK (Offset_ebmStats_siueS, OFFSET_OF(QLRA_ebmStats, siueS)==OFFSET_OF(LRA_ebmStats, siueS)) | |
| CHECK (Offset_ebmStats_epu0S, OFFSET_OF(QLRA_ebmStats, epu0S)==OFFSET_OF(LRA_ebmStats, epu0S)) | |
| CHECK (Offset_ebmStats_epu1S, OFFSET_OF(QLRA_ebmStats, epu1S)==OFFSET_OF(LRA_ebmStats, epu1S)) | |
| CHECK (Offset_ebmStats_epu2S, OFFSET_OF(QLRA_ebmStats, epu2S)==OFFSET_OF(LRA_ebmStats, epu2S)) | |
| CHECK (Offset_ebmStats_ssrS, OFFSET_OF(QLRA_ebmStats, ssrS)==OFFSET_OF(LRA_ebmStats, ssrS)) | |
| CHECK (Size_aemStats, sizeof(QLRA_aemStats)==sizeof(LRA_aemStats)) | |
| CHECK (Size_aemStats_cmd, SIZE_OF(QLRA_aemStats, cmd)==SIZE_OF(LRA_aemStats, cmd)) | |
| CHECK (Size_aemStats_rsp, SIZE_OF(QLRA_aemStats, rsp)==SIZE_OF(LRA_aemStats, rsp)) | |
| CHECK (Size_aemStats_evt, SIZE_OF(QLRA_aemStats, evt)==SIZE_OF(LRA_aemStats, evt)) | |
| CHECK (Size_aemStats_trg, SIZE_OF(QLRA_aemStats, trg)==SIZE_OF(LRA_aemStats, trg)) | |
| CHECK (Size_aemStats_nCmdPPerr, SIZE_OF(QLRA_aemStats, nCmdPPerr)==SIZE_OF(LRA_aemStats, nCmdPPerr)) | |
| CHECK (Size_aemStats_nCmdPerr, SIZE_OF(QLRA_aemStats, nCmdPerr)==SIZE_OF(LRA_aemStats, nCmdPerr)) | |
| CHECK (Size_aemStats_nTrgPerr, SIZE_OF(QLRA_aemStats, nTrgPerr)==SIZE_OF(LRA_aemStats, nTrgPerr)) | |
| CHECK (Size_aemStats_arcErr, SIZE_OF(QLRA_aemStats, arcErr)==SIZE_OF(LRA_aemStats, arcErr)) | |
| CHECK (Size_aemStats_nFreeErr, SIZE_OF(QLRA_aemStats, nFreeErr)==SIZE_OF(LRA_aemStats, nFreeErr)) | |
| CHECK (Offset_aemStats_cmd, OFFSET_OF(QLRA_aemStats, cmd)==OFFSET_OF(LRA_aemStats, cmd)) | |
| CHECK (Offset_aemStats_rsp, OFFSET_OF(QLRA_aemStats, rsp)==OFFSET_OF(LRA_aemStats, rsp)) | |
| CHECK (Offset_aemStats_evt, OFFSET_OF(QLRA_aemStats, evt)==OFFSET_OF(LRA_aemStats, evt)) | |
| CHECK (Offset_aemStats_trg, OFFSET_OF(QLRA_aemStats, trg)==OFFSET_OF(LRA_aemStats, trg)) | |
| CHECK (Offset_aemStats_nCmdPPerr, OFFSET_OF(QLRA_aemStats, nCmdPPerr)==OFFSET_OF(LRA_aemStats, nCmdPPerr)) | |
| CHECK (Offset_aemStats_nCmdPerr, OFFSET_OF(QLRA_aemStats, nCmdPerr)==OFFSET_OF(LRA_aemStats, nCmdPerr)) | |
| CHECK (Offset_aemStats_nTrgPerr, OFFSET_OF(QLRA_aemStats, nTrgPerr)==OFFSET_OF(LRA_aemStats, nTrgPerr)) | |
| CHECK (Offset_aemStats_arcErr, OFFSET_OF(QLRA_aemStats, arcErr)==OFFSET_OF(LRA_aemStats, arcErr)) | |
| CHECK (Offset_aemStats_nFreeErr, OFFSET_OF(QLRA_aemStats, nFreeErr)==OFFSET_OF(LRA_aemStats, nFreeErr)) | |
| CHECK (Size_temStats, sizeof(QLRA_temStats)==sizeof(LRA_temStats)) | |
| CHECK (Size_temStats_cmd, SIZE_OF(QLRA_temStats, cmd)==SIZE_OF(LRA_temStats, cmd)) | |
| CHECK (Size_temStats_rsp, SIZE_OF(QLRA_temStats, rsp)==SIZE_OF(LRA_temStats, rsp)) | |
| CHECK (Size_temStats_evt, SIZE_OF(QLRA_temStats, evt)==SIZE_OF(LRA_temStats, evt)) | |
| CHECK (Size_temStats_nEvtErr, SIZE_OF(QLRA_temStats, nEvtErr)==SIZE_OF(LRA_temStats, nEvtErr)) | |
| CHECK (Size_temStats_nTrgPerr, SIZE_OF(QLRA_temStats, nTrgPerr)==SIZE_OF(LRA_temStats, nTrgPerr)) | |
| CHECK (Size_temStats_nCableErr, SIZE_OF(QLRA_temStats, nCableErr)==SIZE_OF(LRA_temStats, nCableErr)) | |
| CHECK (Size_temStats_nTagErr, SIZE_OF(QLRA_temStats, nTagErr)==SIZE_OF(LRA_temStats, nTagErr)) | |
| CHECK (Size_temStats_nTimeout, SIZE_OF(QLRA_temStats, nTimeout)==SIZE_OF(LRA_temStats, nTimeout)) | |
| CHECK (Size_temStats_nCmdPerr, SIZE_OF(QLRA_temStats, nCmdPerr)==SIZE_OF(LRA_temStats, nCmdPerr)) | |
| CHECK (Size_temStats_nCmdPPerr, SIZE_OF(QLRA_temStats, nCmdPPerr)==SIZE_OF(LRA_temStats, nCmdPPerr)) | |
| CHECK (Size_temStats_nPrimPerr, SIZE_OF(QLRA_temStats, nPrimPerr)==SIZE_OF(LRA_temStats, nPrimPerr)) | |
| CHECK (Size_temStats_nRdntPerr, SIZE_OF(QLRA_temStats, nRdntPerr)==SIZE_OF(LRA_temStats, nRdntPerr)) | |
| CHECK (Size_temStats_nRdntSel, SIZE_OF(QLRA_temStats, nRdntSel)==SIZE_OF(LRA_temStats, nRdntSel)) | |
| CHECK (Offset_temStats_cmd, OFFSET_OF(QLRA_temStats, cmd)==OFFSET_OF(LRA_temStats, cmd)) | |
| CHECK (Offset_temStats_rsp, OFFSET_OF(QLRA_temStats, rsp)==OFFSET_OF(LRA_temStats, rsp)) | |
| CHECK (Offset_temStats_evt, OFFSET_OF(QLRA_temStats, evt)==OFFSET_OF(LRA_temStats, evt)) | |
| CHECK (Offset_temStats_nEvtErr, OFFSET_OF(QLRA_temStats, nEvtErr)==OFFSET_OF(LRA_temStats, nEvtErr)) | |
| CHECK (Offset_temStats_nTrgPerr, OFFSET_OF(QLRA_temStats, nTrgPerr)==OFFSET_OF(LRA_temStats, nTrgPerr)) | |
| CHECK (Offset_temStats_nCableErr, OFFSET_OF(QLRA_temStats, nCableErr)==OFFSET_OF(LRA_temStats, nCableErr)) | |
| CHECK (Offset_temStats_nTagErr, OFFSET_OF(QLRA_temStats, nTagErr)==OFFSET_OF(LRA_temStats, nTagErr)) | |
| CHECK (Offset_temStats_nTimeout, OFFSET_OF(QLRA_temStats, nTimeout)==OFFSET_OF(LRA_temStats, nTimeout)) | |
| CHECK (Offset_temStats_nCmdPerr, OFFSET_OF(QLRA_temStats, nCmdPerr)==OFFSET_OF(LRA_temStats, nCmdPerr)) | |
| CHECK (Offset_temStats_nCmdPPerr, OFFSET_OF(QLRA_temStats, nCmdPPerr)==OFFSET_OF(LRA_temStats, nCmdPPerr)) | |
| CHECK (Offset_temStats_nPrimPerr, OFFSET_OF(QLRA_temStats, nPrimPerr)==OFFSET_OF(LRA_temStats, nPrimPerr)) | |
| CHECK (Offset_temStats_nRdntPerr, OFFSET_OF(QLRA_temStats, nRdntPerr)==OFFSET_OF(LRA_temStats, nRdntPerr)) | |
| CHECK (Offset_temStats_nRdntSel, OFFSET_OF(QLRA_temStats, nRdntSel)==OFFSET_OF(LRA_temStats, nRdntSel)) | |
| CHECK (Size_ticStats, sizeof(QLRA_ticStats)==sizeof(LRA_ticStats)) | |
| CHECK (Size_ticStats_nCmdPerr, SIZE_OF(QLRA_ticStats, nCmdPerr)==SIZE_OF(LRA_ticStats, nCmdPerr)) | |
| CHECK (Size_ticStats_nReadErr, SIZE_OF(QLRA_ticStats, nReadErr)==SIZE_OF(LRA_ticStats, nReadErr)) | |
| CHECK (Offset_ticStats_nCmdPerr, OFFSET_OF(QLRA_ticStats, nCmdPerr)==OFFSET_OF(LRA_ticStats, nCmdPerr)) | |
| CHECK (Offset_ticStats_nReadErr, OFFSET_OF(QLRA_ticStats, nReadErr)==OFFSET_OF(LRA_ticStats, nReadErr)) | |
| CHECK (Size_cccStats, sizeof(QLRA_cccStats)==sizeof(LRA_cccStats)) | |
| CHECK (Size_cccStats_summ, SIZE_OF(QLRA_cccStats, summ)==SIZE_OF(LRA_cccStats, summ)) | |
| CHECK (Size_cccStats_pData, SIZE_OF(QLRA_cccStats, pData)==SIZE_OF(LRA_cccStats, pData)) | |
| CHECK (Size_cccStats_nData, SIZE_OF(QLRA_cccStats, nData)==SIZE_OF(LRA_cccStats, nData)) | |
| CHECK (Size_cccStats_error, SIZE_OF(QLRA_cccStats, error)==SIZE_OF(LRA_cccStats, error)) | |
| CHECK (Size_cccStats_diag, SIZE_OF(QLRA_cccStats, diag)==SIZE_OF(LRA_cccStats, diag)) | |
| CHECK (Size_cccStats_nEvtPerr, SIZE_OF(QLRA_cccStats, nEvtPerr)==SIZE_OF(LRA_cccStats, nEvtPerr)) | |
| CHECK (Size_cccStats_nTimeout, SIZE_OF(QLRA_cccStats, nTimeout)==SIZE_OF(LRA_cccStats, nTimeout)) | |
| CHECK (Size_cccStats_nCmdPerr, SIZE_OF(QLRA_cccStats, nCmdPerr)==SIZE_OF(LRA_cccStats, nCmdPerr)) | |
| CHECK (Size_cccStats_nReadErr, SIZE_OF(QLRA_cccStats, nReadErr)==SIZE_OF(LRA_cccStats, nReadErr)) | |
| CHECK (Offset_cccStats_summ, OFFSET_OF(QLRA_cccStats, summ)==OFFSET_OF(LRA_cccStats, summ)) | |
| CHECK (Offset_cccStats_pData, OFFSET_OF(QLRA_cccStats, pData)==OFFSET_OF(LRA_cccStats, pData)) | |
| CHECK (Offset_cccStats_nData, OFFSET_OF(QLRA_cccStats, nData)==OFFSET_OF(LRA_cccStats, nData)) | |
| CHECK (Offset_cccStats_error, OFFSET_OF(QLRA_cccStats, error)==OFFSET_OF(LRA_cccStats, error)) | |
| CHECK (Offset_cccStats_diag, OFFSET_OF(QLRA_cccStats, diag)==OFFSET_OF(LRA_cccStats, diag)) | |
| CHECK (Offset_cccStats_nEvtPerr, OFFSET_OF(QLRA_cccStats, nEvtPerr)==OFFSET_OF(LRA_cccStats, nEvtPerr)) | |
| CHECK (Offset_cccStats_nTimeout, OFFSET_OF(QLRA_cccStats, nTimeout)==OFFSET_OF(LRA_cccStats, nTimeout)) | |
| CHECK (Offset_cccStats_nCmdPerr, OFFSET_OF(QLRA_cccStats, nCmdPerr)==OFFSET_OF(LRA_cccStats, nCmdPerr)) | |
| CHECK (Offset_cccStats_nReadErr, OFFSET_OF(QLRA_cccStats, nReadErr)==OFFSET_OF(LRA_cccStats, nReadErr)) | |
| CHECK (Size_tccStats, sizeof(QLRA_tccStats)==sizeof(LRA_tccStats)) | |
| CHECK (Size_tccStats_summ, SIZE_OF(QLRA_tccStats, summ)==SIZE_OF(LRA_tccStats, summ)) | |
| CHECK (Size_tccStats_data, SIZE_OF(QLRA_tccStats, data)==SIZE_OF(LRA_tccStats, data)) | |
| CHECK (Size_tccStats_tot, SIZE_OF(QLRA_tccStats, tot)==SIZE_OF(LRA_tccStats, tot)) | |
| CHECK (Size_tccStats_error, SIZE_OF(QLRA_tccStats, error)==SIZE_OF(LRA_tccStats, error)) | |
| CHECK (Size_tccStats_diag, SIZE_OF(QLRA_tccStats, diag)==SIZE_OF(LRA_tccStats, diag)) | |
| CHECK (Size_tccStats_nDatPerr, SIZE_OF(QLRA_tccStats, nDatPerr)==SIZE_OF(LRA_tccStats, nDatPerr)) | |
| CHECK (Size_tccStats_nTrcSerr, SIZE_OF(QLRA_tccStats, nTrcSerr)==SIZE_OF(LRA_tccStats, nTrcSerr)) | |
| CHECK (Size_tccStats_nWcntPerr, SIZE_OF(QLRA_tccStats, nWcntPerr)==SIZE_OF(LRA_tccStats, nWcntPerr)) | |
| CHECK (Size_tccStats_nHdrPerr, SIZE_OF(QLRA_tccStats, nHdrPerr)==SIZE_OF(LRA_tccStats, nHdrPerr)) | |
| CHECK (Size_tccStats_nTimeout, SIZE_OF(QLRA_tccStats, nTimeout)==SIZE_OF(LRA_tccStats, nTimeout)) | |
| CHECK (Size_tccStats_nFullErr, SIZE_OF(QLRA_tccStats, nFullErr)==SIZE_OF(LRA_tccStats, nFullErr)) | |
| CHECK (Size_tccStats_nTfeTerr, SIZE_OF(QLRA_tccStats, nTfeTerr)==SIZE_OF(LRA_tccStats, nTfeTerr)) | |
| CHECK (Size_tccStats_nTrcTerr, SIZE_OF(QLRA_tccStats, nTrcTerr)==SIZE_OF(LRA_tccStats, nTrcTerr)) | |
| CHECK (Size_tccStats_nCmdPerr, SIZE_OF(QLRA_tccStats, nCmdPerr)==SIZE_OF(LRA_tccStats, nCmdPerr)) | |
| CHECK (Size_tccStats_nReadErr, SIZE_OF(QLRA_tccStats, nReadErr)==SIZE_OF(LRA_tccStats, nReadErr)) | |
| CHECK (Offset_tccStats_summ, OFFSET_OF(QLRA_tccStats, summ)==OFFSET_OF(LRA_tccStats, summ)) | |
| CHECK (Offset_tccStats_data, OFFSET_OF(QLRA_tccStats, data)==OFFSET_OF(LRA_tccStats, data)) | |
| CHECK (Offset_tccStats_tot, OFFSET_OF(QLRA_tccStats, tot)==OFFSET_OF(LRA_tccStats, tot)) | |
| CHECK (Offset_tccStats_error, OFFSET_OF(QLRA_tccStats, error)==OFFSET_OF(LRA_tccStats, error)) | |
| CHECK (Offset_tccStats_diag, OFFSET_OF(QLRA_tccStats, diag)==OFFSET_OF(LRA_tccStats, diag)) | |
| CHECK (Offset_tccStats_nDatPerr, OFFSET_OF(QLRA_tccStats, nDatPerr)==OFFSET_OF(LRA_tccStats, nDatPerr)) | |
| CHECK (Offset_tccStats_nTrcSerr, OFFSET_OF(QLRA_tccStats, nTrcSerr)==OFFSET_OF(LRA_tccStats, nTrcSerr)) | |
| CHECK (Offset_tccStats_nWcntPerr, OFFSET_OF(QLRA_tccStats, nWcntPerr)==OFFSET_OF(LRA_tccStats, nWcntPerr)) | |
| CHECK (Offset_tccStats_nHdrPerr, OFFSET_OF(QLRA_tccStats, nHdrPerr)==OFFSET_OF(LRA_tccStats, nHdrPerr)) | |
| CHECK (Offset_tccStats_nTimeout, OFFSET_OF(QLRA_tccStats, nTimeout)==OFFSET_OF(LRA_tccStats, nTimeout)) | |
| CHECK (Offset_tccStats_nFullErr, OFFSET_OF(QLRA_tccStats, nFullErr)==OFFSET_OF(LRA_tccStats, nFullErr)) | |
| CHECK (Offset_tccStats_nTfeTerr, OFFSET_OF(QLRA_tccStats, nTfeTerr)==OFFSET_OF(LRA_tccStats, nTfeTerr)) | |
| CHECK (Offset_tccStats_nTrcTerr, OFFSET_OF(QLRA_tccStats, nTrcTerr)==OFFSET_OF(LRA_tccStats, nTrcTerr)) | |
| CHECK (Offset_tccStats_nCmdPerr, OFFSET_OF(QLRA_tccStats, nCmdPerr)==OFFSET_OF(LRA_tccStats, nCmdPerr)) | |
| CHECK (Offset_tccStats_nReadErr, OFFSET_OF(QLRA_tccStats, nReadErr)==OFFSET_OF(LRA_tccStats, nReadErr)) | |
| CHECK (Size_stats, sizeof(QLRA_stats)==sizeof(LRA_stats)) | |
| CHECK (Size_stats_version, SIZE_OF(QLRA_stats, version)==SIZE_OF(LRA_stats, version)) | |
| CHECK (Size_stats_resetTime, SIZE_OF(QLRA_stats, resetTime)==SIZE_OF(LRA_stats, resetTime)) | |
| CHECK (Size_stats_startTime, SIZE_OF(QLRA_stats, startTime)==SIZE_OF(LRA_stats, startTime)) | |
| CHECK (Size_stats_endTime, SIZE_OF(QLRA_stats, endTime)==SIZE_OF(LRA_stats, endTime)) | |
| CHECK (Size_stats_nRead, SIZE_OF(QLRA_stats, nRead)==SIZE_OF(LRA_stats, nRead)) | |
| CHECK (Size_stats_nFail, SIZE_OF(QLRA_stats, nFail)==SIZE_OF(LRA_stats, nFail)) | |
| CHECK (Size_stats_gem, SIZE_OF(QLRA_stats, gem)==SIZE_OF(LRA_stats, gem)) | |
| CHECK (Size_stats_cru, SIZE_OF(QLRA_stats, cru)==SIZE_OF(LRA_stats, cru)) | |
| CHECK (Size_stats_pdu0, SIZE_OF(QLRA_stats, pdu0)==SIZE_OF(LRA_stats, pdu0)) | |
| CHECK (Size_stats_pdu1, SIZE_OF(QLRA_stats, pdu1)==SIZE_OF(LRA_stats, pdu1)) | |
| CHECK (Size_stats_ebm, SIZE_OF(QLRA_stats, ebm)==SIZE_OF(LRA_stats, ebm)) | |
| CHECK (Size_stats_aem, SIZE_OF(QLRA_stats, aem)==SIZE_OF(LRA_stats, aem)) | |
| CHECK (Size_stats_tem, SIZE_OF(QLRA_stats, tem)==SIZE_OF(LRA_stats, tem)) | |
| CHECK (Size_stats_tic, SIZE_OF(QLRA_stats, tic)==SIZE_OF(LRA_stats, tic)) | |
| CHECK (Size_stats_ccc, SIZE_OF(QLRA_stats, ccc)==SIZE_OF(LRA_stats, ccc)) | |
| CHECK (Size_stats_tcc, SIZE_OF(QLRA_stats, tcc)==SIZE_OF(LRA_stats, tcc)) | |
| CHECK (Offset_stats_version, OFFSET_OF(QLRA_stats, version)==OFFSET_OF(LRA_stats, version)) | |
| CHECK (Offset_stats_resetTime, OFFSET_OF(QLRA_stats, resetTime)==OFFSET_OF(LRA_stats, resetTime)) | |
| CHECK (Offset_stats_startTime, OFFSET_OF(QLRA_stats, startTime)==OFFSET_OF(LRA_stats, startTime)) | |
| CHECK (Offset_stats_endTime, OFFSET_OF(QLRA_stats, endTime)==OFFSET_OF(LRA_stats, endTime)) | |
| CHECK (Offset_stats_nRead, OFFSET_OF(QLRA_stats, nRead)==OFFSET_OF(LRA_stats, nRead)) | |
| CHECK (Offset_stats_nFail, OFFSET_OF(QLRA_stats, nFail)==OFFSET_OF(LRA_stats, nFail)) | |
| CHECK (Offset_stats_gem, OFFSET_OF(QLRA_stats, gem)==OFFSET_OF(LRA_stats, gem)) | |
| CHECK (Offset_stats_cru, OFFSET_OF(QLRA_stats, cru)==OFFSET_OF(LRA_stats, cru)) | |
| CHECK (Offset_stats_pdu0, OFFSET_OF(QLRA_stats, pdu0)==OFFSET_OF(LRA_stats, pdu0)) | |
| CHECK (Offset_stats_pdu1, OFFSET_OF(QLRA_stats, pdu1)==OFFSET_OF(LRA_stats, pdu1)) | |
| CHECK (Offset_stats_ebm, OFFSET_OF(QLRA_stats, ebm)==OFFSET_OF(LRA_stats, ebm)) | |
| CHECK (Offset_stats_aem, OFFSET_OF(QLRA_stats, aem)==OFFSET_OF(LRA_stats, aem)) | |
| CHECK (Offset_stats_tem, OFFSET_OF(QLRA_stats, tem)==OFFSET_OF(LRA_stats, tem)) | |
| CHECK (Offset_stats_tic, OFFSET_OF(QLRA_stats, tic)==OFFSET_OF(LRA_stats, tic)) | |
| CHECK (Offset_stats_ccc, OFFSET_OF(QLRA_stats, ccc)==OFFSET_OF(LRA_stats, ccc)) | |
| CHECK (Offset_stats_tcc, OFFSET_OF(QLRA_stats, tcc)==OFFSET_OF(LRA_stats, tcc)) | |
1.5.8