/* 
+----------------------------------------------------------------------------- 
|  Project :  GPRS (8441)
|  Modul   :  gmm_kernp.c
+----------------------------------------------------------------------------- 
|  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 is part of the entity GMM and implements all 
|             functions to handles the incoming primitives as described in 
|             the SDL-documentation (KERN-statemachine)
+----------------------------------------------------------------------------- 
*/ 



#ifndef GMM_KERNP_C
#define GMM_KERNP_C
#endif

#define ENTITY_GMM

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

#include "typedefs.h"    /* to get Condat data types */
#include "vsi.h"        /* to get a lot of macros */
#include "macdef.h"
#include "gprs.h"
#include "gsm.h"        /* to get a lot of macros */
#include "ccdapi.h"     /* to get CCD API */
#include "cnf_gmm.h"    /* to get cnf-definitions */
#include "mon_gmm.h"    /* to get mon-definitions */
#include "prim.h"       /* to get the definitions of used SAP and directions */
#include "gmm.h"        /* to get the global entity definitions */

#include "gmm_f.h"      /* to ger the gobal functions */
#include "gmm_kernl.h"      /* to ger the local functions */
#include "gmm_kernf.h"      /* to ger the local functions */
#include "gmm_rdys.h"      /* to get some signals */
#include  <string.h>    /* to get memcpy */
#include "gmm_txs.h"    /* to get some signals */
#include "gmm_syncs.h"
#include "gmm_em.h"     /* To get Engineering Mode functions */

/*==== CONST ================================================================*/

/*==== LOCAL VARS ===========================================================*/

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

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

/*
+------------------------------------------------------------------------------
| Function    : kern_t3302
+------------------------------------------------------------------------------
| Description : Handles expiry of timer T3302. This function is called from
|               pei_primitive().
|               Timeout for Attach or RAU failure
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void  kern_t3302(void)
{
  GMM_TRACE_FUNCTION( "kern_t3302" );
  TRACE_0_INFO("TIMEOUT T3302");
  sig_kern_rdy_stop_t3302_req();
  /*
   * reset attach attempt counter
   * <R.GMM.ATTACH.M.010>
   */
  /*
   * reset rau attempt counter
   * <R.GMM.ATTACH.M.010>
   */


  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_DEREG_SUSPENDING:
    case KERN_GMM_DEREG_SUSPENDED:
      gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=FALSE;
      break;
    case KERN_GMM_REG_SUSPENDING:
      gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=FALSE;
      SET_STATE(GU,GU_UPDATE_NEEDED);
      break;
    case KERN_GMM_REG_RESUMING:
    case KERN_GMM_REG_SUSPENDED:
      gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=FALSE;
      SET_STATE(GU,GU_UPDATE_NEEDED);
      break;
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
      kern_attach_reset();
      kern_attach ();
      break;
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
      kern_attach_reset();

      if (PERIODIC_RAU == gmm_data->kern.attach_cap.update_proc_type)
      {
        /* 44.2.3.3.2 */
        kern_periodic_rau();
      }
      else
      {
        kern_rau_limited();
      }

      break;
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
      /*
       * GPRS is still attached (normal service)
       * so we need to resume LLC again
       */
      kern_attach_reset();
      kern_rau();
      break;
    default:
      TRACE_ERROR( "kern_t3302 unexpected" );
      break;
  }
  GMM_RETURN;
  
} /* kern_t3302 */

/*
+------------------------------------------------------------------------------
| Function    : kern_t3310
+------------------------------------------------------------------------------
| Description : Handles expiry of timer T3310. This function is called from
|               pei_primitive().
|               Timeout for ATTACH
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_t3310 (void)
{
  GMM_TRACE_FUNCTION( "kern_t3310" );
  TRACE_0_INFO("TIMEOUT T3310");

  gmm_data->kern.attach_cap.t3310_value=0;

  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_REG_INITIATED:
      /************************************************************************
       * MSC: 3.8 Attach
       *
       * MSC: 3.8.1 Normal Attach
       * MSC: 3.8.1.4 Abnormal cases
       * MSC: 3.8.1.4.3 c) T3310 time-out
       ************************************************************************/
      if ( gmm_data->kern.ct3310 < MAX_CT3310 )
      {
        /*
         * ATTACH
         * <R.GMM.AGABNORM.M.007>
         */
        kern_gmmreg_detach (  GMMREG_DT_GPRS,  
            GMMCS_NET_FAIL, /* TCS 2.1 */
            GMMREG_SEARCH_RUNNING,
            GMMCS_NET_FAIL);

        kern_attach();
      }
      else
      {
        /*
         * AAC
         *<R.GMM.AGABNORM.M.008>
         */
        kern_aac(GMMCS_NO_SERVICE); /* TCS 2.1 */
      }

      break;
    case KERN_GMM_RAU_INITIATED:
      /************************************************************************
       * MSC: 3.10 RAU
       *
       * MSC: 3.10.1 Normal and periodic RAU initiation
       * MSC: 3.10.1.4 Abnormal cases
       * MSC: 3.10.1.4.3 c) T3310 time-out
       *
       ************************************************************************/
      /* 
       * I reused the timer T3310 instead of T3330 
       */
      if ( gmm_data->kern.ct3310 < MAX_CT3310 )
      {
        if (PERIODIC_RAU == gmm_data->kern.attach_cap.update_proc_type)
        {
          /* 44.2.3.3.2 */
          kern_periodic_rau();
        }
        else
        {
          kern_rau_limited();
        }
      }
      else
      {
        /*
         * AAC
         */
        kern_aac(GMMCS_NO_SERVICE); /* TCS 2.1 */
      }
      break;
    /* START PATCH UBUOB ISSUE 8274 */
    case KERN_GMM_REG_RESUMING:
    case KERN_GMM_REG_SUSPENDING:
    case KERN_GMM_REG_SUSPENDED:
      gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = FALSE;
      SET_STATE(GU,GU_UPDATE_NEEDED);
      break;
    /* END PATCH UBUOB ISSUE 8274 */
    case KERN_GMM_REG_LIMITED_SERVICE:
      TRACE_EVENT("T3310 ignored in limited mode"); 
      break;
    default:
      TRACE_ERROR( "kern_t3310 unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_t3310 */
/*
+------------------------------------------------------------------------------
| Function    : kern_t3311
+------------------------------------------------------------------------------
| Description : Handles expiry of timer T3310. This function is called from
|               pei_primitive().
|               Timeout for ATTACH or RAU Reject
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_t3311 (void)
{
  GMM_TRACE_FUNCTION( "kern_t3311" );
  TRACE_0_INFO("TIMEOUT T3311");
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
      kern_attach ();
      break;
    case  KERN_GMM_REG_NORMAL_SERVICE:
      /*
       * <R.GMM.RNABNORM.M.022> 
       */
      kern_periodic_rau();
      break;
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
      kern_llgmm_suspend(LLGMM_RAU);
      /*FALLTHROUGH*/
      //lint -fallthrough
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
      kern_rau_limited ();
      break;
    /* START PATCH UBUOB ISSUE 8893 */
    case KERN_GMM_DEREG_SUSPENDING:
    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_DEREG_RESUMING:
    /* END PATCH UBUOB ISSUE 8893 */
    case KERN_GMM_REG_RESUMING:
    /* START PATCH UBUOB ISSUE 8273 */
    case KERN_GMM_REG_SUSPENDING:
    case KERN_GMM_REG_SUSPENDED:
      gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = FALSE;
      SET_STATE(GU,GU_UPDATE_NEEDED);
      break;
    /* END PATCH UBUOB ISSUE 8273 */
    default:
      TRACE_ERROR( "kern_t3311 unexpected" );
      break;
  }
  
  GMM_RETURN;
} /* kern_t3311 */
/*
+------------------------------------------------------------------------------
| Function    : kern_t3312
+------------------------------------------------------------------------------
| Description : Handles expiry of timer T3312. This function is called from
|               pei_primitive().

|               Periodic RAU timer
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_t3312 (void)
{
  GMM_TRACE_FUNCTION( "kern_t3312" );
  TRACE_0_INFO("TIMEOUT T3312");
  switch( GET_STATE( KERN ) )
  {
    
    case KERN_GMM_REG_NORMAL_SERVICE:
      if (GMM_GRR_STATE_CR==gmm_data->kern.attach_cap.grr_state)
      {
         gmm_data->kern.timeout_t3312 = TRUE;
         SET_STATE(GU,GU_UPDATE_NEEDED);
      }
      else
      {
        kern_periodic_rau();
      }
      break;
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
      /*
       * 24.008 ch 4.7.2.2. at the end:
       *
       * If the MS is both IMSI attached for GPRS and non-GPRS services in a network that
       * operates in network operation mode I, and if the MS has camped on a cell that does
       * not support GPRS, and timer T3312 expires, then the MS shall start an MM location
       * updating procedure. In addition, the MS shall perform a combined routing area update
       * procedure indicating "combined RA/LA updating with IMSI attach" when the MS enters
       * a cell that supports GPRS and indicates that the network is in operation mode I.
       */
      gmm_data->kern.timeout_t3312 = TRUE;
      SET_STATE(GU,GU_UPDATE_NEEDED);
      
      if (GMM_MM_DEREG != GET_STATE(MM)
      && GMMRR_LA_INVALID!=gmm_data->kern.sig_cell_info.env.rai.lac)
      {
        SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING);
#endif
        kern_llgmm_suspend(LLGMM_CALL); /* in no cell availble LLC is alread susended */
        kern_gmmrr_suspend(GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);
      }      
      break;


    case KERN_GMM_REG_LIMITED_SERVICE:
    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_REG_RESUMING:
    case KERN_GMM_REG_SUSPENDING:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
    case KERN_GMM_REG_SUSPENDED:
        /* no break; */
        /*
         * <R.GMM.RAUTIMER.M.009>
         */
      gmm_data->kern.timeout_t3312 = TRUE;
      SET_STATE(GU,GU_UPDATE_NEEDED);
      break;
    default:
      break;
  }
  
  GMM_RETURN;
} /* kern_t3312 */
/*
+------------------------------------------------------------------------------
| Function    : kern_t3321
+------------------------------------------------------------------------------
| Description : Handles expiry of timer T3321. This function is called from
|               pei_primitive().
|               Timeout for DETACH
|
|               MSC: 3.9 GPRS detach procedure
|               
|               MCS: 3.9.3 Abnormal cases
|               MSC: 3.9.3.1 a) Timeout of timer T3321
|
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_t3321 (void)
{

#ifdef REL99
  T_gmobile_identity gmobile_identity; /* TCS 4.0 */
#endif

  GMM_TRACE_FUNCTION( "kern_t3321" );
  TRACE_0_INFO("TIMEOUT T3321");
  /*
   * MSC: 3.9 GPRS detach procedure
   *
   * MCS: 3.9.3 Abnormal cases
   * MSC: 3.9.3.1 a) Timeout of timer T3321
   */
  if ( ++gmm_data->kern.ct3321 < 5 )
  {
    MCAST (u_detach_request, U_DETACH_REQUEST);
    
      TRACE_EVENT ("  START T3321" );
      sig_kern_rdy_start_timer_req ( kern_T3321, gmm_data->kern.t3321_val );
    
      u_detach_request->u_detach_type.u_type_of_detach 
                          = gmm_data->kern.detach_cap.detach_type,
      u_detach_request->u_detach_type.power_off = PO_NORMAL_DETACH;


#ifdef REL99
    /* Detach request sent to a Release 99 network has two addional
     * parameters. PTMSI and PTMSI signature  
     */        
    switch (gmm_data->kern.sig_cell_info.sgsnr_flag)/*!gmm_data->release99 =>old code*/ /* TCS 4.0 */
    {
      default:
      case PS_SGSN_UNKNOWN:
      case PS_SGSN_98_OLDER:
        u_detach_request->v_gmobile_identity = FALSE; /* TCS 4.0 */
        u_detach_request->v_p_tmsi_signature_2 = FALSE; /* TCS 4.0 */
        break;
      case PS_SGSN_99_ONWARDS:      
        /* 
         * PTMSI
         */
        kern_ulong2mobile_identity( gmm_data->ptmsi.current, &gmobile_identity ); /* TCS 4.0 */
        u_detach_request->v_gmobile_identity = TRUE; /* TCS 4.0 */
        u_detach_request->gmobile_identity   = gmobile_identity; /* TCS 4.0 */
        
        /* 
         * PTMSI Signature
         */
        if(gmm_data->ptmsi_signature.available) /* TCS 4.0 */
        { /* TCS 4.0 */
          u_detach_request->v_p_tmsi_signature_2 =TRUE; /* TCS 4.0 */
          u_detach_request->p_tmsi_signature_2.p_tmsi_signature_value /* TCS 4.0 */
                             = gmm_data->ptmsi_signature.value; /* TCS 4.0 */
        } /* TCS 4.0 */
        else  /* TCS 4.0 */
        { /* TCS 4.0 */
          u_detach_request->v_p_tmsi_signature_2=FALSE; /* TCS 4.0 */
        } /* TCS 4.0 */
        break;
      }
#endif


      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_GPRS:
          u_detach_request->u_detach_type.u_type_of_detach 
                          = DT_GPRS;
          break;
        case GMMREG_DT_IMSI:
          u_detach_request->u_detach_type.u_type_of_detach 
                          = DT_IMSI;
          break;
        case GMMREG_DT_COMB:
          u_detach_request->u_detach_type.u_type_of_detach 
                          = DT_COMB;
          break;
        case GMMREG_DT_SIM_REMOVED:
          if ( GMM_MM_DEREG != GET_STATE(MM) )
          {
            u_detach_request->u_detach_type.u_type_of_detach 
                          = DT_COMB;
          }
          else
          {
            u_detach_request->u_detach_type.u_type_of_detach 
                          = DT_GPRS;
          }
          break;
        default:
          TRACE_ERROR ("unexpexted GMMREG_DT_TYPE");
          break;
      }
      kern_mm_detach_started ();    
      sig_kern_tx_data_req ( CURRENT_TLLI, U_DETACH_REQUEST);
  }
  else
  {    
    switch( GET_STATE( KERN ) )
    {
      case KERN_GMM_DEREG_INITIATED:
        kern_local_detach( GMMCS_INT_NOT_PRESENT, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_DEREG); /* TCS 2.1 */
        break;  
      case KERN_GMM_REG_IMSI_DETACH_INITIATED:
        /*
         * <R.GMM.DMABNORM.M.020>
         */
        kern_local_detach( GMMCS_INT_NOT_PRESENT, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_REG_NORMAL); /* TCS 2.1 */
        break;
      default:
        TRACE_ERROR( "kern_t3321 unexpected" );
        break;
    }
  }
  GMM_RETURN;
} /* kern_t3321 */
/*
+------------------------------------------------------------------------------
| Function    : kern_tpower_off
+------------------------------------------------------------------------------
| Description : Handles expiry of timer Tpower_off. This function is called from
|               pei_primitive().
|               Timeout for power_off after sending DETACH message
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_tpower_off (void)
{
  GMM_TRACE_FUNCTION( "kern_tpower_off" );
  TRACE_0_INFO("TIMEOUT TPOWER_OFF");
  kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */
                GMMREG_DT_SOFT_OFF==gmm_data->kern.detach_cap.detach_type?
                GMM_LOCAL_DETACH_PROC_SOFT_OFF:
                GMM_LOCAL_DETACH_PROC_POWER_OFF);

  GMM_RETURN;
  
} /* kern_tpower_off */

