/*
+-----------------------------------------------------------------------------
|  Project :  GSM-PS
|  Modul   :  ALR
+-----------------------------------------------------------------------------
|  Copyright 2002 Texas Instruments Berlin, AG
|                 All rights reserved.
|
|                 This file is confidential and a trade secret of Texas
|                 Instruments Berlin, AG
|                 The receipt of or possession of this file does not convey
|                 any rights to reproduce or disclose its contents or to
|                 manufacture, use, or sell anything it may describe, in
|                 whole, or in part, without the specific written consent of
|                 Texas Instruments Berlin, AG.
+-----------------------------------------------------------------------------
|  Purpose :  Definitions for the Protocol Stack Entity ALR
+-----------------------------------------------------------------------------
*/

#ifndef ALR_H
#define ALR_H

#define STOP_SYNC_TASK          /* stop always any sync tasks before start a new one */
#if 0
#define DL_TRACE_ENABLED        /* use DL offline trace */
#define TRACE_STATE_TRANSITION  /* trace some state transitions */
#endif /* 0 */

#if !defined(_SIMULATION_) && defined(WIN32)
#define _SIMULATION_
#endif  /* !_SIMULATION_ && WIN32 */

#if defined(_SIMULATION_)
#undef  DL_TRACE_ENABLED  /* no _SYST trace during simulation */
#endif  /* WIN32 */

#define SYST_TRACE(a) vsi_o_ttrace(0, 0xFFFF,a)
#define SYST           0, 0xffff
#define SYST_TRACE_P(a) vsi_o_ttrace a
/*
 * use it as showed next line...
 * SYST_TRACE_P((SYST, "e.g. two parameter: %d %d", p1, p2));
 */


#if !defined(ELEMENTS)
#define ELEMENTS(array) (sizeof(array)/sizeof(array[0]))
#endif  /* !ELEMENTS */

/*
 * for voice memo
 */
#include "p_cst.h"

/* Bitoffset for Message Buffer allocation */
#define ENCODE_OFFSET             24

/*
 * Bitmasks
 */
#define BIT_0                     0x01
#define BIT_1                     0x02
#define BIT_2                     0x04
#define BIT_3                     0x08
#define BIT_4                     0x10
#define BIT_5                     0x20
#define BIT_6                     0x40
#define BIT_7                     0x80
#define BIT_012                   0x07

#include "p_ph.h"
#include "p_mph.h"

/* First 40 carriers per band will be added at top of the MPH_POWER_CNF
 * and the next 20 Carriers (40 to 60) will be added at the bottom.
 * Remaining carriers needs to be ignored.
 */

#define ADD_AT_THE_TOP       0x01   /* first 40 carrier */
#define ADD_AT_THE_BOTTOM    0x02   /* already 40 carriers were added */
#define REACHED_THE_MAXIMUM  0x04   /* already 60 carriers were added */
#define DO_NOT_ADD           0x08   /* wrong carrier */


/* Private modes */
#define MODE_CHAN_ASS_FAIL   16
#define MODE_HANDOVER_FAIL   17

/* Results of configuration dedicated mode */
#define DEDICATED_SUCCESS    0

#define  ALR_ALLOCATE_NEW_BA(v)             ((((v)+1) % (ALR_BA_HIGH-ALR_BA_LOW+1)) + ALR_BA_LOW)
#define  IS_EXT_MEAS_RUNNING                (alr_data->cs_data.mph_ext_meas_req NEQ NULL)

/*
 * Dynamic Configurations
 */
#define ID_STD               1
#define ID_CONFIG            2
#define ID_MON_COUNTER_IDLE  3
#define ID_MON_COUNTER_DEDI  4
#define ID_TRC_DATA_IND      5
#define ID_RACH_FAILURE      6
#define ID_EOTD              7

#define ID_TRC_DATA_IND_ALL     0xff
#define ID_TRC_DATA_IND_VALID   0x7f
#define ID_TRC_DATA_IND_INVALID 0x80
#define ID_TRC_DATA_IND_BCCH    0x01  /* normal and extended BCCH */
#define ID_TRC_DATA_IND_PCH     0x02  /* normal and extended PCH */
#define ID_TRC_DATA_IND_CCCH    0x04
#define ID_TRC_DATA_IND_CBCH    0x08
#define ID_TRC_DATA_IND_SCCH    0x10  /* SACCH and SDCCH */
#define ID_TRC_DATA_IND_FCCH    0x20  /* full and half rate FACCH */
#define ID_TRC_DATA_IND_STATE   0x40  /* MA status */
#define ID_TRC_DATA_IND_INIT    0x3f  /* all valid frames without stati */
#define ID_TRC_DATA_IND_INIT2   0x1f  /* ... without FACCH */

EXTERN  UBYTE v_mon_trc_data_ind;
EXTERN  UBYTE v_cfg_rach_failure;

/* In addition to normal page modes defined in SAP */
#define PGM_REORG_CS         3
#define NO_PGM_CHANGE        4
#define SAVED_PGM            0xff

/*If page mode is set to REORG and a HPLMN search is performed, L1 cannot
synchronize to NC's. Therefore NORMAL page mode is started. This state
defines that the mobile should be in REORG, but actual is in NORMAL.*/
#define PGM_REORG_NC_SYNC    5
EXTERN  UBYTE page_mode_before_hplmn_search;/*to distinguish PGM_REORG and PGM_REORG_CS */

/* Page Mode Changes */
#define NONE                 0
#define SWAP_TO_EXTEND       1
#define SWAP_TO_REORG        2
#define SWAP_TO_NORMAL       3

#define MAX_GSM_CHANNEL_ATTEMPTS  40   /* GSM says 30, but this is done in the field */
#define MAX_DPCS_CHANNEL_ATTEMPTS  40

/* Band Limitations for multiband reporting */
#define NO_BAND_LIMITATION   0
#define EXCLUDE_SC_BAND      1
#define ONLY_SC_BAND         2

#define IMSI_LEN                  9
#define SI_CONTENTS_MSG_T         2
#define SI_CONTENTS_CS2           9
#define ONLY_ACS                  0x80
#define STOP_PCH_READING          1
#define DONT_STOP_PCH_READING     0
#define STOP_MEASUREMENTS         2

/*
 * Neighbour cell status
 */
/* #define DEFINE_OLD_NC_STATUS */
#if !defined(DEFINE_OLD_NC_STATUS)
/* neighbour cell base stati */
#define  NCS_INACTIVE                       0x00
#define  NCS_IDLE                           0x01
#define  NCS_FB_SB                          0x02
#define  NCS_SB                             0x03
/* neighbour cell bit masks */
#define  NCB_BCCH                           0x04
#define  NCB_READ                           0x08
#define  NCB_PENDING                        0x10
#define  NCB_SYNC                           0x20
#define  NCB_RR_NOT_INFORMED                0x40
#define  NCB_FAILED                         0x80

/* neighbour cell stati */
/* 1of<n> n = 6,12 means that the cell belongs to the n strongest */
/* RLA_C means Received Level Averages according GSM 05.08 seciton 6.1 */

                                            /* (1) no PERIODIC measurement received; cell is excluded from all activities except rxlev measurement */
#define  INACTIVE                           (NCS_INACTIVE)

                                            /* (2) PERIODIC measurement received; not synchronized; BCCH data unknown */
#define  IDLE                               (NCS_IDLE)

                                            /* (11a) not a 1of12 cell any more; synchronized */
#define  IDLE_SYNC                          (NCS_IDLE|NCB_SYNC)

                                            /* (3) strong cell(1of12); not synchronized yet; need first FB and SB synchronization */
#define  READ_FB_SB                         (NCS_FB_SB|NCB_READ)

                                            /* (4) first FB and SB synchronization ongoing */
#define  READ_FB_SB_PENDING                 (NCS_FB_SB|NCB_READ|NCB_PENDING)

                                            /* (9) synchronized; need re-synchronization of SB (10/30 sec); no need to read BCCH */
#define  READ_SB                            (NCS_SB|NCB_READ)

                                            /* (10) re-synchronization of SB ongoing (10/30 sec); no reading of BCCH */
#define  READ_SB_PENDING                    (NCS_SB|NCB_READ|NCB_PENDING)

                                            /* (9a) synchronized; need re-synchronization of SB and re-reading of BCCH (5 min) */
#define  READ_SB_BCCH                       (NCS_SB|NCB_READ|NCB_BCCH)

                                            /* (10a) re-synchronization of SB ongoing (5 min) */
#define  READ_SB_BCCH_PENDING               (NCS_SB|NCB_READ|NCB_BCCH|NCB_PENDING)

                                            /* (11a) re-synchronization of SB finished; need re-reading of BCCH (5 min) */
