FreeCalypso > hg > fc-tourmaline
view src/g23m-gprs/grlc/grlc.h @ 268:f2e52cab0a73
abb_inth.c: check all interrupt causes, not just one
The original code used if - else if - else if etc constructs, thus
the first detected interrupt was the only one handled. However,
Iota ITSTATREG is a clear-on-read register, thus if we only handle
the first detected interrupt and skip checking the others, then the
other interrupts will be lost, if more than one interrupt happened
to occur in one ABB interrupt handling cycle - a form of rare race
condition. Change the code to check all interrupts that were read
in this cycle.
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 13 Jun 2021 18:17:53 +0000 |
| parents | fa8dc04885d8 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | 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 */