/*
+------------------------------------------------------------------------------
| Function    : kern_tlocal_detach
+------------------------------------------------------------------------------
| Description : Handles expiry of timer Tlocal_detach. This function is called from
|               pei_primitive().
|               function local_detach is called to locally detach the MS.
|               GRR and LLC can not unassigned immediately. So GMM waits untill 
|               the tlocal_detach timer has been expired or either CGRLC_TRIGGER_IND
|               has been received or GMMRR_SUSPEND_CNF has been received.
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void  kern_tlocal_detach (void)
{
  GMM_TRACE_FUNCTION( "kern_tlocal_detach" );


  switch( GET_STATE( KERN ) )
  {
    default:
      TRACE_ERROR("tlocal_detach not in state DEREG_SUSPENDING");
      /* NO break; */
    case KERN_GMM_DEREG_SUSPENDING:
      kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, 
                GMM_SUSP_UNKNOWN);  

      break;
  }

  GMM_RETURN  ;
} /* kern_tlocal_detach */




/*
+------------------------------------------------------------------------------
| Function    : kern_gmmreg_net_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMREG_NET_REQ
|
|          MSC: 3.20 MM Interface
|          MSC: 3.20.2 Network selection
|
| Parameters  : *gmmreg_net_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmreg_net_req ( T_GMMREG_NET_REQ *gmmreg_net_req )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmreg_net_req" );

  PFREE (gmmreg_net_req);
  kern_mm_net_req();
  GMM_RETURN;
} /* kern_gmmreg_net_req() */

/*
+------------------------------------------------------------------------------
| Function    : kern_gmmreg_plmn_res
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMREG_PLMN_RES
|
|          MSC: 3.20 MM Interface
|          MSC: 3.20.2 Network selection
|
| Parameters  : *gmmreg_plmn_res - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmreg_plmn_res ( T_GMMREG_PLMN_RES *gmmreg_plmn_res )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmreg_plmn_res" );

  gmm_data->kern.attach_cap.network_selection_mode=MODE_MAN;
  kern_remove_plmn_from_forbidden_list(gmmreg_plmn_res->plmn);
    
  /* START PATCH UBUOB ISSUE 8276 */
  /* T3302 should not be stopped here, because this is dangerous if the */
  /* user selection does not lead to a different PLMN */
  /*vsi_t_stop  ( GMM_handle, kern_T3302);*/
  /*sig_kern_rdy_start_t3302_req();*/
  /* END PATCH UBUOB ISSUE 8276 */

  /* When we receive manual mode network selection stop TSYNC timer */
  vsi_t_stop  ( GMM_handle, sync_TSYNC);

  gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = FALSE;
  /*
   * attach_cap.gmmreg sets the caller of the attach procedure to MMI
   */
  gmm_data->kern.attach_cap.gmmreg = TRUE;
  /*
   * if the moble has been rejected with cause #11,#12, or #13 it has to igored
   * when user wanted the moile explicitly to try to attach
   * TC 44.2.1.1.4.3.2
   */
  gmm_data->kern.detach_cap.error_cause=GMMCS_INT_NOT_PRESENT; /* TCS 2.1 */

  /* Setting mm_status to FULL Service immediately on receiving PLMN Response creates a false display 
   * on MMI if selecting forbidden PLMN second time in a row. However, it is necessary in case of Normal PLMN selection
   * for an early indication to ACI. Hence setting mm_status to Full Service only if the selected PLMN was not rejected by 
   * the N/W in the same power cycle.
   */
  if((memcmp(gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[0].mcc,gmmreg_plmn_res->plmn.mcc, SIZE_MCC) NEQ 0) AND
     (memcmp(gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[0].mnc,gmmreg_plmn_res->plmn.mnc, SIZE_MNC)NEQ 0))
  {
    gmm_data->kern.sig_cell_info.mm_status = MMGMM_FULL_SERVICE;
    sig_kern_sync_set_mm_state(MMGMM_FULL_SERVICE);
  }

#ifndef NTRACE
  /*
   * My assumption is, that I have to know the class if plmn_res comes as power 
   * on primitive with AT+COPS=1,2,"001001". There are no possabilities  to 
   * change the classes. a class change is handeled with attach_req
   */
  if(gmm_data->kern.attach_cap.mobile_class!=gmmreg_plmn_res->mobile_class)
  {
    TRACE_ERROR("class change not expected: NO DETACH_REQ will be send!");
  }
#endif
  gmm_data->kern.attach_cap.plmn_requested  = gmmreg_plmn_res->plmn; 
  gmm_data->kern.attach_cap.mobile_class = gmmreg_plmn_res->mobile_class;  
  gmm_data->kern.attach_cap.attach_type = gmmreg_plmn_res->attach_type;
#ifndef NTRACE      
  switch ( gmm_data->kern.attach_cap.mobile_class )
  {
    case GMMREG_CLASS_CC:
      TRACE_0_PARA ("MS class CC");
      break;
    case GMMREG_CLASS_CG:
      TRACE_0_PARA ("MS class CG");
      break;
    case GMMREG_CLASS_B:
      TRACE_0_PARA ("MS class B");
      break;
    case GMMREG_CLASS_BG:
      TRACE_0_PARA ("MS class BG");
      break;
    case GMMREG_CLASS_BC:
      TRACE_0_PARA ("MS class BC");
      break;
    case GMMREG_CLASS_A:
      TRACE_0_PARA ("MS class A");
      break;
    default:
      TRACE_ERROR ("unknown mobile class");
      break;
  }
  switch (gmm_data->kern.attach_cap.attach_type)
  {
    case GMMREG_AT_IMSI:
      TRACE_EVENT ("----- GSM only attach -----");
      break;
    case GMMREG_AT_GPRS:
      TRACE_EVENT ("----- GPRS attach -----");
      break;
    case GMMREG_AT_COMB:
      TRACE_EVENT ("----- GSM and GPRS attach -----");
      break;
    default:
      TRACE_ERROR ("unknown attach type");
      break;
  }

#endif
  {
    PALLOC ( mmgmm_plmn_res, MMGMM_PLMN_RES);
      mmgmm_plmn_res->plmn = gmmreg_plmn_res->plmn;
      mmgmm_plmn_res->reg_type = REG_CELL_SEARCH_ONLY;
      PFREE (gmmreg_plmn_res);

    switch( GET_STATE( KERN ) )
    {
      case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
      case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:           
        mmgmm_plmn_res->reg_type = REG_GPRS_INACTIVE;
        break;
      case KERN_GMM_NULL_NO_IMSI:
        if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class
        || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type)
        {
          /* NO state change */
        }
        else
        {
          SET_STATE ( KERN, KERN_GMM_DEREG_NO_IMSI);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI);
#endif
        }
        mmgmm_plmn_res->reg_type = REG_GPRS_INACTIVE;

        break;

      case KERN_GMM_DEREG_RESUMING:
      case KERN_GMM_REG_RESUMING:
      case KERN_GMM_DEREG_NO_IMSI:
        break;
      /*
       * GMM-DEREGISTERED
       */
      case KERN_GMM_DEREG_SUSPENDING:
        /* 
         * not reachable beause of save in pei 
         */
      case KERN_GMM_DEREG_SUSPENDED:
        kern_resume_grr_der();
        /* NO break;*/
      case KERN_GMM_DEREG_PLMN_SEARCH:
      case KERN_GMM_DEREG_LIMITED_SERVICE:
      case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
      case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
        if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class
        || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type)
        {
          SET_STATE ( KERN, KERN_GMM_NULL_PLMN_SEARCH);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_NULL_PLMN_SEARCH);
#endif
          mmgmm_plmn_res->reg_type = REG_GPRS_INACTIVE;
        }
        else
        {
          SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH);
#endif
        }

        break;

      case KERN_GMM_NULL_PLMN_SEARCH:
      case KERN_GMM_NULL_IMSI:          
       
        if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class
        || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type)
        {
          SET_STATE ( KERN, KERN_GMM_NULL_PLMN_SEARCH);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_NULL_PLMN_SEARCH);
#endif
          mmgmm_plmn_res->reg_type = REG_GPRS_INACTIVE;
        }
        else
        {
          SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH);
#endif
          kern_gmmrr_enable();
        }

        break;

      case KERN_GMM_REG_NORMAL_SERVICE:

      case KERN_GMM_REG_NO_CELL_AVAILABLE:
      case KERN_GMM_REG_LIMITED_SERVICE:
      case KERN_GMM_RAU_INITIATED:
      case KERN_GMM_REG_INITIATED:
      case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
      case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:  
        break;
      case KERN_GMM_REG_SUSPENDING:
        /* 
         * not reachablebeause of save in pei 
         */
      case KERN_GMM_REG_SUSPENDED:
        /*
         * Attach requests in suspended mode will be handled after resumption
         * by triggering form GRR with GMMRR_CELL_IND
         */

        /*
         * The user is not allowed to change the mobile class or establish a 
         * voice call the same time manuall network search is started. it would 
         * not be nice
         */
        kern_resume_grr_reg();

        TRACE_ERROR("I hoped, that this never is happened, ...");
        break;
      default:
        TRACE_ERROR( "GMMREG_PLMN_RES unexpected" );
        break;
       
    }
      mmgmm_plmn_res->mobile_class=gmm_data->kern.attach_cap.mobile_class;  
    PSEND ( hCommMM, mmgmm_plmn_res );
  }
  GMM_RETURN;
} /* kern_gmmreg_plmn_res() */

/*
+------------------------------------------------------------------------------
| Function    : kern_gmmreg_plmn_mode_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMREG_PLMN_MODE_REQ
|
|          MSC: 3.20 MM Interface
|          MSC: 3.20.1 Change of PLMN Mode
|
| Parameters  : *gmmreg_plmn_mode_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmreg_plmn_mode_req ( T_GMMREG_PLMN_MODE_REQ *gmmreg_plmn_mode_req )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmreg_plmn_mode_req" );
  {
    PPASS ( gmmreg_plmn_mode_req, mmgmm_plmn_mode_req, MMGMM_PLMN_MODE_REQ );
      /* 
       * PATCH UBUOB 11.3.02: if we change from MANUAL to AUTOMATC or vice versa,
       * then we need to clear the limited_service flag
       * Problem was: Bouyg SIM, manual registration on SFR upon return to
       * auto mode, first GPRS ATTACH
       
      if (gmm_data->kern.attach_cap.network_selection_mode 
          != gmmreg_plmn_mode_req->net_selection_mode)
      {
         gmm_data->kern.sig_cell_info.mm_status = MMGMM_FULL_SERVICE;
         sig_kern_sync_set_mm_state(MMGMM_FULL_SERVICE);
      }
      */
      /*
       * PLMN mode set to manual mode with PLMN_RES only
        gmm_data->kern.attach_cap.network_selection_mode = 
        gmmreg_plmn_mode_req->net_selection_mode;
       */
     if (GMMREG_NET_SEL_MODE_AUTO == gmmreg_plmn_mode_req->net_selection_mode)
     {
       gmm_data->kern.attach_cap.network_selection_mode = 
         gmmreg_plmn_mode_req->net_selection_mode;
     }
     else
     {
      TRACE_0_INFO ("manual mode ignored. will be set with PLMN_RES");
     }

    PSEND ( hCommMM, mmgmm_plmn_mode_req );
  }
  GMM_RETURN;
} /* kern_gmmreg_plmn_mode_req () */

/*
+------------------------------------------------------------------------------
| Function    : kern_gmmreg_config_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMREG_CONFIG_REQ
|
| Parameters  : *gmmreg_config_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmreg_config_req ( T_GMMREG_CONFIG_REQ *gmmreg_config_req )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmreg_config_req" );
  gmm_data->config.cipher_on 
                  = gmmreg_config_req->cipher_on;
  PFREE (gmmreg_config_req);
  GMM_RETURN;
} /* kern_gmmreg_plmn_mode_req () */
/*
+------------------------------------------------------------------------------
| Function    : kern_gmmreg_detach_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMREG_DETACH_REQ
|
| Parameters  : *gmmreg_detach_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmreg_detach_req ( T_GMMREG_DETACH_REQ *gmmreg_detach_req )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmreg_detach_req" );

  /*
   * RAU may interrupt detach procedure, so we have to store the detach type
   */
  gmm_data->kern.detach_cap.detach_type=gmmreg_detach_req->detach_type;
  gmm_data->kern.detach_cap.gmmreg=TRUE;
  
  switch (gmmreg_detach_req->detach_type)
  {
    case GMMREG_DT_GPRS:
      switch(gmm_data->kern.attach_cap.attach_type)
      {
        case GMMREG_AT_GPRS:
        case GMMREG_AT_NOT_KNOWN:
          gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN;
          break;
        default:
        case GMMREG_AT_IMSI:
        case GMMREG_AT_COMB:
          gmm_data->kern.attach_cap.attach_type=GMMREG_AT_IMSI;
          break;
      }
      TRACE_EVENT ("Para: GPRS detach");
      break;
    case GMMREG_DT_IMSI:
      gmm_data->kern.attach_cap.attach_type=
        (GMMREG_CLASS_CC == gmm_data->kern.attach_cap.mobile_class?
            GMMREG_AT_NOT_KNOWN:
            GMMREG_AT_GPRS);
      TRACE_EVENT ("Para: IMSI detach");
      break;
    case GMMREG_DT_POWER_OFF:
      /*
       * TMSI reset to remove TMSI in GRR when gmmrr_assign_req will
       * be sent
       */
      gmm_data->tmsi = GMMRR_TMSI_INVALID;
      gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN;
      gmm_data->kern.attach_cap.network_selection_mode=MODE_AUTO;
      TRACE_EVENT ("Para: Power OFF");
      break;
    case GMMREG_DT_SOFT_OFF:
      /*
       * TMSI reset to remove TMSI in GRR when gmmrr_assign_req will
       * be sent
       */
      gmm_data->tmsi = GMMRR_TMSI_INVALID;
      gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN;
      TRACE_EVENT ("Para: Soft OFF");
      break;
    case GMMREG_DT_COMB:
      gmm_data->kern.attach_cap.service_mode=SERVICE_MODE_LIMITED;
      gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN;
      TRACE_EVENT ("Para: GMMREG_DT_COMB");
      break;
    case GMMREG_DT_SIM_REMOVED:
      gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN;
      TRACE_EVENT ("Para: GMMREG_DT_SIM_REMOVED");
      break;
    case GMMREG_DT_DISABLE_GPRS:
      TRACE_EVENT ("Para: GMMREG_DT_DISABLE_GPRS");
      break;
    case GMMREG_DT_LIMITED_SERVICE:
      gmm_data->kern.attach_cap.service_mode=SERVICE_MODE_LIMITED;
      TRACE_EVENT ("Para: GMMREG_DT_LIMITED_SERVICE");
      break;
    default:
      gmm_data->kern.attach_cap.attach_type=
        (GMMREG_CLASS_CG == gmm_data->kern.attach_cap.mobile_class?
            GMMREG_AT_NOT_KNOWN:
            GMMREG_AT_IMSI);
      vsi_o_ttrace(VSI_CALLER TC_ERROR,"Error: Unknown detach_type = %x", gmmreg_detach_req->detach_type);
    break;


  }

  gmm_data->kern.detach_cap.detach_type = gmmreg_detach_req->detach_type;  

  gmm_data->kern.detach_cap.gmmreg = TRUE;
  gmm_data->kern.attach_cap.gmmreg = FALSE;
#ifndef GMM_TCS4  
  gmm_data->kern.attach_cap.gmmsm  = FALSE;
#endif
  
  PFREE ( gmmreg_detach_req );

  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_REG_LIMITED_SERVICE:
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
    case KERN_GMM_REG_TEST_MODE:  
    case KERN_GMM_REG_TEST_MODE_NO_IMSI:  
      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_IMSI:
        case GMMREG_DT_COMB:
        case GMMREG_DT_SIM_REMOVED:
          SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED);