#define  READ_BCCH                          (NCS_SB|NCB_READ|NCB_BCCH|NCB_SYNC)

                                            /* (12a) re-reading of BCCH ongoing (5 min) */
#define  READ_BCCH_PENDING                  (NCS_SB|NCB_READ|NCB_BCCH|NCB_SYNC|NCB_PENDING)

                                            /* (5) 1of6 cell; synchronized; BCCH data unknown; need to read BCCH, but to notify RR after a measurement ind only */
#define  READ_BCCH_RR_NOT_INFORMED          (NCS_SB|NCB_READ|NCB_BCCH|NCB_SYNC|NCB_RR_NOT_INFORMED)

                                            /* (6) 1of6 cell; reading of BCCH ongoing  */
#define  READ_BCCH_PENDING_RR_NOT_INFORMED  (NCS_SB|NCB_READ|NCB_BCCH|NCB_SYNC|NCB_RR_NOT_INFORMED|NCB_PENDING)

                                            /* (8) 1of12 cell; synchronized; in case 1of6: BCCH data known; RR is notified; subsequent RLA_Cs being computed */
#define  FB_SB_SYNC                         (NCS_FB_SB|NCB_SYNC)

                                            /* (7) 1of6 cell; synchronized; BCCH data known; RR not yet notified; first RLA_C being computed */
#define  FB_SB_SYNC_RR_NOT_INFORMED         (NCS_FB_SB|NCB_SYNC|NCB_RR_NOT_INFORMED)

                                            /* (13) 1of<n> cell state questionable; FB/SB sync or BCCH reading failed 1 thru 8 times */
#define  FB_SB_FAILED                       (NCS_FB_SB|NCB_FAILED)

                                            /* (14) 1of<n> cell; synchronization of FB/SB or reading of BCCH failed > 8 times; NCC check failed; */
#define  EXCLUDED                           (NCB_FAILED)

#else /* !DEFINE_OLD_NC_STATUS */
#define INACTIVE                            0
#define IDLE                                1
#define READ_BCCH                           2
#define FB_SB_SYNC                          3
#define FB_SB_FAILED                        4
#define READ_FB_SB                          5
#define READ_SB                             6
#define IDLE_SYNC                           7
#define EXCLUDED                            8
#define FB_SB_SYNC_RR_NOT_INFORMED          9
#define READ_SB_BCCH                       10
#define READ_BCCH_PENDING                  11
#define READ_FB_SB_PENDING                 12
#define READ_SB_PENDING                    13
#define READ_SB_BCCH_PENDING               14
#define READ_BCCH_RR_NOT_INFORMED          15
#define READ_BCCH_PENDING_RR_NOT_INFORMED  16
#endif /* !DEFINE_OLD_NC_STATUS */

/*
 * states of a neighbour cell with respect to the BA list
 * in the last MPH_NEIGHBOURCELL_REQ.
 */
#define IN_BA              0   /* NCell was in last MPH_NEIGHBOURCELL_REQ */
#define NOT_IN_BA_SHORT    1   /* NCell wasn't in last MPH_NEIGHBOURCELL_REQ but at last confirmation it had state IN_BA (not in BA for a short time) */
#define NOT_IN_BA_LONG     2   /* NCell wasn't in last MPH_NEIGHBOURCELL_REQ and at last confirmation it hadn't state IN_BA (not in BA for a long time) */
/*
*  Definitions for AMR
*/
#define CM_AMR             0x41

/*
 * The times are given in number of multiframes. Each multiframe is
 * equal to circa 217 milliseconds.
 */
#define THIRTY_SECONDS_SCELL_BCCH   128

/*
 * States Main Control
 */
#define MA_NULL              0
#define MA_CELL_SELECTION    1
#define MA_IDLE              2
#define MA_CON_EST           3
#define MA_DEDICATED         4
#define MA_CELL_RESELECTION  5

#ifdef GPRS
#define MA_PTM               6
#endif

EXTERN  const char * const
        STATE_MA_NAME[];
#ifndef GPRS
#define STATE_MA_NAME_INIT   \
       "MA_NULL"            ,\
       "MA_CELL_SELECTION"  ,\
       "MA_IDLE"            ,\
       "MA_CON_EST"         ,\
       "MA_DEDICATED"       ,\
       "MA_CELL_RESELECTION"
#else  /* !GPRS */
#define STATE_MA_NAME_INIT   \
       "MA_NULL"            ,\
       "MA_CELL_SELECTION"  ,\
       "MA_IDLE"            ,\
       "MA_CON_EST"         ,\
       "MA_DEDICATED"       ,\
       "MA_CELL_RESELECTION",\
       "MA_PTM"
#endif  /* !GPRS */
/*
 * States Idle Neighbour Cell
 */
#define NC_NULL              0
#define NC_IDLE              1
#define NC_DEDICATED         2
#define NC_CON_EST           3
#ifdef GPRS
#define NC_PIM_PBCCH         4
#define NC_PTM_PBCCH         5

EXTERN  const char * const
        STATE_NC_NAME[];
#define STATE_NC_NAME_INIT   \
       "NC_NULL"            ,\
       "NC_IDLE"            ,\
       "NC_DEDICATED"       ,\
       "NC_CON_EST"         ,\
       "NC_PIM_PBCCH"       ,\
       "NC_PTM_PBCCH"
#else
EXTERN  const char * const
        STATE_NC_NAME[];
#define STATE_NC_NAME_INIT   \
       "NC_NULL"            ,\
       "NC_IDLE"            ,\
       "NC_DEDICATED"       ,\
       "NC_CON_EST"
#endif

/*
 * States Dedicated Control
 */
#define DEDI_INACTIVE        0
#define DEDI_IMM_ASS         1
#define DEDI_IMM_ASS_RECONN  2
#define DEDI_ACTIVE          3

EXTERN  const char * const
        STATE_DEDI_NAME[];
#define STATE_DEDI_NAME_INIT \
       "DEDI_INACTIVE"      ,\
       "DEDI_IMM_ASS"       ,\
       "DEDI_IMM_ASS_RECONN",\
       "DEDI_ACTIVE"

/*
 * States Cell Selection
 */
#define CS_NULL              0
#define CS_INIT_L1           1  /* start with configuration of the radio band */
#define CS_INIT_ACTIVE       2  /* configuration of the radio band is active */
#define CS_INIT_DONE         3  /* configuration has done */
#define CS_START_MEASURE     4  /* start measurement with preceding configuration */
#define CS_ACTIVE_MEASURE    5  /* power measurement step is active */
#define CS_MEASURED          6  /* power measurement step has finished */
#define CS_INIT_SYNC         7  /* configuration of the radio band before SYNC */
#define CS_STOP_SYNC         8  /* stop any sync task */
#define CS_STOP_SYNC_DONE    9  /* no sync task active */
#define CS_ACTIVE_SYNC      10
#define CS_ACTIVE_BCCH      11
#define CS_NW_SYNC_TIMEOUT  12  /* ALR has timed out whilst attempting to sync to a nw */

EXTERN  const char * const
        STATE_CS_NAME[];
#define STATE_CS_NAME_INIT\
       "CS_NULL"            ,\
       "CS_INIT_L1"         ,\
       "CS_INIT_ACTIVE"     ,\
       "CS_INIT_DONE"       ,\
       "CS_START_MEASURE"   ,\
       "CS_ACTIVE_MEASURE"  ,\
       "CS_MEASURED"        ,\
       "CS_INIT_SYNC"       ,\
       "CS_STOP_SYNC"       ,\
       "CS_STOP_SYNC_DONE"  ,\
       "CS_ACTIVE_SYNC"     ,\
       "CS_ACTIVE_BCCH"     ,\
       "CS_NW_SYNC_TIMEOUT"

/*
 * States PCH Control
 */
#define PCH_NULL           0
#define PCH_ACTIVE         1

EXTERN  const char * const
        STATE_PCH_NAME[];
#define STATE_PCH_NAME_INIT\
       "PCH_NULL"         ,\
       "PCH_ACTIVE"

/*
 * States RACH Control
 */
#define RA_NULL            0
#define RA_ACTIVE          1
#define RA_LISTEN_TO_CCCH  2

EXTERN  const char * const
        STATE_RA_NAME[];
#define STATE_RA_NAME_INIT \
       "RA_NULL"          ,\
       "RA_ACTIVE"        ,\
       "RA_LISTEN_TO_CCCH"

/*
 * States CBCH Control
 */
#define CBCH_NULL          0
#define CBCH_IDLE          1
#define CBCH_NO_DRX        2
#define CBCH_DRX           3

#define CBCH_HZ_OFF        0
#define CBCH_HZ_IDLE        5
#define CBCH_HZ_PENDING     6
#define CBCH_HZ_RECEIVED    7


