/* 
+----------------------------------------------------------------------------- 
|  Project :  GSM-PS (8410)
|  Modul   :  MM_MMF
+----------------------------------------------------------------------------- 
|  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 Modul defines the functions for the mob. management
|             capability of the module Mobility Management.
+----------------------------------------------------------------------------- 
*/ 

#ifndef MM_MMF_C
#define MM_MMF_C

#include "config.h"
#include "fixedconf.h"
#include "condat-features.h"

#define ENTITY_MM

/*==== INCLUDES ===================================================*/

#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#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_mm.h"
#include "mon_mm.h"
#include "pei.h"
#include "tok.h"
#include "mm.h"
#ifdef _SIMULATION_
  #include "ffs_pc_api.h"
#else
  #include "../../services/ffs/ffs.h"
#endif
#include "mm_em.h"

/*==== EXPORT =====================================================*/
BOOL poor_quality_network = FALSE; /* Hack, maybe needed by CC */

/*==== TEST =====================================================*/

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

/*==== FUNCTIONS ==================================================*/
GLOBAL T_FFS_RET ffs_mkdir(const char *name);

/*==== PRIVAT =====================================================*/
LOCAL BOOL mm_handle_ffs_read_result  (T_FFS_SIZE status_read);
LOCAL BOOL mm_handle_ffs_write_result (T_FFS_RET status_write);
LOCAL BOOL mm_create_ffs_dirs         (const char *name);
LOCAL BOOL mm_check_ffs_dirs          (void);


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_fill_identity           |
+--------------------------------------------------------------------+

  PURPOSE : This function fills the mobile identity structure with
            the desired identity, this maybe the IMSI, the IMSISV,
            the IMEI or the TMSI.

*/

