FreeCalypso > hg > fc-tourmaline
diff src/g23m-fad/rlp/rlp.h @ 1:fa8dc04885d8
src/g23m-*: import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Fri, 16 Oct 2020 06:25:50 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-fad/rlp/rlp.h Fri Oct 16 06:25:50 2020 +0000 @@ -0,0 +1,1389 @@ +/* ++----------------------------------------------------------------------------- +| Project : CSD (8411) +| Modul : Rlp.h ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : Definitions for the Protocol Stack Entity +| Radio Link Protocol ++----------------------------------------------------------------------------- +*/ + +#ifndef RLP_H +#define RLP_H + +/* + * Conditional Compiling + */ + +#undef TRACE_INTERPRETED_RLP_FRAME +#undef TRACE_RLP_FRAME +#define V42BIS + +/* + * Macros + */ + + /* + * instance management + */ +#define GET_INSTANCE(p) &rlp_data_base[0] + +/* + * Constants + */ +/* + * global unchangable constants + */ +#ifdef V42BIS +#define ORIG_RLP_VERS 1 /* rlp version (1=single link ext)*/ +#else +#define ORIG_RLP_VERS 0 /* rlp version (0=single link)*/ +#endif + +#define WIND_SIZE_MAX 61 /* max window size RLP */ +#define DATA_SIZE_SHORT 25 /* num of data bytes in rlp frame (short format) */ +#define DATA_SIZE_LONG 67 /* num of data bytes in rlp frame (long format, version 1) */ + +/* + * default timeout for the RLP timer + */ +#define GEN_TO TT_VALUE /* default retransmission timer*/ +#define UL_TO TUL_RCV_VALUE + +/* + * max number of outstanding SREJs + */ +#define MAX_SREJ_COUNT 10 + +/* +* timer indices +* +* 0..MAX_SREJ_COUNT reserved for field +*/ +#define TT_HANDLE (MAX_SREJ_COUNT+1) +#define TRCVR_HANDLE (MAX_SREJ_COUNT+2) +#define TXID_HANDLE (MAX_SREJ_COUNT+3) +#define TUL_RCV_HANDLE (MAX_SREJ_COUNT+4) + +/* + * number of frames that are requested in case if low water + */ + +/* + * maximum number N2 can have + */ +#define N2_MAX 255 + +/* + * derived constants + */ +#define HEADER_LEN (RLP_HEADER_LEN/8) +#define TRAILER_LEN (RLP_TRAILER_LEN/8) +#define FRAME_SIZE_SHORT (DATA_SIZE_SHORT+HEADER_LEN+TRAILER_LEN) +#define FRAME_SIZE_LONG (DATA_SIZE_LONG+HEADER_LEN+TRAILER_LEN) + +/* + * constants for XID parameter types + */ +#define XID_T_NULL 0 /* end tag */ +#define XID_T_RLP_VERS 1 /* rlp version number */ +#define XID_T_K_IWF_MS 2 /* window size iwf->ms */ +#define XID_T_K_MS_IWF 3 /* window size ms->iwf */ +#define XID_T_T1 4 /* acknowledge timer */ +#define XID_T_N2 5 /* max num of retrans attempts */ +#define XID_T_T2 6 /* reply delay */ +#define XID_T_COMPR 7 /* data compression */ + +/* + * constants for XID parameter length in bytes + */ +#define XID_L_RLP_VERS 1 /* rlp version number */ +#define XID_L_K_MS_IWF 1 /* window size ms->iwf */ +#define XID_L_K_IWF_MS 1 /* window size iwf->ms */ +#define XID_L_T1 1 /* acknowledge timer */ +#define XID_L_N2 1 /* max num of retrans attempts */ +#define XID_L_T2 1 /* reply delay */ +#define XID_L_COMPR 4 /* data compression */ + +/* + * constants, to indicate parameters, which are used in XID + */ +#define UF_SET_RLP_VERS 0x01 +#define UF_SET_K_IWF_MS 0x02 +#define UF_SET_K_MS_IWF 0x04 +#define UF_SET_T1 0x08 +#define UF_SET_N2 0x10 +#define UF_SET_T2 0x20 +#define UF_SET_COMPR 0x40 +#define UF_ALL 0x7F + +/* + * default values for XID + */ +#define DEF_RLP_VERS 0 +#define DEF_K_MS_IWF 61 +#define DEF_K_IWF_MS 61 +#define DEF_T1_FR14400 520 +#define DEF_T1_FR9600 480 +#define DEF_T1_FR4800 540 +#define DEF_T1_HR4800 780 + +#define DEF_T2 80 +#define DEF_N2 6 +#define DEF_PT 0 +#define DEF_P0 0 +#define DEF_P1 512 +#define DEF_P2 6 + +/* + * Bitoffset for encoding/decoding + */ +#define ENCODE_OFFSET 0 + +/* + * Parameter of dynamic configuration commands + */ + +#ifndef NTRACE + +/* for trace purposes */ + +#define SERVICE_NAME_KER "KER" +#define SERVICE_NAME_KERXID_C "XID_C" +#define SERVICE_NAME_RCV "RCV" +#define SERVICE_NAME_SND "SND" + +#endif + +#define KER ker. +#define KERXID_C ker.XID_C. +#define RCV rcv. +#define SND snd. + +/* + * State index for the entity processes + */ + +/* + * States of the entity process KERNEL + */ +#define RLP_ADM_AND_DETACHED 0 +#define RLP_ADM_AND_ATTACHED 1 +#define RLP_PENDING_CONNECT_REQ 2 +#define RLP_PENDING_CONNECT_IND 3 +#define RLP_CONNECTION_ESTABLISHED 4 +#define RLP_PENDING_RESET_REQ 5 +#define RLP_PENDING_RESET_IND 6 +#define RLP_DISCONNECT_INITIATED 7 +#define RLP_PERMANENT_ERROR 9 +#define RLP_PENDING_REMAP_REQ 10 +#define RLP_REMAP_DATA 11 + +/* + * States of the entity process RCV + */ +#define RPDU_WAIT_FOR_A_BLOCK 0 + + +/* + * States of the entity process SND + */ +#define SPDU_WAIT_EVENT 0 + +/*==== TYPES ======================================================*/ + +/* + * RLP global typedefs + */ + +typedef ULONG T_BITSET; + +typedef UBYTE T_BIT_INT; +typedef T_BIT_INT T_BIT; + +typedef UBYTE T_FRAME_NUM; +typedef UBYTE T_EXT_FRAME_NUM; + +/* + * structure of a RLP Frame + */ +typedef UBYTE T_RLP_FRAMEDATA; +/* +typedef UBYTE T_RLP_FRAME_SHORT[FRAME_SIZE_SHORT]; +*/ +typedef UBYTE T_RLP_FRAME_LONG[FRAME_SIZE_LONG]; +typedef UBYTE* T_RLP_FRAMEPTR; + +/* + * bitcoding of the M5-M1 of the RLP header for the + * different frame types. + */ +typedef enum +{ + UF_UI =0x00, + UF_DM =0x03, + UF_SABM =0x07, + UF_DISC =0x08, + UF_UA =0x0C, + UF_NULL =0x0F, + UF_XID =0x17, + UF_TEST =0x1C, + UF_REMAP =0x11 +} T_UF; + +/* + * bitcoding of the S2-S1 of the RLP header for the + * different frame types. + */ +typedef enum +{ + SF_RR =0x00, + SF_RNR =0x01, + SF_REJ =0x02, + SF_SREJ =0x03 +} T_SF; + +typedef enum +{ + PDU_INVALID, + PDU_SABM, + PDU_DISC, + PDU_UA, + PDU_DM, + PDU_TEST, + PDU_NULL, + PDU_XID, + PDU_UI, + PDU_RR_I, + PDU_RNR_I, + PDU_SREJ_I, + PDU_REJ_I, + PDU_RR, + PDU_RNR, + PDU_SREJ, + PDU_REJ, + PDU_REMAP +} T_PDU_TYPE; + +/* + * Process kernel specific types + */ +#define IS_IDLE 0 +#define IS_SEND 1 + +#define IW_IDLE 0 +#define IW_WAIT 1 + +#define ISW_IDLE 0 +#define ISW_SEND 1 +#define ISW_WAIT 2 + +#define DTX_N 0 +#define DTX_RR 1 +#define DTX_RNR 2 + +typedef UBYTE T_COUNTER; + +#define INVALID_IDX ((UBYTE) -1) + +/* + * send buffer management + */ +#define SBM_INVALID_IDX INVALID_IDX + +#define SBM_BUF_SIZE (WIND_SIZE_MAX+1) +#define SBM_PRIMBUF_SIZE SBM_BUF_SIZE + +typedef T_RLP_DATA_REQ T_SBM_PRIM; + +typedef UBYTE T_SBM_BUFFER_INDEX; +typedef UBYTE T_SBM_BUFFER_EXTIDX; + +typedef USHORT T_SBM_PRIM_INDEX; +typedef USHORT T_SBM_PRIM_EXTIDX; + +typedef struct +{ + T_SBM_PRIM *Prim; + UBYTE RefCount; +} T_SBM_PRIMSLOT; + +typedef enum +{ + SBM_IDLE, + SBM_SEND, + SBM_WAIT +} T_SBM_STATE; + +typedef struct +{ + T_SBM_PRIM_EXTIDX PrimSlot1; /* Index on T_SBM_PRIM */ + T_SBM_PRIM_EXTIDX PrimSlot2; /* Index on T_SBM_PRIM */ + USHORT Offset1; /* Offset of data in primitive */ + USHORT Offset2; /* Offset of data in primitive */ + USHORT Len1; /* Length of data in primitive */ + USHORT Len2; /* Length of data in primitive */ + T_SBM_STATE S_State; /* 'SBM_SEND' means, data has to be sent (with seq. num. n) */ + T_SBM_BUFFER_EXTIDX NextSREJ; +} T_SBM_SLOT; + +/* + * receive buffer management + */ +#define RBM_INVALID_IDX INVALID_IDX + +#define RBM_BUF_SIZE (WIND_SIZE_MAX+1) + +#ifdef _SIMULATION_ +#define RBM_PQ_MAX_PRIM 10 +#else +#define RBM_PQ_MAX_PRIM 4 +#endif + +#define RBM_PQ_THRE_RNR (RBM_PQ_MAX_PRIM-2) +#define RBM_PQ_SIZE (RBM_PQ_MAX_PRIM+1) + +typedef T_RLP_DATA_IND T_RBM_PRIM; + +typedef UBYTE T_RBM_BUFFER_INDEX; +typedef UBYTE T_RBM_BUFFER_EXTIDX; +typedef UBYTE T_RBM_PQ_INDEX; + +typedef T_RLP_FRAME_LONG T_RBM_FRAME_LONG; +typedef T_RLP_FRAMEPTR T_RBM_FRAMEPTR; + +typedef enum +{ + RBM_IDLE, + RBM_RCVD, + RBM_SREJ, + RBM_WAIT +} T_RBM_STATE; + + +typedef struct +{ + T_RBM_FRAME_LONG Frame; /* To store user information */ + T_RBM_STATE R_State; /* 'RBM_RCVD': data has been received (with seq. num. n) + 'RBM_SREJ': the retrans. has to be requested using srej(n) + 'RBM_WAIT': the entity waits for the requested retransmitted data */ +} T_RBM_SLOT; + +/* + * SREJ timer managment + */ + +#define SRM_DATA_SIZE (WIND_SIZE_MAX+1) + +typedef T_COUNTER T_SRM_COUNTER; + +typedef struct +{ + T_SRM_COUNTER count; +} T_SRM_SLOT; + +/* + * process global data + */ + +/* + * data for process kernel + */ + +/* + * table entry for timeout handling of the T_RCVS timer + */ +typedef struct +{ + BOOL isFree; + T_FRAME_NUM slot; + UBYTE trcvs_running; +} T_RCVS_ENTRY; + +typedef struct +{ + UBYTE state; +#ifndef NTRACE + char *name; + char *state_name; +#endif +} T_SUB_STATE; + +typedef struct +{ + UBYTE state; +#ifndef NTRACE + char *name; + char *state_name; +#endif + + /*------------ variables according to GSM 04.22 ----------------------------------*/ + + T_BIT ABit; /* to store the Ack_Flg value of a received Connect_Resp frame */ + + T_BIT Ackn_FBit; /* Value of the F-Bit used in the next acknowledging PDU. */ + UBYTE Ackn_State; /* 'SEND': an acknowledging PDU (Supervisory or Data) has to be sent */ + /* after receiving an I-frame or a command frame with the Poll bit = 1 */ + + USHORT BytesPerPrim; /* number of bytes in RLP data primitives */ + BOOL Connected; /* Process in RLP_CONNECTION_ESTABLISHED state */ + + USHORT Def_T1; /* Default value for T1, depends on transmission rate */ + + T_COUNTER DISC_Count; /* to count the transmissions of DISC.*/ + BOOL DISC_Ind; /* In RLP_DISCONNECT_INITIATED: Indicate succesfull DISC by RLP_DISC_IND */ + T_BIT DISC_PBit; /* The value of the P-bit in the next DISC command PDU.*/ + UBYTE DISC_State; /* 'SEND': the DISC command PDU has to be sent at the next possible opportunity. */ + /* 'WAIT': the RLP entity waits for the corresponding response.*/ + T_BIT DM_FBit; /* Value of the F-Bit used in the next DM response PDU.*/ + UBYTE DM_State; /* 'SEND': the PDU DM has to be sent. */ + UBYTE DTX_SF; /* to store the last Superv. frame for DTX (only RR or RNR can be suppressed) */ + T_FRAME_NUM DTX_VR; /* to store the last transmitted value of VR (used to decide the DTX condition) */ + USHORT FrameSize; /* Size of RLP frame may be FRAME_SIZE_SHORT or FRAME_SIZE_LONG */ + USHORT FramesPerPrim;/* number of frames in RLP data primitives (calculated from BytesPerPrim) */ + + T_FRAME_NUM K_ms_iwf; /* window size ms->iwf */ + T_FRAME_NUM K_iwf_ms; /* window size iwf->ms */ + + BOOL LRFull; /* Local Receiver Full */ + BOOL LRReady; /* Local Receiver Ready */ + + UBYTE N2; /* maximum numer of retransmission attempts */ + + USHORT OldFrameSize; /* Size of RLP frame before REMAP */ + + T_FRAME_NUM Orig_K_iwf_ms; /* original value for k_iwf_ms */ + T_FRAME_NUM Orig_K_ms_iwf; /* original value for k_ms_iwf */ + UBYTE Orig_N2; /* original value for n2 */ + UBYTE Orig_P0; /* original value for p0 */ + USHORT Orig_P1; /* original value for p1 */ + UBYTE Orig_P2; /* original value for p2 */ + UBYTE Orig_Pt; /* original value for pt */ + USHORT Orig_T1; /* original value for t1 */ + USHORT Orig_T2; /* original value for t2 */ + + UBYTE P0; /* V.42bis data compression request */ + USHORT P1; /* number of possible codewords */ + UBYTE P2; /* maximum encodable string length */ + + T_COUNTER Poll_Count; /* to count the transmissions of poll requests*/ + UBYTE Poll_State; /* 'SEND': a supervisory PDU with P-bit set to one has to be sent*/ + /* 'WAIT': the RLP entity waits for the response with F-bit set to one */ + UBYTE Poll_xchg; /* 'IDLE': sending of a frame with P-bit set is allowed */ + /* 'WAIT': an acknowledgement of a previous P-bit is outstanding */ + UBYTE Pt; /* type of data compression */ + + UBYTE REJ_State; /* The REJ_State is send if and only if a REJ PDU has to be sent */ + + T_RLP_FRAME_LONG REMAP_Frame; /* frame to be sent in the next REMAP PDU*/ + T_FRAME_DESC REMAP_FrameDesc; /* Descriptor for REMAP_Frame (static) */ + T_FRAME_NUM RemapNr; /* Frame number taken from REMAP response */ + + UBYTE Rlp_Vers; /* negotiated RLP version */ + BOOL RRReady; /* Remote Receiver Ready*/ + T_COUNTER SABM_Count; /* to count the transmissions of SABM*/ + UBYTE SABM_State; /* 'SEND': the SABM PDU has to be sent */ + /* 'WAIT': the RLP entity waits for the UA response */ + T_SF SF; /* to store the last superv. PDU type*/ + USHORT SREJ_Count; /* number of outstanding SREJs == number of running SREJ timers (downlink) */ + + USHORT T1; /* value for acknowledge timer */ + USHORT T2; /* reply delay */ + USHORT T_ul; /* value for timer T_UL_RCV (upper layer waiting for data) */ + + T_RLP_FRAME_LONG TEST_R_Frame; /* data to be sent in the next TEST response PDU */ + T_FRAME_DESC TEST_R_FrameDesc; /* descriptor for TEST_R_Frame (static) */ + T_BIT TEST_R_FBit; /* value of the P-Bit used in the next TEST response PDU */ + UBYTE TEST_R_State; /* 'SEND': the TEST response PDU has to be sent */ + + T_BIT UA_FBit; /* value of the F-Bit used in the next UA response */ + UBYTE UA_State; /* if (UA_State = SEND) an UA PDU has to be sent */ + + T_RLP_FRAME_LONG UI_Frame; /* frame to be sent in the next UI PDU*/ + T_FRAME_DESC UI_FrameDesc; /* Descriptor for UI_Frame (static) */ + T_BIT UI_PBit; /* value of the P-Bit used in the next UI PDU */ + UBYTE UI_State; /* 'SEND': a UI PDU has to be sent */ + + UBYTE UL_Rcv_State; /* 'WAIT': Upper layer is waiting for data */ + UBYTE UL_Snd_State; /* 'WAIT': RLP is waiting for data from upper layer*/ + + T_COUNTER XID_Count; /* to count the transmissions of XID commands */ + + T_RLP_FRAME_LONG XID_C_Frame; /* data to be sent in the next XID command PDU */ + T_FRAME_DESC XID_C_FrameDesc;/* Descriptor for XID_C_Frame (static) */ + T_BIT XID_C_PBit; /* value of the P-Bit used in the next XID command PDU */ + + T_SUB_STATE XID_C; /* 'SEND': the XID command PDU has to be sent */ + /* 'WAIT': the RLP entity waits for the next XID response */ + + T_BITSET XID_C_Used_Flg; /* Contains bits that indicate + which parameters have been received in the last XID command PDU */ + + T_RLP_FRAME_LONG XID_R_Frame; /* frame to be sent in the next XID response PDU */ + T_FRAME_DESC XID_R_FrameDesc; /* Descriptor for XID_R_Frame (static) */ + T_BIT XID_R_FBit; /* value of the P-Bit used in the next XID response PDU */ + UBYTE XID_R_State; /* 'SEND': the XID response PDU has to be sent*/ + T_BITSET XID_R_Used_Flg; /* Contains bits that indicate + which parameters have to be send in the next XID response PDU */ + + T_RCVS_ENTRY rcvsTab[MAX_SREJ_COUNT]; + +} T_KER; + +/* + * data for process receive_pdu + */ + +/* no global data */ + +/* + * data for process send_pdu + */ + +typedef struct +{ + UBYTE state; +#ifndef NTRACE + char *name; + char *state_name; +#endif + + T_RLP_FRAME_LONG HO_Frame; /* Buffer and Descriptor for RLP Frames with header only */ + T_FRAME_DESC HO_FrameDesc; + USHORT FrameSize; /* Size of RLP frame may be FRAME_SIZE_SHORT or FRAME_SIZE_LONG */ +} T_SND; + +/* + * data for send buffer management + */ +typedef struct +{ + T_SBM_PRIM_INDEX CurrPrimSlot; + USHORT CurrPrimOff; + USHORT CurrPrimLen; + T_SBM_BUFFER_INDEX K; + T_SBM_BUFFER_EXTIDX LastSentFrame; + T_SBM_PRIMSLOT Prim[SBM_PRIMBUF_SIZE]; + T_SBM_SLOT Frame[SBM_BUF_SIZE]; + USHORT FrameSize; + T_SBM_BUFFER_EXTIDX SREJ_List; + T_SBM_BUFFER_INDEX REJ_Buf[N2_MAX +1]; + UBYTE REJ_BufLo; + UBYTE REJ_BufHi; + UBYTE REJ_BufSize; + T_SBM_BUFFER_INDEX REJ_BufLastN; + T_SBM_BUFFER_INDEX VA; + T_SBM_BUFFER_INDEX VD; + T_SBM_BUFFER_INDEX VS; +} T_SBM; + +/* + * data for receive buffer management + */ +typedef struct +{ + BOOL Initialised; + BOOL FrameInRiBu; + T_RBM_PRIM *CurrPrim; + USHORT CurrPrimCou; + USHORT FramesPerPrim; + T_RBM_BUFFER_INDEX K; + T_RBM_SLOT Slot[RBM_BUF_SIZE]; + USHORT FrameSize; + T_RBM_FRAME_LONG Frame; + T_RBM_PRIM *PQ_Array[RBM_PQ_SIZE]; + T_RBM_PQ_INDEX PQ_Read; + T_RBM_PQ_INDEX PQ_Write; + T_RBM_BUFFER_INDEX VR; + T_RBM_BUFFER_INDEX LastVR; +} T_RBM; + +/* + * data for srej timer management + */ +typedef struct +{ + T_SRM_SLOT Data[SRM_DATA_SIZE]; +} T_SRM; + +#if defined (TRACE_INTERPRETED_RLP_FRAME) || defined (TRACE_RLP_FRAME) + +typedef struct +{ + char trc_buf[80]; + UBYTE idx; +} T_RLP_DEBUG; + +#endif + +/* + * entity data for each RLP instance + */ + +typedef struct +{ + UBYTE tul_rcv_running; + T_FRAME_NUM rcvs_slot; + + T_KER ker; /* process kernel */ + T_SND snd; /* process send_pdu */ + T_SBM sbm; /* send buffer manager */ + T_SUB_STATE rcv; + T_RBM rbm; /* receive buffer manager */ + T_SRM srm; /* srej timer manager */ + + /* Flags for frame trace */ + BOOL uplink_frame_trace; + BOOL downlink_frame_trace; + +#if defined (TRACE_INTERPRETED_RLP_FRAME) || defined (TRACE_RLP_FRAME) + T_RLP_DEBUG deb; +#endif + +} T_RLP_DATA; + + +/*==== EXPORT =====================================================*/ +/* + * data base + */ + + +/* + * instance data base + */ +#ifdef RLP_PEI_C + +/*lint -e759 : header declaration for symbol 'rlp_data_base' could be moved from header to module */ +GLOBAL T_RLP_DATA rlp_data_base[1], *rlp_data; +GLOBAL ULONG rlp_data_base_size; +GLOBAL ULONG rlp_data_magic_num; + +#else + +EXTERN T_RLP_DATA rlp_data_base [], *rlp_data; +EXTERN ULONG rlp_data_magic_num; + +#endif + +#define ENTITY_DATA rlp_data +#define RLP_DATA_MAGIC_NUM (('R'<<24) + ('L'<<16) + ('P'<<8)) /* "FAD",NUL */ + +/* + * Prototypes + * + * RLP KERNEL + * + * KERNEL primitive processing + */ + +EXTERN void ker_rlp_attach_req (T_RLP_ATTACH_REQ *rlp_attach_req); +EXTERN void ker_rlp_detach_req (T_RLP_DETACH_REQ *rlp_detach_req); +EXTERN void ker_rlp_connect_req (T_RLP_CONNECT_REQ *rlp_connect_req); +EXTERN void ker_rlp_connect_res (T_RLP_CONNECT_RES *rlp_connect_res); +EXTERN void ker_rlp_disc_req (T_RLP_DISC_REQ *rlp_disc_req); +EXTERN void ker_rlp_reset_req (T_RLP_RESET_REQ *rlp_reset_req); +EXTERN void ker_rlp_reset_res (T_RLP_RESET_RES *rlp_reset_res); +EXTERN void ker_rlp_data_req (T_RLP_DATA_REQ *rlp_data_req); +EXTERN void ker_rlp_getdata_req (T_RLP_GETDATA_REQ *rlp_getdata_req); +EXTERN void ker_rlp_ui_req (T_RLP_UI_REQ *rlp_ui_req); +EXTERN void ker_rlp_remap_req (T_RLP_REMAP_REQ *rlp_remap_req); +EXTERN void ker_rlp_remap_data_res (T_RLP_REMAP_DATA_RES *ker_rlp_remap_data_res); + +/* + * KERNEL signal processing + */ +#ifdef OPTION_MULTITHREAD + #define sig_rcv_ker_sabm_ind _ENTITY_PREFIXED(sig_rcv_ker_sabm_ind) + #define sig_rcv_ker_disc_ind _ENTITY_PREFIXED(sig_rcv_ker_disc_ind) + #define sig_rcv_ker_ua_ind _ENTITY_PREFIXED(sig_rcv_ker_ua_ind) + #define sig_rcv_ker_dm_ind _ENTITY_PREFIXED(sig_rcv_ker_dm_ind) + #define sig_rcv_ker_rr_ind _ENTITY_PREFIXED(sig_rcv_ker_rr_ind) + #define sig_rcv_ker_rnr_ind _ENTITY_PREFIXED(sig_rcv_ker_rnr_ind) + #define sig_rcv_ker_rej_ind _ENTITY_PREFIXED(sig_rcv_ker_rej_ind) + #define sig_rcv_ker_srej_ind _ENTITY_PREFIXED(sig_rcv_ker_srej_ind) + #define sig_rcv_ker_rr_i_ind _ENTITY_PREFIXED(sig_rcv_ker_rr_i_ind) + #define sig_rcv_ker_rnr_i_ind _ENTITY_PREFIXED(sig_rcv_ker_rnr_i_ind) + #define sig_rcv_ker_rej_i_ind _ENTITY_PREFIXED(sig_rcv_ker_rej_i_ind) + #define sig_rcv_ker_srej_i_ind _ENTITY_PREFIXED(sig_rcv_ker_srej_i_ind) + #define sig_rcv_ker_xid_ind _ENTITY_PREFIXED(sig_rcv_ker_xid_ind) + #define sig_rcv_ker_test_ind _ENTITY_PREFIXED(sig_rcv_ker_test_ind) + #define sig_rcv_ker_ready_ind _ENTITY_PREFIXED(sig_rcv_ker_ready_ind) + #define sig_rcv_ker_remap_ind _ENTITY_PREFIXED(sig_rcv_ker_remap_ind) + #define sig_rcv_ker_rawdata_ind _ENTITY_PREFIXED(sig_rcv_ker_rawdata_ind) +#endif + +EXTERN void sig_rcv_ker_sabm_ind (void); +EXTERN void sig_rcv_ker_disc_ind (T_BIT); +EXTERN void sig_rcv_ker_ua_ind (T_BIT); +EXTERN void sig_rcv_ker_dm_ind (T_BIT); +EXTERN void sig_rcv_ker_rr_ind (T_BIT, T_BIT, T_FRAME_NUM); +EXTERN void sig_rcv_ker_rnr_ind (T_BIT, T_BIT, T_FRAME_NUM); +EXTERN void sig_rcv_ker_rej_ind (T_BIT, T_BIT, T_FRAME_NUM); +EXTERN void sig_rcv_ker_srej_ind (T_BIT, T_BIT, T_FRAME_NUM); +EXTERN void sig_rcv_ker_rr_i_ind (T_BIT, T_BIT, T_FRAME_NUM, T_FRAME_NUM); +EXTERN void sig_rcv_ker_rnr_i_ind (T_BIT, T_BIT, T_FRAME_NUM, T_FRAME_NUM); +EXTERN void sig_rcv_ker_rej_i_ind (T_BIT, T_BIT, T_FRAME_NUM, T_FRAME_NUM); +EXTERN void sig_rcv_ker_srej_i_ind (T_BIT, T_BIT, T_FRAME_NUM, T_FRAME_NUM); +EXTERN void sig_rcv_ker_xid_ind (T_BIT, T_BIT); +EXTERN void sig_rcv_ker_test_ind (T_BIT, T_BIT); +EXTERN void sig_rcv_ker_ready_ind (void); +EXTERN void sig_rcv_ker_remap_ind (void); + +#ifdef _SIMULATION_ +EXTERN void sig_rcv_ker_rawdata_ind (T_RA_DATA_IND *); +#else +EXTERN void sig_rcv_ker_rawdata_ind (void); +#endif +/* + * KERNEL procedures + */ + +#ifdef OPTION_MULTITHREAD + + #define ker_init _ENTITY_PREFIXED(ker_init) + #define ker_get_xid_data _ENTITY_PREFIXED(ker_get_xid_data) + #define ker_put_xid_data _ENTITY_PREFIXED(ker_put_xid_data) + #define ker_copy_frame_to_sdu _ENTITY_PREFIXED(ker_copy_frame_to_sdu) + #define ker_copy_sdu_to_frame _ENTITY_PREFIXED(ker_copy_sdu_to_frame) + #define ker_get_frame_desc _ENTITY_PREFIXED(ker_get_frame_desc) + #define ker_i_handler _ENTITY_PREFIXED(ker_i_handler) + #define ker_init_link_vars _ENTITY_PREFIXED(ker_init_link_vars) + #define ker_reset_all_t_rcvs _ENTITY_PREFIXED(ker_reset_all_t_rcvs) + #define ker_s_handler _ENTITY_PREFIXED(ker_s_handler) + #define ker_send_data _ENTITY_PREFIXED(ker_send_data) + #define ker_send_txu _ENTITY_PREFIXED(ker_send_txu) + #define ker_deinit_link_vars _ENTITY_PREFIXED(ker_deinit_link_vars) + #define ker_send_rlp_error_ind _ENTITY_PREFIXED(ker_send_rlp_error_ind) + #define ker_init_xid_data _ENTITY_PREFIXED(ker_init_xid_data) + #define ker_getSlotTRCVS _ENTITY_PREFIXED(ker_getSlotTRCVS) + #define ker_fill_remap_frame _ENTITY_PREFIXED(ker_fill_remap_frame) + #define ker_send_remap_data _ENTITY_PREFIXED(ker_send_remap_data) + #define ker_set_frame_size _ENTITY_PREFIXED(ker_set_frame_size) + +#ifdef TRACE_RLP_FRAME + #define ker_trace_rlp_frame _ENTITY_PREFIXED(ker_trace_rlp_frame) +#endif + +#endif + +EXTERN void ker_init(void); + +EXTERN void ker_get_xid_data + ( + T_RLP_FRAMEDATA *raw_data, + UBYTE index, + T_RLP_XID_IND *xid_data, + BOOL ms_is_initiator, + ULONG *used_flags + ); + +EXTERN void ker_put_xid_data + ( + T_RLP_FRAMEDATA *l_Data, /* buffer for data */ + UBYTE index, /* start index in buffer */ + ULONG l_uf, /* valid parameters */ + BOOL ms_is_initiator, /* MS is sending XID*/ + UBYTE l_rlp_version, /* negotiated vers. */ + T_FRAME_NUM l_k_iwf_ms, /* winSize ms->iwf */ + T_FRAME_NUM l_k_ms_iwf, /* winSize iwf->ms */ + USHORT l_t1, /* ack timer value */ + UBYTE l_n2, /* num restransmiss */ + USHORT l_t2, /* reply delay */ + UBYTE l_pt, /* type data compr. */ + UBYTE l_p0, /* v42bis comp. req */ + USHORT l_p1, /* num possible code*/ + UBYTE l_p2 /* max encod. strlen*/ + ); + +EXTERN void ker_copy_frame_to_sdu + ( + T_RLP_FRAMEPTR frame, + T_sdu *sdu + ); + +EXTERN void ker_copy_sdu_to_frame + ( + T_sdu *sdu, + T_RLP_FRAMEPTR frame, + USHORT n + ); + +EXTERN void ker_get_frame_desc + ( + T_RLP_FRAMEPTR frame, + T_FRAME_DESC *frameDesc + ); + +EXTERN BOOL ker_i_handler(T_FRAME_NUM ns); + +EXTERN void ker_init_link_vars + ( + void + ); + +#ifdef TRACE_RLP_FRAME +EXTERN void ker_trace_rlp_frame + ( + T_RLP_FRAMEPTR frame + ); +#endif + +EXTERN void ker_reset_all_t_rcvs + ( + void + ); + +EXTERN void ker_s_handler + ( + T_BIT cBit, + T_BIT pFBit, + T_SF sf, + T_FRAME_NUM nr, + BOOL *retransError + ); + +EXTERN void ker_send_data + ( + void + ); + +EXTERN BOOL ker_send_txu + ( + void + ); + +EXTERN void ker_deinit_link_vars + ( + void + ); + +EXTERN void ker_send_rlp_error_ind + ( + USHORT cause + ); + +EXTERN void ker_init_xid_data + ( + T_RLP_ATTACH_REQ *rlp_attach_request + ); + +EXTERN T_FRAME_NUM ker_getSlotTRCVS + ( + USHORT index + ); + +EXTERN void ker_fill_remap_frame + ( + T_FRAME_NUM vr + ); + +EXTERN BOOL ker_send_remap_data + ( + void + ); + +EXTERN void ker_set_frame_size + ( + UBYTE rate + ); + +/* + * RLP RCV + * + * RCV primitive processing + */ +#ifdef _SIMULATION_ +EXTERN const void rcv_ra_ready_ind(T_RA_READY_IND *ra_ready_ind); +#else +EXTERN void rcv_ra_ready_ind(void); +#endif + +EXTERN void rcv_ra_data_ind(T_RA_DATA_IND *ra_data_ind); + +/* + * RCV signal processing + */ +#ifdef OPTION_MULTITHREAD + #define sig_ker_rcv_rawdata_res _ENTITY_PREFIXED(sig_ker_rcv_rawdata_res) +#endif + +EXTERN void sig_ker_rcv_rawdata_res + ( + T_PDU_TYPE pduType, + T_BIT cBit, + T_BIT pFBit, + T_FRAME_NUM nr, + T_FRAME_NUM ns, + BOOL crc + ); + +/* + * RCV procedures + */ + +#ifdef OPTION_MULTITHREAD + #define rcv_init _ENTITY_PREFIXED(rcv_init) +#endif + +EXTERN void rcv_init(void); + +/* + * RLP SND + */ + +/* + * SND signal processing + */ +#ifdef OPTION_MULTITHREAD + #define sig_ker_snd_sabm_req _ENTITY_PREFIXED(sig_ker_snd_sabm_req) + #define sig_ker_snd_disc_req _ENTITY_PREFIXED(sig_ker_snd_disc_req) + #define sig_ker_snd_ua_req _ENTITY_PREFIXED(sig_ker_snd_ua_req) + #define sig_ker_snd_dm_req _ENTITY_PREFIXED(sig_ker_snd_dm_req) + #define sig_ker_snd_rr_req _ENTITY_PREFIXED(sig_ker_snd_rr_req) + #define sig_ker_snd_rnr_req _ENTITY_PREFIXED(sig_ker_snd_rnr_req) + #define sig_ker_snd_rej_req _ENTITY_PREFIXED(sig_ker_snd_rej_req) + #define sig_ker_snd_srej_req _ENTITY_PREFIXED(sig_ker_snd_srej_req) + #define sig_ker_snd_rr_i_req _ENTITY_PREFIXED(sig_ker_snd_rr_i_req) + #define sig_ker_snd_rnr_i_req _ENTITY_PREFIXED(sig_ker_snd_rnr_i_req) + #define sig_ker_snd_rej_i_req _ENTITY_PREFIXED(sig_ker_snd_rej_i_req) + #define sig_ker_snd_srej_i_req _ENTITY_PREFIXED(sig_ker_snd_srej_i_req) + #define sig_ker_snd_ui_req _ENTITY_PREFIXED(sig_ker_snd_ui_req) + #define sig_ker_snd_xid_req _ENTITY_PREFIXED(sig_ker_snd_xid_req) + #define sig_ker_snd_test_req _ENTITY_PREFIXED(sig_ker_snd_test_req) + #define sig_ker_snd_remap_req _ENTITY_PREFIXED(sig_ker_snd_remap_req) + #define sig_ker_snd_null_req _ENTITY_PREFIXED(sig_ker_snd_null_req) + + #define sig_ker_snd_set_frame_size_req _ENTITY_PREFIXED(sig_ker_snd_set_frame_size_req) +#endif + +EXTERN void sig_ker_snd_sabm_req (void); +EXTERN void sig_ker_snd_disc_req (T_BIT); +EXTERN void sig_ker_snd_ua_req (T_BIT); +EXTERN void sig_ker_snd_dm_req (T_BIT); + +#ifdef ENABLE_DTX +EXTERN void sig_ker_snd_rr_req (T_BIT, T_BIT, T_FRAME_NUM, T_BIT); +#else +EXTERN void sig_ker_snd_rr_req (T_BIT, T_BIT, T_FRAME_NUM); +#endif + +EXTERN void sig_ker_snd_rnr_req (T_BIT, T_BIT, T_FRAME_NUM, T_BIT); +EXTERN void sig_ker_snd_rej_req (T_BIT, T_BIT, T_FRAME_NUM); +EXTERN void sig_ker_snd_srej_req (T_BIT, T_BIT, T_FRAME_NUM); +EXTERN void sig_ker_snd_rr_i_req (T_BIT, T_BIT, T_FRAME_NUM, T_FRAME_NUM, T_FRAME_DESC *); +EXTERN void sig_ker_snd_rnr_i_req (T_BIT, T_BIT, T_FRAME_NUM, T_FRAME_NUM, T_FRAME_DESC *); +EXTERN void sig_ker_snd_rej_i_req (T_BIT, T_BIT, T_FRAME_NUM, T_FRAME_NUM, T_FRAME_DESC *); +EXTERN void sig_ker_snd_srej_i_req (T_BIT, T_BIT, T_FRAME_NUM, T_FRAME_NUM, T_FRAME_DESC *); +EXTERN void sig_ker_snd_ui_req (T_BIT, T_BIT, T_FRAME_DESC *); +EXTERN void sig_ker_snd_xid_req (T_BIT, T_BIT, T_FRAME_DESC *); +EXTERN void sig_ker_snd_test_req (T_BIT, T_BIT, T_FRAME_DESC *); +EXTERN void sig_ker_snd_remap_req (T_FRAME_DESC *); +EXTERN void sig_ker_snd_null_req (void); + +EXTERN void sig_ker_snd_set_frame_size_req (USHORT); + +/* + * SND procedures + */ + +#ifdef OPTION_MULTITHREAD + #define snd_init _ENTITY_PREFIXED(snd_init) + #define snd_send_u_frame _ENTITY_PREFIXED(snd_send_u_frame) + #define snd_send_s_frame _ENTITY_PREFIXED(snd_send_s_frame) + #define snd_send_si_frame _ENTITY_PREFIXED(snd_send_si_frame) +#endif + +EXTERN void snd_init(T_SND *snd); + +EXTERN void snd_send_u_frame + ( + T_UF frameType, + T_BIT pFBit, + T_BIT crBit, + T_FRAME_DESC *dataDesc + ); + +EXTERN void snd_send_s_frame + ( + T_SF frameType, + T_FRAME_NUM nr, + T_BIT pFBit, + T_BIT crBit, + T_FRAME_DESC *dataDesc + ); + +EXTERN void snd_send_si_frame + ( + T_SF frameType, + T_FRAME_NUM nr, + T_BIT pFBit, + T_FRAME_NUM ns, + T_BIT crBit, + T_FRAME_DESC *dataDesc + ); + +/* + * Send Buffer Management SBM + */ +#ifdef OPTION_MULTITHREAD + #define sbm_set_wind_size _ENTITY_PREFIXED(sbm_set_wind_size) + #define sbm_init _ENTITY_PREFIXED(sbm_init) + #define sbm_store_prim _ENTITY_PREFIXED(sbm_store_prim) + #define sbm_ack_upto_n _ENTITY_PREFIXED(sbm_ack_upto_n) + #define sbm_srej_frame _ENTITY_PREFIXED(sbm_srej_frame) + #define sbm_get_frame _ENTITY_PREFIXED(sbm_get_frame) + #define sbm_rej_from_n _ENTITY_PREFIXED(sbm_rej_from_n) + #define sbm_frame_in_range _ENTITY_PREFIXED(sbm_frame_in_range) + #define sbm_space_in_buf _ENTITY_PREFIXED(sbm_space_in_buf) + #define sbm_deinit _ENTITY_PREFIXED(sbm_deinit) + #define sbm_set_retrans _ENTITY_PREFIXED(sbm_set_retrans) + #define sbm_check_rej_count _ENTITY_PREFIXED(sbm_check_rej_count) + #define sbm_recall_prim _ENTITY_PREFIXED(sbm_recall_prim) +#endif + +EXTERN void sbm_set_wind_size + ( + T_SBM_BUFFER_INDEX windSize + ); + +EXTERN void sbm_init + ( + T_SBM_BUFFER_INDEX windSize, + USHORT frameSize, + UBYTE n2 + ); + +EXTERN void sbm_store_prim + ( + T_SBM_PRIM *sendPrim + ); + +EXTERN BOOL sbm_ack_upto_n + ( + T_SBM_BUFFER_EXTIDX + ); + +EXTERN void sbm_srej_frame + ( + T_SBM_BUFFER_INDEX n + ); + +EXTERN void sbm_get_frame + ( + T_FRAME_DESC *frameDesc, + T_SBM_BUFFER_INDEX *frameNo, + BOOL *framesCouldBeSent, + BOOL *ok + ); + +EXTERN void sbm_rej_from_n + ( + T_SBM_BUFFER_INDEX n, + BOOL *retransError + ); + +EXTERN BOOL sbm_frame_in_range + ( + T_SBM_BUFFER_INDEX n + ); + +EXTERN USHORT sbm_space_in_buf + ( + void + ); + +EXTERN void sbm_deinit + ( + void + ); + +EXTERN void sbm_set_retrans + ( + UBYTE n2 + ); + +EXTERN void sbm_check_rej_count + ( + BOOL *retransError + ); + +EXTERN BOOL sbm_recall_prim + ( + T_SBM_PRIM **sendPrim + ); + +EXTERN void sbm_reset_after_remap + ( + USHORT newFrameSize, + T_SBM_BUFFER_INDEX new_vs + ); + +/* + * Receive Buffer Management RBM + */ +#ifdef OPTION_MULTITHREAD + #define rbm_set_wind_size _ENTITY_PREFIXED(rbm_set_wind_size) + #define rbm_init _ENTITY_PREFIXED(rbm_init) + #define rbm_deinit _ENTITY_PREFIXED(rbm_deinit) + #define rbm_reset _ENTITY_PREFIXED(rbm_reset) + #define rbm_reset_srej_slots _ENTITY_PREFIXED(rbm_reset_srej_slots) + #define rbm_reset_all_r_states _ENTITY_PREFIXED(rbm_reset_all_r_states) + #define rbm_check_slots_srej _ENTITY_PREFIXED(rbm_check_slots_srej) + #define rbm_set_rslot_wait _ENTITY_PREFIXED(rbm_set_rslot_wait) + #define rbm_set_rslot_wait2srej _ENTITY_PREFIXED(rbm_set_rslot_wait2srej) + #define rbm_set_rslot_rcvd _ENTITY_PREFIXED(rbm_set_rslot_rcvd) + #define rbm_get_current_frame _ENTITY_PREFIXED(rbm_get_current_frame) + #define rbm_accept_current_frame _ENTITY_PREFIXED(rbm_accept_current_frame) + #define rbm_mark_missing_i_frames_srej _ENTITY_PREFIXED(rbm_mark_missing_i_frames_srej) + #define rbm_count_missing_i_frames _ENTITY_PREFIXED(rbm_count_missing_i_frames) + #define rbm_buffer_all_in_sequence_frames _ENTITY_PREFIXED(rbm_buffer_all_in_sequence_frames) + #define rbm_ns_check _ENTITY_PREFIXED(rbm_ns_check) + #define rbm_get_vr _ENTITY_PREFIXED(rbm_get_vr) + #define rbm_get_prim _ENTITY_PREFIXED(rbm_get_prim) + #define rbm_get_curr_prim _ENTITY_PREFIXED(rbm_get_curr_prim) + #define rbm_move_current_frame _ENTITY_PREFIXED(rbm_move_current_frame) + #define rbm_is_state_wait _ENTITY_PREFIXED(rbm_is_state_wait) + #define rbm_prepare_remap _ENTITY_PREFIXED(rbm_prepare_remap) + +#ifdef _SIMULATION_ + #define rbm_store_frame _ENTITY_PREFIXED(rbm_store_frame) +#endif +#endif + +EXTERN BOOL rbm_set_wind_size + ( + T_RBM_BUFFER_INDEX windSize + ); + +EXTERN void rbm_init + ( + T_RBM_BUFFER_INDEX windSize, + USHORT frameSize, + USHORT framesPerPrim + ); + +EXTERN void rbm_deinit + ( + void + ); + +EXTERN void rbm_reset(T_RBM *rbm); + +EXTERN void rbm_reset_srej_slots + ( + void + ); + +EXTERN void rbm_reset_all_r_states + ( + void + ); + +EXTERN T_RBM_BUFFER_EXTIDX rbm_check_slots_srej + ( + void + ); + +EXTERN void rbm_set_rslot_wait + ( + T_RBM_BUFFER_INDEX slot + ); + +EXTERN void rbm_set_rslot_wait2srej + ( + T_RBM_BUFFER_INDEX slot + ); + +EXTERN void rbm_set_rslot_rcvd + ( + T_RBM_BUFFER_INDEX slot, + BOOL *resetTimer + ); + +EXTERN T_RBM_FRAMEPTR rbm_get_current_frame + ( + void + ); + +EXTERN void rbm_accept_current_frame + ( + void + ); + +EXTERN void rbm_mark_missing_i_frames_srej + ( + T_RBM_BUFFER_INDEX ns + ); + +EXTERN void rbm_count_missing_i_frames + ( + T_RBM_BUFFER_INDEX ns, + T_RBM_BUFFER_INDEX *count + ); + +EXTERN void rbm_buffer_all_in_sequence_frames + ( + T_RBM_BUFFER_INDEX fromSlot, + BOOL *primIsReady, + BOOL *rcvReady, + BOOL *rcvFull + ); + +EXTERN void rbm_ns_check + ( + T_RBM_BUFFER_INDEX ns, + BOOL *valid, + BOOL *expected + ); + +EXTERN T_RBM_BUFFER_INDEX rbm_get_vr + ( + void + ); + +EXTERN BOOL rbm_get_prim + ( + T_RBM_PRIM **prim, + BOOL *rcvReady, + BOOL *rcvFull + ); + +EXTERN T_RBM_PRIM *rbm_get_curr_prim + ( + void + ); + +EXTERN void rbm_move_current_frame + ( + T_RBM_BUFFER_INDEX slot + ); + +EXTERN BOOL rbm_is_state_wait + ( + T_RBM_BUFFER_INDEX slot + ); + +EXTERN T_FRAME_NUM rbm_prepare_remap + ( + USHORT frameSize + ); + +#ifdef _SIMULATION_ +EXTERN void rbm_store_frame(T_RBM_FRAMEPTR frame); +#endif + +/* + * SREJ Timer Management SRM + */ +#ifdef OPTION_MULTITHREAD + #define srm_init _ENTITY_PREFIXED(srm_init) + #define srm_deinit _ENTITY_PREFIXED(srm_deinit) + #define srm_reset _ENTITY_PREFIXED(srm_reset) + #define srm_clear _ENTITY_PREFIXED(srm_clear) + #define srm_count _ENTITY_PREFIXED(srm_count) + #define srm_get_counter _ENTITY_PREFIXED(srm_get_counter) +#endif + +EXTERN void srm_init + ( + void + ); + +EXTERN void srm_deinit + ( + void + ); + +EXTERN void srm_reset + ( + void + ); + +EXTERN void srm_clear + ( + T_FRAME_NUM n + ); + +EXTERN void srm_count + ( + T_FRAME_NUM n + ); + +EXTERN T_COUNTER srm_get_counter + ( + T_FRAME_NUM n + ); + +/* + * timer + */ +#define TIMERSTART(i,v) vsi_t_start(VSI_CALLER i,v); +#define TIMERSTOP(i) vsi_t_stop(VSI_CALLER i); + /* + * time + * xid parameters are given in 10^2 s, we store in 10^3 s (ms) + */ +#define TIME_INT2EXT(t) ((t) / 10) +#define TIME_EXT2INT(t) ((t) * 10) + +/* + * Communication handles + */ +#ifdef OPTION_MULTITHREAD + #define hCommL2R _ENTITY_PREFIXED(hCommL2R) +#ifdef _SIMULATION_ + #define hCommRA _ENTITY_PREFIXED(hCommRA) +#endif +#endif + +#ifdef RLP_PEI_C + +GLOBAL T_HANDLE rlp_handle; +GLOBAL T_HANDLE hCommL2R = VSI_ERROR; /* L2R Communication */ + +#ifdef _SIMULATION_ +GLOBAL T_HANDLE hCommRA = VSI_ERROR; /* RA Communication */ +#endif + +#else +EXTERN T_HANDLE rlp_handle; +EXTERN T_HANDLE hCommL2R; /* L2R Communication */ + +#ifdef _SIMULATION_ +EXTERN T_HANDLE hCommRA; /* RA Communication */ +#endif + +#endif + +GLOBAL void rlp_exec_timeout (USHORT index); + +#ifdef _SIMULATION_ + +#define HEX_BYTE(B,H) { UBYTE b, *a = (UBYTE*)H;\ + b = (((UBYTE)B) >> 4) & 0x0F;\ + if (b > 9) b += 'A'-10; else b += '0'; *a = b;\ + b = ((UBYTE)B) & 0x0F;\ + if (b > 9) b += 'A'-10; else b += '0'; *(a+1) = b;} + +#endif + +#if defined (TRACE_INTERPRETED_RLP_FRAME) || defined (TRACE_RLP_FRAME) + +#define DEC_BYTE(B,A) {UBYTE b, rep, *a = ((UBYTE*)A)+2; b = (UBYTE) B;\ + for (rep=0;rep<3;rep++) {*a = (b%10) + '0'; b /= 10; a--;}} + +#endif + +#endif