EXTERN  const char * const STATE_NORMAL_CBCH_NAME[];
EXTERN  const char * const STATE_EXT_CBCH_NAME[];

#define STATE_CBCH_NAME_INIT\
       "CBCH_NULL"         ,\
       "CBCH_IDLE"         ,\
       "CBCH_NO_DRX"       ,\
       "CBCH_DRX"

/*
 * States Idle Mode Serving Cell
 */
#define SC_NULL            0
#define SC_IDLE_INITIAL    1
#define SC_IDLE            2

EXTERN  const char * const
        STATE_SC_NAME[];
#define STATE_SC_NAME_INIT \
       "SC_NULL"          ,\
       "SC_IDLE_INITIAL"  ,\
       "SC_IDLE"

/*
 * States Idle Mode Serving Cell
 */

typedef enum {
  NC_ACQUIRE=0,
  NC_CONFIRM
} T_NCELL_PROC;

EXTERN  const char * const
        STATE_NC_PROC_NAME[];
#define STATE_NC_PROC_NAME_INIT \
       "NC_ACQUIRE"          ,\
       "NC_CONFIRM"


/*
 * ALR manages 9 (MAX_STATE) states: CBCH,CS,MA,NC,PCH,RA,SC,DEDI,NC_PROC
 */

#define STATE_CS                  0
#define STATE_MA                  1
#define STATE_NC                  2
#define STATE_PCH                 3
#define STATE_RA                  4
#define STATE_SC                  5
#define STATE_DEDI                6
#define STATE_NC_PROC             7
#define STATE_NORMAL_CBCH         8
#define STATE_EXT_CBCH            9
#define MAX_STATE                 10

/*
 * A definition is provided in ALR_PEI.C
 */
#ifdef ALR_PEI_C
  GLOBAL const char * const    STATE_NORMAL_CBCH_NAME[] = {    STATE_CBCH_NAME_INIT };
  GLOBAL const char * const    STATE_EXT_CBCH_NAME[] = {    STATE_CBCH_NAME_INIT };
  GLOBAL const char * const    STATE_CS_NAME  [] = {    STATE_CS_NAME_INIT   };
  GLOBAL const char * const    STATE_MA_NAME  [] = {    STATE_MA_NAME_INIT   };
  GLOBAL const char * const    STATE_NC_NAME  [] = {    STATE_NC_NAME_INIT   };
  GLOBAL const char * const    STATE_PCH_NAME [] = {    STATE_PCH_NAME_INIT  };
  GLOBAL const char * const    STATE_RA_NAME  [] = {    STATE_RA_NAME_INIT   };
  GLOBAL const char * const    STATE_SC_NAME  [] = {    STATE_SC_NAME_INIT   };
  GLOBAL const char * const    STATE_DEDI_NAME[] = {    STATE_DEDI_NAME_INIT };
  GLOBAL const char * const    STATE_NC_PROC_NAME[]={ STATE_NC_PROC_NAME_INIT };
#endif  /* ALR_PIC_C */

/*==== MACROS =====================================================*/

/*

   This macros convert channel numbers from and to the layer 1 specific
   representation for the target version.

   For the single bands GSM900, DCS1800 and PCS1900 the macro is removed
   at compile time.

   For dualband (STD==5,STD==6) a DCS1800 channel number is converted
   using the convert function located at the end of alr_main.c

   In the windows variant no change occurs.

*/

EXTERN USHORT convert_arfcn_to_l1  (USHORT arfcn, UBYTE local_std);
EXTERN USHORT convert_arfcn_to_g23 (USHORT arfcn, UBYTE local_std);

/* range check with the fastest way for ARM */
/* corresponds with ((min <= x) AND (x <= max)) */
#define INRANGE(min, x, max)  ((unsigned)(x-min) <= (max-min))

#if defined (WIN32)
  #define ARFCN_TO_L1(a)          ((USHORT)((a)&ARFCN_MASK))
  #define ARFCN_TO_G23(a)         ((USHORT)((a)&ARFCN_MASK))
  #define ARFCN_STD_TO_L1(a,std)  ((USHORT)((a)&ARFCN_MASK))
  #define ARFCN_STD_TO_G23(a,std) ((USHORT)((a)&ARFCN_MASK))
#else
  /*
   * target version
   */
  #define ARFCN_TO_L1(a)          convert_arfcn_to_l1((USHORT)(a),std)
  #define ARFCN_TO_G23(a)         convert_arfcn_to_g23((USHORT)(a),std)
  #define ARFCN_STD_TO_L1(a,std)  convert_arfcn_to_l1((USHORT)(a),std)
  #define ARFCN_STD_TO_G23(a,std) convert_arfcn_to_g23((USHORT)(a),std)
#endif

/* add resp. get the std value to resp. from arfcn */
#define STD_ADD_TO_ARFCN(a,std)  (((a)&~STD_BIT_MASK) | ((std)<<STD_BIT_SHIFT))
#define STD_GET_FROM_ARFCN(a)    ((((a)&STD_BIT_MASK)>>STD_BIT_SHIFT))

/* find the frequency band index to which the given arfcn belongs. */
EXTERN const int array_band_index[];
#define get_band_index_from_arfcn(arfcn, idx, std)\
{\
   UBYTE local_std = STD_GET_FROM_ARFCN(arfcn);\
   if( !local_std )\
      	local_std = std;\
    idx = local_std;\
    if( local_std ==  STD_DUAL ) {\
            if (arfcn >= LOW_CHANNEL_1800)\
            idx = STD_1800;\
            else\
            idx = STD_900;\
    }\
    else if ( local_std EQ  STD_DUAL_EGSM ) {\
            if (arfcn >= LOW_CHANNEL_EGSM)\
                idx = BAND_E_GSM;\
            else if (arfcn >= LOW_CHANNEL_1800)\
                idx = STD_1800;\
            else if (arfcn EQ CHANNEL_0)\
                idx = STD_EGSM;\
            else\
                idx = STD_900;\
    }\
    else if( local_std EQ  STD_DUAL_US ) {\
            if (arfcn >= LOW_CHANNEL_1900)\
                idx = STD_1900;\
            else\
                idx = STD_850;\
    }\
    (local_std<=STD_DUAL_US)?(idx=array_band_index[idx-1]):(idx=MAX_NUM_BANDS) ;\
}

/*==== TYPES ======================================================*/

EXTERN UBYTE std;       									/*lint -esym(526,std)        : not defined | defined in other entity */
EXTERN UBYTE test_house;									/*lint -esym(526,test_house) : not defined | defined in other entity */

typedef struct {
  USHORT  radio_freq;
  SHORT   accum_power_result;
} T_POWER_ARRAY;

typedef struct {
  USHORT        power_array_size;
  T_POWER_ARRAY power_array[MAX_CARRIERS];
} T_POWER_MEAS;

typedef struct {
  USHORT        power_array_size;
  T_POWER_ARRAY power_array[MAX_CARRIERS_DUAL_EGSM];
} T_POWER_MEAS1;

typedef struct {
  USHORT        power_array_size;
  T_POWER_ARRAY power_array[MAX_CARRIERS_DUAL_US];
} T_POWER_MEAS2;

EXTERN T_POWER_MEAS1  alr_power_meas_result1;
EXTERN T_POWER_MEAS2  alr_power_meas_result2;

#define CS_SYNC_FAIL_COUNT_MAX 5
#define CS_BCCH_FAIL_COUNT_MAX 10

typedef struct {
  T_POWER_MEAS    *p_results1;
  T_POWER_MEAS    *p_results2;
  T_MPH_POWER_CNF *p_power_cnf;
  T_MPH_POWER_REQ *p_power_req;           /*   CSI-LLD section: 4.1.3.1.2 */
  T_MPH_EXT_MEAS_REQ *mph_ext_meas_req;
  USHORT          arfcn;
  UBYTE           ext_meas_state_pend;    /* wait for pending MPHC_RXLEV_IND or MPHC_NCELL_SYNC_IND */
  UBYTE           sync_active;
  UBYTE           freq_bands;
  UBYTE           std;
  UBYTE           std12;
  UBYTE           freq_area;
  UBYTE           search_mode;
  UBYTE           sync_fail_count;
  UBYTE           bcch_fail_count;
  UBYTE           c_meas;
  UBYTE           c_max_meas;
  T_TIME          c_tim_meas;
} T_CS_DATA;

#define MAX_OLD_CB  10
#define CBCH_BLOCK_SIZE      22
#define CBCH_BLOCKS           4
#define CBCH_MSG_SIZE      (CBCH_BLOCKS*CBCH_BLOCK_SIZE)

