/* 
+----------------------------------------------------------------------------- 
|  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 ACI_EM_C
#define ACI_EM_C
#endif

#include "aci_all.h"
/*===== INCLUDES ===================================================*/

#include "aci_cmh.h"

#ifdef UART
#include "dti.h"
#include "dti_conn_mng.h"
#endif

#ifdef _SIMULATION_
#ifdef UART
#include "psa_uart.h"
#endif
#endif

#include "ati_cmd.h"
#include "aci_mem.h"

#ifdef FF_ATI
#include "aci_io.h"
#endif

#include "aci.h"

#include "aci_em.h"

#ifdef GPRS
#include "gaci.h"
#include "gaci_cmh.h"
#include "psa.h"
#include "cmh.h"
#include "cmh_sm.h"
#endif


/*==== CONSTANTS ==================================================*/
/*==== PRIVAT =====================================================*/
/*==== EXPORT =====================================================*/

EXTERN UBYTE em_l1_sem_buffer [];
EXTERN UBYTE em_l1_sem_index;
EXTERN UBYTE em_dl_sem_buffer [];
EXTERN UBYTE em_dl_sem_index;
EXTERN UBYTE em_rr_sem_buffer [];
EXTERN UBYTE em_rr_sem_index;

EXTERN void  em_l1_sem_read (void);
EXTERN void  em_l1_sem_reset(void);
EXTERN void  em_dl_sem_read (void);
EXTERN void  em_dl_sem_reset(void);
EXTERN void  em_rr_sem_read (void);
EXTERN UBYTE em_rr_sem_reset(void);

EXTERN UBYTE em_mm_event_buffer[EM_MM_BUFFER_SIZE];
EXTERN UBYTE em_mm_buffer_write;
EXTERN UBYTE em_cc_event_buffer[EM_CC_BUFFER_SIZE];
EXTERN UBYTE em_cc_buffer_write;
EXTERN UBYTE em_ss_event_buffer[EM_SS_BUFFER_SIZE];
EXTERN UBYTE em_ss_buffer_write;
EXTERN UBYTE em_sms_event_buffer[EM_SMS_BUFFER_SIZE];
EXTERN UBYTE em_sms_buffer_write;
EXTERN UBYTE em_sim_event_buffer[EM_SIM_BUFFER_SIZE];
EXTERN UBYTE em_sim_buffer_write;

EXTERN void  em_aci_sem (UBYTE entity, UBYTE *buffer, UBYTE buf_index_tmp);

#ifndef WIN32
EXTERN const CHAR* l1_version(void);
EXTERN const CHAR* dl_version(void);
EXTERN const CHAR* rr_version(void);
EXTERN const CHAR* mm_version(void);
EXTERN const CHAR* cc_version(void);
EXTERN const CHAR* ss_version(void);
EXTERN const CHAR* sim_version(void);
EXTERN const CHAR* sms_version(void);
/*EXTERN const CHAR* aci_version(void);*/
#endif


/*==== VARIABLES ==================================================*/

/*  
*  callback for the single infrastructure and mobile data functions.
*/
static drv_SignalCB_Type_EM  em_para_signal_callback         = NULL;
static drv_SignalCB_Type_EM  em_para_signal_sc_callback      = NULL;
static drv_SignalCB_Type_EM  em_para_signal_sc_gprs_callback = NULL;
static drv_SignalCB_Type_EM  em_para_signal_nc_callback      = NULL;
static drv_SignalCB_Type_EM  em_para_signal_loc_callback     = NULL;
static drv_SignalCB_Type_EM  em_para_signal_plmn_callback    = NULL;
static drv_SignalCB_Type_EM  em_para_signal_cip_callback     = NULL;
static drv_SignalCB_Type_EM  em_para_signal_pow_callback     = NULL;
static drv_SignalCB_Type_EM  em_para_signal_id_callback      = NULL;
static drv_SignalCB_Type_EM  em_para_signal_ver_callback     = NULL;
static drv_SignalCB_Type_EM  em_para_signal_gmm_callback     = NULL;
static drv_SignalCB_Type_EM  em_para_signal_grlc_callback    = NULL;
static drv_SignalCB_Type_EM  em_para_signal_amr_callback     = NULL;
static drv_SignalCB_Type_EM  em_para_signal_pdp_callback     = NULL;

/*  
*  callback for the event trace function.
*/
static drv_SignalCB_Type_EM_EVENT  em_event_signal_callback  = NULL;

/*  
*  These flags indicates if the first event for the corresponding entity occurred. It is only used to
*  prevent unnecessary semaphor copying.
*/
static UBYTE em_l1_trace;
static UBYTE em_dl_trace;
static UBYTE em_rr_trace;
static UBYTE em_mm_trace;
static UBYTE em_cc_trace;
static UBYTE em_ss_trace;
static UBYTE em_sms_trace;
static UBYTE em_sim_trace;

/*  
*  The buffer keeps all information about index and length of the single event trace data until it is
*  passed to the originator of the em_Read_Event_Parameter() call.
*/
static T_EM_EVENT_BUF aci_em_buf;

static UBYTE   drv_enabled;

static UBYTE em_aci_buf_index;

GLOBAL USHORT em_relcs = 0;

/*==== FUNCTIONS ==================================================*/
LOCAL UBYTE em_class_infra_data       (UBYTE em_subclass, UBYTE em_type);
LOCAL UBYTE em_class_mobile_data      (UBYTE em_subclass, UBYTE em_type);
LOCAL UBYTE em_class_event_tracing    (UBYTE em_subclass, ULONG bitmask_h, ULONG bitmask_l);

LOCAL UBYTE em_subclass_sc            (UBYTE em_type);
LOCAL UBYTE em_subclass_sc_gprs       (UBYTE em_type);
LOCAL UBYTE em_subclass_nc            (UBYTE em_type);
LOCAL UBYTE em_subclass_loc_pag       (UBYTE em_type);
LOCAL UBYTE em_subclass_plmn          (UBYTE em_type);
LOCAL UBYTE em_subclass_ciph_hop_dtx  (UBYTE em_type);
LOCAL UBYTE em_subclass_power         (UBYTE em_type);
LOCAL UBYTE em_subclass_id            (UBYTE em_type);
LOCAL UBYTE em_subclass_version       (UBYTE em_type);
LOCAL UBYTE em_subclass_gmm           (UBYTE em_type);
LOCAL UBYTE em_subclass_grlc          (UBYTE em_type);
LOCAL UBYTE em_subclass_amr           (UBYTE em_type);
#ifdef GPRS
LOCAL UBYTE em_subclass_pdp           (UBYTE em_type);
LOCAL void  em_pco_pdp_trace_req      (void );
#endif