#endif
          kern_mm_imsi_detach();
          break;
        case GMMREG_DT_DISABLE_GPRS:
          kern_local_detach( GMMCS_INT_NOT_PRESENT, FALSE,
             GMM_LOCAL_DETACH_PROC_ENTER_NULL_IMSI); /* TCS 2.1 */
          break;
        case GMMREG_DT_GPRS:
          kern_local_detach( GMMCS_INT_NOT_PRESENT, FALSE,
             GMM_LOCAL_DETACH_PROC_ENTER_NULL_IMSI); /* TCS 2.1 */
          break;
        case GMMREG_DT_POWER_OFF:
          kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */
                GMM_LOCAL_DETACH_PROC_POWER_OFF);
          break;
        case GMMREG_DT_SOFT_OFF:
          kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */
                GMM_LOCAL_DETACH_PROC_SOFT_OFF);

          break;
        default:
          TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ");
          break;
      }
      break;
    case KERN_GMM_REG_INITIATED:
      /* 
       * This cause is abnormal, because the normal and not the local detach 
       * procedure is started on power off 
       *
       * MSC: 3.8.1.4.7 g) Power off
       * <R.GMM.AGABNORM.M.015>,
       * <R.GMM.AGABNORM.M.031>
       */
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
      kern_gmmrr_attach_finished();
      /* NO break;*/

    case KERN_GMM_REG_NORMAL_SERVICE:
      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_IMSI:
        case GMMREG_DT_COMB:
        case GMMREG_DT_SIM_REMOVED:
          switch (gmm_data->kern.sig_cell_info.net_mode)
          {
            case GMMRR_NET_MODE_I:
              kern_detach( );
              break;
            case GMMRR_NET_MODE_II:
              SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING);
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING);
#endif
              kern_llgmm_suspend(LLGMM_CALL);
              kern_gmmrr_suspend(GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_IMSI_DETACH);
              break;
            case GMMRR_NET_MODE_III:
              kern_detach( );
              break;
            default:
              TRACE_ERROR ("unknown net mode");
              break;
          }
          break;
        case GMMREG_DT_DISABLE_GPRS:
        case GMMREG_DT_GPRS:
        case GMMREG_DT_POWER_OFF:
        case GMMREG_DT_SOFT_OFF:
          kern_detach( );
          break;

        default:
          TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ");
          break;
      }
      break;
    
    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_DISABLE_GPRS:
          gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC;
          /* NO break */
        default:
          kern_detach( );
          break;
      }
      break;
 
    case KERN_GMM_REG_SUSPENDED:
      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_IMSI:
        case GMMREG_DT_COMB:
        case GMMREG_DT_SIM_REMOVED:
          kern_mm_imsi_detach();
          break;
        case GMMREG_DT_DISABLE_GPRS:
          gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC;
          /* NO break; */
        case GMMREG_DT_GPRS:
          /*
           * Wait untill GSM is finished
           */
          break;
        case GMMREG_DT_POWER_OFF:
          kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */
                GMM_LOCAL_DETACH_PROC_POWER_OFF);
          break;
        case GMMREG_DT_SOFT_OFF:
          kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */
                GMM_LOCAL_DETACH_PROC_SOFT_OFF);
          break;
       default:
          TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ");
          break;
      }
      break;
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_REG_RESUMING:
      TRACE_ERROR ("prim should be saved by pei");
      /* NO break */
    case KERN_GMM_REG_SUSPENDING:
      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_IMSI:
        case GMMREG_DT_COMB:
        case GMMREG_DT_SIM_REMOVED:
          gmm_data->kern.suspension_type |= GMM_SUSP_IMSI_DETACH;
          break;
        case GMMREG_DT_DISABLE_GPRS:
          gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC;
          /* NO break; */
        case GMMREG_DT_GPRS:
          /*
           * Wait untill GSM is finished
           */
          break;
        case GMMREG_DT_POWER_OFF:
        case GMMREG_DT_SOFT_OFF:
          SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED);
#endif
          kern_resume_grr_reg();
          break;
        default:
          TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ");
          break;
      }
      break;
  
    case KERN_GMM_NULL_NO_IMSI:
    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_IMSI:
        case GMMREG_DT_COMB:
          if ( GMM_MM_DEREG != GET_STATE(MM) )
          {
            kern_mm_imsi_detach();
            break;
          }
          /* else NO break;*/
        case GMMREG_DT_SIM_REMOVED:
        case GMMREG_DT_GPRS:
        {  
          PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF);
            gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type;
          PSEND ( hCommMMI, gmmreg_detach_cnf );  
          break;
        }
        case GMMREG_DT_POWER_OFF:
          SET_STATE ( KERN, KERN_GMM_NULL_NO_IMSI );
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI );
#endif
          /* NO break*/
        case GMMREG_DT_SOFT_OFF:
            kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, /* TCS 2.1 */
                  GET_STATE(MM)==GMM_MM_DEREG?
                    MMGMM_DETACH_DONE:
                    MMGMM_PERFORM_DETACH,
                    gmm_data->kern.detach_cap.detach_type);

          break;
        case GMMREG_DT_DISABLE_GPRS:
          gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC;
          {  
            PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF);
              gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type;
            PSEND ( hCommMMI, gmmreg_detach_cnf );  
          }
          break;

        default:
          TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ");
          break;
      }
      break;
 

    case KERN_GMM_NULL_IMSI:
    case KERN_GMM_NULL_PLMN_SEARCH:
    case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:
      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_IMSI:
        case GMMREG_DT_COMB:
          if ( GMM_MM_DEREG != GET_STATE(MM) )
          {
            kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, MMGMM_PERFORM_DETACH,
                                     GMMREG_DT_SIM_REMOVED); 

            break;
          }
          /* else NO break;*/
        case GMMREG_DT_GPRS:
        {  
          PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF);
            gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type;
          PSEND ( hCommMMI, gmmreg_detach_cnf );  
          break;
        }
        case GMMREG_DT_SOFT_OFF:
          SET_STATE ( KERN, KERN_GMM_NULL_IMSI );
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI );
#endif
          kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, /* TCS 2.1 */
                  GET_STATE(MM)==GMM_MM_DEREG?
                    MMGMM_DETACH_DONE:
                    MMGMM_PERFORM_DETACH,gmm_data->kern.detach_cap.detach_type);

          break;
        case GMMREG_DT_SIM_REMOVED:
        case GMMREG_DT_POWER_OFF:
          SET_STATE ( KERN, KERN_GMM_NULL_NO_IMSI );
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI );
#endif
          kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, /* TCS 2.1 */
                  GET_STATE(MM)==GMM_MM_DEREG?
                    MMGMM_DETACH_DONE:
                    MMGMM_PERFORM_DETACH,
                    gmm_data->kern.detach_cap.detach_type);

          break;
        case GMMREG_DT_DISABLE_GPRS:
          gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC;
          {  
            PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF);
              gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type;
            PSEND ( hCommMMI, gmmreg_detach_cnf );  
          }
          break;
        default:
          TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ");
          break;
      }
      break;

    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
      kern_gmmrr_attach_finished();
    
      /* NO break; */

    case KERN_GMM_DEREG_NO_IMSI:
    case KERN_GMM_DEREG_PLMN_SEARCH:
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_INITIATED:

    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_DEREG_SUSPENDING:
      
      switch ( gmm_data->kern.detach_cap.detach_type )
      {
        case GMMREG_DT_IMSI:
        case GMMREG_DT_COMB:
          if ( GMM_MM_DEREG != GET_STATE(MM) )
          {
            switch ( GET_STATE( KERN ) )
            {
              case KERN_GMM_DEREG_SUSPENDING:
                gmm_data->kern.suspension_type |= GMM_SUSP_IMSI_DETACH;
                break;
              default:
                kern_imsi_detach_der_susp ();
                break;
            }
          }
          /* NO break;*/
        case GMMREG_DT_GPRS:
        {  
          PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF);
            gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type;
          PSEND ( hCommMMI, gmmreg_detach_cnf );  
          break;
        }
        case GMMREG_DT_SOFT_OFF:
          kern_local_detach( GMMCS_POWER_OFF, FALSE, GMM_LOCAL_DETACH_PROC_SOFT_OFF); /* TCS 2.1 */
          break;
        case GMMREG_DT_POWER_OFF:
          kern_local_detach( GMMCS_POWER_OFF, FALSE, GMM_LOCAL_DETACH_PROC_POWER_OFF); /* TCS 2.1 */
          break;
        case GMMREG_DT_DISABLE_GPRS:
        case GMMREG_DT_SIM_REMOVED:
          kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, /* TCS 2.1 */
            GMM_LOCAL_DETACH_PROC_ENTER_DEREG );
          break;
        default:
          TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ");
          break;
      }
      break;

    case KERN_GMM_RAU_INITIATED:
    case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST:
      /*
       * DETACH whilst RAU
       */
      break;

    default:
      TRACE_ERROR( "GMMREG_DETACH_REQ unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_gmmreg_detach_req() */


/*
+------------------------------------------------------------------------------
| Function    : kern_gmmsms_reg_state_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMSMS_REG_STATE_REQ
|
|          MSC: 3.21 Interaction with SMS
|
| Parameters  : *gmmsms_reg_state_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmsms_reg_state_req ( T_GMMSMS_REG_STATE_REQ *gmmsms_reg_state_req )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmsms_reg_state_req" );

  PFREE (gmmsms_reg_state_req);
  {
    PALLOC ( gmmsms_reg_state_cnf, GMMSMS_REG_STATE_CNF );
    gmmsms_reg_state_cnf->radio_priority_level = 
      gmm_data->kern.attach_cap.sms_radio_priority_level;
    switch( GET_STATE( KERN ) )
    {
      case KERN_GMM_NULL_NO_IMSI:
      case KERN_GMM_NULL_IMSI:
      case KERN_GMM_DEREG_NO_IMSI:
      case KERN_GMM_REG_SUSPENDED:
      case KERN_GMM_REG_RESUMING:
      case KERN_GMM_DEREG_SUSPENDED:
      case KERN_GMM_DEREG_RESUMING:
      case KERN_GMM_DEREG_PLMN_SEARCH:
      case KERN_GMM_DEREG_LIMITED_SERVICE:
      case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
      case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
      case KERN_GMM_DEREG_INITIATED:
      case KERN_GMM_REG_INITIATED:
      case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
      case KERN_GMM_REG_NO_CELL_AVAILABLE:
      case KERN_GMM_REG_LIMITED_SERVICE:
      case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
      case KERN_GMM_RAU_INITIATED:
        
        gmmsms_reg_state_cnf->reg_state = SMS_RS_DEREGISTERED;
        break;
   
      case KERN_GMM_REG_NORMAL_SERVICE:
        
        gmmsms_reg_state_cnf->reg_state = SMS_RS_REGISTERED;
        break;
      default:
        TRACE_ERROR( "GMMSMS_REG_STATE_REQ unexpected" );
        break;
    }
    PSEND(hCommSMS,gmmsms_reg_state_cnf);
  }/* PALLOC*/
  GMM_RETURN;
} /* kern_gmmsms_reg_state_req() */