/* no alignment or gaps between members ! */
typedef struct cbmsg_header_t
{
  UBYTE   serial_no1;
  UBYTE   serial_no2;
  UBYTE   msg_id3;
  UBYTE   msg_id4;
  UBYTE   dcs;
  UBYTE   page;
} T_CBMSG_HEADER;

typedef struct
{
  UBYTE  cnt;
  T_CBMSG_HEADER header [MAX_OLD_CB];
} T_CB_MSG;

#define CBCH_CHANNELS 2
/*
 * index defines are in alr_cbch.c :
 * CBCH_NORM 0
 * CBCH_EXT  1
 */
typedef struct
{
  /* message which currently read */
  UBYTE      msg_is_extended;
  UBYTE      msg [CBCH_MSG_SIZE];
  USHORT     msg_id_sat [MAX_IDENTS_SAT];
  UBYTE      msg_type;
  UBYTE      sat_enabled;
  UBYTE      expected_seq_number[CBCH_CHANNELS];
  /* schedule support for normal and extended CBCH */
  UBYTE      begin_schedule[CBCH_CHANNELS];
  UBYTE      end_schedule[CBCH_CHANNELS];
  UBYTE      scheduled_sched_msg[CBCH_CHANNELS];
  UBYTE      schedule_length[CBCH_CHANNELS];
  UBYTE      last_slot_read[CBCH_CHANNELS];
  ULONG      schedule_map[CBCH_CHANNELS][2];
  /* configured by MMI: specifies which messages are wanted */
  UBYTE      modus;
  UBYTE      old_cid_plmn_lac [7];
  UBYTE      dcs_id [MAX_IDENTS];
  USHORT     msg_id [MAX_IDENTS];
  T_CB_MSG   old_cbch_msg;
#if defined(FF_HOMEZONE)
  /*
   * special handling for homezone CBCH message after cell reselecting
   */
  UBYTE      homezone;
  USHORT     msg_hz_id;
  UBYTE      dcs_hz_id;
  USHORT     hz_timeout;
 #endif  /* FF_HOMEZONE */
#if !defined (L1_STORES_CBCH_CONFIG)
  T_MPHC_CONFIG_CBCH_REQ     mphc_config_cbch;
#endif
} T_CBCH_DATA;

typedef struct
{
  UBYTE                  sys_info_1[22];
  UBYTE                  sys_info_2[22];
  UBYTE                  sys_info_2bis[22];
  UBYTE                  sys_info_2ter[22];
  UBYTE                  sys_info_3[22];
  UBYTE                  sys_info_4[22];
  UBYTE                  sys_info_5[18];
  UBYTE                  sys_info_5bis[18];
  UBYTE                  sys_info_5ter[18];
  UBYTE                  sys_info_6[18];
#ifdef GPRS
  UBYTE                  sys_info_13[22];
#endif
} T_MA_DATA;

typedef struct
{
  /* information for using the cell */
  USHORT     ba_arfcn;
  UBYTE      last_rxlev;
  UBYTE      tim_valid;
  ULONG      frame_offset;
  ULONG      time_align;
  UBYTE      bsic;
  /* power measurements of the cell */
  UBYTE      rxlev[5];
  UBYTE      rxlev_average;
  UBYTE      c_rxlev;
  /* state of the cell */
  UBYTE      one_of_six;   /* this is a subset of one_of_twelve */
  UBYTE      one_of_twelve;
  UBYTE      status;
  UBYTE      ba_status;
  UBYTE      new_strong_cell;
  /* counters for status handling */
  UBYTE      c_attempt;
  UBYTE      c_error;
  UBYTE      c_bcch;
  UBYTE      c_sync;
  USHORT     blocks_required;
  /* Meas results for averaging when NC=1 or NC=2 */
#ifdef GPRS
  USHORT     nc_rxlev;
  UBYTE      c_nc_rxlev;
#endif
  /* temporary BCCH storage */
  T_MPH_UNITDATA_IND* mph_unitdata_ind;
  T_MPH_UNITDATA_IND* mph_unitdata_ind78;
  
} T_NC;

/* values for component tim_state */
#define NC_TIM_STOPPED       0
#define NC_CONF_ENABLED      1
#define NC_CONF_DISABLED     2
#define NC_CONF_PENDING      3

typedef struct
{
  /* +1 because we use this for idle mode cell selection */
#define LAST_BSIC_REQ        BA_LIST_SIZE
  T_NC       cell[BA_LIST_SIZE+1];
  T_NC       cr_cell; /*  */
  UBYTE      c_ba_arfcn;
  UBYTE      ba_id;
  USHORT     channel;
  USHORT     rxlev_full;
  USHORT     rxlev_sub;
  UBYTE      rxqual_full;
  UBYTE      rxqual_sub;
  USHORT     tav;
  UBYTE      pwrc;
  UBYTE      dtx;
  UBYTE      act_dtx;
  UBYTE      update;
  UBYTE      sc_included;
  UBYTE      multiband;
  UBYTE      c_nc_timer;
  /*
   * Counter variable used to store 10sec timer interval 
   * in terms of  the number of 51 frame control multi-frames. 
   * This counter is decremented for every measurement indication
   * received from L1. This is initialized with TEN_SECONDS_ NCSYNC.
   */
  UBYTE      c_ncsync_tim; 
  /*
   *Variable to store the system time whenever 
   * the NCSYNC counter is re-assigned
   */
  T_TIME     ncsync_start_tim;
  /* for MPH_MEASUREMENT_IND */
  USHORT     fn_offset;
  UBYTE      max_reports;
  UBYTE      c_reports; /*
   * counters to keep track of the send NCELL_SYNC_REQ's
   * and NCELL_BCCH_REQ's valid ranges are 0..12 and 0..6
   */
  UBYTE       c_sync_req;
  UBYTE       c_bcch_req;
  /* EOTD related */
  UBYTE       eotd_avail;
  UBYTE       tim_state;
  UBYTE       new_strong_cell_detect;
  UBYTE       c_sync_intrupted;
  T_MPH_NCELL_POS_IND* ppos_ind;
  T_MPH_NCELL_POS_REQ* ppos_req;
} T_NC_DATA;

#define SYSTEM_INFO_1_READ           0x01
#define SYSTEM_INFO_2_READ           0x02
#define SYSTEM_INFO_3_READ           0x04
#define SYSTEM_INFO_4_READ           0x08

#ifdef GPRS
#define SYSTEM_INFO_13_READ          0x10
#endif

#define ALL_SI_READ_EXCEPT_SI13      0x0F

typedef struct
{
  T_MPHC_START_CCCH_REQ  pl_idle, last_start_ccch_req;
  SHORT      imsi_mod_1000;
  UBYTE      dlt;
  UBYTE      act_dlt;
  UBYTE      si3_read;
  UBYTE      saved_page_mode;
  UBYTE      imsi [IMSI_LEN];
  UBYTE      v_tmsi;
  ULONG      tmsi;
  BOOL       reorg_bcch_reading;
  UBYTE      si_bitmap;
} T_PCH_DATA;

typedef struct
{
  UBYTE       ms_class;
  UBYTE       dcs_class;
  UBYTE       max_tx_pwr_ccch;
  UBYTE       delta [8];
  UBYTE       channel_request [8];
#ifdef GPRS
  UBYTE       t1 [8];
  UBYTE       t2 [8];
  UBYTE       t3 [8];
#endif
  UBYTE       max_bursts;
  UBYTE       c_burst;
} T_RACH_DATA;

typedef struct
{
  UBYTE             rlt;
  UBYTE             act_rlt;
  USHORT            act_bcch;
  UBYTE             act_mode;
  /*
   *   Description of the actual used
   *   channel, confirmed by layer 1
   */
  T_channel_desc            act_channel_desc;
  T_frequency_list          act_frequency_list;
  T_starting_time           act_starting_time;
  T_frequency_list_bef_sti  act_frequency_list_bef_sti;
  T_channel_desc            act_channel_desc_bef_sti;
  UBYTE                     act_channel_mode;
  BOOL                      act_pwrc;
  UBYTE                     act_cipher_mode;
  UBYTE                     act_a5_algorithm;
  T_cipher_key              act_cipher_key;
  T_amr_configuration       act_amr_configuration;
  UBYTE                     act_power;
  UBYTE                     act_dtx_allowed;
  /*
   *    Description of the old used
   *    channel.
   */
  USHORT                    old_bcch;
  UBYTE                     old_bsic;
  UBYTE                     old_channel;
  UBYTE                     old_channel_mode;
  T_channel_desc            old_channel_desc;
  T_frequency_list          old_frequency_list;
  T_starting_time           old_starting_time;
  T_frequency_list_bef_sti  old_frequency_list_bef_sti;
  T_channel_desc            old_channel_desc_bef_sti;
  BOOL                      old_pwrc;
  UBYTE                     old_cipher_mode;
  UBYTE                     old_a5_algorithm;
  T_cipher_key              old_cipher_key;
  T_amr_configuration       old_amr_configuration;
  UBYTE                     old_power;
  UBYTE                     old_dtx_allowed;

  /*
   *    Description of the new configured
   *    channel, not yet confirmed by layer 1.
   */
  USHORT                    temp_bcch;
  UBYTE                     temp_bsic;
  UBYTE                     temp_channel;
  UBYTE                     temp_channel_mode;
  T_channel_desc            temp_channel_desc;
  T_frequency_list          temp_frequency_list;
  T_starting_time           temp_starting_time;
  T_frequency_list_bef_sti  temp_frequency_list_bef_sti;
  T_channel_desc            temp_channel_desc_bef_sti;
  BOOL                      temp_pwrc;
  UBYTE                     temp_cipher_mode;
  UBYTE                     temp_a5_algorithm;
  T_cipher_key              temp_cipher_key;
  T_amr_configuration       temp_amr_configuration;
  UBYTE                     temp_power;
  UBYTE                     temp_dtx_allowed;

  /*
   *     Description of frequency redefinition
   *     parameter.
   */
  T_channel_desc    redef_channel_desc;
  T_frequency_list  redef_frequency_list;
  T_starting_time   redef_starting_time;
  /*
   *     Extended Measurmeent Order parameter.
   */
  UBYTE                     emo_ba_id;
} T_DEDI_DATA;

