FreeCalypso > hg > fc-magnetite
diff src/g23m-gprs/grlc/grlc.h @ 183:219afcfc6250
src/g23m-gprs: initial import from TCS3.2/LoCosto
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Thu, 13 Oct 2016 04:24:13 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-gprs/grlc/grlc.h Thu Oct 13 04:24:13 2016 +0000 @@ -0,0 +1,1247 @@ +/* ++----------------------------------------------------------------------------- +| Project : GPRS (8441) +| Modul : GRLC ++----------------------------------------------------------------------------- +| 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 entity GRLC. ++----------------------------------------------------------------------------- +*/ + +#ifndef GRLC_H +#define GRLC_H + +/* + * defines the user of the vsi interface + */ +#define VSI_CALLER GRLC_handle, +#define VSI_CALLER_SINGLE GRLC_handle + +/* + * Macros + */ + +#define ENCODE_OFFSET 0 /* PALLOC SDU*/ + +/* + * Bit and byte length for encoding/decoding + */ + +#define BIT_UL_CTRL_BLOCK_MAC_HEADER 8 +#define BIT_UL_CTRL_BLOCK_CONTENTS 176 +#define BIT_UL_CTRL_BLOCK (BIT_UL_CTRL_BLOCK_MAC_HEADER+BIT_UL_CTRL_BLOCK_CONTENTS) + +#define BYTE_UL_CTRL_BLOCK (BIT_UL_CTRL_BLOCK/BITS_PER_BYTE) + + +/* + * The following definitions are used for the management of single block + * sending without TBF establishment. + * + * TC holds a queue of size MSG_OWNER_MAX_NUM to buffer the single blocks + * requested by the services. Only services MEAS and CS can request single + * blocks in parallel. In case service CTRL has requested a single block, + * services MEAS and CS are not allowed to request any single blocks. + * + * Service CS uses the same buffer as the service CTRL. Only one single block + * can be stored for both services. The service MEAS has an individual buffer. + * At this time only one single block can be stored for this service but we are + * free to increase the size just by increasing the value of MAX_CTRL_BLK_NUM. + */ +#define MAX_CTRL_BLK_NUM 5 /* number of single blocks that can be stored at */ + /* the same time */ + +#define BLK_INDEX_CTRL 0 /* Packet Cell Change Failure */ +#define BLK_INDEX_CS 0 /* Packet Measurement Report (NC Measurements) */ +#define BLK_INDEX_TM 1 /* Packet Resource Request (Reallocation) */ +#define BLK_INDEX_MEAS 2 /* Packet Measurement Report (EXT Measurements) */ + + +typedef UBYTE T_BLK_OWNER; + +#define BLK_STATE_NONE 0 /* no control message associated */ +#define BLK_STATE_ALLOCATED 1 /* control message is allocated */ +#define BLK_STATE_SENT_REQ 2 /* control message is sent, waiting for response */ + +typedef UBYTE T_BLK_STATE; + +/* + * Constants + */ + +/* + * Disable Get State traces only for target enviroment + */ + +#ifdef _TARGET_ +#undef GET_STATE +#define GET_STATE(P) (ENTITY_DATA->P state) +#endif + + +/* + * Define the size of the GRLC queue in frame + */ +#define PEI_PRIM_QUEUE_SIZE 32 + +/* + * Defines the size of the queue which do a tempory save of llc primitives + */ + +#ifdef _TARGET_ +#define PRIM_QUEUE_SIZE 20 +#else +#define PRIM_QUEUE_SIZE 10 +#endif/*TARGET*/ + + +#define GMM_PRIM_QUEUE_SIZE 2 +#define MAX_WINDOW_SIZE 64 + + +#define PRIM_QUEUE_SIZE_TOTAL (PRIM_QUEUE_SIZE+GMM_PRIM_QUEUE_SIZE) + +#define MAX_LLC_PDU_SIZE 1560 +#define MAX_GRLC_USER_DATA (MAX_WINDOW_SIZE * 50) /* window size * user data with CS4 */ +#define FN_MAX 0x297000 + +/* MAC HEADER TYPE*/ +#define RLC_DATA_BLOCK 0 +#define CTRL_BLK_NO_OPT 1 +#define CTRL_BLK_OPT 2 + +/* + * Size of Next Poll Array + */ +#define NEXT_POLL_ARRAY_SIZE 8 +#define WIN_SIZE 64 /*window size of rlc*/ +/* + * Size of Poll Type Array + */ +#define POLL_TYPE_ARRAY_SIZE 8 + + + + +/* +TBF BSN RANGE +*/ +#define NR_OF_PDUS_PER_RLCMAC_BLOCK 8 /* max. number of pdus in one rlc mac block */ +#define TLLI_SIZE 4 /* tlli size in UBYTE */ + +#define WIN_MOD 63 +#define BSN_MAX 127 + +#define RD_LI_CNT_MAX 8 /* max. number of pdus in one rlc mac block in downlink direction*/ + + +#define OFFSET_CTRL_BLOCK_IDX 200 + +/* +end constants for RU +*/ +#define MAX_UL_TN 4 /* max. number of timeslots supported in uplink */ + +/* +start constants for RD +*/ + + +#define RD_NEXT_ARRAY_DATA_SIZE 50 /* valid for all coding schemes */ + +#define ACK_CNT_MEAS_RPT_FIRST 2 +#define ACK_CNT_NORMAL 1 + +/* +end constants for RD +*/ + +/* +start constants for TM +*/ +#define RADIO_PRIO_4 3 + +/* +end constants for TM +*/ + +/* +start constants for TPC +*/ +#define MIN_PCL_DCS1800 28 /* minimum power control level DCS 1800 */ +#define MAX_PCL_DCS1800 29 /* maximum power control level DCS 1800 */ +#define MIN_PCL_GSM900 31 /* minimum power control level GSM 900 */ +#define MAX_PCL_GSM900 0 /* maximum power control level GSM 900 */ +#define MIN_PCL_PCS1900 21 /* minimum power control level PCS 1900 */ +#define MAX_PCL_PCS1900 22 /* maximum power control level PCS 1900 */ + +#define GAMMA_0_DCS1800 36 +#define GAMMA_0_GSM900 39 +#define GAMMA_0_PCS1900 36 + +#define TPC_SWITCHED_ON 0xFF /* normal TPC process is applied */ +#define TPC_ALFGAM_NOT_PRESENT 0xFF /* the ALPHA and GAMMA values are */ + /* marked as not present */ + +#define CLIP_T_AVG(x) ( (x) > 25 ? 25 : (x) ) +#define CLIP_ALPHA(x) ( (x) > 10 ? 10 : (x) ) +#define CLIP_BS_PAG_BLKS_RES(x) ( (x) > 12 ? 0 : (x) ) +#define CLIP_BS_PRACH_BLKS(x) ( (x) > 12 ? 0 : (x) ) + +#define M_TPC_TRACE_STATIC 0x01 /* trace TPC parameter everytime tpc_update_pch is called */ +#define M_TPC_TRACE_CHANGE 0x02 /* trace TPC parameter only in case at least one PCL changes */ +#define M_TPC_TRACE_FUNCTION 0x04 /* trace mask for parameters of maca_power_control */ +/* +end constants for TPC +*/ + +/* +start constants for MEAS +*/ +#define MEAS_ACRCY 1000 /* accuracy */ +/* +end constants for MEAS +*/ + + +#define NOT_SET 255 + +/* + * Service definitions. Used to access service data with GET/SET_STATE. + */ + + +#define TM tm. +#define RD rd. +#define RU ru. +#define GFF gff. + + + + +/* + * Timer definitions (also used by GRLC_PEI.C) + */ + +typedef enum +{ + T3164 = 0, /* handled by service RU */ + T3166, /* handled by service RU */ + T3168, /* handled by service TM */ + T3180, /* handled by service RU */ + T3182, /* handled by service RU */ + T3184, /* handled by service RU */ + T3188, /* handled by service TM */ + T3190, /* handled by service RD */ + T3192, /* handled by service RD */ + T3314, /* handled by service RU */ + + TIMER_COUNT /* !!! always the last entry !!! */ + +} T_TIMER_INDEX; + +/*#define T3198 no timer */ /* handled by service RU: used relative to fn, defined in T_RLC_DATA_BLOCK: T3198 = BS_CV_MAX * block periods: not timer is used */ + + +#define T3164_VALUE 5000 /* ms */ +#define T3166_VALUE 5000 /* ms */ +/* T3168_VALUE - assigned in system info (in GPRS Cell Options) + range 500,1000,...4000ms */ +#define T3180_VALUE 5000 /* ms */ +#define T3182_VALUE 5000 /* ms */ +#define T3184_VALUE 5000 /* ms */ +#define T3188_VALUE 5000 /* ms */ +#define T3190_VALUE 5000 /* ms */ + +/*#define T3192_VALUE - assigned in system info (in GPRS Cell Options) + range 500,1000,...4000ms */ +/* T3198_VALUE - value depends BS_CV_MAX, there may be some inctances of this timer, + how many? the duration is not very long (asumption) - how long? + handling with rlc_uplink/downlink functions and a table? */ + +/* + * Service name definitions for trace purposes. The service abbrevation + * (e.g. RU) has to be the same as above for the service definitions. + */ +#ifndef NTRACE + +#define SERVICE_NAME_TM "TM" +#define SERVICE_NAME_RU "RU" +#define SERVICE_NAME_RD "RD" +#define SERVICE_NAME_GFF "GFF" + + +#endif /* !NTRACE */ + + + +/* + * Service TM + */ +#define TM_ACCESS_DISABLED 0 +#define TM_ACCESS_PREPARED 1 +#define TM_PIM 2 +#define TM_PAM 3 +#define TM_PTM 4 +#define TM_WAIT_4_PIM 5 + +/* + * Service RD + */ + +#define RD_NULL 0 +#define RD_ACK 1 +#define RD_REL_ACK 2 +#define RD_UACK 3 +#define RD_REL_UACK 4 +#define RD_NET_REL 5 +#define RD_WAIT_FOR_STARTING_TIME_ACK 6 +#define RD_WAIT_FOR_STARTING_TIME_UACK 7 +#define RU_NET_REL 8 + +/* + * Service RU + */ + +#define RU_NULL 0 /* not active state of RU */ +#define RU_ACK 1 /* acknowledged mode state of RU */ +#define RU_REL_ACK 2 /* release state in acknowledged mode of RU, i.e. cv=0 is transmitted but not acked */ +#define RU_SEND_PCA 3 /* send packet control acknowledgment state of RU in acknowledged and unacknowledged mode, +i.e all blocks are transmitted and acked, waiting for of FN for transmiitng the packet control ack message */ +#define RU_UACK 4 /* unacknowledged mode state of RU */ +#define RU_REL_UACK 5 /* release state in unacknowledged mode of RU, i.e. cv=0 is transmitted but not acked + (i.e receiving of packet uplink ack/nack with fbi=1) */ +#define RU_WAIT_FOR_FIRST_CALL_ACK 6 +#define RU_WAIT_FOR_FIRST_CALL_UACK 7 + +/* + * Service GFF + */ + + +#define GFF_ACTIVE 0 +#define GFF_DEACTIVE 1 +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH +#define GFF_TWO_PHASE 2 +#endif + + +/* + * states for grlc_data->tc.send_grlc_ready_ind + */ +#define SEND_A_GRLC_READY_IND 0 +#define WAIT_FOR_LLC_DATA_REQ 1 +#define PRIM_QUEUE_FULL 2 + +/* + * states for Ready Timer + */ +#define STANDBY_STATE 0 +#define READY_STATE 1 + +typedef UBYTE T_READY_TIMER_STATE; + +#define READY_TIMER_HANDLING_DISABLED 0 +#define READY_TIMER_HANDLING_ENABLED 1 + +typedef UBYTE T_READY_TIMER_HANDLING; + +/*==== TYPES ======================================================*/ + +/* + * GRLC global typedefs + */ + +/* enums */ + +typedef UBYTE T_PRIM_TYPE; + + +typedef enum +{ + CS_ZERO = 255, + CS_1 = 0, + CS_2 = 1, + CS_3 = 2, + CS_4 = 3 +} T_CODING_SCHEME; + + + +typedef enum +{ + TFI_CHANGE_NULL, /* no tfi modification needed after starting time is elapsed */ + TFI_CHANGE_UL, /* uplink tfi shall modified after starting time is elapsed */ + TFI_CHANGE_DL, /* downlink tfi shall modified after starting time is elapsed */ + TFI_CHANGE_ALL /* uplink and downlink tfi shall modified after starting time is elapsed */ +} T_TFI_CHANGE; + +typedef enum +{ + TBF_TYPE_NULL, +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + TBF_TYPE_TP_ACCESS, +#endif + TBF_TYPE_UL, + TBF_TYPE_DL, + TBF_TYPE_CONC +} T_TBF_TYPE; + +/* + * Please keep the numbering scheme, so that bit operations can be used. + */ +#define REL_TYPE_NULL 0 /* no release of TBF requested */ +#define REL_TYPE_DL 1 /* release of DL TBF requested */ +#define REL_TYPE_UL 2 /* release of UL TBF requested */ +#define REL_TYPE_DL_UL 3 /* release of DL and UL TBF requested */ + +typedef UBYTE T_REL_TYPE; + + + + +/*start enum for rd*/ +typedef enum /* T_NEXT_POLL_BLOCK_TYPE*/ +{ + NEXT_POLL_BLOCK_NONE, + NEXT_POLL_BLOCK_DL_DATA, + NEXT_POLL_BLOCK_CTRL +}T_NEXT_POLL_BLOCK_TYPE; + +/* + * used by rd : vn array (enum is using ulong) + */ +#define VN_RECEIVED 1 +#define VN_INVALID 255 + +/*start enum for ru*/ +typedef enum /* T_PAN_CNT*/ +{ + PAN_INC, + PAN_DEC +}T_PAN_CNT; + +#define VB_NACKED 0 /* negative acknowledged */ +#define VB_ACKED 1 /* positive acknowledged */ +#define VB_PENDING_ACK 2 /* not jet acknowledged */ +#define VB_FIRST_SEG_TXD 3 +#define VB_INVALID 255 /* outside window */ + + +typedef enum /* T_LAST_BSN*/ +{ + LAST_BSN_IS_SENT, /* final uplink data block(cv=0) is sent(confirmed by l1)*/ + LAST_BSN_STALL_CONDITION, /* stall indication in uplink, ack or uack mode */ + LAST_BSN_RESUME_UACK_MODE_AFTER_SI, /* in rlc uack, data transfer is allowed after SI */ + LAST_BSN_NOT_BULIT =255 /* final data block is not sent */ +}T_LAST_BSN; + +/*end um for ru*/ + +/*start enum for GFF*/ + +typedef enum /* RLC_STATUS_TYPE*/ +{ + RLC_STATUS_NULL = 0, + RLC_STATUS_UL = 1, + RLC_STATUS_DL = 2, + RLC_STATUS_BOTH = 3 +}T_RLC_STATUS_TYPE; +/*end um for GFF*/ + + +/* + * Structure + */ + +typedef enum /* T_FA_TYPE*/ +{ + FA_NO_CURRENT, + FA_NO_NEXT, + FA_BITMAP, + FA_REPEAT +}T_FA_TYPE; + +typedef struct /* parameterts of one fixed alloction*/ +{ + T_CGRLC_fix_alloc_struct alloc; + USHORT ul_res_sum; /* number of uplink resources during this fixed allocation*/ + ULONG alloc_start_fn; + ULONG alloc_end_fn; +} T_FA_ALLOC; + + +typedef struct /* T_FA_MANAG*/ +{ + T_FA_TYPE fa_type; + T_FA_ALLOC current_alloc; + T_FA_ALLOC next_alloc; + BOOL repeat_alloc; + USHORT tbf_oct_cnt; /* number of octets, to be transmitted during the current tbf*/ + USHORT tbf_oct_cap_remain; /* remainig capacity in octetes of current fix allocation*/ + USHORT ul_res_used; /* number of used uplink resources(timeslots) used in fixed allocation*/ + USHORT ul_res_remain; /* number of REMAINING uplink resources(timeslots) in fixed allocation*/ + USHORT ul_res_sum; /* number of total uplink resources in fix alloc mode during one tbf*/ +} T_FA_MANAG; + + + + +typedef struct /* T_UL_TBF */ +{ + ULONG tlli; /* tlli that is valid for activ TBF */ + UBYTE access_type; /* access type of the current tbf*/ + UBYTE mac_mode; + UBYTE rlc_mode; /* is estimated in tc_start_access */ + T_CODING_SCHEME cs_type; + UBYTE ti; /* =1 tlli field present in data block, else not present*/ + BOOL tlli_cs_type; /* coding scheme for rlc data blocks including TLLI*/ + UBYTE prio; /* Radio Prioritity from grlc_data_req or + grlc_unitdata_req; should be set in tm_start_access */ + UBYTE ac_class; /* access class and radio priority of the network */ + UBYTE nr_blocks; /* set in ts_start_access; CS_1 is used */ + /* 4 Access Burst or RLCMAC-Block, + maybe storing is not necessary*/ + UBYTE nts; /* number of timeslots allocated for tbf */ + UBYTE ts_mask; /* timeslot mask */ + UBYTE bs_cv_max; + USHORT rlc_db_granted; /* indicates if close ended or open ended tbf is used */ + + T_FA_MANAG fa_manag; /* contains all fixed alloction parameters*/ +} T_UL_TBF; + + +typedef struct /* T_DL_TBF */ +{ + ULONG tlli; /* tlli that is valid for activ TBF */ + UBYTE mac_mode; + UBYTE rlc_mode; /* is estimated in tc_start_access */ + T_CODING_SCHEME cs_type; + UBYTE nts; /* number of timeslots allocated for tbf */ + UBYTE ts_mask; /* timeslot mask */ + UBYTE t3192_val; + UBYTE trans_id; /* transaction id */ +} T_DL_TBF; + + +typedef struct /* T_TBF_CTRL */ +{ + T_TBF_TYPE tbf_type; + ULONG start_fn; + ULONG end_fn; + ULONG rlc_oct_cnt; + UBYTE pdu_cnt; + UBYTE vs_vr; + UBYTE va_vq; + USHORT cnt_ts; + UBYTE tfi; + UBYTE ack_cnt; + UBYTE fbi; + UBYTE ret_bsn; +} T_TBF_CTRL; + + + + +typedef struct /* T_PRIM_QUEUE */ +{ + UBYTE next; /* index of following entry; 0xff if no primitive follows */ + UBYTE previous; /* index of previous entry; 0xff first primitive */ + T_GRLC_DATA_REQ * prim_ptr; /* pointer to primitive */ + T_PRIM_TYPE prim_type; /* GRLC_UNITDATAreq or GRLC_DATAreq*/ + BOOL cv_status; /* is set if pdu is included in the count down procedure */ + BOOL rlc_status; /* is set if transmission of the pdu has started*/ + BOOL re_allocation;/* in front of this pdu is a reallocation necessary */ + BOOL start_new_tbf;/* marks the first llc of a new tbf*/ + UBYTE last_bsn; /* indicates the last bsn of th rlc data block, which belongs to the pdu */ +} T_PRIM_QUEUE; + + + +typedef struct /* T_NEXT_POLL_ARRAY */ +{ + UBYTE cnt; + UBYTE next; + UBYTE ctrl_ack; + ULONG fn; + UBYTE poll_type[POLL_TYPE_ARRAY_SIZE]; +}T_NEXT_POLL_ARRAY; + +typedef struct /* T_TM_B_DATA : used in Testmode B */ +{ + USHORT block_status; /* stores the block_status received on downlink */ + UBYTE e_bit; /* stores the e_bit received on downlink */ + UBYTE payload[50]; /* stores the payload received on downlink */ +}T_TM_B_DATA; + +typedef struct /* T_TESTMODE "test mode" */ +{ + UBYTE mode; /* test mode, where + * 0x00 means no test mode + * 0x01 means type A + * 0x02 means type B + */ + ULONG n_pdu; /* number of PDUs which are to be transmitted */ + UBYTE dl_ts_offset; /* Downlink Timeslot Offset, only for CGRLC_LOOP */ + USHORT prbs_shift_reg; /* pseudo random bit sequence(prbs) + * shift register + */ + UBYTE * ptr_test_data; /* + * reference to data which are callaculated for + * the current framenumber. All slots related to the same + * frame number have to have the same data. + */ + UBYTE no_data_calculation; /* + * Is set when the prbs for the current + * frame number is already calculated + */ + T_TM_B_DATA rec_data[2]; /* for Testmode B: received data is stored. Only 2 timeslots + * are supported. The data will be stored sequentialy depending upon + * Downlink Timeslot Offset value + */ +} T_TESTMODE; + + + + + + + +typedef struct /* saves all downlink data blocks*/ +{ + USHORT rx_no; + T_dl_data dl_data[MAC_MAX_DL_DATA_BLCKS]; +} T_dl_struct; + + + +typedef struct /* saves struct of downlink data blocks*/ +{ + T_dl_struct data_ptr; + ULONG fn; +} T_FUNC_DL_BLOCKS; + + +typedef struct /* functional interface: RLC_UPLINK, RLC_DOWNLINK, MACA_POWER_CONTROL */ +{ + T_FUNC_DL_BLOCKS dl_blocks; + T_MAC_DATA_IND mac_data_ind; + T_MAC_READY_IND mac_ready_ind; + T_MAC_PWR_CTRL_IND mac_pwr_ctrl_ind; +} T_FUNC_INTERFACE; + + + + + +/* structure for service internal data */ + + + + + +/*start of structs for RU*/ + + +typedef struct +{ + U8 mac; /*< mac header */ + U8 ti; /*< TLLI Indicator (TI) bit */ + U8 e_bit; /*< Extended bit */ + U8 li_cnt; /*< Number of LIs */ + U8 li_me[NR_OF_PDUS_PER_RLCMAC_BLOCK]; /*< LI, M and e-Bit */ +} T_U_DATA; + + +typedef struct /* T_RLC_DATA*/ +{ + T_sdu * ptr_data; + USHORT l_buf; + USHORT o_buf; +} T_RLC_DATA; + +typedef struct /* T_RLC_DATA_BLOCK*/ +{ + USHORT block_status; + T_U_DATA header; /*stores the header of the rlc data block*/ + UBYTE data_cnt; /*number of pdus in the rlc data block*/ + T_RLC_DATA data[NR_OF_PDUS_PER_RLCMAC_BLOCK]; /*stores the pointers of the sdus*/ + ULONG T3198; /*timer T3198, value= BS_CV_MAX block periods*/ + UBYTE cnt_pl_trans; /* counts the number of transmissions over physical link*/ +} T_RLC_DATA_BLOCK; + +typedef struct /* T_PL_RETRANS*/ +{ + UBYTE cnt; /* number of transmitted rlc/mac blocks */ + UBYTE blk[MAX_UL_TN]; /* stores the bsn(data block) or ctrl block nr */ +} T_PL_RETRANS; + + + +/*end of structs for RU*/ + +/*start of structs for RD*/ + + + + +typedef struct /*T_NEXT_ARRAY*/ +{ + ULONG * next; /*zeig auf next struct vom typ T_NEXT_ARRAY*/ + USHORT len; + UBYTE data[RD_NEXT_ARRAY_DATA_SIZE]; +} T_NEXT_ARRAY; + +typedef struct /* T_DATA_ARRAY */ /*for received data blocks*/ +{ + BOOL pdu_complete; /* indicates if the last part of the data block is a complete pdu*/ + UBYTE pdu_cnt; /* nr of complete pdus in the current data block*/ + T_NEXT_ARRAY * first; /* indicates the first element(first next_array) of the pdu */ +} T_DATA_ARRAY; + + +/*end of structs for RD*/ + + + +/*start of structs for GFF*/ + + + + +typedef struct /* T_RLC_VALUES*/ +{ + USHORT sdu_len; + USHORT cnt_ts; +} T_RLC_VALUES; + + +/*end of structs for GFF*/ + + + +/* data base for control messages */ +typedef struct /* T_UL_CTRL_BLOCK */ +{ + T_BLK_OWNER owner; + T_BLK_STATE state; + UBYTE data[BYTE_UL_CTRL_BLOCK]; +} T_UL_CTRL_BLOCK; + +typedef UBYTE T_BLK_INDEX; + + + +typedef struct /* T_UL_CTRL_BLOCK_ARRAY */ +{ + T_UL_CTRL_BLOCK blk[MAX_CTRL_BLK_NUM]; + T_BLK_INDEX seq[MAX_CTRL_BLK_NUM]; +} T_UL_CTRL_BLOCK_ARRAY; + + +typedef struct +{ + USHORT l_buf; + USHORT o_buf; + UBYTE buf [2 * BYTE_UL_CTRL_BLOCK]; + /* CAN's suggestion never more then 2 blocks */ + /* or 8 blocks? ID's suggestion 'B_SIZE_D_PAGING_REQ\8+1' */ + +} T_CTRLBUF; + + + +typedef struct /* T_TM_DATA */ +{ + UBYTE state; + UBYTE disable_class; /* tm_grlc_init sets it to CR, updated with cgrlc_disable_req*/ + UBYTE n_res_req; /* number of sended packet resource request */ + UBYTE n_acc_req_procedures; /* number of started access procedures */ + T_UL_CTRL_BLOCK_ARRAY ul_ctrl_blk; /* holds all relevant information for */ + /* sending uplink control blocks */ + + UBYTE start_of_new_tbf; /* index where the new TBF starts + 0xff means not used */ + BOOL send_grlc_ready_ind; /* GRLC_READY_IND have to be sent if this variable is TRUE + when a internal signal sig_ru_tm_prim_delete + was received by TM. */ + UBYTE change_mark; /* received from GRR, needed for sending in packet resource request*/ +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + BOOL pacch_prr_pca_sent; /* Use during release , Prr,pca was sent */ +#endif + + T_CGRLC_freq_param freq_param; /* frequency parameter of the current TBF */ + + USHORT max_grlc_user_data; /* maximum nr of byte which can be stored in uplink in the LLC data queue*/ + +#ifndef NTRACE + char *name; + char *state_name; +#endif +} T_TM_DATA; + +typedef struct /* T_ACK_CTRL */ +{ + UBYTE cnt_meas_rpt; + UBYTE cnt_other; +} T_ACK_CTRL; + +typedef struct /* T_RD_DATA */ +{ + /*UBYTE*/ + UBYTE state; + UBYTE vq; + UBYTE vr; + UBYTE li_cnt; + UBYTE rlc_data_len; + UBYTE f_ack_ind; + UBYTE ssn; + UBYTE last_bsn; + UBYTE bsn_pdu_start; + UBYTE cnt_sent_f_ack; /* counts number of sent final downlink ack nacks*/ + + /*USHORT*/ + USHORT pdu_len; + /*ULONG*/ + ULONG fn_p_tbf_rel; + /*POINTER*/ + /*BOOL*/ + BOOL ch_req_in_ack_prog; /*indicates weather the channel request is programmed in the last packet downlink ack/nack or not*/ + BOOL channel_req; /*indicates weather the channel request is sent in packet downlink ack/naok or not*/ + BOOL pdu_complete; + BOOL inSequence; + BOOL release_tbf; + BOOL v_next_tbf_params; /* indicates if next_tbf_params is valid or not*/ + BOOL ignore_pdu; /* if true pdu shall be ignored, max_pdu_size reached and until next pdu bound every thing is discarded */ + + /*Type*/ + UBYTE rlc_mode; + T_DATA_ARRAY data_array[WIN_SIZE]; + T_NEXT_ARRAY *ptr_grlc; + T_GRLC_DATA_IND grlc_data_ind; + T_NEXT_POLL_BLOCK_TYPE next_poll_block; + T_CODING_SCHEME cs_type; + T_DL_TBF next_tbf_params; /* stores downlink parameters in case of tbf starting time*/ + + /*array*/ + UBYTE vn[WIN_SIZE]; + USHORT li[RD_LI_CNT_MAX]; + UBYTE m[RD_LI_CNT_MAX]; + T_ACK_CTRL ack_ctrl; + +#ifndef NTRACE + char *name; + char *state_name; +#endif +} T_RD_DATA; + +typedef struct /* T_RU_DATA */ +{ + /*DECLARATIONS*/ + /*UBYTE*/ + UBYTE state; + UBYTE nts; + UBYTE nts_max; + UBYTE ti; + UBYTE next_prim; + UBYTE active_prim; + UBYTE vs; + UBYTE va; + UBYTE bsn_ret; + UBYTE last_si_block; + UBYTE cv; + UBYTE N3104; + UBYTE N3104_MAX; + UBYTE count_cv_0; + UBYTE nr_nacked_blks; /*number of negative acked blocks*/ + UBYTE pdu_cnt; /* nr of pdus per tbf*/ + UBYTE pdu_sent; /* nr of sent pdus per tbf, but stil not acknowlegded*/ + UBYTE pdu_rem; /* nr of remaining pdus per tbf*/ + UBYTE pdu_boundaries; /*nr of need boundaries*/ + /*USHORT*/ + USHORT block_status; + USHORT poll_tn; + USHORT rlc_data_size; + USHORT sdu_len; + USHORT sdu_off; + USHORT rlc_octet_cnt; + USHORT tbc; /*number of rlc data blocks during the tbf, which is requested to send*/ + USHORT cnt_ts; + /*ULONG*/ + ULONG poll_fn; + /*BOOL*/ + BOOL tlli_cs_type; + BOOL cd_active; /*indicates if the countdown procedure is active*/ + BOOL reorg_l1_needed; /* set to true if data blocks in l1 queue must be recalculated*/ + BOOL v_next_tbf_params; /* indicates if next_tbf_params is valid or not*/ + BOOL first_usf; /* true: wait for the first valid usf. FALSE: first usf was read*/ + /*Type*/ + UBYTE rlc_mode; + T_CODING_SCHEME cs_type; + T_PL_RETRANS pl_retrans_current; /*status of current block, requested blocks to be send by PL*/ + T_LAST_BSN last_bsn; /* needed for starting timer t3182 */ + /*array*/ + T_RLC_DATA_BLOCK rlc_data[WIN_SIZE]; /*contains the rlc data block, including header and pointer to the data*/ + UBYTE vb[WIN_SIZE]; + T_UL_TBF next_tbf_params; /* stores uplink parameters in case of tbf starting time*/ + + + UBYTE write_pos_index; + T_ul_data ul_data[MAX_UL_TN]; + BOOL release_tbf; +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + BOOL tbf_re_est; /*TBF Re-establish on PACCH*/ +#endif + +#ifndef NTRACE + char *name; + char *state_name; +#endif +} T_RU_DATA; + + + + +typedef struct /* T_GFF_DATA */ +{ + UBYTE state; + T_RLC_STATUS_TYPE rlc_status; + +#ifndef NTRACE + char *name; + char *state_name; +#endif +} T_GFF_DATA; + +typedef ULONG T_SIGN_VAR_VALUE; +typedef USHORT T_SIGN_VAR_INDEX; + +typedef struct /* T_SIGN_VAR */ +{ + T_SIGN_VAR_VALUE value; /* current signal variance */ + T_SIGN_VAR_INDEX index; /* mean index */ +} T_SIGN_VAR; + +typedef USHORT T_C_INDEX; +typedef USHORT T_C_VALUE; + +typedef struct /* T_C_FILTER */ +{ + T_C_VALUE value; /* current C value */ + T_C_INDEX index; /* iteration index */ +} T_C_FILTER; + +typedef struct +{ + USHORT total; /* Total number of bits */ + USHORT fault; /* Number of faulty bits */ +} T_BE_INFO; + +typedef struct +{ + UBYTE num_dl_blck; /* Number of downlink data blocks */ + T_BE_INFO be_info[MAC_MAX_DL_DATA_BLCKS]; + /* Bit error information */ +} T_BER_IND; + +typedef ULONG T_BER_VALUE; +typedef USHORT T_BER_INDEX; + +typedef struct /* T_BER_AVG */ +{ + T_BER_VALUE value; /* current BER value in % */ + T_BER_INDEX index; /* iteration index */ +} T_BER_AVG; + +#if ( ! ( MAC_MAX_TIMESLOTS == CGRLC_MAX_TIMESLOTS ) ) + #error MAC_MAX_TIMESLOTS == CGRLC_MAX_TIMESLOTS required +#endif + +#if ( ! ( MAC_RXLEV_NONE == CGRLC_RXLEV_NONE ) ) + #error MAC_RXLEV_NONE == CGRLC_RXLEV_NONE required +#endif + +#if ( ! ( MAC_RXLEV_MIN == CGRLC_RXLEV_MIN ) ) + #error MAC_RXLEV_MIN == CGRLC_RXLEV_MIN required +#endif + +#if ( ! ( MAC_RXLEV_MAX == CGRLC_RXLEV_MAX ) ) + #error MAC_RXLEV_MAX == CGRLC_RXLEV_MAX required +#endif + +typedef enum /* T_PCH_IDX */ +{ + PCH_IDX_A = 0, + PCH_IDX_B = 1, + + PCH_IDX_MAX = 2 +} T_PCH_IDX; + +typedef struct /* T_PCH_ARRAY */ +{ + UBYTE pch[MAC_MAX_TIMESLOTS]; +} T_PCH_ARRAY; + +typedef struct /* T_PCH_BUFFER */ +{ + T_PCH_IDX pch_idx; + T_PCH_ARRAY pch_array[PCH_IDX_MAX]; +} T_PCH_BUFFER; + +typedef struct /* T_MS_PWR_CAP */ +{ + const UBYTE *p_control; /* power control level -> output power */ + SHORT pwr_min; /* minimum nominal output power in the cell */ + SHORT gamma_0; /* GAMMA 0 */ +} T_MS_PWR_CAP; + +typedef struct /* T_TPC_DATA */ +{ + UBYTE fix_pcl; /* fixed PCL */ + + BOOL v_fix_pwr_par; + T_CGRLC_pwr_ctrl_param fix_pwr_par; /* fixed power parameter */ + + T_CGRLC_pwr_ctrl_param pwr_par; /* power control parameter */ + T_CGRLC_glbl_pwr_ctrl_param glbl_pwr_par; /* global power control parameter */ + + T_PCH_BUFFER pch_buffer; /* power control level buffer */ + +#if !defined (NTRACE) + + UBYTE n_tpc_trace; + +#endif /* #if !defined (NTRACE) */ + +#ifndef NTRACE + char *name; + char *state_name; +#endif +} T_TPC_DATA; + +typedef struct /* T_GRLC_MEAS_DATA */ +{ + T_CGRLC_INT_LEVEL_REQ ilev; + T_C_FILTER c_filter; + T_SIGN_VAR sign_var; + T_BER_AVG ber_avg; + BOOL sq_restart; + +#if !defined (NTRACE) + + UBYTE v_im_trace; + +#endif /* #if !defined (NTRACE) */ + +#ifndef NTRACE + char *name; + char *state_name; +#endif +} T_GRLC_MEAS_DATA; + +typedef struct /* T_GRLC_READY_TIMER */ +{ + T_READY_TIMER_HANDLING handling; + T_READY_TIMER_STATE state; + ULONG value; +} T_GRLC_READY_TIMER; + +typedef struct /* T_GRLC_DATA */ +{ + T_GRLC_READY_TIMER ready_timer; + + UBYTE burst_type; + UBYTE ab_type; + T_CGRLC_pan_struct pan_struct; + UBYTE t3168_val; + + + T_UL_TBF uplink_tbf; /* This structure is used by TM,RU + during uplink-tbf */ + T_DL_TBF downlink_tbf; /* This structure is used by TM,RD + during downlink-tbf */ + T_TBF_TYPE tbf_type; + T_REL_TYPE rel_type; /* indicates the type of TBF currently being released */ + UBYTE prim_start_free; /* index of first free prim queue entry */ + UBYTE prim_start_tbf ; /* index of first tbf prim queue entry */ + + UBYTE save_prim_start_free; /* save value during rau request */ + UBYTE save_prim_start_tbf ; /* save value during rau request */ + BOOL gmm_procedure_is_running; /* inidcates if gmm procedure is rnnig or not*/ + + USHORT prim_user_data; /* user data which is current in the prim_queue */ + T_PRIM_QUEUE prim_queue[PRIM_QUEUE_SIZE_TOTAL]; + /* queueing of llc-pdu's */ + UBYTE ta_value; + + UBYTE ul_tn_mask; /* current uplink timeslot mask */ + UBYTE dl_tn_mask; /* current downlink timeslot mask */ + + UBYTE ul_tfi; + UBYTE dl_tfi; + UBYTE r_bit; /* current r-bit value - set by TC - read by RU/RD*/ + UBYTE poll_start_free; + UBYTE poll_start_tbf; + ULONG ul_fn; /* framenumber for the current radio block, needed for transmission*/ + ULONG dl_fn; /* framenumber of the last radio block, where a block is received*/ + T_NEXT_POLL_ARRAY next_poll_array[NEXT_POLL_ARRAY_SIZE] ; + UBYTE N3102; + T_chan_req_des chan_req_des; /* this will be included in next Packet Downlink AckNack + write by TC, read by RD */ + T_TESTMODE testmode; /* this structure contains all GPRS test mode related data */ + + /* only for tracing*/ + ULONG grlc_data_req_cnt; + ULONG dl_tbf_start_time; + ULONG ul_tbf_start_time; + UBYTE ul_index; + UBYTE dl_index; + T_TBF_CTRL tbf_ctrl[2]; + + /*handling of gaps*/ + ULONG missed_poll_fn; + + UBYTE t3164_to_cnt; /* conunts the timeouts of timer t3164 in sequence */ + UBYTE start_fn_ul_tfi; /* stores the uplink tfi, which becomes valid after starting time*/ + UBYTE start_fn_dl_tfi; /* stores the downlink tfi, which becomes valid after starting time*/ + T_ul_poll_resp ul_poll_resp[2];//MULTISLOT + UBYTE ul_poll_pos_index; /* index of ul_poll_response, need for polling */ + ULONG next_poll_fn; /*indicates the next poll fn */ + T_FUNC_INTERFACE func; + + ULONG nr_of_crc_errors; + T_TFI_CHANGE tfi_change; + BOOL ul_tfi_changed; + UBYTE grlc_wo_ccd; /*=0 ccd is used for en/decoding, =1 messages are decoded wo ccd */ +#ifdef REL99 + BOOL pfi_support; + U8 pfi_value; + U8 nw_rel; +#endif + +#if defined (_TARGET_) /*target debugging*/ + ULONG last_ul_fn; + ULONG last_dl_fn; +#define CALL_ERROR_NR_OF_ST_FN 9 + ULONG ul_fn_store[CALL_ERROR_NR_OF_ST_FN+1]; + ULONG ul_fn_errors[CALL_ERROR_NR_OF_ST_FN+1]; + ULONG dl_fn_store[CALL_ERROR_NR_OF_ST_FN+1]; + ULONG dl_fn_errors[CALL_ERROR_NR_OF_ST_FN+1]; + UBYTE ul_cnt_syn; /*for target, count calls in rlc uplink*/ + UBYTE ul_cnt_asyn; /*for target, count calls in gffp mac_ready_ind*/ + UBYTE dl_cnt_syn; /*for target, count calls in rlc downlink*/ + UBYTE dl_cnt_asyn; /*for target, count calls in gffp mac_data_ind*/ + UBYTE ul_call_errors; /*for target, count calls in rlc uplink during grlc is active*/ + UBYTE dl_call_errors; /*for target, count calls in rlc downlink during grlc is active*/ +#endif /*(_TARGET_) */ + + /* + * Service data + */ + T_GFF_DATA gff; + T_TM_DATA tm; + T_RD_DATA rd; + T_RU_DATA ru; + T_TPC_DATA tpc; + T_GRLC_MEAS_DATA meas; +}T_GRLC_DATA; + + + + + + + + +/*==== EXPORT =====================================================*/ + +/* + * data base + */ +#ifdef GRLC_PEI_C + T_GRLC_DATA grlc_data_base, *grlc_data; +#else +EXTERN T_GRLC_DATA grlc_data_base, *grlc_data; +#endif + +#define ENTITY_DATA grlc_data + + +/* + * Communication handles (see also GRLC_PEI.C) + */ +#define hCommL1 grlc_hCommMAC +#define hCommGRR grlc_hCommGRR +#define hCommGRLC grlc_hCommGRLC +#define hCommGMM grlc_hCommGMM +#define hCommLLC grlc_hCommLLC +#define hCommPL grlc_hCommPL +#ifdef FF_WAP + #define hCommWAP grlc_hCommWAP /*In future an own FMM Entity is planned*/ +#endif + +#define _decodedMsg grlc__decodedMsg + + +#ifdef GRLC_PEI_C + T_HANDLE hCommL1 = VSI_ERROR; + T_HANDLE hCommGRLC = VSI_ERROR; + T_HANDLE hCommGRR = VSI_ERROR; + T_HANDLE hCommGMM = VSI_ERROR; + T_HANDLE hCommLLC = VSI_ERROR; + T_HANDLE hCommPL = VSI_ERROR; +#ifdef FF_WAP + T_HANDLE hCommWAP = VSI_ERROR; +#endif + T_HANDLE GRLC_handle; + + + +GLOBAL UBYTE _decodedMsg [MAX_MSTRUCT_LEN_GRLC]; + +/* + * make the pei_create function unique + */ +#define pei_create grlc_pei_create + +/* + * make the pei_func_primitive function unique + */ +#define pei_func_primitive grlc_pei_func_primitive + +#else /* !GRLC_PEI_C */ +EXTERN T_HANDLE hCommL1; +EXTERN T_HANDLE hCommGRLC; +EXTERN T_HANDLE hCommGRR; +EXTERN T_HANDLE hCommGMM; +EXTERN T_HANDLE hCommLLC; +EXTERN T_HANDLE hCommPL; +#ifdef FF_WAP + EXTERN T_HANDLE hCommWAP; +#endif +EXTERN T_HANDLE GRLC_handle; +#endif /* GRLC_PEI_C */ + + +EXTERN UBYTE _decodedMsg [MAX_MSTRUCT_LEN_GRLC]; + +#ifdef _TARGET_ + +#undef TRACE_FUNCTION +#define TRACE_FUNCTION(a) +#undef TRACE_ISIG +#define TRACE_ISIG(a) + +#endif /* _TARGET_ */ + +#endif /* GRLC_H */