+
−/*
+
−+-----------------------------------------------------------------------------
+
−|  Project :
+
−|  Modul   :
+
−+-----------------------------------------------------------------------------
+
−|  Copyright 2002 Texas Instruments Berlin, AG
+
−|                 All rights reserved.
+
−|
+
−|                 This file is confidential and a trade secret of Texas
+
−|                 Instruments Berlin, AG
+
−|                 The receipt of or possession of this file does not convey
+
−|                 any rights to reproduce or disclose its contents or to
+
−|                 manufacture, use, or sell anything it may describe, in
+
−|                 whole, or in part, without the specific written consent of
+
−|                 Texas Instruments Berlin, AG.
+
−+-----------------------------------------------------------------------------
+
−|  Purpose :  This Modul defines the timer handling functions
+
−|             for the component DL of the mobile station
+
−+-----------------------------------------------------------------------------
+
−*/
+
−
+
−#ifndef RR_TIM_C
+
−#define RR_TIM_C
+
−
+
−#define ENTITY_RR
+
−
+
−/*==== INCLUDES ===================================================*/
+
−
+
−#include <string.h>
+
−#include <stdlib.h>
+
−#include <stddef.h>     /* offsetof */
+
−#include <stdio.h>      /* sprintf */
+
−#include "typedefs.h"
+
−#include "pcm.h"
+
−#include "pconst.cdg"
+
−#include "mconst.cdg"
+
−#include "message.h"
+
−#include "ccdapi.h"
+
−#include "vsi.h"
+
−#include "custom.h"
+
−#include "gsm.h"
+
−#include "prim.h"
+
−#include "cnf_rr.h"
+
−#include "tok.h"
+
−#include "rr.h"
+
−#ifdef TI_PS_FF_AT_P_CMD_CTREG
+
−#include "cl_shrd.h"
+
−#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+
−
+
−/*==== EXPORT =====================================================*/
+
−/*==== PRIVAT =====================================================*/
+
−#if !defined(ELEMENTS)
+
−#define ELEMENTS(array) (sizeof(array)/sizeof(array[0]))
+
−#endif  /* !ELEMENTS */
+
−
+
−/*==== VARIABLES ==================================================*/
+
−EXTERN UBYTE test_house;
+
−#ifdef TI_PS_FF_AT_P_CMD_CTREG
+
−EXTERN T_TIME cast2T_Time(UBYTE tab_val);
+
−#else
+
−EXTERN T_TIME lim_service_mode_time[25];
+
−#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+
−/*
+
− * In the old frame variant most of the timer handling is done
+
− * in RR. RR has a timer pool and holds the dependency between
+
− * logical timer and timer handle.
+
− *
+
− * With the new frame variant this is simplified. RR uses a constant
+
− * for the timer and gets back the this constant after timeout.
+
− *
+
− * This is the reason why most of the functions are only needed for
+
− * the old frame variant.
+
− */
+
−
+
−/*==== FUNCTIONS ==================================================*/
+
−
+
−#if defined(TIMER_TRACE)
+
−static void  trace_timer (USHORT index, long value)
+
−{
+
−  GET_INSTANCE_DATA;
+
−/* Implements Measure#32: Row */
+
−  static T_S2I_STRING const tim_names[] =
+
−  {
+
−    S2I_STRING("T3110"),
+
−    S2I_STRING("T3122"),
+
−    S2I_STRING("T3126"),
+
−    S2I_STRING("T_RESELECT"),
+
−    S2I_STRING("TREG"),
+
−    S2I_STRING("TABORT"),
+
−    S2I_STRING("T_NO_RESELECT"),
+
−    S2I_STRING("TIM_EXT_MEAS"),
+
−    #if defined FF_EOTD
+
−    S2I_STRING("TAPDU"),
+
−    #endif /* FF_EOTD */
+
−    S2I_STRING("TNNN"),
+
−    S2I_STRING("TCSVALID"),
+
−    S2I_STRING("T_DEDICATED_MODE"),
+
−    S2I_STRING("T_PLMN_SEARCH"),
+
−    S2I_STRING("T_FAST_CS"),
+
−    S2I_STRING("T_NORMAL_CS")
+
−  };
+
−  switch(value)
+
−  {
+
−/* Implements Measure#32: Row 431, 432, 433 and 435 */
+
−    default:/* >0: start */
+
−      TRACE_TIMER_P2 ("T-Start:%s=%lu", S2I_STRING(tim_names[index]), value);
+
−      break;
+
−    case 0:/* EQ 0: stop */
+
−      TRACE_TIMER_P1 ("T-Stop:%s", S2I_STRING(tim_names[index]));
+
−      break;
+
−    case -1:/* -1: expire */
+
−      TRACE_TIMER_P1 ("T-Expired:%s ", S2I_STRING(tim_names[index]));
+
−      break;
+
−    case -2:/* -2: check */
+
−      if(rr_data->t_running[index])
+
−      { 
+
−        TRACE_TIMER_P1 ("T-Check:%s active", S2I_STRING(tim_names[index]));
+
−      }
+
−      else
+
−      { 
+
−        TRACE_TIMER_P1 ("T-Check:%s inactive", S2I_STRING(tim_names[index]));
+
−      }
+
−      break;
+
−  }
+
−}
+
−#else
+
−#define trace_timer(index,value)
+
−#endif  /* TIMER_TRACE */
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_t3110                  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer T3110. Timer is started after reception
+
−            of channel release message and controls layer 2 disconnection.
+
−            It starts the configuration of idle mode, if layer 2 has
+
−            not signalled in time the disconnection of the layer 2 link.
+
−
+
−*/
+
−
+
−GLOBAL void tim_t3110 (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  TRACE_FUNCTION ("tim_t3110()");
+
−
+
−  if (GET_STATE (STATE_DAT) EQ DAT_CHAN_REL)
+
−  {
+
−    /*
+
−     * Send STOP_DEDICATED_REQUEST to L1 and wait for confirmation 
+
−     */
+
−    att_stop_dedicated();
+
−  }
+
−
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_t3122                  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer T3122. Started after reception of an
+
−            immediate assignment reject message. MM does not start
+
−            any new establishment during the timer is running.
+
−            After timeout MM is informed. New attempts from MM can
+
−            be started.
+
−
+
−*/
+
−
+
−GLOBAL void tim_t3122 (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  PALLOC (sync, RR_SYNC_IND);
+
−
+
−  TRACE_FUNCTION ("tim_t3122()");
+
−
+
−  switch (GET_STATE (STATE_DAT))
+
−  {
+
−    case DAT_NULL:
+
−    case DAT_CELL_RESELECT:
+
−    case DAT_IDLE:
+
−    case DAT_IMM_ASS:
+
−    case DAT_IMM_ASS_1:
+
−      /*
+
−       * send the indication to MM that T3122 has
+
−       * timed-out.
+
−       */
+
−      sync->ciph              = NOT_PRESENT_8BIT;
+
−      sync->chm.ch_mode       = NOT_PRESENT_8BIT;
+
−      sync->synccs            = SYNCCS_T3122_TIM_OUT;
+
−      memset(&sync->mm_info, 0, sizeof(T_mm_info));
+
−      sync->mm_info.valid     = FALSE;
+
−      memset(&sync->bcch_info, 0, sizeof(T_bcch_info));
+
−      sync->bcch_info.v_bcch  = FALSE;
+
−
+
−      PSENDX (MM, sync);
+
−      srv_use_stored_prim ();
+
−      break;
+
−
+
−    default:
+
−      PFREE (sync);
+
−      break;
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_t3126                  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer T3126. This timer is used for two cases.
+
−            1. It controls that all random bursts are send during a
+
−               certain time. If (why ever) layer 1 does not confirm
+
−               all outgoing random bursts, this timer prevents RR
+
−               from stucking. This functionality is not described in
+
−               GSM and is introduced for security reasons.
+
−            2. It controls the reception of an immediate assignment
+
−               message. This is the normal GSM functionality.
+
−
+
−*/
+
−
+
−GLOBAL void tim_t3126 (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  TRACE_FUNCTION ("tim_t3126()");
+
−
+
−  if (GET_STATE (STATE_DAT) EQ DAT_IMM_ASS)
+
−  {
+
−    if (rr_data->ms_data.all_conf_received)
+
−    {
+
−      /*
+
−       * Normal GSM functionality. Control of the
+
−       * reception of immediate assignment messages.
+
−       */
+
−      TRACE_EVENT ("Immediate Assignment failed");
+
−
+
−      dat_send_release_ind ( RRCS_RND_ACC_FAIL );
+
−
+
−      /*
+
−       * Check if we have to do a cell reselection
+
−       * or if we can return directly to idle mode in the current
+
−       * cell
+
−       */
+
−      TRACE_EVENT("check rej_rec");
+
−      if (rr_data->imm_ass_rej_rec NEQ TRUE)
+
−      {
+
−        /*
+
−         * search for idle mode cell
+
−         * (exclude current serving cell, because
+
−         *  the random access was unsuccessfull)
+
−         */
+
−#ifdef GPRS
+
−        if(att_gprs_cell_has_pbcch())
+
−        {
+
−/*XY: inform GRR, and don't wait for CR_RSP we will get a CR_REQ in this case */
+
−          att_rrgrr_cr_ind(CR_REQ_CANDIDATE);
+
−          rr_data->gprs_data.start_proc = START_PROC_NOTHING;
+
−        }
+
−        else
+
−        {
+
−#endif
+
−
+
−          TRACE_EVENT_P1("rr_data->c_ncell_bcch: %x",rr_data->c_ncell_bcch);
+
−
+
−          /*There are three scenarios to be considered */
+
−          /*
+
−           * i   - The first MPH_MEASUREMENT_IND has not yet arrived
+
−           * ii  - The first MPH_MEASUREMENT_IND has arrived but not all 
+
−           *       the SIs have been received
+
−           * (These are managed below)
+
−           *
+
−           * iii - The first MPH_MEASUREMENT_IND has arrived and all the 
+
−           *       SIs have been received AND a reselection is pending
+
−           * This is managed in 'att_bcch_status_to_decoded()'
+
−           */
+
−
+
−         if(((rr_data->first_meas_received EQ TRUE) AND (rr_data->c_ncell_bcch EQ 0)) OR
+
−/* Implements RR Clone findings #8 */
+
−              att_cell_barred_status_cr_no_cr (SC_INDEX)
+
−              OR 
+
−             (rr_data->nc_data[SC_INDEX].c1 <= 0))
+
−          {
+
−/*XY:n inform GRR, and        wait for CR_RSP */
+
−#ifdef GPRS
+
−            att_start_cell_reselection_gprs (CELL_RESELECTION_RACH);
+
−#else
+
−            att_start_cell_reselection (CELL_RESELECTION_RACH);
+
−#endif
+
−          }
+
−          else
+
−          {
+
−            /*
+
−             * continue camping on current SC until indication of ncell BCCH info
+
−             * after first measurement indication
+
−             */
+
−             rr_data->resel_pending = TRUE;
+
−             att_return_to_idle();
+
−          }
+
−#ifdef GPRS
+
−        }
+
−#endif
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * we have received an IMMEDIATE ASSIGNMENT REJECT
+
−         * (the random access procedure was successfull, meaning
+
−         *  that an answer was received from the network, even
+
−         *  if the answer was negative)
+
−         * In this case we go directly back to the current
+
−         * serving cell
+
−         */
+
−#ifdef GPRS
+
−        if(att_gprs_cell_has_pbcch())
+
−        {
+
−/*XY: inform GRR, and don't wait for CR_RSP */
+
−          att_rrgrr_cr_ind(CR_SUSPENDED_IDLE);
+
−          rr_data->gprs_data.start_proc = START_PROC_NOTHING;
+
−        }
+
−#endif
+
−        att_return_to_idle();
+
−      }
+
−    }
+
−    else
+
−    {
+
−      /*
+
−       * Layer 1 has not confirmed all outgoing random bursts
+
−       * in time. Simulate that all confirmations have received
+
−       * and start second part of connection establishment
+
−       * with waiting for the immediate assignment.
+
−       */
+
−      TRACE_TIMER ("missing random acc cnf");
+
−
+
−      TIMERSTART (T3126, T3126_VALUE);
+
−      rr_data->ms_data.all_conf_received = TRUE;
+
−    }
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_treselect              |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer T_RESELECT. The timer controls reception
+
−            of the whole BCCH during cell selection and cell reselection.
+
−
+
−*/
+
−
+
−GLOBAL void tim_treselect (void)
+
−{ 
+
−  GET_INSTANCE_DATA;
+
−  TRACE_FUNCTION ("tim_treselect()");
+
−
+
−  switch (GET_STATE (STATE_ATT))
+
−  {
+
−    case ATT_CS2:
+
−#ifdef GPRS
+
−      if((rr_data->cr_data.cd.sys_info_read EQ SYS_INFO_EXCEPT_SI13) AND test_house)
+
−      {
+
−        if(rr_data->ms_data.rr_service EQ LIMITED_SERVICE)
+
−        {
+
−          /*
+
−           * We have found a 'potential' cell for limited service 
+
−           */
+
−          rr_data->nc_data[CR_INDEX].si13_loc_ind = SI13_NOT_PRESENT;
+
−          SET_STATE(STATE_GPRS, GPRS_ACTIVATED);
+
−          att_check_bcch_carrier ();
+
−          return;
+
−        }
+
−        else
+
−        {
+
−          /*
+
−           * There is a problem with some R&S tests where SI13 is indicated
+
−           * in SI3/4 but there is no SI13 transmitted by the tester. RR continues
+
−           * to wait to for SI13 having successfully received all other SI's from L1
+
−           *
+
−           * The timeout of T_RESELECT would cause this cell to be ignored and 
+
−           * RR would have instructed L1 to check the next BSIC.
+
−           * Thus, it can happen that after a failed scan of all subsequent frequencies, 
+
−           * MM is indicated with "no cell available" i.e. we lose a GSM-only healthy cell
+
−           *
+
−           * Mark the current arfcn as being eligible for LIM service, which RR can camp 
+
−           * onto on the next pass when looking for emergency cells.
+
−           */
+
−          if(dat_forb_lai_check (CR_INDEX))
+
−          {
+
−          att_store_plmn_in_found_list (&rr_data->nc_data[CR_INDEX].lai);
+
−          }
+
−          else
+
−          {
+
−            TRACE_EVENT ("Do not store Forbidden LAI PLMN in the found PLMN list");
+
−          }
+
−          cs_set_attributes (EMERGENCY_CELL,  rr_data->nc_data[CR_INDEX].arfcn);
+
−          TRACE_EVENT_P1("Setting %x as EMERG", rr_data->nc_data[CR_INDEX].arfcn);
+
−        }
+
−     }
+
−#endif
+
−
+
−      /*
+
−       * Sometimes SI 2Ter is indicated, but it is never sent
+
−       * With this patch the inconsistent BCCH is taken.
+
−       * Fix for defect OMAPS00069058: SI13 is indicated on EBCCH, but never
+
−       * received. The fix avoids ignoring this cell on TRESELECT timeout.
+
−       */
+
−      if ( (rr_data->cr_data.cd.sys_info_read EQ SYS_INFO_EXCEPT_2TER)
+
−#ifdef GPRS
+
−          OR
+
−           (rr_data->cr_data.cd.sys_info_read EQ SYS_INFO_EXCEPT_SI13)
+
−#endif
+
−         )
+
−      {
+
−        /*
+
−         * if at least the rest is available, check the
+
−         * BCCH carrier to camp on a cell.
+
−         */
+
−#ifdef GPRS
+
−        if ( (rr_data->cr_data.cd.sys_info_read EQ SYS_INFO_EXCEPT_SI13) AND
+
−             (GET_STATE (STATE_GPRS) EQ GPRS_PIM_BCCH ) 
+
−           )
+
−        {
+
−          rr_data->nc_data[CR_INDEX].si13_loc_ind = SI13_NOT_PRESENT;
+
−          SET_STATE(STATE_GPRS, GPRS_ACTIVATED); 
+
−        }
+
−#endif
+
−        att_check_bcch_carrier ();
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * initialise the internal data for the next candidate,
+
−         * because the BCCH is not completely available.
+
−         */
+
−        srv_clear_list (&rr_data->cr_data.cd.ncell_list);
+
−        if (cs_sync_next ())
+
−        {
+
−          /*
+
−           * start FB/SB reading for the next channel.
+
−           */
+
−          SET_STATE (STATE_ATT, ATT_CS1);
+
−#ifdef GPRS
+
−          if (GET_STATE (STATE_GPRS) EQ GPRS_PIM_BCCH )
+
−          {
+
−            SET_STATE(STATE_GPRS, GPRS_ACTIVATED);
+
−          }
+
−#endif
+
−          rr_data->old_serving_cell = NOT_PRESENT_8BIT;
+
−        }
+
−      }
+
−      break;
+
−
+
−    case ATT_CS3:
+
−
+
−      if (rr_data->cr_data.cd.sys_info_read EQ SYS_INFO_EXCEPT_2TER)
+
−      {
+
−        /*
+
−         * if all sys infos except SI 2Ter is available, check the
+
−         * BCCH carrier to camp on a cell.
+
−         * When GPRS is activate, ATT_STATE is changed from ATT_CS3 to
+
−         * ATT_IDLE following reception of rrgrr_cr_req from GRR. Hence
+
−         * it not approprite to check for ATT_STATE for cell reselection
+
−         * completion. A new flag has been introduced for this purpose.
+
−         * This is s temporary solution, untill CQ 24632 is submitted
+
−         * where the SI2TER functionality will be cleaned up.
+
−         */
+
−
+
−        rr_data->cr_treselect_exp = FALSE;
+
−
+
−        att_check_bcch_carrier ();
+
−
+
−        if(rr_data->cr_treselect_exp)
+
−        {
+
−          TRACE_EVENT("Cell Reselection Success");
+
−          /* cell reselection completed */
+
−          return;
+
−        }
+
−      }
+
−
+
−      TRACE_EVENT ("cell reselection failed");
+
−
+
−      /*
+
−       * reset the paging received flag.
+
−       */
+
−      rr_data->pag_rec = FALSE;
+
−      srv_clear_stored_prim (MPH_PAGING_IND);
+
−
+
−      /*
+
−       * Indicate failed reestablishment earlier
+
−       */
+
−      if (rr_data->sc_data.selection_type EQ BACK_FROM_DEDICATED_RLF)
+
−        dat_code_reestablishment_fail ();
+
−
+
−      /*
+
−       * start a cell selection after timeout.
+
−       */
+
−      rr_data->old_serving_cell = NOT_PRESENT_8BIT;
+
−
+
−    /*XY:n don't inform GRR , but call start_cs anyway */
+
−    
+
−    /* Cell Selection Improvements-LLD section:4.1.3.9
+
−     * Cell reselection fails due to T_RESELECT timer expiry
+
−     * Start Fast search
+
−     */
+
−#ifdef GPRS
+
−       att_start_cell_selection_gprs (RR_ORIGINATED,FAST_SEARCH_MODE);
+
−#else
+
−       att_start_cell_selection (RR_ORIGINATED, CS_NOT_PARALLEL ,FAST_SEARCH_MODE);
+
−#endif
+
−
+
−      break;
+
−
+
−    case ATT_IDLE:
+
−    case ATT_CON_EST:
+
−      /*
+
−       * Parallel scanning for a channel in idle mode has failed.
+
−       * Initialize the data for the next channel and start
+
−       * FB/SB reading for this channel.
+
−       */
+
−       #ifdef GPRS
+
−      if( rr_data->sc_data.selection_type EQ CELL_RESELECTION_ON_GPRS_ACT)
+
−      {
+
−       /* Cell Selection Improvements-LLD section:4.1.3.9           
+
−        * GPRS activation on current cell fails due to T_RESELECT timer
+
−        * expiry   
+
−        * Start Fast search
+
−        */
+
−        att_start_cell_selection_gprs(MM_ORIGINATED,FAST_SEARCH_MODE);
+
−      }
+
−      else
+
−      {
+
−      #endif
+
−      srv_clear_list (&rr_data->cr_data.cd.ncell_list);
+
−      cs_sync_next ();
+
−      #ifdef GPRS
+
−      }
+
−      #endif
+
−      break;
+
−    case ATT_CS_INIT:
+
−       /* Boot Time Performance Enhancement:           
+
−        * RR has not received the normal RR_ACTIVATE_REQ yet 
+
−        * Free the stored power_cnf and move back to ATT_NULL
+
−        */
+
−      if( srv_check_stored_prim(MPH_POWER_CNF))
+
−      {
+
−        srv_clear_stored_prim(MPH_POWER_CNF);
+
−      }
+
−      SET_STATE(STATE_CELL_SEL, CS_NULL);
+
−      SET_STATE(STATE_ATT, ATT_NULL);
+
−      break;
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)     MODULE  : RR_TIM                       |
+
−| STATE   : code              ROUTINE : tim_plmn_search_expiry |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This timer expires to signal end on Manual cell selection.
+
−  
+
−*/
+
−GLOBAL void tim_plmn_search_expiry (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  if(rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI)
+
−  {
+
−    /*
+
−    * Mark all ARFCN's as Checked !
+
−    * After the next MPH_BSIC_CNF & MPH_UNITDATA_IND,
+
−    * cs_sync_next_bsic() will return FALSE.
+
−    */
+
−    UBYTE i;
+
−    for ( i=0; i < rr_data->cs_data.max_arfcn; i++ )
+
−    {
+
−      rr_data->cs_data.attributes[i] |= CS_CHECK_FLAG;
+
−    }   
+
−  }  
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)     MODULE  : RR_TIM                       |
+
−| STATE   : code              ROUTINE : tim_tfast_cs                 |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This timer expires to signal end on Fast Search. Currently
+
−            this function just traces the Black Listed channels
+
−            CSI-LLD section:4.1.3.4.1.9
+
−*/
+
−
+
−GLOBAL void tim_tfast_cs(void)
+
−{
+
−  TRACE_FUNCTION("tim_tfast_cs()");
+
−
+
−  srv_trace_black_list();
+
−  srv_trace_white_list();
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)     MODULE  : RR_TIM                       |
+
−| STATE   : code              ROUTINE : tim_tnormal_cs               |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This timer expires to signal end on Normal search.Currently
+
−            this function just traces the Black Listed channels
+
−            CSI-LLD section:4.1.3.4.1.10                     
+
−*/
+
−
+
−GLOBAL void tim_tnormal_cs(void)
+
−{
+
−  TRACE_FUNCTION("tim_tnormal_cs()");
+
−
+
−  srv_trace_black_list();
+
−  srv_trace_white_list();
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)     MODULE  : RR_TIM                       |
+
−| STATE   : code              ROUTINE : att_reset_registration_timer |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function stops the registration timer early on
+
−            request of MMI / Keypad driver. This function can be called
+
−            to avoid too long periods between search attempts to come
+
−            back to coverage.
+
−
+
−*/
+
−
+
−GLOBAL void tim_reset_registration_timer (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_TIME status = 0;
+
−
+
−  TRACE_FUNCTION ("tim_reset_registration_timer()");
+
−
+
−  /*
+
−   * depending on the current RR service
+
−   */
+
−  switch (rr_data->ms_data.rr_service)
+
−  {
+
−    case NO_SERVICE:
+
−    case LIMITED_SERVICE:
+
−      if (rr_data->ms_data.reg_counter >= 12)
+
−      {
+
−        /*
+
−         * Only if RR has searched already more then 12 times,
+
−         * that means there is a long period between search attempts
+
−         * from some minutes.
+
−         *
+
−         * Get the remaining time of the timer.
+
−         */
+
−        TIMER_STATUS (rr_handle, TREG, &status);
+
−        if (status)
+
−        {
+
−          /*
+
−           * if the timer is just running, stop the timer,
+
−           * reset the attempt counter and simulate timeout
+
−           * by starting the timer again for one second.
+
−           */
+
−          TIMERSTOP (TREG);
+
−          rr_data->ms_data.reg_counter = 0;
+
−          TIMERSTART (TREG, ONE_SEC);
+
−        }
+
−      }
+
−      break;
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_treg                   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer TREG. Used by RR to recover from
+
−            No service to limited / full service or
+
−            limited service to full service or
+
−            full service (non-HPLMN) to full service (HPLMN)
+
−
+
−*/
+
−
+
−GLOBAL void tim_treg (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  U8 search_mode = 0;
+
−#ifdef GPRS
+
−  UBYTE state;
+
−#endif /* GPRS */
+
−#ifdef TI_PS_FF_AT_P_CMD_CTREG
+
−  BOOL ret;
+
−  UBYTE tab_val;
+
−#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+
−  TRACE_FUNCTION ("tim_treg()");
+
−
+
−  /*
+
−   * clear old cell identification to
+
−   * signal with RR_ACTIVATE_IND to MM to force
+
−   * location updatings.
+
−   */
+
−  att_reset_old_lai_rac();
+
−  
+
−  /*
+
−   * due to : "Network not recovered after a manual registration failure"
+
−   * do nothing if measurement is running (RR is already in state ATT_CS1)
+
−   */
+
−  switch (GET_STATE (STATE_ATT))
+
−  {
+
−    case ATT_CS1:
+
−    case ATT_CS2:
+
−      break;
+
−
+
−    case ATT_CS3:
+
−    case ATT_DEDICATED:
+
−    case ATT_CON_EST:
+
−      /*
+
−       * handle the expiry event later after state change (by an
+
−       * additional expiry of TREG)
+
−       */
+
−      rr_data->treg_pending = TRUE;
+
−      break;
+
−    case ATT_IDLE:
+
−#ifdef GPRS
+
−      state = GET_STATE(STATE_GPRS);
+
−      switch(state)
+
−      {
+
−        case GPRS_PTM_BCCH:
+
−        case GPRS_PAM_BCCH:
+
−        case GPRS_PAM_PBCCH:
+
−        case GPRS_PTM_PBCCH:
+
−          rr_data->treg_pending = TRUE;
+
−          break;
+
−        default:
+
−          if(GET_STATE(STATE_CELL_SEL) EQ CS_CCO)
+
−            rr_data->treg_pending = TRUE;
+
−          break;
+
−      }
+
−      if(rr_data->treg_pending)
+
−      {
+
−        att_start_registration_timer();
+
−        break;
+
−      }
+
−#endif
+
−    /*lint -fallthrough*/
+
−    default:
+
−
+
−    /* Obtain the new search mode
+
−     * CSI-LLD : 4.1.3.4.1.5
+
−     */
+
−    search_mode = cs_get_new_search_mode();
+
−
+
−    switch (rr_data->ms_data.rr_service)
+
−    {
+
−      case NO_SERVICE:
+
−        /*
+
−         * actual there is no service. Depending on the
+
−         * last request from MM a limited service search
+
−         * or full service search is started.
+
−         */
+
−        /* XY:n inform GRR, and      wait for CR_RSP */
+
−#ifdef GPRS
+
−        att_start_cell_selection_gprs(RR_ORIGINATED,search_mode);
+
−#else
+
−        att_start_cell_selection(RR_ORIGINATED, CS_NOT_PARALLEL,search_mode);
+
−#endif
+
−        break;
+
−
+
−      case LIMITED_SERVICE:
+
−        /*
+
−         * actual there is limited service. Depending on the
+
−         * frequency area a limited service search or full service 
+
−         * search is started.
+
−         */    
+
−
+
−          /* Both American and European carriers are detected in 
+
−           * this area. Perform Non-Parallel search only when the 
+
−           * time gap between search attempts exceeds 2min
+
−           * CSI-LLD 4.3
+
−           */
+
−          if(rr_data->ms_data.reg_counter)
+
−          {
+
−#ifdef TI_PS_FF_AT_P_CMD_CTREG
+
−            ret = cl_shrd_get_treg(RR_MOD_LIMSERVICE_TIME,
+
−                                    (UBYTE)(rr_data->ms_data.reg_counter - 1),
+
−                                    &tab_val);
+
−            if (!ret)
+
−            {
+
−              /* Use default on failure */
+
−              tab_val = lim_service_mode_time [rr_data->ms_data.reg_counter-1];
+
−            }
+
−            rr_data->ms_data.reg_time_gap += cast2T_Time(tab_val);
+
−#else
+
−            /* Add the time gap between search attempts */
+
−            rr_data->ms_data.reg_time_gap += 
+
−              lim_service_mode_time[rr_data->ms_data.reg_counter-1];
+
−#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+
−            TRACE_EVENT_P2("[%d]reg_counter, [%d]reg_time_gap", 
+
−              rr_data->ms_data.reg_counter,
+
−              rr_data->ms_data.reg_time_gap);
+
−          }
+
−
+
−          if((rr_data->ms_data.reg_counter < 20) AND 
+
−             (rr_data->ms_data.reg_time_gap < rr_data->dyn_config.lim_ser_nps_delay))
+
−          {
+
−            /* Perform parallel search if delay >= 2min. This is to allow time 
+
−             * for emergency calls
+
−             */
+
−            att_start_cell_selection(RR_ORIGINATED, CS_PARALLEL,search_mode); 
+
−          }
+
−          else
+
−          {
+
−
+
−            rr_data->ms_data.reg_time_gap = 0;
+
−
+
−            /* Perform Non-Parallel search every >= 2min */
+
−#ifdef GPRS
+
−            att_start_cell_selection_gprs(RR_ORIGINATED,search_mode);
+
−#else
+
−            att_start_cell_selection(RR_ORIGINATED, CS_NOT_PARALLEL,search_mode);
+
−#endif          
+
−        }
+
−        break;
+
−
+
−      case FULL_SERVICE:
+
−        /*
+
−         * actual there is full service. Nothing to do here.
+
−         */
+
−        break;
+
−    }
+
−    break;
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_tnnn                   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer TNNN
+
−
+
−*/
+
−GLOBAL void tim_tnnn (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  int   index;
+
−  BOOL  tnnn_active = FALSE;
+
−
+
−  for (index = 0; index < (int)ELEMENTS(rr_data->nc_data); index++)
+
−  {
+
−    if (rr_data->nc_data[index].tnnn)
+
−    {
+
−      rr_data->nc_data[index].tnnn--; /* decrement all active timer counts */
+
−      if (rr_data->nc_data[index].tnnn)
+
−        tnnn_active = TRUE;          /* at least one timer count active */
+
−      else
+
−      {
+
−/* Implements Measure#32: Row 442 */
+
−        switch(index)
+
−        {
+
−          case CR_INDEX:
+
−            TRACE_TIMER_P1 ("T-Expiry:TNNN[CR%d]", rr_data->nc_data[index].arfcn);
+
−            break;
+
−          case SC_INDEX:
+
−            TRACE_TIMER_P1 ("T-Expiry:TNNN[SC%d]", rr_data->nc_data[index].arfcn);
+
−            break;
+
−          default:
+
−            TRACE_TIMER_P1 ("T-Expiry:TNNN[%d]", rr_data->nc_data[index].arfcn);
+
−            break;
+
−        }
+
−      }
+
−    }
+
−  }
+
−
+
−  if (!tnnn_active)
+
−    TIMERSTOP (TNNN); /* no timer count active -> stop physical timer */
+
−}
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_tabort                 |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer TABORT
+
−
+
−*/
+
−GLOBAL void tim_tabort (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  TRACE_EVENT("tim_tabort TIMEOUT");
+
−
+
−  /* Sometimes SI 2Ter is indicated but it is never sent.
+
−   * Wait till expiry of T_RESELECT Timer, to give more time to read SI 2Ter.
+
−   * Do not send RR_ABORT_IND in this special case,
+
−   * as this will cause MMI to show "No Network"
+
−   */
+
−  if( (rr_data->cr_data.cd.sys_info_read EQ SYS_INFO_EXCEPT_2TER) AND
+
−      ((GET_STATE(STATE_ATT) EQ ATT_CS2) OR (GET_STATE(STATE_ATT) EQ ATT_CS3)) )
+
−  {
+
−    TRACE_EVENT("SI2 Ter missing - wait for T_RESELECT expiry");
+
−    TIMERSTART (TABORT, TABORT_VALUE);
+
−    return;
+
−  }
+
−
+
−  /*If the MS is carrying out a search for a list of PLMNs, this may take */
+
−  /*longer than 10s and the MMI is not displaying the PLMN name */
+
−  /*Boot Time:If MM has initiated a power scan for quick registration
+
−    *do not send RR_ABORT_IND here. 
+
−    */
+
−  if((rr_data->ms_data.req_mm_service NEQ FUNC_NET_SRCH_BY_MMI) AND
+
−     (rr_data->ms_data.req_mm_service NEQ FUNC_ST_PWR_SCAN))
+
−  {
+
−    att_code_net_lost();
+
−#ifdef FF_PS_RSSI
+
−    RX_SetValue ( 0, RX_QUAL_UNAVAILABLE, RX_ACCE_UNAVAILABLE);
+
−#else
+
−    RX_SetValue (0);
+
−#endif
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS              MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : check_tnnn                 |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Starts timer TABORT
+
−
+
−*/
+
−void tstart_tabort( USHORT val )
+
−{
+
−  GET_INSTANCE_DATA;
+
−  if( rr_data->net_lost )
+
−  {
+
−    if(!IS_TIMER_ACTIVE(TABORT))
+
−    {
+
−      TIMERSTART (TABORT, val);
+
−    }
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : check_tnnn                 |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Checks to see if timer TNNN is running or not
+
−
+
−*/
+
−static int check_tnnn (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  int nc;
+
−  int tnnn_active = FALSE;
+
−
+
−  /* check all timer counter for active state */
+
−  for (nc = 0; nc < (int)ELEMENTS(rr_data->nc_data); nc++)
+
−  {
+
−    if (rr_data->nc_data[nc].tnnn)
+
−    {
+
−      tnnn_active = TRUE;
+
−      break;
+
−    }
+
−  }
+
−  return tnnn_active;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : set_tnnn                   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Sets timer TNNN
+
−
+
−*/
+
−GLOBAL void set_tnnn (int index, USHORT value)
+
−{
+
−  GET_INSTANCE_DATA;
+
−/* Implements Measure#32: Row 443 */
+
−  switch (index)
+
−  {
+
−    case CR_INDEX:
+
−      TRACE_TIMER_P2 ("T-Start:TNNN[CR%d]=%d", rr_data->nc_data[index].arfcn, value);
+
−      break;
+
−    case SC_INDEX:
+
−      TRACE_TIMER_P2 ("T-Start:TNNN[SC%d]=%d", rr_data->nc_data[index].arfcn, value);
+
−      break;
+
−    default:
+
−      TRACE_TIMER_P2 ("T-Start:TNNN[%d]=%d", rr_data->nc_data[index].arfcn, value);
+
−      break;
+
−  }
+
−
+
−  if (!check_tnnn ())
+
−  {/* up to now there are no timer counter active -> start physical timer */
+
−    trace_timer (TNNN, value);
+
−    rr_data->t_running[TNNN] = 1;
+
−
+
−    /*
+
−     * start physical periodically timer.
+
−     */
+
−        TIMER_PSTART (rr_handle, TNNN, ONE_SEC, ONE_SEC);
+
−  }
+
−
+
−  /* set the new timer counter */
+
−  rr_data->nc_data[index].tnnn = value / ONE_SEC;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : reset_tnnn                 |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Resets timer TNNN
+
−
+
−*/
+
−GLOBAL void reset_tnnn (int index)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  if (rr_data->nc_data[index].tnnn)
+
−  {
+
−/* Implements Measure#32: Row 444 */
+
−    switch (index)
+
−    {
+
−      case CR_INDEX:
+
−        TRACE_TIMER_P1 ("T-Stop:TNNN[CR%d]", rr_data->nc_data[index].arfcn);
+
−        break;
+
−      case SC_INDEX:
+
−        TRACE_TIMER_P1 ("T-Stop:TNNN[SC%d]", rr_data->nc_data[index].arfcn);
+
−        break;
+
−      default:
+
−        TRACE_TIMER_P1 ("T-Stop:TNNN[%d]", rr_data->nc_data[index].arfcn);
+
−        break;
+
−    }
+
−
+
−    /* reset the timer counter */
+
−    rr_data->nc_data[index].tnnn = 0;
+
−
+
−    if (IS_TIMER_ACTIVE(TNNN) AND !check_tnnn ())
+
−      TIMERSTOP (TNNN);
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : is_tnnn                    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Returns value of timer TNNN
+
−
+
−*/
+
−GLOBAL int is_tnnn (int index)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  if (rr_data->nc_data[index].tnnn)
+
−  {
+
−/* Implements Measure#32: Row 446 */
+
−    switch (index)
+
−    {
+
−      case CR_INDEX:
+
−        TRACE_TIMER_P2 ("T-Check:TNNN[CR%d]=%d", rr_data->nc_data[index].arfcn, 
+
−                rr_data->nc_data[index].tnnn*ONE_SEC);
+
−        break;
+
−      case SC_INDEX:
+
−        TRACE_TIMER_P2 ("T-Check:TNNN[SC%d]=%d", rr_data->nc_data[index].arfcn, 
+
−                rr_data->nc_data[index].tnnn*ONE_SEC);
+
−        break;
+
−      default:
+
−        TRACE_TIMER_P2 ("T-Check:TNNN[%d]=%d", rr_data->nc_data[index].arfcn, 
+
−                rr_data->nc_data[index].tnnn*ONE_SEC);
+
−        break;
+
−    }
+
−  }
+
−  else
+
−  {
+
−/* Implements Measure#32: Row 445 */
+
−    switch (index)
+
−    {
+
−      case CR_INDEX:
+
−        TRACE_TIMER_P1 ("T-Check:TNNN[CR%d] inactive", rr_data->nc_data[index].arfcn);
+
−        break;
+
−      case SC_INDEX:
+
−        TRACE_TIMER_P1 ("T-Check:TNNN[SC%d] inactive", rr_data->nc_data[index].arfcn);
+
−        break;
+
−      default:
+
−        TRACE_TIMER_P1 ("T-Check:TNNN[%d] inactive", rr_data->nc_data[index].arfcn);
+
−        break;
+
−    }
+
−  }
+
−
+
−  return rr_data->nc_data[index].tnnn;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_ext_meas               |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer TIM_EXT_MEAS.
+
−
+
−*/
+
−
+
−GLOBAL void tim_ext_meas (void)
+
−{
+
−  TRACE_FUNCTION ("tim_ext_meas ()");
+
−  dat_emo_stop ( TRUE );
+
−}
+
−
+
−#if defined FF_EOTD
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : RR_TIM                     |
+
−| STATE   : code                ROUTINE : tim_apdu                   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Timeout of timer TAPDU.
+
−
+
−*/
+
−
+
−GLOBAL void tim_apdu (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  TRACE_FUNCTION ("tim_apdu ()");
+
−  rr_applic_rx_init ( &rr_data->applic_rx );
+
−}
+
−#endif /* FF_EOTD */
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : RR_TIM                   |
+
−| STATE   : code                  ROUTINE : tim_exec_timeout         |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : execute timeout for the new frame variant.
+
−
+
−*/
+
−
+
−GLOBAL void tim_exec_timeout (USHORT index)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  TRACE_FUNCTION ("tim_exec_timeout()");
+
−
+
−  if (index >= NUM_OF_RR_TIMERS)
+
−  {
+
−#if defined(TIMER_TRACE)
+
−    SYST_TRACE_P ((SYST, "tim_exec_timeout(%u)", index));
+
−#endif
+
−  }
+
−  else
+
−  {
+
−    if (index NEQ TNNN) /* TNNN timer has its own trace */
+
−    {
+
−      trace_timer (index, -1);
+
−      rr_data->t_running[index] = 0;
+
−    }
+
−
+
−    if (rr_data->t_expire[index])
+
−      rr_data->t_expire[index] ();
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : RR_TIM                   |
+
−| STATE   : code                  ROUTINE : tim_stop_timer           |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : stop timer in the new frame variant.
+
−
+
−*/
+
−
+
−GLOBAL void tim_stop_timer (USHORT index)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  TRACE_FUNCTION ("tim_stop_timer()");
+
−
+
−  if (index >= NUM_OF_RR_TIMERS)
+
−  {
+
−#if defined(TIMER_TRACE)
+
−    SYST_TRACE_P ((SYST, "tim_stop_timer(%u)", index));
+
−#endif
+
−  }
+
−  else
+
−  {
+
−    trace_timer (index, 0);
+
−    rr_data->t_running[index] = 0;
+
−        TIMER_STOP (rr_handle, index);
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : RR_TIM                   |
+
−| STATE   : code                  ROUTINE : tim_start_timer          |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : start timer in the new frame variant.
+
−
+
−*/
+
−
+
−GLOBAL void tim_start_timer (USHORT index, T_TIME value)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  TRACE_FUNCTION ("tim_start_timer()");
+
−
+
−  if (index >= NUM_OF_RR_TIMERS)
+
−  {
+
−#if defined(TIMER_TRACE)
+
−    SYST_TRACE_P ((SYST, "tim_start_timer(%u)", index));
+
−#endif
+
−  }
+
−  else
+
−  {
+
−    trace_timer (index, value);
+
−    rr_data->t_running[index] = 1;
+
−    TIMER_START (rr_handle, index, value);
+
−   
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : RR_TIM                   |
+
−| STATE   : code                  ROUTINE : tim_check_timer          |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Checks if a specified timer is running
+
−
+
−*/
+
−#if defined(TIMER_TRACE)
+
−GLOBAL BOOL tim_check_timer(USHORT index)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  TRACE_FUNCTION ("tim_check_timer()");
+
−
+
−  if (index >= NUM_OF_RR_TIMERS)
+
−  {
+
−    SYST_TRACE_P ((SYST, "tim_check_timer(%u)", index));
+
−    return FALSE;
+
−  }
+
−  else
+
−  {
+
−    trace_timer (index, -2);
+
−    return (rr_data->t_running[index]);
+
−  }
+
−}
+
−#endif  /* TIMER_TRACE */
+
−#endif /* RR_TIM_C */