#define TIM_NCSYNC_VALUE               10000
#define TIM_NW_SYNC_GUARD_VALUE         2500

/*
 *  timer
 */
#define TIMER_TRACE

#if defined (TIMER_TRACE)
#define TIMERSTART(i,v)                 tim_start_timer (i, v)
#define TIMERSTOP(i)                    tim_stop_timer (i)
#define IS_TIMER_ACTIVE(i)              tim_check_timer (i)
#else
#define TIMERSTART(i,v)
#define TIMERSTOP(i)
#define IS_TIMER_ACTIVE(i)
#endif /* TIMER_TRACE */

enum  tim_index_e
{
  TIM_POWERMEAS,
  TIM_NW_SYNC_GUARD,
#if defined(FF_HOMEZONE)
  TIM_HOMEZONE,
#endif  /* FF_HOMEZONE */
  NUM_OF_ALR_TIMERS
};

typedef  void (*T_TIMER_EXPIRY)(void);

typedef struct
{
  UBYTE             running[NUM_OF_ALR_TIMERS];
  T_TIMER_EXPIRY    expire[NUM_OF_ALR_TIMERS];
} T_TIM_DATA;

#ifdef OPTION_MULTITHREAD
  #define tim_init                  _ENTITY_PREFIXED(tim_init)
  #define tim_exec_timeout          _ENTITY_PREFIXED(tim_exec_timeout)
  #define tim_stop_timer            _ENTITY_PREFIXED(tim_stop_timer)
  #define tim_start_timer           _ENTITY_PREFIXED(tim_start_timer)
  #define tim_check_timer           _ENTITY_PREFIXED(tim_check_timer)
  #define trace_timer               _ENTITY_PREFIXED(trace_timer)
#endif

EXTERN void tim_init (void);
EXTERN void tim_exec_timeout (USHORT index);
EXTERN void tim_stop_timer (USHORT index);
EXTERN void tim_start_timer (USHORT index, T_TIME value);
EXTERN BOOL tim_check_timer(USHORT index);

/* all data is stored so, that it doesn't need
   to be converted if send to the upper layers.
   Exceptions are alr_data.cs_data.results,
                  alr_data.pch_data.pl_idle
                  alr_data.pch_data.imsi */

typedef struct
{
  UBYTE          state[MAX_STATE];
  /*
   * each of these elements is only
   * accessed by the appropiate
   * process
   */
  T_CBCH_DATA    cbch_data;
  T_CS_DATA      cs_data;
  T_MA_DATA      ma_data;
  T_NC_DATA      nc_data;
  T_PCH_DATA     pch_data;
  T_RACH_DATA    rach_data;
  T_DEDI_DATA    dedi_data;
#ifdef GPRS
  T_ALR_GPRS_DATA    gprs_data;
#endif  /* GPRS */
  T_TIM_DATA     tim_data;

  UBYTE          mmi;             /* mmi variant     */
  UBYTE          keypad;          /* keypad variant  */
  UBYTE          sc_band;         /* frequency band of the serving cell */
  BOOL           ext_display;     /* ext display     */
  EF_MSCAP       mscap;           /* MS capabilities (channel mode, data cap., features */
                                  /* is this component really needed ?? */
  /*
   * these parameters are used by more than one process
   * this is to avoid data inconsistencies between
   * the different processes
   */
  USHORT         serving_cell;
  USHORT         old_serving_cell;
  UBYTE          bsic;
  UBYTE          bs_pa_mfrms;
  UBYTE          ncc_permitted;
  UBYTE          plmn_search_running;
#ifdef GPRS
  UBYTE          nc_sync_with_grr;
  UBYTE          nwctrl_meas_active; /* indicates whether averaging when NC=1,2 is active */
#endif
} T_ALR_DATA;

/*==== EXPORT =====================================================*/
/*
 *  Main Control
 */
EXTERN void ma_init                    (void);
/*
 *  Primitive processing functions for upper layer (RR)
 */
EXTERN void ma_mph_idle_req                 (T_MPH_IDLE_REQ                 *mph_idle_req);
EXTERN void ma_mph_neighbourcell_req        (T_MPH_NEIGHBOURCELL_REQ        *mph_neighbourcell_req);
EXTERN void ma_mph_emo_req                  (T_MPH_EMO_REQ                  *mph_emo_req);
EXTERN void ma_mph_dedicated_req            (T_MPH_DEDICATED_REQ            *mph_dedicated_req);
EXTERN void ma_mph_dedicated_fail_req       (T_MPH_DEDICATED_FAIL_REQ       *mph_dedicated_fail_req);
EXTERN void ma_mph_ciphering_req            (T_MPH_CIPHERING_REQ            *mph_ciphering_req);
EXTERN void ma_mph_freq_redef_req           (T_MPH_FREQ_REDEF_REQ           *mph_freq_redef_req);
EXTERN void ma_mph_channel_mode_req         (T_MPH_CHANNEL_MODE_REQ         *mph_channel_mode_req);
EXTERN void ma_mph_deactivate_req           (T_MPH_DEACTIVATE_REQ           *mph_deactivate_req);
EXTERN void ma_mph_classmark_req            (T_MPH_CLASSMARK_REQ            *mph_classmark_req);
EXTERN void ma_mph_ext_meas_req             (T_MPH_EXT_MEAS_REQ             *mph_ext_meas_req);
EXTERN void ma_mph_tch_loop_req             (T_MPH_TCH_LOOP_REQ             *mph_tch_loop_req);
EXTERN void ma_mph_dai_req                  (T_MPH_DAI_REQ                  *mph_dai_req);
EXTERN void ma_mph_cbch_req                 (T_MPH_CBCH_REQ                 *mph_cbch_req);
EXTERN void ma_mph_identity_req             (T_MPH_IDENTITY_REQ             *mph_identity_req);
EXTERN void ma_mph_power_req                (T_MPH_POWER_REQ                *mph_power_req);
EXTERN void ma_mph_bsic_req                 (T_MPH_BSIC_REQ                 *mph_bsic_req);
EXTERN void ma_mph_random_access_req        (T_MPH_RANDOM_ACCESS_REQ        *mph_random_access_req);
EXTERN void ma_mph_sync_req                 (T_MPH_SYNC_REQ                 *mph_sync_req);
EXTERN void ma_mph_ncell_pos_req            (T_MPH_NCELL_POS_REQ            *mph_ncell_pos_req);
EXTERN void ma_mph_clean_buf_req            (T_MPH_CLEAN_BUF_REQ            *mph_clean_buf_req);
EXTERN void ma_mph_stop_dedi_req            (T_MPH_STOP_DEDICATED_REQ       *mph_stop_dedi_req);
#ifdef GPRS
EXTERN void ma_mph_meas_rep_req             (T_MPH_MEAS_REP_REQ             *mph_meas_rep_req);
#endif
/*
 *  Primitive processing functions for lower layer
 */
