view src/g23m-gprs/grlc/grlc.h @ 303:f76436d19a7a default tip

!GPRS config: fix long-standing AT+COPS chance hanging bug There has been a long-standing bug in FreeCalypso going back years: sometimes in the AT command bring-up sequence of an ACI-only MS, the AT+COPS command would produce only a power scan followed by cessation of protocol stack activity (only L1 ADC traces), instead of the expected network search sequence. This behaviour was seen in different FC firmware versions going back to Citrine, and seemed to follow some law of chance, not reliably repeatable. This bug has been tracked down and found to be specific to !GPRS configuration, stemming from our TCS2/TCS3 hybrid and reconstruction of !GPRS support that was bitrotten in TCS3.2/LoCosto version. ACI module psa_mms.c, needed only for !GPRS, was missing in the TCS3 version and had to be pulled from TCS2 - but as it turns out, there is a new field in the MMR_REG_REQ primitive that needs to be set correctly, and that psa_mms.c module is the place where this initialization needed to be added.
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 08 Jun 2023 08:23:37 +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 */