/*
+-----------------------------------------------------------------------------
|  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