EXTERN void ma_mphc_rxlev_ind               (T_MPHC_RXLEV_IND               *rxlev_ind);
EXTERN void ma_mphc_stop_rxlev_cnf          (T_MPHC_STOP_RXLEV_CON          *rxlev_con);
EXTERN void ma_mphc_empty_cnf               (void                           *);
EXTERN void ma_mphc_network_sync_ind        (T_MPHC_NETWORK_SYNC_IND        *network_sync_ind);
EXTERN void ma_cs_stop_network_sync_req     (void);
EXTERN void ma_mphc_new_scell_cnf           (T_MPHC_NEW_SCELL_CON           *new_Scell_cnf);
EXTERN void ma_mphc_ncell_bcch_ind          (T_MPHC_NCELL_BCCH_IND          *ncell_bcch_data_ind);
EXTERN void ma_mphc_ncell_sync_ind          (T_MPHC_NCELL_SYNC_IND          *ncell_sync_ind);
GLOBAL void ma_mphc_stop_ncell_sync_cnf     (T_MPHC_STOP_NCELL_SYNC_CON     *ncell_sync_cnf );
EXTERN void ma_mphc_rxlev_periodic_ind      (T_MPHC_RXLEV_PERIODIC_IND      *rxlev_periodic_ind);
EXTERN void ma_mphc_ra_cnf                  (T_MPHC_RA_CON                  *ra_cnf);
EXTERN void ma_mphc_data_ind                (T_MPHC_DATA_IND                *data_ind);
EXTERN void ma_mphc_change_frequency_cnf    (T_MPHC_CHANGE_FREQUENCY_CON    *change_frequency_cnf);
EXTERN void ma_mphc_async_ho_cnf            (T_MPHC_ASYNC_HO_CON            *async_ho_cnf);
EXTERN void ma_mphc_channel_assign_cnf      (T_MPHC_CHANNEL_ASSIGN_CON      *channel_assign_cnf);
EXTERN void ma_mphc_handover_fail_cnf       (T_MPHC_HANDOVER_FAIL_CON       *handover_fail_cnf);
EXTERN void ma_mphc_immed_assign_cnf        (T_MPHC_IMMED_ASSIGN_CON        *immed_assign_cnf);
EXTERN void ma_mphc_pre_sync_ho_cnf         (T_MPHC_PRE_SYNC_HO_CON         *pre_sync_ho_cnf);
EXTERN void ma_mphc_sync_ho_cnf             (T_MPHC_SYNC_HO_CON             *sync_ho_cnf);
EXTERN void ma_mphc_ta_fail_ind             (T_MPHC_TA_FAIL_IND             *ta_fail_ind);
EXTERN void ma_mphc_handover_finished_ind   (T_MPHC_HANDOVER_FINISHED       *handover_finished);
EXTERN void ma_mphc_meas_report_ind         (T_MPHC_MEAS_REPORT             *meas_report);
EXTERN void ma_mphc_adc_ind                 (T_MPHC_ADC_IND                 *adc_results);
EXTERN void ma_mphc_init_l1_cnf             (T_MPHC_INIT_L1_CON             *init_l1_cnf);
EXTERN void ma_mphc_stop_dedi_con           (T_MPHC_STOP_DEDICATED_CON      *stop_cnf);
#if defined(STOP_SYNC_TASK)
EXTERN void ma_mphc_stop_network_sync_cnf   (T_MPHC_STOP_NETWORK_SYNC_CON   *stop_network_sync_cnf);
#endif /* STOP_SYNC_TASK */
/* Signal processing functions for process Cell Selection */
EXTERN void ma_cs_init_l1_req               (UBYTE                           radio_band_config);
EXTERN void ma_cs_stop_network_sync_req     (void);
EXTERN void ma_cs_network_sync_req          (USHORT                          channel);
EXTERN void ma_cs_rxlev_req                 (void);
EXTERN void ma_cs_power_cnf                 (T_MPH_POWER_CNF                *mph_power_cnf);

/* Signal processing functions for process Neigbour Cell */
EXTERN void ma_nc_rxlev_periodic_req        (T_MPHC_RXLEV_PERIODIC_REQ      *update);
EXTERN void ma_nc_stop_ncell_bcch_req       (USHORT                          arfcn);
EXTERN void ma_nc_stop_ncell_sync_req       (USHORT                          arfcn);
EXTERN void ma_nc_sync_req                  (T_MPHC_NCELL_SYNC_REQ          *sync_req);
EXTERN void ma_nc_list_sync_req             (T_MPHC_NCELL_LIST_SYNC_REQ     *list_sync_req);
EXTERN void ma_nc_bcch_req                  (T_MPHC_NCELL_BCCH_REQ          *bcch_req);
EXTERN void ma_nc_update_ba_list            (T_MPHC_UPDATE_BA_LIST          *update_ba_list);
EXTERN void nc_new_serving_cell             (USHORT                          serving_cell);
EXTERN void ma_nc_report_res                (T_MPH_MEASUREMENT_IND          *mph_measurement_ind);

/* Signal processing functions for process RACH_Contol */
EXTERN void ma_rach_stop_ra_req             (void);
EXTERN void ma_rach_ra_req                  (T_MPHC_RA_REQ                  *mph_ra_req);
EXTERN void ma_rach_random_cnf              (T_MPH_RANDOM_ACCESS_CNF        *mph_random_access_cnf);

/* Signal processing functions for process Dedi_Control */
EXTERN void ma_dedi_stop_req (void);
EXTERN void ma_dedi_cnf (UBYTE cause);
EXTERN void ma_dedi_chan_ass_req (T_MPHC_CHANNEL_ASSIGN_REQ *mphc_channel_assign_req);
EXTERN void ma_dedi_async_ho_req (T_MPHC_ASYNC_HO_REQ *async_ho_req);
EXTERN void ma_dedi_sync_ho_req (T_MPHC_SYNC_HO_REQ *sync_ho_req);
EXTERN void ma_dedi_pre_sync_ho_req (T_MPHC_PRE_SYNC_HO_REQ *pre_sync_ho_req);
EXTERN void ma_dedi_fail_cnf (void);
EXTERN void ma_dedi_ho_fail_req (void);
EXTERN void ma_dedi_imm_ass_req (T_MPHC_IMMED_ASSIGN_REQ *immed_assign_req);
EXTERN void ma_dedi_change_freq_req (T_MPHC_CHANGE_FREQUENCY *change_frequency);
EXTERN void ma_dedi_chan_mode_req (T_MPHC_CHANNEL_MODE_MODIFY_REQ *channel_mode_modify_req);
EXTERN void ma_dedi_ciph_req (T_MPHC_SET_CIPHERING_REQ *set_ciphering_req);
EXTERN void ma_dedi_start_dai_req (T_OML1_START_DAI_TEST_REQ *oml1_start_dai_test_req);
EXTERN void ma_dedi_close_tch_loop_req (T_OML1_CLOSE_TCH_LOOP_REQ *oml1_close_tch_loop_req);
EXTERN void ma_dedi_stop_dai_req (void);
EXTERN void ma_dedi_open_tch_loop_req (void);

/* Signal processing functions for process PCH_control */
EXTERN void ma_pch_start_ccch_req           (T_MPHC_START_CCCH_REQ          *pl_idle);
EXTERN void ma_pch_paging_ind               (UBYTE                           id_type,
                                             UBYTE                           channel_needed);
EXTERN void ma_pch_stop                     (void);

/* Signal processing functions for process MMI_control */
EXTERN void ma_mmi_cbch_req                 (T_MMI_CBCH_REQ                 *cbch_req);
EXTERN void ma_mmi_sat_cbch_dwnld_req       (T_MMI_SAT_CBCH_DWNLD_REQ        *cbch_req);
/* Signal processing functions for process CBCH_control */
EXTERN void ma_cb_stop_cbch_req             (void);
EXTERN void ma_cb_sched_req                 (T_MPHC_CBCH_SCHEDULE_REQ       *sched_req);
EXTERN void ma_cb_config_cbch               (T_MPHC_CONFIG_CBCH_REQ         *config_cbch);
EXTERN void ma_cb_mmi_cbch_ind              (T_MMI_CBCH_IND                 *mmi_cbch_ind);
EXTERN void ma_cb_info_req                  (UBYTE                           bitmap);

/* Signal processing functions used by more then one process */
EXTERN void ma_scell_nbcch_req              (T_MPHC_SCELL_NBCCH_REQ         *nbcch_req);
EXTERN void ma_scell_ebcch_req              (T_MPHC_SCELL_EBCCH_REQ         *ebcch_req);
EXTERN void ma_stop_scell_bcch_req          (void);
EXTERN void ma_stop_active_procs            (UBYTE flags);
EXTERN void ma_bsic_cnf                     (T_MPH_BSIC_CNF                 *mph_bsic_cnf);
EXTERN void ma_send_unitdata                (T_MPHC_DATA_IND                *data_ind);
EXTERN void ma_error_ind                    (UBYTE                           cause,
                                             USHORT                          arfcn);