/*
+------------------------------------------------------------------------------
| Function    : kern_gmmrr_page_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_PAGE_IND
|
| Parameters  : *gmmrr_page_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmrr_page_ind ( T_GMMRR_PAGE_IND *gmmrr_page_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmrr_page_ind" );

  
  switch( GET_STATE( KERN ) )
  {
    /* 
     * case GMM-DEREG
     * If the MS is not GPRS attached when it receives a paging for
     * GPRS services, the MS shall ignore the paging.
     * <R.GMM.PAGNGPRS.M.17> 
     */
    case KERN_GMM_REG_NORMAL_SERVICE:
      switch ( gmmrr_page_ind->page_id )
      {
        case GMMRR_IMSI:
          TRACE_EVENT("paged with IMSI");
          PFREE ( gmmrr_page_ind );
          gmm_data->gu                        = GU2_NOT_UPDATED;
          kern_sim_del_locigprs ();
          kern_sim_gmm_update ();
          /*
           * <R.GMM.PGPIMSI.M.004>, <R.GMM.PGPIMSI.M.005>,
           * <R.GMM.PGPIMSI.M.008>
           */
          gmm_data->kern.detach_cap.detach_type = GMM_DT_RE_ATTACH;
          kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, /* TCS 2.1 */
          FALSE, GMM_LOCAL_DETACH_PROC_RE_ATTACH);
          /* 
           * goto LABEL ATTACH
           *
           * <R.GMM.PGPIMSI.M.009>
           * GMM-DEREG.NORMAL-SERVICE
           *
          kern_attach_reset();
          kern_attach();
           */
          break;
        case GMMRR_PTMSI:
          TRACE_EVENT("paged with P-TMSI");
          PFREE ( gmmrr_page_ind );
        {
          /* 
           * <R.GMM.PGPPTMS.M.007> 
           */
          PALLOC (llgmm_trigger_req, LLGMM_TRIGGER_REQ);
            llgmm_trigger_req->trigger_cause = LLGMM_TRICS_PAGE_RESPONSE;
          PSEND ( hCommLLC, llgmm_trigger_req );
          break;
        }
        default:
          PFREE ( gmmrr_page_ind );
          TRACE_ERROR( "IMSI or PTMSI page ID expected" );
          break;
      }
      break;
    default:
      PFREE ( gmmrr_page_ind );
      TRACE_ERROR( "GMMRR_PAGE_IND unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_gmmrr_page_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_gmmrr_cs_page_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_CS_PAGE_IND
|
| Parameters  : *gmmrr_cs_page_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmrr_cs_page_ind ( T_GMMRR_CS_PAGE_IND *gmmrr_cs_page_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmrr_cs_page_ind" );

  PFREE ( gmmrr_cs_page_ind );

  
  {
    PALLOC ( gmmrr_cs_page_res, GMMRR_CS_PAGE_RES );

    switch (gmm_data->kern.attach_cap.mobile_class)
    {
      case GMMRR_CLASS_CG:
        gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
        gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS;
        break;

/* PATCH JPS 26.10.02: with class BX, we can have BC in NMOIII */
      case GMMREG_CLASS_BG:
        if (GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode)
        {
          gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
          gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS;
          break;
        }
        /* NO break; */
      case GMMREG_CLASS_BC:
      case GMMREG_CLASS_B:
/* PATCH JPS 26.10.02 END */
        switch( GET_STATE( KERN ) )
        {
          case KERN_GMM_DEREG_RESUMING:
          case KERN_GMM_REG_RESUMING:
            TRACE_ERROR ("prim should be saved by pei");
            break;
          case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
            gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE;
            /* NO break;*/
          case KERN_GMM_DEREG_NO_IMSI:
          case KERN_GMM_DEREG_SUSPENDED:
          case KERN_GMM_DEREG_LIMITED_SERVICE:
          
          case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
          case KERN_GMM_DEREG_PLMN_SEARCH:
          case KERN_GMM_DEREG_INITIATED:
          case KERN_GMM_REG_INITIATED:
            if (GMM_MM_DEREG != GET_STATE(MM)
            &&  MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status
            )
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF;
              SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDED );
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDED );
#endif
            }
            else
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
            }             
            gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS;
            break;
          case KERN_GMM_REG_SUSPENDED:
          case KERN_GMM_REG_LIMITED_SERVICE:
          case KERN_GMM_REG_NO_CELL_AVAILABLE:
            if (GMM_MM_DEREG != GET_STATE(MM)
            && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status)              
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF;
              SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED );
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED );
#endif
              kern_llgmm_suspend(LLGMM_CALL);
            }
            else
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
            }              
            gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS;

            break;
          case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
            if (GMM_MM_DEREG != GET_STATE(MM)
            &&  MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status)
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF;
              gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE;
              SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED );
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED );
#endif
              kern_llgmm_suspend(LLGMM_CALL);
            }
            else
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
            }
            gmmrr_cs_page_res->susp_gprs = GMMRR_SUSP_GPRS;
            /*
             * kern_llgmm_unassign();
             */
            break;
          case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
            /* IOT: Combined RA/LA is accepted with network cause 16
             * MSC temporarily unavailable. MM state is reset to GMM_MM_DEREG
             * From the IOT, it was observed that after GMM moves to NMOII, MM
             * was able to perform LAU successfully, but not combined RAU. Hence
             * in this state we should be able to make and receive CS calls
             * Also network is able to reach us through paging */
            if (/*GMM_MM_DEREG != GET_STATE(MM)
            && */ MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status)
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF;
              gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE;
              SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED );
              kern_llgmm_suspend(LLGMM_CALL);
            }
            else
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
            }
            gmmrr_cs_page_res->susp_gprs = GMMRR_SUSP_GPRS;
            /*
             * kern_llgmm_unassign();
             */
            break;
          case KERN_GMM_RAU_INITIATED:
          case KERN_GMM_REG_NORMAL_SERVICE:
            if (GMM_MM_DEREG != GET_STATE(MM)
            && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status)
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF;
              SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED );
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED );
#endif
              kern_llgmm_suspend(LLGMM_CALL);
            }
            else
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
            }
            gmmrr_cs_page_res->susp_gprs = GMMRR_SUSP_GPRS;
            /*
             * kern_llgmm_unassign();
             */
            break;
          case KERN_GMM_NULL_IMSI:
            /*
             * in state KERN_GMM_NULL_IMSI MS is doing a GPRS detach
             * and GMM has informed MM to act as GSM only mobile but
             * before MM processes the message, GMM receives CS_PAGE_IND
             * GMM must reject the CS_PAGE as MM will take care of the
             * next CS_PAGE_IND after processing MMGMM_REG_REQ to act as
             * GSM only mobile. if GMM accepts the CS_PAGE, GRR will be
             * suspended and after coming out of dedicated mode MM will
             * not inform GMM about CS connection release and GRR will
             * not be resumed. This is to prevent such a race condition.
             */

            TRACE_EVENT("CS Call Received To GMM In GMM_NULL_IMSI state");
            gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
            gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS;
            break;
          case KERN_GMM_NULL_PLMN_SEARCH:
            if (GMM_MM_DEREG != GET_STATE(MM)
            && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status)
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF;
            }
            else
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
            }
            gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS;
            break;
          default:
            if (GMM_MM_DEREG != GET_STATE(MM)
            && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status)
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF;
            }
            else
            {
              gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ;
            }       
            gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS;
            TRACE_ERROR( "GMMRR_CS_PAGE_IND unexpected" );
            break;
        }  
        break;
      case GMMRR_CLASS_A:
      case GMMRR_CLASS_CC:
        gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF;
        gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; /* GMM1903A */
        break;
      default:
        TRACE_ERROR( "unknown MS class");
        break;
    }
    /* START PATCH UBUOB ISSUE 8379 */
    if (gmmrr_cs_page_res->response == GMMRR_CS_PAGE_CNF)
    {
      gmm_data->kern.gmmrr_resume_sent = FALSE;
    }
    /* END PATCH UBUOB ISSUES 8379 */
    PSEND ( hCommGRR, gmmrr_cs_page_res );
  }
  GMM_RETURN;
} /* kern_gmmrr_cs_page_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_gmmrr_cr_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_CR_IND
|
| Parameters  : *gmmrr_cr_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmrr_cr_ind ( T_GMMRR_CR_IND *gmmrr_cr_ind )
{     
  GMM_TRACE_FUNCTION( "kern_gmmrr_cr_ind" );

  PFREE ( gmmrr_cr_ind );
  if ( GMM_GRR_STATE_ON == gmm_data->kern.attach_cap.grr_state)
  /*
   * If GRR is suspended state should be kept.
   */
  {
    gmm_data->kern.attach_cap.grr_state = GMM_GRR_STATE_CR;
  }

  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_REG_INITIATED:
    case KERN_GMM_RAU_INITIATED:
      /*
       * store timer value to be able to restart timer after cell reselection
       */
      gmm_data->kern.attach_cap.t3310_value=0;
      if (VSI_OK == vsi_t_status ( GMM_handle , kern_T3310, &(gmm_data->kern.attach_cap.t3310_value))
      &&  gmm_data->kern.attach_cap.t3310_value>0)
      { 
        vsi_t_stop ( GMM_handle , kern_T3310);
      }
      
      TRACE_1_INFO ("TIMER t3310 = %dmsec stopped - waiting for CELL_IND",gmm_data->kern.attach_cap.t3310_value);
      break;
    default:
      break;
  }
  GMM_RETURN;
}/* kern_gmmrr_cr_ind */


/*
+------------------------------------------------------------------------------
| Function    : kern_cgrlc_status_ind (TCS 2.1)
+------------------------------------------------------------------------------
| Description : Handles the primitive CGRLC_STATUS_IND (TCS 2.1)
|
| Parameters  : *cgrlc_status_ind - Ptr to primitive payload (TCS 2.1)
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_cgrlc_status_ind ( T_CGRLC_STATUS_IND *cgrlc_status_ind ) /* TCS 2.1 */
{ 
  GMM_TRACE_FUNCTION( "kern_cgrlc_status_ind" ); /* TCS 2.1 */

  switch (cgrlc_status_ind->failure) /* TCS 2.1 */
  {
  case CGRLC_ACCESS_2_NETWORK_NOT_ALLOWED: /* TCS 2.1 */
    TRACE_EVENT ("Access to the network is not allowed");
    break;
  case CGRLC_PACKET_ACCESS_FAILURE: /* TCS 2.1 */
    TRACE_EVENT("Failure during packet access procedure, e.g. T3162 expired");
    break;
  case CGRLC_RLC_MAC_ERROR: /* TCS 2.1 */
    TRACE_EVENT("T3168 expires during contention resolution");
    break;
  case CGRLC_TLLI_MISMATCH: /* TCS 2.1 */
    TRACE_EVENT ("TLLI mismatch has occurred");
    break;
  case CGRLC_TBF_ESTABLISHMENT_FAILURE: /* TCS 2.1 */
    TRACE_EVENT ("T3164 expires or failure occurs due to any other reason");
    break;
  case CGRLC_RESUMPTION_FAILURE: /* TCS 2.1 */
    TRACE_EVENT ("resumption failure after dedicated mode was left");
    break;
  case CGRLC_CONTENTION_RESOLUTION_FAILED: /* TCS 2.1 */
    TRACE_EVENT ("Contantion Resolution has failed"); /* TCS 2.1 */
    break; /* TCS 2.1 */
  default:
    TRACE_ERROR ("unknown failure");
    break;
  }

  PFREE (cgrlc_status_ind); /* TCS 2.1 */
  
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_REG_INITIATED:
    case KERN_GMM_RAU_INITIATED:
      /************************************************************************
       * MSC: 3.8 Attach
       *
       * MSC: 3.8.1 Normal Attach
       * MSC: 3.8.1.4 Abnormal cases
       * MSC: 3.8.1.4.2 b) Lower layer failure before the ATTACH ACCEPT or
       *                   ATTACH REJECT 
       *                   message is received
       ************************************************************************
       *
       *<R.GMM.AGABNORM.M.004>, <R.GMM.LOWERFAIL.M.001>
       */
      kern_aac( /*llgmm_status_ind->error_cause*/ 0);
      break;
    case KERN_GMM_DEREG_INITIATED:
      /************************************************************************
       * MSC: 3.9 GPRS detach procedure
       *
       * MCS: 3.9.3 Abnormal cases
       * MSC: 3.9.3.2 b) Lower layer failure
       ************************************************************************/
      kern_local_detach ( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_DEREG); /* TCS 2.1 */
      break;
    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
      /* 
       * <R.GMM.DMABNORM.M.021> 
       */
      /************************************************************************
       * MSC: 3.9 GPRS detach procedure
       *
       * MCS: 3.9.3 Abnormal cases
       * MSC: 3.9.3.2 b) Lower layer failure
       ************************************************************************/
       gmm_data->kern.detach_cap.detach_type = GMMREG_DT_IMSI;
       kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_REG_NORMAL); /* TCS 2.1 */
       break;
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_REG_RESUMING:
    case KERN_GMM_REG_SUSPENDED:
      TRACE_ERROR( "CGRLC_STATUS_IND unexpected" ); /* TCS 2.1 */
      break;
    default:
      break;
  }
  GMM_RETURN;
} /* kern_cgrlc_status_ind() */ /* TCS 2.1 */
/*
+------------------------------------------------------------------------------
| Function    : kern_llgmm_status_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive LLGMM_STATUS_IND
|
| Parameters  : *llgmm_status_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_llgmm_status_ind ( T_LLGMM_STATUS_IND *llgmm_status_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_llgmm_status_ind" );

  PFREE (llgmm_status_ind);
  
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_REG_INITIATED:
    case KERN_GMM_RAU_INITIATED:
      /************************************************************************
       * MSC: 3.8 Attach
       *
       * MSC: 3.8.1 Normal Attach
       * MSC: 3.8.1.4 Abnormal cases
       * MSC: 3.8.1.4.2 b) Lower layer failure before the ATTACH ACCEPT or
       *                   ATTACH REJECT 
       *                   message is received
       ************************************************************************
       *
       *<R.GMM.AGABNORM.M.004>, <R.GMM.LOWERFAIL.M.001>
       */
      kern_aac( /*llgmm_status_ind->error_cause*/ GMMCS_NO_SERVICE); /* TCS 2.1 */
      break;
    case KERN_GMM_DEREG_INITIATED:
      /************************************************************************
       * MSC: 3.9 GPRS detach procedure
       *
       * MCS: 3.9.3 Abnormal cases
       * MSC: 3.9.3.2 b) Lower layer failure
       ************************************************************************/
       kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_DEREG); /* TCS 2.1 */
       break;
    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
      /* 
       * <R.GMM.DMABNORM.M.021> 
       */
      /************************************************************************
       * MSC: 3.9 GPRS detach procedure
       *
       * MCS: 3.9.3 Abnormal cases
       * MSC: 3.9.3.2 b) Lower layer failure
       ************************************************************************/
       gmm_data->kern.detach_cap.detach_type = GMMREG_DT_IMSI;
       kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_REG_NORMAL); /* TCS 2.1 */
      
       break;
    default:
      TRACE_ERROR( "LLGMM_STATUS_IND unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_llgmm_status_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_llgmm_tlli_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive LLGMM_TLLI_IND
|
| Parameters  : *llgmm_status_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_llgmm_tlli_ind ( T_LLGMM_TLLI_IND *llgmm_tlli_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_llgmm_tlli_ind" );
  TRACE_1_PARA ("TLLI: 0x%x", llgmm_tlli_ind->new_tlli);

  GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_TLLI);
  
  switch( GET_STATE( KERN ) )
  {
    default:
    case KERN_GMM_NULL_NO_IMSI:
    case KERN_GMM_NULL_IMSI:
    case KERN_GMM_NULL_PLMN_SEARCH:
    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
    case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:
      TRACE_ERROR("LLGMM_TLLI_IND unexpected");
      break;

    case KERN_GMM_DEREG_INITIATED:
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_DEREG_NO_IMSI:
    case KERN_GMM_DEREG_PLMN_SEARCH:
    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_REG_INITIATED:
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
    case KERN_GMM_REG_LIMITED_SERVICE:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
    case KERN_GMM_REG_SUSPENDED:
    case KERN_GMM_REG_NORMAL_SERVICE:
    case KERN_GMM_RAU_INITIATED:
    case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST:
    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
    case KERN_GMM_REG_RESUMING:
    case KERN_GMM_DEREG_SUSPENDING:
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_REG_SUSPENDING:
    case KERN_GMM_REG_TEST_MODE:
    case KERN_GMM_REG_TEST_MODE_NO_IMSI:

      if ( llgmm_tlli_ind->new_tlli != gmm_data->tlli.current)
      {
         TRACE_ERROR("TLLI value not expected");
      }
      
      TRACE_0_OUT_PARA("Unassign Old PTMSI");
        
      gmm_data->tlli.old  = GMMRR_TLLI_INVALID;
      gmm_data->ptmsi.old = GMMRR_TMSI_INVALID;
  
      GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_TLLI | GMM_DEBUG_PRINT_MASK_PTMSI);
      /*
       * LLC should know about unassigning itself
       */
      kern_gmmrr_assign();
      break;
  }

  PFREE (llgmm_tlli_ind);

  GMM_RETURN;
} /* kern_llgmm_tlli_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_sim_gmm_insert_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive SIM_GMM_INSERT_IND
|      
|               MSC: 3.2   SIM
|
| Parameters  : *sim_gmm_insert_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_sim_gmm_insert_ind ( T_SIM_GMM_INSERT_IND *sim_gmm_insert_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_sim_gmm_insert_ind" );
  /*
   * Set IMSI
   */

  kern_read_imsi ( sim_gmm_insert_ind ) ;

  GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_IMSI);

  kern_read_loc_info (sim_gmm_insert_ind);

  GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_CID);
  GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_KERN_ATTACH);

  gmm_data->acc_contr_class = sim_gmm_insert_ind->acc_ctrl.acc[0] * 256 +
                               sim_gmm_insert_ind->acc_ctrl.acc[1];
  gmm_data->kern.sim_op_mode = sim_gmm_insert_ind->op_mode;
  kern_read_kc_cksn   (sim_gmm_insert_ind);

  PFREE ( sim_gmm_insert_ind );

  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_NULL_NO_IMSI:
    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
    case KERN_GMM_DEREG_NO_IMSI:
      /*
       *  MSC: 3.2   SIM
       *
       *  MSC: 3.2.1 SIM is inserted and valid
       */
      /*
       * SIM is considered as invalid until SIM removed or switching off
       */
      gmm_data->sim_gprs_invalid = FALSE;
      /*
       * reset the attach attampt counter and the rau attempt counter
       * <R.GMM.ATTACH.M.007>
       */
      gmm_data->kern.aac = 0;

      switch( GET_STATE( KERN ) )
      {
        case KERN_GMM_NULL_NO_IMSI:
          /* 
           * <R.GMM.DOTHCASE.M.001>
           * SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH );
           *
           * state GMM-DEREGISTERED.IMSI discribes the state GMM-NULL.IMSI-VALID
           */
       
          SET_STATE ( KERN, KERN_GMM_NULL_IMSI );
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI );
#endif
          break;
        case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
          SET_STATE (KERN, KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
#endif
          break;
        case KERN_GMM_DEREG_NO_IMSI:
          /*
           * GMM enters state NULL_IMSI beause GMM is waiting for a new attach 
           * prim from GACI (COPS=0)
           */
          SET_STATE ( KERN, KERN_GMM_NULL_IMSI );
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI );
#endif
          break;
        default:
          TRACE_ERROR( "State unexpected" );
          break;
      }
      break;
    default:
      TRACE_ERROR( "SIM_GMM_INSERT_IND unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_sim_gmm_insert_ind() */



/*
+------------------------------------------------------------------------------
| Function    : kern_sim_remove_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive SIM_REMOVE_IND
|
| Parameters  : *sim_remove_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_sim_remove_ind ( T_SIM_REMOVE_IND *sim_remove_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_sim_remove_ind" );

  PFREE ( sim_remove_ind );

  gmm_data->sim_gprs_invalid = TRUE;
  gmm_data->kern.detach_cap.detach_type = GMMREG_DT_SIM_REMOVED;
  /*
   * multiple outstanding SIM_AUTHENTICATION_REQ messages reset the 
   * counter whenever SIM is removed
   */
  gmm_data->kern.auth_cap.last_auth_req_id = NOT_PRESENT_8BIT;
  
  switch( GET_STATE( KERN ) )
  {
    /*
     * MSC: 3.2 SIM
     *
     * MSC: 3.2.2. No SIM present or SIM not valid
     * MSC: 3.2.2.2 State GMM-REG
     */

    /*
     * MSC: 3.2.2.2.1 Network not reachable
     * state GMM_REG
     */
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_REG_RESUMING:
    case KERN_GMM_REG_SUSPENDED:
      if (GMM_GRR_STATE_SUSPENDED==gmm_data->kern.attach_cap.grr_state)
      /*
       * wait for MMGMM_CM_RELEASE_IND
       */
      {
        break;
      }
      /* NO break;*/
    case KERN_GMM_REG_LIMITED_SERVICE:
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
    {
      kern_local_detach (GMMCS_SIM_REMOVED, FALSE,GMM_LOCAL_DETACH_PROC_SIM_REMOVED); /* TCS 2.1 */
      break;
    }
    case KERN_GMM_REG_TEST_MODE:  
      {
        PALLOC (cgrlc_test_end_req, CGRLC_TEST_END_REQ); /* TCS 2.1 */
        SET_STATE (KERN, KERN_GMM_REG_TEST_MODE_NO_IMSI);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_REG_TEST_MODE_NO_IMSI);
#endif
        PSEND (hCommGRLC, cgrlc_test_end_req); /* TCS 2.1 */
       }
      break;
    /*
     * MSC: 3.2.2.2.2 Network reachable
     * state GMM_REG.NORMAL_SERVICE
     */
    case KERN_GMM_RAU_INITIATED:
    case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
    case KERN_GMM_REG_NORMAL_SERVICE:
      /*
       * <R.GMM.DSUBFANO.M.003>
       */
 
      kern_detach ();
      break;
    /*
     * MSC: 3.2 SIM
     *
     * MSC: 3.2.2. No SIM present or SIM not valid
     * MSC: 3.2.2.1 State GMM-DEREG
     */

    /*
     * state GMM_DEREG
     */
    case KERN_GMM_DEREG_PLMN_SEARCH:
    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
    case KERN_GMM_REG_INITIATED:
    case KERN_GMM_DEREG_INITIATED:

      kern_mm_imsi_detach_ind ( GMMCS_SIM_REMOVED, MMGMM_PERFORM_DETACH,
                                gmm_data->kern.detach_cap.detach_type); /* TCS 2.1 */
      /*
       * <R.GMM.ODNOIMSI.M.001>
       */
      SET_STATE ( KERN, KERN_GMM_DEREG_NO_IMSI );
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI );
#endif
      break;
    
    case KERN_GMM_NULL_IMSI:
    
      kern_mm_imsi_detach_ind ( GMMCS_SIM_REMOVED, MMGMM_PERFORM_DETACH,
                                gmm_data->kern.detach_cap.detach_type  );  /* TCS 2.1 */
      /*
       * <R.GMM.ODNOIMSI.M.001>
       */
      SET_STATE ( KERN, KERN_GMM_NULL_NO_IMSI );
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI );
#endif
      break;

    default:
      kern_mm_imsi_detach_ind ( GMMCS_SIM_REMOVED, MMGMM_PERFORM_DETACH,
                                gmm_data->kern.detach_cap.detach_type); /* TCS 2.1 */
      TRACE_ERROR( "SIM_REMOVE_IND unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_sim_remove_ind() */


/*
+------------------------------------------------------------------------------
| Function    : kern_gmmrr_suspend_cnf
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_SUSPEND_CNF
|
|               GRR confirms that GRR is successful suspended and RR is
|               activated.
|
| Parameters  : *gmmrr_suspend_cnf - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmrr_suspend_cnf ( T_GMMRR_SUSPEND_CNF *gmmrr_suspend_cnf )
{ 
  GMM_TRACE_FUNCTION( "kern_gmmrr_suspend_cnf" );
  PFREE(gmmrr_suspend_cnf);
  gmm_data->kern.attach_cap.grr_state = GMM_GRR_STATE_SUSPENDED;

  TRACE_1_PARA ("susp_type: %x", gmm_data->kern.suspension_type);
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_DEREG_SUSPENDING:
      SET_STATE (KERN, KERN_GMM_DEREG_SUSPENDED);
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDED);
#endif
     if(gmm_data->kern.detach_cap.detach_type EQ GMMREG_DT_GPRS)
     	{
        if ( GET_STATE(MM) != GMM_MM_REG_NORMAL_SERVICE)
            /*
                      * The state of MM is forwarded to MMI 
                      */
            {
              gmm_data->kern.detach_cap.detach_type = GMMREG_DT_COMB;  
            }
            if ( kern_lau_needed())
            {
              /* 
                          * see also kern_enter_der ()
                          */
              kern_gmmreg_detach (gmm_data->kern.detach_cap.detach_type, GMMCS_INT_NOT_PRESENT,
                                GMMREG_SEARCH_RUNNING, GMMCS_INT_NOT_PRESENT);
            }
            else
            {
              kern_gmmreg_detach (gmm_data->kern.detach_cap.detach_type, GMMCS_INT_NOT_PRESENT,
                                GMMREG_SEARCH_NOT_RUNNING,GMMCS_INT_NOT_PRESENT);
            }
     	}

      kern_call_undone_mm_proc_der();
      break;

    case KERN_GMM_REG_SUSPENDING:
      SET_STATE (KERN, KERN_GMM_REG_SUSPENDED);
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED);
#endif
      kern_call_undone_mm_proc_reg();
      break;

    case KERN_GMM_NULL_NO_IMSI:
      kern_local_detach ( GMMCS_POWER_OFF,    /* TCS 2.1 */
        FALSE, GMM_LOCAL_DETACH_PROC_NOTHING);
      break;
    default:
      TRACE_ERROR( "GMMRR_SUSPNED_CNF unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_gmmrr_suspend_cnf() */
/*
+------------------------------------------------------------------------------
| Function    : kern_cgrlc_test_mode_cnf (TCS 2.1)
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_SUSPEND_CNF
|
|               GRR confirms that the test mode is finished
|
| Parameters  : *cgrlc_test_mode_cnf - Ptr to primitive payload (TCS 2.1)
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_cgrlc_test_mode_cnf ( T_CGRLC_TEST_MODE_CNF *cgrlc_test_mode_cnf ) /* TCS 2.1 */
{ 
  GMM_TRACE_FUNCTION( "kern_cgrlc_test_mode_cnf" ); /* TCS 2.1 */
  PFREE (cgrlc_test_mode_cnf); /* TCS 2.1 */

  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_REG_TEST_MODE:
      kern_enter_reg_normal();
      break;
    case KERN_GMM_REG_TEST_MODE_NO_IMSI:
      /*
       * <R.GMM.DSUBFANO.M.003>
       */

      gmm_data->kern.detach_cap.detach_type = GMMREG_DT_SIM_REMOVED;
      kern_detach ();
      break;
    default:
      TRACE_ERROR( "CGRLC_TEST_MODE_CNF unexpected" ); /* TCS 2.1 */
      break;
  }
  GMM_RETURN;
} /* kern_cgrlc_test_mode_cnf() */ /* TCS 2.1 */