LOCAL UBYTE em_event_l1               (USHORT bitmask_h, ULONG bitmask_l);
LOCAL UBYTE em_event_dl               (USHORT bitmask_h);
LOCAL UBYTE em_event_rr               (USHORT bitmask_h, ULONG bitmask_l);
LOCAL UBYTE em_event_mm               (ULONG  bitmask_h);
LOCAL UBYTE em_event_cc               (ULONG  bitmask_h, ULONG bitmask_l);
LOCAL UBYTE em_event_ss               (USHORT bitmask_h);
LOCAL UBYTE em_event_sms              (ULONG  bitmask_h, ULONG bitmask_l);
LOCAL UBYTE em_event_sim              (ULONG  bitmask);

LOCAL void em_sw_ver_info_cnf (T_EM_SW_VER *version);


/*==== FUNCTIONS ==================================================*/

/*
+------------------------------------------------------------------------------
|  Function     :  em_Init
+------------------------------------------------------------------------------
|  Description  :  The function initializes the driverīs internal data. The 
|                  function returns DRV_OK in case of a successful completition. 
|                  The function returns DRV_INITIALIZED if the driver has already 
|                  been initialized and is ready to be used or is already in use. 
|                  In case of an initialization failure, which means that the 
|                  driver cannot be used, the function returns DRV_INITFAILURE.
|                  This function handles unsupported primitives.
|
|  Parameters   :  Callback function
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

GLOBAL UBYTE em_Init (drv_SignalCB_Type_EM in_SignalCBPtr, drv_SignalCB_Type_EM_EVENT in_SignalEventCBPtr)
{
 TRACE_FUNCTION("em_Init ()");

 em_para_signal_callback  = in_SignalCBPtr;      /* store call-back function - Data */
 em_event_signal_callback = in_SignalEventCBPtr; /* store call-back function - Event */

 em_relcs = 0;
 
 if (drv_enabled EQ FALSE) {                  /* EM not initialized yet */
   drv_enabled = TRUE;
   return DRV_OK;
 }
 else {
   return DRV_INITIALIZED;
 }
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_Exit
+------------------------------------------------------------------------------
|  Description  :  The function is used to indicate that the driver and its 
|                  functionality isnīt needed anymore.
|
|  Parameters   :  void
|
|  Return       :  void
+------------------------------------------------------------------------------
*/