EXTERN void ma_clean_dedi_sys_buffer        (void);
EXTERN void ma_new_scell_req                (T_MPHC_NEW_SCELL_REQ           *new_scell);
EXTERN void ma_scell_full_nbcch             (void);
#ifdef GPRS
EXTERN BOOL ma_is_ptm                       (void);
EXTERN void ma_nc_rxlev_sc_req              (T_TB_RXLEV_SC_REQ              *rxlev_sc_req);
#endif
EXTERN void ma_clean_sys_buffer             (USHORT                          si_mask);

/* defined in dl_pei.c */
EXTERN void dl1_downlink_indication         (UBYTE                           chan,
                                             UBYTE                          *frame);

/*
 *  CBCH Control
 */
EXTERN void   cb_init                       (void);
EXTERN void   cb_stop                       (void);
EXTERN void   cb_start                      (void);
EXTERN void   cb_mmi_cbch_req               (T_MMI_CBCH_REQ                  *cbch);
EXTERN void   cb_mph_cbch_req               (T_cbch                          *cbch);
EXTERN void   cb_data_ind                   (T_MPHC_DATA_IND                 *cbch_ind);
EXTERN void   cb_mmi_sat_cbch_req           (T_MMI_SAT_CBCH_DWNLD_REQ        *cbch_req);
#if defined(FF_HOMEZONE)
EXTERN void   cb_tim_homezone (void);
#endif  /* FF_HOMEZONE */

/*
 *  Cell Selection
 */
EXTERN void   cs_init                       (void);
EXTERN void   cs_rxlev_ind                  (T_MPHC_RXLEV_IND               *rxlev_ind);
EXTERN void   cs_network_sync_ind           (T_MPHC_NETWORK_SYNC_IND        *network_sync_ind);
EXTERN void   cs_stop                       (void);
EXTERN T_POWER_MEAS* cs_prepare_power_req   (void);
EXTERN void   cs_power_req                  (UBYTE                           pch_interrupt);
EXTERN void   cs_bsic_req                   (T_MPH_BSIC_REQ                 *mph_bsic_req);
EXTERN void   cs_read_scell_bcch            (void);
EXTERN UBYTE  get_band                      (USHORT                          arfcn);
EXTERN void   cs_increment_bfc              (void);
EXTERN void   cs_decrement_bfc              (void);
EXTERN void   cs_set_wideband_sync          (void);

/*
 *  Dedicated Control
 */
EXTERN void   dedi_init                     (void);
EXTERN void   dedi_req                      (T_MPH_DEDICATED_REQ            *dedicated_req);
EXTERN void   dedi_fail_req                 (void);
EXTERN void   dedi_ta_fail_ind              (void);
EXTERN void   dedi_ho_finished              (UBYTE                           cause);
EXTERN void   dedi_freq_redef_req           (T_MPH_FREQ_REDEF_REQ           *freq);
EXTERN void   dedi_chan_mode_req            (T_MPH_CHANNEL_MODE_REQ         *ch_mode);
EXTERN void   dedi_ciph_req                 (T_MPH_CIPHERING_REQ            *ciph_req);
EXTERN void   dedi_tch_loop_req             (T_MPH_TCH_LOOP_REQ             *tloop);
EXTERN void   dedi_dai_req                  (T_MPH_DAI_REQ                  *dai);
EXTERN void   dedi_change_freq_cnf          (void);
EXTERN void   dedi_async_ho_cnf             (void);
EXTERN void   dedi_chan_ass_cnf             (void);
EXTERN void   dedi_ho_fail_cnf              (void);
EXTERN void   dedi_imm_ass_cnf              (void);
EXTERN void   dedi_pre_sync_ho_cnf          (void);
EXTERN void   dedi_sync_ho_cnf              (void);
EXTERN void   dedi_stop                     (void);
EXTERN void   dedi_increment_rlt            (void);
EXTERN void   dedi_decrement_rlt            (void);

/*
 *  MMI Control
 */
EXTERN USHORT RX_GetValue                   (void);

/*
 *  Idle Mode Neighbour Cell
 */
EXTERN void   nc_init                       (void);
EXTERN void   nc_ncell_list                 (T_MPH_NEIGHBOURCELL_REQ        *mph_neighbourcell_req);
EXTERN void   nc_stop                       (void);
EXTERN void   nc_bsic_req                   (T_MPH_BSIC_REQ                 *mph_bsic_req);
EXTERN void   nc_sync_ind                   (T_MPHC_NCELL_SYNC_IND          *sync_ind);
EXTERN void   nc_bcch_ind                   (T_MPHC_NCELL_BCCH_IND          *data_ind);
EXTERN void   nc_start_dedicated            (UBYTE                           pwrc,
                                             UBYTE                           dtx);
EXTERN void   nc_update_dedicated           (UBYTE                           dtx,
                                             UBYTE                           pwrc);
EXTERN void   nc_update_list                (USHORT                          channel);
EXTERN BOOL   nc_get_fn_time                (USHORT                          channel,
                                             ULONG                           *fn,
                                             ULONG                           *time);
EXTERN void   nc_suspend                    (void);
EXTERN void   nc_add_offset                 (void);
EXTERN void   nc_report                     (T_MPHC_RXLEV_PERIODIC_IND      *rxlev_periodic_ind);
EXTERN void   nc_start_reselect             (USHORT                          arfcn);
EXTERN void   nc_start_monitoring           (void);
EXTERN void   nc_report_dedicated           (T_MPHC_MEAS_REPORT             *meas_report);
EXTERN void   nc_fill_report_sc_dedi        (T_MPH_MEASUREMENT_IND          *rr_report,
                                             UBYTE                           ncells);
EXTERN void   nc_store_tav                  (USHORT                          tav);
EXTERN void   nc_check_new_ncc_permitted    (UBYTE                           new_ncc_permitted);
EXTERN void   nc_stop_rr_activity           (UBYTE                           stop);
EXTERN void   nc_stop_ext_meas_ind          (void);
EXTERN void   nc_resume                     (void);
EXTERN void   nc_check_activity             (void);
EXTERN void   nc_set_status                 (USHORT                          index,
                                             UBYTE                           new_status);
EXTERN USHORT  nc_get_index                 (USHORT arfcn);
EXTERN void    nc_ncsync_tim_expiry         (void);
EXTERN void    nc_ncell_pos_req             (T_MPH_NCELL_POS_REQ*            pos_req);
GLOBAL void nc_resume_dedicated(void);
GLOBAL void nc_suspend_handover (void);

#ifdef GPRS
EXTERN void    nc_start_pbcch(void);
EXTERN void    nc_build_nwctrl_rr_report    (T_MPH_MEAS_REP_CNF             *rr_report);
#endif
/*
 *  PCH Control
 */
EXTERN void   pch_init                      (void);
EXTERN void   pch_configure                 (T_MPH_IDLE_REQ                 *idle,
                                             UBYTE page_mode);
EXTERN void   pch_start_ccch_req            (void);
EXTERN void   pch_save_pgm                  (UBYTE                           mode);
EXTERN void   pch_identity_req              (T_MPH_IDENTITY_REQ             *mph_identity_req);
EXTERN void   pch_check_pag_3               (T_MPHC_DATA_IND                *data_ind);
EXTERN void   pch_check_pag_2               (T_MPHC_DATA_IND                *data_ind);
EXTERN void   pch_check_pag_1               (T_MPHC_DATA_IND                *data_ind);
EXTERN void   pch_check_page_mode           (T_MPHC_DATA_IND                *data_ind);
EXTERN void   pch_check_page_mode_cr        (T_MPHC_DATA_IND                *data_ind);
EXTERN void   pch_decrement_dlt             (void);
EXTERN void   pch_increment_dlt             (void);
EXTERN void   pch_stop                      (void);
EXTERN UBYTE  pch_mode_reorg                (void);
EXTERN void   pch_config_resel              (T_MPHC_DATA_IND                *data_ind);
/*
 *  RACH Control
 */
EXTERN void   rach_init                     (void);
EXTERN void   rach_configure_power          (UBYTE                           power);
EXTERN void   rach_configure_class          (UBYTE                           class,
                                             UBYTE                           dcs_class);
EXTERN void   rach_stop                     (void);
EXTERN UBYTE  cut_power_value               (UBYTE                           power,
                                             T_MPH_DEDICATED_REQ            *mph_dedicated_req);

EXTERN void   rach_random_req               (T_MPH_RANDOM_ACCESS_REQ        *random_req);
EXTERN void   rach_ra_cnf                   (T_MPHC_RA_CON*                  ra_cnf);

/*
 *  Idle Mode Serving Cell
 */
EXTERN void   sc_start_periodic             (void);
EXTERN const void csf_show_version (T_TST_TEST_HW_CON  *ver);
EXTERN void   tim_stop_sync_to_nw           (void);