/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_lup_needed_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_LUP_NEEDED_IND
|
|          MSC: 3.20.8 MMGMM LUP NEEDED IND
|
| Parameters  : *mmgmm_lup_needed_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_lup_needed_ind ( T_MMGMM_LUP_NEEDED_IND *mmgmm_lup_needed_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_lup_needed_ind" );
#ifndef NTRACE
  switch (mmgmm_lup_needed_ind->reason) /* TCS 2.1 */
  {
    case MMGMM_T3212:
      TRACE_EVENT("T3212 has expired");
      break;
    case MMGMM_T_ACCEPT:
      TRACE_EVENT("T_ACCEPT has expired");
      break;
    case MMGMM_IMSI_IN_VLR:
      TRACE_EVENT("IMSI unknown in VLR received");
      break;
    case MMGMM_RXLEV_JUMP:
      TRACE_EVENT("RR indicated an increased RX level");
      break;
    case MMGMM_REG_TIMER:
      TRACE_EVENT("Registration timer in MM expired");
      break;
    default:
      TRACE_ERROR("GPRS indicator is out of range");
      break;
  }
#endif
  switch (GET_STATE( KERN ))
  {
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_NULL_NO_IMSI:
    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
    case KERN_GMM_NULL_IMSI:
    case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:
    case KERN_GMM_DEREG_INITIATED:
    case KERN_GMM_DEREG_NO_IMSI:
    case KERN_GMM_DEREG_PLMN_SEARCH:    
    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_DEREG_SUSPENDING:
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
      break;
    default:
      if( GMMRR_NET_MODE_I==gmm_data->kern.sig_cell_info.net_mode
      &&  MMGMM_T3212==mmgmm_lup_needed_ind->reason) /* TCS 2.1 */
      /*
       * <R.GMM.MMGMMONE.M.002>, <R.GMM.MMGMMONE.M.003>
       */
      {
        PFREE (mmgmm_lup_needed_ind);
        GMM_RETURN;  
      }
      break;
  }


  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_NULL_NO_IMSI:
    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
    case KERN_GMM_NULL_IMSI:
    case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:
      /*
       * After deregistration MM will receive mmgmm_reg_req
       * automatically
       */
      break;
    case KERN_GMM_DEREG_NO_IMSI:
      /* PLU also if #7 */
      /*NO break;*/
    case KERN_GMM_DEREG_PLMN_SEARCH:    

    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_REG_INITIATED:
      SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING );
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING );
#endif
      kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);  
      break;

    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
      gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE;
      SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING );
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING );
#endif
      kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);  
      break;
    case KERN_GMM_DEREG_INITIATED:
    case KERN_GMM_DEREG_RESUMING:      
    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_REG_SUSPENDED:
    case KERN_GMM_REG_RESUMING:
    case KERN_GMM_RAU_INITIATED:
    case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST:
    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
      SET_STATE(MM, GMM_MM_REG_UPDATE_NEEDED);
      break;
      
    case KERN_GMM_REG_SUSPENDING:
    case KERN_GMM_DEREG_SUSPENDING:
      gmm_data->kern.suspension_type |= GMM_SUSP_LAU;
      break;

    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
      gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=TRUE;
      SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING );
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING );
#endif
      kern_llgmm_suspend(LLGMM_CALL);
      kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);  
      break;
    case KERN_GMM_REG_LIMITED_SERVICE:
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
      if(gmm_data->kern.gmmrr_resume_sent)
      /*
       * GMM is waiting for GMMRR_CELL_IND. So I rememmber to attach MM with
       * seting mm_imsi_attached to update_needed
       */
      {
        SET_STATE(MM,GMM_MM_REG_UPDATE_NEEDED);        
      }
      else
      {
        SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING );
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING );
#endif
        kern_llgmm_suspend(LLGMM_CALL);
        kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);  
      }
      break;
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_REG_NORMAL_SERVICE:
      if( GMMRR_NET_MODE_I==gmm_data->kern.sig_cell_info.net_mode)
      {
        kern_rau();
      }
      else
      {
        SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING );
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING );
#endif
        kern_llgmm_suspend(LLGMM_CALL);
        kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);  
      }
      break;
    case KERN_GMM_REG_TEST_MODE_NO_IMSI:
    case KERN_GMM_REG_TEST_MODE:
      break;
    default:
      TRACE_ERROR ("Unexpexcted state");   
      break;
  }
  
  PFREE (mmgmm_lup_needed_ind);
  GMM_RETURN;  
} /* kern_mmgmm_lup_needed_ind() */


/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_lup_accept_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_LUP_ACCEPT_IND
|
|          MSC: 3.20.3 IMSI attach/detach
|
| Parameters  : *mmgmm_lup_accept_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_lup_accept_ind ( T_MMGMM_LUP_ACCEPT_IND *mmgmm_lup_accept_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_lup_accept_ind" );
 
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_NULL_PLMN_SEARCH:
    case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:
    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
    case KERN_GMM_NULL_NO_IMSI:
    
    case KERN_GMM_NULL_IMSI:
    case KERN_GMM_DEREG_NO_IMSI:
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_PLMN_SEARCH:
    case KERN_GMM_REG_INITIATED:

    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_DEREG_SUSPENDING:
      if ( GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode
      && GMMREG_CLASS_BC==  gmm_data->kern.attach_cap.mobile_class )
      {
        kern_mmgmmreg_attach_cnf (GMMREG_AT_IMSI, SEARCH_NOT_RUNNING, (T_MMGMM_REG_CNF*)mmgmm_lup_accept_ind);
      }
      else
      {
        kern_mmgmmreg_attach_cnf (GMMREG_AT_IMSI, SEARCH_RUNNING, (T_MMGMM_REG_CNF*)mmgmm_lup_accept_ind);
      }
      break;                                      
    case KERN_GMM_REG_NORMAL_SERVICE:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
    case KERN_GMM_REG_LIMITED_SERVICE:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_DEREG_INITIATED:
    case KERN_GMM_RAU_INITIATED:

    case KERN_GMM_REG_RESUMING:
    case KERN_GMM_REG_SUSPENDED:
      kern_mmgmmreg_attach_cnf (GMMREG_AT_COMB, SEARCH_RUNNING, (T_MMGMM_REG_CNF*)mmgmm_lup_accept_ind);
      break;
    default:
      TRACE_ERROR ("Unexpexcted state");   
      break;
  }
  PFREE ( mmgmm_lup_accept_ind );
  GMM_RETURN;  
} /* kern_mmgmm_lup_accept_ind() */
/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_lup_accept_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_INFO_IND
|
|          MSC: 3.20.6 MM Information
|
| Parameters  : *mmgmm_info_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_info_ind ( T_MMGMM_INFO_IND *mmgmm_info_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_info_ind" );
  {
    PPASS (mmgmm_info_ind, gmmreg_info_ind, GMMREG_INFO_IND);
    PSEND ( hCommMMI, gmmreg_info_ind );
  }  
  GMM_RETURN;
} /* kern_mmgmm_info_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_sim_authentication_cnf
+------------------------------------------------------------------------------
| Description : The function kern_sim_authentication_cnf
|       
| Parameters  : *sim_authentication_cnf - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_sim_authentication_cnf ( T_SIM_AUTHENTICATION_CNF *
                                        sim_authentication_cnf )
{ 
  GMM_TRACE_FUNCTION( "kern_sim_authentication_cnf" );
  
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_REG_NORMAL_SERVICE:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
    case KERN_GMM_REG_NO_CELL_AVAILABLE: 
    case KERN_GMM_REG_LIMITED_SERVICE: 
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_REG_INITIATED:
    case KERN_GMM_DEREG_INITIATED:
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
    case KERN_GMM_RAU_INITIATED:
    case KERN_GMM_REG_IMSI_DETACH_INITIATED: 
      /*
       * PATCH ubuob 19.7.02: multiple outstanding AUTHENTICATION REQ messages
       * reduce the count of outstanding requests
       */

      /*
       * only use this SIM answer if there are no other outstanding SIM_AUTHENTICATION_REQ messages!
       */

      if (gmm_data->kern.auth_cap.last_auth_req_id == sim_authentication_cnf->req_id)


      if (gmm_data->kern.auth_cap.last_auth_req_id == sim_authentication_cnf->req_id)
      {
         MCAST (authentication_and_ciphering_response,
          AUTHENTICATION_AND_CIPHERING_RESPONSE);
            authentication_and_ciphering_response->a_c_reference_number
            .a_c_reference_number_value 
            = gmm_data->kern.auth_cap.a_c_reference_number;
        
          authentication_and_ciphering_response
           ->v_authentication_parameter_sres = TRUE;
          authentication_and_ciphering_response
            ->authentication_parameter_sres.sres_value.l_sres_value = MAX_SRES*8;
          authentication_and_ciphering_response
            ->authentication_parameter_sres.sres_value.o_sres_value = 0;
          memcpy (authentication_and_ciphering_response->
            authentication_parameter_sres.sres_value.b_sres_value, 
            sim_authentication_cnf->sres, MAX_SRES);  
        
          memcpy ( gmm_data->kern.auth_cap.kc, sim_authentication_cnf->kc,
            MAX_KC ) ;
        
#ifdef GMM_TCS4
        gmm_data->kern.auth_cap.last_auth_req_id = NOT_PRESENT_8BIT;
#endif
          
        PFREE (sim_authentication_cnf);
        /*
         * <R.GMM.AUTH_RES.M.006>
         */
        {
          PALLOC ( llgmm_assign_req, LLGMM_ASSIGN_REQ );
            llgmm_assign_req->old_tlli = LLGMM_TLLI_INVALID;
            llgmm_assign_req->new_tlli = gmm_data->tlli.current;
            if (NO_KEY== gmm_data->kern.auth_cap.cksn)
            {
              memset (llgmm_assign_req->llgmm_kc.key, 0x0, MAX_KC);
            }
            else
            {
              memcpy ( llgmm_assign_req->llgmm_kc.key, gmm_data->kern.auth_cap.kc, MAX_KC );
            }
            llgmm_assign_req->ciphering_algorithm 
              = gmm_data->kern.auth_cap.ciphering_algorithm;
      
          PSEND ( hCommLLC, llgmm_assign_req );
        }
        
        
        if (IMEISV_REQUESTED == gmm_data->kern.auth_cap.imeisv_requested)
        {
          authentication_and_ciphering_response->v_gmobile_identity = TRUE;
          kern_get_imeisv (
            &authentication_and_ciphering_response->gmobile_identity);
        }
        else
        {
          authentication_and_ciphering_response->v_gmobile_identity = FALSE;     
        }
        sig_kern_tx_data_req (CURRENT_TLLI,AUTHENTICATION_AND_CIPHERING_RESPONSE);
      }
      else
      {  
        PFREE (sim_authentication_cnf);
         /* 
          * mutliple  authentication request problem occurred!!!!
          * ignore this SIM answer because another request has already been sent to
          * the SIM again and this overwrote the A&C reference number
          */
         TRACE_0_INFO ("error: Authentication received twice, SIM ignored");
      }
      /* end patch ubuob */
      break;

    default:

      PFREE (sim_authentication_cnf);
      TRACE_1_INFO ("state: %x", GET_STATE( KERN ));
      TRACE_ERROR("A&C RES unexpected");
      break;
  }
  GMM_RETURN;    
} /* kern_sim_authentication_cnf() */