LOCAL void mm_fill_identity (T_mob_id *mob_ident, UBYTE id_type)
{
  GET_INSTANCE_DATA;
  T_imsi_struct imei_struct;
  TRACE_FUNCTION ("mm_fill_identity()");

  memset (mob_ident, 0, sizeof (T_mob_id));

  switch (id_type)
  {
    case ID_TYPE_IMSI:
      mob_ident->ident_type  = id_type;
      mob_ident->v_ident_dig = TRUE;
      mob_ident->c_ident_dig = mm_calculate_digits (mm_data->reg.imsi_struct.id);
      mob_ident->odd_even    = mob_ident->c_ident_dig & 1;
      memcpy (mob_ident->ident_dig, mm_data->reg.imsi_struct.id, 16);
      break;
    
    case ID_TYPE_IMEI:
      csf_read_imei (&imei_struct);
      mob_ident->ident_type  = id_type;
      mob_ident->v_ident_dig = TRUE;
      mob_ident->c_ident_dig = 15;
      mob_ident->odd_even    = 1; 
      memcpy (mob_ident->ident_dig, imei_struct.id, 14);
      mob_ident->ident_dig[14] = 0;
      break;
    
    case ID_TYPE_IMEISV:
      csf_read_imei (&imei_struct);
      mob_ident->ident_type  = id_type;
      mob_ident->v_ident_dig = TRUE;
      mob_ident->c_ident_dig = 16;
      mob_ident->odd_even    = 0;
      memcpy (mob_ident->ident_dig, imei_struct.id, 16);
      break;
    
    case ID_TYPE_TMSI:
      mob_ident->ident_type  = id_type;
      mob_ident->v_ident_dig = FALSE;
      mob_ident->tmsi.l_tmsi = 32;
      mob_ident->v_tmsi      = TRUE;
      ccd_codeByte (mob_ident->tmsi.b_tmsi, 0, 8, 
        (UBYTE)(mm_data->reg.tmsi >> 24));
      ccd_codeByte (mob_ident->tmsi.b_tmsi, 8, 8, 
        (UBYTE)(mm_data->reg.tmsi >> 16));
      ccd_codeByte (mob_ident->tmsi.b_tmsi, 16, 8, 
        (UBYTE)(mm_data->reg.tmsi >> 8));
      ccd_codeByte (mob_ident->tmsi.b_tmsi, 24, 8, 
        (UBYTE)(mm_data->reg.tmsi));
      break;

    default: 
      TRACE_ERROR ("No such mobile identity");
      break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_fill_ident_for_est      |
+--------------------------------------------------------------------+

  PURPOSE : This functinon fills the mobile identity for an 
            establishment message and uses the appropriate identity
            for this purpose. The function returns the used mobile
            identity type.

*/

LOCAL UBYTE mm_fill_ident_for_est (T_mob_id *mob_ident)
{
  GET_INSTANCE_DATA;
  UBYTE id_type;

  TRACE_FUNCTION ("mm_fill_ident_for_est()");

  if (mm_data->reg.op.sim_ins EQ SIM_NO_INSRT)
  {
    /* No SIM present */
    id_type = ID_TYPE_IMEI;
  }
  else
  {
    /* SIM present */
    if (mm_data->reg.tmsi EQ TMSI_INVALID_VALUE)
    {
      /* No TMSI present */
      id_type = ID_TYPE_IMSI;
    }
    else
    {
      /* TMSI present */
      id_type = ID_TYPE_TMSI;
    }
  }

  mm_fill_identity (mob_ident, id_type);

  return id_type;
}

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

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

/*
 * -------------------------------------------------------------------
 * Procedures
 * -------------------------------------------------------------------
 */


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_abort_connection        |
+--------------------------------------------------------------------+

  PURPOSE : This function sends the RR_ABORT_REQ primitive.

*/

GLOBAL void mm_abort_connection (UBYTE abcs)
{
  TRACE_FUNCTION ("mm_abort_connection ()");
  
  assert (abcs EQ ABCS_SIM_REM OR 
          abcs EQ ABCS_NORM);
  
  {
    PALLOC ( rr_abort_req, RR_ABORT_REQ); /* T_RR_ABORT_REQ */
    rr_abort_req->abcs = abcs;
    PSENDX (RR, rr_abort_req);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_attach_loc_upd          |
+--------------------------------------------------------------------+

  PURPOSE : This function starts an IMSI ATTACH location update.

*/

GLOBAL void mm_attach_loc_upd (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_attach_loc_upd ()");

  if (mm_lup_allowed_by_gmm())
  {
    mm_start_loc_upd (IMSI_ATTACH_LUP);
  }
  else
  {
    SET_STATE (STATE_MM, MM_IDLE_LUP_NEEDED);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_normal_loc_upd          |
+--------------------------------------------------------------------+

  PURPOSE : This function starts a normal location update procedure.

*/

GLOBAL void mm_normal_loc_upd (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_normal_loc_upd ()");

  if (mm_lup_allowed_by_gmm())
  {
    mm_start_loc_upd (NORMAL_LUP);
  }
  else
  {
    SET_STATE (STATE_MM, MM_IDLE_LUP_NEEDED);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_periodic_loc_upd        |
+--------------------------------------------------------------------+

  PURPOSE : This function starts a periodic location update.

*/

GLOBAL void mm_periodic_loc_upd (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_periodic_loc_upd ()");
  if (mm_lup_allowed_by_gmm())
  {
    mm_start_loc_upd (PERIODIC_LUP);
  }
  else
  {
    SET_STATE (STATE_MM, MM_IDLE_LUP_NEEDED);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_build_auth_res          |
+--------------------------------------------------------------------+

  PURPOSE : In this function the AUTHENTICATION RESPONSE message is 
            built.

*/

GLOBAL void mm_build_auth_res (T_SIM_AUTHENTICATION_CNF *sim_auth_cnf,
                               T_U_AUTH_RES             *auth_res)
{
  TRACE_FUNCTION ("mm_build_auth_res ()");
  auth_res->msg_type = U_AUTH_RES;
  auth_res->auth_sres.l_auth_sres = MAX_SRES << 3;
  auth_res->auth_sres.o_auth_sres = 0;
  memcpy (auth_res->auth_sres.b_auth_sres, sim_auth_cnf->sres, MAX_SRES);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_build_ident_res         |
+--------------------------------------------------------------------+

  PURPOSE : In this function the IDENTITY RESPONSE message is built.

*/

GLOBAL void mm_build_ident_res (UBYTE         id_type, 
                                T_U_IDENT_RES *ident_res)
{
  TRACE_FUNCTION ("mm_build_ident_res ()");
  ident_res->msg_type = U_IDENT_RES;
  mm_fill_identity (&ident_res->mob_id, id_type);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_build_mm_status         |
+--------------------------------------------------------------------+

  PURPOSE : In this function the MM STATUS message is built.

*/

GLOBAL void mm_build_mm_status (UBYTE         cause,
                                T_B_MM_STATUS *mm_status)
{
  TRACE_FUNCTION ("mm_build_mm_status ()");
  mm_status->msg_type  = B_MM_STATUS;
  mm_status->rej_cause = cause;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_build_rr_sync_req_cause |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to synchronize RR information 
            with changed information in MM.
            The function mm_build_rr_sync_req_cause() is used especially
            if the registration has failed for some reason, e.g. 
            authentication failure. Cause value is given, 
            ciphering information and tmsi are not present if this 
            function is called.

*/

GLOBAL void mm_build_rr_sync_req_cause (USHORT cause)
{
  GET_INSTANCE_DATA;
  PALLOC (rr_sync_req, RR_SYNC_REQ); /* T_RR_SYNC_REQ */

  TRACE_FUNCTION ("mm_build_rr_sync_req_cause ()");

  rr_sync_req->op.v_op    = V_OP_NOT_PRES;
  rr_sync_req->cksn       = CKSN_NOT_PRES;
  rr_sync_req->kcv.v_kc   = V_KC_NOT_PRES;
  rr_sync_req->tmsi_struct.v_mid = V_MID_NOT_PRES;
  rr_sync_req->plmn.v_plmn = V_PLMN_NOT_PRES;
  rr_sync_req->synccs     = cause;
  rr_sync_req->accc       = mm_data->reg.acc_class;
  rr_sync_req->eq_plmn_list.v_eq_plmn = FALSE;

  TRACE_EVENT_P1 ("sync_cause = %04x", cause);

  switch (cause)
  {
    case SYNCCS_LAI_ALLOW:
    case SYNCCS_LAI_NOT_ALLOW:
    case SYNCCS_LAI_NOT_ALLOW_FOR_ROAMING:
      rr_sync_req->plmn.v_plmn = V_PLMN_PRES;
      memcpy (rr_sync_req->plmn.mcc, mm_data->mm.lai.mcc, SIZE_MCC);
      memcpy (rr_sync_req->plmn.mnc, mm_data->mm.lai.mnc, SIZE_MNC);
      rr_sync_req->lac = mm_data->mm.lai.lac;
      break;
    case SYNCCS_EPLMN_LIST:
      rr_sync_req->eq_plmn_list.v_eq_plmn = TRUE;
      memcpy(&rr_sync_req->eq_plmn_list.eq_plmn, 
             &mm_data->reg.eqv_plmns.eqv_plmn_list, 
             EPLMNLIST_SIZE*UBYTES_PER_PLMN);
      break;
    default: /* eg. SYNCCS_ACCC */
      break;
  }
  PSENDX (RR, rr_sync_req);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_build_rr_sync_req       |
+--------------------------------------------------------------------+

  PURPOSE : The function unifies the functions mm_build_rr_sync_req_mode()
            and mm_build_rr_sync_req_ciph() and is used to synchronize 
            RR information with changed information in MM. The parameter
            'ciph' decides whether the ciphering parameters are to be 
            set.
*/

GLOBAL void mm_build_rr_sync_req (T_MSG_TYPE ciph)
{
  GET_INSTANCE_DATA;
  PALLOC (rr_sync_req, RR_SYNC_REQ); /* T_RR_SYNC_REQ */

  TRACE_FUNCTION ("mm_build_rr_sync_req()");
  rr_sync_req->tmsi_struct.v_mid   = V_MID_NOT_PRES;
  rr_sync_req->synccs              = NOT_PRESENT_16BIT;
  rr_sync_req->accc                = mm_data->reg.acc_class;
  rr_sync_req->plmn.v_plmn         = V_PLMN_NOT_PRES;

  if( ciph EQ MSG_MM_CIPH)
  {
    rr_sync_req->op.v_op           = V_OP_NOT_PRES;
    rr_sync_req->cksn              = mm_data->reg.cksn;
    rr_sync_req->kcv.v_kc          = V_KC_PRES;
    memcpy (rr_sync_req->kcv.kc, mm_data->reg.kc, MAX_KC);
  }
  else
  {
    memcpy (&rr_sync_req->op, &mm_data->reg.op, sizeof (T_op));
    rr_sync_req->cksn              = NOT_PRESENT_8BIT;
    rr_sync_req->kcv.v_kc          = V_KC_NOT_PRES;
  }
  PSENDX (RR, rr_sync_req);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_build_rr_sync_req_tmsi  |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to synchronize RR information 
            with changed information in MM.
            The function mm_build_rr_sync_req_tmsi() is used especially
            to inform RR about a change in the ciphering parameter 
            tmsi.
            
*/

GLOBAL void mm_build_rr_sync_req_tmsi (void)
{
  GET_INSTANCE_DATA;
  PALLOC (rr_sync_req, RR_SYNC_REQ); /* T_RR_SYNC_REQ */

  TRACE_FUNCTION ("mm_build_rr_sync_req_tmsi ()");

  rr_sync_req->op.v_op           = V_OP_NOT_PRES;
  rr_sync_req->cksn              = CKSN_RES;
  rr_sync_req->kcv.v_kc          = V_KC_NOT_PRES;
  rr_sync_req->plmn.v_plmn       = V_PLMN_NOT_PRES;
  rr_sync_req->synccs            = NOT_PRESENT_16BIT;
  rr_sync_req->accc              = mm_data->reg.acc_class;

  memset (rr_sync_req->tmsi_struct.id, 0, 
          sizeof (rr_sync_req->tmsi_struct.id));  /* IMSI digits */
  rr_sync_req->tmsi_struct.v_mid    = V_MID_PRES;
  rr_sync_req->tmsi_struct.id_type  = TYPE_TMSI;
  rr_sync_req->tmsi_struct.tmsi_dig = mm_data->reg.tmsi;

  PSENDX (RR, rr_sync_req);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_build_rr_sync_hplmn_req |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to synchronize RR information 
            with changed AHPLMN in MM.
            The function mm_build_rr_sync_hplmn_req() is used especially
            to inform RR about the change of the status of RPLMN to AHPLMN.            
            
*/

GLOBAL void mm_build_rr_sync_hplmn_req (void)
{
  GET_INSTANCE_DATA;

  PALLOC (rr_sync_hplmn_req, RR_SYNC_HPLMN_REQ); /* T_RR_SYNC_HPLMN_REQ */

  TRACE_FUNCTION ("mm_build_rr_sync_hplmn_req()");

  rr_sync_hplmn_req->plmn.v_plmn = mm_data->reg.acting_hplmn.v_plmn;
  memcpy(&rr_sync_hplmn_req->plmn.mcc, &mm_data->reg.acting_hplmn.mcc, SIZE_MCC);
  memcpy(&rr_sync_hplmn_req->plmn.mnc, &mm_data->reg.acting_hplmn.mnc, SIZE_MNC);

  PSENDX(RR,rr_sync_hplmn_req);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_check_critical_error    |
+--------------------------------------------------------------------+

  PURPOSE : This function checks wheter a critical error has been 
            detected in the air message. Critical errors which prevent 
            the treatment of an air message are 
            - invalid Message ID
            - mandatory IE missing
            - IE coded as comprehension required missing
*/

GLOBAL BOOL mm_check_critical_error (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_check_critical_error ()");
  if (mm_data->error EQ RC_INVALID_MAND_MESSAGE     OR 
      mm_data->error EQ RC_MESSAGE_TYPE_NOT_IMPLEM  OR
      mm_data->error EQ RC_CONDITIONAL_IE           OR
      mm_data->error EQ RC_SERVICE_NOT_SUPPORTED    OR
      mm_data->error EQ RC_MESSAGE_INCOMPAT         OR
      mm_data->error EQ RC_MESSAGE_TYPE_INCOMPAT)
  {
    return (TRUE);
  }
  return (FALSE);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_send_status             |
+--------------------------------------------------------------------+

  PURPOSE : This function checks wheter a critical error has been 
            detected requiring 
            - to abort the AIM processing and
            - to send a STATUS message.
            The error can be detected by CCD or within the AIM processing itself.
            If any, the message is send, using the value found in mm_data->error as cause.
*/

GLOBAL BOOL mm_send_status_on_error (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_send_status_on_error ()");
  if (mm_check_critical_error())
  {

/* Implements Measure 29 and streamline encoding */
    mm_send_status(mm_data->error);
    mm_for_set_error (0);
    return (TRUE);
  }
  return (FALSE);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_check_error_flag        |
+--------------------------------------------------------------------+

  PURPOSE : This function checks wheter a critical error has been 
            detected in the air message. Critical errors which prevent 
            the treatment of an air message are all errors except 
            an error in an optional information element.
            [In calls of this function it is checked whether the 
             error is an RC_INVALID_MAND_MESSAGE, only this case is 
             treated as error in the caller's code. The code could be 
             simplified here if mm_check_error_flag() was a function 
             returning a BOOLEAN, indicating whether the message is valid
             or not. This is done this way in the CC entitity.]

*/

GLOBAL void mm_check_error_flag (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_check_error_flag ()");
  if (mm_data->error NEQ 0 AND 
      mm_data->error NEQ OPTIONAL_INFO_ERROR)
  {
/* Implements Measure 29 and streamline encoding */
    mm_send_status(mm_data->error);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_clear_mob_ident         |
+--------------------------------------------------------------------+

  PURPOSE : This function zeroes out the mobile identity. 


*/

GLOBAL void mm_clear_mob_ident (T_imsi_struct*mob_ident)
{
  TRACE_FUNCTION ("mm_clear_mob_ident ()");
  
  memset (mob_ident, 0, sizeof (T_imsi_struct));
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_clear_reg_data          |
+--------------------------------------------------------------------+

  PURPOSE : This function clears some variables in the registration 
            data. This is done in a way that the SIM data is not lost, 
            the SIM data is only disabled by setting a software flag
            indicating MM shall not use the SIM data until it is 
            requested to do so by upper layers.

*/

GLOBAL void mm_clear_reg_data (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_clear_reg_data ()");
 
  mm_data->reg.op.func = FUNC_LIM_SERV_ST_SRCH;
  mm_data->reg.op.sim_ins = SIM_NO_INSRT;
  mm_data->first_attach = TRUE;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_copy_rr_act_cnf_data    |
+--------------------------------------------------------------------+

  PURPOSE : This function copies the data delivered by RR_ACTIVATE_CNF
            or RR_ACTIVATE_IND into the internal MM data structures.

*/

GLOBAL void mm_copy_rr_act_cnf_data (T_RR_ACTIVATE_CNF *rr_activate_cnf)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_copy_rr_act_cnf_data ()");

  mm_data->mm.mm_info = rr_activate_cnf->mm_info; /* Stucture copy */
  memcpy (mm_data->mm.lai.mcc, rr_activate_cnf->plmn.mcc, SIZE_MCC);
  memcpy (mm_data->mm.lai.mnc, rr_activate_cnf->plmn.mnc, SIZE_MNC);
  mm_data->mm.lai.lac = rr_activate_cnf->lac;
  mm_data->mm.cid = rr_activate_cnf->cid;

  EM_CELL_SELECTION_RESELECTION;

#ifdef GPRS
  mm_data->mm.gprs_indication= rr_activate_cnf->gprs_indication;
#endif /* GPRS */

  // Write-only variable, eliminated HM 20.07.00
  // mm_data->mm.lac = rr_activate_cnf->lac;

  /*
   * Until now we have only knowledge that chinese networks
   * seem to have special problems we have to deal with,
   * but maybe other countries have these special problems, too.
   */
  poor_quality_network =
    ((rr_activate_cnf->plmn.mcc[0] EQ 4) AND
     (rr_activate_cnf->plmn.mcc[1] EQ 6) AND
     (rr_activate_cnf->plmn.mcc[2] EQ 0));
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_count_connections       |
+--------------------------------------------------------------------+

  PURPOSE : Count the number of connections which connection state 
            equals to the parameter conn_type. In case conn_type 
            is CM_NOT_IDLE, all connections not idle are counted.

*/

GLOBAL SHORT mm_count_connections (UBYTE conn_type)
{
  GET_INSTANCE_DATA;
  UBYTE cm;
  UBYTE ti;
  SHORT count = 0;
    
  TRACE_FUNCTION ("mm_count_connections ()");
  
  for (cm = 0; cm < NUM_OF_CM_ENT; cm++)
  {
    for (ti = 0; ti < NUM_OF_CONN_PER_CM_ENT; ti++)
    {
      if (((conn_type EQ CM_NOT_IDLE) AND (CMSTATE(cm, ti) NEQ CM_IDLE)) OR
          (CMSTATE(cm, ti) EQ conn_type))
      {
#if defined (WIN32)
        (void)CM_GET_STATE(cm, ti);
#endif
        count++;
      }
    }
  }
  return (count);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_create_est_message      |
+--------------------------------------------------------------------+

  PURPOSE : This functinon creates the establishment message, 
            either for MM services or for CM services. 
            If the entitity requiring service is a CM component, 
            the CM entitity will be remembered in mm_data->last_comp.

*/

GLOBAL void mm_create_est_message (USHORT    est_cause,
                                   UBYTE     service,
                                   UBYTE     ti,
                                   USHORT    *bit_size_message)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_create_est_message ()");

  TRACE_EVENT_P1 ("  ESTCS = %x", est_cause);
  TRACE_EVENT_P7 ("  REG: MCC=%X%X%X MNC=%X%X%X LAC=%04X",
                  mm_data->reg.lai.mcc[0],
                  mm_data->reg.lai.mcc[1],
                  mm_data->reg.lai.mcc[2],
                  mm_data->reg.lai.mnc[0],
                  mm_data->reg.lai.mnc[1],
                  mm_data->reg.lai.mnc[2],
                  mm_data->reg.lai.lac);
  TRACE_EVENT_P7 ("  MM: MCC=%X%X%X MNC=%X%X%X LAC=%04X",
                  mm_data->mm.lai.mcc[0],
                  mm_data->mm.lai.mcc[1],
                  mm_data->mm.lai.mcc[2],
                  mm_data->mm.lai.mnc[0],
                  mm_data->mm.lai.mnc[1],
                  mm_data->mm.lai.mnc[2],
                  mm_data->mm.lai.lac);

  if (est_cause NEQ ESTCS_SERV_REQ_BY_MM)
  {
    UBYTE comp;

    /*
     * Set the CM component requiring CM service 
     */
    switch (service)
    {
      case CALL_SERVICE:
      case EMERGENCY_SERVICE:
        comp = CC_COMP;
        break;

      case SS_SERVICE:
        comp = SS_COMP;
        break;

      case SMS_SERVICE:
        comp = SMS_COMP;
        break;

      default: /* Request for MM service */
        TRACE_ERROR ("Illegal service");
        comp = CC_COMP; /* Just to say something */
        break;
    }

    mm_data->pend_conn.ti   = ti;
    mm_data->pend_conn.comp = comp;
    mm_data->pend_conn.service = service;
    mm_data->pend_conn.cause = est_cause;
    if (est_cause EQ ESTCS_CAL_REEST)
    {
      CM_SET_STATE (comp, ti, CM_REEST_PENDING);
    }
    else
    {
      CM_SET_STATE (comp, ti, CM_PENDING);
    }
  }

  mm_data->rej_cause = 0;

  switch (est_cause)
  {
    case ESTCS_CAL_REEST:
      {
        MCAST (cm_reestab_req, U_CM_REESTAB_REQ); /* T_U_CM_REESTAB_REQ */

        *bit_size_message = BSIZE_U_CM_REESTAB_REQ;
        cm_reestab_req->msg_type = U_CM_REESTAB_REQ;
        cm_reestab_req->ciph_key_num.key_seq = mm_data->reg.cksn;
        cm_reestab_req->v_loc_area_ident = FALSE;

        csf_read_mobile_class_2 (&cm_reestab_req->mob_class_2);
        cm_reestab_req->mob_class_2.rf_pow_cap = mm_data->rf_power;

        if (mm_fill_ident_for_est (&cm_reestab_req->mob_id) EQ ID_TYPE_TMSI)
        {
          /* TMSI used. Include also location area to make this unambiguous */
          cm_reestab_req->v_loc_area_ident = TRUE;
          cm_reestab_req->loc_area_ident = mm_data->reg.lai; /* Struct copy */
        }
      }
      break;

    case ESTCS_SERV_REQ_BY_MM:
      {
        MCAST (loc_upd_req, U_LOC_UPD_REQ); /* T_U_LOC_UPD_REQ */

        *bit_size_message = BSIZE_U_LOC_UPD_REQ;
        loc_upd_req->msg_type = U_LOC_UPD_REQ;
        loc_upd_req->loc_upd_type = mm_data->loc_upd_type; /* Struct copy */
        loc_upd_req->ciph_key_num.key_seq = mm_data->reg.cksn;
        loc_upd_req->loc_area_ident = mm_data->reg.lai; /* Struct copy */
        if (loc_upd_req->loc_area_ident.mnc[2] EQ 0xF)
          loc_upd_req->loc_area_ident.c_mnc = 2;
        csf_read_mobile_class_1 (&loc_upd_req->mob_class_1);
        loc_upd_req->mob_class_1.rf_pow_cap = mm_data->rf_power;
        mm_fill_ident_for_est (&loc_upd_req->mob_id);
      }
      break;

    default:
      {
        MCAST (cm_serv_req, U_CM_SERV_REQ); /* T_U_CM_SERV_REQ */

        EM_CM_SERVICE_REQUESTED;

#if defined (WIN32)
        {
          char buf [40];
          sprintf (buf, "detected power = %d", mm_data->rf_power);
          TRACE_FUNCTION (buf);
        }
#endif

        *bit_size_message = BSIZE_U_CM_SERV_REQ;
        cm_serv_req->msg_type = U_CM_SERV_REQ;
        cm_serv_req->cm_serv_type = service;
        cm_serv_req->ciph_key_num.key_seq = mm_data->reg.cksn;

        csf_read_mobile_class_2 (&cm_serv_req->mob_class_2);
        cm_serv_req->mob_class_2.rf_pow_cap = mm_data->rf_power;

        mm_fill_ident_for_est (&cm_serv_req->mob_id);
      }
      break;
  }
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : MM_MM                         |
| STATE   : code             ROUTINE : mm_create_imsi_detach_message |
+--------------------------------------------------------------------+

  PURPOSE : This function creates the IMSI DETACH message. This may 
            either be forwarded to the network by the means of 
            RR_ESTABLISH_REQ or RR_DATA_REQ if a network connection 
            already exists.

*/

GLOBAL void mm_create_imsi_detach_message (void)
{
  GET_INSTANCE_DATA;
  MCAST (imsi_detach, U_IMSI_DETACH_IND);

  TRACE_FUNCTION ("mm_create_imsi_detach_message ()");

  imsi_detach->msg_type = U_IMSI_DETACH_IND;
  csf_read_mobile_class_1 (&imsi_detach->mob_class_1);
  imsi_detach->mob_class_1.rf_pow_cap = mm_data->rf_power;
  mm_fill_ident_for_est (&imsi_detach->mob_id);

  EM_IMSI_DETACH;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_delete_entry            |
+--------------------------------------------------------------------+

  PURPOSE :   The purpose of this function is to delete a stored entry
              previously written by the mm_write_entry() function.
              There are some types of entries which may be stored in
              the T_STORE data structure.
              - Establish attempts by the CM sublayer (MMXX_ESTABLISH_REQ)
              - Net requests by MMI (MMXXX_NET_REQ, AT+COPS=?)
              - Expired timers (TIMEOUT)
              - primitives incoming
              In case the content type is set to PRIMITIVE_ENTRY currently
              nothing is done, because no delete case was necessary so far.

*/

GLOBAL void mm_delete_entry (UBYTE comp, UBYTE ti)
{
  GET_INSTANCE_DATA;
  USHORT  i;
  USHORT  j;

  TRACE_FUNCTION ("mm_delete_entry ()");

  /*
   * Find stored entry in table
   */
  for (i = 0; i < MAX_STORE_ENTRIES; i++)
  {
    if (mm_data->store[i].content_type EQ EVENT_ENTRY)
    {

      if (mm_data->store[i].use NEQ ENTRY_FREE AND
          mm_data->store[i].content.event.comp EQ comp AND
          mm_data->store[i].content.event.ti   EQ ti)
      {
        TRACE_EVENT_P2 ("Delete entry: comp=%d, ti=%d", comp, ti);
        
        for (j = i; j < MAX_STORE_ENTRIES - 1; j++)
        {
          mm_data->store[j] = mm_data->store[j + 1]; /* Struct copy */
        }        
        mm_data->store[MAX_STORE_ENTRIES - 1].use = ENTRY_FREE;
        mm_data->store[MAX_STORE_ENTRIES - 1].content_type = NO_ENTRY;
          
        if (comp < NUM_OF_CM_ENT)
        {
            /* Establish request for any CM entity has been deleted */
            CM_SET_STATE(comp, ti, CM_IDLE);
        } 
        return;
      } /*IF comp ti*/
    } /*IF content_type*/
  } /*FOR*/
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_set_follow_on_request   |
+--------------------------------------------------------------------+

  PURPOSE : set the follow on request if at least one connection 
            attempt is stored.

*/

GLOBAL BOOL mm_set_follow_on_request (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_set_follow_on_request()");

  if (mm_count_connections (CM_STORE) NEQ 0 AND mm_cm_est_allowed())
  {
    mm_data->loc_upd_type.follow = FOR_PENDING_YES;
    return TRUE;
  }
  else
  {
    mm_data->loc_upd_type.follow = FOR_PENDING_NO;
    return FALSE;
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_init                    |
+--------------------------------------------------------------------+

  PURPOSE : This function initializes the MM data structures.

*/

GLOBAL void mm_init (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_init()");

  TIMERSTOP (T_REGISTRATION);
  TIMERSTOP (T3210);
  TIMERSTOP (T3211);
  TIMERSTOP (T3212);  
  mm_data->t3212_timeout = FALSE;
  TIMERSTOP (T3213);
  mm_data->t3213_restart = 0;
  TIMERSTOP (T3220);
  TIMERSTOP (T3230);
  TIMERSTOP (T3240);
#ifdef REL99
  TIMERSTOP (T3241);
#endif

  memset (mm_data, 0, sizeof (T_MM_DATA));
  mm_data->limited_cause = MMCS_SIM_REMOVED; /* MMCS_SIM_INVAL_NOSIM */

  mm_data->last_auth_req_id = NOT_PRESENT_8BIT;
  mm_data->first_attach = TRUE;
  mm_data->first_attach_mem = FALSE;

  mm_data->t3212_cfg_counter = 0;
  mm_data->idle_entry = RRCS_INT_NOT_PRESENT;
  mm_data->ciphering_on = CIPH_NOT_PRES; /* Initialize ciphering indicator */

  
  mm_data->reg.length_mnc = 2;
  mm_data->net_search_count = 0;
  mm_data->ef_indicator = 0; /* Initialize for EF indication to SIM */
  mm_data->reg.is_cingular_sim = FALSE; /*This flag is specially for cingular n/w*/
  
  reg_init ();

  poor_quality_network = FALSE;

#ifdef GPRS
  SET_STATE (STATE_REG_TYPE, REG_GPRS_INACTIVE);
  SET_STATE (STATE_GPRS_CM_EST, CM_GPRS_EST_IDLE);
#endif /* GPRS */
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_calculate_digits        |
+--------------------------------------------------------------------+

  PURPOSE : This function calculates the length of the IMSI. 
            (The digits delivered to this function are the digits of
            an IMSI, but this doesn't become obvious from the function's
            or parameter's name.)

*/

GLOBAL UBYTE mm_calculate_digits (const UBYTE *digits)
{
  UBYTE i = 0;

  TRACE_FUNCTION ("mm_calculate_digits()");

  while (digits[i] < 0x0A AND i < 16)
    i++;

  return i;
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_loc_upd_rej             |
+--------------------------------------------------------------------+

  PURPOSE : This function is called if LOCATION UPDATING REJECT has 
            been received and then after the RR connection has been 
            released or aborted, after leaving MM_LUP_REJECTED state.
            It is also used if MMGMM_ATTACH_REJ_REQ is received by GMM.
            It is also used if MMGMM_NREG_REQ is received with
            cs EQ CS_DISABLE and certain mmgmm_error_cause values.
            Maybe the name "mm_network_rejected()" would be a 
            better name for the function now.

            NOTE: For MM's own location updating, every non-defined 
                  cause is mapped into RC_SERVICE_ORDER (0x22). 
                  If the network sends some GPRS only defined cause 
                  by means of the LOCATION UPDATING REJECT message, 
                  we catch this in the default.

*/

GLOBAL void mm_loc_upd_rej (void)
{
  GET_INSTANCE_DATA;
  T_plmn hplmn;

  TRACE_FUNCTION ("mm_loc_upd_rej ()");

  reg_extract_hplmn (&hplmn);

  TRACE_EVENT_P1 ("rej_cause = %04X", mm_data->rej_cause);

  /* 
   * T3212 is stopped if a LOCATION UPDATING ACCEPT or 
   * LOCATION UPDATING REJECT message is received.
   * [GSM 04.08 subclause 4.4.2]
   * Exception: MMGMM_ERRCS_GPRS_NOT_ALLOWED_IN_PLMN as this shall not
   * have any influence on T3212.
   */
#ifdef GPRS
  if (mm_data->rej_cause NEQ GMMCS_GPRS_NOT_ALLOWED_IN_PLMN)
#endif /* #ifdef GPRS */
  {
    TIMERSTOP (T3212);
    mm_data->t3212_timeout = FALSE;
  }

  switch (mm_data->rej_cause)
  {
    case MMCS_PLMN_NOT_ALLOWED: /* #11 + Ofs */
#ifdef GPRS
    case GMMCS_PLMN_NOT_ALLOWED:
#endif /* #ifdef GPRS */
      mm_data->attempt_cnt = 0;
      mm_data->loc_upd_type.lut = NOT_RUNNING;
      if (reg_plmn_equal_hplmn (&mm_data->reg.actual_plmn) EQ FALSE)
      {
        /*
         * The PLMN is only added to forbidden list if not the HPLMN.
         * An internal error of the HPLMN would otherwise invalidate
         * the SIM for the HPLMN even after SIM removal/SIM insertion.
         */
        reg_plmn_add_bad (mm_data->reg.forb_plmn, 
                          MAX_FORB_PLMN_ID,
                          &mm_data->reg.actual_plmn);
        mm_build_rr_sync_req_cause (SYNCCS_LIMITED_SERVICE);
        mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL);

        /* Delete EPLMN List */
        if (reg_clear_plmn_list (mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE))
          mm_build_rr_sync_req_cause(SYNCCS_EPLMN_LIST);
#ifdef REL99
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, FALSE);
#else
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED);
#endif
        /* Set the new MM state before calling reg_mm_failure() */
        SET_STATE (STATE_MM, MM_IDLE_LIMITED_SERVICE);
        reg_mm_failure (FORB_PLMN_INCLUDED);
      }
      else
      {
        /* 
         * Cause #11 for the HPLMN. This is a network failure.
         */

        // Call mm_lup_restart() instead? Makes no sense this way...

        mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL);

        /* Delete EPLMN List */
        if (reg_clear_plmn_list (mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE))
          mm_build_rr_sync_req_cause(SYNCCS_EPLMN_LIST);
        
#ifdef REL99
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, FALSE);
#else
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED);
#endif
        /* Set the new MM state before calling reg_mm_failure() */
        SET_STATE (STATE_MM, MM_IDLE_LIMITED_SERVICE);
        reg_mm_failure (FORB_PLMN_NOT_INCLUDED);
      }

      USE_STORED_ENTRIES();
      break;

    case MMCS_LA_NOT_ALLOWED: /* #12 + Ofs */
#ifdef GPRS
    case GMMCS_LA_NOT_ALLOWED:
#endif /* #ifdef GPRS */
      /* 
       * There is no list of "forbidden location areas for regional
       * provision of service" supported by G23. Compare this with the 
       * requirements of GSM 04.08 subclause 4.4.4.7.
       * The non-implementation of this list should not cause any 
       * harm for cause #12.
       */
      mm_data->attempt_cnt = 0;
      mm_build_rr_sync_req_cause (SYNCCS_LAI_NOT_ALLOW);
      mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL);

      mm_data->loc_upd_type.lut = NOT_RUNNING;
#ifdef REL99
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, FALSE);
#else
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED);
#endif
      /* Set the new MM state before calling reg_mm_failure() */
      SET_STATE (STATE_MM, MM_IDLE_LIMITED_SERVICE);
      reg_mm_failure (FORB_PLMN_NOT_INCLUDED);
      USE_STORED_ENTRIES();
      break;

    
#ifdef GPRS
    case GMMCS_ROAMING_NOT_ALLOWED:
#ifdef REL99
      /* Invalidate the TMSI, CKSN, KC in RR */
      mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL);
      case GMMCS_ROAMING_NOT_ALLOWED_WITH_RAU_REJ: /* #13 + Ofs GMM sent for GPRS RAU rejected case*/
      /* GMM sent cause value 13 becauseof 'Normal/periodic RAU Rejected' or 
       * 'Combined RAU Rejected by the network'.*/
      /*FALLTHROUGH*/
#endif
      /*FALLTHROUGH*/
      //lint -fallthrough
#endif /* #ifdef GPRS */
    case MMCS_ROAMING_NOT_ALLOWED: /* #13 + Ofs */
      /* MM received cause value 13 because of 'LU rejected' by the network*/
      /*
       * For the cause 13 handling as per the specification 24.008 v3.15.0,
       * If Cause value 13 received because of 'LU rejected' or 'Normal/periodic RAU
       * Rejected' or 'Combined RAU Rejected by the network' MM will
       *   - store the LAI in the list of "forbidden location areas for roaming".
       *   - set the update status to U3 ROAMING NOT ALLOWED and shall reset the
       *     location update attempt counter
       *   - The mobile station shall perform a PLMN selection instead of a cell
       *     selection when back to the MM IDLE state according to 3GPP TS 23.122.
       *
       * If cause value 13 received because of 'GPRS attach rejected' or 'Combined
       * GPRS rejected' or 'Network initiated GPRS detach' MM will
       *   - Do the above steps
       *   - Additionally MM will any TMSI and ciphering key sequence number.
       */
      mm_data->attempt_cnt = 0;
      mm_data->loc_upd_type.lut = NOT_RUNNING;

      /* Remember the PLMN which sent this reject cause, it's low prio now */
      mm_data->reg.low_prio_plmn = mm_data->reg.actual_plmn; /* Struct copy */
      
      /* Enter the location area in RR into the list of 
       * "forbidden location areas for roaming" for reject cause #13.
       * This list is maintained in RR */
      mm_build_rr_sync_req_cause (SYNCCS_LAI_NOT_ALLOW_FOR_ROAMING);

      /* Inform RR about the limited service condition */
      mm_build_rr_sync_req_cause (SYNCCS_LIMITED_SERVICE);

      /* As RR_SYNC_REQ (SYNCCS_LIMITED_SERVICE) clears the PLMN in RR, 
       * we do the same with the actual PLMN in MM. */
      reg_clear_plmn (&mm_data->reg.actual_plmn);
#ifndef REL99
      /* Invalidate the TMSI, CKSN, KC in RR */
      mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL);
#endif
      /* Delete EPLMN List */
      if (reg_clear_plmn_list (mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE))
        mm_build_rr_sync_req_cause(SYNCCS_EPLMN_LIST);

#ifdef REL99
#ifdef GPRS
      /* Following will check if the TMSI, CKSN, KC needs to be deleted */
      if(mm_data->rej_cause EQ GMMCS_ROAMING_NOT_ALLOWED)
      {
        /*
         * Update the MM state with invalidate the TMSI, CKSN, KC in MM
         * and send indication to SIM.
         */
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, FALSE);
      }
      else
#endif /* #ifdef GPRS */
      {
        /*
         * update the MM state but don't delete the TMSI, CKSN, KC 
         * and send indication to SIM.
         */
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, TRUE);
      }

#else
      /* Inform the SIM */
      reg_invalidate_upd_state (MS_LA_NOT_ALLOWED);
#endif
      /* Set the new MM state before calling reg_mm_failure() */
      SET_STATE (STATE_MM, MM_IDLE_LIMITED_SERVICE);
      reg_mm_failure (FORB_PLMN_NOT_INCLUDED);
      USE_STORED_ENTRIES();
      break;

#ifdef REL99
#ifdef GPRS
    case GMMCS_NO_SUITABLE_CELL_IN_LA: /* #15 + Ofs GMM sent for GPRS attach rejected case*/
      /* GMM sent cause value 15 because of 'GPRS attach rejected' or 'Combined GPRS rejected'
       * or 'Network initiated GPRS detach'.*/
      /* Invalidate the TMSI, CKSN, KC in RR */
      mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL);
      /*FALLTHROUGH*/
    case GMMCS_NO_SUITABLE_CELL_IN_LA_WITH_RAU_REJ: /* #15 + Ofs GMM sent for GPRS RAU rejected case*/
      /* GMM sent cause value 15 because of 'Normal/periodic RAU Rejected' or 
       * 'Combined RAU Rejected by the network'.*/
      /*FALLTHROUGH*/
      //lint -fallthrough
#endif
    case MMCS_NO_SUITABLE_CELL_IN_LA: /* #15 + Ofs MM received in LU rejected message*/
      /*MM received cause value 15 because of 'LU rejected' by the network*/
      /*
       * For cause 15 handling as per the specification 24.008 v3.15.0,
       * If Cause value 15 received because of 'LU rejected' or 'Normal/periodic RAU
       * Rejected' or 'Combined RAU Rejected by the network' MM will
       *   - store the LAI in the list of "forbidden location areas for roaming".
       *   - set the update status to U3 ROAMING NOT ALLOWED and shall reset the
       *     location update attempt counter
       *   - The MS shall search for a suitable cell in another location area in
       *     the same PLMN according to 3GPP TS 03.22 and 3GPP TS 25.304.
       * If cause value 15 received because of 'GPRS attach rejected' or 'Combined
       * GPRS rejected' or 'Network initiated GPRS detach' MM will
       *   - Do the above steps
       *   - Additionally will delete any TMSI and ciphering key sequence number.
       */
      mm_data->attempt_cnt = 0;
      mm_data->loc_upd_type.lut = NOT_RUNNING;
      /*
       * Enter the location area in RR into the list of "forbidden location areas for roaming"
       * for reject cause #15. This list is maintained in RR.
       */
      mm_build_rr_sync_req_cause (SYNCCS_LAI_NOT_ALLOW_FOR_ROAMING);

      /* Set the new MM state MM_IDLE_LIMITED_SERVICE*/
      SET_STATE (STATE_MM, MM_IDLE_LIMITED_SERVICE);
      /* Following will check if the TMSI, CKSN, KC needs to be deleted */
#ifdef GPRS
      if(mm_data->rej_cause EQ GMMCS_NO_SUITABLE_CELL_IN_LA)
      {
        /*
         * Update the MM state with invalidate the TMSI, CKSN, KC in MM
         * and send indication to SIM.
         */
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, FALSE);
      }
      else
#endif /* #ifdef GPRS */
      {
        /*
         * update the MM state but don't delete the TMSI, CKSN, KC
         * and send indication to SIM.
         */
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, TRUE);
      }

      /* MM should send primitive MMGMM_REG_REJ to GMM only in case if cause 15 is received
       * because of its own failure i.e if there was either a RR failure or a MM failure
       * (e.g. LOCATION UPDATING reject). It should then inform GMM about failure. Upon
       * reception of MMGMM_REG_REJ primitive, GMM send failure information to MMI.
       */
      if(GET_CAUSE_ORIGIN_ENTITY (mm_data->rej_cause) EQ MM_ORIGINATING_ENTITY)
      {
        /* MM sends primitive MMGMM_REG_REJ to GMM */
        mm_mmgmm_nreg_ind (NREG_LIMITED_SERVICE,
                          SEARCH_RUNNING,
                          FORB_PLMN_NOT_INCLUDED);
      }
      else
      {
        /*Do not send NREG Indication. GMM is already unregistered*/
      }
      /*
       * Start PLMN serch, try the PLMN in the list i.e. search
       * another location area in the same PLMN.
       */
      mm_mmr_reg_req (FUNC_PLMN_SRCH);

      /*Responce back with confirmation if MMGMM_NREG_REQ was received.*/
      if (mm_data->nreg_request)
      {
        mm_mmgmm_nreg_cnf (mm_data->nreg_cause);
      }

      USE_STORED_ENTRIES();
      break;
#endif

    case MMCS_IMSI_IN_HLR: /* #2 + Ofs */
#ifdef GPRS
    case GMMCS_IMSI_UNKNOWN:
      if (!mm_lup_allowed_by_gmm())
      {
        /* 
         * The "IMSI unknown in HLR" was received by a GMM request and 
         * not by a LOCATION UPDATING REJECT message.
         * MM must not enter MM_IDLE_NO_IMSI here, as the SIM 
         * is still valid for the GPRS side and MM still has to deliver
         * some services for GMM which it cannot deliver in service state 
         * "NO IMSI". The relevant testcases here are (Release 1999):
         * GSM 11.10 subclause 44.2.1.2.2, GSM 11.10 subclause 44.2.3.2.3.
         * What is tested there is that after an ATTACH ACCEPT/
         * ROUTING AREA UPDATING ACCEPT message the mobile doesn't 
         * respond to packet paging with IMSI anymore and that no DETACH 
         * is performed for GSM.
         * What is not tested is that the mobile station doesn't respond to 
         * paging with IMSI on the old channels after entering an area where 
         * we have network mode II/III or that the mobile rejects a manual 
         * switch to mobile class CS without switch off. 
         * What is done here may not be perfect, but should be sufficient.
         * In fact, #2 may never be seen in field, as the network providers
         * may not want to sell GPRS subscriptions without GSM subscriptions.
         */

        /* Release all waiting CM requests */
        mm_mmxx_rel_ind (mm_data->rej_cause, CM_NOT_IDLE);
        
        /* 
         * Invalidate TMSI and ciphering parameters in RR. 
         * RR remains in full service for GPRS.
         */
        mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL);

        /* Delete EPLMN List */
        if (reg_clear_plmn_list (mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE))
          mm_build_rr_sync_req_cause(SYNCCS_EPLMN_LIST);

        /* Invalidate the update state */
#ifdef REL99
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, FALSE);
#else
        reg_invalidate_upd_state (MS_LA_NOT_ALLOWED);
#endif

        /* If the deregistration was caused by a MMGMM_NREG_REQ, 
         * confirm it properly */
        if (mm_data->nreg_request) 
          mm_mmgmm_nreg_cnf (mm_data->nreg_cause);

        /* Next state is a parking state */
        SET_STATE (STATE_MM, MM_IDLE_LUP_NEEDED);
        break;
      }
      /* 
       * However, if #2 is received by LOCATION UPDATING REJECT message,
       * GSM 04.08 subclause 4.4.4.7 claims that the SIM shall be considered
       * as invalid for "the mobile station" (and not only for the GSM part).
       * There is no distinction between causes #2, #3 and #6 there.
       */
      /*FALLTHROUGH*/
      //lint -fallthrough
#endif /* #ifdef GPRS */
    case MMCS_ILLEGAL_MS:  /* #3 + Ofs */
    case MMCS_ILLEGAL_ME:  /* #6 + Ofs */
#ifdef GPRS
    case GMMCS_ILLEGAL_MS:
    case GMMCS_ILLEGAL_ME:
    case GMMCS_GSM_GPRS_NOT_ALLOWED: /* #8 + Ofs */
#endif /* #ifdef GPRS */
      mm_clear_mob_ident (&mm_data->reg.imsi_struct);
      mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL_NO_PAG);

      /* Delete EPLMN List */
      if (reg_clear_plmn_list (mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE))
        mm_build_rr_sync_req_cause(SYNCCS_EPLMN_LIST);

      // Debug patch >>>
      if (mm_data->mm_idle_no_imsi_marker EQ 0)
        mm_data->mm_idle_no_imsi_marker = 19;
      // End debug patch

      mm_data->loc_upd_type.lut = NOT_RUNNING;
#ifdef REL99
      reg_invalidate_upd_state (MS_LA_NOT_ALLOWED, FALSE);
#else
      reg_invalidate_upd_state (MS_LA_NOT_ALLOWED);
#endif
      /* Invalidate SIM data after indirect call to reg_build_sim_update() */
      mm_clear_reg_data ();
      mm_data->reg.plmn_cnt = 0; /* Delete list of available PLMNs */
      /* Set the new MM state before calling reg_mm_failure */
      SET_STATE (STATE_MM, MM_IDLE_NO_IMSI);
      reg_mm_failure (FORB_PLMN_NOT_INCLUDED);
      USE_STORED_ENTRIES();
      break;

#ifdef GPRS
    case GMMCS_GPRS_NOT_ALLOWED_IN_PLMN: /* #14 + Ofs */
      /* 
       * We assume this cause will not be sent by the HPLMN.
       *
       * "The MS shall store the PLMN identity in the "forbidden PLMNs for
       * GPRS service" list. A GPRS MS operating in MS operation mode C 
       * shall perform a PLMN selection instead of a cell selection."
       * [3GPP TS 04.08 version 7.13.0 and others]
       */
      reg_plmn_add_bad (mm_data->reg.gprs_forb_plmn,
                        MAX_GPRS_FORB_PLMN_ID,
                        &mm_data->reg.actual_plmn);

      if (mm_data->reg.op.m EQ MODE_AUTO AND
          mm_data->gprs.mobile_class EQ MMGMM_CLASS_CG AND
          !reg_plmn_equal_hplmn (&mm_data->reg.actual_plmn))
      {
        if (mm_data->reg.plmn_cnt EQ 0)
        {
          /* A PLMN list is not present */
          reg_extract_hplmn (&mm_data->reg.actual_plmn);
          mm_data->reg.plmn_cnt = 0; /* Delete list of available PLMNs */
          mm_mmr_reg_req (FUNC_PLMN_SRCH);
        }
        else
        {
          /* A PLMN list is present */
          if (mm_data->reg.plmn_cnt > mm_data->reg.plmn_index)
          {
            /* 
             * There are still untried entries in the PLMN list. 
             * Try the next PLMN in the list.
             */
            reg_unpack_plmn (&mm_data->reg.actual_plmn,
                             mm_data->reg.plmn, mm_data->reg.plmn_index);
            mm_data->reg.plmn_index++;
            mm_data->attempt_cnt = 0;
            mm_mmr_reg_req (FUNC_PLMN_SRCH);
          }
          else
          {
            /* 
             * There is no signalization to signal the end of search to 
             * GMM here. Maybe this has to be introduced.
             */
          }
        }
      }
      break;
#endif /* #ifdef GPRS */

    case MMCS_NETWORK_FAILURE: /* #17 + Ofs */
#ifdef GPRS
    case GMMCS_NET_FAIL:
#endif /* #ifdef GPRS */
      /*FALLTHROUGH*/
    default:

      /* Delete EPLMN List */
      if (reg_clear_plmn_list (mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE))
        mm_build_rr_sync_req_cause(SYNCCS_EPLMN_LIST);

      mm_lup_restart ();
      break;
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_lup_restart             |
+--------------------------------------------------------------------+

  PURPOSE : The purpose of this function is to perform the actions
            required after a location updating attempt has failed.
            Either T3211 or T3212 are started by this function,
            so a new location updating attempt will be started
            after expiry.

*/

GLOBAL void mm_lup_restart (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_lup_restart ()");

  mm_data->last_rej_cause = 0;
  if (mm_data->attempt_cnt < 4)
    mm_data->attempt_cnt++;
  if (mm_data->attempt_cnt < 4 AND
      mm_check_lai (&mm_data->reg.lai, &mm_data->mm.lai) AND
      mm_data->reg.update_stat EQ MS_UPDATED)
  {
    /*
     * - The update status is UPDATED, and the stored LAI is equal to the one
     *   received on the BCCH from the current serving cell and the
     *   attempt counter is smaller than 4:
     *   
     *   The mobile station shall keep the update status to UPDATED, the MM IDLE
     *   sub-state after the RR connection release is NORMAL SERVICE. 
     * (GSM 04.08 4.4.4.9)
     */ 
    TIMERSTART (T3211, T_3211_VALUE);
    SET_STATE (STATE_MM, MM_IDLE_NORMAL_SERVICE);

#ifdef GPRS
    if (mm_data->gprs.sim_physically_removed)
    {
      mm_sim_removed_gprs_active ();
      return;
    }
#endif /* #ifdef GPRS */

  }
  else
  {
    /* 
     * - Either the update status is different from UPDATED, or the stored 
     *   LAI is different from the one received by the on the BCCH from the 
     *   serving cell, or the attempt counter is greater or equal to 4:
     * 
     *   The mobile station shall delete any LAI, TMSI, ciphering key sequence
     *   number stored in the SIM, set the update status to NOT UPDATED and 
     *   enter the MM IDLE sub-state ATTEMPTING TO UPDATE or optionally the 
     *   MM IDLE sub-state PLMN SEARCH in order to perform a PLMN selection 
     *   according to 3GPP TS 23.122 when the RR connection is released. If 
     *   the attempt counter is smaller than 4, the mobile station shall 
     *   memorize that timer T3211 is to be started when the RR connection is 
     *   released, otherwise it shall memorize that timer T3212 is to be started
     *   when the RR connection is released. 
     * (GSM 24.008 4.4.4.9)
     */
    mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL);
#ifdef REL99
    reg_invalidate_upd_state (MS_NOT_UPDATED, FALSE);
#else
    reg_invalidate_upd_state (MS_NOT_UPDATED);
#endif

    /* Set the new state now, vital for reg_plmn_select() */
    SET_STATE (STATE_MM, MM_IDLE_ATTEMPT_TO_UPDATE);

#ifdef GPRS
    if (mm_data->gprs.sim_physically_removed)
    {
      mm_sim_removed_gprs_active ();
      return;
    }
#endif /* #ifdef GPRS */

    if (mm_data->attempt_cnt < 4)
    {
      TIMERSTART (T3211, T_3211_VALUE);
    }
    else
    {
      mm_mmxx_rel_ind (MMCS_NO_REGISTRATION, CM_NOT_IDLE);
      mm_start_t3212_bcch ();
      mm_data->loc_upd_type.lut = NOT_RUNNING;

      if (mm_lup_allowed_by_gmm())
      {
        if (mm_data->reg.plmn_cnt > mm_data->reg.plmn_index)
        {
          /*
           * Select the next PLMN in the list, if available.
           * This is recommended in GSM 03.22 subclause 4.4.4.
           * "When in Automatic Network Selection mode and the MS is in the 
           * "not updated" state with one or more suitable cells to camp on;
           * then after the maximum allowed unsuccessful LR requests (controlled
           * by the specific attempt counters) the MS may continue (or start if 
           * not running) the user reselection procedure of 4.4.3.2 A."
           */
          reg_plmn_select (FORB_PLMN_NOT_INCLUDED);
        }
        else if (mm_data->reg.op.m EQ MODE_AUTO AND
                 mm_data->reg.op.sim_ins EQ SIM_INSRT AND
                 mm_data->reg.quick_hplmn_search EQ TRUE)
        {
          /* The state PLMN SEARCH is also entered in the following cases:
           * - optionally, when the mobile station is in the ATTEMPTING TO UPDATE 
           * state and is in Automatic Network Selection mode and location update 
           * attempt counter is greater than or equal to 4.
           * (GSM 24.008 4.2.1.2)
           */
          /* optionally the MM IDLE sub-state PLMN SEARCH in order to perform a 
           * PLMN selection according to 3GPP TS 23.122
           * (GSM 24.008 4.4.4.9)
           */
          mm_data->plmn_scan_mm = TRUE;
          mm_data->reg.quick_hplmn_search = FALSE;
          mm_mmgmm_nreg_ind (NREG_LIMITED_SERVICE, 
                       SEARCH_RUNNING,
                       FORB_PLMN_NOT_INCLUDED);
          mm_func_mmgmm_net_req();
        }
        else
        {
          mm_mmgmm_nreg_ind (NREG_LIMITED_SERVICE, 
                             SEARCH_NOT_RUNNING,
                             FORB_PLMN_NOT_INCLUDED);
          mm_data->reg.quick_hplmn_search = TRUE;
        }
      }

      if (mm_data->reg.op.sim_ins EQ SIM_INSRT AND 
          mm_data->reg.op.ts EQ TS_NO_AVAIL)
      {
        /*
         * If there is no test SIM inserted and after 4 unsuccessfull 
         * registration attempts, the registration timer is started.
         * On timeout of the registration timer, *one* normal location 
         * updating is started.
         * Without this, MM may stay in MM_IDLE_ATTEMPT_TO_UPDATE 
         * for an infinite time. (No call attempt, no cell selection, 
         * no periodic location updating)
         */
        TIMERSTART (T_REGISTRATION, T_REG_VALUE);
      }
    }
  }
  reg_check_hplmn_tim (mm_data->reg.thplmn);
  USE_STORED_ENTRIES();
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_mdl_rel_req             |
+--------------------------------------------------------------------+

  PURPOSE : This function sends an MDL_RELEASE_REQ for SAPI 0 to the 
            data link layer. Usually this is done after RR_RELEASE_IND 
            or RR_ABORT_IND is received by RR. 
            One really good question is why this is handled in MM and
            not in RR. But this doesn't matter as it works the way it
            is implemented.

*/

GLOBAL void mm_mdl_rel_req (void)
{
  PALLOC (mdl_release_req, MDL_RELEASE_REQ); /* T_MDL_RELEASE_REQ */
  TRACE_FUNCTION ("mm_mdl_rel_req ()");

  mdl_release_req->sapi = SAPI_0;
  mdl_release_req->ch_type = NOT_PRESENT_8BIT;

  PSENDX (DL, mdl_release_req);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_mdl_rel_req_sapi_3      |
+--------------------------------------------------------------------+

  PURPOSE : This function sends an MDL_RELEASE_REQ for SAPI 3 to the 
            data link layer. Usually this is done after RR_RELEASE_IND 
            or RR_ABORT_IND is received by RR. 
            One really good question is why this is handled in MM and
            not in RR. But this doesn't matter as it works the way it
            is implemented.

*/

GLOBAL void mm_mdl_rel_req_sapi_3 (void)
{
  PALLOC (mdl_release_req, MDL_RELEASE_REQ);

  TRACE_FUNCTION ("mm_mdl_rel_req_sapi_3 ()");

  mdl_release_req->sapi = SAPI_3;
  mdl_release_req->ch_type = NOT_PRESENT_8BIT;

  PSENDX (DL, mdl_release_req);
}
   

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_mmsms_rel_ind           |
+--------------------------------------------------------------------+

  PURPOSE : This functions releases the SMS connections (SAPI 3) 
            of the required connection type to the SMS entitity. This 
            function is used if MM receives a RR_RELEASE_IND primitive
            for SAPI 3.

*/

GLOBAL void mm_mmsms_rel_ind (USHORT cause, UBYTE conn_typ)
{
  GET_INSTANCE_DATA;
  UBYTE ti;

  TRACE_FUNCTION ("mm_mmsms_rel_ind ()");
    
  for (ti = 0; ti < NUM_OF_CONN_PER_CM_ENT; ti++)
  {
    switch (conn_typ)
    {
      case CM_PENDING:
      case CM_ACTIVE:
      case CM_REEST_PENDING:
        if (mm_data->conn_state[SMS_COMP][ti] NEQ conn_typ)
          continue;
        /*FALLTHROUGH*/
        //lint -fallthrough
      default: /* all connections */
        if (mm_data->conn_state[SMS_COMP][ti] EQ CM_IDLE)
          continue;
        CM_SET_STATE (SMS_COMP, ti, CM_IDLE);
        mm_mmxx_release_ind (SMS_COMP, ti, cause);
        mm_delete_entry (SMS_COMP, ti);
        break;
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_mmxx_err_ind            |
+--------------------------------------------------------------------+

  PURPOSE : This function is called if a radio link error occurs, 
            this means, the RR_ABORT_IND primitive was received 
            while active connections existed. Upper layers are 
            notificated about the failure. The function returns the 
            number of active connections found (CM_ACTIVE).

*/

GLOBAL SHORT mm_mmxx_err_ind (USHORT cause)
{
  GET_INSTANCE_DATA;
  UBYTE count = 0;
  UBYTE cm;
  UBYTE ti;

  TRACE_FUNCTION ("mm_mmxx_err_ind ()");
  for (cm = 0; cm < NUM_OF_CM_ENT; cm++)
  {
    for ( ti = 0; ti < NUM_OF_CONN_PER_CM_ENT; ti++)
    {
      if (CMSTATE(cm, ti) EQ CM_ACTIVE)
      {
        count++;
        switch (cm)
        {
          case CC_COMP:
          {
            PALLOC (mmcm_error_ind, MMCM_ERROR_IND);
            mmcm_error_ind->ti    = ti;
            mmcm_error_ind->cause = cause;
            PSENDX (CC, mmcm_error_ind);
            break;
          }
          case SS_COMP:
          {
            PALLOC (mmss_error_ind, MMSS_ERROR_IND);
            mmss_error_ind->ti    = ti;
            mmss_error_ind->cause = cause;
            PSENDX (SS, mmss_error_ind);
            break;
          }
          case SMS_COMP:
          {
            PALLOC (mmsms_error_ind, MMSMS_ERROR_IND);
            mmsms_error_ind->ti    = ti;
            mmsms_error_ind->cause = cause;
            PSENDX (SMS, mmsms_error_ind);
            break;
          }
          default:
            TRACE_ERROR ("Illegal cm comp");
            break;
        }
      }
    }
  }
  return (count);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_mmxx_est_cnf            |
+--------------------------------------------------------------------+

  PURPOSE : Handle CM SERVICE ACCEPT / completion of ciphering mode
            setting for connections requested by CM entities. 
            Two different cases, call establishment and
            call reestablishment are handled here.

*/

GLOBAL void mm_mmxx_est_cnf (void)
{
  GET_INSTANCE_DATA;
  UBYTE ti;

  TRACE_FUNCTION ("mm_mmxx_est_cnf ()");
  {
    if (mm_count_connections (CM_REEST_PENDING) EQ 0)
    {
      /* 
       * No connections waiting for reestablishment. The establishment
       * was confirmed for a pending connection. Set the state of the 
       * pending connection to CM_ACTIVE as it is now not pending anymore.
       * Notify the CM entitity which requested the connection
       * about the successful establishment. 
       * (There can only be one pending connection at a given time).
       */

      CM_SET_STATE (mm_data->pend_conn.comp,
                    mm_data->pend_conn.ti, CM_ACTIVE);

      switch (mm_data->pend_conn.comp)
      {
        case CC_COMP:
          {
            PALLOC (mmcm_establish_cnf, MMCM_ESTABLISH_CNF);
            mmcm_establish_cnf->ti = mm_data->pend_conn.ti;
            PSENDX (CC, mmcm_establish_cnf);
          }
          break;
        case SS_COMP:
          {
            PALLOC (mmss_establish_cnf, MMSS_ESTABLISH_CNF);
            mmss_establish_cnf->ti = mm_data->pend_conn.ti;
            PSENDX (SS, mmss_establish_cnf);
          }
          break;
        case SMS_COMP:
          {
            PALLOC (mmsms_establish_cnf, MMSMS_ESTABLISH_CNF);
            mmsms_establish_cnf->ti = mm_data->pend_conn.ti;
            PSENDX (SMS, mmsms_establish_cnf);
          }
          break;
        default:
          TRACE_ERROR (UNEXPECTED_DEFAULT); /* Cannot happen */
          break;
      }
    }
    else
    {
      /* 
       * Reestablishment pending. Only the CM entitiy CC can perform call
       * reestablishment, so only CC needs to be treated here.
       */
      for (ti = 0; ti < NUM_OF_CONN_PER_CM_ENT; ti++)
      {
        if (mm_data->conn_state[CC_COMP][ti] EQ CM_REEST_PENDING)
        {
          PALLOC (mmcm_reestablish_cnf, MMCM_REESTABLISH_CNF);
          CM_SET_STATE (CC_COMP, ti, CM_ACTIVE);
          mmcm_reestablish_cnf->ti = ti;
          PSENDX (CC, mmcm_reestablish_cnf);
        }
      }
    }
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_mmxx_release_ind        |
+--------------------------------------------------------------------+

  PURPOSE : Send either MMCM_RELEASE_IND, MMSS_RELEASE_IND or
            MMSMS_RELEASE_IND, dependend of the CM component.

*/

GLOBAL void mm_mmxx_release_ind (UBYTE comp, UBYTE ti, USHORT relcs)
{
  TRACE_FUNCTION ("mm_mmxx_release_ind()");

  switch (comp)
  {
    case CC_COMP:
      {
        PALLOC (mmcm_release_ind, MMCM_RELEASE_IND); /* T_MMCC_RELEASE_IND */
        mmcm_release_ind->ti    = ti;
        mmcm_release_ind->cause = relcs;
        PSENDX (CC, mmcm_release_ind);
      }
      break;

    case SS_COMP:
      {
        PALLOC (mmss_release_ind, MMSS_RELEASE_IND); /* T_MMSS_RELEASE_IND */
        mmss_release_ind->ti    = ti;
        mmss_release_ind->cause = relcs;
        PSENDX (SS, mmss_release_ind);
      }
      break;

    case SMS_COMP:
      {
        PALLOC (mmsms_release_ind, MMSMS_RELEASE_IND); /* T_MMSMS_RELEASE_IND */
        mmsms_release_ind->ti    = ti;
        mmsms_release_ind->cause = relcs;
        PSENDX (SMS, mmsms_release_ind);
      }
      break;

    default: 
      TRACE_ERROR (UNEXPECTED_PARAMETER);
      break;
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_mmxx_rel_ind            |
+--------------------------------------------------------------------+

  PURPOSE : The mm_mmxx_rel_ind() function releases all CM connections 
            of a given ´given type. Type may be CM_PENDING, 
            CM_ACTIVE, CM_REEST_PENDING and CM_NOT_IDLE.

*/

GLOBAL void mm_mmxx_rel_ind (USHORT cause, UBYTE conn_typ)
{
  GET_INSTANCE_DATA;
  UBYTE comp;
  UBYTE ti;

  TRACE_FUNCTION ("mm_mmxx_rel_ind ()");

  for (comp = 0; comp < NUM_OF_CM_ENT; comp++)
  {
    for (ti = 0; ti < NUM_OF_CONN_PER_CM_ENT; ti++)
    {
      switch (conn_typ)
      {
        case CM_PENDING:
        case CM_ACTIVE:
        case CM_REEST_PENDING:
          if (CMSTATE(comp, ti) NEQ conn_typ)
            continue;
          /*FALLTHROUGH*/
          //lint -fallthrough
        default: /* CM_NOT_IDLE */
          if (CMSTATE(comp, ti) EQ CM_IDLE)
            continue;
          CM_SET_STATE (comp, ti, CM_IDLE);
          mm_mmxx_release_ind (comp, ti, cause);
          mm_delete_entry (comp, ti);
      }
    }
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_power_off               |
+--------------------------------------------------------------------+

  PURPOSE : This function deactivates the lower layers 
            and enters the MM NULL state.

*/

GLOBAL void mm_power_off (void)
{
  GET_INSTANCE_DATA;
  USHORT index;

  TRACE_FUNCTION ("mm_power_off ()");

  /* Send RR_DEACTIVATE_REQ */
  {
    PALLOC (rr_deactivate_req, RR_DEACTIVATE_REQ);
    PSENDX (RR, rr_deactivate_req);
  }
  
  /* Invalidate the registration data temporary only without deleting it. */
  mm_clear_reg_data ();

  /* Stop all MM timers */
  for (index = 0; index < NUM_OF_MM_TIMERS; index++)
  {
    TIMERSTOP (index);
  }

  mm_data->t3212_timeout = FALSE;

  /* MM enters MM_NULL state, but the important MM data is still alive. */
  SET_STATE (STATE_MM, MM_NULL);
#ifdef GPRS
  SET_STATE (STATE_REG_TYPE, REG_GPRS_INACTIVE);
  SET_STATE (STATE_GPRS_CM_EST, CM_GPRS_EST_OK);
#endif /* GPRS */
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_random                  |
+--------------------------------------------------------------------+

  PURPOSE : A random number generator.

*/

GLOBAL USHORT mm_random (USHORT    n)
{
  GET_INSTANCE_DATA;
  T_TIME actual_time;

  TRACE_FUNCTION ("mm_random ()");

  vsi_t_time (VSI_CALLER &actual_time);
  mm_data->rand_base += actual_time;
  return ((USHORT) mm_data->rand_base % n);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_read_entry              |
+--------------------------------------------------------------------+

  PURPOSE : This functions reads the entries which are flagged as 
            "USE" and executes them. This is done by:
            - rebuilding the original primitives and sending them to 
            the MM entitity in case of content_type "EVENT_ENTRY".
            - calling the respective timeout handling routine for 
            timers (content_type "EVENT_ENTRY"),
            - resending the stored primitive (content_type "PRIMITIVE_ENTRY")

*/

GLOBAL void mm_read_entry (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_read_entry ()");
                          
  if (mm_data->store[0].use EQ USE)
  {
    USHORT i;
    T_STORE current;

    current = mm_data->store[0]; /* Struct copy */

    for (i = 0; i < MAX_STORE_ENTRIES - 1; i++)
    {
      mm_data->store[i] = mm_data->store[i + 1]; /* Struct copy */
    }
    mm_data->store[MAX_STORE_ENTRIES - 1].use = ENTRY_FREE;
    mm_data->store[MAX_STORE_ENTRIES - 1].content_type = NO_ENTRY;

    TRACE_EVENT_P2 ("Read entry: comp=%d, ti=%d", current.content.event.comp, current.content.event.ti);

    if (current.content_type EQ EVENT_ENTRY)
    {
      switch (current.content.event.comp)
      {
        case TIMEOUT:
          switch (current.content.event.ti) /* TI used as timer index here */
          {
            case T3210:  tim_t3210 ();  break;
            case T3211:  tim_t3211 ();  break;
            case T3212:  tim_t3212 ();  break;
            case T3213:  tim_t3213 ();  break;
            case T3220:  tim_t3220 ();  break;
            case T3230:  tim_t3230 ();  break;
            case T3240:  tim_t3240 ();  break;
#ifdef REL99
            case T3241:  tim_t3241 ();  break;
#endif
            default: 
              TRACE_EVENT (UNEXPECTED_DEFAULT);
              break;
          }
          break;

        case REG_COMP:
          mm_func_mmgmm_net_req ();
          break;

        case SS_COMP:
        case SMS_COMP:
          current.content.event.estcs = 0; /* Override estcs */
          /*FALLTHROUGH*/
          //lint -fallthrough
        case CC_COMP:
          CM_SET_STATE (current.content.event.comp, current.content.event.ti, CM_IDLE);
          mm_mmxx_establish_req (current.content.event.comp, current.content.event.ti, current.content.event.estcs, current.info);
          break;

        default:
          TRACE_ERROR (UNEXPECTED_DEFAULT);
          break;
      } /* switch comp */
    } /* if content_type */
    else
    {
      /* the following code will be used if additional primitives
       * will be stored this way or a generic handling for storage
       * and retrieval of elements is requested.
       */
      switch (((T_PRIM_HEADER *)current.content.primitive)->opc)
      {
        case RR_ACTIVATE_IND:
       mm_rr_activate_ind((T_RR_ACTIVATE_IND *) P2D(current.content.primitive));
          break;

        case RR_ABORT_IND:
          mm_rr_abort_ind((T_RR_ABORT_IND *) P2D(current.content.primitive));
          break;

        default:
          TRACE_ERROR (UNEXPECTED_DEFAULT);
          break;
      }
    }/* if content_type */
  } /* if use */
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_reest                   |
+--------------------------------------------------------------------+

  PURPOSE : 

*/

GLOBAL void mm_reest (UBYTE ti)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_reest ()");
  if (mm_data->reg.op.func EQ FUNC_LIM_SERV_ST_SRCH)
  {
    mm_mmxx_rel_ind (MMCS_NO_REGISTRATION, CM_NOT_IDLE);
    mm_sim_set_imsi_marker( MSG_MM_REE);
  }
  else
  {
    mm_rr_est_req (ESTCS_CAL_REEST, CALL_SERVICE, ti);
    SET_STATE (STATE_MM, MM_WAIT_FOR_RR_CONN_MM);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_release_rr_connection   |
+--------------------------------------------------------------------+

  PURPOSE : This functions releases the RR connection after a 
            CM connection / CM connection attempt or after a 
            successfull location updating procedure.
            It can be assumed that if this function is entered MM 
            has better service than no service at all (no state 19.5). 
            It can also be assumed that the mobile is not currently 
            performing a network search, so the following IDLE state 
            will not be one of the IDLE search states 19.7 and 19.8.

*/

GLOBAL void mm_release_rr_connection (UBYTE resumption)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_release_rr_connection ()");

  /* 
   * We are here after either an CM service (attempt) or 
   * after a successfull location updating procedure.
   * The possible remaining states from this point are:
   * 
   * - MM_IDLE_NORMAL_SERVICE, 19.1
   * - MM_IDLE_ATTEMPT_TO_UPDATE, 19.2
   * - MM_IDLE_LIMITED_SERVICE, 19.3
   * - MM_IDLE_NO_IMSI, 19.4 
   * - MM_IDLE_LUP_NEEDED, 19.6 (GPRS only)
   */

#ifdef GPRS
  if (mm_data->gprs.reg_cnf_on_idle_entry AND
      mm_count_connections (CM_NOT_IDLE) EQ 0)
  {
    /* Inform GMM about successful end of registration procedure */
    mm_data->reg.full_service_indicated = FALSE; /* Force MMGMM_REG_CNF */
    mm_mmgmm_reg_cnf ();
  }

  switch (GET_STATE (STATE_REG_TYPE))
  {
    case REG_GPRS_INACTIVE:
      break; /* No further signalling for GMM needed. GPRS is off */

    case REG_REMOTE_CONTROLLED:
      if (mm_data->gprs.sim_physically_removed AND mm_normal_upd_needed())
      {
        /* 
         * Indicate end of RC update to GMM after SIM removal while also
         * engaged in a call, the MS is not updated in the location area.
         */
        mm_mmgmm_nreg_ind (NREG_LIMITED_SERVICE, 
                           SEARCH_NOT_RUNNING,
                           FORB_PLMN_NOT_INCLUDED);
      }
      break;

    case REG_CELL_SEARCH_ONLY:
      /* Inform GMM about release of last CM connection, if any */
      mm_mmgmm_cm_release_ind (resumption);
      break;

    default:
      TRACE_ERROR (UNEXPECTED_DEFAULT);
      break;
  }
#endif /* GPRS */

  if (mm_data->reg.op.sim_ins EQ SIM_NO_INSRT)
  {
    /* 
     * The SIM is considered invalid or is not present at all.
     */
    if (mm_data->idle_substate NEQ MM_IDLE_NO_IMSI)
    {
      /* 
       * The SIM has recently been invalidated,
       * Indicate the new service to MMI 
       */   
      mm_mmgmm_nreg_ind (NREG_LIMITED_SERVICE, 
                         SEARCH_NOT_RUNNING,
                         FORB_PLMN_NOT_INCLUDED);
    }
    
    // Find original place where MM entered MM_IDLE_NO_IMSI state >>>
    if (mm_data->mm_idle_no_imsi_marker EQ 0)
      mm_data->mm_idle_no_imsi_marker = 4;
    // End of debugging patch <<<
    SET_STATE (STATE_MM, MM_IDLE_NO_IMSI);
    USE_STORED_ENTRIES();
    return;
  }

  /* 
   * If we are here the next state is not MM_IDLE_NO_IMSI.
   */
  
  if (mm_data->idle_substate EQ MM_IDLE_LIMITED_SERVICE)
  {
    /* 
     * If we are here we come from an emergency call (attempt) 
     * and had previously limited service only. So we have to 
     * re-enter limited service state here.
     */
    SET_STATE (STATE_MM, MM_IDLE_LIMITED_SERVICE);
    USE_STORED_ENTRIES();
    return;
  }

#ifdef GPRS 
  if (!mm_lup_allowed_by_gmm () AND
      (mm_normal_upd_needed () OR mm_attach_upd_needed ()))
  {
    /* 
     * MM needs location updating, but is not allowed by GMM to start it.
     */
    if (mm_data->rej_cause EQ MMCS_IMSI_IN_VLR)
    {
      /* 
       * Mobile has no registration in VLR. 
       * Normal update after CM SERVICE REJECT with RC_IMSI_IN_VLR needed.
       */

      /* Throw out all calls to force sending of MMGMM_CM_RELEASE_IND. */
      mm_mmxx_rel_ind (mm_data->rej_cause, CM_NOT_IDLE);
      mm_mmgmm_cm_release_ind (resumption);

      /* Reset the exceptional condition */
      mm_data->rej_cause = 0;

      /* Inform GMM about lost registration in network */
      mm_mmgmm_lup_needed_ind (MMGMM_IMSI_IN_VLR);
    }

    SET_STATE (STATE_MM, MM_IDLE_LUP_NEEDED);
    USE_STORED_ENTRIES();
    return;
  }
#endif /* GPRS */

  /* 
   * Here the remaining possible states are:
   * 
   * - MM_IDLE_NORMAL_SERVICE, 19.1
   * - MM_IDLE_ATTEMPT_TO_UPDATE, 19.2
   * - MM_IDLE_LIMITED_SERVICE, 19.3 (?) // This is not possible
   */

  /* After CM connection (attempt), restart T3212 if necessary */
  mm_start_t3212_bcch ();

  /* 
   * Find appropriate IDLE state:
   * Updated anywhere => MM_IDLE_NORMAL_SERVICE 
   * Updated nowhere  => MM_IDLE_ATTEMPT_TO_UPDATE
   */
  if (mm_data->reg.update_stat EQ MS_UPDATED)
  {
    SET_STATE (STATE_MM, MM_IDLE_NORMAL_SERVICE);
  }
  else
  {
    SET_STATE (STATE_MM, MM_IDLE_ATTEMPT_TO_UPDATE);
  }

  // There may be still some problems if we have a clash 
  // RR_ESTABLISH_REQ -> RR_ACTIVATE_IND -> RR_ESTABLISH_CNF -> RR_RELEASE_IND
  // It could be a good idea to repeat the RR_ACTIVATE_IND in this case at 
  // exactly this place and return. To be checked...
  
  /* 
   * Check whether T3211 or T3213 are running, if so, the updating
   * will be delayed until the respective timer expires.
   */
  if (!TIMERACTIVE (T3211) AND !TIMERACTIVE(T3213))
  {
    mm_continue_running_update ();
  }
  USE_STORED_ENTRIES();
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_rr_act_req              |
+--------------------------------------------------------------------+

  PURPOSE : This function activates the RR sublayer

*/

GLOBAL void mm_rr_act_req (void)
{
  GET_INSTANCE_DATA;

  PALLOC (rr_activate_req, RR_ACTIVATE_REQ); /* T_RR_ACTIVATE_REQ */

  TRACE_FUNCTION ("mm_rr_act_req()");

  TIMERSTOP (T3211);
  TIMERSTOP (T3213);
  mm_data->t3213_restart = 0;
  
  memcpy (&rr_activate_req->op, &mm_data->reg.op, sizeof (T_op));
  rr_activate_req->op.service = 0;  /* not used */
  rr_activate_req->cell_test  = mm_data->reg.cell_test;
  rr_activate_req->check_hplmn = CHECK_PLMN_NOT_PRES;

  switch (rr_activate_req->op.func)
  {
    case FUNC_LIM_SERV_ST_SRCH:
      mm_data->loc_upd_type.lut = NOT_RUNNING;

      //lint -fallthrough
    case FUNC_ST_PWR_SCAN:
    case FUNC_NET_SRCH_BY_MMI:
      rr_activate_req->cksn = CKSN_RES;
      rr_activate_req->accc = 0;
      memset (&rr_activate_req->plmn, 0x0F,
              sizeof (T_plmn));
      rr_activate_req->plmn.v_plmn = V_PLMN_NOT_PRES;
      memset (&rr_activate_req->kcv, 0,
              sizeof (T_kcv));
      memset (&rr_activate_req->imsi_struct, 0,
              sizeof (T_imsi_struct));
      memset (&rr_activate_req->tmsi_struct, 0,
              sizeof (T_tmsi_struct));
      memset (&rr_activate_req->bcch_info, 0,
              sizeof (T_bcch_info));
      break;

    case FUNC_PLMN_SRCH:
      rr_activate_req->cksn = mm_data->reg.cksn;
      rr_activate_req->accc = mm_data->reg.acc_class;
      memcpy (&rr_activate_req->plmn, &mm_data->reg.actual_plmn,
              sizeof (T_plmn));
      rr_activate_req->kcv.v_kc = V_KC_PRES;
      memcpy (rr_activate_req->kcv.kc, mm_data->reg.kc, 8);
      rr_activate_req->accc = mm_data->reg.acc_class;
      memcpy (&rr_activate_req->imsi_struct, &mm_data->reg.imsi_struct,
              sizeof (T_imsi_struct));
      
      memset (rr_activate_req->tmsi_struct.id, 0, 
              sizeof (rr_activate_req->tmsi_struct.id));
      if (mm_data->reg.tmsi EQ TMSI_INVALID_VALUE)
      {
        rr_activate_req->tmsi_struct.v_mid    = V_MID_NOT_PRES;
        rr_activate_req->tmsi_struct.id_type  = TYPE_NO_ID;
        rr_activate_req->tmsi_struct.tmsi_dig = 0;
      }
      else
      {
        rr_activate_req->tmsi_struct.v_mid    = V_MID_PRES;
        rr_activate_req->tmsi_struct.id_type  = TYPE_TMSI;
        rr_activate_req->tmsi_struct.tmsi_dig = mm_data->reg.tmsi;
      }
       	

      // Question: Did these testcases fail only because there was a bug?
      // This has still to be tested on the Anite! ...
      // And bcch_encode is suspect here. Maybe the variable could be 
      // eliminated and instead the expression 
      // "(mm_data->reg.update_stat EQ MS_UPDATED AND 
      //  !reg_plmn_empty (&last_plmn))" be used. ...

      /*
       * stored cell selection only in the field
       * else 20.4 and 20.5 on the Anite will fail
       * Exception: the boolean variable 'config_use_stored_bcch' is set to a 
       * value of TRUE by the config command: CONFIG USE_STORED_BCCH
       * or the AT command: AT%CPRIM="MM","CONFIG USE_STORED_BCCH"
       */
      if (mm_data->reg.bcch_encode AND
          ((mm_data->reg.op.ts EQ TS_NO_AVAIL) OR 
           (mm_data->config_use_stored_bcch)))
      {
        /*
         * use SIM data only the first time.
         */
        mm_data->reg.bcch_encode = FALSE;

        // Patch HM 14.03.01 >>>
        // memcpy (&rr_activate_req->bcch_info, &mm_data->reg.bcch, 17);
        // rr_activate_req->bcch_info.v_bcch = TRUE;
        rr_activate_req->bcch_info.v_bcch = V_BCCH_PRES;
        memcpy (rr_activate_req->bcch_info.bcch, mm_data->reg.bcch, SIZE_BCCH);
        // Patch HM 14.03.01 <<<
        
        TRACE_EVENT ("with BCCH information");
      }
      else
        memset (&rr_activate_req->bcch_info, 0, 
                sizeof (T_bcch_info));

      /* restart HPLMN timer for 6 min if we change to a PLMN not the HPLMN */
      if (!reg_best_plmn_in_country(&rr_activate_req->plmn))
      {
        reg_check_hplmn_tim(1);
      }
      /* reg_stop_hplmn_tim (); */

      /* Not Power ON Scenario AND Not a Test SIM */
      if (mm_data->first_attach EQ FALSE)
      {
          /* set the hplmn flag to true only if MM is in substate 
          Limited service or No cell available*/
          if (((GET_STATE(STATE_MM)) EQ MM_IDLE_NO_CELL_AVAILABLE) OR
              ((GET_STATE(STATE_MM)) EQ MM_IDLE_LIMITED_SERVICE))
          {
              /* check_hplmn set to true */
              rr_activate_req->check_hplmn = CHECK_PLMN_PRES;
          }
      }
      break;

    default:
      TRACE_ERROR (UNEXPECTED_DEFAULT);
      break;
  }

  /* Tell RR whether we are interested in GPRS */
  if (mm_gsm_alone())
    rr_activate_req->gprs_indication = GPRS_NO;
  else 
    rr_activate_req->gprs_indication = GPRS_YES;

  if (mm_data->reg.op.sim_ins EQ SIM_NO_INSRT) 
  {
    /* 
     * Without valid SIM, some informations are not present.
     * Ensure SIM specific data will be deleted from RR_ACTIVATE_REQ 
     * if SIM data present, but not considered as valid by MM.
     */
    memset (&rr_activate_req->plmn, 0x0F, sizeof (T_plmn));
    rr_activate_req->plmn.v_plmn = V_PLMN_NOT_PRES;
    rr_activate_req->op.sim_ins = SIM_NO_INSRT;
    rr_activate_req->op.ts      = TS_NO_AVAIL;
    rr_activate_req->cksn       = CKSN_RES;
    memset (&rr_activate_req->kcv, 0x00, sizeof (T_kcv));
    rr_activate_req->accc       = 0x0000;
    mm_clear_mob_ident (&rr_activate_req->imsi_struct);
    mm_clear_mob_ident ((T_imsi_struct*) &rr_activate_req->tmsi_struct);
    memset (&rr_activate_req->bcch_info, 0, sizeof (T_bcch_info));
    rr_activate_req->cell_test  = CELL_TEST_DISABLE;
    /* rr_activate_req->gprs_indic = GPRS_NO; */
  }

  /* Add Equiavlent PLMN list to the activation data */
  memcpy (&rr_activate_req->eq_plmn_list, 
             &mm_data->reg.eqv_plmns.eqv_plmn_list,
              sizeof (EPLMNLIST_SIZE*UBYTES_PER_PLMN));
  /*added by jennifer for 134 sim card issue */
      if((rr_activate_req->plmn.mcc[0]==4)
     && (rr_activate_req->plmn.mcc[1]==6)
     &&(rr_activate_req->plmn.mcc[2]==0)
     &&(rr_activate_req->plmn.mnc[0]==0)
     &&(rr_activate_req->plmn.mnc[1]==2))
     {
     rr_activate_req->plmn.mnc[1]=0;
     }
  /*added by jennifer for 134 sim card issue*/

  TRACE_EVENT_P7 ("RR_ACT_REQ (%d) MCC=%X%X%X MNC=%X%X%X",
                  rr_activate_req->op.func,
                  rr_activate_req->plmn.mcc[0],
                  rr_activate_req->plmn.mcc[1],
                  rr_activate_req->plmn.mcc[2],
                  rr_activate_req->plmn.mnc[0],
                  rr_activate_req->plmn.mnc[1],
                  rr_activate_req->plmn.mnc[2]);

  PSENDX (RR, rr_activate_req);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_rr_data_req             |
+--------------------------------------------------------------------+

  PURPOSE : This function sends the CM_SERVICE_REQUEST message to the 
            network if a CM entity is requesting an additional connection.

*/

GLOBAL void mm_rr_data_req (USHORT est_cause, UBYTE service, UBYTE ti)
{
  GET_INSTANCE_DATA;
  USHORT bit_size_message = 0;

  TRACE_FUNCTION ("mm_rr_data_req ()");

  mm_create_est_message (est_cause, 
                         service, 
                         ti,
                         &bit_size_message);
  for_data_req (bit_size_message);
  mm_data->wait_for_accept = TRUE;
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_rr_est_req              |
+--------------------------------------------------------------------+

  PURPOSE : This functions creates and sends the RR_ESTABLISH_REQ 
            primitive. A RR connection is requested.

*/

GLOBAL void mm_rr_est_req (USHORT    est_cause,
                           UBYTE     service,
                           UBYTE     ti)
{
  GET_INSTANCE_DATA;
  USHORT bit_size_message = 0;
  MCAST (loc_upd_req, U_LOC_UPD_REQ);

  TRACE_FUNCTION ("mm_rr_est_req ()");

  if (est_cause EQ ESTCS_SERV_REQ_BY_MM)
  {
    /* LOCATION UPDATING only, IMSI DETACH not handled here */
    
    mm_create_est_message (est_cause, service, ti,
                           &bit_size_message);

    if (mm_data->reg.update_stat EQ MS_NOT_UPDATED)
      loc_upd_req->ciph_key_num.key_seq = CKSN_RES;

    for_est_req (est_cause, bit_size_message);
  }
  else
  {
    /* All the CM stuff */

#ifdef  GPRS
    assert (GET_STATE (STATE_GPRS_CM_EST) EQ REG_GPRS_INACTIVE OR
            GET_STATE (STATE_GPRS_CM_EST) EQ CM_GPRS_EST_OK);
#endif

    mm_create_est_message (est_cause, service, ti,
                           &bit_size_message);
    
    for_est_req (est_cause, bit_size_message);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_start_loc_upd           |
+--------------------------------------------------------------------+

  PURPOSE : This function starts a location update. 
            The type of the location update will be given in 
            loc_upd_type and is one of NORMAL_LUP, PERIODIC_LUP or 
            IMSI_ATTACH_LUP.

*/
GLOBAL void mm_start_loc_upd (UBYTE loc_upd_type)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_start_loc_upd ()");

  TRACE_EVENT_P1 ("attempt #%x", mm_data->attempt_cnt + 1);

  /* Set the actual plmn to the PLMN selected by RR */
  // Added here by HM 13.11.00
  mm_data->reg.actual_plmn.v_plmn = V_PLMN_PRES;
  memcpy (mm_data->reg.actual_plmn.mcc, mm_data->mm.lai.mcc, SIZE_MCC);
  memcpy (mm_data->reg.actual_plmn.mnc, mm_data->mm.lai.mnc, SIZE_MNC);

  mm_set_follow_on_request ();
  // mm_data->t3212_timeout = FALSE;
  mm_data->idle_entry  = RRCS_INT_NOT_PRESENT;
  mm_data->loc_upd_type.lut = loc_upd_type;
  mm_data->limited_cause = MMCS_INT_NOT_PRESENT;

  EM_RR_CONECTION_REQUESTED;

  /* 
   * Remember the idle substate MM may have to enter afterwards. 
   * 
   * This implementation of MM lacks the implementation of MM_IDLE_LUP_NEEDED
   * for the GSM only protocol stack.
   * So, we have to use MM_IDLE_NORMAL_SERVICE and MM_IDLE_ATTEMPT_TO_UPDATE 
   * not as foreseen by ETSI in some certain situations as replacement for 
   * the missing state MM_IDLE_LUP_NEEDED.
   */

#if 0  /* Bodybag 2004-01-15; remove latest 2004-07-15 */
  // The old code: 
  // Problem: Remembers MM_IDLE_ATTEMPT_TO_UPDATE even if IMSI ATTACH.
  // This is wrong, compare this with GSM 04.08 subclause 4.2.3.
  // Problem 2.) Didn't handle GPRS.
  switch (GET_STATE(STATE_MM))
  {
    case MM_IDLE_ATTEMPT_TO_UPDATE:
    case MM_WAIT_FOR_RR_ACTIVE:
      mm_data->idle_substate = MM_IDLE_ATTEMPT_TO_UPDATE;
      break;

    default:
      mm_data->idle_substate = MM_IDLE_NORMAL_SERVICE;
      break;
  }
#endif

  if (mm_data->reg.update_stat EQ MS_UPDATED)
    mm_data->idle_substate = MM_IDLE_NORMAL_SERVICE;
  else
    mm_data->idle_substate = MM_IDLE_ATTEMPT_TO_UPDATE;

  if (mm_data->rej_cause NEQ RRCS_RND_ACC_FAIL)
    mm_data->last_rej_cause = mm_data->rej_cause;

  mm_rr_est_req (ESTCS_SERV_REQ_BY_MM, NO_CM_SERVICE, 0);
  
  TIMERSTOP (T3211);
  TIMERSTOP (T3213);
  mm_data->t3213_restart = 0;
  
  SET_STATE (STATE_MM, MM_WAIT_FOR_RR_CONN_LUP);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_continue_running_update |
+--------------------------------------------------------------------+

  PURPOSE : This function continues a running location update.

*/
GLOBAL void mm_continue_running_update (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_continue_running_update()");

  switch (mm_data->loc_upd_type.lut)
  {
    case NORMAL_LUP:
      mm_normal_loc_upd ();
      break;
    case PERIODIC_LUP:
      mm_periodic_loc_upd ();
      break;
    case IMSI_ATTACH_LUP:
      mm_attach_loc_upd ();
      break;
    default: /* No updating procedure in progress */
      break;
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_start_net_req           |
+--------------------------------------------------------------------+

  PURPOSE : This function starts a network request.

*/

GLOBAL void mm_start_net_req (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_start_net_req ()");

  mm_data->reg.op.func = FUNC_NET_SRCH_BY_MMI;
  mm_rr_act_req ();

  /* 
   * 19.7 PLMN SEARCH 
   * The mobile station is searching for PLMNs, and the conditions for 
   * state 19.8 are not met. This state is ended when either a cell is 
   * selected (the new state is 19.1, 19.3 or 19.6), 
   * or when it is concluded that no cell is available for the moment 
   * (the new state is 19.5). [GSM 04.08 subclause 4.1.2.1.2]
   */
  
  /* 
   * 19.8 PLMN SEARCH, NORMAL SERVICE
   * Valid subscriber data are available, update status is U1, a cell is
   * selected which belongs to the LA where the subscriber is registered,
   * and the mobile station is searching for PLMNs. This state is ended
   * when either a cell is selected (the new state is 19.1, 19.3 or 19.6),
   * or when it is concluded that no cell is available for the moment 
   * (the new state is 19.5). [GSM 04.08 subclause 4.1.2.1.2]
   */
 
  /* 
   * MM will enter MM_PLMN_SEARCH_NORMAL_SERVICE in the current implementation 
   * also if update state is different from U1 e.g. if MM is in state 
   * MM_IDLE_ATTEMPT_TO_UPDATE. This makes sense, as the update state can be
   * queried to find this condition.
   */

  switch (GET_STATE (STATE_MM))
  {
    case MM_IDLE_NORMAL_SERVICE:        /* 19.1 */
    case MM_IDLE_ATTEMPT_TO_UPDATE:     /* 19.2 */
#ifdef GPRS
    case MM_IDLE_LUP_NEEDED:            /* 19.6 */
#endif /* GPRS */
      /* Remember the type of IDLE state MM had before network search */
      mm_data->idle_substate = GET_STATE (STATE_MM);
      SET_STATE (STATE_MM, MM_PLMN_SEARCH_NORMAL_SERVICE);
      break;
    
    case MM_IDLE_PLMN_SEARCH:           /* 19.7 */
      break; /* No state change */

    case MM_PLMN_SEARCH_NORMAL_SERVICE: /* 19.8 */
      break; /* No state change */
    
    case MM_IDLE_LIMITED_SERVICE:       /* 19.3 */
    case MM_IDLE_NO_IMSI:               /* 19.4 */
      /* Remember the type of IDLE state MM had before network search */
      mm_data->idle_substate = GET_STATE (STATE_MM);
      SET_STATE (STATE_MM, MM_IDLE_PLMN_SEARCH);
      break; 

    case MM_NULL:
    case MM_WAIT_FOR_RR_ACTIVE:         /* 18 */
    case MM_IDLE_NO_CELL_AVAILABLE:     /* 19.5 */
      mm_data->idle_substate = MM_IDLE_NO_CELL_AVAILABLE;
      SET_STATE (STATE_MM, MM_IDLE_PLMN_SEARCH);
      break;
    
#ifdef GPRS
    case MM_LOCATION_UPDATING_PENDING:
    case MM_IMSI_DETACH_PENDING:
      /* What is happening here? Re-think again about this ... */
      TRACE_EVENT ("Interesting protocol sequence");
      
      /* Back to last IDLE substate */
      SET_STATE (STATE_MM, mm_data->idle_substate);
      
      /* Repeat this in old IDLE state */
      mm_start_net_req ();
      return;
#endif /* GPRS */
    
    default:
      TRACE_EVENT ("No IDLE state at network search. Observe this"); // ...
      mm_data->idle_substate = MM_IDLE_NO_CELL_AVAILABLE;
      SET_STATE (STATE_MM, MM_IDLE_PLMN_SEARCH);
      break; 
  }    
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_start_t3212_bcch        |
+--------------------------------------------------------------------+

  PURPOSE : Start the periodic location updating timer T3212 with the
            broadcasted value. This is done in two situations: First, 
            after power on and no IMSI ATTACH / NORMAL UPDATE is needed
            and second at return to IDLE state after network contact.
            The case where no periodic update timer exists is 
            handled also, in this case T3212 is stopped.
            If T3212 is running it is left alone and not restarted, 
            so it is ensured that no periodic location updating is 
            missed if a dedicated connection to the network is released 
            in e.g. state MM_WAIT_FOR_NW_COMMAND, but the conditions in 
            GSM 04.08 subclause 4.4.2 were not met to stop the timer (e.g.
            no MM message received or emergeny call and the previous 
            IDLE state was MM_IDLE_LIMITED_SERVICE.

*/

GLOBAL void mm_start_t3212_bcch (void)
{
  GET_INSTANCE_DATA;
  T_TIME t3212_time;
  
  TRACE_FUNCTION ("mm_start_t3212_bcch()");

#ifdef GPRS 
  if ((mm_data->mm.mm_info.t3212 EQ 0) OR mm_data->gprs.combined_procedures)
#else
  if (mm_data->mm.mm_info.t3212 EQ 0)
#endif /* GPRS */
  {
    /* 
     * No periodic location updating timer
     */
    TIMERSTOP (T3212); 
    mm_data->t3212_timeout = FALSE;
  }
  else
  {
    /*
     * Start T3212 with broadcasted value only if not already running
     */
    if (!TIMERACTIVE (T3212))
    {
      TRACE_EVENT ("T3212 start BCCH");
      if (mm_data->t3212_cfg_counter NEQ 0)
        t3212_time = T_T3212_TIC_VALUE * mm_data->t3212_cfg_counter;
      else
        t3212_time = T_T3212_TIC_VALUE * 36 * mm_data->mm.mm_info.t3212;
      TIMERSTART (T3212, t3212_time);
    }
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_change_t3212            |
+--------------------------------------------------------------------+

  PURPOSE : This function starts/restarts the periodic updating timer
            with a new value if a change of the broadcasted value 
            was detected, either by receiving RR_ACTIVATE_CNF, 
            RR_ACTIVATE_IND or RR_SYNC_IND.

*/

GLOBAL void mm_change_t3212 (void)
{
  GET_INSTANCE_DATA;
  T_TIME t3212_time;
 
  TRACE_FUNCTION ("mm_change_t3212 ()");

#ifdef GPRS 
  if ((mm_data->mm.mm_info.t3212 EQ 0) OR mm_data->gprs.combined_procedures)
#else
  if (mm_data->mm.mm_info.t3212 EQ 0)
#endif /* GPRS */
  {
    /*
     * No periodic location updating timer
     */
    TIMERSTOP (T3212);
    mm_data->t3212_timeout = FALSE;
  }
  else
  {
    if (TIMERACTIVE(T3212) OR mm_data->t3212_timeout)
    {
      if (!mm_data->t3212_timeout)
      {
        T_TIME remaining_time;
        /*
         * T3212 is running and there maybe changes.
         * Restart T3212 with remaining time modulo BCCH value.
         * Nothing will happen here if the BCCH time is 
         * greater or equal the remaining time (modulo operator), 
         * so we avoid TIMERSTOP / TIMERSTART in this case also.
         */
  #if defined (NEW_FRAME)
        TIMER_STATUS (mm_handle, T3212, &remaining_time);
  #else
        TIMER_STATUS (mm_handle, mm_data->t_handle[T3212], &remaining_time);
  #endif
        t3212_time = 
          remaining_time % (mm_data->mm.mm_info.t3212 * 36 * T_T3212_TIC_VALUE);
        if (t3212_time NEQ remaining_time)
        {
          TRACE_EVENT ("T3212 restart modulo");
          TIMERSTOP (T3212); // Neccessary ?
  #ifdef WIN32
          vsi_o_ttrace(VSI_CALLER TC_EVENT,
                       "Modulo time = %d", t3212_time);
  #endif
          TIMERSTART (T3212, t3212_time);
        }
      }
    }
    else
    {
      if (mm_data->first_attach) 
      {
        /* 
         * First activation after power on and no IMSI ATTACH, 
         * start T3212 with broadcasted value.
         */
        mm_start_t3212_bcch ();
      }
      else
      {
        /*
         * changes detected, T3212 is not running and it is not the first
         * activation. Restart T3212 with random value between 0 and BCCH.
         */
        TRACE_EVENT ("T3212 restart random");
        if (mm_data->t3212_cfg_counter NEQ 0)
        {
          t3212_time = mm_data->t3212_cfg_counter;
        }
        else
        {
          t3212_time = 
            T_T3212_TIC_VALUE * 
              mm_random ((USHORT)(mm_data->mm.mm_info.t3212 * 36));
        }
        TIMERSTART (T3212, t3212_time);
      }
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_use_entry               |
+--------------------------------------------------------------------+

  PURPOSE : This functions marks all entries in the stored event table
            which are marked as "STORED" as "USE". Then these events 
            are processed by mm_read_entry(). mm_read_entry() will 
            re-build the respective primitive for each event which
            is marked as "USE" and sent it to MM, giving it a new 
            chance to be processed by MM. For timers, the respective
            handling function will be called.

*/

GLOBAL void mm_use_entry (void)
{
  GET_INSTANCE_DATA;
  SHORT i;
  
  TRACE_FUNCTION ("mm_use_entry ()");

  for (i = 0; i < MAX_STORE_ENTRIES; i++)
  {
    if (mm_data->store[i].use EQ STORED)
      mm_data->store[i].use = USE;
  }

  while (mm_data->store[0].use EQ USE)
    mm_read_entry ();
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_write_entry             |
+--------------------------------------------------------------------+

  PURPOSE : SDL SAVE
            This function saves a primitive which cannot be used
            in the current state, but may be used after the next 
            state transition. If content_type is given as EVENT_ENTRY
            storing is done for the data component, TI and establ. cause.
            If another primitive is to be stored, the pointer is set to 
            the T_PRIM_HEADER and stored.
*/

GLOBAL void mm_write_entry (UBYTE     comp,
                            UBYTE     ti,
                            USHORT    estcs,
                            U8        content_type,
                            void      *primitive,
                            U8        info)
{
  GET_INSTANCE_DATA;
  USHORT i;
  
  TRACE_FUNCTION ("mm_write_entry ()");

  for (i = 0; i < MAX_STORE_ENTRIES; i++)
  {
    if (mm_data->store[i].use EQ ENTRY_FREE)
    {
      TRACE_EVENT_P2 ("Write entry: comp=%d, ti=%d", comp, ti);
      
      mm_data->store[i].use                 = STORED;
      mm_data->store[i].content_type        = content_type;
      if (content_type EQ EVENT_ENTRY)
      {
        mm_data->store[i].content.event.ti    = ti;
        mm_data->store[i].content.event.estcs = estcs;
        mm_data->store[i].content.event.comp  = comp;
        mm_data->store[i].info  = info;
        if (comp < NUM_OF_CM_ENT)
        {
          CM_SET_STATE (comp, ti, CM_STORE);
        }
      }
      else
      {
        mm_data->store[i].content.primitive   = D2P(primitive);
      }
      return;
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_check_lai               |
+--------------------------------------------------------------------+

  PURPOSE : This function checks whether two given location areas
            identifications (MCC, MNC and LAC) are identical. 
            Returns TRUE if LAIs are identical, otherwise FALSE.

*/

GLOBAL BOOL mm_check_lai (const T_loc_area_ident * lai1,
                          const T_loc_area_ident * lai2)
{
  TRACE_FUNCTION ("mm_check_lai ()");

  return ((memcmp (lai1->mcc, lai2->mcc, SIZE_MCC) EQ 0) AND
          (memcmp (lai1->mnc, lai2->mnc, SIZE_MNC) EQ 0) AND
          lai1->lac EQ lai2->lac);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_check_lai_from_RR       |
+--------------------------------------------------------------------+

  PURPOSE : This function compares the PLMN and location area in the 
            form delivered by RR and in and T_plmn structure 
            for equality. Returns TRUE if the PLMNs and location areas
            are equal, otherwise FALSE.

*/

GLOBAL BOOL mm_check_lai_from_RR (const T_loc_area_ident * lai1,
                                  const T_plmn           * plmn2,
                                  USHORT             lac2)
{
  TRACE_FUNCTION ("mm_check_lai_from_RR ()");

  return (memcmp (lai1->mcc, plmn2->mcc, SIZE_MCC) EQ 0 AND
          memcmp (lai1->mnc, plmn2->mnc, SIZE_MNC) EQ 0 AND
          lai1->lac EQ lac2);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_normal_upd_needed       |
+--------------------------------------------------------------------+

  PURPOSE : This function returns TRUE if a normal updating is needed.

*/

GLOBAL BOOL mm_normal_upd_needed (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_normal_upd_needed()");

  if (mm_data->reg.update_stat EQ MS_UPDATED AND
      mm_check_lai (&mm_data->reg.lai, &mm_data->mm.lai))
    return FALSE;
  return TRUE;
}


/* 
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_attach_upd_needed       |
+--------------------------------------------------------------------+

  PURPOSE : This function returns TRUE if an IMSI ATTACH is needed.

*/

GLOBAL BOOL mm_attach_upd_needed (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_attach_upd_needed()");

  if (mm_data->mm.mm_info.att EQ ATT_ALLOW AND mm_data->first_attach) 
    return TRUE;
  return FALSE;
}


/* 
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_periodic_upd_needed     |
+--------------------------------------------------------------------+

  PURPOSE : This function returns TRUE if a periodic location update 
            is immediately needed. This can happen if T3212 expired 
            in a no coverage situation.

*/

GLOBAL BOOL mm_periodic_upd_needed (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_periodic_upd_needed()");

  if (mm_data->t3212_timeout AND mm_data->mm.mm_info.t3212 NEQ 0)
    return TRUE;
  return FALSE;
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_end_of_detach           |
+--------------------------------------------------------------------+

  PURPOSE : This function performs all actions which are done 
            at the end of a detach operation. This function may 
            be called due reception of the primitives RR_RELEASE_IND or 
            RR_ABORT_IND. In case the end of the IMSI DETACH procedure 
            was caused by a timeout of T3220, the RR connection has been 
            aborted normally and this function is called after the 
            release has been acknowledged by RR_RELEASE_IND from RR.

*/          

GLOBAL void mm_end_of_detach (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_end_of_detach()");
  
  TIMERSTOP (T3220);
  
  switch (mm_data->nreg_cause)
  {
    case CS_SIM_REM:
      /* Send RR_ABORT_REQ with ABCS_SIM_REM to invalidate SIM in RR */
      mm_abort_connection (ABCS_SIM_REM);
      
      // This may be done instead RR_ABORT_REQ
      // mm_build_rr_sync_req_cause (SYNCCS_TMSI_CKSN_KC_INVAL_NO_PAG);
      
      mm_clear_reg_data ();
        
      // Find original place where MM entered MM_IDLE_NO_IMSI state >>>
      if (mm_data->mm_idle_no_imsi_marker EQ 0)
        mm_data->mm_idle_no_imsi_marker = 5;
      // End of debugging patch <<<
      SET_STATE (STATE_MM, MM_IDLE_NO_IMSI);

      reg_end_of_deregistration (mm_data->nreg_cause, LIMITED_SERVICE);
      break;

    case CS_POW_OFF:
    case CS_SOFT_OFF:
      mm_power_off ();
      reg_end_of_deregistration (mm_data->nreg_cause, NO_SERVICE);
      break;

#ifdef GPRS 
    case CS_DISABLE:
      /* Remember MM may have to perform IMSI ATTACH if reactivated */
      mm_data->first_attach = TRUE;
        
      /* 
       * Find appropriate IDLE state after disabling of CS GSM.
       * If there was really an IMSI DETACH before, the new state 
       * will be MM_IDLE_LUP_NEEDED as the old state was 
       * MM_IDLE_LIMITED_SERVICE and now at least an IMSI ATTACH 
       * is needed again, but if not really a DETACH was performed, 
       * also another IDLE state may be entered.
       */
      if (mm_data->reg.op.sim_ins EQ SIM_NO_INSRT)
      {
        SET_STATE (STATE_MM, MM_IDLE_NO_IMSI);
      }
      else if (mm_data->idle_substate EQ MM_IDLE_LIMITED_SERVICE)
      {
        SET_STATE (STATE_MM, MM_IDLE_LIMITED_SERVICE);
      }
      else if (mm_normal_upd_needed () OR mm_attach_upd_needed())
      {
        SET_STATE (STATE_MM, MM_IDLE_LUP_NEEDED);
      }
      else
      {
        SET_STATE (STATE_MM, MM_IDLE_NORMAL_SERVICE);
      }

      /* Confirm the requested deregistration */
      mm_mmgmm_nreg_cnf (mm_data->nreg_cause);
      break;
#endif /* GPRS */    
  
    default: 
      TRACE_ERROR (UNEXPECTED_DEFAULT);
      break;
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_get_service_state       |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to get the service state from 
            the MM main state and/or the service state. 
            The return value of this function is expected to be in the
            range of states 19.1..19.6 for GPRS and 19.1..19.5 for GSM.
            The function shall only be used if leaving idle state and
            entering some sort of dedicated state.

*/

GLOBAL UBYTE mm_get_service_state (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_get_service_state()");
  
  switch (GET_STATE (STATE_MM))
  {
    case MM_NULL:                       /* 0 */
      /*  
       * In MM_NULL state, the mobile is switched off, so there is no cell.
       */
      return MM_IDLE_NO_CELL_AVAILABLE;
    
    case MM_WAIT_FOR_RR_CONN_LUP:       /* 13 */
    case MM_WAIT_FOR_RR_ACTIVE:         /* 18 */
      /* 
       * MM has a cell which may be good for full service.
       * MM has also a valid SIM (IMSI).
       *
       * This implementation of MM lacks the implementation of 
       * state MM_IDLE_LUP_NEEDED for the GSM only protocol stack.
       * MM_IDLE_LUP_NEEDED is only used in this implementation if MM needs
       * an update with GPRS, but GPRS has not yet triggered the updating.
       * So we have to use MM_IDLE_NORMAL_SERVICE and MM_IDLE_ATTEMPT_TO_UPDATE
       * not as foreseen by ETSI in some certain situations as replacement for 
       * the missing state MM_IDLE_LUP_NEEDED.
       */
      if (mm_data->reg.update_stat EQ MS_UPDATED) 
        return MM_IDLE_NORMAL_SERVICE; 
      else
        return MM_IDLE_ATTEMPT_TO_UPDATE;

    case MM_IDLE_NORMAL_SERVICE:        /* 19.1 */
    case MM_IDLE_ATTEMPT_TO_UPDATE:     /* 19.2 */
    case MM_IDLE_LIMITED_SERVICE:       /* 19.3 */
    case MM_IDLE_NO_IMSI:               /* 19.4 */
    case MM_IDLE_NO_CELL_AVAILABLE:     /* 19.5 */
#ifdef GPRS
    case MM_IDLE_LUP_NEEDED:            /* 19.6, not used by GSM only stack */
#endif /* GPRS */
      /* 
       * In the cases of 19.1..19.5 (GSM only) or 19.1..19.6 (GPRS also)
       * the service state is simply the appropriate MM IDLE state.
       */
      return GET_STATE (STATE_MM);
            
    case MM_IDLE_PLMN_SEARCH:           /* 19.7 */
    case MM_PLMN_SEARCH_NORMAL_SERVICE: /* 19.8 */
      /* 
       * For the searching IDLE states, no respective service state exists.
       * This is due to the fact that the information that RR is searching
       * for a network can be obtained by reading the MM main state.
       * It is more interesting if CM wants to perform a call to know the
       * IDLE state before the mobile has started network search.
       */
      return mm_data->idle_substate;
    
    default:
      /* 
       * Some sort of dedicated state. This cannot/need not be used to 
       * determine the service state.
       */
      return mm_data->idle_substate;
  }
}


/*
+----------------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                              |
| STATE   : code                ROUTINE : mm_full_service_pplmn_scan         |
+----------------------------------------------------------------------------+

  PURPOSE : This states according to MM main state whether the PPLMN
            rescan procedure could be applicable.


*/

GLOBAL BOOL mm_full_service_pplmn_scan (void)
{
  GET_INSTANCE_DATA;
  switch (GET_STATE (STATE_MM))
  {
    /*
     * The 'normal' cases : idle updated states
     */
    case MM_IDLE_NORMAL_SERVICE:
    case MM_PLMN_SEARCH_NORMAL_SERVICE:
    /* new introduced
     * We also might be in full service but without a valid registration.
     */
    case MM_IDLE_ATTEMPT_TO_UPDATE:
    /*
     * RR connection active, which is either for a CM connection which imply
     * that we are updated (unless it is an emergency call!) or for a MM
     * procedure. If MM procedure fails consistently then we will lose the
     * registration data and the timer will be stopped anyway.
     */
    case MM_WAIT_FOR_OUTG_MM_CONN:
    case MM_CONN_ACTIVE:
    case MM_PROCESS_PROMPT:
    case MM_WAIT_FOR_NW_CMD:
#ifdef REL99
    case MM_RR_CONN_RELEASE_NOT_ALLOWED:
#endif
    case MM_WAIT_FOR_RR_CONN_MM:
    case MM_WAIT_FOR_REESTABLISH:
      
    /*
     * It is important not to stop the timer when in this state (check of 
     * conditions can be done during LUP procedure!) 
     */
    case MM_LUP_INITIATED:
      return TRUE;

    /*
     * If we currently have no or limited service then the standard PLMN 
     * reselection procedure will apply if automatic mode.
     */
    case MM_NULL:
    case MM_IDLE_LIMITED_SERVICE:
    case MM_IDLE_NO_CELL_AVAILABLE:
    case MM_IDLE_PLMN_SEARCH:
    case MM_WAIT_FOR_RR_ACTIVE:

    /*
     * We also might be in full service but without a valid registration. No
     * point to carry on as HPLMN timer would be started after succesfull GSM
     * attach or LUP procedure.
     */
    case MM_WAIT_FOR_RR_CONN_LUP:
    case MM_LUP_REJECTED:
#if defined(GPRS)
    case MM_LOCATION_UPDATING_PENDING:
#endif

    /*
     * No IMSI, detached or in the process to do it. HPLMN rescan does not 
     * make sense so disregard it.
     */
    case MM_IMSI_DETACH_INIT:
#if defined(GPRS)
    case MM_IMSI_DETACH_PENDING:
#endif
    case MM_IDLE_NO_IMSI:
    case MM_WAIT_FOR_RR_CONN_DETACH:
      return FALSE;

    /* 
     * 3GPP 23.122 clause 4.4.3.4 may apply here and makes life easy:
     * "The investigation scan is restricted to automatic selection mode and 
     *  shall only be performed by an MS that is capable of both voice and 
     * packet data."
     */
#ifdef GPRS
    case MM_IDLE_LUP_NEEDED:
      return FALSE;
#endif /* #ifdef GPRS */

     default:
      TRACE_ERROR (UNEXPECTED_DEFAULT);
      return FALSE;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_read_ffs_init           |
+--------------------------------------------------------------------+

  PURPOSE : This function is the initial read of ffs by MM.
*/

const char eplmn_list_name[] = "/gsm/l3/eplmn";
/* added by jennifer to write simloci to FFS */
//int Writesimloci = 1;
//if(Writesimloci)
const char simloci_name[] = "/gsm/l3/simloci";
T_loc_info                loc_info_ffs;
/* added by jennifer to write simloci to FFS */

const char imsi_name[] = "/gsm/l3/imsi";
T_imsi_struct      imsi_in_ffs;


GLOBAL void mm_read_ffs_init(void)
{
  GET_INSTANCE_DATA;

  TRACE_FUNCTION ("mm_read_ffs_init()");

  /* If MM has to create the directories for FFS, there is no point in carry on with the */
  /* initialisation */
  if(mm_check_ffs_dirs())
    return;

  if(mm_read_ffs())
  {
    /*Successful read*/

    /*
     * Compare IMSIs...
     */
    if(!(reg_imsi_equal(&mm_data->reg.eqv_plmns.eqv_plmn_imsi, 
                        &mm_data->reg.imsi_struct)))
    {
      /*
       * Remove old EPLMN list
       */
      memset (&mm_data->reg.eqv_plmns.eqv_plmn_list, 0xFF, EPLMNLIST_SIZE*UBYTES_PER_PLMN);

      /*
       * Write the new IMSI
       */
      mm_data->reg.eqv_plmns.eqv_plmn_imsi = mm_data->reg.imsi_struct; /*Struct Copy*/
      mm_write_eplmn_to_ffs();
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_read_ffs                |
+--------------------------------------------------------------------+

  PURPOSE : This function reads the EPLMN from the ffs by MM.
*/

GLOBAL BOOL mm_read_ffs(void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_read_ffs()");

  return (mm_handle_ffs_read_result(ffs_file_read (eplmn_list_name, 
                              &mm_data->reg.eqv_plmns, 
                               sizeof(T_ffs_eplmn_imsi))));
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_read_ffs                |
+--------------------------------------------------------------------+

  PURPOSE : This function resets the EPLMN data and writes the empty 
            data to the FFS
*/

GLOBAL void mm_reset_ffs(void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_reset_ffs()");

  memset (&mm_data->reg.eqv_plmns.eqv_plmn_list, 
           0xFF, 
           EPLMNLIST_SIZE*UBYTES_PER_PLMN);

  mm_write_eplmn_to_ffs();
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_write_eplmn_to_ffs      |
+--------------------------------------------------------------------+

  PURPOSE : This function writes the current EPLMN list to the 
            FFS
*/

GLOBAL void mm_write_eplmn_to_ffs(void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_write_eplmn_to_ffs()");
 
  mm_check_ffs_dirs();
  mm_handle_ffs_write_result(ffs_file_write (eplmn_list_name, 
                                &mm_data->reg.eqv_plmns,
                                 sizeof(T_ffs_eplmn_imsi),
                                 FFS_O_CREATE | FFS_O_RDWR));
}
/*add by TISH 0418 to write imsi to FFS*/

GLOBAL void mm_write_imsi_to_ffs(void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("mm_write_imsi_to_ffs()");
  mm_check_ffs_dirs();
  mm_handle_ffs_write_result(ffs_file_write (imsi_name,
  					&mm_data->reg.imsi_struct,
  					sizeof(T_imsi_struct),
            FFS_O_CREATE | FFS_O_RDWR));
}

GLOBAL BOOL mm_read_ffs_imsi(void)
{

  TRACE_FUNCTION ("mm_read_ffs_imsi");
  
  return (mm_handle_ffs_read_result(ffs_file_read (imsi_name, 
                              &imsi_in_ffs, 
                              sizeof(T_imsi_struct))));
}
/*add by TISH 0418 to write imsi to FFS*/


/* added by TISH 0418 to write simloci to FFS */

GLOBAL void mm_write_simloci_to_ffs(void)
{
  GET_INSTANCE_DATA;

  ULONG tmsi_binary;

  TRACE_FUNCTION ("mm_write_simloci_to_ffs()");
  
  tmsi_binary = mm_data->reg.tmsi;
  loc_info_ffs.c_loc = SIZE_LOC_INFO;
  loc_info_ffs.loc[0]  = (UBYTE)(tmsi_binary >> 24);
  loc_info_ffs.loc[1]  = (UBYTE)(tmsi_binary >> 16);
  loc_info_ffs.loc[2]  = (UBYTE)(tmsi_binary >> 8);
  loc_info_ffs.loc[3]  = (UBYTE)tmsi_binary;
  loc_info_ffs.loc[4]  = mm_data->reg.lai.mcc[1] << 4;
  loc_info_ffs.loc[4] += mm_data->reg.lai.mcc[0];
  loc_info_ffs.loc[5]  = mm_data->reg.lai.mnc[2] << 4;
  loc_info_ffs.loc[5] += mm_data->reg.lai.mcc[2];  
  loc_info_ffs.loc[6]  = mm_data->reg.lai.mnc[1] << 4;
  loc_info_ffs.loc[6] += mm_data->reg.lai.mnc[0];
  loc_info_ffs.loc[7]  = mm_data->reg.lai.lac >> 8;
  loc_info_ffs.loc[8]  = mm_data->reg.lai.lac & 0xff;
  loc_info_ffs.loc[9]  = 0;
  loc_info_ffs.loc[10] = mm_data->reg.update_stat;

  TRACE_EVENT_P7("writelocinfo:%d,%d,%d,%d,%d,%d,%d", loc_info_ffs.loc[4],
		 loc_info_ffs.loc[5], loc_info_ffs.loc[6], loc_info_ffs.loc[7],
		 loc_info_ffs.loc[8], loc_info_ffs.loc[9],
		 loc_info_ffs.loc[10]);
  mm_check_ffs_dirs();
  mm_handle_ffs_write_result(ffs_file_write (simloci_name, 
                                &loc_info_ffs,
                                 sizeof(T_loc_info),
                                 FFS_O_CREATE | FFS_O_RDWR));
  
}

GLOBAL BOOL mm_read_ffs_simloci(void)
{

  TRACE_FUNCTION ("mm_read_ffs_simloci");
  
  return (mm_handle_ffs_read_result(ffs_file_read (simloci_name, 
                              &loc_info_ffs, 
                                sizeof(T_loc_info))));
}
/* added by TISH 0418 to write simloci to FFS */

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_check_ffs_dirs          |
+--------------------------------------------------------------------+

  PURPOSE : This routine creates the /gsm/l3 directory for the eplmn 
            file in the FFS. The return result indicates whether either 
            directories existed or not. There is no error handling.
*/

LOCAL BOOL mm_check_ffs_dirs( void )
{
  const char gsm_name[] = "/gsm";
  const char gsm_l3_name[] = "/gsm/l3";
  BOOL x, y;

  x = mm_create_ffs_dirs(gsm_name);
  y = mm_create_ffs_dirs(gsm_l3_name);
  return(x&&y);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_create_ffs_dirs         |
+--------------------------------------------------------------------+

  PURPOSE : This routine calls the ffs_mkdir() routine to create a 
            specified directory. It returns whether the directory 
            existed or not prior to creation.
*/
LOCAL BOOL mm_create_ffs_dirs(const char *dir_name)
{
  T_FFS_RET status;
  BOOL dirs_present = FALSE;

  status=ffs_mkdir(dir_name);
  switch(status)
  {
    case EFFS_EXISTS:
      dirs_present = TRUE;
      break;

    case EFFS_OK:
      break;

    default: /*Error*/
      TRACE_EVENT_P1("Create Dir error - %x",status);
      break;
  }
  return dirs_present;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_handle_ffs_read_result  |
+--------------------------------------------------------------------+

  PURPOSE : This function checks the status from FFS and returns
            TRUE if there is no error and FALSE if there is
*/
LOCAL BOOL mm_handle_ffs_read_result(T_FFS_SIZE status_read)
{
  if(status_read)
  {
    TRACE_EVENT ("FFS Read OK");
    return TRUE;
  }
  else
  {
    TRACE_EVENT_P1("EPLMN Read ERROR - %x", status_read);
    return FALSE;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_handle_ffs_write_result |
+--------------------------------------------------------------------+

  PURPOSE : This function checks the status from FFS and returns
            TRUE if there is no error and FALSE if there is
*/
LOCAL BOOL mm_handle_ffs_write_result(T_FFS_RET status_write)
{
  if(status_write >= EFFS_OK)
  {
    TRACE_EVENT("FFS Write OK");
    if(status_write)
      TRACE_EVENT_P1 ("Bytes written: %d",status_write);

    return(TRUE);
  }
  else
  {
    TRACE_EVENT_P1 ("FFS Write Error - Status: %x",status_write);
    return(FALSE);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_display_eplmn           |
+--------------------------------------------------------------------+

  PURPOSE : This function displays the current EPLMN list

*/

GLOBAL void mm_display_eplmn(void)
{
  GET_INSTANCE_DATA;
  TRACE_EVENT ("EPLMN List");
  TRACE_EVENT_P3 ("%x, %x, %x", mm_data->reg.eqv_plmns.eqv_plmn_list[0],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[1],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[2]);
  TRACE_EVENT_P3 ("%x, %x, %x", mm_data->reg.eqv_plmns.eqv_plmn_list[3],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[4],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[5]);
  TRACE_EVENT_P3 ("%x, %x, %x", mm_data->reg.eqv_plmns.eqv_plmn_list[6],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[7],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[8]);
  TRACE_EVENT_P3 ("%x, %x, %x", mm_data->reg.eqv_plmns.eqv_plmn_list[9],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[10],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[11]);
  TRACE_EVENT_P3 ("%x, %x, %x", mm_data->reg.eqv_plmns.eqv_plmn_list[12],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[13],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[14]);
  TRACE_EVENT_P3 ("%x, %x, %x", mm_data->reg.eqv_plmns.eqv_plmn_list[15],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[16],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[17]);

  TRACE_EVENT_P3 ("%c, %c, %c", mm_data->reg.eqv_plmns.eqv_plmn_list[0],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[1],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[2]);
  TRACE_EVENT_P3 ("%c, %c, %c", mm_data->reg.eqv_plmns.eqv_plmn_list[3],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[4],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[5]);
  TRACE_EVENT_P3 ("%c, %c, %c", mm_data->reg.eqv_plmns.eqv_plmn_list[6],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[7],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[8]);
  TRACE_EVENT_P3 ("%c, %c, %c", mm_data->reg.eqv_plmns.eqv_plmn_list[9],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[10],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[11]);
  TRACE_EVENT_P3 ("%c, %c, %c", mm_data->reg.eqv_plmns.eqv_plmn_list[12],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[13],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[14]);
  TRACE_EVENT_P3 ("%c, %c, %c", mm_data->reg.eqv_plmns.eqv_plmn_list[15],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[16],
                                mm_data->reg.eqv_plmns.eqv_plmn_list[17]);

}

/* Implements Measure 29 and streamline encoding */
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
| STATE   : code                ROUTINE : mm_send_status             |
+--------------------------------------------------------------------+

  PURPOSE : This function builts and sends status

*/
GLOBAL void mm_send_status (UBYTE  cause)
{
  TRACE_FUNCTION ("mm_send_status ()");
  
  {
    MSG_CAST (mm_status, T_B_MM_STATUS);
    mm_build_mm_status (cause, mm_status);
    for_data_req (BSIZE_B_MM_STATUS);
  }
}
#endif