EXTERN UBYTE  grlc_test_mode_active(void);				/*lint -esym(526,grlc_test_mode_active) : not defined | defined in other entity */
EXTERN void   cst_pei_config (char *, char *);		/*lint -esym(526,cst_pei_config)       : not defined | defined in other entity */
#if defined (_SIMULATION_)
EXTERN void rr_csf_check_rfcap (UBYTE init);			/*lint -esym(526,rr_csf_check_rfcap)   : not defined | defined in other entity */
#endif  /* _SIMULATION_ */
EXTERN CHAR* alr_version(void);

#if defined(ALR_CSF_C) && defined(_TMS470)
EXTERN void  Cust_Init_Layer1(void);
EXTERN void  SIM_PowerOff (void);
EXTERN void  TM_EnableWatchdog (void);
EXTERN void  TM_ResetWatchdog(SYS_UWORD16 count);
#endif  /* ALR_CSF_C && _TMS470 */

#if defined(WIN32)
#include <stdio.h>  /* prototype of sprintf() */
#endif  /* WIN32 */

#if !defined NTRACE
EXTERN void trc_mon_counter_idle (UBYTE act_dlt, UBYTE max_dlt);
EXTERN void trc_mon_counter_dedi (UBYTE act_rlt, UBYTE max_rlt);
#endif /* (!defined NTRACE ) */



EXTERN T_ALR_DATA * alr_data;
#ifdef WIN32
  EXTERN T_POWER_MEAS tap_rxlev_response_european[];
  EXTERN T_POWER_MEAS tap_rxlev_response_american[];
#endif

#define ENTITY_DATA                alr_data

/*
 * If all entities are linked into one module this definitions
 * prefixes the global data with the enity name
 */
#ifdef OPTION_MULTITHREAD
  #define hCommL1         _ENTITY_PREFIXED(hCommL1)
  #define hCommPL         _ENTITY_PREFIXED(hCommPL)
  #define hCommDL         _ENTITY_PREFIXED(hCommDL)
  #define hCommRR         _ENTITY_PREFIXED(hCommRR)
  #define hCommMMI        _ENTITY_PREFIXED(hCommMMI)
  #define hCommCST        _ENTITY_PREFIXED(hCommCST)
#ifdef GPRS
  #define hCommGPL        _ENTITY_PREFIXED(hCommGPL)
#endif /* #ifdef GPRS */
#endif

EXTERN T_HANDLE  hCommPL;              /* PL   own handle          */
EXTERN T_HANDLE  hCommL1;              /* L1   Communication       */
EXTERN T_HANDLE  hCommDL;              /* DL   Communication       */
EXTERN T_HANDLE  hCommRR;              /* RR   Communication       */
EXTERN T_HANDLE  hCommMMI;             /* MMI  Communication       */
EXTERN T_HANDLE  hCommCST;             /* CST  Communication       */
#ifdef GPRS
EXTERN T_HANDLE  hCommGPL;             /* GPL  Communication       */
#endif /* GPRS */
EXTERN T_HANDLE  pl_handle;

EXTERN UBYTE          v_mon_counter_idle;
EXTERN UBYTE          v_mon_counter_dedi;
EXTERN UBYTE          v_eotd;

#if defined(DL_TRACE_ENABLED)
  EXTERN void dl_trace                   (UCHAR                    trace_type,
                                          UCHAR                    channel,
                                          UCHAR                    ch_type,
                                          UCHAR                  * data);
  #ifdef OPTION_MULTITHREAD
    #define dl_trace_buf    _ENTITY_PREFIXED(dl_trace_buf)
  #endif
  #if defined(ALR_MAIN_C)
    GLOBAL char dl_trace_buf[100];
  #else  /* ALR_MAIN_C */
    EXTERN char dl_trace_buf[100];
  #endif  /* ALR_MAIN_C */
  #define TRACE_PL_EVENT   4
  #define DOES_NOT_MATTER  0
  #define DL_OFFLINE_TRACE(s) \
    dl_trace (TRACE_PL_EVENT, DOES_NOT_MATTER, DOES_NOT_MATTER, (UCHAR*)s)
#else  /* DL_TRACE_ENABLED */
  #define DL_OFFLINE_TRACE(s)
#endif  /* DL_TRACE_ENABLED */

#if !defined(NCONFIG) && !defined(NTRACE) && defined(TRACE_STATE_TRANSITION)
void trc_state_transition(int line, UBYTE newstate);
#else
#define trc_state_transition(line,newstate)
#endif  /* !NCONFIG && !NTRACE && TRACE_STATE_TRANSITION */

#if defined(_SIMULATION_)
#define TRACING
#define TRACE_EVENT_WIN(s)                                TRACE_EVENT(s)
#define TRACE_EVENT_WIN_P1(s,a1)                          TRACE_EVENT_P1(s,a1)
#define TRACE_EVENT_WIN_P2(s,a1,a2)                       TRACE_EVENT_P2(s,a1,a2)
#define TRACE_EVENT_WIN_P3(s,a1,a2,a3)                    TRACE_EVENT_P3(s,a1,a2,a3)
#define TRACE_EVENT_WIN_P4(s,a1,a2,a3,a4)                 TRACE_EVENT_P4(s,a1,a2,a3,a4)
#define TRACE_EVENT_WIN_P5(s,a1,a2,a3,a4,a5)              TRACE_EVENT_P5(s,a1,a2,a3,a4,a5)
#define TRACE_EVENT_WIN_P6(s,a1,a2,a3,a4,a5,a6)           TRACE_EVENT_P6(s,a1,a2,a3,a4,a5,a6)
#define TRACE_EVENT_WIN_P7(s,a1,a2,a3,a4,a5,a6,a7)        TRACE_EVENT_P7(s,a1,a2,a3,a4,a5,a6,a7)
#define TRACE_EVENT_WIN_P8(s,a1,a2,a3,a4,a5,a6,a7,a8)     TRACE_EVENT_P8(s,a1,a2,a3,a4,a5,a6,a7,a8)
#define TRACE_EVENT_WIN_P9(s,a1,a2,a3,a4,a5,a6,a7,a8,a9)  TRACE_EVENT_P9(s,a1,a2,a3,a4,a5,a6,a7,a8,a9)
#else  /* _SIMULATION_ */
#define TRACE_EVENT_WIN(s)
#define TRACE_EVENT_WIN_P1(s,a1)
#define TRACE_EVENT_WIN_P2(s,a1,a2)
#define TRACE_EVENT_WIN_P3(s,a1,a2,a3)
#define TRACE_EVENT_WIN_P4(s,a1,a2,a3,a4)
#define TRACE_EVENT_WIN_P5(s,a1,a2,a3,a4,a5)
#define TRACE_EVENT_WIN_P6(s,a1,a2,a3,a4,a5,a6)
#define TRACE_EVENT_WIN_P7(s,a1,a2,a3,a4,a5,a6,a7)
#define TRACE_EVENT_WIN_P8(s,a1,a2,a3,a4,a5,a6,a7,a8)
#define TRACE_EVENT_WIN_P9(s,a1,a2,a3,a4,a5,a6,a7,a8,a9)
#endif  /* _SIMULATION_ */

#if defined TRACING
#define ALR_TRACE(a) vsi_o_ttrace(VSI_CALLER TC_EVENT,a);
#else
#define ALR_TRACE(a)
#endif  /* TRACING */

#define TNNN_WITH_TIMER

/*
#define ALR_TRACE_ENABLED
*/
#if defined(ALR_TRACE_ENABLED)
  void alr_trc_init (void);
  void alr_trc_exit (void);
  void alr_trc_store (UCHAR event, UCHAR channel, UCHAR state, void* l2_data);
  void alr_trc_read_all (void);
  void alr_trc_read (int count);
#else  /* ALR_TRACE_ENABLED */
#define alr_trc_init()
#define alr_trc_exit()
#define alr_trc_store(e,c,s,p)
#define alr_trc_read(c)
#define alr_trc_read_all()
#endif  /* ALR_TRACE_ENABLED */

/*
 * ALR TRACE defines
 */
#define ALR_TRC_UPLINK        0
#define ALR_TRC_DOWNLINK      1
#define ALR_TRC_EVENT         2
#define ALR_TRC_STRING        3

#define ALR_TRC_CH_UNDEF      0
#define ALR_TRC_CH_FACCH_FR   1
#define ALR_TRC_CH_FACCH_HR   2
#define ALR_TRC_CH_SDCCH4     3
#define ALR_TRC_CH_SDCCH8     4
#define ALR_TRC_CH_SACCH      5
#define ALR_TRC_CH_UNKNOWN    6

#define ALR_TRC_DATA_SIZE     40

#define ALR_RXLEV_AVERAGE_MIN 0
#define ALR_RXLEV_AVERAGE_LWR_THR 4

#endif  /* ALR_H */