/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_nreg_cnf
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_NREG_CNF
|
|          MSC: 3.20.3 IMSI attach/detach
|
| Parameters  : *mmgmm_nreg_cnf - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_nreg_cnf ( T_MMGMM_NREG_CNF *mmgmm_nreg_cnf )
{ 
  UBYTE detach_type;
  GMM_TRACE_FUNCTION( "kern_mmgmm_nreg_cnf" );

  if (gmm_data->kern.attach_cap.mobile_class_changed
  && GMM_GRR_STATE_ON == gmm_data->kern.attach_cap.grr_state)
  {
    gmm_data->kern.attach_cap.mobile_class_changed=FALSE;
    kern_gmmrr_enable();
  }

  switch (mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */
  {
    case CS_SIM_REM:
      detach_type = GMMREG_DT_SIM_REMOVED;
      TRACE_EVENT ("SIM is removed");
      break;
    case CS_POW_OFF:
      detach_type = GMMREG_DT_POWER_OFF;
      TRACE_EVENT ("Power is switched off");
      break;
    case CS_SOFT_OFF:
      detach_type = GMMREG_DT_SOFT_OFF;
      TRACE_EVENT ("Power is soft switched off");
      break;      
    case CS_DISABLE:
      detach_type = GMMREG_DT_IMSI;
      TRACE_EVENT ("GSM switched off");
      break;
    default:
      detach_type = GMMREG_DT_POWER_OFF;
      TRACE_EVENT ("unknown detach type in MMGMM_NREG_CNF");
      break;
  }
  SET_STATE( MM, GMM_MM_DEREG );
  sig_kern_sync_set_mm_state(MMGMM_CELL_SELECTED);

  if (gmm_data->sim_gprs_invalid && gmm_data->kern.cell_id.lac  == GMMREG_LA_INVALID && mmgmm_nreg_cnf->detach_cause == CS_SIM_REM)
  {
      switch ( GET_STATE (KERN) )
      {
          case KERN_GMM_DEREG_PLMN_SEARCH:
          case KERN_GMM_DEREG_SUSPENDED:
             SET_STATE(KERN,KERN_GMM_DEREG_NO_IMSI);
#ifdef FF_EM_MODE
             EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI);
#endif
             break;
          case KERN_GMM_REG_IMSI_DETACH_INITIATED:
             kern_enter_reg_normal();
             break;
          case KERN_GMM_DEREG_NO_IMSI:
             SET_STATE(KERN,KERN_GMM_NULL_NO_IMSI);
#ifdef FF_EM_MODE
             EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI);
#endif
             break;
          default:
              break;
      }
      PFREE ( mmgmm_nreg_cnf );
      GMM_RETURN;
  }
  switch ( GET_STATE (KERN) )
  {
    case KERN_GMM_DEREG_PLMN_SEARCH:
      switch(mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */
      {
        case CS_SOFT_OFF:
        case CS_POW_OFF:
          kern_gmmreg_detach (GMMREG_DT_POWER_OFF,
                              GMMCS_POWER_OFF, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_POWER_OFF);
          break;
        case CS_SIM_REM:
          SET_STATE(KERN,KERN_GMM_DEREG_NO_IMSI);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI);
#endif
          kern_gmmreg_detach (GMMREG_DT_SIM_REMOVED,
                              GMMCS_SIM_REMOVED, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_SIM_REMOVED);
          break;
        default:
          kern_gmmreg_detach (GMMREG_DT_COMB,
                              /* START UBUOB PATCH ISSUE 8381 */
                              GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */
                              /* END UBUOB PATCH ISSUE 8381 */
                              SEARCH_RUNNING,
                              GMMCS_NET_CAUSE_NOT_PRESENT);
          kern_mm_activate_rr();
          break;
      }

      break;

    case KERN_GMM_NULL_NO_IMSI:
    case KERN_GMM_NULL_IMSI:
      /*
       * POWER OFF
       */
      if( CS_DISABLE==mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */
      {
        detach_type=GMMREG_DT_IMSI;
      }
      kern_gmmreg_detach (detach_type,
                              gmm_data->kern.detach_cap.error_cause, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              gmm_data->kern.detach_cap.error_cause);                          
          
      break;
    case KERN_GMM_DEREG_SUSPENDED:
      switch(mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */
      {
        case CS_SOFT_OFF:
          kern_gmmreg_detach (GMMREG_DT_SOFT_OFF,
                              GMMCS_POWER_OFF, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_POWER_OFF);
          break;
        case CS_POW_OFF:
          kern_gmmreg_detach (GMMREG_DT_POWER_OFF,
                              GMMCS_POWER_OFF, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_POWER_OFF);
          break;
        case CS_SIM_REM:
          SET_STATE(KERN,KERN_GMM_DEREG_NO_IMSI);
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI);
#endif
          kern_gmmreg_detach (GMMREG_DT_SIM_REMOVED,
                              GMMCS_SIM_REMOVED, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_SIM_REMOVED);
          break;
        default:
          /* ACI can not handle SEARCH RUNNING to show GSM detached */
          if (GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode
          && GMMREG_CLASS_BG==  gmm_data->kern.attach_cap.mobile_class )
          {
            kern_gmmreg_detach (GMMREG_DT_COMB,
                              GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */
                              SEARCH_RUNNING,
                              GMMCS_NET_CAUSE_NOT_PRESENT);
          }
          else
          { 
            kern_gmmreg_detach (GMMREG_DT_COMB,
                              GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_NET_CAUSE_NOT_PRESENT);
          }
          break;
      }
      kern_call_undone_mm_proc_der();
      break;
    case KERN_GMM_REG_SUSPENDED:
      switch(mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */
      {
        case CS_SOFT_OFF:
             kern_gmmreg_detach (GMMREG_DT_SOFT_OFF,
                              GMMCS_POWER_OFF, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_POWER_OFF);
          break;
        case CS_POW_OFF:
          kern_gmmreg_detach (GMMREG_DT_POWER_OFF,
                              GMMCS_POWER_OFF, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_POWER_OFF);
          break;
        case CS_DISABLE:
          if (GMMREG_DT_IMSI == gmm_data->kern.detach_cap.detach_type)
          {
             kern_gmmreg_detach (GMMREG_DT_IMSI,
                              GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_NET_CAUSE_NOT_PRESENT);
             break;
          }
          /*
           * else: wait for gprs detach to be finished
           * FALLTHROUGH
           */
        case CS_SIM_REM:
          if (GMMRR_NET_MODE_III!=gmm_data->kern.sig_cell_info.net_mode)
          {

            /*
             * Wait until GPRS is deregistered
             */
            break;
          }
          /*
           * else NO break;
           * we are ms class BG and have switched off GSM
           */
        default:
          kern_gmmreg_detach (GMMREG_DT_IMSI,
                              GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */
                              SEARCH_NOT_RUNNING,
                              GMMCS_NET_CAUSE_NOT_PRESENT);
          break;
      }
      kern_call_undone_mm_proc_reg();
      break;
    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
       kern_enter_reg_normal();
      if(GMMRR_NET_MODE_I!=gmm_data->kern.sig_cell_info.net_mode)
      /*
       * In NMO I gmmreg_detach_cnf was sent before requesting 
       * mmgmm_net_req
       */
      {
        kern_gmmreg_detach (detach_type,
                            GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */
                            GMMREG_SEARCH_NOT_RUNNING,
                            GMMCS_NET_CAUSE_NOT_PRESENT);
      }
      break;
    case KERN_GMM_REG_NORMAL_SERVICE:
      break;
    case KERN_GMM_DEREG_NO_IMSI:
      SET_STATE(KERN,KERN_GMM_NULL_NO_IMSI);
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI);
#endif
      kern_gmmreg_detach (detach_type,
                      GMMCS_INT_NOT_PRESENT, /* TCS 2.1 */
                      GMMREG_SEARCH_NOT_RUNNING,
                      GMMCS_INT_NOT_PRESENT);            
      break;
    default:
        TRACE_ERROR( "MMGMM_NREG_CNF unexpected" );
      break;
  } 
  PFREE ( mmgmm_nreg_cnf );

#ifdef TRACE_FUNC  
#ifdef IDENTATION
  if (gmm_data->deep<=0) {
    /*
     * after power off deep is set to 0 in kern_init so we need here normal 
     * return
     */
    return;
  } 
  else
  {
    GMM_RETURN;
  }
#endif
#endif
} /* kern_mmgmm_nreg_cnf() */

/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_auth_rej_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_AUTH_REJ_IND
|
| Parameters  : *mmgmm_auth_rej_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_auth_rej_ind ( T_MMGMM_AUTH_REJ_IND *mmgmm_auth_rej_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_auth_rej_ind" );
  PFREE (mmgmm_auth_rej_ind);

  gmm_data->sim_gprs_invalid = TRUE;
  gmm_data->kern.detach_cap.detach_type = GMMREG_DT_SIM_REMOVED;
  kern_sim_del_locigprs ();
  gmm_data->gu  = GU3_ROAMING_NOT_ALLOWED;
  kern_sim_gmm_update ();
  
  GMM_RETURN;
} /* kern_mmgmm_auth_rej_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_t3212_val_ind
|
| Description : Handles the primitive MMGMM_T3212_VAL  _IND
|
| Parameters  : *mmgmm_t3212_val_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_t3212_val_ind ( T_MMGMM_T3212_VAL_IND *mmgmm_t3212_val_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_t3212_val_ind" );

#ifdef REL99
  switch (gmm_data->kern.sig_cell_info.sgsnr_flag)/*!gmm_data->release99 =>old code*/ /* TCS 4.0 */
  {
    default:
    case PS_SGSN_UNKNOWN:
    case PS_SGSN_98_OLDER:
#endif

    /*
     * see GSM04.08 ch. 11.2.2 NOTE 4
     */
    gmm_data->kern.t3302_val = mmgmm_t3212_val_ind->t3212_val;
    /*
     * Boeser Hack wegen Faulheit, signal should be taken
     */
    gmm_data->sync.mm_cell_info.t3212_val = gmm_data->kern.t3302_val;

#ifdef REL99
      break;
    case PS_SGSN_99_ONWARDS:
      break;
  }
#endif

  PFREE ( mmgmm_t3212_val_ind );
  GMM_RETURN;
} /* kern_mmgmm_t3212_val_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_cm_establish_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_CM_ESTABLISH_IND
|
| Parameters  : *mmgmm_cm_establish_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_cm_establish_ind ( T_MMGMM_CM_ESTABLISH_IND *mmgmm_cm_establish_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_cm_establish_ind" );

  PFREE ( mmgmm_cm_establish_ind );

  if (gmm_data->kern.gmmrr_resume_sent)
  {
    kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
    GMM_RETURN;
  }
    
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_REG_RESUMING:
      TRACE_ERROR ("prim should be saved");
      break;
    case KERN_GMM_DEREG_SUSPENDING:
    case KERN_GMM_REG_SUSPENDING:
      gmm_data->kern.suspension_type |= GMM_SUSP_CALL;
      break;

    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_NULL_IMSI:
      kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK);
      break;
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_PLMN_SEARCH:
    case KERN_GMM_DEREG_INITIATED:
    case KERN_GMM_REG_INITIATED:
      switch (gmm_data->kern.attach_cap.mobile_class)
      {
        case GMMREG_CLASS_A:
          if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode)
          {
             kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
          }
          else
          {
            kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK);
          }
          break;
        case GMMREG_CLASS_CG:
          kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
          break; 
        case GMMREG_CLASS_BG:
          if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode)
          {
            kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
            break;
          }
          /* NO break */
        case GMMREG_CLASS_B:
        case GMMREG_CLASS_BC:
          /* START PATCH UBUOB ISSUE 8278 */
          switch (GET_STATE (KERN))
          {
            case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
              gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE;
              break;
            default:
              break;
          }
          /* END PATCH UBUOB ISSUE 8278 */

          if (GMM_MM_DEREG != GET_STATE(MM))
          {
            SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING );
#ifdef FF_EM_MODE
            EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING );
#endif
            /* START PATCH UBUOB ISSUE 8781 */
            /* kern_gmmreg_suspend (GMMREG_CS_CALL); */
            /* END PATCH UBUOB ISSUE 8781 */
            kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_CALL);
            vsi_t_stop(GMM_handle, kern_T3321);
          }
          else
          {
            SET_STATE( KERN, KERN_GMM_DEREG_SUSPENDING);
#ifdef FF_EM_MODE
            EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING);