GLOBAL void em_Exit (void)
{
 TRACE_FUNCTION("em_Exit ()");

 em_para_signal_callback = NULL;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_Read_Data_Parameter
+------------------------------------------------------------------------------
|  Description  :  The function is used to indicate that the driver and its 
|                  functionality isnīt needed anymore.
|
|  Parameters   :  UBYTE em_class              
|                  UBYTE em_subclass
|                  UBYTE em_type
|                  void (*cbfunc)(T_DRV_SIGNAL_EM * Signal)
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

GLOBAL UBYTE em_Read_Data_Parameter (UBYTE em_class, UBYTE em_subclass, UBYTE em_type, 
                                     void (*cbfunc)(T_DRV_SIGNAL_EM * Signal))
{
 TRACE_FUNCTION("em_Read_Data_Parameter ()");

  /*
   Used to store the callback-address for the different sub-functions. If the same infrastructure data is 
   requested a second time before the first one is served only the latest one is handled.
  */
  switch (em_subclass)
  {
    case EM_SUBCLASS_SC:
      em_para_signal_sc_callback      = cbfunc;
      break;
    case EM_SUBCLASS_SC_GPRS:
      em_para_signal_sc_gprs_callback = cbfunc;
      break;
    case EM_SUBCLASS_NC:
      em_para_signal_nc_callback      = cbfunc;
      break;
    case EM_SUBCLASS_LOC_PAG:
      em_para_signal_loc_callback     = cbfunc;
      break;
    case EM_SUBCLASS_PLMN:
      em_para_signal_plmn_callback    = cbfunc;
      break;
    case EM_SUBCLASS_CIPH_HOP_DTX:
      em_para_signal_cip_callback     = cbfunc;
      break;
    case EM_SUBCLASS_POWER:
      em_para_signal_pow_callback     = cbfunc;
      break;
    case EM_SUBCLASS_ID:
      em_para_signal_id_callback      = cbfunc;
      break;
    case EM_SUBCLASS_SW_VERSION:
      em_para_signal_ver_callback     = cbfunc;
      break;
    case EM_SUBCLASS_GMM:
      em_para_signal_gmm_callback     = cbfunc;
      break;
    case EM_SUBCLASS_GRLC:
      em_para_signal_grlc_callback    = cbfunc;
      break;
    case EM_SUBCLASS_AMR:
      em_para_signal_amr_callback     = cbfunc;
      break;
    case EM_SUBCLASS_PDP:
      em_para_signal_pdp_callback     = cbfunc;
      break;
    default:
      em_para_signal_callback         = NULL;
      break;
  }

  switch (em_class)
  {
    case EM_CLASS_INFRA_DATA:
      return(em_class_infra_data(em_subclass, em_type));
    case EM_CLASS_MOBILE_DATA:
      return(em_class_mobile_data(em_subclass, em_type));
    default:
      return EM_INVALID_CLASS;
  }
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_Read_Event_Parameter
+------------------------------------------------------------------------------
|  Description  :  The function is used to indicate that the driver and its 
|                  functionality isnīt needed anymore.
|
|  Parameters   :  UBYTE entity 
|                  (*cbfunc)(T_DRV_SIGNAL_EM_EVENT * Signal)
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

GLOBAL UBYTE em_Read_Event_Parameter (UBYTE entity, void (*cbfunc)(T_DRV_SIGNAL_EM_EVENT * Signal))
{
  T_DRV_SIGNAL_EM_EVENT signal_params;
  
  UBYTE  emet1=0,emet2=0,emet3=0,emet4=0,emet5=0,emet6=0,emet7=0,emet8=0;
  UBYTE *event_buf;
  USHORT length_event_buf;
  UBYTE  alr_tmp, dl_tmp, rr_tmp, mm_tmp, cc_tmp, ss_tmp, sms_tmp, sim_tmp;

  TRACE_FUNCTION("em_Read_Event_Parameter ()");

  /*
  *  Used to store the callback-address for the different sub-functions. If the same event trace is 
  *  requested a second time before the first one is served only the latest one is handled.
  */
  em_event_signal_callback = cbfunc;

  em_aci_buf_index = 0;

  /*
  *  length_event_buf indicates the length of all event traces and is used for dynamic
  *  memory allocation. The single values are from the correspondent entities and therefor
  *  defined as global. To ensure that no buffer overflow happens, the actual index is stored
  *  in a temp variable - a new event could occure after the memory is allocated.
  */
  length_event_buf = (alr_tmp=em_l1_sem_index) + (dl_tmp=em_dl_sem_index) +  (rr_tmp=em_rr_sem_index) + 
                     (mm_tmp=em_mm_buffer_write) + (cc_tmp=em_cc_buffer_write) + (ss_tmp=em_ss_buffer_write) + 
                     (sms_tmp=em_sms_buffer_write) + (sim_tmp=em_sim_buffer_write);

  #ifdef WIN32
  length_event_buf = 100;
  #endif /* WIN32 */

  memset(&aci_em_buf, 0, sizeof(T_EM_EVENT_BUF));

  ACI_MALLOC(event_buf, length_event_buf);

  /*
  *  This checks if the entity is set in the bitmask and at least one event
  *  occurred in the corresponding entity. The event flag (em_xx_trace) protects
  *  unnecessary buffer operations.
  */
  emet1 = ( (((entity & 0x0001) > 0) ? TRUE : FALSE) AND em_l1_trace ) ;  /* L1  */
  emet2 = ( (((entity & 0x0002) > 0) ? TRUE : FALSE) AND em_dl_trace ) ;  /* DL  */
  emet3 = ( (((entity & 0x0004) > 0) ? TRUE : FALSE) AND em_rr_trace ) ;  /* RR  */
  emet4 = ( (((entity & 0x0008) > 0) ? TRUE : FALSE) AND em_mm_trace ) ;  /* MM  */
  emet5 = ( (((entity & 0x0010) > 0) ? TRUE : FALSE) AND em_cc_trace ) ;  /* CC  */
  emet6 = ( (((entity & 0x0020) > 0) ? TRUE : FALSE) AND em_ss_trace ) ;  /* SS  */
  emet7 = ( (((entity & 0x0040) > 0) ? TRUE : FALSE) AND em_sms_trace );  /* SMS */
  emet8 = ( (((entity & 0x0080) > 0) ? TRUE : FALSE) AND em_sim_trace );  /* SIM */

  if(emet1)
  {
      em_aci_sem(EM_L1, event_buf, alr_tmp); 
      em_l1_trace = FALSE;
  }
  if(emet2)
  {
      em_aci_sem(EM_DL, event_buf, dl_tmp); 
      em_dl_trace = FALSE;
  }
  if(emet3)
  {
      em_aci_sem(EM_RR, event_buf, rr_tmp);
      em_rr_trace = FALSE;
  }
  if(emet4)
  {
      em_aci_sem(EM_MM, event_buf, mm_tmp); 
      em_mm_trace = FALSE;
  }
  if(emet5)
  {
      em_aci_sem(EM_CC, event_buf, cc_tmp); 
      em_cc_trace = FALSE;
  }
  if(emet6)
  {
      em_aci_sem(EM_SS, event_buf, ss_tmp);
      em_ss_trace = FALSE;
  }
  if(emet7)
  {
      em_aci_sem(EM_SMS, event_buf, sms_tmp); 
      em_sms_trace = FALSE;
  }
  if(emet8)
  {
      em_aci_sem(EM_SIM, event_buf, sim_tmp);
      em_sim_trace = FALSE;
  } 

  memcpy(&signal_params.Data, &aci_em_buf, sizeof(T_EM_EVENT_BUF));
  signal_params.DataLength = length_event_buf;
  signal_params.Pointer    = event_buf;

  if (em_event_signal_callback NEQ NULL) {
  (*em_event_signal_callback)(&signal_params);
  }
  
  ACI_MFREE(event_buf);

  return TRUE;
}
                                
/*
+------------------------------------------------------------------------------
|  Function     :  em_Set_EventTrace
+------------------------------------------------------------------------------
|  Description  :  Set the event flags and the callback function for the subclass
|
|  Parameters   :  subclass  - defines the subclass the data is coming from
|                  bitmask_h - bitmask 
|                  bitmask_l - bitmask 
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE em_Set_EventTrace (UBYTE em_subclass, ULONG bitmask_h, ULONG bitmask_l)
{
 TRACE_FUNCTION("em_Set_EventTrace ()");

 return(em_class_event_tracing(em_subclass, bitmask_h, bitmask_l));
}


/*
+------------------------------------------------------------------------------
|  Function     :  em_Received_Data
+------------------------------------------------------------------------------
|  Description  :  Compose the callback function
|
|  Parameters   :  data - requested data
          subclass - defines the subclass the data is coming from
|
|  Return       :  void
+------------------------------------------------------------------------------
*/
GLOBAL void em_Received_Data (void *data, UBYTE subclass)
{
 /*lint -e813*//* info about auto variable size of drv_SignalID_Type_EM*/
 drv_SignalID_Type_EM signal_params; 

 TRACE_FUNCTION("em_Received_Data ()");

 signal_params.SignalType = subclass;

 switch (subclass) {
   case EM_SUBCLASS_SC: {
     memcpy(&signal_params.UserData.sc, data, sizeof (T_EM_SC_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.sc) + 6); 
     em_para_signal_callback = em_para_signal_sc_callback;
     break; } 
   case EM_SUBCLASS_SC_GPRS: {        
     memcpy(&signal_params.UserData.sc_gprs, data, sizeof (T_EM_SC_GPRS_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.sc_gprs) + 6); 
     em_para_signal_callback = em_para_signal_sc_gprs_callback;
     break; } 
   case EM_SUBCLASS_NC: {             
     memcpy(&signal_params.UserData.nc, data, sizeof (T_EM_NC_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.nc) + 6); 
     em_para_signal_callback = em_para_signal_nc_callback;   
     break; } 
   case EM_SUBCLASS_LOC_PAG: {         
     memcpy(&signal_params.UserData.log_pag, data, sizeof (T_EM_LOC_PAG_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.log_pag) + 6); 
     em_para_signal_callback = em_para_signal_loc_callback;   
     break; } 
   case EM_SUBCLASS_PLMN: {           
     memcpy(&signal_params.UserData.plmn, data, sizeof (T_EM_PLMN_INFO_CNF));
     signal_params.UserData.plmn.rel_cause = em_relcs;
     signal_params.DataLength    = (sizeof (signal_params.UserData.plmn) + 6); 
     em_para_signal_callback = em_para_signal_plmn_callback;   
     break; } 
   case EM_SUBCLASS_CIPH_HOP_DTX: {   
     memcpy(&signal_params.UserData.cip, data, sizeof (T_EM_CIP_HOP_DTX_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.cip) + 6); 
     em_para_signal_callback = em_para_signal_cip_callback;
     break; } 
   case EM_SUBCLASS_POWER: {          
     memcpy(&signal_params.UserData.power, data, sizeof (T_EM_POWER_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.power) + 6); 
     em_para_signal_callback = em_para_signal_pow_callback;
     break; } 
   case EM_SUBCLASS_ID: {             
     memcpy(&signal_params.UserData.id, data, sizeof (T_EM_IDENTITY_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.id) + 6); 
     em_para_signal_callback = em_para_signal_id_callback;
     break; } 
   case EM_SUBCLASS_SW_VERSION: {
     em_sw_ver_info_cnf(&signal_params.UserData.version);
     signal_params.DataLength    = (sizeof (signal_params.UserData.version) + 6); 
     em_para_signal_callback = em_para_signal_ver_callback;
     break; } 
   case EM_SUBCLASS_GMM: {        
     memcpy(&signal_params.UserData.gmm, data, sizeof (T_EM_GMM_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.gmm) + 6); 
     em_para_signal_callback = em_para_signal_gmm_callback;
     break; } 
   case EM_SUBCLASS_GRLC: {        
     memcpy(&signal_params.UserData.grlc, data, sizeof (T_EM_GRLC_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.grlc) + 6); 
     em_para_signal_callback = em_para_signal_grlc_callback;
     break; } 
   case EM_SUBCLASS_AMR: {        
     memcpy(&signal_params.UserData.amr, data, sizeof (T_EM_AMR_INFO_CNF));
     signal_params.DataLength    = (sizeof (signal_params.UserData.amr) + 6); 
     em_para_signal_callback = em_para_signal_amr_callback;
     break; }
   case EM_SUBCLASS_PDP: {        
     em_para_signal_callback = em_para_signal_pdp_callback;
     break; }
   default: {
     signal_params.UserData.defaulT  = 0xff; 
     signal_params.DataLength    = (sizeof (signal_params.UserData.defaulT) + 6); 
     em_para_signal_callback = NULL;
     break; } 
  }  
  if (em_para_signal_callback NEQ NULL) {
   (*em_para_signal_callback)(&signal_params);
   }

  if(data NEQ NULL)
    PFREE(data);  
}

LOCAL void em_sw_ver_info_cnf (T_EM_SW_VER *version)
{
  TRACE_FUNCTION ("em_sw_ver_info_cnf()");

  memset (version, 0, sizeof (T_EM_SW_VER));

#ifndef WIN32
  /* The respective functions are auto-generated by the target build only */

  /* Copy the static const strings into the structure */
  strncpy (version->alr,  l1_version(),   MAX_VER-1);
  strncpy (version->dl,   dl_version(),   MAX_VER-1);
  strncpy (version->rr,   rr_version(),   MAX_VER-1);
  strncpy (version->mm,   mm_version(),   MAX_VER-1);
  strncpy (version->cc,   cc_version(),   MAX_VER-1);
  strncpy (version->ss,   ss_version(),   MAX_VER-1);
  strncpy (version->sms,  sms_version(),  MAX_VER-1);
  strncpy (version->sim,  sim_version(),  MAX_VER-1);
#endif
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_class_infra_data
+------------------------------------------------------------------------------
|  Description  :  This function calls the appropriate subfunction for the 
|          requested data (infrastructure data).
|
|  Parameters   :  em_subclass - defines the subclass the data is requested from
|          em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_class_infra_data (UBYTE em_subclass, UBYTE em_type)
{
 TRACE_FUNCTION("em_class_infra_data ()");

  switch (em_subclass)
  {
    case EM_SUBCLASS_SC:
      return (em_subclass_sc(em_type));
    case EM_SUBCLASS_SC_GPRS:
     #ifdef GPRS
        return (em_subclass_sc_gprs(em_type));
     #else
       return EM_INVALID_SUBCLASS;   
     #endif /* GPRS */
    case EM_SUBCLASS_NC:
      return (em_subclass_nc(em_type));      
    case EM_SUBCLASS_LOC_PAG:
      return (em_subclass_loc_pag(em_type));
    case EM_SUBCLASS_PLMN:
      return (em_subclass_plmn(em_type));
    case EM_SUBCLASS_CIPH_HOP_DTX:
      return (em_subclass_ciph_hop_dtx(em_type));
    case EM_SUBCLASS_GMM:
#ifdef GPRS
      return (em_subclass_gmm(em_type));
#else /* GPRS */
      return EM_INVALID_SUBCLASS;   
#endif /* GPRS */
    case EM_SUBCLASS_GRLC:
#ifdef GPRS
      return (em_subclass_grlc(em_type));
#else /* GPRS */
      return EM_INVALID_SUBCLASS;   
#endif /* GPRS */
    case EM_SUBCLASS_AMR:
      return (em_subclass_amr(em_type));
#ifdef GPRS
    case EM_SUBCLASS_PDP:
      return (em_subclass_pdp(em_type));
#else
      return EM_INVALID_SUBCLASS;
#endif
    default:
      return EM_INVALID_SUBCLASS;
  }
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_class_mobile_data
+------------------------------------------------------------------------------
|  Description  :  This function calls the appropriate subfunction for the 
|          requested data (mobile data).
|
|  Parameters   :  em_subclass - defines the subclass the data is requested from
|          em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_class_mobile_data (UBYTE em_subclass, UBYTE em_type)
{
 TRACE_FUNCTION("em_class_mobile_data ()");

 switch (em_subclass)
  {
  case EM_SUBCLASS_POWER:
   return (em_subclass_power(em_type));
  case EM_SUBCLASS_ID:
   return (em_subclass_id(em_type));
  case EM_SUBCLASS_SW_VERSION:
   return (em_subclass_version(em_type)); /* not implemented yet */
  default:
   return EM_INVALID_SUBCLASS;
 }
}


/*
+------------------------------------------------------------------------------
|  Function     :  em_class_event_tracing
+------------------------------------------------------------------------------
|  Description  :  This function calls the appropriate subfunction for the 
|                  requested data (event trace).
|
|  Parameters   :  em_subclass - defines the event subclass
|                  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_class_event_tracing (UBYTE em_subclass, ULONG bitmask_h, ULONG bitmask_l)
{
 TRACE_FUNCTION("em_class_event_tracing ()");

  switch (em_subclass)
  {
    case EM_SUBCLASS_LAYER_1:
       return em_event_l1((USHORT)bitmask_h, bitmask_l);   
    case EM_SUBCLASS_DL:
       return em_event_dl((USHORT)bitmask_l);   
    case EM_SUBCLASS_RR:
       return em_event_rr((USHORT)bitmask_h, bitmask_l);   
    case EM_SUBCLASS_MM:
       return em_event_mm(bitmask_l);   
    case EM_SUBCLASS_CC:
       return em_event_cc(bitmask_h, bitmask_l);   
    case EM_SUBCLASS_SS:
       return em_event_ss((USHORT)bitmask_l); 
    case EM_SUBCLASS_SMS:
       return em_event_sms(bitmask_h, bitmask_l);   
    case EM_SUBCLASS_SIM:
       return em_event_sim(bitmask_l);         
    default:
      return EM_INVALID_SUBCLASS;
  }
} 

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_sc
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_sc (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_sc()");

  /*
   *-------------------------------------------------------------------
   * create and send primitive
   *-------------------------------------------------------------------
   */
  {
  PALLOC(em_sc_info_req, EM_SC_INFO_REQ); /* T_EM_SC_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_sc_info_req->data = em_type;
    
  /* the primitive is send to RR via MM */
  PSENDX (RR, em_sc_info_req);
  }
 return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_sc_gprs
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

#ifdef GPRS
LOCAL UBYTE em_subclass_sc_gprs (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_sc_gprs()");

  /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
  PALLOC(em_sc_gprs_info_req, EM_SC_GPRS_INFO_REQ); /* T_EM_SC_GPRS_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_sc_gprs_info_req->data = em_type;
    
  /* the primitive is send to GRR via GMM */
  PSEND (hCommGMM, em_sc_gprs_info_req);
  }
 return TRUE;
}
#endif /* GPRS */

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_nc
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_nc (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_nc()");

/*
 *-------------------------------------------------------------------
 * create and send primitive
 *-------------------------------------------------------------------
 */
 {
  PALLOC(em_nc_info_req, EM_NC_INFO_REQ); /* T_EM_NC_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_nc_info_req->data = em_type;
    
  /* the primitive is send to RR via MM */
  PSENDX (RR, em_nc_info_req);
  }
 return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_loc_pag
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_loc_pag (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_loc_pag()");

/*
 *-------------------------------------------------------------------
 * create and send primitive
 *-------------------------------------------------------------------
 */
 {
  PALLOC(em_loc_pag_info_req, EM_LOC_PAG_INFO_REQ); /* T_EM_LOC_PAG_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_loc_pag_info_req->data = em_type;
    
  /* the primitive is send to RR via MM */
  PSENDX (RR, em_loc_pag_info_req);
  }
 return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_plmn
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_plmn (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_plmn()");

/*
 *-------------------------------------------------------------------
 * create and send primitive
 *-------------------------------------------------------------------
 */
 {
  PALLOC(em_plmn_info_req, EM_PLMN_INFO_REQ); /* T_EM_PLMN_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_plmn_info_req->data = em_type;
    
  /* the primitive is send to RR via MM */
  PSENDX (RR, em_plmn_info_req);
  }
 return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_ciph_hop_dtx
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_ciph_hop_dtx (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_ciph_hop_dtx()");

/*
 *-------------------------------------------------------------------
 * create and send primitive
 *-------------------------------------------------------------------
 */
 {
  PALLOC(em_cip_hop_dtx_info_req, EM_CIP_HOP_DTX_INFO_REQ); /* T_EM_CIP_HOP_DTX_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_cip_hop_dtx_info_req->data = em_type;
    
  /* the primitive is send to RR via MM */
  PSENDX (RR, em_cip_hop_dtx_info_req);
  }
 return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_power
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_power (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_power()");

/*
 *-------------------------------------------------------------------
 * create and send primitive
 *-------------------------------------------------------------------
 */
 {
  PALLOC(em_power_info_req, EM_POWER_INFO_REQ); /* T_EM_POWER_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_power_info_req->data = em_type;
    
  /* the primitive is send to RR via MM */
  PSENDX (RR, em_power_info_req);
  }
 return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_id
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_id (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_id()");

/*
 *-------------------------------------------------------------------
 * create and send primitive
 *-------------------------------------------------------------------
 */
 {
  PALLOC(em_identity_info_req, EM_IDENTITY_INFO_REQ); /* T_EM_IDENTITY_INFO_REQ */
  
  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_identity_info_req->data = em_type;
    
  /* the primitive is send to RR via MM */
  PSENDX (RR, em_identity_info_req);
  }
 return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_version
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_version (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_version()");

/*
 *-------------------------------------------------------------------
 * create and send primitive
 *-------------------------------------------------------------------
 */
 {
  PALLOC(em_sw_version_info_req, EM_SW_VERSION_INFO_REQ); /* T_EM_SW_VERSION_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_sw_version_info_req->data = em_type;
    
  /* the primitive is send to RR via MM */
  PSENDX (RR, em_sw_version_info_req);
  }
 return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_pco_bitmap
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_pco_bitmap - defines the actual requested data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

UBYTE em_subclass_pco_bitmap (U32 em_pco_bitmap)
{
  TRACE_FUNCTION ("em_subclass_pco_bitmap()");

/*
 *-------------------------------------------------------------------
 * create and send primitive
 *-------------------------------------------------------------------
 */

#ifdef GPRS
  /*check for requested GMM, GRLC, GRR info*/
  if(em_pco_bitmap & (EM_PCO_GPRS_INFO | EM_PCO_GMM_INFO | EM_PCO_GRLC_INFO))
  {
    PALLOC(em_pco_trace_req, EM_PCO_TRACE_REQ); /* T_EM_PCO_TRACE_REQ */

    em_pco_trace_req->pco_bitmap = em_pco_bitmap;

    /* the primitive is send to GMM*/
    PSENDX(GMM, em_pco_trace_req);
  }
#endif /*GPRS*/
  
  /*check for requested RR info*/
  if(em_pco_bitmap & (EM_PCO_SC_INFO | EM_PCO_NC_INFO | EM_PCO_LOC_PAG_INFO | EM_PCO_IDENTITY_INFO |
          EM_PCO_CIPH_HOP_DTX_INFO | EM_PCO_POWER_INFO | EM_PCO_PLMN_INFO | EM_PCO_SW_VERSION_INFO |
          EM_PCO_AMR_INFO))
  {
    PALLOC(em_pco_trace_req, EM_PCO_TRACE_REQ); /* T_EM_PCO_TRACE_REQ */

    em_pco_trace_req->pco_bitmap = em_pco_bitmap;

    /* the primitive is send to RR*/
    PSENDX(RR, em_pco_trace_req);
  }

#ifdef GPRS
  if(em_pco_bitmap & EM_PCO_PDP_INFO)
  {
    em_pco_pdp_trace_req();
  }
#endif
 return TRUE;
}/*em_subclass_pco_bitmap*/

/*
+------------------------------------------------------------------------------
|  Function     :  em_pco_pdp_trace_req
+------------------------------------------------------------------------------
|  Description  :  This function prints PDP configuration on PCO 
|
|  Parameters   :  void
|
|  Return       :  void
+------------------------------------------------------------------------------
*/
#ifdef GPRS
LOCAL void em_pco_pdp_trace_req(void)
{
  UBYTE c_state,cid;

  TRACE_FUNCTION ("em_pco_pdp_trace_req()");

  TRACE_EVENT_EM_P1("EM_PDP_INFO_REQ: num_ctxts : %d",MAX_CID);
        
  for(cid=1;cid<=MAX_PDP_CTXT;cid++)
  {
    c_state = get_state_over_cid( cid );
         
    if((c_state EQ CS_UNDEFINED) OR (c_state EQ CS_INVALID_STATE))
      TRACE_EVENT_EM_P1("EM_PDP_INFO_REQ: state : %d",c_state);
    else
    {
      TRACE_EVENT_EM_P4("EM_PDP_INFO_REQ: state:%d,pdp_type:%s,apn:%s,pdp address:%s", 
              c_state,
              pdp_context[cid-1].con.pdp_type,
              pdp_context[cid-1].con.apn,
              ((c_state EQ CS_ACTIVATED) OR (c_state EQ CS_DATA_LINK)) 
              ? pdp_context[cid-1].allocated_pdp_addr : pdp_context[cid-1].con.pdp_addr);
    }
  }

}
#endif /* GPRS */

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_gmm
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

#ifdef GPRS
LOCAL UBYTE em_subclass_gmm(UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_gmm()");

  /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
  PALLOC(em_gmm_info_req, EM_GMM_INFO_REQ); /* T_EM_SC_GPRS_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_gmm_info_req->data = em_type;
    
  /* the primitive is send to GMM */
  PSEND (hCommGMM, em_gmm_info_req);
  }
 return TRUE;
}
#endif /* GPRS */

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_gmm
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

#ifdef GPRS
LOCAL UBYTE em_subclass_grlc(UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_grlc()");

  /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
  PALLOC(em_subclass_grlc, EM_GRLC_INFO_REQ); /* T_EM_SC_GPRS_INFO_REQ */

  /* fill in primitive parameter:  */
  /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
  em_subclass_grlc->data = em_type;
    
  /* the primitive is send to GRLC via GMM */
  PSEND (hCommGMM, em_subclass_grlc);
  }
 return TRUE;
}
#endif /* GPRS */

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_amr
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_subclass_amr (UBYTE em_type)
{
  TRACE_FUNCTION ("em_subclass_amr()");

  /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
    PALLOC(em_amr_info_req, EM_AMR_INFO_REQ); /* T_EM_AMR_INFO_REQ */

    /* fill in primitive parameter:  */
    /* the bitmask em_type is only used to prevent unnecesary use of primitives*/
    em_amr_info_req->data = em_type;
    
    /* the primitive directly to RR */
    PSENDX (RR, em_amr_info_req);
  }
  return TRUE;
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_subclass_pdp
+------------------------------------------------------------------------------
|  Description  :  This function displays PDP output directly since the 
|                  data is available in ACI itself.                   
|
|  Parameters   :  em_type - defines the actual data
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

#ifdef GPRS
LOCAL UBYTE em_subclass_pdp (UBYTE em_type)
{
  
  TRACE_FUNCTION ("em_subclass_pdp()");

  em_Received_Data ((void *)NULL, EM_SUBCLASS_PDP);

  return TRUE;

}
#endif

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_l1
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_event_l1 (USHORT bitmask_h, ULONG bitmask_l)
{
  TRACE_FUNCTION ("em_event_l1()");

 /* check if only specified events are set in the bitmask */
 if (!(bitmask_h & ~EM_BITMASK_L1_H)) 
 {
  /*
   *-------------------------------------------------------------------
   * create and send primitive
   *-------------------------------------------------------------------
   */
   PALLOC(em_l1_event_req, EM_L1_EVENT_REQ); /* T_EM_L1_EVENT_REQ */

     /* fill in primitive parameter:  */
   em_l1_event_req->bitmask_l1_h = bitmask_h;
   em_l1_event_req->bitmask_l1_l = bitmask_l;

   /* additional information for the mscviewer */
   TRACE_PRIM_TO("PL");
          
   /* the primitive is send to PL */
   PSENDX (PL, em_l1_event_req);
   return TRUE;
 }
 else                      /* wrong bitmask */
  return EM_DATA_NOT_AVAIL;                 
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_dl
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_event_dl (USHORT bitmask)
{
  TRACE_FUNCTION ("em_event_dl()");

 /* check if only specified events are set in the bitmask */
 if (!(bitmask & ~EM_BITMASK_DL)) {
 /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
   PALLOC(em_dl_event_req, EM_DL_EVENT_REQ); /* T_EM_DL_EVENT_REQ */

   /* fill in primitive parameter:  */
   em_dl_event_req->bitmask_dl = bitmask;

   /* additional information for the mscviewer */
   TRACE_PRIM_TO("DL");
          
   /* the primitive is send to DL via MM */
   PSENDX (MM, em_dl_event_req);
   }
  return TRUE;
 }
 else                      /* wrong bitmask */
  return EM_DATA_NOT_AVAIL;                 
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_rr
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_event_rr (USHORT bitmask_h, ULONG bitmask_l)
{
  TRACE_FUNCTION ("em_event_rr()");

 /* check if only specified events are set in the bitmask */
 if (!(bitmask_h & ~EM_BITMASK_RR_H)) {
 /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
   PALLOC(em_rr_event_req, EM_RR_EVENT_REQ); /* EM_RR_EVENT_REQ */

   /* fill in primitive parameter:  */
   em_rr_event_req->bitmask_rr_h = bitmask_h;
   em_rr_event_req->bitmask_rr_l = bitmask_l;

   /* no additional information for the mscviewer is needed here because 
    * RR is the default entity inside the mscview.tbl
   TRACE_PRIM_TO("RR");
   */
       
   /* the primitive is send to RR */
   PSENDX (RR, em_rr_event_req);
   }
  return TRUE;
 }
 else                      /* wrong bitmask */
  return EM_DATA_NOT_AVAIL;                 
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_mm
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_event_mm (ULONG bitmask)
{
  TRACE_FUNCTION ("em_event_mm()");

 /* check if only specified events are set in the bitmask */
 if (!(bitmask & ~EM_BITMASK_MM)) {
 /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
   PALLOC(em_mm_event_req, EM_MM_EVENT_REQ); /* T_EM_MM_EVENT_REQ */

   /* fill in primitive parameter:  */
   em_mm_event_req->bitmask_mm = bitmask;

   /* additional information for the mscviewer */
   TRACE_PRIM_TO("MM");
          
   /* the primitive is send to MM */
   PSENDX (MM, em_mm_event_req);
   }
  return TRUE;
 }
 else                      /* wrong bitmask */
  return EM_DATA_NOT_AVAIL;                 
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_cc
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_event_cc (ULONG bitmask_h, ULONG bitmask_l)
{
  TRACE_FUNCTION ("em_event_cc()");

 /* check if only specified events are set in the bitmask */
 if (!(bitmask_h & ~EM_BITMASK_CC_H)) {
 /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
   PALLOC(em_cc_event_req, EM_CC_EVENT_REQ); /* T_EM_CC_EVENT_REQ */

   /* fill in primitive parameter:  */
   em_cc_event_req->bitmask_cc_h = bitmask_h;
   em_cc_event_req->bitmask_cc_l = bitmask_l;          

   /* additional information for the mscviewer */
   TRACE_PRIM_TO("CC");
          
   /* the primitive is send to CC */
   PSENDX (CC, em_cc_event_req);
   }
  return TRUE;
 }
 else                      /* wrong bitmask */
  return EM_DATA_NOT_AVAIL;                 
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_ss
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/


LOCAL UBYTE em_event_ss (USHORT bitmask)
{
  TRACE_FUNCTION ("em_event_ss()");

 /* check if only specified events are set in the bitmask */
 if (!(bitmask & ~EM_BITMASK_SS)) {
 /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
   PALLOC(em_ss_event_req, EM_SS_EVENT_REQ); /* T_EM_SS_EVENT_REQ */

   /* fill in primitive parameter:  */
   em_ss_event_req->bitmask_ss = bitmask;

   /* additional information for the mscviewer */
   TRACE_PRIM_TO("SS");
          
   /* the primitive is send to SS */
   PSENDX (SS, em_ss_event_req);
   }
  return TRUE;
 }
 else                      /* wrong bitmask */
  return EM_DATA_NOT_AVAIL;                 
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_sms
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_event_sms (ULONG bitmask_h, ULONG bitmask_l)
{
  TRACE_FUNCTION ("em_event_sms()");

 /* check if only specified events are set in the bitmask */
 if (!(bitmask_h & ~EM_BITMASK_SMS_H)) {
 /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
   PALLOC(em_sms_event_req, EM_SMS_EVENT_REQ); /* T_EM_SMS_EVENT_REQ */

   /* fill in primitive parameter:  */
   em_sms_event_req->bitmask_sms_h = bitmask_h;
   em_sms_event_req->bitmask_sms_l = bitmask_l;

   /* additional information for the mscviewer */
   TRACE_PRIM_TO("SMS");
          
   /* the primitive is send to SMS */
   PSENDX (SMS, em_sms_event_req);
   }
  return TRUE;
 }
 else                      /* wrong bitmask */
  return EM_DATA_NOT_AVAIL;                 
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_sim
+------------------------------------------------------------------------------
|  Description  :  This function send the appropriate primitive to the involved 
|                  entity. 
|
|  Parameters   :  bitmask - defines the single events
|
|  Return       :  UBYTE
+------------------------------------------------------------------------------
*/

LOCAL UBYTE em_event_sim (ULONG bitmask)
{
  TRACE_FUNCTION ("em_event_sim()");

 /* check if only specified events are set in the bitmask */
 if (!(bitmask & ~EM_BITMASK_SIM)) {
 /*
  *-------------------------------------------------------------------
  * create and send primitive
  *-------------------------------------------------------------------
  */
  {
   PALLOC(em_sim_event_req, EM_SIM_EVENT_REQ); /* T_EM_SIM_EVENT_REQ */

   /* fill in primitive parameter:  */
   em_sim_event_req->bitmask_sim = bitmask;

   /* additional information for the mscviewer */
   TRACE_PRIM_TO("SIM");
          
   /* the primitive is send to SIM */
   PSENDX (SIM, em_sim_event_req);
   }
  return TRUE;
 }
 else                      /* wrong bitmask */
  return EM_DATA_NOT_AVAIL;                 
}

/*
+------------------------------------------------------------------------------
|  Function     :  em_aci_sem
+------------------------------------------------------------------------------
|  Description  :  Clear all entries inside the semaphor for event tracing 
|
|  Parameters   :  UBYTE entity 
|
|  Return       :  void
+------------------------------------------------------------------------------
*/
void em_aci_sem (UBYTE entity, UBYTE *buffer, UBYTE buf_index_tmp)
{
 TRACE_FUNCTION ("em_aci_sem()");

 /*
 *  aci_em_buf.xxx.index keeps the position of the data inside the buffer
 *  aci_em_buf.xxx.length indicates the length of the data to be copied
 *  both values are used for later processing of the data 
 */
 switch (entity) 
 {
   case (EM_L1):
      em_l1_sem_read();
      memcpy(buffer + em_aci_buf_index, em_l1_sem_buffer, buf_index_tmp);
      aci_em_buf.alr.index  = em_aci_buf_index;
      aci_em_buf.alr.length = buf_index_tmp;
      em_aci_buf_index += buf_index_tmp;
      em_l1_sem_reset ();
      break;
    case (EM_DL):
      em_dl_sem_read();
      memcpy(buffer + em_aci_buf_index, em_dl_sem_buffer, buf_index_tmp);
      aci_em_buf.dl.index  = em_aci_buf_index;
      aci_em_buf.dl.length = buf_index_tmp;         
      em_aci_buf_index += buf_index_tmp;
      em_dl_sem_reset ();
      break;
    case (EM_RR):
      em_rr_sem_read();
      memcpy(buffer + em_aci_buf_index, em_rr_sem_buffer, buf_index_tmp);
      aci_em_buf.rr.index  = em_aci_buf_index;
      aci_em_buf.rr.length = buf_index_tmp;
      em_aci_buf_index += buf_index_tmp;
      em_rr_sem_reset ();
      break;
   case (EM_MM):
      memcpy(buffer + em_aci_buf_index, em_mm_event_buffer, buf_index_tmp);
      aci_em_buf.mm.index  = em_aci_buf_index;
      aci_em_buf.mm.length = buf_index_tmp;
      em_aci_buf_index += buf_index_tmp;
      em_mm_buffer_write = 0;
      break;
   case (EM_CC):
      memcpy(buffer + em_aci_buf_index, em_cc_event_buffer, buf_index_tmp);
      aci_em_buf.cc.index  = em_aci_buf_index;
      aci_em_buf.cc.length = buf_index_tmp;
      em_aci_buf_index += buf_index_tmp;
      em_cc_buffer_write = 0;
      break;
   case (EM_SS):
      memcpy(buffer + em_aci_buf_index, em_ss_event_buffer, buf_index_tmp);
      aci_em_buf.ss.index  = em_aci_buf_index;
      aci_em_buf.ss.length = buf_index_tmp;
      em_aci_buf_index += buf_index_tmp;
      em_ss_buffer_write = 0;
      break;
   case (EM_SMS):
      memcpy(buffer + em_aci_buf_index, em_sms_event_buffer, buf_index_tmp);
      aci_em_buf.sms.index  = em_aci_buf_index;
      aci_em_buf.sms.length = buf_index_tmp;
      em_aci_buf_index += buf_index_tmp;
      em_sms_buffer_write = 0;
      break;
   case (EM_SIM):
      memcpy(buffer + em_aci_buf_index, em_sim_event_buffer, buf_index_tmp);
      aci_em_buf.sim.index  = em_aci_buf_index;
      aci_em_buf.sim.length = buf_index_tmp;
      em_aci_buf_index += buf_index_tmp;
      em_sim_buffer_write = 0;
      break;
   default:
      break;
 } /* switch */
} /* endfunc em_aci_sem */

/*
+------------------------------------------------------------------------------
|  Function     :  em_event_trace_ind
+------------------------------------------------------------------------------
|  Description  :  When event tracing is enabled, the entity sends a notification 
|                  that the first event occurred. The event flag (em_xx_trace) 
|                  protects unnecessary buffer operations.
|
|  Parameters   :  Entity 
|
|  Return       :  void
+------------------------------------------------------------------------------
*/
GLOBAL const void em_event_trace_ind (T_EM_DATA_IND * em_data_ind)
{
 TRACE_FUNCTION ("em_event_trace_ind()");

 switch (em_data_ind->entity)
 {
  case EM_L1:
   em_l1_trace = TRUE;
   break;
  case EM_DL:
   em_dl_trace = TRUE;
   break;
  case EM_RR:
   em_rr_trace = TRUE;
   break;
  case EM_MM:
   em_mm_trace = TRUE;
   break;
  case EM_CC:
   em_cc_trace = TRUE;
   break;
  case EM_SS:
   em_ss_trace = TRUE;
   break;
  case EM_SMS:
   em_sms_trace = TRUE;
   break;
  case EM_SIM:
   em_sim_trace = TRUE;
   break;
  default:
   break;
 } /* switch */
 PFREE(em_data_ind);
}


/*+++++++++++++++++++++++++++++++++++++++++ E O F +++++++++++++++++++++++++++++++++++++++++*/