diff src/g23m-gsm/alr2/alr.h @ 3:b4c81ea2d291

src/g23m-gsm/alr2: initial import from Magnetite
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 15 Jul 2018 04:43:28 +0000
parents
children 935692f51b38
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gsm/alr2/alr.h	Sun Jul 15 04:43:28 2018 +0000
@@ -0,0 +1,1463 @@
+/*
++-----------------------------------------------------------------------------
+|  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 */