#endif
            /*
             * kern_llgmm_unassign();
             */
            kern_llgmm_suspend(LLGMM_CALL);
            kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_CALL);
          }
          break;  
        default:
          TRACE_ERROR( "unknown MS class");
          break;
      }
      break;
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
    case KERN_GMM_REG_LIMITED_SERVICE:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_RAU_INITIATED:
      switch (gmm_data->kern.attach_cap.mobile_class)
      {
        case GMMREG_CLASS_A:
          kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK);
          break;
        case GMMREG_CLASS_CG:
          kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
          break; 
        case GMMREG_CLASS_BG:
          if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode)
          {
            kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
            break;
          }
          /* NO break; */      
        case GMMREG_CLASS_B:
        case GMMREG_CLASS_BC:
          /* START PATCH UBUOB ISSUE 8278 */
          switch (GET_STATE (KERN))
          {
            case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
              gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE;
              break;
            default:
              break;
          }
          /* END PATCH UBUOB ISSUE 8278 */
          SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING );
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING );
#endif
          kern_llgmm_suspend(LLGMM_CALL);
          kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_CALL);
          break;
        default:
          TRACE_ERROR( "unknown MS class");
          break;
      }  
      break;

    case KERN_GMM_REG_NORMAL_SERVICE:
      switch (gmm_data->kern.attach_cap.mobile_class)
      {
        case GMMREG_CLASS_A:
          kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK);
          break;
        case GMMREG_CLASS_CG:
          kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
          break; 
        case GMMREG_CLASS_BG:
          if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode)
          {
            kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
            break;
          }
          /* NO break; */        
        case GMMREG_CLASS_B:
        case GMMREG_CLASS_BC:
          SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING );
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING );
#endif
          kern_llgmm_suspend(LLGMM_CALL);
          kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_CALL);
          break;
        default:
          TRACE_ERROR( "unknown MS class");
          break;
      }  
      break;
    case KERN_GMM_REG_SUSPENDED:
      switch (gmm_data->kern.attach_cap.mobile_class)
      {
        case GMMREG_CLASS_A:
          kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK);
          break;
        case GMMREG_CLASS_CG:
          kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
          break; 
        case GMMREG_CLASS_BG:
          if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode)
          {
            kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
            break;
          }
          /* NO break; */        
        case GMMREG_CLASS_B:
        case GMMREG_CLASS_BC:
          /*
           * call is rejected because MM may establish the call by itself.
           * When state REG_RESUMING will be defined than GMM will return OK.
           * In case of waiting for GMMRR_CELL_IND after GMMRR_RESUME_REQ
           * the mobile will run into a dead lock situation otherwise.
           */
          kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
          break;
        default:
          TRACE_ERROR( "unknown MS class");
          break;
      }  
      break;
    case KERN_GMM_DEREG_NO_IMSI:
    case KERN_GMM_NULL_NO_IMSI:
      kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
      break;
    default:
      kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT);
      TRACE_1_INFO ("state: %x", GET_STATE( KERN ));
      TRACE_ERROR( "MMGMM_CM_ESTABLISH_IND unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_mm_cm_establish_ind() */
/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_cm_emergency_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_CM_EMERGENCY_IND
|
| Parameters  : *mmgmm_cm_emergency_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_cm_emergency_ind ( T_MMGMM_CM_EMERGENCY_IND *mmgmm_cm_emergency_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_cm_emeregncy_ind" );

  PFREE ( mmgmm_cm_emergency_ind );

  if (GMMREG_CLASS_A == gmm_data->kern.attach_cap.mobile_class
  && GMMRR_NET_MODE_III != gmm_data->kern.sig_cell_info.net_mode)
  {
     kern_mm_cm_emergency_res (MMGMM_ESTABLISH_OK);
    GMM_RETURN;
  }
  
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_REG_RESUMING:
      TRACE_ERROR ("prim should be saved");
      break;

    case KERN_GMM_DEREG_SUSPENDING:
    case KERN_GMM_REG_SUSPENDING:
      gmm_data->kern.suspension_type |= GMM_SUSP_EM_CALL;
      break;
    case KERN_GMM_DEREG_SUSPENDED:
    case KERN_GMM_REG_SUSPENDED:
    case KERN_GMM_NULL_IMSI:
    case KERN_GMM_NULL_NO_IMSI:
    case KERN_GMM_NULL_PLMN_SEARCH:
    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
    case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:
      kern_mm_cm_emergency_res (MMGMM_ESTABLISH_OK);
      break;
    case KERN_GMM_DEREG_NO_IMSI:
      if (gmm_data->kern.detach_cap.gmmreg)
      /* 
       * The mobile is switching off this moment. Thera are no power anymore
       */
      {
        kern_mm_cm_emergency_res (MMGMM_ESTABLISH_REJECT);
      }
      break;

    case KERN_GMM_DEREG_PLMN_SEARCH:
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_INITIATED:
    case KERN_GMM_REG_INITIATED:
      SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING );
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING );
#endif
      kern_llgmm_suspend(LLGMM_CALL);
      kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_EM_CALL);
      break;
    case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST:
    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
    case KERN_GMM_REG_LIMITED_SERVICE:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_RAU_INITIATED:
      SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING);
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING);
#endif
      kern_llgmm_suspend(LLGMM_CALL);
      kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_EM_CALL);
      break;
    case KERN_GMM_REG_NORMAL_SERVICE:
      SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING );
#ifdef FF_EM_MODE
      EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING );
#endif
      /*
       * kern_llgmm_unassign();
       */
      kern_llgmm_suspend(LLGMM_CALL);
      kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_EM_CALL);
      break;
    default:
      TRACE_ERROR( "MMGMM_CM_EMERGENCY_IND unexpected" );
      break;
  }
  GMM_RETURN;
} /* kern_mm_cm_emergency_ind() */
/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_cm_release_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_CM_RELEASE_IND
|
| Parameters  : *mmgmm_cm_release_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_cm_release_ind ( T_MMGMM_CM_RELEASE_IND *mmgmm_cm_release_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_cm_release_ind" );

  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_REG_SUSPENDED:
      /*
       * resume with cell_ind
       */
      if (MMGMM_RESUMPTION_OK!=mmgmm_cm_release_ind->resumption)
      {
        TRACE_EVENT("Para: resumption failure: RAU needed");
        SET_STATE(GU,GU_UPDATE_NEEDED);
      }
      else
      {
        TRACE_EVENT("OPar: resumption OK.");
      }
      PFREE ( mmgmm_cm_release_ind );
      kern_call_undone_mm_proc_reg();
      break;
    case KERN_GMM_DEREG_SUSPENDED:
      PFREE ( mmgmm_cm_release_ind );
      kern_call_undone_mm_proc_der();
      break;
    case KERN_GMM_DEREG_SUSPENDING:
    case KERN_GMM_REG_SUSPENDING:
      gmm_data->kern.suspension_type &= ~ (GMM_SUSP_CALL|GMM_SUSP_EM_CALL);

      PFREE ( mmgmm_cm_release_ind );
      break;
    
    default:

      if (GMMREG_CLASS_A!=gmm_data->kern.attach_cap.mobile_class)
      {
        TRACE_ERROR( "MMGMM_CM_RELEASE_IND unexpected" );
      }    
      PFREE ( mmgmm_cm_release_ind );
      break;
  }
  GMM_RETURN;
} /* kern_mm_cm_release_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_plmn_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive MMGMM_PLMN_IND
|
|          MSC: 3.20 MM Interface
|          MSC: 3.20.2 Network selection
|
| Parameters  : *mmgmm_plmn_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_plmn_ind ( T_MMGMM_PLMN_IND *mmgmm_plmn_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_plmn_ind" );
  {
    PPASS (mmgmm_plmn_ind, gmmreg_plmn_ind, GMMREG_PLMN_IND);
    PSEND ( hCommMMI, gmmreg_plmn_ind );
  }
  GMM_RETURN;
} /* kern_mm_plmn_ind() */


/*
+------------------------------------------------------------------------------
| Function    : kern_gmmreg_attach_req
+------------------------------------------------------------------------------
| Description : Handles the the primitive GMMREG_ATTACH_REQ
|
|               This signal passed the attach_type from MMI to 
|               the service KERN
|
|         MSC : 3.4 MMI-initiated normal/combined GPRS attach
|
| Parameters  : *gmmreq_attach_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmreg_attach_req ( T_GMMREG_ATTACH_REQ *gmmreg_attach_req ) 
{ 
  U8 attach_type_changed = FALSE;
  GMM_TRACE_FUNCTION( "kern_gmmreg_attach_req" );
  TRACE_EVENT ("hp_gmm_24473#1#24473"); /* TCS 2.1 */

  /* Changes for Boot Time Speedup. GMM will get dummy GMMREG_ATTACH_REQ indicating QUICK_REG. 
   * GMM will send MMGMM_REG_REQ indicating QUICK_REG. No need to process this request as it is 
   * dummy request and GMM will get other GMMREG_ATTACH_REQ indicating NORMAL_REG
   */
  if (gmmreg_attach_req->bootup_act EQ QUICK_REG)
  {
    kern_mm_reg_req (REG_GPRS_INACTIVE, QUICK_REG);
    return ;
  }
  vsi_t_stop  ( GMM_handle, kern_T3302);
  sig_kern_rdy_stop_t3302_req();
  gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = FALSE;
  /*
   * attach_cap.gmmreg sets the caller of the attach procedure to MMI
   */
  gmm_data->kern.attach_cap.gmmreg = TRUE;
  gmm_data->kern.detach_cap.gmmreg = FALSE;

  gmm_data->kern.attach_cap.service_mode = gmmreg_attach_req->service_mode;
  

  if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
  {
    /*
     * I expect that limited service means emergency call over GSM only
     * CLASS_CC can be set, because service mode is changed via 
     * GMMREG_ATTACH_REQ only, so that the wanted mobile class is giveb again
     */
    gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC;    
    gmm_data->kern.attach_cap.attach_type = GMMREG_AT_IMSI;

  }
  else
  {
     /*
      *PATCH TB 26/10/02 <
      * Inform GRR of the new MS class
      */
     attach_type_changed = 
        (  gmm_data->kern.attach_cap.mobile_class != gmmreg_attach_req->mobile_class
        || gmm_data->kern.attach_cap.attach_type!= gmmreg_attach_req->attach_type);
     
     if (GMM_GRR_STATE_OFF != gmm_data->kern.attach_cap.grr_state
     && (gmm_data->kern.attach_cap.mobile_class != gmmreg_attach_req->mobile_class))
     {
       if (GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode)
       {
          gmm_data->kern.attach_cap.mobile_class_changed = TRUE;
          gmm_data->kern.attach_cap.mobile_class = gmmreg_attach_req->mobile_class;
          /*
           * inform GRR after switch (mmgmm_nreg_cnf xor kern _enter_der)
           * kern_gmmrr_enable();
           */
       }
       else
       {
          gmm_data->kern.attach_cap.mobile_class = gmmreg_attach_req->mobile_class;
          kern_gmmrr_enable();
       }
     }     
     /* PATCH TB 26/10/02 > */


     gmm_data->kern.attach_cap.mobile_class = gmmreg_attach_req->mobile_class;
      /*
       * if MMI wants to detach, then detach is expected or class change
       */
     gmm_data->kern.attach_cap.attach_type = 
       (GMMREG_CLASS_CG == gmmreg_attach_req->mobile_class?
        GMMREG_AT_GPRS:
        gmm_data->kern.attach_cap.attach_type|gmmreg_attach_req->attach_type);

  }
   

  
  #ifndef NTRACE      
  switch (gmmreg_attach_req->service_mode)
  {
    case SERVICE_MODE_LIMITED:
      TRACE_EVENT ("Limited Service");
      break;
    case SERVICE_MODE_FULL:
      TRACE_EVENT ("Full Service");
      break;
    default:
      TRACE_ERROR ("wrong Service requested");
  }
  switch ( gmm_data->kern.attach_cap.mobile_class )
  {
    case GMMREG_CLASS_CC:
      TRACE_0_PARA("MS class CC");
      break;
    case GMMREG_CLASS_CG:
      TRACE_0_PARA("MS class CG");
      break;
    case GMMREG_CLASS_B:
      TRACE_0_PARA("MS class B");
      break;
    case GMMREG_CLASS_BG:
      TRACE_0_PARA("MS class BG");
      break;
    case GMMREG_CLASS_BC:
      TRACE_0_PARA("MS class BC");
      break;
    case GMMREG_CLASS_A:
      TRACE_0_PARA("MS class A");
      break;
    default:
      TRACE_ERROR ("unknown mobile class");
      break;
  }
  switch (gmm_data->kern.attach_cap.attach_type)
  {
    case GMMREG_AT_IMSI:
      TRACE_0_PARA("GSM only attach");
      break;
    case GMMREG_AT_GPRS:
      TRACE_0_PARA("GPRS attach");
      break;
    case GMMREG_AT_COMB:
      TRACE_0_PARA("GSM and GPRS attach");
      break;
    default:
      TRACE_ERROR ("unknown attach type");
      TRACE_1_PARA("%d",gmm_data->kern.attach_cap.attach_type);
      break;
  }
#endif

  if (gmm_data->sim_gprs_invalid
  && GMMREG_CLASS_CG == gmm_data->kern.attach_cap.mobile_class)
  /* 
   * i.e. error cause 7: gprs not allowed
   */
  {
    PREUSE(gmmreg_attach_req,gmmreg_attach_rej,GMMREG_ATTACH_REJ );
      gmmreg_attach_rej->detach_type = 
        (GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM)?GMMREG_DT_GPRS:GMMREG_DT_COMB),
      gmmreg_attach_rej->search_running = GMMREG_SEARCH_NOT_RUNNING,
      gmmreg_attach_rej->cause = GMMCS_GPRS_NOT_ALLOWED; /* TCS 2.1 */
      gmmreg_attach_rej->service = GMMCS_GPRS_NOT_ALLOWED;
      gmm_data->kern.attach_cap.gmmreg = FALSE;
      
    PSEND ( hCommMMI, gmmreg_attach_rej );
    GMM_RETURN;
  }
 
  
  PFREE ( gmmreg_attach_req );
  
  switch( GET_STATE( KERN ) )
  {
    /*
     * GMM-DEREGISTERED
     */
    case KERN_GMM_DEREG_RESUMING:
    case KERN_GMM_REG_RESUMING:
      TRACE_ERROR ("prim should be saved");
      break;
 
    case KERN_GMM_DEREG_PLMN_SEARCH:
    case KERN_GMM_DEREG_LIMITED_SERVICE:
    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
    
    case KERN_GMM_DEREG_SUSPENDING:
    case KERN_GMM_DEREG_SUSPENDED:
      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        SET_STATE ( KERN, KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
#endif
        kern_gmmrr_disable();
        kern_mm_activate_mm();
        break;
      }

      if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class
      || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type)
      {
        SET_STATE ( KERN, KERN_GMM_NULL_IMSI );
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI );
#endif
        kern_gmmrr_disable();
        kern_mm_activate_mm();
        if ( GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM) )
        {
          kern_gmmreg_attach_cnf( GMMREG_AT_IMSI);
        }
        break;
      }

      switch ( gmm_data->kern.attach_cap.mobile_class )
      {
        case GMMREG_CLASS_CG:
          if ( GMM_MM_DEREG != GET_STATE(MM) )
          {
            switch( GET_STATE( KERN ) )
            {
              case KERN_GMM_DEREG_SUSPENDED:
                /*
                 * Case GMMREG_CLASS_CG.
                 * The detach procedure for cs is only possible after receiving
                 * GMMRR_CELL_IND
                 */
                break;
              case KERN_GMM_DEREG_SUSPENDING:
                gmm_data->kern.suspension_type |=GMM_SUSP_IMSI_DETACH;
                break;
              default:
                if (kern_lai_changed() )
                {
                  SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING );
#ifdef FF_EM_MODE
                  EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING );
#endif
                  kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);
                }
                else 
                {
                  kern_imsi_detach_der_susp();
                }
                GMM_RETURN;
            }
          }
          break;
        default:
          break;
      }

      switch( GET_STATE( KERN ) )
      {
        case KERN_GMM_DEREG_SUSPENDED:
          gmm_data->kern.attach_cap.mm_lau_attempted=TRUE;
          gmm_data->kern.suspension_type &= ~GMM_SUSP_LAU;
          break;
        case KERN_GMM_DEREG_SUSPENDING:
          gmm_data->kern.suspension_type |=GMM_SUSP_LAU;
          break;
        default:          
          {
            kern_mm_reg_req (REG_CELL_SEARCH_ONLY, NORMAL_REG);
          }
          break;
          
      }
      break;
    case KERN_GMM_NULL_PLMN_SEARCH:
      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        SET_STATE (KERN,KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
#endif
        kern_mm_activate_mm ();
        break;
      }

      if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class
      || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type)
      {
        kern_mm_activate_mm ();
        break;
      }


      switch ( gmm_data->kern.attach_cap.mobile_class )
      {
        case GMMREG_CLASS_CG:
          if ( GMM_MM_DEREG != GET_STATE(MM) )
          {
            SET_STATE(KERN, KERN_GMM_DEREG_PLMN_SEARCH);
#ifdef FF_EM_MODE
            EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH);
#endif
            /*
             * MM enters autmaticly gprs cell search mode so that GMM 
             * need not to send mmgmm_reg_req (cell_search_only)
             */
            kern_mm_imsi_detach();
          }
          else
          {
            SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH );
#ifdef FF_EM_MODE
            EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH );
#endif
            kern_mm_activate_rr();
          }
          break;
        default:
          /*
           * class A and B
           */
          SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH );
#ifdef FF_EM_MODE
          EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH );
#endif
          kern_mm_activate_rr();
        break;
      }
      break;
    /*
     * GPRS will be enabled
     */
    case KERN_GMM_NULL_IMSI:          
      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        SET_STATE (KERN,KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
#endif
        kern_mm_activate_mm ();
        break;
      }
      if (GMM_MM_DEREG != GET_STATE(MM) 
      && GMMREG_CLASS_CC == gmm_data->kern.attach_cap.mobile_class)
      {
        TRACE_EVENT ("GMMREG_ATTACH_REQ has been come twice and is ignored!");
        /*
         * the funcion is not alled because mm_plmn is used.
         */
       
        kern_gmmreg_attach_cnf(GMMREG_AT_IMSI);
        gmm_data->kern.attach_cap.gmmreg = FALSE;

       break;
      }
      /* NO break */
    case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:           
      if (SERVICE_MODE_LIMITED != gmm_data->kern.attach_cap.service_mode)
      {
        gmm_data->kern.sig_cell_info.gmm_status = GMMRR_SERVICE_UNKNOWN ; /* Initalize gmm status value */
        switch ( gmm_data->kern.attach_cap.mobile_class )
        {
          case GMMREG_CLASS_CC:
            if (KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ==GET_STATE(KERN)
            || GMM_MM_DEREG == GET_STATE(MM))
            {
              SET_STATE ( KERN, KERN_GMM_NULL_PLMN_SEARCH );
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_NULL_PLMN_SEARCH );
#endif
              kern_mm_activate_mm();
            }
            else
            {
              SET_STATE(KERN,KERN_GMM_NULL_IMSI);
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI);
#endif
              kern_gmmreg_attach_cnf( GMMREG_AT_IMSI);
            }
            break;
          case GMMREG_CLASS_CG:
            if ( GMM_MM_DEREG != GET_STATE(MM) )
            {
              switch(GET_STATE(KERN))
              {
                case KERN_GMM_NULL_IMSI:
                  SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH);
#ifdef FF_EM_MODE
                  EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH);
#endif
                  /*
                   * MM enters autmaticly gprs cell search mode so that GMM 
                   * need not to send mmgmm_reg_req (cell_search_only)
                   */
                  kern_mm_imsi_detach();
                  break;
                default:
                  break;
              }
            }
            else
            {
              SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH );
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH );
#endif
              kern_mm_activate_rr();
            }
            break;
          default:
            /*
             * class A and B
             */
            if (GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type)
            {
              SET_STATE ( KERN, KERN_GMM_NULL_PLMN_SEARCH );
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_NULL_PLMN_SEARCH );
#endif
              kern_mm_activate_mm();
            }
            else
            {
              SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH );
#ifdef FF_EM_MODE
              EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH );
#endif

              kern_mm_activate_rr();
            }
          break;
        }
      }  
      break;
    /* end case KERN_GMM_NULL_IMSI */

    case KERN_GMM_DEREG_NO_IMSI:
      /*
       * this state is not necessary, it is the same as NULL_NO_IMSI
       * and will be romoved soon
       */

      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        SET_STATE (KERN,KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ);
#endif
      }
      else
      {
        SET_STATE (KERN,KERN_GMM_NULL_NO_IMSI);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI);
#endif
      }
      kern_gmmrr_disable();
      kern_mm_activate_mm(); 
      break;
     
    case KERN_GMM_NULL_NO_IMSI:
      /*
       * Attach Rejected for the first time to enable POWER_OFF
       */
      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        SET_STATE (KERN,KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ);
#endif
      }
      kern_mm_activate_mm();
      break;
    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
      if ( SERVICE_MODE_LIMITED != gmm_data->kern.attach_cap.service_mode)
      {
        SET_STATE (KERN,KERN_GMM_NULL_NO_IMSI);
#ifdef FF_EM_MODE
        EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI);
#endif
      }
      kern_mm_activate_mm();
      break;
    case KERN_GMM_REG_NORMAL_SERVICE:
      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        kern_l_sim_rem_reg();
      }
      else
      {
        switch ( gmm_data->kern.attach_cap.mobile_class )
        {
          case GMMREG_CLASS_CC:
            if ( GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM) )
            {
              kern_gmmreg_attach_cnf ( GMMREG_AT_IMSI );
            }
            kern_disable();
            break;
          case GMMREG_CLASS_CG:
            if (GMM_MM_DEREG != GET_STATE(MM))
            {
              if (kern_lai_changed() )
              {
                switch (gmm_data->kern.sig_cell_info.net_mode)
                {
                  case GMMRR_NET_MODE_I:
                    kern_rau();
                    break;
                  default:
                    SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING );
#ifdef FF_EM_MODE
                    EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING );
#endif
                    kern_llgmm_suspend(LLGMM_CALL);
                    kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);
                    break;
                }
              }
              else 
              {
                switch (gmm_data->kern.sig_cell_info.net_mode)
                {
                  case GMMRR_NET_MODE_I:
                    gmm_data->kern.detach_cap.detach_type = GMMREG_DT_IMSI;
                    kern_detach();
                    break;
                  default:
                    kern_imsi_detach_reg_susp();
                    break;
                }
              }
              GMM_RETURN;
            }
            /*
             * <R.GMM.AGACCEPT.M.027>,
             * <R.GMM.PATTCNF.M.001>
             */
            else
            {
              kern_gmmreg_attach_cnf ( GMMREG_AT_GPRS );
            }
            break;
          default:
            if (attach_type_changed)
            {
              /*
               * class A and B
               */
              if ( GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM) )
              {
                kern_gmmreg_attach_cnf ( GMMREG_AT_COMB );
              }
              else
              {
                /*
                 * Combined RAU procedure is established
                 * if GPRS is attached and IMSI should attached
                 */
              
                kern_rau();
              }
            }
            else
            {
              kern_mm_reg_req (REG_CELL_SEARCH_ONLY, NORMAL_REG);
            }
            break;
        }
      }
      break;
    case KERN_GMM_REG_SUSPENDED:
    case KERN_GMM_REG_SUSPENDING:
      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        kern_l_sim_rem_reg_lim ();
        break;
      }
      /*
       * Attach requests in suspended mode will be handled after resumption
       * by triggering form GRR with GMMRR_CELL_IND
       */
      break;
    
    case KERN_GMM_REG_NO_CELL_AVAILABLE:
    case KERN_GMM_REG_LIMITED_SERVICE:
      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        kern_l_sim_rem_reg_lim ();
        break;
      }
      /* NO break */
    case KERN_GMM_RAU_INITIATED:
    case KERN_GMM_REG_INITIATED:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:  
    
      if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode)
      {
        kern_l_sim_rem_reg ();
      }
      else
      {
        switch ( gmm_data->kern.attach_cap.mobile_class )
        {
          case GMMREG_CLASS_CC:

            gmm_data->kern.detach_cap.detach_type = GMMREG_DT_DISABLE_GPRS;

            kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_NULL_IMSI); /* TCS 2.1 */
            if ( GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM) )
            {
              kern_gmmreg_attach_cnf ( GMMREG_AT_IMSI );
            }
            kern_enter_der();
            break;
          case GMMREG_CLASS_CG:
            if (GMM_MM_DEREG != GET_STATE(MM))
            {
              if (kern_lai_changed() )
              {
                switch(GET_STATE(KERN))
                {
                  case KERN_GMM_REG_NO_CELL_AVAILABLE:
                  case KERN_GMM_RAU_INITIATED:
                  case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
                  case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:  
                    kern_llgmm_suspend(LLGMM_CALL);
                    break;
                  default:
                    break;
                }

                SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING );
#ifdef FF_EM_MODE
                EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING );
#endif

                
                kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU);
              }
              else 
              {
                kern_imsi_detach_reg_susp();
              }
              GMM_RETURN;
            }
            else
            /*
             * <R.GMM.AGACCEPT.M.027>,
             * <R.GMM.PATTCNF.M.001>
             */
            {
              if (KERN_GMM_REG_INITIATED!=GET_STATE(KERN))
              {
                kern_gmmreg_attach_cnf ( GMMREG_AT_GPRS );
              }
            }
            break;
          default:
            
            {
              kern_mm_reg_req (REG_CELL_SEARCH_ONLY, NORMAL_REG);
            }
            break;
          }
        }
      break;  
    default:
      TRACE_ERROR( "GMMREG_ATTACH_REQ unexpected" );
      break;
     
  }
  GMM_RETURN;
} /* kern_gmmreg_attach_req() */


/*
+------------------------------------------------------------------------------
| Function    : kern_gmmsm_sequence_res
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMSM_SEQENCE_RES
|
| Parameters  : *gmmsm_sequence_res - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
#ifdef GMM_TCS4
GLOBAL void kern_gmmsm_sequence_res ( T_MMPM_SEQUENCE_RES *gmmsm_sequence_res )
#else
GLOBAL void kern_gmmsm_sequence_res ( T_GMMSM_SEQUENCE_RES *gmmsm_sequence_res )
#endif
{ 
  GMM_TRACE_FUNCTION( "kern_gmmsm_sequence_res" );

  
  switch( GET_STATE( KERN ) )
  {
    case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST:
    { 
      int i=0;
      MCAST (routing_area_update_complete, ROUTING_AREA_UPDATE_COMPLETE);
      routing_area_update_complete->v_receive_n_pdu_number_list = TRUE;
      routing_area_update_complete->receive_n_pdu_number_list.
        c_receive_n_pdu_number_list_val = gmmsm_sequence_res->c_npdu_list;
      
      for (i=0;i<routing_area_update_complete->receive_n_pdu_number_list.c_receive_n_pdu_number_list_val;i++)
      {
        routing_area_update_complete
          ->receive_n_pdu_number_list.receive_n_pdu_number_list_val[i]
          .nsapi 
          =  gmmsm_sequence_res->npdu_list[i].nsapi;
          
        routing_area_update_complete
          ->receive_n_pdu_number_list.receive_n_pdu_number_list_val[i]
          .receive_n_pdu_number_val
           
          =  gmmsm_sequence_res->npdu_list[i].receive_n_pdu_number_val;

      }
      
      PFREE (gmmsm_sequence_res);
      kern_rau_complete (gmm_data->kern.attach_cap.result_type);
      
      break;
    }
    default:
      PFREE (gmmsm_sequence_res);
      TRACE_ERROR( "GMMSM_SEQUENCE_RES received in an unusual state." );
      break;
  }
  GMM_RETURN;
} /* kern_gmmsm_sequence_res() */

 /*TI DK primitive*/
#ifdef REL99
/*+------------------------------------------------------------------------------
| Function    : kern_gmmsm_pdp_status_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMSM_PDP_STATUS_REQ
|
| Parameters  : *gmmsm_pdp_status_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_gmmsm_pdp_status_req ( T_MMPM_PDP_CONTEXT_STATUS_REQ *gmmsm_pdp_status_req )

{ 
  GMM_TRACE_FUNCTION( "kern_gmmsm_pdp_status_req" );

  /* Store the data in context */  
  gmm_data->kern.attach_cap.pdp_context_status = 
                                    gmmsm_pdp_status_req->nsapi_set;
  
  GMM_RETURN;
} /* kern_gmmsm_pdp_status_req() */
#endif

/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_ciphering_ind
+------------------------------------------------------------------------------
| Description : forwards the ciphering indicator of GSM to MMI
|
| Parameters  : *mmgmm_ciphering_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_ciphering_ind ( T_MMGMM_CIPHERING_IND *mmgmm_ciphering_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_ciphering_ind" );
  {
    PALLOC (gmmreg_ciphering_ind, GMMREG_CIPHERING_IND);
    gmmreg_ciphering_ind->gsm_ciph = mmgmm_ciphering_ind->ciph;
    /* 
     * do not include the ciphering status of gprs purposely to have the
     * behaviour for GSM and for GPRS (do not remember the status of the other!)
     */
    gmmreg_ciphering_ind->gprs_ciph = CIPH_NA;
    PFREE ( mmgmm_ciphering_ind );
    PSEND ( hCommMMI, gmmreg_ciphering_ind );
  }
  GMM_RETURN;
} /* kern_mmgmm_ciphering_ind() */
/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_tmsi_ind
+------------------------------------------------------------------------------
| Description : forwards the TMSI received in MM  to GMM
|
| Parameters  : *mmgmm_tmsi_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_tmsi_ind ( T_MMGMM_TMSI_IND *mmgmm_tmsi_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_tmsi_ind" );
  gmm_data->tmsi = mmgmm_tmsi_ind->tmsi;
  TRACE_1_PARA("TMSI %x", gmm_data->tmsi  );
  PFREE ( mmgmm_tmsi_ind );
  GMM_RETURN;
} /* kern_mmgmm_ciphering_ind() */

/*
+------------------------------------------------------------------------------
| Function    : kern_mmgmm_ahplmn_ind
+------------------------------------------------------------------------------
| Description : forwards the ahplmn indicator to MMI
|
| Parameters  : *mmgmm_ahplmn_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void kern_mmgmm_ahplmn_ind ( T_MMGMM_AHPLMN_IND *mmgmm_ahplmn_ind )
{ 
  GMM_TRACE_FUNCTION( "kern_mmgmm_ahplmn_ind" );
  {
    PPASS (mmgmm_ahplmn_ind, gmmreg_ahplmn_ind, GMMREG_AHPLMN_IND);
    PSEND ( hCommMMI, gmmreg_ahplmn_ind );
  }
  GMM_RETURN;
} /* kern_mmgmm_ahplmn_ind() */