--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gsm-fw/g23m-gsm/rr/rr_em.c	Sun Sep 28 23:20:04 2014 +0000
@@ -0,0 +1,2107 @@
+/*	
++-----------------------------------------------------------------------------
+|  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 engineering mode (EM) device driver for the
+|             G23 protocol stack. This driver is used to control all engineering
+|             mode related functions.
++-----------------------------------------------------------------------------
+*/
+
+#ifndef RR_EM_C
+#define RR_EM_C
+
+#define ENTITY_RR
+
+/*==== INCLUDES ===================================================*/
+
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>     /* offsetof */
+#include <stdio.h>      /* sprintf */
+#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 =====================================================*/
+
+/*==== VARIABLES ==================================================*/
+
+#ifdef FF_EM_MODE
+
+/*
+  These variables are used between entities. Even this is not a clean solution it is a straigth forward
+  way to reduce the overhead to a minimum. A clean solution would be based on an only usage of primitives
+  which would stress the os with no aditional advantage!!
+*/
+/* these are accessed by ACI */
+GLOBAL UBYTE    em_rr_sem_buffer [EM_RR_SEM_SIZE]; /*lint -esym(552,em_rr_sem_buffer) -esym(765,em_rr_sem_buffer ) */
+GLOBAL UBYTE    em_rr_sem_index;                  /*lint -esym(765,em_rr_sem_index)*/
+GLOBAL UBYTE    em_act_dlt = 0; /*lint -esym(765,em_act_dlt) | used by ALR */
+GLOBAL UBYTE    em_act_rlt = 0; /*lint -esym(765,em_act_rlt) | used by ALR */
+
+static USHORT ma [MAX_MA_CHANNELS];     /* MA list after starting time */
+static USHORT ma2[MAX_MA_CHANNELS];     /* MA list before starting time if available */
+static UBYTE  v_start=0;                  /* starting time valid */
+static UBYTE  maio2=0;
+
+static T_HANDLE  sem_EM_RR;
+static UBYTE em_rr_trace_occured;
+
+
+/* Event tracing flags for EM */
+GLOBAL BOOL rr_v[EM_MAX_RR_EVENTS];
+GLOBAL USHORT em_assign_fail_rr_cause;
+GLOBAL USHORT em_handover_fail_rr_cause;
+
+LOCAL void em_rr_sem_clear (void);
+LOCAL void rr_em_first_event_check(void);
+
+#endif /* FF_EM_MODE */
+
+/*==== FUNCTIONS ==================================================*/
+#ifdef FF_EM_MODE
+
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_get_hchn
++------------------------------------------------------------------------------
+|  Description  :  This function stores the hopping channels after change occured.
+|
+|  Parameters   :  channel_array  - channel mode 1
+|                  channel2_array - channel mode 2
+|                  start          - valid flag for channel mode2
+|                  maio_2         - MAIO for before time configuration
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void dat_em_get_hchn (USHORT* channel_array, USHORT* channel2_array, UBYTE start,UBYTE maio_2)
+{
+ TRACE_FUNCTION ("dat_em_get_hchn()");
+
+ memset(ma, 0, 65);
+ memset(ma2, 0, 65);
+ memcpy(ma, channel_array, 65);
+ v_start = start;
+ if (v_start) {
+  maio2 = maio_2;
+  memcpy(ma2, channel2_array, 65); }
+}
+/*
++------------------------------------------------------------------------------
+|  Function     :  em_init_get_hchn
++------------------------------------------------------------------------------
+|  Description  :  initiates the hopping list. This is necessary, because a request
+|                  of the hopping list immideatly after switch on causes a reset.
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void em_init_get_hchn ()
+{
+ TRACE_FUNCTION ("em_init_get_hchn()");
+
+ ma[0]  = NOT_PRESENT_16BIT;
+ ma2[0] = NOT_PRESENT_16BIT;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  em_get_first_codec
++------------------------------------------------------------------------------
+|  Description  :  Returns the highest bit rate AMR codec mode
+|  
+|  Parameters   :  acs - Active codec set
+|                  
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+
+GLOBAL UBYTE em_get_first_codec(UBYTE acs)
+{
+  UBYTE i;
+ 
+  /* Find Highest bit rate codec mode from ACS */
+  for(i=0;i<8;i++)
+  {
+    if((0x80>>i) & acs )
+      break;
+  }
+
+  /* First codec( Highest bit rate codec mode) */
+  return (EM_AMR_MODE_12_2-i);
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_sc_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_SC_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_SC_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_sc_info_req (T_EM_SC_INFO_REQ *em_sc_info_req)
+{
+  GET_INSTANCE_DATA;
+  PALLOC(em_sc_info_cnf, EM_SC_INFO_CNF);
+  memset (em_sc_info_cnf, 0, sizeof (T_EM_SC_INFO_CNF));
+ 
+  PFREE(em_sc_info_req);
+  TRACE_FUNCTION ("dat_em_sc_info_req()");
+
+  em_sc_info_cnf->vocoder = EM_VOC_NA;
+
+  switch (GET_STATE (STATE_ATT))
+  {
+    case ATT_IDLE:
+      if (rr_data->nc_data[SC_INDEX].bcch_status EQ DECODED)
+      {
+        em_sc_info_cnf->arfcn   = rr_data->nc_data[SC_INDEX].arfcn;
+        em_sc_info_cnf->c1      = rr_data->nc_data[SC_INDEX].c1;
+        em_sc_info_cnf->c2      = rr_data->nc_data[SC_INDEX].c2;
+        em_sc_info_cnf->rxlev   = rr_data->nc_data[SC_INDEX].rxlev;
+        em_sc_info_cnf->bsic    = rr_data->nc_data[SC_INDEX].bsic;
+        em_sc_info_cnf->dsc     = em_act_dlt;
+        em_sc_info_cnf->txlev   = rr_data->sc_data.cd.cell_options.pow_ctrl;
+        em_sc_info_cnf->tn      = rr_data->sc_data.chan_desc.tn;
+        em_sc_info_cnf->lac     = rr_data->nc_data[SC_INDEX].lai.lac;
+        em_sc_info_cnf->cba     = rr_data->nc_data[SC_INDEX].rach.cell_bar_access;
+        em_sc_info_cnf->cbq     = rr_data->nc_data[SC_INDEX].c2_par.cbq;
+        em_sc_info_cnf->cell_id = rr_data->nc_data[SC_INDEX].cell_id;
+        em_sc_info_cnf->cell_type_ind = EM_CELL_GSM;
+#ifdef GPRS
+        if(rr_data->nc_data[SC_INDEX].rac NEQ NOT_PRESENT_8BIT)
+          em_sc_info_cnf->cell_type_ind = EM_CELL_GPRS;
+#endif
+      }
+      else if (rr_data->nc_data[SC_INDEX].bcch_status EQ NON_DECODED)
+      {
+        em_sc_info_cnf->arfcn   = rr_data->nc_data[SC_INDEX].arfcn;
+        em_sc_info_cnf->rxlev   = rr_data->nc_data[SC_INDEX].rxlev;
+        em_sc_info_cnf->bsic    = rr_data->nc_data[SC_INDEX].bsic;
+      }
+      break;
+
+    case ATT_DEDICATED:
+      if (!rr_data->ms_data.measurement_report.valid)
+        break;
+
+      em_sc_info_cnf->arfcn    = rr_data->ms_data.measurement_report.arfcn;
+      em_sc_info_cnf->bsic     = rr_data->nc_data[SC_INDEX].bsic;
+      em_sc_info_cnf->txlev    = rr_data->sc_data.cd.cell_options.pow_ctrl;
+      em_sc_info_cnf->tn       = rr_data->sc_data.chan_desc.tn;
+      em_sc_info_cnf->lac      = rr_data->nc_data[SC_INDEX].lai.lac;
+      em_sc_info_cnf->cell_id  = rr_data->nc_data[SC_INDEX].cell_id;
+      em_sc_info_cnf->rxlev_f  = rr_data->ms_data.measurement_report.rx_lev_full;
+      em_sc_info_cnf->rxlev_s  = rr_data->ms_data.measurement_report.rx_lev_sub;
+      em_sc_info_cnf->rlt      = em_act_rlt;
+      em_sc_info_cnf->tav      = rr_data->sc_data.new_ta;
+      em_sc_info_cnf->rxqual_f = rr_data->ms_data.measurement_report.rx_qual_full;
+      em_sc_info_cnf->rxqual_s = rr_data->ms_data.measurement_report.rx_qual_sub;
+      em_sc_info_cnf->vocoder  = rr_data->sc_data.ch_mode;
+      if (rr_data->nc_data[SC_INDEX].bcch_status EQ DECODED)
+      {
+        em_sc_info_cnf->cell_type_ind = EM_CELL_GSM;
+#ifdef GPRS
+        if(rr_data->nc_data[SC_INDEX].rac NEQ NOT_PRESENT_8BIT)
+          em_sc_info_cnf->cell_type_ind = EM_CELL_GPRS;
+#endif
+      }
+      break;
+
+    default:
+      break;
+  }/*switch*/
+  PSENDX(MMI, em_sc_info_cnf);
+} /*dat_em_sc_info_req*/
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_nc_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_NC_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_NC_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_nc_info_req (T_EM_NC_INFO_REQ *em_nc_info_req)
+{
+  GET_INSTANCE_DATA;
+  UBYTE index = 0;
+  UBYTE index2 = 0;
+  PALLOC(em_nc_info_cnf, EM_NC_INFO_CNF);
+  memset (em_nc_info_cnf, 0, sizeof (T_EM_NC_INFO_CNF));
+  memset (em_nc_info_cnf->rac, 0xff, EM_MAX_NUM_NC);
+
+  PFREE(em_nc_info_req);
+  TRACE_FUNCTION ("dat_em_nc_info_req()");
+
+  switch (GET_STATE (STATE_ATT))
+  {
+    case ATT_IDLE:
+      for (index = 0 , index2 = 0 ; index < EM_MAX_NUM_NC ; index++)
+      {
+        if (rr_data->nc_data[index].bcch_status EQ DECODED)
+        {
+          em_nc_info_cnf->arfcn_nc[index2]    = rr_data->nc_data[index].arfcn;
+          em_nc_info_cnf->c1_nc[index2]       = rr_data->nc_data[index].c1;
+          em_nc_info_cnf->c2_nc[index2]       = rr_data->nc_data[index].c2;
+          em_nc_info_cnf->rxlev_nc[index2]    = rr_data->nc_data[index].rxlev;
+          em_nc_info_cnf->bsic_nc[index2]     = rr_data->nc_data[index].bsic;
+          em_nc_info_cnf->cell_id_nc[index2]  = rr_data->nc_data[index].cell_id;
+          em_nc_info_cnf->lac_nc[index2]      = rr_data->nc_data[index].lai.lac;
+          em_nc_info_cnf->frame_offset[index2]      = rr_data->ms_data.measurement_report.ncells.frame_offset[index];
+          em_nc_info_cnf->time_alignmt[index2]      = rr_data->ms_data.measurement_report.ncells.time_alignmt[index];
+          em_nc_info_cnf->cba_nc[index2]      = rr_data->nc_data[index].rach.cell_bar_access;
+          em_nc_info_cnf->cbq_nc[index2]      = rr_data->nc_data[index].c2_par.cbq;
+          em_nc_info_cnf->cell_type_ind[index2]     = EM_CELL_GSM;
+#ifdef GPRS
+          em_nc_info_cnf->rac[index2]               = rr_data->nc_data[index].rac;
+
+          /* rac in nc_data is set only when v_gprs_ind is present in SI3/SI4 rest
+             octets. Since v_gprs_ind is not stored,rac is used to check gprs 
+             support in the cell */
+          if(em_nc_info_cnf->rac[index2] NEQ NOT_PRESENT_8BIT)
+            em_nc_info_cnf->cell_type_ind[index2]   = EM_CELL_GPRS; 
+#endif
+          em_nc_info_cnf->cell_resel_offset[index2] = rr_data->nc_data[index].c2_par.cell_reselect_offset;
+          em_nc_info_cnf->temp_offset[index2]       = rr_data->nc_data[index].c2_par.temp_offset;
+          em_nc_info_cnf->rxlev_acc_min[index2]     = rr_data->nc_data[index].select_para.rxlev_access_min;
+          index2++;
+        } /* if decoded */
+
+        else if (rr_data->nc_data[index].bcch_status EQ NON_DECODED)
+        {
+          em_nc_info_cnf->arfcn_nc[index2]   = rr_data->nc_data[index].arfcn;
+          em_nc_info_cnf->rxlev_nc[index2]   = rr_data->nc_data[index].rxlev;
+          em_nc_info_cnf->bsic_nc[index2]    = rr_data->nc_data[index].bsic;
+          index2++;
+        } /* if non decoded */
+      } /* for */
+      em_nc_info_cnf->no_ncells = rr_data->ms_data.measurement_report.ncells.no_of_ncells;
+      break;
+
+    case ATT_DEDICATED:
+      {
+        if (!rr_data->ms_data.measurement_report.valid)
+          break;
+
+        em_nc_info_cnf->no_ncells = rr_data->ms_data.measurement_report.ncells.no_of_ncells;
+
+        for (index = 0; index< rr_data->ms_data.measurement_report.ncells.no_of_ncells; index++)
+        {
+          /*in the measurement report the cells are ordered by fieldstrength*/
+          em_nc_info_cnf->arfcn_nc[index]    = rr_data->ms_data.measurement_report.ncells.arfcn[index];
+          em_nc_info_cnf->rxlev_nc[index]    = rr_data->ms_data.measurement_report.ncells.rx_lev[index];
+          em_nc_info_cnf->bsic_nc[index]     = rr_data->ms_data.measurement_report.ncells.bsic[index];
+          em_nc_info_cnf->frame_offset[index]= rr_data->ms_data.measurement_report.ncells.frame_offset[index];
+          em_nc_info_cnf->time_alignmt[index]= rr_data->ms_data.measurement_report.ncells.time_alignmt[index];
+        } /*for*/
+      }/*case*/
+      break;
+
+    default:
+      break;
+  }/*switch*/
+  PSENDX(MMI, em_nc_info_cnf);
+}/*dat_em_nc_info_req*/
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_loc_pag_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_LOC_PAG_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_LOC_PAG_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_loc_pag_info_req (T_EM_LOC_PAG_INFO_REQ *em_loc_pag_info_req)
+{
+  GET_INSTANCE_DATA;
+  PALLOC(em_loc_pag_info_cnf, EM_LOC_PAG_INFO_CNF);
+  memset (em_loc_pag_info_cnf, 0, sizeof (T_EM_LOC_PAG_INFO_CNF));
+
+  PFREE(em_loc_pag_info_req);
+  TRACE_FUNCTION ("dat_em_loc_pag_info_req()");
+
+  if (rr_data->nc_data[SC_INDEX].bcch_status EQ DECODED)
+  {
+    memcpy(em_loc_pag_info_cnf->mcc, rr_data->nc_data[SC_INDEX].lai.mcc, SIZE_MCC);
+
+    /*check for MNC with 2 digits*/
+	/* Fixed for Issue 21468 */
+    if (rr_data->nc_data[SC_INDEX].lai.mnc[2] NEQ 0xF) /*defines a 3 digit NMC*/
+    {
+      memcpy(em_loc_pag_info_cnf->mnc, rr_data->nc_data[SC_INDEX].lai.mnc, SIZE_MNC);
+    }
+    else /*2 digit -> leave the first value empty*/
+    {
+      em_loc_pag_info_cnf->mnc[1] = rr_data->nc_data[SC_INDEX].lai.mnc[0];
+      em_loc_pag_info_cnf->mnc[2] = rr_data->nc_data[SC_INDEX].lai.mnc[1];
+    }
+
+    em_loc_pag_info_cnf->bs_pa_mfrms  = rr_data->nc_data[SC_INDEX].control_descr.bs_pa_mfrms;
+    em_loc_pag_info_cnf->t3212        = rr_data->nc_data[SC_INDEX].control_descr.t3212;
+  }
+
+  if (rr_data->ms_data.tmsi_available EQ TRUE)
+    em_loc_pag_info_cnf->tmsi       = rr_data->ms_data.tmsi_binary;
+
+  PSENDX(MMI, em_loc_pag_info_cnf);
+}/*dat_em_loc_pag_info_req*/
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_plmn_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_PLMN_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_PLMN_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_plmn_info_req (T_EM_PLMN_INFO_REQ *em_plmn_info_req)
+{
+  GET_INSTANCE_DATA;
+  PALLOC(em_plmn_info_cnf, EM_PLMN_INFO_CNF);
+  memset (em_plmn_info_cnf, 0, sizeof (T_EM_PLMN_INFO_CNF));
+  
+  PFREE(em_plmn_info_req);
+  TRACE_FUNCTION ("dat_em_plmn_info_req()");
+
+  em_plmn_info_cnf->no_creq_max = rr_data->nc_data[SC_INDEX].rach.max_retrans;
+  em_plmn_info_cnf->reest_flag  = rr_data->nc_data[SC_INDEX].rach.re;
+  em_plmn_info_cnf->txpwr_max   = rr_data->nc_data[SC_INDEX].select_para.ms_txpwr_max_cch;
+  em_plmn_info_cnf->rxlev_min   = rr_data->nc_data[SC_INDEX].select_para.rxlev_access_min;
+  em_plmn_info_cnf->rel_cause   = 0xff; /* these info will be parsed by aci */
+
+  PSENDX(MMI, em_plmn_info_cnf);
+}/*dat_em_plmn_info_req*/
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_cip_hop_dtx_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_CIP_HOP_DTX_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_CIP_HOP_DTX_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_cip_hop_dtx_info_req (T_EM_CIP_HOP_DTX_INFO_REQ *em_cip_hop_dtx_info_req)
+{
+  GET_INSTANCE_DATA;
+  UBYTE i;
+  PALLOC(em_cip_hop_dtx_info_cnf, EM_CIP_HOP_DTX_INFO_CNF);
+  memset (em_cip_hop_dtx_info_cnf, 0, sizeof (T_EM_CIP_HOP_DTX_INFO_CNF));
+
+  PFREE(em_cip_hop_dtx_info_req);
+  TRACE_FUNCTION ("dat_em_cip_hop_dtx_info_req()");
+
+  /* Intialize to 0xffff. No hopping channels */
+  em_cip_hop_dtx_info_cnf->hop_chn.ma[0]  = NOT_PRESENT_16BIT;
+  em_cip_hop_dtx_info_cnf->hop_chn2.ma[0] = NOT_PRESENT_16BIT;
+  
+  if((GET_STATE(STATE_ATT) EQ ATT_DEDICATED) AND 
+	                            (GET_STATE(STATE_DAT) EQ DAT_DEDICATED))
+  {
+    /* cipher status */
+    em_cip_hop_dtx_info_cnf->ciph_stat = rr_data->sc_data.ciph_on;
+
+    /* Hopping status */
+    em_cip_hop_dtx_info_cnf->hop = rr_data->sc_data.chan_desc.hop;
+
+    if (rr_data->sc_data.chan_desc.hop EQ H_NO)
+    { /* Hopping is not configured */
+      em_cip_hop_dtx_info_cnf->arfcn = rr_data->sc_data.chan_desc.arfcn;
+    }
+    else
+    { /* hopping sequence no   */
+      em_cip_hop_dtx_info_cnf->hsn    = rr_data->sc_data.chan_desc.hsn;
+    }
+
+    if(em_cip_hop_dtx_info_cnf->hop NEQ H_NO)
+    {
+      /* MAIO */
+      em_cip_hop_dtx_info_cnf->hop_chn.maio = rr_data->sc_data.chan_desc.maio;
+
+      i=0;
+      while((i<MAX_MA_CHANNELS) AND (ma[i] NEQ NOT_PRESENT_16BIT))
+      {
+        em_cip_hop_dtx_info_cnf->hop_chn.ma[i] = ma[i];
+        i++;
+      }
+    
+      /* Number of hopping channels */
+      em_cip_hop_dtx_info_cnf->hop_chn.nr_arfcns = i;
+      if(i < MAX_MA_CHANNELS) 
+      {
+        em_cip_hop_dtx_info_cnf->hop_chn.ma[i] = NOT_PRESENT_16BIT;
+      }
+
+      /* starting time status */
+      em_cip_hop_dtx_info_cnf->v_start = v_start;
+  
+      /* Hopping list after time */
+      if (v_start)
+      {
+        /* MAIO */
+        em_cip_hop_dtx_info_cnf->hop_chn2.maio = maio2;
+      
+        i=0;
+        while((i<MAX_MA_CHANNELS) AND (ma2[i] NEQ NOT_PRESENT_16BIT))
+        {
+          em_cip_hop_dtx_info_cnf->hop_chn2.ma[i] = ma2[i];
+          i++;
+        }
+        /* Number of hopping channels */
+        em_cip_hop_dtx_info_cnf->hop_chn2.nr_arfcns = i;
+        if(i < MAX_MA_CHANNELS)
+        {
+          em_cip_hop_dtx_info_cnf->hop_chn2.ma[i] = NOT_PRESENT_16BIT;
+        }
+      } /* v_start */
+      
+    } /* hop NEQ H_NO */
+  
+  } /* dedicated state */
+
+  /* DTX status */
+  em_cip_hop_dtx_info_cnf->dtx_stat  = rr_data->sc_data.cd.dtx; 
+
+  PSENDX(MMI, em_cip_hop_dtx_info_cnf);
+}/*dat_em_cip_hop_dtx_info_req*/
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_mobdata_power_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_POWER_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_POWER_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_mobdata_power_info_req (T_EM_POWER_INFO_REQ *em_power_info_req)
+{
+  GET_INSTANCE_DATA;
+  PALLOC(em_power_info_cnf, EM_POWER_INFO_CNF);
+
+  PFREE(em_power_info_req);
+
+  TRACE_FUNCTION ("dat_em_mobdata_power_info_req()");
+
+  memset (em_power_info_cnf, 0, sizeof (T_EM_POWER_INFO_CNF));
+  memcpy(&em_power_info_cnf->classm2, &rr_data->ms_data.classmark2, sizeof (T_classm2));
+  memcpy(&em_power_info_cnf->classm3, &rr_data->ms_data.classmark3, sizeof (T_classm3));
+
+  PSENDX(MMI, em_power_info_cnf);
+}/*dat_em_mobdata_power_info_req*/
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_mobdata_id_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_IDENTITY_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_IDENTITY_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_mobdata_id_info_req (T_EM_IDENTITY_INFO_REQ *em_identity_info_req)
+{
+  GET_INSTANCE_DATA;
+  PALLOC(em_identity_info_cnf, EM_IDENTITY_INFO_CNF);
+  memset (em_identity_info_cnf, 0, sizeof (T_EM_IDENTITY_INFO_CNF));
+
+  PFREE(em_identity_info_req);
+  TRACE_FUNCTION ("dat_em_mobdata_id_info_req()");
+
+  /*
+   *   The values for IMEI and IMEISV are identical up to the last 4bits. The 'ident_type' distinguish
+   *   IMEI and IMEISV where ident_type = 3 is synonymously with IMEISV. In case only IMEI is needed,
+   *   em_mm_mobdata_id_info_req->em_imei.ident_dig[16] should not considered.
+   */
+
+  em_identity_info_cnf->em_imeisv.ident_type   = rr_data->ms_data.imei.ident_type;
+  em_identity_info_cnf->em_imeisv.v_ident_dig  = rr_data->ms_data.imei.v_ident_dig;
+  em_identity_info_cnf->em_imeisv.c_ident_dig  = rr_data->ms_data.imei.c_ident_dig;
+  em_identity_info_cnf->em_imeisv.odd_even     = rr_data->ms_data.imei.odd_even;
+  memcpy (em_identity_info_cnf->em_imeisv.ident_dig, rr_data->ms_data.imei.ident_dig, 16);
+
+  if (rr_data->ms_data.imsi_available) /* SIM available */
+  {
+    em_identity_info_cnf->em_imsi.ident_type    = rr_data->ms_data.imsi.ident_type;
+    em_identity_info_cnf->em_imsi.v_ident_dig   = rr_data->ms_data.imsi.v_ident_dig;
+    em_identity_info_cnf->em_imsi.c_ident_dig   = rr_data->ms_data.imsi.c_ident_dig;
+    em_identity_info_cnf->em_imsi.odd_even      = rr_data->ms_data.imsi.odd_even;
+    memcpy (em_identity_info_cnf->em_imsi.ident_dig, rr_data->ms_data.imsi.ident_dig, 16);
+  }
+
+  if (rr_data->ms_data.tmsi_available EQ TRUE)
+    em_identity_info_cnf->tmsi     = rr_data->ms_data.tmsi_binary;
+
+  PSENDX(MMI, em_identity_info_cnf);
+} /*dat_em_mobdata_id_info_req*/
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_mobdata_version_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_SW_VERSION_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_SW_VERSION_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_mobdata_version_info_req (T_EM_SW_VERSION_INFO_REQ *em_sw_version_info_req)
+{
+  PALLOC(em_sw_version_info_cnf, EM_SW_VERSION_INFO_CNF);
+  PFREE(em_sw_version_info_req);
+
+
+  TRACE_FUNCTION ("dat_em_mobdata_version_info_req()");
+
+  memset (em_sw_version_info_cnf, 0, sizeof (T_EM_SW_VERSION_INFO_CNF));
+
+  em_sw_version_info_cnf->v_mmi  = 0xFF;
+  em_sw_version_info_cnf->v_sim  = 0xFF;
+  em_sw_version_info_cnf->v_cc   = 0xFF;
+  em_sw_version_info_cnf->v_ss   = 0xFF;
+  em_sw_version_info_cnf->v_sms  = 0xFF;
+  em_sw_version_info_cnf->v_mm   = 0xFF;
+  em_sw_version_info_cnf->v_rr   = 0xFF;
+  em_sw_version_info_cnf->v_dl   = 0xFF;
+  em_sw_version_info_cnf->v_l1   = 0xFF;
+
+  PSENDX(MMI, em_sw_version_info_cnf);
+}/*dat_em_mobdata_version_info_req*/
+
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_amr_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_AMR_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_AMR_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_amr_info_req (T_EM_AMR_INFO_REQ *em_amr_info_req)
+{
+  GET_INSTANCE_DATA;
+  UBYTE i=0;
+  PALLOC(em_amr_info_cnf, EM_AMR_INFO_CNF);
+  memset (em_amr_info_cnf, 0, sizeof (T_EM_AMR_INFO_CNF));
+ 
+  PFREE(em_amr_info_req);
+  TRACE_FUNCTION ("dat_em_amr_info_req()");
+
+  /* AMR information is valid only in dedicated state, when chan mode is AMR */
+  if((GET_STATE(STATE_ATT) EQ ATT_DEDICATED) AND 
+	                              (GET_STATE(STATE_DAT) EQ DAT_DEDICATED))
+  {
+    if(rr_data->sc_data.ch_mode EQ CM_AMR)
+    {
+      /* AMR vocoder type */
+      em_amr_info_cnf->amr_vocoder = rr_data->sc_data.chan_desc.chan_type;
+
+      /* Initial codec mode indicator */
+      em_amr_info_cnf->amr_icmi    = rr_data->sc_data.amr_conf.icmi;
+
+      /* Initial codec mode. Valid if icmi = 1(Start mode signalled) */
+      em_amr_info_cnf->amr_icm     = rr_data->sc_data.amr_conf.st_mode;
+
+      /* Active codec set */
+      em_amr_info_cnf->amr_acs     = rr_data->sc_data.amr_conf.set_amr;
+
+      /* First codec( Highest bit rate codec mode) */
+      em_amr_info_cnf->amr_first_codec = 
+                   em_get_first_codec(rr_data->sc_data.amr_conf.set_amr);
+
+      if(rr_data->sc_data.amr_conf.v_cod_prop)
+      {
+        /* Number of codec modes */
+        em_amr_info_cnf->amr_nr_modes = rr_data->sc_data.amr_conf.c_cod_prop + 1;
+
+        /* Threshold and Hysteresis properties between codec modes */
+        for(i=0;i<rr_data->sc_data.amr_conf.c_cod_prop;i++)
+        {
+          memcpy(&em_amr_info_cnf->amr_cod_prop[i],&rr_data->sc_data.amr_conf.cod_prop[i],
+                 sizeof(T_amr_cod_prop));
+        }
+      }  
+      else
+      {
+        /* Number of codec modes */
+        em_amr_info_cnf->amr_nr_modes = 1;
+      }
+    } /* CM_AMR */
+  } /* ATT DEDICATED */
+
+  PSENDX(MMI, em_amr_info_cnf);
+} /*dat_em_amr_info_req*/
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_init_rr_event_trace
++------------------------------------------------------------------------------
+|  Description  :  Initialize the event tracing flags for RR
+|
+|  Parameters   :  void
+|
+|  Return       :  void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void em_init_rr_event_trace(void)
+{
+ UBYTE i;
+
+ TRACE_FUNCTION ("em_init_rr_event_trace()");
+
+ for (i=0; i< EM_MAX_RR_EVENTS; i++)
+   rr_v[i] = 0;
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : rr_em_rr_event_req
++------------------------------------------------------------------------------
+|  Description  :  Set the event tracing flags according the bitmask
+|
+|  Parameters   :  Primitive - Bitmask(T_EM_RR_EVENT_REQ)
+|
+|  Return       :  void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void rr_em_rr_event_req (T_EM_RR_EVENT_REQ *em_rr_event_req)
+{
+ UBYTE i;
+
+ TRACE_FUNCTION ("rr_em_rr_event_req()");
+
+ /*
+  *  The event tracing flags are set according the bitmask. rr_v[i] are
+  *  the flags belonging to the event number described in 8443.601
+ */
+ for(i=1; i<33; i++)
+   rr_v[i] = ((em_rr_event_req->bitmask_rr_l & (0x01<<(i-1))) > 0) ? TRUE : FALSE;
+
+ for(i=33; i<(EM_MAX_RR_EVENTS); i++)
+   rr_v[i] = ((em_rr_event_req->bitmask_rr_h & (0x01<<(i-1))) > 0) ? TRUE : FALSE;
+
+ /*
+   A new event trace is generated therefor the flag is set to 0.
+ */
+ em_rr_trace_occured = 0;
+
+ PFREE(em_rr_event_req);
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_2
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define EVT_LEN_OFFSET     2  /* Event Number and Length value bytes */
+#define BUFFER_2_LENGTH   2
+GLOBAL UBYTE em_write_buffer_2 (UBYTE event_no)
+{
+ UBYTE em_rr_event_buffer[BUFFER_2_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_2()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;                      /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write]   = 0x00; /* Value length - 0 equals no data */
+
+ return (em_rr_sem (BUFFER_2_LENGTH, em_rr_event_buffer));              /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_3
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_3_LENGTH 3
+GLOBAL UBYTE em_write_buffer_3  (UBYTE event_no, UBYTE value)
+{
+ UBYTE em_rr_event_buffer[BUFFER_3_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_3()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;                /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_3_LENGTH-EVT_LEN_OFFSET;  /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write]   = value;                   /* Data to be stored */
+
+ return (em_rr_sem (BUFFER_3_LENGTH, em_rr_event_buffer));        /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_3a
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value (USHORT)
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_3A_LENGTH 4
+GLOBAL UBYTE em_write_buffer_3a (UBYTE event_no, USHORT value)
+{
+ UBYTE em_rr_event_buffer[BUFFER_3A_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_3a()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;               /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_3A_LENGTH-EVT_LEN_OFFSET; /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write++] = (UBYTE)(value >> 8);    /* Data to be stored - MSB first */
+ em_rr_event_buffer[em_rr_buffer_write++] = (UBYTE)(value );        /* LSB second */
+
+ return (em_rr_sem (BUFFER_3A_LENGTH, em_rr_event_buffer));      /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_4
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, length of data and value1 and value2
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_4_LENGTH 4
+GLOBAL UBYTE em_write_buffer_4  (UBYTE event_no, UBYTE value1, UBYTE value2)
+{
+ UBYTE em_rr_event_buffer[BUFFER_4_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_4()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;               /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_4_LENGTH-EVT_LEN_OFFSET;  /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write++] = value1;                 /* Value 1 */
+ em_rr_event_buffer[em_rr_buffer_write++] = value2;                 /* Value 2 */
+
+ return (em_rr_sem (BUFFER_4_LENGTH, em_rr_event_buffer));       /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_4a
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value, data cs (USHORT)
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_4A_LENGTH 5
+GLOBAL UBYTE em_write_buffer_4a (UBYTE event_no, UBYTE value, USHORT cs)
+{
+ UBYTE em_rr_event_buffer[BUFFER_4A_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_4a()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;               /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_4A_LENGTH-EVT_LEN_OFFSET;  /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write++] = value;                  /* first data info */
+ em_rr_event_buffer[em_rr_buffer_write++] = (UBYTE)(cs >> 8);       /* Data to be stored - MSB first */
+ em_rr_event_buffer[em_rr_buffer_write++] = (UBYTE)(cs);            /* LSB second */
+
+ return (em_rr_sem (BUFFER_4A_LENGTH, em_rr_event_buffer));         /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_4b
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value, data plmn (T_plmn)
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_4B_LENGTH  9
+GLOBAL UBYTE em_write_buffer_4b (UBYTE event_no, UBYTE value, T_plmn plmn)
+{
+ UBYTE em_rr_event_buffer[BUFFER_4B_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_4b()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ memset(em_rr_event_buffer, 0, BUFFER_4B_LENGTH);
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;                  /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_4B_LENGTH-EVT_LEN_OFFSET;  /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write++] = value;
+ if(plmn.v_plmn)
+ {
+  memcpy(&em_rr_event_buffer[em_rr_buffer_write], plmn.mcc, SIZE_MCC);
+  em_rr_buffer_write += SIZE_MCC;
+  memcpy(&em_rr_event_buffer[em_rr_buffer_write], plmn.mnc, SIZE_MNC);
+ }
+
+ return (em_rr_sem (BUFFER_4B_LENGTH, em_rr_event_buffer));        /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_4c
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value1, data plmn (T_plmn)
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_4C_LENGTH ((MAX_PLMN*(SIZE_MCC+SIZE_MNC))+EVT_LEN_OFFSET)
+GLOBAL UBYTE em_write_buffer_4c (UBYTE event_no, UBYTE value1, T_plmn plmn[MAX_PLMN])
+{
+ UBYTE em_rr_event_buffer[BUFFER_4C_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+ UBYTE length = 0;
+ UBYTE i;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_4c()");
+ /* Ensure value1 is within specified boundaries */
+ if( value1 > MAX_PLMN )
+ {
+   value1 = MAX_PLMN;
+ }
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ memset(em_rr_event_buffer, 0, BUFFER_4C_LENGTH);
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;                     /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = 1+value1*(SIZE_MCC + SIZE_MNC); /* Value length - 0 equals no value */
+ for (i=0; i<value1; i++) {
+   if(plmn[i].v_plmn)
+   {
+     memcpy(em_rr_event_buffer + em_rr_buffer_write, plmn[i].mcc, SIZE_MCC);
+     em_rr_buffer_write += SIZE_MCC;
+     memcpy(em_rr_event_buffer + em_rr_buffer_write, plmn[i].mnc, SIZE_MNC);
+     em_rr_buffer_write += SIZE_MNC;
+   }
+ }
+ length = (EVT_LEN_OFFSET + value1*(SIZE_MCC + SIZE_MNC));
+
+ return (em_rr_sem (length, em_rr_event_buffer));                          /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_5
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value1, data value2, data cs (USHORT)
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_5_LENGTH  5
+GLOBAL UBYTE em_write_buffer_5 (UBYTE event_no, UBYTE value1, UBYTE value2, UBYTE value3)
+{
+ UBYTE em_rr_event_buffer[BUFFER_5_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_5()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;               /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_5_LENGTH-EVT_LEN_OFFSET; /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write++] = value1;                 /* first data info */
+ em_rr_event_buffer[em_rr_buffer_write++] = value2;                 /* second data info */
+ em_rr_event_buffer[em_rr_buffer_write++] = value3;                 /* Data */
+
+ return (em_rr_sem (BUFFER_5_LENGTH, em_rr_event_buffer));       /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_5c
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value, data plmn (T_plmn)
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_5C_LENGTH  10
+GLOBAL UBYTE em_write_buffer_5c (UBYTE event_no, UBYTE value1, UBYTE value2, T_plmn plmn)
+{
+ UBYTE em_rr_event_buffer[BUFFER_5C_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_5c()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ memset(em_rr_event_buffer, 0, BUFFER_5C_LENGTH);
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;                 /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_5C_LENGTH-EVT_LEN_OFFSET;  /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write++] = value1;
+ em_rr_event_buffer[em_rr_buffer_write++] = value2;
+ if(plmn.v_plmn)
+ {
+  memcpy(em_rr_event_buffer + em_rr_buffer_write, plmn.mcc, SIZE_MCC);
+  em_rr_buffer_write += SIZE_MCC;
+  memcpy(em_rr_event_buffer + em_rr_buffer_write, plmn.mnc, SIZE_MNC);
+ }
+
+ return (em_rr_sem (BUFFER_5C_LENGTH, em_rr_event_buffer));        /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_8
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value1, data value2, data cs (USHORT)
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_8_LENGTH  8
+GLOBAL UBYTE em_write_buffer_8 (UBYTE event_no, UBYTE value1, UBYTE value2, UBYTE value3, UBYTE value4,
+                            UBYTE value5, UBYTE value6)
+{
+ UBYTE em_rr_event_buffer[BUFFER_8_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_8()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;               /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_8_LENGTH-EVT_LEN_OFFSET; /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write++] = value1;                 /* first data info */
+ em_rr_event_buffer[em_rr_buffer_write++] = value2;                 /* second data info */
+ em_rr_event_buffer[em_rr_buffer_write++] = value3;                 /* data */
+ em_rr_event_buffer[em_rr_buffer_write++] = value4;                 /* data */
+ em_rr_event_buffer[em_rr_buffer_write++] = value5;                 /* data */
+ em_rr_event_buffer[em_rr_buffer_write++] = value6;                 /* data */
+
+ return (em_rr_sem (BUFFER_8_LENGTH, em_rr_event_buffer));       /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_write_buffer_9
++------------------------------------------------------------------------------
+|  Description  :  Perform buffer check and store corresponding data in it.
+|
+|  Parameters   :  Event number, data value1, data value2, data cs (USHORT)
+|
+|  Return       :  TRUE/FALSE
+|
++------------------------------------------------------------------------------
+*/
+#define BUFFER_9_LENGTH  9
+GLOBAL UBYTE em_write_buffer_9 (UBYTE event_no, UBYTE value1, UBYTE value2, UBYTE value3,
+                           UBYTE value4,   UBYTE value5, UBYTE value6, UBYTE value7)
+{
+ UBYTE em_rr_event_buffer[BUFFER_9_LENGTH];
+ UBYTE em_rr_buffer_write = 0;
+
+ TRACE_FUNCTION ("rr_em_write_buffer_9()");
+
+ /*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+ rr_em_first_event_check();
+
+ em_rr_event_buffer[em_rr_buffer_write++] = event_no;               /* Event number */
+ em_rr_event_buffer[em_rr_buffer_write++] = BUFFER_9_LENGTH-EVT_LEN_OFFSET; /* Value length - 0 equals no value */
+ em_rr_event_buffer[em_rr_buffer_write++] = value1;                 /* first data info */
+ em_rr_event_buffer[em_rr_buffer_write++] = value2;                 /* second data info */
+ em_rr_event_buffer[em_rr_buffer_write++] = value3;                 /* data */
+ em_rr_event_buffer[em_rr_buffer_write++] = value4;                 /* data */
+ em_rr_event_buffer[em_rr_buffer_write++] = value5;                 /* data */
+ em_rr_event_buffer[em_rr_buffer_write++] = value6;                 /* data */
+ em_rr_event_buffer[em_rr_buffer_write++] = value7;                 /* data */
+
+ return (em_rr_sem (BUFFER_9_LENGTH, em_rr_event_buffer));       /* Data is stored inside buffer, reset flag */
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : rr_semaphore_err
++------------------------------------------------------------------------------
+|  Description  :  Semaphor error
+|
+|
+|  Parameters   :  void
+|
+|  Return       :  void
+|
++------------------------------------------------------------------------------
+*/
+static void rr_semaphore_err (void)
+{
+ static UCHAR out = 0;
+  if (!out)
+  {
+    out = 1;
+/* Implements Measure#32: Row 224 */
+    TRACE_EVENT ("semaphore error");
+
+  }
+}
+
+
+/*
++------------------------------------------------------------------------------
+|  Function     : rr_enter_critical_section
++------------------------------------------------------------------------------
+|  Description  :
+|                 Attempt to access critical section by taking control
+|                 of the semaphore
+|
+|  Parameters   : void
+|
+|  Return       : int
+|
++------------------------------------------------------------------------------
+*/
+static int rr_enter_critical_section (T_HANDLE sem)
+{
+  if (vsi_s_get (VSI_CALLER sem) NEQ VSI_OK)
+  {
+    SYST_TRACE ( "** Enter Critical Sec:semaphore NOT cleared **");
+    rr_semaphore_err();
+    return -1;
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : rr_leave_critical_section
++------------------------------------------------------------------------------
+|  Description  :
+|                 Relinquish control of semaphore and release access to
+|                 critical section
+|
+|  Parameters   : void
+|
+|  Return       : int
+|
++------------------------------------------------------------------------------
+*/
+static int rr_leave_critical_section (T_HANDLE sem)
+{
+  if (vsi_s_release (VSI_CALLER sem) NEQ VSI_OK)
+  {
+    SYST_TRACE ( "** Leave Critical Sec:semaphore NOT cleared **");
+    rr_semaphore_err();
+    return -1;
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_rr_sem_init
++------------------------------------------------------------------------------
+|  Description  :
+|                 Initialise Semaphore
+|
+|  Parameters   : void
+|
+|  Return       : int
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void em_rr_sem_init (void)
+{
+  sem_EM_RR  = vsi_s_open (VSI_CALLER "EM_RR_SEM",1);
+
+  if (sem_EM_RR NEQ VSI_ERROR)
+    em_rr_sem_clear ();
+  else
+    SYST_TRACE ("RR:can´t open semaphore \"EM_RR_SEM\"");
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_rr_sem_exit
++------------------------------------------------------------------------------
+|  Description  :
+|                 Close the semaphore
+|
+|  Parameters   : void
+|
+|  Return       : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void em_rr_sem_exit (void)
+{
+  if (sem_EM_RR NEQ VSI_ERROR)
+    vsi_s_close (VSI_CALLER sem_EM_RR);
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_rr_sem_clear
++------------------------------------------------------------------------------
+|  Description  :
+|                 Clear semaphore
+|
+|  Parameters   : void
+|
+|  Return       : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void em_rr_sem_clear (void)
+{
+  if (rr_enter_critical_section(sem_EM_RR))
+  {
+    return;
+  }
+
+  em_rr_sem_index = 0;
+  if(rr_leave_critical_section(sem_EM_RR))
+  {
+    return;
+  }
+  SYST_TRACE ( "RR:em_rr_sem_index cleared");
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_rr_sem_reset
++------------------------------------------------------------------------------
+|  Description  :
+|                 Reset the semaphore
+|
+|  Parameters   : void
+|
+|  Return       : UBYTE
+|
++------------------------------------------------------------------------------
+*/
+/*lint -esym(714,em_rr_sem_reset) | Symbol not referenced         | used by ACI */
+/*lint -esym(765,em_rr_sem_reset) | external could be made static | used by ACI */
+
+GLOBAL void em_rr_sem_reset (void)
+{
+  em_rr_sem_index = 0;
+  if(rr_leave_critical_section(sem_EM_RR))
+  {
+    return;
+  }
+
+  SYST_TRACE ( "RR:em_rr_sem_index reset OK");
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_rr_sem_read
++------------------------------------------------------------------------------
+|  Description  :
+|                 Read state of the semaphore. The rr semaphor will be read by
+|                 the engineering mode via aci.
+|
+|  Parameters   : void
+|
+|  Return       : UBYTE
+|
++------------------------------------------------------------------------------
+*/
+/*lint -esym(714,em_rr_sem_read) | Symbol not referenced         | used by ACI */
+/*lint -esym(765,em_rr_sem_read) | external could be made static | used by ACI */
+
+GLOBAL void em_rr_sem_read (void)
+{
+  TRACE_FUNCTION ("em_rr_sem_read()");
+
+  {
+    USHORT    semCount;
+
+    if (vsi_s_status (VSI_CALLER sem_EM_RR, &semCount) NEQ VSI_OK)
+    {
+      SYST_TRACE ( "** RR:sem status error **");
+      rr_semaphore_err();
+      return;
+    }
+    if (semCount EQ 0)
+    {
+      vsi_o_ttrace(VSI_CALLER TC_EVENT, "semCount = %d", semCount);
+      SYST_TRACE ( "semCount EQ 0");
+      return;
+    }
+  }
+
+  rr_enter_critical_section(sem_EM_RR);
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     : em_rr_sem
++------------------------------------------------------------------------------
+|  Description  :
+|
+|
+|  Parameters   : void
+|
+|  Return       : TRUE/FALSE - TRUE keeps the event flag valid,
+|                              FALSE indicates a successful flag handle
+|
++------------------------------------------------------------------------------
+*/
+/*lint -esym(714,em_rr_sem) | Symbol not referenced         | used by ACI */
+/*lint -esym(765,em_rr_sem) | external could be made static | used by ACI */
+GLOBAL UBYTE em_rr_sem (UBYTE length, UBYTE *data)
+{
+  UBYTE     i;
+
+  TRACE_FUNCTION ("em_rr_sem()");
+
+  {
+    USHORT    semCount;
+
+    if (vsi_s_status (VSI_CALLER sem_EM_RR, &semCount) NEQ VSI_OK)
+    {
+      rr_semaphore_err();
+      return FALSE;
+    }
+    if (semCount EQ 0)
+    {
+      vsi_o_ttrace(VSI_CALLER TC_EVENT, "semCount = %d", semCount);
+      SYST_TRACE ( "semCount EQ 0");
+      return FALSE;
+    }
+  }
+
+  /*
+   *  buffer overflow protection
+   */
+  if (( em_rr_sem_index + length)  > EM_RR_SEM_SIZE )
+  {
+    TRACE_FUNCTION ("rr buffer overflow");
+    return FALSE;
+  }
+
+  if(rr_enter_critical_section(sem_EM_RR))
+    return FALSE;
+
+  for (i=0; i<length; i++)
+    em_rr_sem_buffer[em_rr_sem_index++] = *(data++);
+
+  if(rr_leave_critical_section(sem_EM_RR))
+  {
+    SYST_TRACE ( "** Unable to clear semaphore **");
+    return FALSE;
+  }
+
+  return TRUE;             /* indicates that flag was handled */
+} /* endfunc em_rr_sem */
+
+
+/*
++------------------------------------------------------------------------------
+|  Function     : rr_em_first_event_check()
++------------------------------------------------------------------------------
+|  Description  :  Checks if first EM-Event ocured
+|
+|  Parameters   :  None
+|
+|  Return       :  None
+|
++------------------------------------------------------------------------------
+*/
+
+/*
+   ACI is informed about the first event trace, used for later data processing.
+ */
+
+LOCAL void rr_em_first_event_check(void)
+{
+ TRACE_FUNCTION("rr_em_first_event_check()");
+
+ if(em_rr_trace_occured EQ 0)
+ {
+  PALLOC(em_notification, EM_DATA_IND);
+  em_notification->entity = EM_RR;
+  PSENDX(MMI, em_notification);
+  em_rr_trace_occured++;
+ }
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  rr_em_pco_trace_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_PCO_TRACE_REQ.
+|
+|  Parameters   :  UBYTE pco_bitmap
+|
+|  Return       :  void
+|
+|  Purpose      :  with this primitive the requested EM Data is traced in the PCO.
++------------------------------------------------------------------------------
+*/
+GLOBAL void rr_em_pco_trace_req (T_EM_PCO_TRACE_REQ *em_pco_trace_req)
+{
+  GET_INSTANCE_DATA;
+  UBYTE em_cell_type = EM_CELL_NA;
+  TRACE_FUNCTION("rr_em_pco_trace_req()");
+
+  /*check for SC data*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_SC_INFO)
+  {
+       switch (GET_STATE (STATE_ATT))
+    {
+      case ATT_IDLE:
+
+        if (rr_data->nc_data[SC_INDEX].bcch_status EQ DECODED)
+        {
+          em_cell_type = EM_CELL_GSM;
+#ifdef GPRS
+          if(rr_data->nc_data[SC_INDEX].rac NEQ NOT_PRESENT_8BIT)
+            em_cell_type = EM_CELL_GPRS;	 
+#endif
+          
+          TRACE_EVENT_EM_P8("EM_SC_INFO_REQ_IDLE_DECODED: arfcn:%d c1:%d c2:%d rxlev:%d bsic:%d cell_id:%d dsc:%d cell_type:%d",
+            
+            rr_data->nc_data[SC_INDEX].arfcn,
+            rr_data->nc_data[SC_INDEX].c1,
+            rr_data->nc_data[SC_INDEX].c2,
+            rr_data->nc_data[SC_INDEX].rxlev,
+            rr_data->nc_data[SC_INDEX].bsic,
+            rr_data->nc_data[SC_INDEX].cell_id,
+            em_act_dlt,
+            em_cell_type);
+
+          TRACE_EVENT_EM_P5("EM_SC_INFO_REQ_IDLE_DECODED: txlev:%d tn:%d lac:%d cba:%d cbq:%d",
+            rr_data->sc_data.cd.cell_options.pow_ctrl,
+            rr_data->sc_data.chan_desc.tn,
+            rr_data->nc_data[SC_INDEX].lai.lac,
+            rr_data->nc_data[SC_INDEX].rach.cell_bar_access,
+            rr_data->nc_data[SC_INDEX].c2_par.cbq);
+        }
+        else if (rr_data->nc_data[SC_INDEX].bcch_status EQ NON_DECODED)
+        {
+          TRACE_EVENT_EM_P4("EM_SC_INFO_REQ_IDLE_NON_DECODED: cell_type:%d arfcn:%d rxlev:%d bsic:%d",
+            em_cell_type,
+            rr_data->nc_data[SC_INDEX].arfcn,
+            rr_data->nc_data[SC_INDEX].rxlev,
+            rr_data->nc_data[SC_INDEX].bsic);
+        }
+        break;
+
+      case ATT_DEDICATED:
+        if (!rr_data->ms_data.measurement_report.valid)
+          break;
+
+        em_cell_type = EM_CELL_GSM;
+
+#ifdef GPRS
+          if(rr_data->nc_data[SC_INDEX].rac NEQ NOT_PRESENT_8BIT)
+            em_cell_type = EM_CELL_GPRS;
+#endif
+
+        TRACE_EVENT_EM_P1("EM_SC_INFO_REQ_DEDICATED: cell_type:%d", em_cell_type);
+
+        TRACE_EVENT_EM_P6("EM_SC_INFO_REQ_DEDICATED: arfcn:%d bsic:%d cell_id:%d txlev:%d tn:%d rxlev_f:%d",
+          rr_data->ms_data.measurement_report.arfcn,
+          rr_data->nc_data[SC_INDEX].bsic,
+          rr_data->nc_data[SC_INDEX].cell_id,
+          rr_data->sc_data.cd.cell_options.pow_ctrl,
+          rr_data->sc_data.chan_desc.tn,
+          rr_data->ms_data.measurement_report.rx_lev_full);
+
+        TRACE_EVENT_EM_P6("EM_SC_INFO_REQ_DEDICATED: rxlev_s:%d rlt:%d ta:%d rxqual_f:%d rxqual_s:%d vocoder:%d",
+          rr_data->ms_data.measurement_report.rx_lev_sub,
+          em_act_rlt,
+          rr_data->sc_data.new_ta,
+          rr_data->ms_data.measurement_report.rx_qual_full,
+          rr_data->ms_data.measurement_report.rx_qual_sub,
+          rr_data->sc_data.ch_mode);
+
+        break;
+
+      default:
+        break;
+    }/*switch - state*/
+  }/*if - SC data*/
+
+  /*check NC data*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_NC_INFO)
+  {
+    UBYTE index = 0;
+    UBYTE rac   = 0xff;
+    
+    switch (GET_STATE (STATE_ATT))
+    {
+      case ATT_IDLE:
+        
+        TRACE_EVENT_EM_P1("EM_NC_INFO_REQ_IDLE: num_nc:%d", /*number of neighbour cells*/
+          rr_data->ms_data.measurement_report.ncells.no_of_ncells);
+
+        for (index = 0; index < EM_MAX_NUM_NC ; index++) /*report cells ordered by index in NC list*/
+        {
+          em_cell_type = EM_CELL_NA;
+
+          if (rr_data->nc_data[index].bcch_status EQ DECODED)
+          {
+            em_cell_type = EM_CELL_GSM;
+            rac = 0xff;
+#ifdef GPRS
+            rac = rr_data->nc_data[index].rac;
+            if(rr_data->nc_data[index].rac NEQ NOT_PRESENT_8BIT)
+              em_cell_type = EM_CELL_GPRS;
+#endif
+
+            TRACE_EVENT_EM_P8("EM_NC_INFO_REQ_IDLE_DECODED: cell_type:%d rac:%d index:%d arfcn:%d c1:%d c2:%d rxlev:%d bsic:%d",
+              em_cell_type,
+              rac,
+              index,
+              rr_data->nc_data[index].arfcn,
+              rr_data->nc_data[index].c1,
+              rr_data->nc_data[index].c2,
+              rr_data->nc_data[index].rxlev,
+              rr_data->nc_data[index].bsic);
+
+            TRACE_EVENT_EM_P6("EM_NC_INFO_REQ_IDLE_DECODED: cid:%d lac:%d f_o:%ld t_a:%ld cba:%d cbq:%d",
+              rr_data->nc_data[index].cell_id,
+              rr_data->nc_data[index].lai.lac,
+              rr_data->ms_data.measurement_report.ncells.frame_offset[index],
+              rr_data->ms_data.measurement_report.ncells.time_alignmt[index],
+              rr_data->nc_data[index].rach.cell_bar_access,
+              rr_data->nc_data[index].c2_par.cbq);
+
+            TRACE_EVENT_EM_P3("EM_NC_INFO_REQ_IDLE_DECODED: cell_resel_off:%d temp_off:%d rxlev_acc_min:%ld",
+              rr_data->nc_data[index].c2_par.cell_reselect_offset,
+              rr_data->nc_data[index].c2_par.temp_offset,
+              rr_data->nc_data[index].select_para.rxlev_access_min);
+
+          } /* if decoded */
+
+          else if (rr_data->nc_data[index].bcch_status EQ NON_DECODED)
+          {
+            TRACE_EVENT_EM_P4("EM_NC_INFO_REQ_IDLE_NON_DECODED: cell_type:%d arfcn:%d rxlev:%d bsic:%d",
+              em_cell_type,
+              rr_data->nc_data[index].arfcn,
+              rr_data->nc_data[index].rxlev,
+              rr_data->nc_data[index].bsic);
+          } /* if non decoded */
+        } /* for */
+
+        break;
+
+      case ATT_DEDICATED:
+        {
+        if (!rr_data->ms_data.measurement_report.valid)
+          break;
+
+        TRACE_EVENT_EM_P1("EM_NC_INFO_REQ_DEDICATED: num_nc:%d",
+          rr_data->ms_data.measurement_report.ncells.no_of_ncells);
+
+        for (index = 0; index< rr_data->ms_data.measurement_report.ncells.no_of_ncells; index++)
+        {
+        /*in the measurement report the cells are ordered by fieldstrength -
+          non valid measurements are at the end*/
+          TRACE_EVENT_EM_P6("EM_NC_INFO_REQ_DEDICATED: index:%d arfcn:%d rx_lev:%d bsic:%d f_o:%ld t_a:%ld",
+            index,
+            rr_data->ms_data.measurement_report.ncells.arfcn[index],
+            rr_data->ms_data.measurement_report.ncells.rx_lev[index],
+            rr_data->ms_data.measurement_report.ncells.bsic[index],
+            rr_data->ms_data.measurement_report.ncells.frame_offset[index],
+            rr_data->ms_data.measurement_report.ncells.time_alignmt[index]);
+        }/*for*/
+
+        }/*case*/
+        break;
+
+      default:
+        break;
+    }/*switch - state*/
+  }/*if - NC data*/
+
+  /*check Location and Paging data*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_LOC_PAG_INFO)
+  {
+    if (rr_data->nc_data[SC_INDEX].bcch_status EQ DECODED)
+    {
+      TRACE_EVENT_EM_P8("EM_LOC_PAG_INFO_REQ_DECODED: mcc:%d %d %d mnc:%d %d %d bs_pa_mfrms:%d t3212:%d",
+        rr_data->nc_data[SC_INDEX].lai.mcc[0],
+        rr_data->nc_data[SC_INDEX].lai.mcc[1],
+        rr_data->nc_data[SC_INDEX].lai.mcc[2],
+
+        /*2 digits vs. 3 digits*/
+        rr_data->nc_data[SC_INDEX].lai.mnc[2] NEQ 0xF ? rr_data->nc_data[SC_INDEX].lai.mnc[0] :
+                                                        0 ,
+        rr_data->nc_data[SC_INDEX].lai.mnc[2] NEQ 0xF ? rr_data->nc_data[SC_INDEX].lai.mnc[1] :
+                                                        rr_data->nc_data[SC_INDEX].lai.mnc[0],
+        rr_data->nc_data[SC_INDEX].lai.mnc[2] NEQ 0xF ? rr_data->nc_data[SC_INDEX].lai.mnc[2] :
+                                                        rr_data->nc_data[SC_INDEX].lai.mnc[1],
+
+        rr_data->nc_data[SC_INDEX].control_descr.bs_pa_mfrms,
+        rr_data->nc_data[SC_INDEX].control_descr.t3212);
+    }
+    if (rr_data->ms_data.tmsi_available EQ TRUE)
+      TRACE_EVENT_EM_P1("EM_LOC_PAG_INFO_REQ_TMSI: %d", rr_data->ms_data.tmsi_binary);
+  }/*if - Location and Paging data*/
+  
+  /*check PLMN parameters*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_PLMN_INFO)
+  {
+    TRACE_EVENT_EM_P4("EM_PLMN_INFO_REQ: no_creq_max:%d re_flag:%d TXPOW_max:%d RXLEV_acc_min:%d",
+      rr_data->nc_data[SC_INDEX].rach.max_retrans,
+      rr_data->nc_data[SC_INDEX].rach.re,
+      rr_data->nc_data[SC_INDEX].select_para.ms_txpwr_max_cch,
+      rr_data->nc_data[SC_INDEX].select_para.rxlev_access_min);
+
+  }/* if - PLMN parameters*/
+  
+  /*check Ciphering Hopping DTX data*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_CIPH_HOP_DTX_INFO)
+  {
+    UBYTE i,offset;
+/* Implements Measure#32: Row 242 */
+    char *basestr="EM_CIP_HOP_DTX_INFO_REQ_FREQ";
+    
+    /*to store the trace output*/
+    char hop_freq_list[MAX_SPRINTF_STRING_LEN]; /*lint !e813 , info about length*/
+    
+    if((GET_STATE(STATE_ATT) EQ ATT_DEDICATED) AND 
+	                            (GET_STATE(STATE_DAT) EQ DAT_DEDICATED))
+    {
+
+      TRACE_EVENT_EM_P6("EM_CIP_HOP_DTX_INFO_REQ_DEDICATED: ciph:%d dtx:%d v_start:%d hop:%d hsn:%d arfcn:%d",
+      rr_data->sc_data.ciph_on,
+      rr_data->sc_data.cd.dtx,
+      v_start,
+      rr_data->sc_data.chan_desc.hop,
+      rr_data->sc_data.chan_desc.hop NEQ H_NO ? rr_data->sc_data.chan_desc.hsn : NOT_PRESENT_16BIT,
+      rr_data->sc_data.chan_desc.arfcn);
+
+      if(rr_data->sc_data.chan_desc.hop NEQ H_NO)
+      {
+/* Implements Measure#32: Row 242 */
+        offset = sprintf(hop_freq_list, "%s1:  ", basestr);
+
+
+    for (i = 0; (i < MAX_MA_CHANNELS) AND (ma[i] NEQ NOT_PRESENT_16BIT); i++)
+    {
+      offset += sprintf(hop_freq_list+offset, "%u ", ma[i]);
+      /*
+       * 4 spaces for freq + 1 blank space + 1 space for '\0'
+       */
+      if(offset > MAX_SPRINTF_STRING_LEN - 6)
+      {    
+        TRACE_EVENT_EM (hop_freq_list);
+/* Implements Measure#32: Row 245 */
+        offset = sprintf(hop_freq_list, "%s1_CONT:  ", basestr);
+      }
+    }
+    TRACE_EVENT_EM (hop_freq_list);
+        TRACE_EVENT_EM_P2("EM_CIP_HOP_DTX_INFO_REQ_FREQ1: nr_arfcns:%d, maio:%d",
+          i,rr_data->sc_data.chan_desc.maio);
+     } /* If hopping valid */
+
+    if (v_start)
+    {
+  
+/* Implements Measure#32: Row 247 */
+      offset = sprintf(hop_freq_list, "%s2:  ", basestr);/*before starting time*/
+
+      for (i = 0; (i < MAX_MA_CHANNELS) AND (ma2[i] NEQ NOT_PRESENT_16BIT); i++)
+      {
+        offset += sprintf(hop_freq_list+offset, "%u ", ma2[i]);
+        if(offset > MAX_SPRINTF_STRING_LEN - 6)
+        {    
+          TRACE_EVENT_EM (hop_freq_list);
+/* Implements Measure#32: Row 248 */
+          offset = sprintf(hop_freq_list, "%s2_CONT:  ", basestr);
+        }
+      }
+      TRACE_EVENT_EM (hop_freq_list);
+        TRACE_EVENT_EM_P2("EM_CIP_HOP_DTX_INFO_REQ_FREQ2: nr_arfcns:%d, maio:%d",i, maio2);
+  
+    }/*if - starting time valid*/
+    } /* ATT dedicated state */
+    else
+    {
+      TRACE_EVENT_EM_P1("EM_CIP_HOP_DTX_INFO_REQ_IDLE: dtx:%d", rr_data->sc_data.cd.dtx);
+    } /* ATT idle state */
+  }/*if - ciphering, hopping, dtx*/
+  
+  /*check Power (Classmark) data*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_POWER_INFO)
+  {/*here the em_power_info_cnf struckture is used, because I couldn't find classmark definition*/
+    PALLOC(em_power_info_cnf, EM_POWER_INFO_CNF);
+    memset (em_power_info_cnf, 0, sizeof (T_EM_POWER_INFO_CNF));
+    memcpy(&em_power_info_cnf->classm2, &rr_data->ms_data.classmark2, sizeof (T_classm2));
+    memcpy(&em_power_info_cnf->classm3, &rr_data->ms_data.classmark3, sizeof (T_classm3));
+
+    TRACE_EVENT_EM_P6("EM_POWER_INFO_REQ_CLASSMARK_2: rev_lev:%d es_ind:%d a5_1:%d rf_pow_cap:%d ps_cap:%d ss_screen:%d",
+      em_power_info_cnf->classm2.rev_lev,  em_power_info_cnf->classm2.es_ind,
+      em_power_info_cnf->classm2.a5_1,     em_power_info_cnf->classm2.rf_pow_cap,
+      em_power_info_cnf->classm2.ps_cap,   em_power_info_cnf->classm2.ss_screen);
+    TRACE_EVENT_EM_P6("EM_POWER_INFO_REQ_CLASSMARK_2: sm_cap:%d freq_cap:%d class_3:%d cmsp:%d a5_3:%d a5_2:%d",
+      em_power_info_cnf->classm2.sm_cap,   em_power_info_cnf->classm2.freq_cap,
+      em_power_info_cnf->classm2.class_3,  em_power_info_cnf->classm2.cmsp,
+      em_power_info_cnf->classm2.a5_3,     em_power_info_cnf->classm2.a5_2);
+
+    TRACE_EVENT_EM_P6("EM_POWER_INFO_REQ_CLASSMARK_3: mb_sub:%d a5_7:%d a5_6:%d a5_5:%d a5_4:%d v_radio_cap_2:%d",
+      em_power_info_cnf->classm3.mb_sub,           em_power_info_cnf->classm3.a5_7,
+      em_power_info_cnf->classm3.a5_6,             em_power_info_cnf->classm3.a5_5,
+      em_power_info_cnf->classm3.a5_4,             em_power_info_cnf->classm3.v_radio_cap_2);
+    TRACE_EVENT_EM_P6("EM_POWER_INFO_REQ_CLASSMARK_3: ra_cap_2:%d v_ra_cap_1:%d ra_cap_1:%d v_r_sup:%d r_sup:%d v_m_s_class:%d",
+      em_power_info_cnf->classm3.radio_cap_2,      em_power_info_cnf->classm3.v_radio_cap_1,
+      em_power_info_cnf->classm3.radio_cap_1,      em_power_info_cnf->classm3.v_r_support,
+      em_power_info_cnf->classm3.r_support,        em_power_info_cnf->classm3.v_m_s_class);
+    TRACE_EVENT_EM_P6("EM_POWER_INFO_REQ_CLASSMARK_3: m_s_class:%d ucs2_treat:%d ext_meas_cap:%d v_meas_cap:%d sw_time:%d sws_time:%d",
+      em_power_info_cnf->classm3.m_s_class,        em_power_info_cnf->classm3.ucs2_treat,
+      em_power_info_cnf->classm3.ext_meas_cap,     em_power_info_cnf->classm3.v_meas_cap,
+      em_power_info_cnf->classm3.meas_cap.sw_time, em_power_info_cnf->classm3.meas_cap.sws_time);
+
+    PFREE(em_power_info_cnf);
+
+  }/* if - Power (Classmark) data*/
+  
+  /*check Identity data*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_IDENTITY_INFO)
+  {   
+    TRACE_EVENT_EM_P4("EM_IDENTITY_INFO_REQ_IMEI: id_type:%d v_id:%d c_id:%d odd_even:%d",
+      rr_data->ms_data.imei.ident_type,
+      rr_data->ms_data.imei.v_ident_dig,
+      rr_data->ms_data.imei.c_ident_dig,
+      rr_data->ms_data.imei.odd_even);
+
+    TRACE_EVENT_EM_P8("EM_IDENTITY_INFO_REQ: imei_1: %d %d %d %d %d %d %d %d",
+      rr_data->ms_data.imei.ident_dig[0], rr_data->ms_data.imei.ident_dig[1],
+      rr_data->ms_data.imei.ident_dig[2], rr_data->ms_data.imei.ident_dig[3],
+      rr_data->ms_data.imei.ident_dig[4], rr_data->ms_data.imei.ident_dig[5],
+      rr_data->ms_data.imei.ident_dig[6], rr_data->ms_data.imei.ident_dig[7]);
+    TRACE_EVENT_EM_P8("EM_IDENTITY_INFO_REQ: imei_2: %d %d %d %d %d %d %d %d",
+      rr_data->ms_data.imei.ident_dig[8],  rr_data->ms_data.imei.ident_dig[9],
+      rr_data->ms_data.imei.ident_dig[10], rr_data->ms_data.imei.ident_dig[11],
+      rr_data->ms_data.imei.ident_dig[12], rr_data->ms_data.imei.ident_dig[13],
+      rr_data->ms_data.imei.ident_dig[14], rr_data->ms_data.imei.ident_dig[15]);
+
+    if (rr_data->ms_data.imsi_available) /* SIM available */
+    {
+      TRACE_EVENT_EM_P4("EM_IDENTITY_INFO_REQ_IMSI: id_type:%d v_id:%d c_id:%d odd_even:%d",
+        rr_data->ms_data.imsi.ident_type,
+        rr_data->ms_data.imsi.v_ident_dig,
+        rr_data->ms_data.imsi.c_ident_dig,
+        rr_data->ms_data.imsi.odd_even);
+      TRACE_EVENT_EM_P8("EM_IDENTITY_INFO_REQ: imsi_1: %d %d %d %d %d %d %d %d",
+        rr_data->ms_data.imsi.ident_dig[0], rr_data->ms_data.imsi.ident_dig[1],
+        rr_data->ms_data.imsi.ident_dig[2], rr_data->ms_data.imsi.ident_dig[3],
+        rr_data->ms_data.imsi.ident_dig[4], rr_data->ms_data.imsi.ident_dig[5],
+        rr_data->ms_data.imsi.ident_dig[6], rr_data->ms_data.imsi.ident_dig[7]);
+      TRACE_EVENT_EM_P8("EM_IDENTITY_INFO_REQ: imsi_2: %d %d %d %d %d %d %d %d",
+        rr_data->ms_data.imsi.ident_dig[8],  rr_data->ms_data.imsi.ident_dig[9],
+        rr_data->ms_data.imsi.ident_dig[10], rr_data->ms_data.imsi.ident_dig[11],
+        rr_data->ms_data.imsi.ident_dig[12], rr_data->ms_data.imsi.ident_dig[13],
+        rr_data->ms_data.imsi.ident_dig[14], rr_data->ms_data.imsi.ident_dig[15]);
+      }/*if - SIM available*/
+
+    if (rr_data->ms_data.tmsi_available EQ TRUE)
+      TRACE_EVENT_EM_P1("EM_IDENTITY_INFO_REQ: tmsi_bin: %ld", rr_data->ms_data.tmsi_binary);
+  }/*if - Identity data*/
+  
+   /*check AMR configuration data*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_AMR_INFO)
+  {
+    if((GET_STATE(STATE_ATT) EQ ATT_DEDICATED) AND 
+	                                (GET_STATE(STATE_DAT) EQ DAT_DEDICATED))
+    {
+      if(rr_data->sc_data.ch_mode EQ CM_AMR)
+      {
+        UBYTE amr_index,amr_nr_modes = 1;
+
+        TRACE_EVENT_EM_P5("EM_AMR_INFO_REQ_DEDICATED: vocoder:%d icmi:%d icm:%d acs:%d first_codec:%d",
+        rr_data->sc_data.chan_desc.chan_type,
+        rr_data->sc_data.amr_conf.icmi,
+        rr_data->sc_data.amr_conf.st_mode,
+        rr_data->sc_data.amr_conf.set_amr,
+        em_get_first_codec(rr_data->sc_data.amr_conf.set_amr));
+
+        if(rr_data->sc_data.amr_conf.v_cod_prop) 
+        {
+          /* Number of codec modes */
+          amr_nr_modes = rr_data->sc_data.amr_conf.c_cod_prop + 1;
+
+          TRACE_EVENT_EM_P1("EM_AMR_INFO_REQ_DEDICATED: amr_num_modes:%d",
+          amr_nr_modes);
+
+          /* Threshold and Hysteresis properties between codec modes */
+          for(amr_index=0;amr_index<amr_nr_modes;amr_index++)
+          {
+            TRACE_EVENT_EM_P2("EM_AMR_COD_PROP: thr:%d hyst:%d",
+            rr_data->sc_data.amr_conf.cod_prop[amr_index].codec_thr,
+            rr_data->sc_data.amr_conf.cod_prop[amr_index].codec_hyst);
+          }
+        } /* codec properties */
+      } /* AMR configured */
+      else
+      {
+        TRACE_EVENT_EM("EM_AMR_INFO_REQ_DEDICATED: AMR not configured");
+      } /* AMR not configured in dedicated state */
+    } /* ATT dedicated state */
+    else
+    {
+      TRACE_EVENT_EM("EM_AMR_INFO_REQ_IDLE: Not Applicable");
+    } /* ATT idle state */
+  } /* EM_PCO_AMR_INFO */
+  
+#if !defined (WIN32)
+  /*check SW Version data*/
+  if(em_pco_trace_req->pco_bitmap & EM_PCO_SW_VERSION_INFO)
+  {
+    TRACE_EVENT_EM_P1("EM_SW_SIM: %s",sim_version());
+    TRACE_EVENT_EM_P1("EM_SW_SMS: %s",sms_version());
+    TRACE_EVENT_EM_P1("EM_SW_SS:  %s",ss_version()) ;
+    TRACE_EVENT_EM_P1("EM_SW_CC:  %s",cc_version()) ;
+    TRACE_EVENT_EM_P1("EM_SW_MM:  %s",mm_version()) ;
+    TRACE_EVENT_EM_P1("EM_SW_RR:  %s",rr_version()) ;
+    TRACE_EVENT_EM_P1("EM_SW_DL:  %s",dl_version()) ;
+    TRACE_EVENT_EM_P1("EM_SW_L1:  %s",l1_version()) ;
+  }/*if - SW Version data*/
+#endif
+ 
+  PFREE(em_pco_trace_req);
+}/*rr_em_pco_trace_req*/
+
+
+/* ------------------ Microtec Cooperation Functions ----------*/
+#ifdef GPRS /* changes for later:  Include extra compile switch for fmm */
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_fmm_sc_info_req
++------------------------------------------------------------------------------
+|  Description  :  This function provides the data for microtec fmm - Program
+|
+|  Parameters   :  Primitive from EM - T_EM_FMM_SC_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+This function sends the latest stored data of the SC. It is only interesting
+during a GPRS connection (PTM). Therefor the ATT_STATE is ATT_IDLE (or RE_SELECTION).
+
+*/
+
+GLOBAL void dat_em_fmm_sc_info_req (T_EM_FMM_SC_INFO_REQ *em_fmm_sc_info_req)
+{ 
+  /*GET_INSTANCE_DATA;*/
+ PFREE(em_fmm_sc_info_req);
+
+ TRACE_FUNCTION ("dat_fmm_em_sc_info_req()");
+
+#ifdef FF_WAP
+ {
+  PALLOC(em_fmm_sc_info_cnf, EM_FMM_SC_INFO_CNF);
+
+  memset (em_fmm_sc_info_cnf, 0, sizeof (T_EM_FMM_SC_INFO_CNF));
+
+  switch (GET_STATE (STATE_ATT))
+  {
+   case ATT_IDLE:
+     if (rr_data->nc_data[SC_INDEX].bcch_status EQ DECODED)
+     {
+      em_fmm_sc_info_cnf->arfcn			      = rr_data->nc_data[SC_INDEX].arfcn;
+      em_fmm_sc_info_cnf->c1		  	      = rr_data->nc_data[SC_INDEX].c1;
+      em_fmm_sc_info_cnf->c2			        = rr_data->nc_data[SC_INDEX].c2;
+      em_fmm_sc_info_cnf->rac			        = rr_data->nc_data[SC_INDEX].rac;
+      em_fmm_sc_info_cnf->hyst			      = rr_data->nc_data[SC_INDEX].select_para.cell_resel_hyst;
+      em_fmm_sc_info_cnf->c32			        = rr_data->nc_data[SC_INDEX].c32;	/*c32_used abfragen ?*/
+      em_fmm_sc_info_cnf->gprs_prio_class = rr_data->nc_data[SC_INDEX].cr_par.priority_class;
+     }
+     else if (rr_data->nc_data[SC_INDEX].bcch_status EQ NON_DECODED)
+     {
+      em_fmm_sc_info_cnf->arfcn   = rr_data->nc_data[SC_INDEX].arfcn;
+     }
+     break;
+   case ATT_CS3:
+     break; /* Cell reselection - if needed can be included later*/
+   default:
+     break;
+  } /*switch*/
+ 
+/* TRACE_EVENT_P7("arfcn:%d c1:%d c2:%d rac:%d hyst:%d c32:%d prio:%d" , em_fmm_sc_info_cnf->arfcn,\
+      em_fmm_sc_info_cnf->c1 , em_fmm_sc_info_cnf->c2	,  em_fmm_sc_info_cnf->rac , em_fmm_sc_info_cnf->hyst,\
+      em_fmm_sc_info_cnf->c32, em_fmm_sc_info_cnf->gprs_prio_class);*/
+
+  PSENDX( WAP, em_fmm_sc_info_cnf);
+ }
+
+#endif /*FF_WAP*/
+
+}
+
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_fmm_nc_info_req
++------------------------------------------------------------------------------
+|  Description  :  Process the primitive EM_FMM_NC_INFO_REQ.
+|
+|  Parameters   :  Primitive from EM - T_EM_FMM_NC_INFO_REQ
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+This function sends the latest stored data of the NC. It is only interesting
+during a GPRS connection (PTM). Therefor the ATT_STATE is ATT_IDLE or RE_SELECTION.
+So the measurement report results should also be available in the nc_data.
+*/
+GLOBAL void dat_em_fmm_nc_info_req (T_EM_FMM_NC_INFO_REQ *em_fmm_nc_info_req)
+{
+  /*GET_INSTANCE_DATA;*/
+ PFREE(em_fmm_nc_info_req);
+
+ TRACE_FUNCTION ("dat_em_fmm_nc_info_req()");
+
+#ifdef FF_WAP
+ {
+  UBYTE index = 0, index2 = 0;
+  PALLOC(em_fmm_nc_info_cnf, EM_FMM_NC_INFO_CNF);
+
+  memset (em_fmm_nc_info_cnf, 0, sizeof (T_EM_FMM_NC_INFO_CNF));
+
+  switch (GET_STATE (STATE_ATT))
+  {
+		case ATT_IDLE:
+		  em_fmm_nc_info_cnf->no_ncells = rr_data->ms_data.measurement_report.ncells.no_of_ncells;
+			for (index = index2 = 0; index< EM_MAX_NUM_NC; index++)
+			{
+				if (rr_data->nc_data[index].bcch_status EQ DECODED)
+				{
+          em_fmm_nc_info_cnf->arfcn_nc[index2]			= rr_data->nc_data[index].arfcn;
+          em_fmm_nc_info_cnf->c2_nc[index2]			= rr_data->nc_data[index].c2;
+          em_fmm_nc_info_cnf->rac_nc[index2]			= rr_data->nc_data[index].rac;
+          em_fmm_nc_info_cnf->c31_nc[index2]			= rr_data->nc_data[index].c31;
+          em_fmm_nc_info_cnf->c32_nc[index2]			= rr_data->nc_data[index].c32;
+          em_fmm_nc_info_cnf->gprs_prio_class_nc[index2]	= rr_data->nc_data[index].cr_par.priority_class;
+          index2++;
+       	} /* if decoded */
+
+				else if (rr_data->nc_data[index].bcch_status EQ NON_DECODED)
+				{
+          em_fmm_nc_info_cnf->arfcn_nc[index]   = rr_data->nc_data[index].arfcn;
+				} /* if non decoded */
+			} /* for */
+
+			break;
+		default:
+			break;
+	}/*switch*/
+
+/* for (index = 0 ; index < EM_MAX_NUM_NC ; index++)
+   TRACE_EVENT_P6("arfcn:%d c2:%d rac:%d c31:%d c32:%d prio:%d", em_fmm_nc_info_cnf->arfcn_nc[index],\
+                    em_fmm_nc_info_cnf->c2_nc[index], em_fmm_nc_info_cnf->rac_nc[index],\
+                    em_fmm_nc_info_cnf->c31_nc[index], em_fmm_nc_info_cnf->c32_nc[index],\
+                    em_fmm_nc_info_cnf->gprs_prio_class_nc[index]);*/
+
+  PSENDX( WAP, em_fmm_nc_info_cnf);
+ }
+
+#endif /*FF_WAP*/
+
+
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_fmm_reselection_start_ind
++------------------------------------------------------------------------------
+|  Description  :  Indicates the start of an cell reselection to FMM
+|
+|  Parameters   :  void
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_fmm_reselection_start_ind (void)
+{
+  /*GET_INSTANCE_DATA;*/
+  TRACE_FUNCTION("dat_em_fmm_reselection_start_ind()");
+#ifdef FF_WAP
+  {
+    PALLOC(em_fmm_reselection_start_ind, EM_FMM_RESELECTION_START_IND);
+    memset (em_fmm_reselection_start_ind, 0, sizeof (T_EM_FMM_RESELECTION_START_IND));
+    em_fmm_reselection_start_ind->arfcn = rr_data->nc_data[rr_data->reselect_index].arfcn;
+    em_fmm_reselection_start_ind->rac = rr_data->nc_data[rr_data->reselect_index].rac;
+    em_fmm_reselection_start_ind->res_type = rr_data->sc_data.selection_type;
+
+/*    TRACE_EVENT_P3("em_fmm_reselection_start_ind %d,%d,%d",em_fmm_reselection_start_ind->arfcn,
+              em_fmm_reselection_start_ind->rac,em_fmm_reselection_start_ind->res_type );*/
+
+    PSENDX(WAP, em_fmm_reselection_start_ind);
+  }
+
+#endif /*FF_WAP */
+
+}
+
+/*
++------------------------------------------------------------------------------
+|  Function     :  dat_em_fmm_reselection_end_ind
++------------------------------------------------------------------------------
+|  Description  :  Indicates the end of an cell reselection to FMM
+|
+|  Parameters   :  void
+|
+|  Return       :  void
++------------------------------------------------------------------------------
+*/
+GLOBAL void dat_em_fmm_reselection_end_ind (void)
+{
+  /*GET_INSTANCE_DATA;*/
+  TRACE_FUNCTION("dat_em_fmm_reselection_end_ind()");
+#ifdef FF_WAP
+  {
+    PALLOC(em_fmm_resel_end_ind, EM_FMM_RESELECTION_END_IND);
+    memset (em_fmm_resel_end_ind, 0, sizeof (T_EM_FMM_RESELECTION_END_IND));
+    em_fmm_resel_end_ind->arfcn = rr_data->nc_data[SC_INDEX].arfcn;
+    em_fmm_resel_end_ind->rac = rr_data->nc_data[SC_INDEX].rac;
+/*    TRACE_EVENT_P2("em_fmm_reselection_end_ind %d,%d",em_fmm_resel_end_ind->arfcn,
+              em_fmm_resel_end_ind->rac);*/
+
+    PSENDX(WAP, em_fmm_resel_end_ind);
+  }
+
+#endif /*FF_WAP*/
+ 
+}
+
+
+#endif /* GPRS */
+
+#endif /* FF_EM_MODE */
+
+
+
+#endif /* RR_EM_C */