--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gsm/rr/rr_datf.c	Tue Oct 04 18:24:05 2016 +0000
@@ -0,0 +1,3533 @@
+/*
++-----------------------------------------------------------------------------
+|  Project :
+|  Modul   :
++-----------------------------------------------------------------------------
+|  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 :  This module defines the functions for the data transfer
+|             capability of the module Radio Resource.
++-----------------------------------------------------------------------------
+*/
+
+#ifndef RR_DATF_C
+#define RR_DATF_C
+
+#define ENTITY_RR
+
+/*==== INCLUDES ===================================================*/
+
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>     /* offsetof */
+#include "typedefs.h"
+#include "pcm.h"
+#include "pconst.cdg"
+#include "mconst.cdg"
+#include "message.h"
+#include "ccdapi.h"
+#include "vsi.h"
+#include "custom.h"
+#include "gsm.h"
+#include "prim.h"
+#include "cnf_rr.h"
+#include "tok.h"
+#include "rr.h"
+#include "rr_em.h"
+
+/*==== EXPORT =====================================================*/
+
+/*==== PRIVATE ====================================================*/
+static void  dat_fill_mobile_identity    (USHORT              fill_type,
+                                          T_mob_ident         *moid);
+static BOOL  dat_eplmn_equal_req         (const UBYTE *mcc,
+                                          const UBYTE *mnc);
+static void  dat_get_background_and_bits (UBYTE               *background,
+                                          UBYTE               *bits);
+static UBYTE dat_get_burst               (UBYTE               background,
+                                          UBYTE               bits);
+static UBYTE dat_get_delta               (UBYTE               i);
+static UBYTE dat_get_ncell_pos           (USHORT              channel);
+static BOOL  dat_hplmn_country           (const UBYTE         *mcc);
+static SHORT dat_imsi_mod_1000           (void);
+static SHORT dat_no_of_paging_blocks     (UBYTE               index);
+static BOOL  dat_owner_of_auth_0_to_9    (void);
+static BOOL  dat_owner_of_auth_11_to_15  (void);
+static void  dat_send_random_bursts      (void);
+
+typedef struct  CODE_TABLE
+{
+  USHORT  cause;
+  UBYTE   last_channel;
+  UBYTE   neci_flag;
+  UBYTE   channel_needed;
+  UBYTE   ms_capability;
+  UBYTE   tch_f_needed;
+  UBYTE   background;
+  UBYTE   bits;
+} CODE_TABLE ;
+
+typedef struct CONVER_TXINTEGER
+{
+  USHORT  t;
+  USHORT  s_non_combined;
+  USHORT  s_combined;
+} CONVERT_TXINTEGER;
+
+/*==== VARIABLES ==================================================*/
+
+/*==== FUNCTIONS ==================================================*/
+
+
+/*
+ * -------------------------------------------------------------------
+ * Procedures
+ * -------------------------------------------------------------------
+ */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_access_allowed         |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function decides whether the access to the network is 
+            allowed or not. 
+            (GSM 4.18, chapter 3.3.1.1.1 Permission to access the network).
+
+*/
+
+GLOBAL BOOL dat_access_allowed (USHORT    establish_cause)
+{
+  GET_INSTANCE_DATA;
+  BOOL  result      = TRUE;
+
+  TRACE_FUNCTION ("dat_access_allowed()");
+
+#if defined (_SIMULATION_)
+  TRACE_EVENT_P1 ("ACC CLASS BCCH = %4x", rr_data->nc_data[SC_INDEX].rach.ac);
+  TRACE_EVENT_P1 ("ACC CLASS SIM  = %4x", rr_data->ms_data.access_classes);
+#endif
+
+  if (establish_cause EQ ESTCS_EMERGENCY_CALL)
+  {
+    /*
+     * if it is an emergency call the corresponding flag
+     * in the random access control parameters must be set
+     */
+    if (rr_data->nc_data[SC_INDEX].rach.ac & 0x0400)
+      result = FALSE;
+
+    /*
+     * or the MS must be member of one of the special classes
+     * defined on the SIM card.
+     */
+    if (result EQ FALSE)
+    {
+      result = dat_owner_of_auth_11_to_15 ();
+    }
+  }
+  else
+  {
+    /*
+     * for non-ememrgency calls
+     */
+
+    /*
+     * Normally, the whole check here should not be necessary as MM
+     * should know about limited service condition and not try to
+     * update in automatic mode or to establish a non-emergency CM service.
+     * So the check here is superflous, but if it catches, MM has a problem
+     * as it will think the cell is temporary barred and will wait for the
+     * barr state to change, not indicating limited service to the MMI under
+     * certain circumstances. It seems so that here something was fixed at
+     * the wrong place.
+     * The old condition was: if (dat_forbidden_lai_check (SC_INDEX))
+     */
+    if(
+         (establish_cause EQ ESTCS_LOCATION_UPDATING)
+           AND
+         ((rr_data->ms_data.operation_mode & 0x40) EQ 0x40)
+      )
+    {
+      /*
+        * Do not barr access for MM procedure establishment if we are in manual
+        * mode. This was previously bypassed within dat_forbidden_lai_check()
+        * function but was leading to incorrect cell reselection whilst RR
+        * was in manual.
+        * If MM wants to perform a LU at this place it means that user manually
+        * selected this network and is then allowed to attempt registration. If
+        * we reseleted on a LAC forbidden for provision of regional service, MM
+        * is switched to limited service so no normal LU will be triggered.
+        */
+      if (dat_owner_of_auth_0_to_9 ())
+        result = TRUE;
+      else
+        result = dat_owner_of_auth_11_to_15 ();
+    }
+    else if ( rr_data->ms_data.rr_service EQ LIMITED_SERVICE)
+    {
+      /*
+        * RR is in limited service.
+        * Only emergency calls are allowed in this state
+        */
+       result = FALSE;
+    }
+    else if (
+                 dat_forb_lai_check (SC_INDEX)
+                   AND
+                 dat_roam_forb_lai_check (SC_INDEX)
+               )
+    {
+      /*
+       * if RR is not inside of a forbidden location area,
+       * the MS must be member of one of the normal or one
+       * of the special classes stored on the SIM card.
+       */
+      if (dat_owner_of_auth_0_to_9 ())
+        result = TRUE;
+      else
+        result = dat_owner_of_auth_11_to_15 ();
+
+    }
+    else
+    {
+      /*
+       * if RR is inside of a forbidden location area
+       * no normal calls are allowed
+       */
+      TRACE_ERROR ("Unexpected, MM doesn't know its service state.");
+      result = FALSE;
+    }
+  }
+
+  return (result);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_calc_downlink_timeout  |
++--------------------------------------------------------------------+
+
+  PURPOSE : The downlink signalling failure criterion is based on the
+            downlink signalling failure counter DSC. When the MS
+            camps on a cell, DSC shall be initialized to a value equal
+            to the nearest integer to 90/N where N is the BS_PA_MFRMS
+            parameter for that cell (GSM 5.08, chapter 6.5 Downlink
+            Signalling Failure).
+
+*/
+
+GLOBAL UBYTE dat_calc_downlink_timeout (UBYTE     index)
+{
+  GET_INSTANCE_DATA;
+  UBYTE divisor;
+  UBYTE dl=0;
+
+  TRACE_FUNCTION ("dat_calc_downlink_timeout()");
+
+  /*
+   * The stored value for BS_PA_MFRMS is in air-interface coding.
+   * To get the real value a value of 2 must be added
+   */
+  divisor = rr_data->nc_data[index].control_descr.bs_pa_mfrms + 2;
+
+  /*
+   * calculate the initial value for the downlink signalling counter.
+   */
+  TRACE_ASSERT(divisor NEQ 0);
+  if(divisor NEQ 0)
+  {
+    dl = 90 / divisor;
+  }
+
+  /*
+   * correct rounding failures
+   *
+   * BS_PA_MFRMS =   2   -> 90/2   = 45
+   *                 3   -> 90/3   = 30
+   *                 4   -> 90/4   = 22.5   -> 23
+   *                 5   -> 90/5   = 18
+   *                 6   -> 90/6   = 15
+   *                 7   -> 90/7   = 12.85  -> 13
+   *                 8   -> 90/8   = 11.25
+   *                 9   -> 90/9   = 10
+   */
+  if (divisor EQ 4 OR divisor EQ 7)
+  {
+    dl++;
+  }
+  return (dl);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_calc_paging_group      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Calculation of paging group is described in GSM 5.02,
+            chapter 6.5.2.
+
+            PAGING_GROUP (0 .. N-1) = ((IMSI mod 1000) mod (BS_CC_CHANS x N)) mod N
+
+            where
+
+            N = number of paging blocks "available" on one CCCH =
+                (number of paging blocks "available" in a 51-multiframe
+                 on one CCCH) x BS_PA_MFRMS.
+
+            IMSI = International Mobile Subscriber Identity, as defined in GSM 03.03.
+
+            mod = Modulo.
+
+*/
+
+GLOBAL UBYTE dat_calc_paging_group (UBYTE     index)
+{
+  GET_INSTANCE_DATA;
+  /*
+   * calculation of the number of paging blocks
+   */
+  SHORT n = dat_no_of_paging_blocks (index);
+
+  /*
+   * calculation of IMSI modulo 1000
+   */
+  SHORT a = dat_imsi_mod_1000 ();
+
+  /*
+   * calculation of BS_CC_CHANS * N (GSM 5.02 section 3.3.2.3)
+   */
+  SHORT b = ((rr_data->nc_data[index].control_descr.ccch_conf / 2) + 1) * n;
+
+  TRACE_FUNCTION ("dat_calc_paging_group()");
+
+  /*
+   * calculation of the paging group
+   */
+  return ((UBYTE) ((a % b) % n));
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_calc_tn                |
++--------------------------------------------------------------------+
+
+  PURPOSE : Determination of the timeslot of the paging block for the
+            MS in idle mode is described in GSM 5.02, chapter 6.5.2
+
+            The formula for calculation of the CCCH group must be used.
+            The dependency between timeslot and CCCH group is
+
+            tn = 2 * CCCH_GROUP
+
+            CCCH_GROUP (0 .. BS_CC_CHANS-1) = ((IMSI mod 1000) mod (BS_CC_CHANS x N)) div N
+
+            where
+
+            N = number of paging blocks "available" on one CCCH =
+                (number of paging blocks "available" in a 51-multiframe
+                on one CCCH) x BS_PA_MFRMS.
+
+            IMSI = International Mobile Subscriber Identity, as defined in GSM 03.03.
+
+            mod = Modulo.
+
+            div = Integer division.
+
+*/
+
+GLOBAL UBYTE dat_calc_tn (UBYTE      index)
+{
+  GET_INSTANCE_DATA;
+  /*
+   * calculate the number of paging blocks
+   */
+  SHORT n = dat_no_of_paging_blocks (index);
+
+  /*
+   * calculate IMSI modulo 1000
+   */
+  SHORT a = dat_imsi_mod_1000 ();
+
+  /*
+   * calculate BS_CC_CHANS * N (GSM 5.02 section 3.3.2.3)
+   */
+  SHORT b = ((rr_data->nc_data[index].control_descr.ccch_conf / 2) + 1) * n;
+
+  TRACE_FUNCTION ("dat_calc_tn()");
+
+  /*
+   * calculate the timeslot
+   */
+  return ((UBYTE) ((a % b) / n) * 2);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_check_error_flag       |
++--------------------------------------------------------------------+
+
+  PURPOSE : In the formatter module several tests are performed to
+            check the syntax and the semantic of the incoming messages.
+            The results of this checks are stored in the error variables.
+            This function sends a RR STATUS message back to the network
+            if a mandatory or conditional error has been detected for
+            a message received in acknowledged mode. It indicates to the
+            calling function whether the message shall be ignored or not.
+
+*/
+
+GLOBAL BOOL dat_check_error_flag (BOOL      send_rr_status)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_check_error_flag()");
+
+  /*
+   * if an error unequal to optional info error has occured
+   */
+  if (rr_data->ms_data.error.cs NEQ 0 AND
+      rr_data->ms_data.error.cs NEQ OPTIONAL_INFO_ERROR)
+  {
+
+  
+    if (send_rr_status)
+    {
+      /*
+       * if the message has been received in acknowledged mode,
+       * answer to the network with a RR STATUS message.
+       */
+/* Implements RR Clone findings #23 */
+      dat_send_rr_status_msg(rr_data->ms_data.error.cs);
+
+ 
+    }
+   
+  }
+
+  switch (rr_data->ms_data.error.cs)
+  {
+    /* case RRC_INVALID_MAN_INFO: this value is currently never set */
+    case RRC_INCORRECT_MSG:
+    case RRC_COND_IE_ERROR:
+      /*
+       * Major failure in the message, ignore it
+       */
+      return FALSE;
+
+    default:
+      /*
+       * minor or no failure, process the message
+       */
+      return TRUE;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_channel_mode_to_mm|
++--------------------------------------------------------------------+
+
+  PURPOSE : A changed channel mode is signalled to MM.
+
+*/
+
+GLOBAL void dat_code_channel_mode_to_mm  (void)
+{
+  GET_INSTANCE_DATA;
+  PALLOC (sync_ind, RR_SYNC_IND);
+
+  TRACE_FUNCTION ("dat_code_channel_mode_to_mm()");
+
+  /*
+   * set the channel type
+   */
+  switch (rr_data->sc_data.chan_desc.chan_type)
+  {
+    case CH_TCH_F:
+      TRACE_EVENT ("TCH/F configured");
+      sync_ind->chm.ch_type  = CH_TCH_F;
+      break;
+    case CH_TCH_H_1:
+    case CH_TCH_H_2:
+      TRACE_EVENT ("TCH/H configured");
+      sync_ind->chm.ch_type  = CH_TCH_H;
+      break;
+    default:
+      TRACE_EVENT ("SDCCH configured");
+      sync_ind->chm.ch_type = CH_SDCCH;
+      break;
+  }
+
+  /*
+   * set the rest of the parameters
+   */
+  sync_ind->ciph             = NOT_PRESENT_8BIT;
+  sync_ind->chm.ch_mode      = rr_data->sc_data.ch_mode;
+  memset(&sync_ind->mm_info, 0, sizeof(T_mm_info));
+  sync_ind->mm_info.valid    = FALSE;
+  memset(&sync_ind->bcch_info, 0, sizeof(T_bcch_info));
+  sync_ind->bcch_info.v_bcch = FALSE;
+  sync_ind->synccs           = NOT_PRESENT_16BIT;
+
+  PSENDX(MM, sync_ind);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_ciphering_to_mm   |
++--------------------------------------------------------------------+
+
+  PURPOSE : A changed ciphering mode is signalled to MM.
+
+*/
+
+GLOBAL void dat_code_ciphering_to_mm (UBYTE ciph_on)
+{
+  PALLOC (sync_ind, RR_SYNC_IND);
+
+  TRACE_FUNCTION ("dat_code_ciphering_to_mm()");
+
+  /*
+   * set the new cipher mode
+   */
+  sync_ind->ciph             = ciph_on;
+
+  /*
+   * clear the rest of the parameters
+   */
+  sync_ind->chm.ch_mode      = NOT_PRESENT_8BIT;
+  memset(&sync_ind->mm_info, 0, sizeof(T_mm_info));
+  sync_ind->mm_info.valid    = FALSE;
+  memset(&sync_ind->bcch_info, 0, sizeof(T_bcch_info));
+  sync_ind->bcch_info.v_bcch = FALSE;
+  sync_ind->synccs           = NOT_PRESENT_16BIT;
+
+  PSENDX(MM, sync_ind);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : RR_DAT                        |
+| STATE   : code             ROUTINE : dat_code_reestablishment_fail |
++--------------------------------------------------------------------+
+
+  PURPOSE : Indicate a failed call reestablishment to MM. If a radio
+            link failure has occured, RR performs a cell reselection
+            to come back to idle mode and then the reestablishment may
+            starts. If no suitable cell is available, it may takes
+            a long time until no service is signalled. This function is
+            used to finish the reestablish earlier, if no candidate
+            is available during coming back from dedicated.
+
+*/
+
+GLOBAL void dat_code_reestablishment_fail (void)
+{
+  GET_INSTANCE_DATA;
+  T_NC_DATA *rrd = &rr_data->nc_data[SC_INDEX];
+
+  PALLOC (sync_ind, RR_SYNC_IND);
+
+  TRACE_FUNCTION ("dat_code_reestablishment_fail()");
+
+  sync_ind->mm_info.valid    = TRUE;
+  sync_ind->mm_info.att      = rrd->control_descr.att;
+  /*
+   * No reestablishment
+   */
+  sync_ind->mm_info.re       = 1;
+  sync_ind->mm_info.ncc      = (rrd->bsic >> 3) & 7;
+  sync_ind->mm_info.bcc      = rrd->bsic & 7;
+  sync_ind->mm_info.t3212    = rrd->control_descr.t3212;
+  /*sync_ind->mm_info.la       = !dat_forb_lai_check (SC_INDEX);*/
+  sync_ind->mm_info.la       = (!(dat_forb_lai_check (SC_INDEX) AND
+                                  dat_roam_forb_lai_check (SC_INDEX)));
+
+  sync_ind->ciph             = NOT_PRESENT_8BIT;;
+  sync_ind->chm.ch_mode      = NOT_PRESENT_8BIT;
+  sync_ind->bcch_info.v_bcch = FALSE;
+  sync_ind->synccs           = NOT_PRESENT_16BIT;
+
+  PSENDX (MM, sync_ind);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_measure_report    |
++--------------------------------------------------------------------+
+
+  PURPOSE : RR builds a RR MEASUREMENT REPORT message for the uplink
+            sacch, whenever it receives a measurement report from the
+            layer 1.
+
+*/
+
+GLOBAL void dat_code_measure_report (T_MPH_MEASUREMENT_IND *report)
+{
+  GET_INSTANCE_DATA;
+  USHORT                i;
+
+  MCAST (meas, U_MEAS_REP);
+  PALLOC_MSG (dl_unitdata_req, DL_UNITDATA_REQ, U_MEAS_REP);/* T_DL_UNITDATA_REQ */
+
+  TRACE_FUNCTION ("dat_code_measure_report()");
+  memset (&dl_unitdata_req->sdu.buf[0], 0, dl_unitdata_req->sdu.o_buf / BITS_PER_BYTE);
+
+  /*
+   * initialize C-structure for the Uplink message
+   */
+  memset (meas, 0, sizeof (T_U_MEAS_REP));
+
+  /*
+   * set message type
+   */
+  meas->msg_type                = U_MEAS_REP;
+
+
+  if (report->valid)
+  {
+    /*
+     * measurement report from layer 1 is valid,
+     * then copy data to C-structure for message
+     */
+    meas->meas_result.ba_used     = rr_data->sc_data.ba_index;
+    meas->meas_result.dtx_used    = report->dtx;
+    meas->meas_result.meas_valid  = 0;
+
+    if (rr_data->dyn_config.fho)
+    {
+      /*
+       * forced handover, special test feature to simulate
+       * a bad serving cell
+       */
+      meas->meas_result.rxlev_full = 0;
+      meas->meas_result.rxlev_sub  = 0;
+    }
+    else
+    {
+      /*
+       * take values from layer 1
+       */
+      meas->meas_result.rxlev_full  = report->rx_lev_full;
+      meas->meas_result.rxlev_sub   = report->rx_lev_sub;
+    }
+
+    meas->meas_result.rxqual_full = report->rx_qual_full;
+    meas->meas_result.rxqual_sub  = report->rx_qual_sub;
+
+    /*
+     * copy neighbourcell values
+     */
+    meas->meas_result.num_ncell   = report->ncells.no_of_ncells;
+
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+    if ( (rr_data->sc_data.ba_list_idle EQ TRUE) OR
+         (rr_data->sc_data.ba_list_ded  EQ TRUE) )   
+#else
+    /*
+     * report ncells only if BA complete or
+     * itīs a expansion (5ter) and the 5/5bis are sent before
+     */
+    if ( (rr_data->sc_data.cd.sys_info_read &  (SYS_INFO_5_READ | SYS_INFO_5BIS_READ))
+                                            EQ (SYS_INFO_5_READ | SYS_INFO_5BIS_READ) )
+#endif
+    {
+      /*
+       * fill ncells to the measurement report
+       */
+      for (i=0;i<meas->meas_result.num_ncell;i++)
+      {
+        meas->meas_result.ncell[i].bsic = report->ncells.bsic[i];
+
+        /*
+         * set position in neighbourcell list instead of channel number
+         */
+        meas->meas_result.ncell[i].bcch_ncell = dat_get_ncell_pos (report->ncells.arfcn[i]);
+        meas->meas_result.ncell[i].rx_lev_ncell = report->ncells.rx_lev[i];
+
+        TRACE_EVENT_P4 ("MR:%u[%4u] p=%u rxl=%u",
+          i, report->ncells.arfcn[i],
+          meas->meas_result.ncell[i].bcch_ncell,
+          meas->meas_result.ncell[i].rx_lev_ncell); /* +++ */
+
+      }
+    }
+    else
+    {
+      /*
+       * Table 10.5.47/GSM 04.08: Measurement Results information element
+       * Range: 0 to 7 (See GSM 05.08)
+       * NO-NCELL-M, Number of neighbouring cell measurements (octets 4 and 5)
+       *
+       * No neighbour cell measurement result := 0
+       * Neighbour cell information not available for serving cell := 7
+       */
+      meas->meas_result.num_ncell = 7;
+    }
+
+  }
+  else
+  {
+    /*
+     * measurement report from layer 1 is invalid
+     */
+    TRACE_EVENT ("invalid Meas");
+    meas->meas_result.meas_valid = 1;
+  }
+
+  /*
+   * code message and send to layer 2.
+   */
+  for_dat_unitdata_req (dl_unitdata_req);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_ext_meas_report   |
++--------------------------------------------------------------------+
+
+  PURPOSE : RR builds a RR EXTENDED MEASUREMENT REPORT message for the
+            uplink sacch.
+*/
+
+GLOBAL void dat_code_ext_meas_report (T_MPH_EMO_MEAS_IND  *mph_emo_meas_ind)
+{
+  GET_INSTANCE_DATA;
+  USHORT          *emo_arfcn = rr_data->  emo_arfcn;
+  UBYTE          c_emo_arfcn = rr_data->c_emo_arfcn;
+  T_ext_meas_res  *ext_meas_res;
+  UBYTE           *rx_lev_ncell;
+  T_meas_results  *meas_results;
+  UBYTE           i,k;
+
+  MCAST (u_ext_meas_report, U_EXT_MEAS_REPORT);
+  PALLOC_MSG (dl_unitdata_req, DL_UNITDATA_REQ, U_EXT_MEAS_REPORT);
+
+  TRACE_FUNCTION ("dat_code_ext_meas_report()");
+
+  /*
+   * initialize C-structure for the Uplink message
+   */
+  memset (u_ext_meas_report, 0, sizeof (T_U_EXT_MEAS_REPORT));
+
+  ext_meas_res = &u_ext_meas_report->ext_meas_res;
+
+  /*
+   * set message type
+   */
+  u_ext_meas_report->msg_type = U_EXT_MEAS_REPORT;
+
+  ext_meas_res->sc_used  = rr_data->emo_seq;
+  ext_meas_res->dtx_used = mph_emo_meas_ind->dtx;
+
+  rx_lev_ncell = &ext_meas_res->rx_lev_ncell[0];
+  meas_results = &mph_emo_meas_ind->meas_results[0];
+
+  TRACE_ASSERT( c_emo_arfcn <=  MAX_EMO_CHANNELS);
+  TRACE_ASSERT( mph_emo_meas_ind->c_meas_results <= (MAX_EMO_CHANNELS +1));
+
+  for ( k = 0; k < c_emo_arfcn; k++ )
+  {
+    for ( i = 0; i < mph_emo_meas_ind->c_meas_results; i++ )
+    {
+      if ( emo_arfcn[k] EQ meas_results[i].arfcn )
+      {
+        rx_lev_ncell[k] = meas_results[i].rx_lev;
+      }
+    }
+  }
+
+  /*
+   * code message and send to layer 2.
+   */
+  for_dat_unitdata_req (dl_unitdata_req);
+
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_mph_chan_mode_req |
++--------------------------------------------------------------------+
+
+  PURPOSE : configure a new channel mode to layer 1.
+
+*/
+
+GLOBAL void dat_code_mph_chan_mode_req (T_D_CHAN_MOD *chan_mod)
+{
+  GET_INSTANCE_DATA;
+  PALLOC (channel_mode_req, MPH_CHANNEL_MODE_REQ);
+
+  TRACE_FUNCTION ("dat_code_mph_chan_mode_req()");
+
+  memset(channel_mode_req, 0, sizeof(T_MPH_CHANNEL_MODE_REQ));
+
+  /*
+   *  configure layer 1 with multi-rate configuration if present
+  */
+  if ( rr_data->sc_data.ch_mode EQ CM_AMR )
+  {
+    int i;
+    channel_mode_req->amr_conf.nscb    = rr_data->sc_data.amr_conf.nscb;
+    channel_mode_req->amr_conf.icmi    = rr_data->sc_data.amr_conf.icmi;
+    channel_mode_req->amr_conf.st_mode = rr_data->sc_data.amr_conf.st_mode;
+    channel_mode_req->amr_conf.acs     = rr_data->sc_data.amr_conf.set_amr;
+
+    channel_mode_req->amr_conf.v_cod_prop = rr_data->sc_data.amr_conf.v_cod_prop;
+    if(channel_mode_req->amr_conf.v_cod_prop)
+    {
+      channel_mode_req->amr_conf.c_cod_prop = rr_data->sc_data.amr_conf.c_cod_prop;
+      for (i=0; i< channel_mode_req->amr_conf.c_cod_prop; i++)
+        memcpy(&channel_mode_req->amr_conf.cod_prop[i],
+               &rr_data->sc_data.amr_conf.cod_prop[i], sizeof(T_cod_prop));
+    }
+  }
+
+  /*
+   * set new channel mode
+   */
+  channel_mode_req->ch   = chan_mod->chan_desc.chan_type;
+  channel_mode_req->mode = chan_mod->chan_mode;
+  PSENDX (PL, channel_mode_req);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_mph_ciphering_req |
++--------------------------------------------------------------------+
+
+  PURPOSE : configure new cipher parameter to layer 1.
+
+*/
+
+GLOBAL void dat_code_mph_ciphering_req (UBYTE       ciph_on,
+                                        UBYTE       algo,
+                                        UBYTE     * kc)
+{
+  PALLOC (mph_ciphering_req, MPH_CIPHERING_REQ);
+
+  TRACE_FUNCTION ("dat_code_mph_ciphering_req()");
+
+  if (ciph_on)
+  {
+    /*
+     * ciphering is on, then set cipher algorithm
+     * and Kc value.
+     */
+    mph_ciphering_req->ciph.stat    = CIPH_ON;
+    mph_ciphering_req->ciph.algo    = algo;
+    memcpy (mph_ciphering_req->ciph.kc, kc, KC_STRING_SIZE);
+  }
+  else
+  {
+    /*
+     * ciphering is off, then set default values
+     */
+    mph_ciphering_req->ciph.stat    = CIPH_OFF;
+    mph_ciphering_req->ciph.algo    = 0;
+    memset (mph_ciphering_req->ciph.kc, 0, KC_STRING_SIZE);
+  }
+
+  PSENDX (PL, mph_ciphering_req);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_sys_info_change   |
++--------------------------------------------------------------------+
+
+  PURPOSE : A change in parameters of system information type 6
+            has been detected. The parameters are configured
+            in layer 1.
+
+*/
+
+GLOBAL void dat_code_sys_info_change  (UBYTE     dtx,
+                                       UBYTE     pwrc,
+                                       UBYTE     rlt)
+{
+  PALLOC (dedicated_req, MPH_DEDICATED_REQ);
+
+  TRACE_FUNCTION ("dat_code_sys_info_change()");
+
+  memset (dedicated_req, 0, sizeof (T_MPH_DEDICATED_REQ));
+
+  /*
+   * set new dtx, rlt, pwrc and ncc_permitted values
+   */
+  dedicated_req->tr_para.dtx   = dtx;
+  dedicated_req->tr_para.rlt   = rlt;
+  dedicated_req->tr_para.pwrc  = pwrc;
+  dedicated_req->mod           = MODE_SYS_INFO_CHANGE;
+
+  PSENDX (PL, dedicated_req);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_DAT                      |
+| STATE   : code               ROUTINE : dat_code_mph_imm_assign_req |
++--------------------------------------------------------------------+
+
+  PURPOSE : configure layer 1 after reception of an immediate assignment
+            or immediate assignment extended message.
+
+*/
+
+GLOBAL void dat_code_mph_imm_assign_req (T_start      *start,
+                                         UBYTE         power,
+                                         UBYTE         maio,
+                                         T_LIST       *freq_after_sti,
+                                         T_LIST       *freq_bef_sti)
+{
+  GET_INSTANCE_DATA;
+
+  PALLOC (dedicated_req, MPH_DEDICATED_REQ);
+
+  TRACE_FUNCTION ("dat_code_mph_imm_assign_req()");
+
+  memset (dedicated_req, 0, sizeof (T_MPH_DEDICATED_REQ));
+
+  dedicated_req->mod = MODE_IMM_ASSIGN;
+
+  /*
+   * set starting time if available
+   */
+  memcpy (&dedicated_req->start, start,
+          sizeof (T_start));
+
+  /*
+   * set channel type
+   */
+  dedicated_req->ch_type.ch    = rr_data->sc_data.chan_desc.chan_type;
+  dedicated_req->ch_type.tn    = rr_data->sc_data.chan_desc.tn;
+  dedicated_req->ch_type.tsc   = rr_data->sc_data.chan_desc.tsc;
+  dedicated_req->ch_type.h     = rr_data->sc_data.chan_desc.hop;
+
+  if (rr_data->sc_data.chan_desc.hop EQ H_NO)
+  {
+    /*
+     * set channel number if no hopping is configured
+     */
+    dedicated_req->ch_type.arfcn = rr_data->sc_data.chan_desc.arfcn;
+  }
+  else
+  {
+    /*
+     * set maio, hsn and hopping list, if hopping is configured
+     */
+    dedicated_req->ch_type.maio  = rr_data->sc_data.chan_desc.maio;
+    dedicated_req->ch_type.hsn   = rr_data->sc_data.chan_desc.hsn;
+
+    /* CSI-LLD section:4.1.1.11
+     * This function Updates the black list with the MA list received
+     * in immediate_assignment req
+     */
+    cs_remove_BA_MA_from_black_list(rr_data->cs_data.region,freq_after_sti);
+
+    srv_create_list (freq_after_sti, dedicated_req->ch_type.ma,
+                     MAX_MA_CHANNELS, TRUE, 0);
+  }
+
+  /*
+   * set channel type 2 (only maio and mobile allocation)
+   */
+  dedicated_req->ch_type2.maio  = maio;
+
+  /* CSI-LLD section:4.1.1.11
+   * This function Updates the black list with the MA list received
+   * in immediate_assignment req
+   */
+  cs_remove_BA_MA_from_black_list(rr_data->cs_data.region,freq_bef_sti);
+
+  srv_create_list (freq_bef_sti, dedicated_req->ch_type2.ma, MAX_MA_CHANNELS,
+                   TRUE, 0);
+
+  dedicated_req->arfcn         = rr_data->nc_data[SC_INDEX].arfcn;
+
+  /*
+   * set power, dtx, rlt, pwrc, timing advance and channel mode
+   */
+  dedicated_req->tr_para.power = power;
+  dedicated_req->tr_para.dtx   = rr_data->sc_data.cd.dtx;
+  dedicated_req->tr_para.rlt   = rr_data->sc_data.cd.cell_options.rlt;
+  dedicated_req->tr_para.pwrc  = rr_data->sc_data.cd.cell_options.pow_ctrl;
+  dedicated_req->tr_para.tav   = rr_data->sc_data.new_ta;
+  dedicated_req->tr_para.mode  = rr_data->sc_data.ch_mode;
+
+  RR_EM_GET_HOPPING_CHANNEL(dedicated_req->ch_type.ma,dedicated_req->ch_type2.ma,
+	                            dedicated_req->start.v_start,maio);
+
+  PSENDX (PL, dedicated_req);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_mph_freq_redef_req|
++--------------------------------------------------------------------+
+
+  PURPOSE : configure a new hopping list after reception of a frequency
+            redefinition message.
+
+*/
+
+GLOBAL void dat_code_mph_freq_redef_req (T_start   *start,
+                                         T_LIST    *hop_list)
+{
+  GET_INSTANCE_DATA;
+
+  T_chan_desc * chan_desc = &rr_data->sc_data.chan_desc;
+
+  PALLOC (freq_redef_req, MPH_FREQ_REDEF_REQ);
+
+  TRACE_FUNCTION ("dat_code_mph_freq_redef_req()");
+
+  /*
+   * copy start time
+   */
+  memcpy (&freq_redef_req->start, start, sizeof (T_start));
+
+  /*
+   * set new hopping list
+   */
+  srv_create_list (hop_list, freq_redef_req->ch_type.ma, MAX_MA_CHANNELS, TRUE,0);
+
+  /* CSI-LLD section:4.1.1.11
+   * This function Updates the black list with the MA list received
+   * in Frequency redifinition message
+   */
+  cs_remove_BA_MA_from_black_list(rr_data->cs_data.region,hop_list);
+
+  /*
+   * set channel type, timeslot, training sequence code,
+   * hopping indication, maio and hsn.
+   */
+  freq_redef_req->ch_type.ch   = chan_desc->chan_type;
+  freq_redef_req->ch_type.tn   = chan_desc->tn;
+  freq_redef_req->ch_type.tsc  = chan_desc->tsc;
+  freq_redef_req->ch_type.h    = chan_desc->hop;
+  freq_redef_req->ch_type.maio = chan_desc->maio;
+  freq_redef_req->ch_type.hsn  = chan_desc->hsn;
+
+  rr_data->mode_after_dedi = MODE_CELL_RESELECTION;
+
+  EM_FREQ_REDEF;
+
+  RR_EM_GET_HOPPING_CHANNEL (freq_redef_req->ch_type.ma, freq_redef_req->ch_type.ma, FALSE,0);
+
+  PSENDX (PL, freq_redef_req);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_mph_old_chan_req  |
++--------------------------------------------------------------------+
+
+  PURPOSE : During channel assignment or handover the layer 2 link is
+            suspended and a new channel is configured. Then the layer 2
+            connection is resumed on the new channel. If this fails,
+            RR switches back to the old channel. The trigger for this
+            is this function.
+
+*/
+
+GLOBAL void dat_code_mph_old_chan_req (void)
+{
+  PALLOC ( mph_dedicated_fail_req, MPH_DEDICATED_FAIL_REQ);
+
+  TRACE_FUNCTION ("dat_code_mph_old_chan_req()");
+
+  PSENDX (PL, mph_dedicated_fail_req);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_prr_channel       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Set the channel type and the service access point
+            identification according to the configured channel type.
+
+*/
+
+GLOBAL void dat_code_prr_channel (UBYTE     *ch_type,
+                                  UBYTE     *sapi,
+                                  UBYTE      chan_type)
+{
+  TRACE_FUNCTION ("dat_code_prr_channel()");
+
+  /*
+   * SAPI is always 0
+   */
+  *sapi    = SAPI_0;
+
+  /*
+   * convert air-interface coding of channel type
+   * to internal values.
+   */
+  switch (chan_type)
+  {
+    case CH_TCH_F:
+      *ch_type = L2_CHANNEL_FACCH_F;
+      break;
+    case CH_TCH_H_1:
+    case CH_TCH_H_2:
+      *ch_type = L2_CHANNEL_FACCH_H;
+      break;
+    default:
+      *ch_type = L2_CHANNEL_SDCCH;
+      break;
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_prr_channel_sms   |
++--------------------------------------------------------------------+
+
+  PURPOSE : Set the channel type and the service access point
+            identification according to the configured channel type
+            for short messages.
+
+*/
+
+GLOBAL void dat_code_prr_channel_sms (T_DL_DATA_REQ *dl_data_req,
+                                      UBYTE         chan_type)
+{
+  TRACE_FUNCTION ("dat_code_prr_channel_sms()");
+
+  /*
+   * sapi is always 3
+   */
+  dl_data_req->sapi    = SAPI_3;
+
+  /*
+   * channel type is SACCH if the main channel (sapi = 0)
+   * is FACCH, else it is SDCCH.
+   */
+  dl_data_req->ch_type = (chan_type < CH_SDCCH_4_0)\
+                         ? L2_CHANNEL_SACCH : L2_CHANNEL_SDCCH;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_code_prr_bcch_info     |
++--------------------------------------------------------------------+
+
+  PURPOSE : create a list of channels from the ba_range information
+            element of a channel release message.
+
+*/
+
+GLOBAL void dat_code_prr_bcch_info (UBYTE        v_ba_range,
+                                    T_ba_range * ba_range)
+{
+  T_LIST   list;
+  USHORT   i;
+  USHORT   j;
+  USHORT   x1;
+  USHORT   x2;
+
+  TRACE_FUNCTION ("dat_code_prr_bcch_info()");
+
+  /*
+   * initialization : the list is empty.
+   */
+  srv_clear_list (&list);
+
+  if (v_ba_range)
+  {
+    /*
+     * only if the information element is inside the
+     * channel release message.
+     * Then for all ranges inside the information element.
+     */
+    for (i=0;i<ba_range->c_freq_range;i++)
+    {
+      x1 = ba_range->freq_range[i].freq_lower;
+      x2 = ba_range->freq_range[i].freq_higher;
+      /*
+       *   set interval borders
+       */
+      if (x1 > HIGH_CHANNEL_900)
+        x1 = HIGH_CHANNEL_900;
+      if (x2 > HIGH_CHANNEL_900)
+        x2 = HIGH_CHANNEL_900;
+
+      if (x1 EQ x2)
+      {
+        /*
+         * add x1 to channel list if both boarders have the same value
+         */
+        srv_set_channel (&list, x1);
+      }
+
+      if (x1 < x2)
+      {
+        /*
+         * add x1..x2 to channel list if the boarders define a range
+         */
+        for (j=x1;j<=x2;j++)
+          srv_set_channel (&list, j);
+      }
+
+      if (x1 > x2)
+      {
+        /*
+         * add LOW_CHANNEL_900..x2 and x1..HIGH_CHANNEL_900 to channel list
+         */
+        for (j=LOW_CHANNEL_900;j<=HIGH_CHANNEL_900;j++)
+          if (j <= x2 OR j>=x1)
+            srv_set_channel (&list, j);
+      }
+    }
+
+    /*
+     * send the resulting list to the SIM card or store it inside the PCM
+     */
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_send_bcchinfo_mm       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Send neigbour cell description to MM
+
+*/
+
+GLOBAL void dat_send_bcchinfo_mm (UBYTE *p)
+{
+  PALLOC (sync_ind, RR_SYNC_IND);
+  sync_ind->ciph             = NOT_PRESENT_8BIT;
+  sync_ind->chm.ch_mode      = NOT_PRESENT_8BIT;
+  sync_ind->mm_info.valid    = FALSE;
+  sync_ind->bcch_info.v_bcch = TRUE;
+  sync_ind->synccs           = NOT_PRESENT_16BIT;
+  if (p)
+  {
+    memcpy (sync_ind->bcch_info.bcch, p, BA_BITMAP_SIZE);
+    TRACE_EVENT_P4 ("BCCHINFO: send 16 byte to MM/SIM (%x,%x,%x,%x,...)", p[0], p[1], p[2], p[3]);
+  }
+  else
+  {
+    memset (sync_ind->bcch_info.bcch, 0, BA_BITMAP_SIZE);
+    TRACE_EVENT ("BCCHINFO: clear SIM");
+  }
+  PSENDX (MM, sync_ind);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_convert_white_list     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Updates White List after cell selection and cell reselection
+            in Full service
+            CSI-LLD section:4.1.2.2.2
+*/
+
+GLOBAL void dat_convert_white_list(void)
+{
+  GET_INSTANCE_DATA;
+  U8 *p = NULL;
+  U8 i;
+  T_LIST tmp_list;
+  BUF_neigh_cell_desc cd;
+
+  TRACE_FUNCTION("dat_convert_white_list()");
+
+  if(rr_data->ms_data.rr_service EQ FULL_SERVICE)
+  {
+    TRACE_EVENT("CR white list -> CS white list");
+
+    /* Clear the old White List info */
+    memset(&rr_data->cs_data.white_list, 0x00, sizeof(T_CS_WHITE_LIST));
+
+    /* copy the serving cell ARFCN */
+    rr_data->cs_data.white_list.last_sc_arfcn = rr_data->nc_data[SC_INDEX].arfcn;
+
+    /* copy the serving cell region */
+    rr_data->cs_data.white_list.region = rr_data->cs_data.region;
+
+    /* Copy the serving cell location area identity */
+    memcpy(&rr_data->cs_data.white_list.last_sc_lac,&rr_data->nc_data[SC_INDEX].lai,
+            sizeof(T_loc_area_ident));
+
+    /* Convert CR white list into T_LIST format and store the same */
+    for(i=0;i<=32;i+=BA_BITMAP_SIZE)
+    {
+      switch(i)
+      {
+        case 0:
+         p = rr_data->cr_data.cr_white_list.si2;
+         break;
+        case 16:
+         p = rr_data->cr_data.cr_white_list.si2bis;
+         break;
+        case 32:
+         p = rr_data->cr_data.cr_white_list.si2ter;
+         break;
+        default:
+          continue;
+      }
+
+      if(p NEQ NULL)
+      {
+        memcpy(cd.b_neigh_cell_desc,p,BA_BITMAP_SIZE);
+        cd.o_neigh_cell_desc = 0;
+        cd.l_neigh_cell_desc = NCELL_DESC_BIT_LEN;
+
+        for_create_channel_list((T_f_range *)&cd,&tmp_list);
+        srv_merge_list(&rr_data->cs_data.white_list.list,&tmp_list);
+      }
+    }
+
+    /* Use last serving cell information also */
+    if(rr_data->cs_data.white_list.last_sc_arfcn NEQ NOT_PRESENT_16BIT)
+    {
+      srv_set_channel(&rr_data->cs_data.white_list.list,
+                      rr_data->cs_data.white_list.last_sc_arfcn&ARFCN_MASK);
+     }
+
+    TRACE_EVENT_P9 ( "White List:[%d]Reg,[%d]Arfcn MCC/MNC r=%x%x%x/%x%x%x/%d",
+      rr_data->cs_data.white_list.region,
+      rr_data->cs_data.white_list.last_sc_arfcn,
+      rr_data->cs_data.white_list.last_sc_lac.mcc[0],
+      rr_data->cs_data.white_list.last_sc_lac.mcc[1],
+      rr_data->cs_data.white_list.last_sc_lac.mcc[2],
+      rr_data->cs_data.white_list.last_sc_lac.mnc[0],
+      rr_data->cs_data.white_list.last_sc_lac.mnc[1],
+      rr_data->cs_data.white_list.last_sc_lac.mnc[2],
+      rr_data->cs_data.white_list.last_sc_lac.lac);
+
+  } /* Full service */
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_store_neigh_cell_desc  |
++--------------------------------------------------------------------+
+
+  PURPOSE : Store neigbour cell description in case of full service
+
+*/
+
+GLOBAL void dat_store_neigh_cell_desc (UBYTE si, UBYTE index,
+                                       BUF_neigh_cell_desc *cd,
+                                       T_LIST *new_neigh_list)
+{
+  GET_INSTANCE_DATA;
+  U8 *p = NULL;
+  U16 o;
+  U8 att_state = GET_STATE (STATE_ATT);
+
+#if defined(_SIMULATION_)
+  {
+    BOOL  plmn_ok;
+
+    plmn_ok = dat_plmn_equal_req (rr_data->nc_data[index].lai.mcc,
+                                  rr_data->nc_data[index].lai.mnc,
+                                  rr_data->ms_data.plmn.mcc,
+                                  rr_data->ms_data.plmn.mnc);
+    TRACE_EVENT_P8 ("dat_store_neigh_cell_desc(): srv:%s op:%s tried:%u, st:%s, NC%u plmn:%u CR:%d SC:%d",
+      _rr_str_SERVICE[rr_data->ms_data.rr_service],
+      _rr_str_FUNC[rr_data->ms_data.req_mm_service],
+      (rr_data->cs_data.scan_mode EQ CS_SECOND_SCAN),
+      STATE_ATT_NAME[att_state], index, plmn_ok,
+      ((int)rr_data->nc_data[CR_INDEX].arfcn),
+      ((int)rr_data->nc_data[SC_INDEX].arfcn));
+  }
+#endif  /* 0|1 */
+
+  if (rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH)
+  {
+    /*
+     * In states ATT_CS2 and ATT_CS3, store BA lists from SI2, 2Bis and 2Ter
+     * inside rr_data->cr_data
+     */
+    if ((att_state EQ ATT_CS2 OR att_state EQ ATT_CS3) AND (index EQ CR_INDEX))
+    {
+      switch (si)
+      {
+        case SYS_INFO_2_MSG:
+          p = rr_data->cr_data.cr_white_list.si2;
+          break;
+        case SYS_INFO_2bis_MSG:
+          p = rr_data->cr_data.cr_white_list.si2bis;
+          break;
+        case SYS_INFO_2ter_MSG:
+          p = rr_data->cr_data.cr_white_list.si2ter;
+          break;
+        default:
+          return;
+      }
+
+      TRACE_EVENT_P3 ("BCCHINFO: store cd of [%d]i%u: si=%02x ",
+                       rr_data->nc_data[index].arfcn, index, si);
+
+      /* compare; store and indicate only if changed */
+      o = cd->o_neigh_cell_desc>>3;
+      if (p NEQ NULL)
+      {
+        if (memcmp (p, &cd->b_neigh_cell_desc[o], BA_BITMAP_SIZE))
+        {
+          memcpy (p, &cd->b_neigh_cell_desc[o], BA_BITMAP_SIZE);
+        }
+      }
+    } /* CR_INDEX */
+
+    else if((att_state EQ ATT_IDLE) AND (index EQ SC_INDEX) AND
+            (rr_data->ms_data.rr_service EQ FULL_SERVICE))
+    {
+      /* In state ATT_IDLE, store BA list directly inside the white list
+       * (only if we are in Full Service)
+       */
+      srv_copy_list (&rr_data->cs_data.white_list.list, new_neigh_list,
+                     sizeof (T_LIST));
+
+      /* Add current serving cell to White List */
+      srv_set_channel(&rr_data->cs_data.white_list.list,
+                      rr_data->nc_data[SC_INDEX].arfcn&ARFCN_MASK);
+
+      if(si EQ SYS_INFO_2_MSG)
+      {
+        /* In case it is the description of system information 2 (and only then)
+         * it should be stored in the SIM card.
+         */
+        o = cd->o_neigh_cell_desc>>3;
+        dat_send_bcchinfo_mm (&cd->b_neigh_cell_desc[o]);
+      }
+    }
+
+    /* additional storing of current serving cell and cell-re-selection cell */
+    rr_data->cs_data.arfcn_sc = rr_data->nc_data[SC_INDEX].arfcn;
+    rr_data->cs_data.arfcn_cr = rr_data->nc_data[CR_INDEX].arfcn;
+  }
+}
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_compare_request_ref    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Reference is GSM 4.08, chapter 3.3.1.1.3.1 On receipt of a
+            CHANNEL REQUEST message
+
+            On receipt of an IMMEDIATE ASSIGNMENT or IMMEDIATE ASSIGNMENT
+            EXTENDED message corresponding to one of its 3 last CHANNEL
+            REQUEST messages, the message shall be identified as the
+            channel description for the MS.
+
+*/
+
+GLOBAL BOOL dat_compare_request_ref (T_req_ref *req_ref, UBYTE * index)
+{
+  GET_INSTANCE_DATA;
+  UBYTE        from;
+  UBYTE        i;
+
+  TRACE_FUNCTION ("dat_compare_request_ref()");
+
+  /*
+   * RR stores the request references for all outgoing
+   * channel requests. The variable from indicates the
+   * beginning of the maximum 3 last channel requests.
+   */
+
+  from = (rr_data->ms_data.access_counter > 2) ?
+          rr_data->ms_data.access_counter - 3 : 0;
+
+  TRACE_EVENT_P4 ("compare: %d %d %d 0x%02x",
+    req_ref->t1, req_ref->t2, req_ref->t3, req_ref->ra);
+
+  TRACE_ASSERT(  rr_data->ms_data.access_counter <=  MAX_RACH_REQ);
+
+  for (i = from; i < rr_data->ms_data.access_counter; i++)
+  {
+    /*
+     * RR checks the sending time T1/T2/T3 of the channel
+     * request message and the content of the message.
+     * If all matches the immediate assignment (extended)
+     * message is identified for the MS.
+     */
+     TRACE_EVENT_P5 ("with[%u]: %d %d %d 0x%02x", i,
+      rr_data->used_frame_no[i].t1, rr_data->used_frame_no[i].t2,
+      rr_data->used_frame_no[i].t3, rr_data->used_channel_ref[i]);
+
+     if (rr_data->used_frame_no[i].t1 EQ req_ref->t1 AND
+         rr_data->used_frame_no[i].t2 EQ req_ref->t2 AND
+         rr_data->used_frame_no[i].t3 EQ req_ref->t3 AND
+         rr_data->used_channel_ref[i] EQ req_ref->ra)
+     {
+       *index = i;
+       return TRUE;
+     }
+  }
+
+  /*
+   * The message is not for the MS
+   */
+  return FALSE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_disconnect_link        |
++--------------------------------------------------------------------+
+
+  PURPOSE : After reception of a channel release message this function
+            starts the disconnection of the link in layer 2.
+
+*/
+
+GLOBAL void dat_disconnect_link (USHORT cause)
+{
+  GET_INSTANCE_DATA;
+  UBYTE  ch_type;
+
+  PALLOC (dl_release_req, DL_RELEASE_REQ);
+
+  TRACE_FUNCTION ("dat_disconnect_link()");
+
+  rr_data->rel_cause      = cause;
+
+  /*
+   * set channel type and sapi according the configured channel
+   * configuration
+   */
+  dat_code_prr_channel (&dl_release_req->ch_type,
+                        &dl_release_req->sapi,
+                        rr_data->sc_data.chan_desc.chan_type);
+
+  ch_type = dl_release_req->ch_type;
+  dl_release_req->mode = DL_NORMAL_RELEASE;
+  PSENDX (DL, dl_release_req);
+
+  /*
+   * control layer 2 release. The timer shall be set in a way
+   * that layer 2 has enough time for at least two DISC frames.
+   * So the value of the timer depends on the channel type
+   * (SDCCH or FACCH).
+   */
+  if (ch_type EQ L2_CHANNEL_SDCCH)
+  {
+    TIMERSTART (T3110, T3110_SDCCH_VALUE);
+  }
+  else
+  {
+    TIMERSTART (T3110, T3110_VALUE);
+  }
+
+  SET_STATE (STATE_DAT, DAT_CHAN_REL);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_fill_mobile_identity   |
++--------------------------------------------------------------------+
+
+  PURPOSE : In several update message the mobile identity must be set.
+            For mobile terminated message the mobile identity of
+            the paging message must be used.
+            For mobile originated connections the mobile identity type
+            depends on the availability of the mobile identities in
+            this order:  TMSI, IMSI, no identity
+
+*/
+
+static void dat_fill_mobile_identity (USHORT      fill_type,
+                                     T_mob_ident *moid)
+{
+  GET_INSTANCE_DATA;
+  UBYTE mobile_type;
+
+  TRACE_FUNCTION ("dat_fill_mobile_identity()");
+
+  memset (moid, 0, sizeof (T_mob_ident));
+
+  /*
+   * for MTC set the type according the paging identity type.
+   */
+  if (fill_type EQ ESTCS_PAGING)
+    mobile_type = rr_data->page_identity_type;
+  else
+  {
+    /*
+     * for MOC set the type according the availability
+     */
+    if (rr_data->ms_data.tmsi_available)
+      mobile_type = TYPE_TMSI;
+    else
+      mobile_type = (rr_data->ms_data.imsi_available)
+                    ? TYPE_IMSI : TYPE_NO_ID;
+  }
+
+  /*
+   * fill the identity according the calculated type
+   */
+  switch (mobile_type)
+  {
+    case TYPE_TMSI:
+      TRACE_EVENT ("FILL TMSI");
+      moid->ident_type      = TYPE_TMSI;
+      moid->tmsi_1.l_tmsi_1   = 32;
+      moid->tmsi_1.o_tmsi_1   = 0;
+      moid->odd_even        = 0;
+      moid->v_tmsi_1        = TRUE;
+      ccd_codeByte (moid->tmsi_1.b_tmsi_1, 0, 8, (UBYTE)(rr_data->ms_data.tmsi_binary >> 24));
+      ccd_codeByte (moid->tmsi_1.b_tmsi_1, 8, 8, (UBYTE)(rr_data->ms_data.tmsi_binary >> 16));
+      ccd_codeByte (moid->tmsi_1.b_tmsi_1, 16, 8, (UBYTE)(rr_data->ms_data.tmsi_binary >> 8));
+      ccd_codeByte (moid->tmsi_1.b_tmsi_1, 24, 8, (UBYTE)rr_data->ms_data.tmsi_binary);
+      break;
+
+    case TYPE_IMSI:
+      TRACE_EVENT ("FILL IMSI");
+      memcpy (moid, &rr_data->ms_data.imsi, sizeof (T_mob_ident));
+      break;
+
+    default:
+      TRACE_EVENT ("FILL NOTHING");
+      memset (moid, 0, sizeof (T_mob_ident));
+      break;
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_check_forb_list        |
++--------------------------------------------------------------------+
+
+  PURPOSE : In automatic mode a cell shall be only selected if it is
+            not member of a forbidden location area list.
+            This function checks the membership in a forbidden LAI
+            independant of the selected mode (manual or automatic).
+
+*/
+
+LOCAL BOOL dat_check_forb_list (int list_type, UBYTE index)
+{
+  GET_INSTANCE_DATA;
+  int i;
+  T_loc_area_ident *forb_list;
+
+  TRACE_FUNCTION ("dat_check_forb_list()");
+
+  if (list_type EQ FORBIDDEN_LIST_NORMAL)
+    forb_list = &rr_data->ms_data.forb_lac_list[0];
+  else
+    forb_list = &rr_data->ms_data.roam_forb_lac_list[0];
+
+  TRACE_ASSERT(index < NCELL_SIZE);
+  
+  /*
+   *
+   * check only in automatic mode
+   *
+   * if ((rr_data->ms_data.operation_mode & 0x40) EQ 0) M_MAN
+   */
+  {
+    /*
+     * check all entries of this list
+     */
+    for (i = 0; i < MAX_LAI; i++)
+    {
+      if ((rr_data->nc_data[index].lai.lac EQ forb_list[i].lac) AND
+          dat_plmn_equal_req (rr_data->nc_data[index].lai.mcc,
+                              rr_data->nc_data[index].lai.mnc,
+                              forb_list[i].mcc,
+                              forb_list[i].mnc))/*lint !e661 !e662 (possible access/creation of out-of-bounds pointer)*/
+      {
+        /*
+         * the check is failed if the location area code is stored.
+         */
+        return FALSE;
+      }
+    }
+  }
+  /*
+   * the check has passed.
+   */
+  return TRUE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_forb_lai_check         |
++--------------------------------------------------------------------+
+
+  PURPOSE : In automatic mode a cell shall be only selected if it is
+            not member of a forbidden location area list.
+
+*/
+
+GLOBAL BOOL dat_forb_lai_check (UBYTE index)
+{
+  TRACE_FUNCTION ("dat_forb_lai_check()");
+
+  return dat_check_forb_list (FORBIDDEN_LIST_NORMAL, index);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_roam_forb_lai_check    |
++--------------------------------------------------------------------+
+
+  PURPOSE : In automatic mode a cell shall be only selected if it is
+            not member of a forbidden location area list.
+
+*/
+
+GLOBAL BOOL dat_roam_forb_lai_check (UBYTE index)
+{
+  TRACE_FUNCTION ("dat_roam_forb_lai_check()");
+
+  return dat_check_forb_list (FORBIDDEN_LIST_ROAMING, index);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_get_background_and_bits|
++--------------------------------------------------------------------+
+
+  PURPOSE : The content of a channel request consists of two parts:
+            The establishment cause and a random value. The function
+            calculates the establishment cause (here defined as background)
+            and the number of bits for the random value.
+
+            The establishment cause inside the channel request message
+            depends on several parameters:
+
+            the internal used establishment cause,
+            the last used channel
+            the NECI-Flag in the system information message
+            the needed channel indicated in a paging message
+            the mobile station capabilities and
+            whether a TCH fullrate is needed
+
+            The abbreviation IG means Ignore. In this case the parameter
+            is not relevant for the calculation.
+
+*/
+#ifdef GPRS
+#define TABLE_SIZE 30
+#else
+#define TABLE_SIZE 21
+#endif
+
+static const CODE_TABLE coding_table [TABLE_SIZE] =
+/*
+ *  establish cause         last NECI  channel   MS    TCH/F   Back-  Bits
+ *                       channel        needed  cap.  needed  ground
+ */
+{ ESTCS_EMERGENCY_CALL,       IG,  IG,      IG,   IG,     IG,  0xA0,    5,
+  ESTCS_REESTABLISHMENT,  TCHFCH,  IG,      IG,   IG,     IG,  0xC0,    5,
+  ESTCS_REESTABLISHMENT,  TCHHCH,   0,      IG,   IG,     IG,  0xC0,    5,
+  ESTCS_REESTABLISHMENT,  TCHHCH,   1,      IG,   IG,     IG,  0x68,    2,
+#ifdef GPRS
+  ESTCS_GPRS_PAGING,          IG,  IG,   ANYCH,   IG,     IG,  0x80,    5,
+  ESTCS_GPRS_PAGING,          IG,  IG,  TCHFCH, FULL,     IG,  0x80,    5,
+  ESTCS_GPRS_PAGING,          IG,  IG, TCHHFCH, FULL,     IG,  0x80,    5,
+  ESTCS_GPRS_PAGING,          IG,  IG,  TCHFCH, DUAL,     IG,  0x20,    4,
+  ESTCS_GPRS_PAGING,          IG,  IG, TCHHFCH, DUAL,     IG,  0x30,    4,
+  ESTCS_GPRS_PAGING,          IG,  IG, SDCCHCH,   IG,     IG,  0x10,    4,
+  ESTCS_GPRS_PAGING,          IG,  IG,      IG, SIGN,     IG,  0x10,    4,
+#endif
+  ESTCS_PAGING,               IG,  IG,   ANYCH,   IG,     IG,  0x80,    5,
+  ESTCS_PAGING,               IG,  IG,  TCHFCH, FULL,     IG,  0x80,    5,
+  ESTCS_PAGING,               IG,  IG, TCHHFCH, FULL,     IG,  0x80,    5,
+  ESTCS_PAGING,               IG,  IG,  TCHFCH, DUAL,     IG,  0x20,    4,
+  ESTCS_PAGING,               IG,  IG, TCHHFCH, DUAL,     IG,  0x30,    4,
+  ESTCS_PAGING,               IG,  IG, SDCCHCH,   IG,     IG,  0x10,    4,
+  ESTCS_PAGING,               IG,  IG,      IG, SIGN,     IG,  0x10,    4,
+  ESTCS_MOC_SPEECH,           IG,   0,      IG,   IG,     IG,  0xE0,    5,
+  ESTCS_MOC_SPEECH,           IG,   1,      IG, DUAL,  FALSE,  0x40,    4,
+  ESTCS_MOC_SPEECH,           IG,  IG,      IG,   IG,     IG,  0xE0,    5,
+  ESTCS_MOC_DATA,             IG,   0,      IG,   IG,     IG,  0xE0,    5,
+  ESTCS_MOC_DATA_HR_SUFF,     IG,   1,      IG, DUAL,  FALSE,  0x50,    4,
+  ESTCS_MOC_DATA,             IG,  IG,      IG,   IG,     IG,  0xE0,    5,
+  ESTCS_LOCATION_UPDATING,    IG,   0,      IG,   IG,     IG,  0x00,    5,  /* new */
+  ESTCS_LOCATION_UPDATING,    IG,   1,      IG,   IG,     IG,  0x00,    4,
+  ESTCS_MOC_SS_SMS,           IG,   0,      IG,   IG,     IG,  0xE0,    5,
+#ifndef GPRS
+  ESTCS_MOC_SS_SMS,           IG,   1,      IG,   IG,     IG,  0x10,    4
+#else
+  ESTCS_MOC_SS_SMS,           IG,   1,      IG,   IG,     IG,  0x10,    4,
+  ESTCS_GPRS_1P,              IG,  IG,      IG,   IG,     IG,  0x78,    3,
+  ESTCS_GPRS_SB,              IG,  IG,      IG,   IG,     IG,  0x70,    3
+#endif
+};
+
+static void dat_get_background_and_bits (UBYTE     *background,
+                                        UBYTE     *bits)
+{
+  GET_INSTANCE_DATA;
+
+  UBYTE  i;
+  USHORT ms_capability;
+
+  TRACE_FUNCTION ("dat_get_background_and_bits()");
+
+  /*
+   * initialise the output parameter
+   */
+  *background   = 0;
+  *bits         = 5;
+  ms_capability = SIGN;
+
+  /*
+   * check the support of vocoder
+   */
+  if (FldGet(rr_data->mscap.chnMode, VocSup))
+  {
+    ms_capability = (FldGet (rr_data->mscap.chnMode, hrSup)) ? DUAL : FULL;
+  }
+
+  /*
+   * go through the table until all criterions are passed (or can be ignored).
+   */
+  for (i = 0; i < TABLE_SIZE; i++)
+  {
+    /*
+     * check internal establishment cause
+     */
+     if (rr_data->ms_data.establish_cause NEQ coding_table[i].cause)
+       continue;
+
+     /*
+      * check last used channel if applicable
+      */
+     if (coding_table[i].last_channel NEQ IG)
+     {
+       if (rr_data->ms_data.last_used_channel NEQ
+           coding_table[i].last_channel)
+         continue;
+     }
+
+     /*
+      * check new establishment cause indication flag if applicable
+      */
+     if (coding_table[i].neci_flag NEQ IG)
+     {
+       if (rr_data->nc_data[SC_INDEX].select_para.neci NEQ
+           coding_table[i].neci_flag)
+         continue;
+     }
+
+     /*
+      * check the channel needed indication of the paging messages
+      * if applicable
+      */
+     if (coding_table[i].channel_needed NEQ IG)
+     {
+       if (rr_data->ms_data.channel_needed NEQ
+           coding_table[i].channel_needed)
+         continue;
+     }
+
+     /*
+      * check the MS capability if applicable
+      */
+     if (coding_table[i].ms_capability NEQ IG)
+     {
+       if (ms_capability NEQ coding_table[i].ms_capability)
+         continue;
+     }
+
+     /*
+      * check the TCH Fullrate needed flag is applicable.
+      */
+     if (coding_table[i].tch_f_needed NEQ IG)
+     {
+       if ((rr_data->ms_data.establish_cause NEQ ESTCS_MOC_SPEECH) AND
+           (rr_data->ms_data.establish_cause NEQ ESTCS_MOC_DATA_HR_SUFF))
+         continue;
+     }
+
+     /*
+      * add this point all criterions are passed, so use the table contents.
+      */
+     *background = coding_table[i].background;
+     *bits       = coding_table[i].bits;
+     return;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_get_burst              |
++--------------------------------------------------------------------+
+
+  PURPOSE : This functions adds a random value to the channel request
+            content. The random value is calculated from a well distributed
+            table.
+
+*/
+static const UBYTE random_values[32] = {  9, 27, 17,  6, 10, 15,  2, 23,
+                                         29, 14,  4, 26, 18,  0, 31, 13,
+                                         21,  1, 30, 22,  5, 24, 20,  8,
+                                          7, 28, 16, 11, 25, 12,  3, 19
+                                        };
+static const UBYTE mask[]            = { 3, 7, 15, 31 };
+
+static UBYTE dat_get_burst (UBYTE     background,
+                            UBYTE     bits)
+{
+  GET_INSTANCE_DATA;
+  UBYTE random_value;
+
+  TRACE_FUNCTION ("dat_get_burst()");
+
+  rr_data->ms_data.index++;
+  rr_data->ms_data.index %= 32;
+  random_value = random_values[rr_data->ms_data.index];
+
+#ifdef GPRS
+  if(
+      (rr_data->ms_data.establish_cause EQ ESTCS_GPRS_1P)
+        AND
+      ((random_value & mask[bits - 2]) EQ 7)
+    )
+  {
+
+    return (background + 6);
+  }
+#endif
+
+  return (background + (random_value & mask[bits - 2]));
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_get_delta              |
++--------------------------------------------------------------------+
+
+  PURPOSE : Reference GSM 4.08, chapter 3.3.1.1.2 Initiation of the
+            immediate assignment procedure
+
+            The RR entity of the mobile station initiates the immediate
+            assignment procedure by scheduling the sending on the
+            RACH and leaving idle mode.
+
+            It then sends maximally M + 1 CHANNEL REQUEST messages on
+            the RACH in a way such that:
+
+            - the number of slots belonging to the mobile station's RACH
+            between initiation of the immediate assignment procedure and
+            the first CHANNEL REQUEST message (excluding the slot containing
+            the message itself) is a random value drawn randomly for each
+            new initial assignment initiation with uniform probability
+            distribution in the set {0, 1, ..., max (T,8) - 1};
+
+            - the number of slots belonging to the mobile station's RACH
+            between two successive CHANNEL REQUEST messages (excluding
+            the slots containing the messages themselves) is a random value
+            drawn randomly for each new transmission with uniform probability
+            distribution in the set {S, S + 1, ..., S + T - 1};
+
+            Here, T is the value of the parameter "Tx-integer" broadcast on the BCCH;
+
+            M is the value of the parameter "max retrans" broadcast on the BCCH;
+
+            S is a parameter depending on the CCCH configuration and on the value
+            of Tx-integer as defined in table 3.1/GSM 04.08.
+
+            Table 3.1/GSM 04.08: Values of parameter S
+
+            +-----------------------------------------------------+
+            + TX-integer + non combined CCCH + combined CCH/SDCCH +
+            +------------+-------------------+--------------------+
+            + 3,8,14,50  +         55        +          41        +
+            + 4,9,16     +         76        +          52        +
+            + 5,10,20    +        109        +          58        +
+            + 6,11,25    +        163        +          86        +
+            + 7,12,32    +        217        +         115        +
+            +-----------------------------------------------------+
+
+*/
+static const CONVERT_TXINTEGER  convert_table[MAX_TX_INTEGER] =
+  /*
+   *      T   S non combined   S combined Tx-integer
+   */
+    {
+          3,  55,              41,        /*  0 */
+          4,  76,              52,        /*  1 */
+          5, 109,              58,        /*  2 */
+          6, 163,              86,        /*  3 */
+          7, 217,             115,        /*  4 */
+          8,  55,              41,        /*  5 */
+          9,  76,              52,        /*  6 */
+         10, 109,              58,        /*  7 */
+         11, 163,              86,        /*  8 */
+         12, 217,             115,        /*  9 */
+         14,  55,              41,        /* 10 */
+         16,  76,              52,        /* 11 */
+         20, 109,              58,        /* 12 */
+         25, 163,              86,        /* 13 */
+         32, 217,             115,        /* 14 */
+         50,  55,              41         /* 15 */
+    };
+
+
+static UBYTE dat_get_delta (UBYTE i)
+{
+  GET_INSTANCE_DATA;
+
+  USHORT index = rr_data->nc_data[SC_INDEX].rach.tx_integer;
+  USHORT n;
+  USHORT result=0;
+
+  TRACE_FUNCTION ("dat_get_delta()");
+
+  /*
+   * calculate righ boarder of the interval.
+   */
+  TRACE_ASSERT( index < MAX_TX_INTEGER );
+  if( index < MAX_TX_INTEGER)
+  {
+    n = (i EQ 0) ? att_max (convert_table[index].t, 8) - 1
+               : convert_table[index].t - 1;
+
+  /*
+   * calculate random value
+   */
+  result = dat_random ((USHORT)(n+1));
+
+  /*
+   * If it is not the first value, add left boarder S
+   */
+  if (i NEQ 0)
+    {
+      /*
+       * in according to GSM 4.08, section 10.5.2.11 (Control Channel Description)
+       * and section 3.3.1.1.2 (Initiation of the immediate assignment procedure)
+       */
+      result +=
+        (rr_data->nc_data[SC_INDEX].control_descr.ccch_conf EQ COMB_CCCH_COMB)
+          ? convert_table[index].s_combined
+          : convert_table[index].s_non_combined;
+    }
+  }
+  return (UBYTE)result;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_get_ncell_pos          |
++--------------------------------------------------------------------+
+
+  PURPOSE : for uplink SACCH RR MEASUREMENT REPORT message the
+            position of a cell inside the neighbourcell list must
+            be calculated. This is done by this function.
+
+*/
+
+static UBYTE dat_get_ncell_pos (USHORT channel)
+{
+  GET_INSTANCE_DATA;
+  UBYTE i;
+
+  TRACE_FUNCTION ("dat_get_ncell_pos()");
+
+  /*
+   * the loop counter i is the position inside the actual
+   * neighbourcell list.
+   */
+  for (i=0; i<MAX_NEIGHBOURCELLS;i++)
+  {
+    if (channel EQ rr_data->act_ncell_list[i])
+    {
+      /*
+       * channel is found, then return the position.
+       */
+      return i;
+    }
+  }
+  return 0;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_eplmn_equal_req        |
++--------------------------------------------------------------------+
+
+  PURPOSE : Compare found PLMN with all PLMNs in EPLMN list 
+
+
+*/
+
+static BOOL dat_eplmn_equal_req(const UBYTE *mcc, const UBYTE *mnc)
+{
+  GET_INSTANCE_DATA;
+  UBYTE i;
+
+  TRACE_FUNCTION("dat_eplmn_equal_req");
+
+  
+  if(rr_data->ms_data.v_eq_plmn)
+  {
+    for(i = 0; i < RR_EPLMNLIST_SIZE; i++)
+    {
+      if(!memcmp(rr_data->ms_data.eq_plmn_list[i].mcc, mcc, SIZE_MCC) &&
+         !memcmp(rr_data->ms_data.eq_plmn_list[i].mnc, mnc, SIZE_MNC))
+        return TRUE;
+    }
+  }
+  return FALSE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_plmn_equal_req         |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function checks whether the given mobile country code
+            and the given mobile network code describes the requested
+            PLMN, eg. the HPLMN distilled from the IMSI.
+            This is not exactly the algorithm as shown for HPLMN
+            matching as shown in 03.22 Normative Annex A, this version
+            here is more universal.
+
+*/
+
+GLOBAL BOOL dat_plmn_equal_req (const UBYTE *bcch_mcc, const UBYTE *bcch_mnc,
+                                const UBYTE *mm_mcc,  const UBYTE *mm_mnc)
+{
+  GET_INSTANCE_DATA;
+  if(((rr_data->ms_data.operation_mode >> SHIFT_FOR_SEARCH_OFFSET) & 1) EQ M_AUTO &&
+     rr_data->ms_data.req_mm_service NEQ FUNC_LIM_SERV_ST_SRCH)    
+  {
+    /* Check for equivalent EPLMNs */
+    if(dat_eplmn_equal_req(bcch_mcc, bcch_mnc))
+      return TRUE;
+  }
+
+  /* Check MCC */
+  if (memcmp (mm_mcc, bcch_mcc, SIZE_MCC) NEQ 0)
+    return FALSE;
+
+  /* Check first 2 MNC digits */
+  if (memcmp (mm_mnc, bcch_mnc, 2) NEQ 0)
+    return FALSE;
+
+  /* Check for full match */
+  if (mm_mnc[2] EQ bcch_mnc[2])
+    return TRUE;
+
+  /* The 3rd digit of the MNC differs */
+  if ((bcch_mcc[0] EQ 3) AND
+      (bcch_mcc[1] EQ 1) AND
+      INRANGE(0,bcch_mcc[2],6))
+  {
+    /*
+     * The MCC is in the range 310..316, this means North America.
+     * The zero suffix rule applies.
+     */
+    return (((mm_mnc[2] EQ 0xf) AND (bcch_mnc[2] EQ 0x0)) OR
+            ((mm_mnc[2] EQ 0x0) AND (bcch_mnc[2] EQ 0xf)));
+  }
+  return (bcch_mnc[2] EQ 0xf);
+}
+
+GLOBAL BOOL dat_hplmn (const UBYTE *mcc, const UBYTE *mnc)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_hplmn()");
+
+  /*
+   * only if a SIM is inserted and an IMSI is available
+   */
+  if (!rr_data->ms_data.imsi_available)
+    return FALSE;
+
+  if ((rr_data->ms_data.ahplmn.v_plmn EQ V_PLMN_PRES) AND
+      (rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH))
+  {
+    /*
+     * If AHPLMN is available
+     * do not compare the mcc, mnc from IMSI for the HPLMN
+     * use the AHPLMN
+     */
+    return dat_plmn_equal_req (mcc, mnc,
+                               rr_data->ms_data.ahplmn.mcc,
+                               rr_data->ms_data.ahplmn.mnc);
+  }
+
+  return dat_plmn_equal_req (mcc, mnc,
+                             &rr_data->ms_data.imsi.ident_dig[0],
+                             &rr_data->ms_data.imsi.ident_dig[3]);       
+   
+ }
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_hplmn_country          |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function checks whether the given mobile country
+            code is equal to the first three digits of the IMSI.
+            The first three digits of the IMSI are equal to the
+            mobile country code of the HPLMN.
+
+*/
+
+static BOOL dat_hplmn_country (const UBYTE *mcc)
+{
+  GET_INSTANCE_DATA;
+  SHORT i;
+  UBYTE mcc_digit;
+
+  TRACE_FUNCTION ("dat_hplmn_country()");
+
+  /*
+   * Only if an IMSI is available
+   */
+  if (rr_data->ms_data.imsi_available)
+  {
+/*    EM_HPLMN_SEARCH_STARTED; - Not supported*/
+    for (i = 0; i < SIZE_MCC; i++)
+    {
+      
+      if((rr_data->ms_data.ahplmn.v_plmn EQ V_PLMN_PRES) AND
+         (rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH))
+      {
+        /*
+         * If AHPLMN is available
+         * do not compare the mcc from IMSI for the HPLMN
+         * use the MM req HPLMN
+         */
+        mcc_digit = rr_data->ms_data.ahplmn.mcc[i];
+      }      
+      else
+      {
+        mcc_digit = rr_data->ms_data.imsi.ident_dig[i];
+      }
+
+      /*
+       * if one of the three first digits of the IMSI is unequal to
+       * the mobile country code, it is not the HPLMN country.
+       */
+      if (mcc[i] NEQ mcc_digit)
+      {
+        return FALSE;
+      }
+    }
+    
+    EM_HPLMN_SEARCH_PASSED;
+    
+    return TRUE;
+  }
+  return FALSE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_imsi_mod_1000          |
++--------------------------------------------------------------------+
+
+  PURPOSE : Calculate IMSI modulo 1000. That means take the last three
+            digits of the IMSI. The length of the IMSI (and so the number
+            of digits overall) is variable.
+
+            This value is needed for calculation of the paging group.
+
+*/
+
+static SHORT dat_imsi_mod_1000 (void)
+{
+  GET_INSTANCE_DATA;
+  SHORT i      = 0;
+  SHORT ret    = 0;
+  int   n;
+
+  TRACE_FUNCTION ("dat_imsi_mod_1000()");
+
+  while (rr_data->ms_data.imsi.ident_dig[i] < 0x0A)
+    i++;
+
+  if (i)
+  {
+    for (n = MAXIMUM (i-3, 0); n <= MAXIMUM (i-1, 0); n++)
+    {
+      ret = ret * 10 + rr_data->ms_data.imsi.ident_dig[n];
+    }
+  }
+  return ret;
+
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_no_of_paging_blocks    |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function calculates the number of paging blocks.
+
+            For 51-Multiframe the following condition exists:
+
+            A non-combined CCCH configuration has 9 CCCH Blocks.
+            A combined CCCH configuration has 3 CCCH Blocks.
+
+            From this n CCCH Blocks BS_AG_BLKS_RES blocks are reserved
+            for AGCH (access grant channels for immediate assignment).
+            The rest is reserved for PCH (Paging Channel).
+
+            This number must be multiplied by the BS_PA_MFRMS parameter
+            (internally stored is the air-interface coding, add 2 for
+            the real value).
+
+            The BS_PA_MFRMS parameter defines the number of 51-Multiframes
+            until the paging blocks are repeated.
+
+*/
+
+static SHORT dat_no_of_paging_blocks (UBYTE     index)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_no_of_paging_blocks()");
+
+  /* in according to GSM 4.08 section 10.5.2.11, table 10.5.33 */
+  if (rr_data->nc_data[index].control_descr.ccch_conf EQ COMB_CCCH_COMB)
+  {
+    /*
+     * combined CCCH,
+     *
+     * number of paging blocks = (3 - BS_AG_BLKS_RES) * BS_PA_MFRMS
+     *
+     * Maximum function only for security reasons, BCCH coding range is 0..7,
+     * but allowed is only 0..2.
+     */
+    return ((att_max (1, (UBYTE)(3 - rr_data->nc_data[index].control_descr.
+                                                bs_ag_blks_res))) *
+            ((UBYTE)(2 + rr_data->nc_data[index].control_descr.bs_pa_mfrms)));
+  }
+  else
+  {
+    /*
+     * non-combined CCCH,
+     *
+     * number of paging blocks = (9 - BS_AG_BLKS_RES) * BS_PA_MFRMS
+     */
+    return ((9 - rr_data->nc_data[index].control_descr.bs_ag_blks_res) *
+            (2 + rr_data->nc_data[index].control_descr.bs_pa_mfrms));
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_owner_of_auth_0_to_9   |
++--------------------------------------------------------------------+
+
+  PURPOSE : It is checked whether the MS is owner of at least one
+            of the normal classes 0 to 9. The coding on the SIM card
+            is in opposite to the coding on the BCCH.
+
+*/
+
+static BOOL dat_owner_of_auth_0_to_9 (void)
+{
+  GET_INSTANCE_DATA;
+  BOOL  result            = FALSE;
+
+  /*
+   * get bits 0 to 9 from SIM card and BCCH
+   */
+  USHORT ms_classes = rr_data->ms_data.access_classes & 0x3FF;
+  USHORT plmn_classes = rr_data->nc_data[SC_INDEX].rach.ac & 0x3FF;
+
+  TRACE_FUNCTION ("dat_owner_of_auth_0_to_9()");
+
+  /*
+   * check only if IMSI is available
+   * else no valid classes of the SIM card available
+   */
+  if (rr_data->ms_data.imsi_available)
+  {
+    /*
+     * check classes
+     */
+    if ((ms_classes & (~plmn_classes)) NEQ 0)
+      result = TRUE;
+  }
+  return result;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_owner_of_auth_11_to_15 |
++--------------------------------------------------------------------+
+
+PURPOSE : It is checked whether the MS is owner of at least one
+          of the normal classes 11 to 15. The coding on the SIM card
+          is in opposite to the coding on the BCCH.
+
+*/
+
+static BOOL dat_owner_of_auth_11_to_15 (void)
+{
+  GET_INSTANCE_DATA;
+  BOOL  result            = FALSE;
+
+  /*
+   * get bits 11 to 15 from the SIM card and the BCCH.
+   */
+  USHORT ms_classes   = rr_data->ms_data.access_classes & 0xF800;
+  USHORT plmn_classes = rr_data->nc_data[SC_INDEX].rach.ac & 0xF800;
+
+  TRACE_FUNCTION ("dat_owner_of_auth_11_to_15()");
+
+  /*
+   * check only if IMSI is available
+   * else no valid classes of the SIM card available
+   */
+  if (rr_data->ms_data.imsi_available)
+  {
+    if (! dat_hplmn (rr_data->nc_data[SC_INDEX].lai.mcc, 
+                     rr_data->nc_data[SC_INDEX].lai.mnc))
+    {
+     /*
+      * ignore bit 11 and 15 if not in the HPLMN
+      */
+        ms_classes   = ms_classes & 0x7000;
+        plmn_classes = plmn_classes & 0x7000;
+    }
+
+    if (! dat_hplmn_country (rr_data->nc_data[SC_INDEX].lai.mcc))
+    {
+     /*
+      * ignore bit 12 to 14 if not in the HPLMN country
+      */
+        ms_classes   = ms_classes & 0x8F00;
+        plmn_classes = plmn_classes & 0x8F00;
+    }
+
+     /*
+      * check classes
+      */
+    if ((ms_classes & (~plmn_classes)) NEQ 0)
+      result = TRUE;
+  }
+
+  return result;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_random                 |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function calculates a random value in the range 0..n-1.
+            The algorithm uses the system time as a base for the random
+            value calculation.
+
+*/
+
+GLOBAL USHORT dat_random (USHORT n)
+{
+  GET_INSTANCE_DATA;
+  T_TIME time_val;
+
+   static USHORT random_value = 0;
+
+  TRACE_FUNCTION ("dat_random()");
+
+  /*
+   * for module testing the random component can be switched off
+   */
+  if (rr_data->dyn_config.no_sys_time)
+    time_val = 0;
+  else
+    vsi_t_time (VSI_CALLER &time_val);
+
+  /*
+   * increment the base of the calculation by the system time.
+   */
+  random_value += (USHORT) time_val;
+
+  /*
+   * calculate the value in the range 0...n.1
+   */
+  return (random_value % n);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_release_connection     |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function is called after receiving MPH_STOP_DEDICATED_CNF
+            from L1 following disconnection of L2 connection.
+
+*/
+
+GLOBAL void dat_release_connection (void)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_release_connection()");
+
+  switch (GET_STATE (STATE_DAT))
+  {
+    case DAT_IMM_ASS:
+      /* 
+       * Layer 2 disconnection is initiated by MM through RR_ABORT_REQ 
+       */
+      if(rr_data->rel_cause EQ RRCS_MM_ABORTED)
+      {
+        dat_rr_release_ind(RRCS_MM_ABORTED, SAPI_0);
+      }
+      break;
+
+    case DAT_IMM_ASS_1:
+      /* 
+       * Layer 2 disconnection is initiated by MM through RR_ABORT_REQ 
+       */
+      if(rr_data->rel_cause EQ RRCS_MM_ABORTED)
+      {
+        dat_rr_release_ind(RRCS_MM_ABORTED, SAPI_0);
+        break;
+      }
+      /* 
+       *DL establishment failure during immediate assignment
+       */
+      switch (rr_data->ms_data.establish_cause)
+      {
+#ifdef GPRS
+        case ESTCS_GPRS_PAGING:
+          dat_stop_dcch_ind ((UBYTE)rr_data->dcch_stop_cause);
+          break;
+        case ESTCS_PAGING:
+          if(!rr_data->repeat_est)
+            dat_rr_release_ind(rr_data->rel_cause, SAPI_0);
+#else
+        case ESTCS_PAGING:
+#endif
+          break;
+        default:
+          dat_rr_release_ind(rr_data->rel_cause, SAPI_0);
+          break;
+      }
+      break;
+
+    default:
+      dat_rr_release_ind (rr_data->rel_cause, SAPI_0);
+      break;
+  }
+
+  /*
+   * clear state of data transfer process and start
+   * cell reselection to come back to idle mode.
+   * Inform GRR, and wait for CR_RSP 
+   */
+  att_leave_dedicated();
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_send_random_bursts     |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function configures layer 1 to send 2 to 8 random
+            bursts during connection establishment
+
+*/
+
+/*
+ * conversion of the air-interface coding (0..3) for the
+ * number of random bursts to be send
+ */
+static const UBYTE max_attempt[MAX_RACH_RETRANS_VAL] = { 2, 3, 5, MAX_RACH_REQ};
+
+static void dat_send_random_bursts (void)
+{
+  GET_INSTANCE_DATA;
+  UBYTE i;
+  UBYTE background;
+  UBYTE bits;
+
+  PALLOC (mph_random_access_req, MPH_RANDOM_ACCESS_REQ);
+
+  TRACE_FUNCTION ("dat_send_random_bursts()");
+
+  /*
+   * calculate the background and the number of bits for the
+   * random part depending on the establishment cause.
+   */
+  dat_get_background_and_bits (&background, &bits);
+  TRACE_EVENT("reset rej_rec");
+  rr_data->imm_ass_rej_rec = FALSE;
+  /*
+   * initialize the primitive and parameter for calculation
+   */
+  rr_data->ms_data.access_counter  = 0;
+  TRACE_ASSERT( rr_data->nc_data[SC_INDEX].rach.max_retrans < 
+                                     MAX_RACH_RETRANS_VAL );
+  rr_data->ms_data.max_attempt     = max_attempt[rr_data->nc_data
+                                     [SC_INDEX].rach.max_retrans];
+  memset (&mph_random_access_req->send_mode, 0, sizeof (T_send_mode));
+  mph_random_access_req->send_mode.no = rr_data->ms_data.max_attempt;
+
+  /*
+   * for all random bursts
+   */
+  TRACE_ASSERT( rr_data->ms_data.max_attempt <= MAX_RACH_REQ );
+  for (i = 0; i < rr_data->ms_data.max_attempt; i++)
+  {
+    /*
+     * calculate time until the random burst must be send
+     */
+    mph_random_access_req->send_mode.delta[i] = dat_get_delta (i);
+
+    /*
+     * calculate the random burst content and store it for
+     * later comparision with the incoming immediate assignment
+     * messages.
+     */
+    mph_random_access_req->send_mode.rach[i] = rr_data->used_channel_ref[i] =
+        dat_get_burst (background, bits);
+    /*
+    TRACE_EVENT_P3 ("RA %u: ref=0x%02x delta=%u",
+      i, rr_data->used_channel_ref[i],
+      mph_random_access_req->send_mode.delta[i]);
+    */
+  }
+
+  /*
+   * configure layer 1.
+   */
+  PSENDX (PL, mph_random_access_req);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_set_last_used_channel  |
++--------------------------------------------------------------------+
+
+  PURPOSE : The last used channel during connection must be stored
+            for the case of call re-establishment.
+
+*/
+
+GLOBAL void dat_set_last_used_channel (T_chan_desc *chan_desc)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_set_last_used_channel()");
+
+  /*
+   * depending on the air-interface coding for the channel type
+   */
+  switch (chan_desc->chan_type)
+  {
+    case CH_TCH_F:
+      /*
+       * Traffic channel full rate
+       */
+      rr_data->ms_data.last_used_channel = TCHFCH;
+      break;
+
+    case CH_TCH_H_1:
+    case CH_TCH_H_2:
+      /*
+       * Traffic channel half rate
+       */
+      rr_data->ms_data.last_used_channel = TCHHCH;
+      break;
+
+    default:
+      /*
+       * SDCCH
+       */
+      rr_data->ms_data.last_used_channel = SDCCHCH;
+      break;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_start_immediate_assign |
++--------------------------------------------------------------------+
+
+  PURPOSE : start of the immediate assignment procedure after getting
+            a RR_ESTABLISH_REQ from MM for a mobile originated connection
+            or a MPH_PAGING_IND from layer 1 for a mobile terminated
+            connection.
+
+*/
+
+GLOBAL void dat_start_immediate_assign (USHORT    cause)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_start_immediate_assign()");
+
+  /*
+   * synchronize attachment process to connection establishment state
+   */
+  att_dat_con_est ();
+
+  /*
+   * initialize parameters for random access procedure
+   */
+  rr_data->ms_data.index             = dat_random (32);
+  rr_data->ms_data.establish_cause   = cause;
+  rr_data->ms_data.access_counter    = 0;
+  rr_data->ms_data.all_conf_received = FALSE;
+
+  /*
+   * if connection is too short to get one measurement report from layer 1,
+   * initialize the structure with the previous idle value
+   */
+  rr_data->ms_data.measurement_report.rx_lev_full = rr_data->nc_data[SC_INDEX].rxlev;
+
+  TRACE_EVENT_P1 ("imm ass SC=[%u]",rr_data->nc_data[SC_INDEX].arfcn);
+
+  /*
+   * send random bursts and wait for immediate assignment
+   */
+  dat_send_random_bursts ();
+  SET_STATE (STATE_DAT, DAT_IMM_ASS);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_start_sabm             |
++--------------------------------------------------------------------+
+
+  PURPOSE : After successful immediate assignment procedure the layer 1
+            is configured on a dedicated control channel (SDCCH or FACCH).
+            Now the layer 2 connection must be established. This is done
+            by this function.
+
+            Layer 2 sends a Paging response in case of mobile terminated
+            connection piggy-backed on the SABM.
+
+            In case of mobile terminated connection the piggy-backed layer 3
+            message is coming from MM.
+
+*/
+
+GLOBAL void dat_start_sabm (void)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_start_sabm()");
+
+  if (rr_data->ms_data.establish_cause EQ ESTCS_PAGING
+#ifdef GPRS
+      OR rr_data->ms_data.establish_cause EQ ESTCS_GPRS_PAGING
+#endif
+     )
+  {
+    MCAST (pag_res, U_PAG_RES);
+    PALLOC_MSG (establish_req, DL_ESTABLISH_REQ, U_PAG_RES);
+
+    dat_code_prr_channel (&establish_req->ch_type,
+                          &establish_req->sapi,
+                          rr_data->sc_data.chan_desc.chan_type);
+    /*
+     * if it is a mobile terminated connection,
+     * fill the C-Structure for a PAGING RESPONSE message.
+     */
+    pag_res->msg_type               = U_PAG_RES;
+    pag_res->ciph_key_num.key_seq   = rr_data->ms_data.cksn;
+    pag_res->mob_class_2            = rr_data->ms_data.classmark2;
+    pag_res->mob_class_2.rf_pow_cap = att_get_power ();
+
+    /*
+     * fill mobile identity and send it to layer 2
+     */
+    dat_fill_mobile_identity (ESTCS_PAGING, &pag_res->mob_ident);
+    for_dat_est_req_content  (establish_req);
+  }
+  else
+  {
+    /*
+     * mobile originated connection. set sdu with message from MM
+     * and send it to layer 2.
+     */
+    PALLOC_SDU (establish_req, DL_ESTABLISH_REQ, ((MAX_L2_FRAME_SIZE * BITS_PER_BYTE) - ENCODE_OFFSET));
+
+    dat_code_prr_channel (&establish_req->ch_type,
+                          &establish_req->sapi,
+                          rr_data->sc_data.chan_desc.chan_type);
+
+    /*lint -e419 (Warning -- Apparent data overrun for function memcpy exceeds argument 1)*/
+    establish_req->sdu.o_buf = rr_data->ms_data.l3msg.offset;
+    establish_req->sdu.l_buf = rr_data->ms_data.l3msg.length; 
+    memcpy (establish_req->sdu.buf, rr_data->ms_data.l3msg.buffer, MAX_L2_FRAME_SIZE);
+    /*lint +e419 (Warning -- Apparent data overrun for function memcpy exceeds argument 1)*/
+    for_dat_est_req_not_coding (establish_req);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_test_sim_available     |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function checks whether a test SIM is available or not.
+
+*/
+
+GLOBAL BOOL dat_test_sim_available (void)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_test_sim_available()");
+
+#if defined (_SIMULATION_)
+  /*
+   * some traces for debugging.
+   */
+  if (rr_data->ms_data.operation_mode & 0x80)
+  {
+      TRACE_FUNCTION ("Test SIM available");
+  }
+  else
+  {
+      TRACE_FUNCTION ("No Test SIM available");
+  }
+#endif
+
+  return ((rr_data->ms_data.operation_mode >> SHIFT_FOR_SIM_TYPE) & 1);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_check_sim_available    |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function checks whether the SIM is available or not.
+
+*/
+
+GLOBAL BOOL dat_check_sim_available (void)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_check_sim_available()");
+
+  return ((rr_data->ms_data.operation_mode >> SHIFT_FOR_SIM_INSERTED) & 1);
+}
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_DAT                     |
+| STATE   : code                ROUTINE : dat_vsd_bit_set            |
++--------------------------------------------------------------------+
+
+  PURPOSE : To set the send state variable V(S) and the
+            corresponding bit for SAPI 0 messages on FACCH or SDCCH.
+            The following possibilities are available:
+
+            SET_ONLY:      V(S) in incremented and the message bit is set
+            RESET_ONLY:    V(S) is initialized and the message bit is not set
+            SET_AND_RESET: V(S) is initialized and the message bit is set.
+
+*/
+
+GLOBAL void dat_vsd_bit_set (T_L3_SDU  *m_buf,
+                            UBYTE     action)
+{
+  static UBYTE         vsd = 0;   /* Send state variable V(S)                    */
+         UBYTE          pd;       /* protocol discriminator of the message       */
+         UBYTE        * msp;      /* pointer to message type for setting the bit */
+#ifdef REL99
+         UBYTE         mscr = 0;     /* variable to hold msc release version*/
+#endif
+  TRACE_FUNCTION ("dat_vsd_bit_set()");
+
+  /*
+   * VSD shall be initialized
+   */
+  if (action NEQ SET_ONLY)
+    vsd = 0;
+
+  /*
+   * message bit shall be set
+   */
+  if (action NEQ RESET_ONLY)
+  {
+    /*
+     * calculate message type pointer and protocol discriminator
+     */
+    TRACE_ASSERT( (m_buf->offset >> 3) < L3_SDU_BUF_SIZE );
+    msp = &m_buf->buffer[m_buf->offset >> 3];
+    pd  = *msp++ & 0x0F;
+#ifdef REL99
+    /*
+     * Get MSCR of the serving MSC
+     */
+    get_msc_release_version(&mscr);
+    TRACE_EVENT_P1("mscr (MSC release) version : 0x%X", mscr);
+#endif
+    switch (pd)
+    {
+      case PD_SMS:
+        /*
+         * SMS on SDCCH is a SAPI 3 message and shall not be set.
+         */
+        break;
+      case PD_CC:
+      case PD_SS:
+      case PD_MM:
+#ifdef REL99
+        if (mscr EQ MSCR_99)
+        {           
+          /* for MSC release R99 or above modulo 4 will be done.
+           * SAPI 0 message: set bit 7th and 8th of MSG Type IE 
+           * and increment V(S) modulo 4.
+           */
+          *msp |= (vsd++ << 6);
+          vsd   = vsd & 0x03;
+        }
+        else
+#endif
+        {
+        /* for MSC release R98 or old modulo 2 will be done.
+         * SAPI 0 message: set bit if vsd is 1, else no effect
+         * and increment V(S) modulo 2.
+         */
+        *msp |= (vsd++ << 6);
+        vsd &= 1;
+    }
+  }
+}
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_begin_start_immediate_assign |
++---------------------------------------------------------------------+
+
+  PURPOSE : initiate immediate assignment procedure by sending
+            channel request
+
+*/
+GLOBAL void dat_begin_start_immediate_assign (UBYTE id_type, UBYTE chan_need)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_begin_start_immediate_assign()");
+
+  rr_data->page_identity_type = id_type;
+  rr_data->ms_data.channel_needed     = chan_need;
+  dat_vsd_bit_set (&rr_data->ms_data.l3msg, RESET_ONLY);
+  rr_data->sc_data.first_attempt = TRUE;
+  rr_data->repeat_est    = FALSE;
+  dat_start_immediate_assign (ESTCS_PAGING);
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_rr_release_ind               |
++---------------------------------------------------------------------+
+
+  PURPOSE : send RR_RELEASE_IND to MM
+
+*/
+GLOBAL void dat_rr_release_ind (USHORT relcs, UBYTE sapi)
+{
+    PALLOC (rr_release_ind, RR_RELEASE_IND);
+
+    rr_release_ind->cause = relcs;
+    rr_release_ind->sapi  = sapi;
+#ifdef GPRS
+    dat_set_gprs_resump(rr_release_ind);
+#endif
+
+    PSENDX (MM, rr_release_ind);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+| STATE   : code                ROUTINE : dat_send_release_ind       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Send RR_REELASE_IND to MM during the Access Procedure
+
+*/
+
+GLOBAL void dat_send_release_ind (USHORT cause)
+{
+  GET_INSTANCE_DATA;
+  TRACE_FUNCTION ("dat_send_release_ind()");
+
+  switch (rr_data->ms_data.establish_cause)
+  {
+#ifdef GPRS
+    case ESTCS_GPRS_1P:
+    case ESTCS_GPRS_SB:
+    case ESTCS_GPRS_PAGING:
+      SET_STATE(STATE_GPRS, GPRS_PIM_BCCH);
+      break;
+    case ESTCS_PAGING:
+      dat_rr_release_ind(RRCS_INT_NOT_PRESENT, SAPI_0);
+      /*
+       *   After sending a release_ind RR shall consider that GRR leaves SUSPENDED state
+       */
+      if(GPRS_SUSPENDED_BCCH EQ GET_STATE(STATE_GPRS))
+      {
+        SET_STATE(STATE_GPRS,GPRS_PIM_BCCH);
+      }
+      else if(GPRS_SUSPENDED_PBCCH EQ GET_STATE(STATE_GPRS))
+      {
+        SET_STATE(STATE_GPRS,GPRS_PIM_PBCCH);
+      }
+#else
+    case ESTCS_PAGING:
+#endif
+      break;
+
+    default:
+#ifdef GPRS
+      /*
+       *   After sending a release_ind RR shall consider that GRR leaves SUSPENDED state
+       */
+      if(GPRS_SUSPENDED_BCCH EQ GET_STATE(STATE_GPRS))
+      {
+        SET_STATE(STATE_GPRS,GPRS_PIM_BCCH);
+      }
+      else if(GPRS_SUSPENDED_PBCCH EQ GET_STATE(STATE_GPRS))
+      {
+        SET_STATE(STATE_GPRS,GPRS_PIM_PBCCH);
+      }
+#endif
+      if ( cause EQ RRCS_RND_ACC_FAIL )
+      {
+        if (! IS_TIMER_ACTIVE (T3122))
+        {
+          dat_rr_release_ind(RRCS_RND_ACC_FAIL, SAPI_0);
+        }
+        else
+        {
+          dat_rr_release_ind(RRCS_RND_ACC_DELAY, SAPI_0);
+        }
+      }
+      else
+      {
+        dat_rr_release_ind(cause, SAPI_0);
+      } 
+      break;
+  }
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_send_assign_fail_msg         |
++---------------------------------------------------------------------+
+
+  PURPOSE : send ASSIGNMENT FAILURE to network.
+
+*/
+void dat_send_assign_fail_msg(UBYTE cause)
+{
+  GET_INSTANCE_DATA;
+  MCAST (assign_fail, U_ASSIGN_FAIL);
+  PALLOC_MSG (dl_reconnect_req, DL_RECONNECT_REQ, U_ASSIGN_FAIL);
+  assign_fail->msg_type = U_ASSIGN_FAIL;
+  assign_fail->rr_cause = cause;
+  dat_code_prr_channel (&dl_reconnect_req->ch_type,
+                        &dl_reconnect_req->sapi,
+                        rr_data->sc_data.chan_desc.chan_type);
+
+  /*
+   * start reconnection in layer 2.
+   */
+  for_dat_reconnect_req (dl_reconnect_req);
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_send_rr_status_msg           |
++---------------------------------------------------------------------+
+
+  PURPOSE : send RR STATUS to network
+
+*/
+void dat_send_rr_status_msg(UBYTE cause)
+{
+  GET_INSTANCE_DATA;
+
+  MCAST (rr_status, B_RR_STATUS);
+  PALLOC_MSG (dl_data_req, DL_DATA_REQ, B_RR_STATUS);
+
+  /*
+   * set channel type and SAPI
+   */
+  dat_code_prr_channel (&dl_data_req->ch_type,
+                        &dl_data_req->sapi,
+                        rr_data->sc_data.chan_desc.chan_type);
+
+  rr_status->msg_type = B_RR_STATUS;
+  rr_status->rr_cause = cause;
+
+  EM_RR_STATUS_SEND;
+
+  for_dat_data_req (dl_data_req);
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_send_handov_fail_msg         |
++---------------------------------------------------------------------+
+
+  PURPOSE : send HANDOVER FAILURE to network
+
+*/
+void dat_send_handov_fail_msg(UBYTE cause)
+{
+  GET_INSTANCE_DATA;
+  MCAST (handov_fail, U_HANDOV_FAIL);
+  PALLOC_MSG (dl_reconnect_req, DL_RECONNECT_REQ, U_HANDOV_FAIL);
+
+  /*
+   * set channel type and sapi for the reconnection.
+   */
+  dat_code_prr_channel (&dl_reconnect_req->ch_type,
+                        &dl_reconnect_req->sapi,
+                        rr_data->sc_data.chan_desc.chan_type);
+
+  handov_fail->rr_cause = cause;
+  handov_fail->msg_type = U_HANDOV_FAIL;
+
+  /*
+   * reconnect layer 2 link.
+   */
+  for_dat_reconnect_req (dl_reconnect_req);
+}
+
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_update_emr_data         |
++---------------------------------------------------------------------+
+
+  PURPOSE : Updates the enhanced measurement parameters, other than
+  BSIC and reporting priority.
+
+*/
+GLOBAL void dat_update_emr_rep_para(T_emp *p_em, T_enh_para_struct *p_enh)
+{  
+  p_enh->scale_order = p_em->scale_ord;
+  if (p_em->v_serv_band_rep EQ TRUE)
+    p_enh->servingband_rep = p_em->serv_band_rep;
+  if (p_em->v_mr EQ TRUE )
+    p_enh->multiband_rep = p_em->mr;
+    
+  /* Update reporting thresholds and reporting offsets*/
+  if (p_em->v_report_900 EQ TRUE)
+  {
+    p_enh->enh_rep_data[0].rep_offset = p_em->report_900.rep_offset_900;
+    p_enh->enh_rep_data[0].rep_offset = p_em->report_900.th_rep_900;
+  }
+  if (p_em->v_report_1800 EQ TRUE)
+  {
+    p_enh->enh_rep_data[1].rep_offset = p_em->report_1800.rep_offset_1800;
+    p_enh->enh_rep_data[1].rep_offset = p_em->report_1800.th_rep_1800;
+  }
+  if (p_em->v_report_400 EQ TRUE)
+  {
+    p_enh->enh_rep_data[2].rep_offset = p_em->report_400.rep_offset_400;
+    p_enh->enh_rep_data[2].rep_offset = p_em->report_400.th_rep_400;
+  }
+  if (p_em->v_report_1900 EQ TRUE)
+  {
+    p_enh->enh_rep_data[3].rep_offset = p_em->report_1900.rep_offset_1900;
+    p_enh->enh_rep_data[3].rep_offset = p_em->report_1900.th_rep_1900;
+  }
+  if (p_em->v_report_850 EQ TRUE)
+  {
+    p_enh->enh_rep_data[4].rep_offset = p_em->report_850.rep_offset_850;
+    p_enh->enh_rep_data[4].rep_offset = p_em->report_850.th_rep_850;
+  }
+  return;
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_code_enh_measure_report         |
++---------------------------------------------------------------------+
+
+  PURPOSE : Forms enhanced measurement report and sends it to DL as a
+  message with short PD.
+*/
+GLOBAL void dat_code_enh_measure_report(T_MPH_MEASUREMENT_IND *report)
+{
+  GET_INSTANCE_DATA;
+  UBYTE     size_avail = MSG_SIZE_EMR - MAND_SIZE_EMR;
+  MCAST (meas_emr, U_EMR);
+  PALLOC_MSG (dl_data, DL_SHORT_UNITDATA_REQ, U_EMR);
+  
+  TRACE_FUNCTION ("dat_code_enh_measure_report()");
+  memset (&dl_data->sdu.buf[0], 0, dl_data->sdu.o_buf / BITS_PER_BYTE); 
+  /* initialize C-structure for the Uplink message */
+  memset (meas_emr, 0, sizeof (T_U_EMR));
+  meas_emr->msg_type = U_EMR;
+  meas_emr->sl2h     = SL2H_0;
+
+  if (report->valid EQ TRUE)
+  {
+    T_enh_para_struct *src = &rr_data->sc_data.emr_data_current.enh_para;       
+    
+    /* Fill the non-measurement paramaters */    
+    meas_emr->ba_ind = rr_data->sc_data.ba_index;
+    meas_emr->scale = report->scale_used;
+    /* Now fill serving cell data */
+    if (report->rxlev_val NEQ 0)
+    {
+      meas_emr->v_scdata = TRUE;
+      meas_emr->scdata.rxlev = report->rxlev_val;
+      meas_emr->scdata.rxqual_full = report->rx_qual_full;
+      meas_emr->scdata.mean_bep = report->mean_bep;
+      meas_emr->scdata.cv_bep = report->cv_bep;
+      meas_emr->scdata.nr_rcvd_bl = report->nbr_rcvd_blks;
+      meas_emr->scdata.dtx_used = report->dtx;
+      size_avail -= SC_INFO_SIZE_EMR; 
+    }  
+    
+    /* Fill neighbour cell measurements */
+    if (report->ncells.no_of_ncells > 0)
+    {
+      UBYTE         i;
+      UBYTE         j;
+      UBYTE         highest_index = 0;
+      UBYTE         index_0 = 1;/*To decrement size by 1 when index is 0*/
+      ULONG         bit_map=0;
+      
+      
+      meas_emr->em_rep.c_rep_q_arr  = meas_emr->c_i_bsic_i = 0;
+      for (i =0; i < report->ncells.no_of_ncells; i++ )
+      {
+        j = report->nc_index[i];
+        /*Decide whether it is a valid BSIC cell or not*/
+        if ( j NEQ NOT_PRESENT_8BIT )
+        {
+          /*This is an valid BSIC cell*/
+          /*Check the priority of the cell*/
+          if ( (src->rep_rate EQ REDUCED_REP_RATE) AND 
+           (src->enh_cell_list[j].rep_priority EQ REP_PRIOR_NORM ))
+          {
+            /*Proceed further only if the cell has not been included-
+              in any report till now or if it's the time to include this
+              cell in the report*/
+            if ( (rr_data->sc_data.rep_count[j] NEQ rr_data->sc_data.emr_count ) AND
+                 (rr_data->sc_data.rep_count[j] NEQ NOT_PRESENT_8BIT ) )
+            {
+              bit_map |= (1<<i);
+              continue; /* Include this cell at the end only if size is available*/
+            }                 
+          }
+          meas_emr->em_rep.rep_q_arr[j].rep_q   = report->ncells.rx_lev[i];
+          
+          if ( j > highest_index ) 
+          {
+          /*When the place where the RXLEV has to be filled requires
+          additional bits in bit map, then we have to account for
+            these single bits and additional 6 bits for RXLEV*/
+            if (size_avail >= (j - highest_index)+6 + index_0 )
+            {
+            /*This means we require atleast j-highest_index+6 bits in bit map to 
+              include this rxlev*/
+              /* 6 bits for RXLEV itself*/                
+              size_avail = size_avail- (j-highest_index+6+index_0) ;
+              highest_index = j;
+              meas_emr->em_rep.c_rep_q_arr =  j+1; /*counter is index+1*/
+              index_0 = 0;  
+              meas_emr->em_rep.rep_q_arr[j].v_rep_q = TRUE;  
+              rr_data->sc_data.rep_count[j] = rr_data->sc_data.emr_count;
+            }             
+          }
+          else if (size_avail >= 6 + index_0)
+          {              
+            size_avail -= (6+index_0); /* size for bit map is already accounted for*/              
+            meas_emr->em_rep.c_rep_q_arr = highest_index +1;
+            index_0 = 0;   
+            meas_emr->em_rep.rep_q_arr[j].v_rep_q = TRUE;  
+            rr_data->sc_data.rep_count[j] = rr_data->sc_data.emr_count;
+          }
+        } /* if j NEQ NOT_PRESENT_8BIT  */
+        else
+        {
+          /*This is a Invalid BSIC cell*/
+          /*fill in invalid BSIC list since cell is not present in the neighbour cell
+          list. Here the index that needs to be filled is index of the ARFCN in BA(list)*/
+          if ( size_avail > NC_INVBSIC_EMR )
+          {            
+            meas_emr->i_bsic_i[meas_emr->c_i_bsic_i].ba_start_bsic = 
+              dat_get_ncell_pos (report->ncells.arfcn[i]);
+            meas_emr->i_bsic_i[meas_emr->c_i_bsic_i].bsic     = report->ncells.bsic[i] ;
+            meas_emr->i_bsic_i[meas_emr->c_i_bsic_i++].rxlev  = report->ncells.rx_lev[i];
+            size_avail -= NC_INVBSIC_EMR;            
+          }   
+        }
+        if (size_avail < 6) /*no more cells can be included*/
+          break;
+      } /* for 'i'*/    
+
+      /*All the low priority cells have to be filled in valid BSIC bmp reporting,
+       if still there's size available*/
+      i = 0;
+      while ( (bit_map NEQ 0) AND (size_avail >= 6) )
+      {
+        if ( ((bit_map >> i ) & (NOT_PRESENT_32BIT)) EQ TRUE )
+        {
+          j = report->nc_index[i];
+          meas_emr->em_rep.rep_q_arr[j].rep_q   = report->ncells.rx_lev[i];          
+          if ( j > highest_index ) 
+          {
+            /*When the place where the RXLEV has to be filled requires
+            additional bits in bit map, then we have to account for
+            these single bits and additional 6 bits for RXLEV*/
+            if (size_avail >= (j - highest_index)+6 + index_0 )
+            {
+            /*This means we require atleast j-highest_index+6 bits in bit map to 
+              include this rxlev*/
+              /* 6 bits for RXLEV itself*/                
+              size_avail = size_avail- (j-highest_index+6+index_0) ;
+              highest_index = j;
+              meas_emr->em_rep.c_rep_q_arr =  j+1; /*counter is index+1*/
+              index_0 = 0;  
+              meas_emr->em_rep.rep_q_arr[j].v_rep_q = TRUE;  
+              rr_data->sc_data.rep_count[j] = rr_data->sc_data.emr_count;
+            }             
+          }
+          else if (size_avail >= 6 + index_0)
+          {              
+            size_avail -= (6+index_0); /* size for bit map is already accounted for*/              
+            meas_emr->em_rep.c_rep_q_arr = highest_index +1;
+            index_0 = 0;   
+            meas_emr->em_rep.rep_q_arr[j].v_rep_q = TRUE;  
+            rr_data->sc_data.rep_count[j] = rr_data->sc_data.emr_count;
+          }
+          else
+            break;
+          bit_map = bit_map &  ( ~ ((ULONG)( 1 << i))); /*reset the corresponding bit in bit map*/
+        }
+      }/*while bit_map*/
+      if (meas_emr->em_rep.c_rep_q_arr > 0)
+        meas_emr->v_em_rep = TRUE;
+      if (meas_emr->c_i_bsic_i > 0)
+      {
+        meas_emr->v_i_bsic_i = TRUE;      
+        meas_emr->bsic_seen = report->bsic_seen;
+      }        
+    } /* if 'report->ncells.no_of_ncells'*/     
+    
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+    /*Fill the report with '0's till the end of message or upto 96 cells  */    
+    while ( (size_avail > 0) AND (meas_emr->em_rep.c_rep_q_arr < 96 ) )
+    {
+      /* There are cells in GSM NC list for which bit map has to be set to '0' 
+         earlier memset takes care of this. we just need to set the counter appropriately*/
+      meas_emr->em_rep.c_rep_q_arr++;
+      size_avail--;
+    }
+#else
+    if ( meas_emr->em_rep.c_rep_q_arr < src->num_valid_cells )
+    {
+      /* There are cells in GSM NC list for which bit map has to be set to '0' 
+         earlier memset takes care of this. we just need to set the counter appropriately*/
+      meas_emr->em_rep.c_rep_q_arr = src->num_valid_cells;      
+    }
+    dl_data->ccd_assist = meas_emr->em_rep.nnc = meas_emr->em_rep.c_rep_q_arr; 
+#endif
+    rr_data->sc_data.emr_count = (rr_data->sc_data.emr_count +1) & 0x03; /*MOD4 addition*/    
+  }
+  else
+  {   
+    /*
+     * measurement report from layer 1 is invalid
+     */
+    TRACE_EVENT ("invalid meas_emr");  
+    /*A dummy msg with all options as FALSE will go in this case, to network.
+     may be useful to maintain periodicity*/
+  }
+  /* Send the message to DL */
+  
+  for_dat_spd_unitdata_req(dl_data);
+}
+#endif
+
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_update_rtd_data         |
++---------------------------------------------------------------------+
+
+  PURPOSE : Updates the real time difference parameters received on MEAS_INFO message.
+*/
+GLOBAL void dat_update_rtd_data(T_D_MEAS_INF *p_mi,T_rr_enh_para *p_temp)
+{
+T_rtdd *rtdd_struct= &p_mi->rtdd;
+dat_update_common_rtd_struct(rtdd_struct,p_temp);
+
+} /* end dat_update_rtd_data()*/
+
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_DAT                           |
+| STATE   : code           ROUTINE : dat_update_common_rtd_struct     |
++---------------------------------------------------------------------+
+
+  PURPOSE : Common function called from for_store_rtd_data() to store 
+  rtd parameters received on si2 quater message and update the same on receiving 
+  meas_info message via function dat_update_rtd_data().
+*/
+
+GLOBAL void dat_update_common_rtd_struct(T_rtdd *rtdd,T_rr_enh_para *p_temp)
+{
+UBYTE     i,j,rtd_index,max_rtd_values;
+  
+  if(rtdd->v_rtdd6 EQ TRUE)
+  {
+    if(rtdd->rtdd6.v_ba_start_rtd EQ TRUE)
+      rtd_index = rtdd->rtdd6.ba_start_rtd;
+    else
+      rtd_index = RTD_DEFAULT_INDEX;
+    
+    if( rtd_index < MAX_NR_OF_NCELL)
+    {
+      p_temp->enh_para.enh_cell_list[rtd_index].v_rtd =  TRUE;
+      max_rtd_values = rtdd->rtdd6.rtds6.c_rtd6 > MAX_NUM_OF_RTD_VALUES ?
+                      MAX_NUM_OF_RTD_VALUES : rtdd->rtdd6.rtds6.c_rtd6;
+      for(i = 0;i < max_rtd_values;i++)
+        p_temp->enh_para.enh_cell_list[rtd_index].rtd[i] = rtdd->rtdd6.rtds6.rtd6[i];
+      p_temp->enh_para.enh_cell_list[rtd_index].c_rtd= max_rtd_values;
+    } /*if*/
+    
+    for(j = 0;j < rtdd->rtdd6.c_rtds6_add;j++)
+    {
+      rtd_index++;
+      if( rtd_index < MAX_NR_OF_NCELL)
+      {
+        p_temp->enh_para.enh_cell_list[rtd_index].v_rtd = TRUE;
+        max_rtd_values = rtdd->rtdd6.rtds6_add[j].c_rtd6 > MAX_NUM_OF_RTD_VALUES ?
+                           MAX_NUM_OF_RTD_VALUES : rtdd->rtdd6.rtds6_add[j].c_rtd6;
+        for(i = 0;i < max_rtd_values;i++)
+          p_temp->enh_para.enh_cell_list[rtd_index].rtd[i] = rtdd->rtdd6.rtds6_add[j].rtd6[i];
+        p_temp->enh_para.enh_cell_list[rtd_index].c_rtd= max_rtd_values;
+      } /*if*/
+    } /*for*/
+  } /*if*/
+  if(rtdd->v_rtdd12 EQ TRUE)
+  {
+    if(rtdd->rtdd12.v_ba_start_rtd EQ TRUE)
+      rtd_index = rtdd->rtdd12.ba_start_rtd;
+    else
+      rtd_index = RTD_DEFAULT_INDEX;
+    
+    if( rtd_index < MAX_NR_OF_NCELL)
+    {
+      p_temp->enh_para.enh_cell_list[rtd_index].v_rtd = TRUE;
+      max_rtd_values = rtdd->rtdd12.rtds12.c_rtd12 > MAX_NUM_OF_RTD_VALUES ?
+                        MAX_NUM_OF_RTD_VALUES: rtdd->rtdd12.rtds12.c_rtd12;
+      for(i = 0;i < max_rtd_values;i++)
+      {
+        p_temp->enh_para.enh_cell_list[rtd_index].rtd[i] =RTD_12BIT;
+        p_temp->enh_para.enh_cell_list[rtd_index].rtd[i] |= rtdd->rtdd12.rtds12.rtd12[i];
+      } /*for*/
+      p_temp->enh_para.enh_cell_list[rtd_index].c_rtd= max_rtd_values;
+    } /*if*/
+    for(j = 0;j < rtdd->rtdd12.c_rtds12_add;j++)
+    {
+      rtd_index++;
+      if(rtd_index < MAX_NR_OF_NCELL)
+      {
+        p_temp->enh_para.enh_cell_list[rtd_index].v_rtd = TRUE;
+        max_rtd_values = rtdd->rtdd12.rtds12_add[j].c_rtd12 > MAX_NUM_OF_RTD_VALUES ?
+                          MAX_NUM_OF_RTD_VALUES : rtdd->rtdd12.rtds12_add[j].c_rtd12;
+        for(i = 0;i < max_rtd_values;i++)
+        {
+          p_temp->enh_para.enh_cell_list[rtd_index].rtd[i] = RTD_12BIT;
+          p_temp->enh_para.enh_cell_list[rtd_index].rtd[i] |= rtdd->rtdd12.rtds12_add[j].rtd12[i];
+        } /*for*/
+        p_temp->enh_para.enh_cell_list[rtd_index].c_rtd= max_rtd_values;
+      } /*if*/
+    } /*for*/
+  } /*if*/
+} /* end of dat_update_common_rtd_struct() */
+
+
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+
+#endif