/*
+-----------------------------------------------------------------------------
|  Project :  GSM-PS
|  Modul   :  ALR_CS
+-----------------------------------------------------------------------------
|  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 SDL process Cell Selection.
+-----------------------------------------------------------------------------
*/

#ifndef ALR_CS_C
#define ALR_CS_C

#define ENTITY_PL

/*==== INCLUDES ===================================================*/
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include "typedefs.h"
#include "vsi.h"
#include "custom.h"
#include "gsm.h"
#include "prim.h"
#include "pei.h"
#include "tok.h"

#include "pcm.h"
#ifdef GPRS
#include "alr_gprs.h"
#endif

#include "alr.h"
#include "alr_em.h"
#include "cl_list.h"

#if defined (_SIMULATION_)
#define TRACING
#endif

#if defined (TRACING)
#define ALR_TRACE_CS(a)  ALR_TRACE(a)
#else
#define ALR_TRACE_CS(a)
#endif

#if defined (TRACING)

#define ALR_TRACE_CS_STD(a1)        TRACE_EVENT_P1 ("std %d",a1)
#define ALR_TRACE_CS_BSIC_REQ(a,s)   TRACE_EVENT_P2 ("BSIC REQ [%u] %d", a, s)
#define ALR_TRACE_CS_SYNC_VALID(a,f,t) TRACE_EVENT_P3 ("set new SC[%u],valid block fno:%d,time_al%d",a,f,t)

#else

#define ALR_TRACE_CS_STD(std)
#define ALR_TRACE_CS_BSIC_REQ(a,s)
#define ALR_TRACE_CS_SYNC_VALID(a,f,t)

#endif

/*==== EXPORT =====================================================*/

/*==== PRIVAT =====================================================*/

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

/* Power scan attempts for different search modes */
LOCAL const U8 power_scan_attempts[] = { 
  FULL_SEARCH_MODE_ATTEMPTS, 
  NORMAL_SEARCH_MODE_ATTEMPTS,
  FAST_SEARCH_MODE_ATTEMPTS, 
  BLACK_LIST_SEARCH_MODE_ATTEMPTS
};

/* Power measurements spreading time for different search modes */
#if defined(_SIMULATION_)
LOCAL const U16 tim_powermeas_value[] = {
  500,
  500,
  100,
  100
};
#else
LOCAL const U16 tim_powermeas_value[] = { 
  TIM_FULL_SEARCH_POWERMEAS_VAL, 
  TIM_NORMAL_SEARCH_POWERMEAS_VAL, 
  TIM_FAST_SEARCH_POWERMEAS_VAL, 
  TIM_BLACK_LIST_SEARCH_POWERMEAS_VAL
};
#endif

LOCAL const int array_band_index[] = { 
  B_GSM_900,
  B_E_GSM, 
  B_PCS_1900, 
  B_DCS_1800, 
  MAX_NUM_BANDS,
  MAX_NUM_BANDS,
  B_GSM_850 
};

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

LOCAL void cs_add_and_sort_channels           (void);
LOCAL void cs_find_inactive_carriers          (T_POWER_MEAS **p_results,
                                               U16 p_results_size[2],U8 *std,
                                               U8 no_of_attempts, SHORT *min_rxlev);
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
LOCAL U8   cs_add_whitelist_carriers          (U16 p_results_size[2], U8 *std,
                                               U8 attempts,
                                               SHORT *min_rxlev,
                                               T_POWER_MEAS **p_results,
                                               U8 no_of_carriers_per_band[4]);
#else
LOCAL U8   cs_add_whitelist_carriers          (U16 p_results_size[2], 
                                               U8 std, U8 attempts,
                                               SHORT *min_rxlev,
                                               T_POWER_MEAS *presults,
                                               U8 no_of_carriers_per_band[4]);
#endif
LOCAL BOOL cs_is_in_black_list                (U8 region,U16 arfcn);
LOCAL U8   cs_restrict_max_carriers_per_band  (U16 arfcn, U8 std, 
                                               U8 no_of_carriers_per_band[4],
                                               U16 p_results_size[2], U8 min_rxlev);
LOCAL void cs_move_extra_carriers              (U8 i_cnf, U8 extra_cnf);
LOCAL void cs_reorder_the_extra_carriers       (U8 extra_cnf);
LOCAL void cs_power_array_swap_arfcn           (T_POWER_ARRAY *from,
                                                T_POWER_ARRAY *to);

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_init                    |
+--------------------------------------------------------------------+

  PURPOSE : Initialize Cell Selection Process.
            Set state and dynamic allocated RAM area to NULL.

*/

GLOBAL void cs_init (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("cs_init()");
  alr_data->state[STATE_CS] = CS_NULL;
  memset (&alr_data->cs_data, 0, sizeof (T_CS_DATA));
  alr_data->cs_data.p_results1 = (T_POWER_MEAS*)&alr_power_meas_result1;
  alr_data->cs_data.p_results2 = (T_POWER_MEAS*)&alr_power_meas_result2;
  alr_data->cs_data.search_mode = SM_WIDE_MODE;
  alr_data->cs_data.sync_fail_count = CS_SYNC_FAIL_COUNT_MAX;
  alr_data->cs_data.bcch_fail_count = CS_BCCH_FAIL_COUNT_MAX;

  if ( IS_EXT_MEAS_RUNNING ) /*alr_data->cs_data.mph_ext_meas_req NEQ NULL*/
  {
    PFREE ( alr_data->cs_data.mph_ext_meas_req );
            alr_data->cs_data.mph_ext_meas_req = NULL;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_get_next_area           |
+--------------------------------------------------------------------+

  PURPOSE : This returns the next area to scan ('next_area').
            Also it sets 'std' and 'freq_area' - members of 'cs_data' -
            depend on given 'freq_bands'.
*/

LOCAL UBYTE cs_get_next_area (void)
{
  GET_INSTANCE_DATA;
  UBYTE next_area;

  if ((alr_data->cs_data.freq_area&ALL_FREQ_AREA) EQ ALL_FREQ_AREA)
    next_area =
      (alr_data->cs_data.freq_area&NEXT_AMERICAN_AREA) ? AMERICAN_FREQ_AREA : EUROPEAN_FREQ_AREA;
  else
    next_area = alr_data->cs_data.freq_area;

  /*
   * In the case the members and value arenīt already initialized,
   * next_area is set to 0
   */
  switch (next_area)
  {
    default:
    case EUROPEAN_FREQ_AREA:
      if ((alr_data->cs_data.std12 & 0x0f) EQ 0) /* not initialized */
        next_area = 0;
      break;
    case AMERICAN_FREQ_AREA:
      if ((alr_data->cs_data.std12 >> 4) EQ 0) /* not initialized */
        next_area = 0;
      break;
    case 0:
      break;
  }

/*
  if (next_area)
  {
    TRACE_EVENT_P9 ("cs_get_next_area: fb=%02x => cs_std=%u(%u) std12=%02x area=%02x'%c%c' next=%u'%c'",
      alr_data->cs_data.freq_bands, alr_data->cs_data.std, std,
      alr_data->cs_data.std12, alr_data->cs_data.freq_area,
      (alr_data->cs_data.freq_area & EUROPEAN_FREQ_AREA) ? 'E':' ',
      (alr_data->cs_data.freq_area & AMERICAN_FREQ_AREA) ? 'A':' ',
      next_area, next_area ? ((next_area EQ AMERICAN_FREQ_AREA) ? 'A':' E') : '?');
  }
*/
  return next_area;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_get_std_area            |
+--------------------------------------------------------------------+

  PURPOSE : This returns the frequency band 'std' depend on given
            'freq_bands'. It also sets the suitable frequency area
            to the value of a possible given area pointer.

            This function knows only the single and dual frequency
            band combinations. Triple or quad frequency band
            combinations leads to return values set to 0.
*/

LOCAL UBYTE cs_get_std_area (UBYTE freq_bands, UBYTE *p_area)
{
  UBYTE cs_freq_area;
  UBYTE cs_std;

  switch (freq_bands)
  {
    case BAND_GSM_900:/* single band */
      cs_freq_area = EUROPEAN_FREQ_AREA;
      cs_std = STD_900;
      break;
    case BAND_DCS_1800:/* single band */
      cs_freq_area = EUROPEAN_FREQ_AREA;
      cs_std = STD_1800;
      break;
    case BAND_PCS_1900:/* single band */
      cs_freq_area = AMERICAN_FREQ_AREA;
      cs_std = STD_1900;
      break;
    case BAND_E_GSM:/* extended single band */
    case BAND_GSM_900|BAND_E_GSM: /* extended single band */
      cs_freq_area = EUROPEAN_FREQ_AREA;
      cs_std = STD_EGSM;
      break;
    case BAND_GSM_850:/* single band */
      cs_freq_area = AMERICAN_FREQ_AREA;
      cs_std = STD_850;
      break;
    case BAND_DUAL:/* dual band */
      cs_freq_area = EUROPEAN_FREQ_AREA;
      cs_std = STD_DUAL;
      break;
    case BAND_DUAL_EXT:/* dual band */
      cs_freq_area = EUROPEAN_FREQ_AREA;
      cs_std = STD_DUAL_EGSM;
      break;
    case BAND_DUAL_US:/* dual band */
      cs_freq_area = AMERICAN_FREQ_AREA;
      cs_std = STD_DUAL_US;
      break;
    default:
      cs_freq_area = 0;
      cs_std = 0;
      break;
  }

  if (p_area)
    *p_area = cs_freq_area;
  return cs_std;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_set_std_area            |
+--------------------------------------------------------------------+

  PURPOSE : This returns the next area to scan ('next_area').
            Also it sets 'std' and 'freq_area' - members of 'cs_data' -
            depend on given 'freq_bands'.
            This function will be executed at least once (single band) and
            not more than twice (multiband) per power request.
*/

LOCAL UBYTE cs_set_std_area (void)
{
  GET_INSTANCE_DATA;
  UBYTE next_area;
  UBYTE cs_freq_bands = alr_data->cs_data.freq_bands;
  UBYTE cs_std;
  UBYTE cs_freq_area = alr_data->cs_data.freq_area;

/*
  TRACE_EVENT_P1 ("cs_set_std_area(): %s call", cs_freq_area?"second":"first");
*/
  if (cs_freq_area & NEXT_AMERICAN_AREA)
    /*
     * Initializing before second measurement
     */
    next_area = AMERICAN_FREQ_AREA;
  else
    next_area = 0;

  if (cs_freq_bands EQ 0)
  {
    TRACE_ERROR ("alr_data->cs_data.freq_bands=0 (Invalid value)!");
    TRACE_ASSERT (cs_freq_bands EQ 0);
  }

  cs_std = cs_get_std_area(cs_freq_bands, &cs_freq_area);
  if (cs_std EQ 0)
  {
    cs_freq_area = 0;
    if (cs_freq_bands & BAND_DUAL_EXT)
    { /* european frequency bands */
      cs_freq_area |= EUROPEAN_FREQ_AREA;
      if (next_area EQ 0)
        next_area = EUROPEAN_FREQ_AREA;
    }
    if (cs_freq_bands & BAND_DUAL_US)
    { /* american frequency bands */
      cs_freq_area |= AMERICAN_FREQ_AREA;
      if (next_area EQ 0)
        next_area = AMERICAN_FREQ_AREA;
    }

    if (next_area EQ EUROPEAN_FREQ_AREA)
    {
      cs_freq_bands &= BAND_DUAL_EXT;
    }
    else
    {
      cs_freq_bands &= BAND_DUAL_US;
      cs_freq_area |= NEXT_AMERICAN_AREA;
    }
    /*
     * get the next 'std' depend on the value of 'next_area'
     */
    cs_std = cs_get_std_area (cs_freq_bands, NULL);
  }

  if (next_area EQ 0)
    next_area = cs_freq_area;

  alr_data->cs_data.freq_area = cs_freq_area;
  alr_data->cs_data.std = cs_std;
  TRACE_EVENT_P9 ("cs_set_std_area: fb=%02x => cs_std=%u(%u) std12=%02x area=%02x'%c%c' next=%u'%c'",
    alr_data->cs_data.freq_bands, alr_data->cs_data.std, std,
    alr_data->cs_data.std12, alr_data->cs_data.freq_area,
    (alr_data->cs_data.freq_area & EUROPEAN_FREQ_AREA) ? 'E':' ',
    (alr_data->cs_data.freq_area & AMERICAN_FREQ_AREA) ? 'A':' ',
    next_area, next_area ? ((next_area EQ AMERICAN_FREQ_AREA) ? 'A':'E') : '?');

  return next_area;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_power_array_swap_arfcn|
+--------------------------------------------------------------------+

  PURPOSE : This function swaps ARFCN and its RxLev between the 
            locations passed.
*/
LOCAL void cs_power_array_swap_arfcn(T_POWER_ARRAY *ptr1,T_POWER_ARRAY *ptr2)
{
  U16   temp_arfcn;
  SHORT temp_rxlev;  

  temp_arfcn               = ptr1->radio_freq;
  temp_rxlev               = ptr1->accum_power_result;

  ptr1->radio_freq         = ptr2->radio_freq;
  ptr1->accum_power_result = ptr2->accum_power_result;

  ptr2->radio_freq         = temp_arfcn;
  ptr2->accum_power_result = temp_rxlev;

}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_prepare_power_req       |
+--------------------------------------------------------------------+

  PURPOSE : This prepares the inputs for the power request depending
            on the frequency areas.

*/

GLOBAL T_POWER_MEAS* cs_prepare_power_req (void)
{
  GET_INSTANCE_DATA;
  UBYTE         next_area,region;
  T_POWER_MEAS  *power_meas;
  T_LIST        *black_list;

  TRACE_FUNCTION ("cs_prepare_power_req");

  /*
   * depending on the set frequency area
   */
  next_area = cs_get_next_area ();

  if (next_area)
  { /* members and values are already initialized */
    switch (next_area)
    {
      default:
      case EUROPEAN_FREQ_AREA:
        power_meas = alr_data->cs_data.p_results1;
        alr_data->cs_data.std = alr_data->cs_data.std12&0x0f;
        break;
      case AMERICAN_FREQ_AREA:
        power_meas = alr_data->cs_data.p_results2;
        alr_data->cs_data.std = alr_data->cs_data.std12>>4;
        break;
    }

    TRACE_EVENT_WIN_P4 ("cs_prepare_power_req: cs_std=%u(%02x) next=%u'%c'",
      alr_data->cs_data.std, alr_data->cs_data.std12,
      next_area, (next_area EQ AMERICAN_FREQ_AREA) ? 'A':'E');

  }
  else
  { /* must be initialize first */
    int   i;
    int   power_array_size;
    int   radio_freq_offset = 1;

    /*
     * depending on the given frequency bands
     */
    next_area = cs_set_std_area ();
    /*
     * depending on the just set frequency standard
     */
    switch(alr_data->cs_data.std)
    {
      case STD_900:
        power_array_size = MAX_CARRIERS_GSM900;
        break;

      case STD_EGSM:
        power_array_size = MAX_CARRIERS_EGSM900;
        break;

      case STD_1900:
        power_array_size = MAX_CARRIERS_PCS1900;
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
        radio_freq_offset = 1024;
#else
        radio_freq_offset = 512;
#endif
        break;

      case STD_1800:
        power_array_size = MAX_CARRIERS_DCS1800;
        radio_freq_offset = 512;
        break;

      case STD_DUAL:
        power_array_size = MAX_CARRIERS_DUAL;
        break;

      case STD_DUAL_EGSM:
        power_array_size = MAX_CARRIERS_DUAL_EGSM;
        break;

      case STD_850:
        power_array_size = MAX_CARRIERS_GSM850;
        radio_freq_offset = 128;
        break;

      case STD_DUAL_US:
        power_array_size = MAX_CARRIERS_DUAL_US;
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
        radio_freq_offset = 128;
#endif
        break;

      default:
          power_array_size = 0;
        break;
    }

    if (power_array_size)
    {
      /*
       * fill all carriers which shall be measured into the structure
       * to layer 1.
       */
      T_POWER_ARRAY *power_array;
      USHORT size;

      if ( IS_EXT_MEAS_RUNNING )
      {
        power_array_size = alr_data->cs_data.mph_ext_meas_req->num_of_chan;
      }

      /* depend on the next area get the right T_POWER_MEAS instance */
      switch (next_area)
      {
        default:
        case EUROPEAN_FREQ_AREA:
            size = sizeof (T_POWER_MEAS1);
            power_meas = alr_data->cs_data.p_results1;
            /*
            TRACE_EVENT_P1 ("static T_POWER_MEAS(EU): size=%u", sizeof (T_POWER_MEAS1));
            */
          memset (alr_data->cs_data.p_results1, 0, sizeof (T_POWER_MEAS));

          /* save value of 'std' for cs_increment_c_channels() */
          alr_data->cs_data.std12 |= alr_data->cs_data.std & 0x0f;
          break;

        case AMERICAN_FREQ_AREA:
            size = sizeof (T_POWER_MEAS2);
            power_meas = alr_data->cs_data.p_results2;
            /*
            TRACE_EVENT_P1 ("static T_POWER_MEAS(USA): size=%u", sizeof (T_POWER_MEAS2));
            */
          /* save value of 'std' for cs_increment_c_channels() */
          alr_data->cs_data.std12 |= (alr_data->cs_data.std << 4);
          break;
      }

      memset (power_meas, 0, size);

      TRACE_EVENT_WIN_P8 ("cs_prepare_power_req: cs_std=%u(%u) std12=%02x rf=%u..%u (%u) next=%u'%c'",
        alr_data->cs_data.std, std, alr_data->cs_data.std12,
        radio_freq_offset, power_array_size+radio_freq_offset-1,
        power_array_size,
        next_area, (next_area EQ AMERICAN_FREQ_AREA) ? 'A':'E');

      power_array = &(power_meas->power_array[0]);
      memset (power_array, 0, sizeof (T_POWER_ARRAY) * power_array_size);
      power_meas->power_array_size = power_array_size;

      if ( IS_EXT_MEAS_RUNNING )
      {
        USHORT *arfcn = &alr_data->cs_data.mph_ext_meas_req->arfcn[0];
        for ( i = 0; i < power_array_size; i++, power_array++, arfcn++ )
        {
          power_array->radio_freq = ARFCN_TO_L1 ( *arfcn );
        }
      }
      else
      {
        if(alr_data->cs_data.p_power_req->search_mode NEQ BLACK_LIST_SEARCH_MODE)
        {
          power_array_size += radio_freq_offset;
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
          if (alr_data->cs_data.std EQ STD_EGSM)
          {
            for (i=radio_freq_offset; i <= MAX_CARRIERS_GSM900; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
            for (i=LOW_CHANNEL_EGSM; i < HIGH_CHANNEL_EGSM; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
            power_array->radio_freq = 0x00;
            power_array++;
          }
          else if (alr_data->cs_data.std EQ STD_DUAL)
          {
            for (i=radio_freq_offset; i <= MAX_CARRIERS_GSM900; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
            for (i=LOW_CHANNEL_1800; i <= HIGH_CHANNEL_1800; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
          }
          else if (alr_data->cs_data.std EQ STD_DUAL_EGSM)
          {
            for (i=radio_freq_offset; i <= MAX_CARRIERS_GSM900; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
            for (i=LOW_CHANNEL_EGSM; i < HIGH_CHANNEL_EGSM; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
            for (i=LOW_CHANNEL_1800; i <= HIGH_CHANNEL_1800; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
            power_array->radio_freq = 0x00;
            power_array++;
          }
          else if (alr_data->cs_data.std EQ STD_DUAL_US)
          {
            for (i=radio_freq_offset; i <= HIGH_CHANNEL_850; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
            for (i=1024; i <= 1322; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
          }
          else
          {
            for(i=radio_freq_offset; i < power_array_size; i++, power_array++)
            {
              power_array->radio_freq = (U16)i;
            }
          }
#else
          for(i=radio_freq_offset; i < power_array_size; i++, power_array++)
          {
            power_array->radio_freq = (U16)i;
          }
#endif
        }
        else
        { 
          /* Blacklist search. Fill all Black Listed and "Grey" carriers 
           * sent by RR for L1 measurement
           */
          region     = srv_get_region_from_std(std);
          power_meas->power_array_size = 0;
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
          if (region EQ BOTH_REGIONS)
          {
            int j;
            for (j=0; j<MAX_REGIONS; j++)
            {
              black_list = (T_LIST*)&alr_data->cs_data.p_power_req->black_list.list[j];
          
          for(i=CHANNEL_0;i<CHANNEL_0_INTERNAL;i++)
          {
            if(srv_get_channel(black_list, i))
            {
              power_array->radio_freq = ARFCN_TO_L1 ( i );

              power_meas->power_array_size++;
              power_array++;
            }
          }
            }
          }
          else
          {
#endif
            black_list = (T_LIST*)&alr_data->cs_data.p_power_req->black_list.list[region];
          
            for(i=CHANNEL_0;i<CHANNEL_0_INTERNAL;i++)
            {
              if(srv_get_channel(black_list, i))
              {
                power_array->radio_freq = ARFCN_TO_L1 ( i );
  
                power_meas->power_array_size++;
                power_array++;
              }
            }
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
          }
#endif
        } /* Black list search */
      } /* !EXT_MEAS */
    } /* power_array_size != 0 */
    else
    {
      TRACE_EVENT_P6 ("cs_prepare_power_req: invalid: fb=%02x cs_std=%u area=%02x'%c%c' next='%c'",
        alr_data->cs_data.freq_bands,
        alr_data->cs_data.std, alr_data->cs_data.freq_area,
        (alr_data->cs_data.freq_area & EUROPEAN_FREQ_AREA) ? 'E':' ',
        (alr_data->cs_data.freq_area & AMERICAN_FREQ_AREA) ? 'A':' ',
        (next_area EQ AMERICAN_FREQ_AREA) ? 'A':'E');
      power_meas = NULL;/* invalid values */
    }
  }
  return power_meas;/* do it */
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_power_req               |
+--------------------------------------------------------------------+

  PURPOSE : This starts measurement of the fieldstrength of all channels.

*/

GLOBAL void cs_power_req (UBYTE pch_interrupt)
{
  GET_INSTANCE_DATA;
  /* When Power On alr_data->cs_data.std will be set to 0, which wil be changed later. This is
     used to find out if it is a first power scan after boot up. MPHC_INIT_L1_REQ will be sent
     only during first powerv scan. It should not be sent on subsequent power scan */
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
  U8 initial_req = alr_data->cs_data.std;
#endif

  TRACE_EVENT_P1 (" p_results1=%08x", alr_data->cs_data.p_results1);
  
  /* Reset CS data */
  alr_data->cs_data.std12 = 0;
  alr_data->cs_data.freq_area = 0;
  alr_data->cs_data.c_meas = 0;
  alr_data->cs_data.p_results1->power_array_size = 0;
  alr_data->cs_data.p_results2->power_array_size = 0;

  cs_prepare_power_req();

  if(IS_EXT_MEAS_RUNNING)
  {
    alr_data->cs_data.c_max_meas = power_scan_attempts[FULL_SEARCH_MODE];

    alr_data->cs_data.c_tim_meas = (tim_powermeas_value[FULL_SEARCH_MODE]/
                                    power_scan_attempts[FULL_SEARCH_MODE]);

  }
  else
  {
    T_MPH_POWER_REQ* mph_power_req = alr_data->cs_data.p_power_req;
    
    /* CSI-LLD Section: 4.1.3.4.2.3 
     * Set the number of RF scan attempts and TIM_POWER_MEAS timer value 
     * based on the search mode
     */

    /* Set the number of RF scan attempts */
    alr_data->cs_data.c_max_meas = 
      power_scan_attempts[mph_power_req->search_mode];

    /* Set TIM_POWER_MEAS timer value */
    alr_data->cs_data.c_tim_meas = 
      (tim_powermeas_value[mph_power_req->search_mode] /  
       power_scan_attempts[mph_power_req->search_mode]);


    if (((alr_data->cs_data.freq_area & ALL_FREQ_AREA) EQ ALL_FREQ_AREA) AND 
        (mph_power_req->search_mode NEQ BLACK_LIST_SEARCH_MODE))
    {
      /* Multiply the number of field strength measurements by 2 */
      alr_data->cs_data.c_max_meas <<= 1;

      /* Reduce the TIM_POWER_MEAS value by half */
      alr_data->cs_data.c_tim_meas >>= 1;
    }

    TRACE_EVENT_P2(" Search Type:[%u] Search Mode:[%u]",
      mph_power_req->pch_interrupt,
      mph_power_req->search_mode);
  }

  /* new state is dependent on necessary of the L1 configuration */
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
  if (!initial_req)
#else
  if ((pch_interrupt EQ PCH_INTERRUPT) OR (alr_data->cs_data.std NEQ std))
#endif
  {
    SET_STATE (STATE_CS, CS_INIT_L1);
  }
  else
  {
    SET_STATE (STATE_CS, CS_START_MEASURE);
  }

  TRACE_EVENT_P2 ("cs_power_req: c_max_meas=%u c_tim_meas=%u",
    alr_data->cs_data.c_max_meas, alr_data->cs_data.c_tim_meas);

  ma_cs_rxlev_req ();
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_bsic_req                |
+--------------------------------------------------------------------+

  PURPOSE : Request of RR to search for frequency correction
            burst and synchron burst.

*/

GLOBAL void cs_bsic_req (T_MPH_BSIC_REQ * mph_bsic_req)
{
  GET_INSTANCE_DATA;
  UBYTE cs_std;

  if (mph_bsic_req)
  {
    ALR_TRACE_CS_BSIC_REQ(mph_bsic_req->arfcn&ARFCN_MASK, GET_STATE (STATE_CS));

    ALR_EM_BSIC_REQUEST;

  }
  /*
   * cs_bsic_req is called from several places with mph_bsic_req EQ NULL
   */

  switch (GET_STATE (STATE_CS))
  {
    case CS_ACTIVE_BCCH:
      ma_stop_scell_bcch_req ();
      /*
       * first stop BCCH reading,
       * then start like in idle mode if
       * it is a valid channel number
       */
    /*lint -fallthrough*/
    default:
      if (mph_bsic_req)
      {
        alr_data->cs_data.arfcn = mph_bsic_req->arfcn;
        cs_std = STD_GET_FROM_ARFCN (mph_bsic_req->arfcn);
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
        alr_data->cs_data.std  = cs_std;
#else
        if (cs_std AND (cs_std NEQ alr_data->cs_data.std))
        { /*
           * When RR supplies a value of 'std' then init radio band before sync
           */
          TRACE_EVENT_WIN_P2("cs_bsic_req: cs_std=%u->%u",
            alr_data->cs_data.std, cs_std);
          alr_data->cs_data.std  = cs_std;
          ma_cs_init_l1_req(alr_data->cs_data.std);
          SET_STATE(STATE_CS, CS_INIT_SYNC);
          return; /* wait of MPHC_INIT_L1_CON */
        }
#endif
      }
      /* If no value of 'std' are supplied, then start sync immediately */
    /*lint -fallthrough*/
    case CS_INIT_DONE:
#if defined(STOP_SYNC_TASK)
      if (alr_data->cs_data.sync_active)
      {
        /*
         * stop any synchronisation task
         */
        SET_STATE(STATE_CS, CS_STOP_SYNC);
        ma_cs_stop_network_sync_req();
        return;/* wait for MPHC_STOP_NETWORK_SYNC_CON */
      }
    /*lint -fallthrough*/
    case CS_STOP_SYNC_DONE:
#endif /* STOP_SYNC */
      /*
       * start synchronisation
       * to the frequency correction burst and synchron burst
       * in layer 1.
       */
      TRACE_EVENT_P1 ("NETWORK_SYNC_REQ[%u]", alr_data->cs_data.arfcn&ARFCN_MASK);
      ma_cs_network_sync_req (ARFCN_STD_TO_L1(alr_data->cs_data.arfcn, alr_data->cs_data.std));
      SET_STATE(STATE_CS, CS_ACTIVE_SYNC);
      break;
#if defined(STOP_SYNC_TASK)
    case CS_STOP_SYNC:
      /* do nothing, wait for MPHC_STOP_NETWORK_SYNC_CON */
      return;
#endif /* STOP_SYNC */
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_rxlev_ind               |
+--------------------------------------------------------------------+

  PURPOSE : This is the response from layer 1 for
            a measurement sample request over all channels.

*/

GLOBAL void cs_rxlev_ind (T_MPHC_RXLEV_IND* rxlev_ind)
{
  GET_INSTANCE_DATA;
#if defined(_SIMULATION_)
  {
    /*
     * special handling for windows simulation. In this case predefined
     * values are used, because the primitives are too big to be forwarded
     * via the test interface.
     */
    int index = rxlev_ind->shared_ptr;

    memcpy(alr_data->cs_data.p_results1,&tap_rxlev_response_european[index],
           sizeof(T_POWER_MEAS));

    memcpy(alr_data->cs_data.p_results2,&tap_rxlev_response_american[index],
           sizeof(T_POWER_MEAS));
  }
#endif  /* _SIMULATION_ */

  TRACE_EVENT_P3 ("cs_rxlev_ind(): cs_std=%u c_meas=%u/%u",
    alr_data->cs_data.std, alr_data->cs_data.c_meas+1, alr_data->cs_data.c_max_meas);

  if ( IS_EXT_MEAS_RUNNING AND alr_data->cs_data.ext_meas_state_pend NEQ CS_NULL )
  {
    TIMERSTOP(TIM_POWERMEAS);
    SET_STATE (STATE_CS, CS_NULL);
    nc_stop_ext_meas_ind();
    return;
  }

  switch (GET_STATE (STATE_CS))
  {
    case CS_MEASURED:

      /* increment the number of measurement samples */
      alr_data->cs_data.c_meas++;

      if (alr_data->cs_data.c_meas EQ alr_data->cs_data.c_max_meas)
      { 
        /* Allocate memory for MPH_POWER_CNF */
        PALLOC (mph_power_cnf, MPH_POWER_CNF);
        
        if (alr_data->cs_data.p_power_cnf)
        {
          PFREE (alr_data->cs_data.p_power_cnf);
        }

        alr_data->cs_data.p_power_cnf = mph_power_cnf;

        memset (alr_data->cs_data.p_power_cnf, 0, sizeof (T_MPH_POWER_CNF));

        TIMERSTOP(TIM_POWERMEAS);

        /* Sort the channels based on their RxLev */
        cs_add_and_sort_channels ();

        if(!IS_EXT_MEAS_RUNNING)
        {
          /* Free MPH_POWER_REQ buffer */
          PFREE(alr_data->cs_data.p_power_req);

          alr_data->cs_data.p_power_req = NULL;
        }

        /* Send fieldstrength list to RR */
        ma_cs_power_cnf (mph_power_cnf);

        /* we are done with power measurements, next comes the BCCH detection */
        SET_STATE (STATE_CS, CS_NULL);

        alr_data->cs_data.p_power_cnf = NULL;

        ALR_EM_POWER_MEASUREMENT_CONFIRM;
      }
      else
      if (alr_data->cs_data.c_meas < alr_data->cs_data.c_max_meas)
      {
       /*
        * start next sample
        */
        if ((alr_data->cs_data.freq_area & ALL_FREQ_AREA) EQ ALL_FREQ_AREA)
        { /*
           * toggle radio_band and configure new before the next measurement
           */
          TRACE_EVENT_P2 ("cs_rxlev_ind(): area=%02x->%02x",
            alr_data->cs_data.freq_area,
            alr_data->cs_data.freq_area^NEXT_AMERICAN_AREA);
          alr_data->cs_data.freq_area ^= NEXT_AMERICAN_AREA;
#ifndef TI_PS_FF_QUAD_BAND_SUPPORT
          SET_STATE (STATE_CS, CS_INIT_L1);
#endif
        }
#ifndef TI_PS_FF_QUAD_BAND_SUPPORT
        else
        { /*
           * start new measurement without new configuration of radio_band
           */
#endif
        SET_STATE (STATE_CS, CS_START_MEASURE);
#ifndef TI_PS_FF_QUAD_BAND_SUPPORT
        }
#endif
        ma_cs_rxlev_req ();
      }
      break;

    default:
      break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_network_sync_ind        |
+--------------------------------------------------------------------+

  PURPOSE : The function handles the result of a search for FCB or SCB.

*/

GLOBAL void cs_network_sync_ind (T_MPHC_NETWORK_SYNC_IND* sync_ind)
{
  GET_INSTANCE_DATA;
  PALLOC (mph_bsic_cnf, MPH_BSIC_CNF);

  alr_data->cs_data.sync_active = FALSE;
  /*
   * The BCCH fail counter has to be reinitialized for every new cell.
   */
  alr_data->cs_data.bcch_fail_count = CS_BCCH_FAIL_COUNT_MAX;
  /*
   * copy arfcn, rxlev and bsic
   */
  mph_bsic_cnf->arfcn  = ARFCN_STD_TO_G23(sync_ind->radio_freq, alr_data->cs_data.std);
  mph_bsic_cnf->arfcn  = STD_ADD_TO_ARFCN(mph_bsic_cnf->arfcn, alr_data->cs_data.std);
  /* US_BIT should be used to differentiate an US frequency channel. */
  switch (alr_data->cs_data.std)
  {
    case STD_1900:
    case STD_850:
    case STD_DUAL_US:
      mph_bsic_cnf->arfcn |= US_BIT;
      break;
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
    case STD_850_1800:
    case STD_850_900_1800:
      if ((mph_bsic_cnf->arfcn >= LOW_CHANNEL_850) && (mph_bsic_cnf->arfcn <= HIGH_CHANNEL_850))
        mph_bsic_cnf->arfcn |= US_BIT;
      break;
    case STD_900_1900:
      if ((mph_bsic_cnf->arfcn >= LOW_CHANNEL_1900) && (mph_bsic_cnf->arfcn <= HIGH_CHANNEL_1900))
        mph_bsic_cnf->arfcn |= US_BIT;
      break;
    case STD_850_900_1900:
      if (mph_bsic_cnf->arfcn >= HIGH_CHANNEL_900)
        mph_bsic_cnf->arfcn |= US_BIT;
      break;
#endif
    default:
      break;
  }

  /*
   * set bsic and result code
   */
  mph_bsic_cnf->bsic   = (UBYTE)(sync_ind->bsic & 63);
  mph_bsic_cnf->cs = sync_ind->sb_flag ? CS_NO_ERROR : CS_NO_BCCH_AVAIL;
  
/* Implements Measure#32: Row 21 and 22 */
  if (sync_ind->sb_flag)
  {
    TRACE_EVENT_P3 ("network_sync_ind:[%u] rf=%u cs_std=%u OK",
      mph_bsic_cnf->arfcn&ARFCN_MASK,
      sync_ind->radio_freq, alr_data->cs_data.std);
  }
  else
  {
    TRACE_EVENT_P3 ("network_sync_ind:[%u] rf=%u cs_std=%u no BCCH avail.",
      mph_bsic_cnf->arfcn&ARFCN_MASK,
      sync_ind->radio_freq, alr_data->cs_data.std);
  }

  switch (GET_STATE(STATE_CS))
  {
    /*
     * workarounds for crossing MPHC_STOP_NETWORK_SYNC_REQ and
     * MPHC_NETWORK_SYNC_IND:
     * It is possible to receive a MPHC_NETWORK_SYNC_IND from layer 1 at the
     * same time as sending a MPHC_STOP_NETWORK_SYNC_REQ. The
     * MPHC_STOP_NETWORK_SYNC_REQ will be ignored by the layer 1 and no
     * STOP_NW_SYNC_CON will be send.
     */
  case CS_STOP_SYNC:
    /* The state CS_STOP_SYNC was set and the MPHC_NETWORK_SYNC_REQ was
     * interrupted to clean the way for a new MPHC_NETWORK_SYNC_REQ. A possible
     * MPHC_NETWORK_SYNC_IND will be treated as MPHC_STOP_NETWORK_SYNC_CON
     * because the result does not matter.
     */
    SET_STATE (STATE_CS, CS_STOP_SYNC_DONE);
    cs_bsic_req(NULL);
    /*lint -fallthrough */
  default:
    /*
     * the synchronisation has been broken
     */
    ALR_TRACE_CS ("MPHC_NETWORK_SYNC_IND ignored");
    PFREE (mph_bsic_cnf);
    return;
    /* break; */

  case CS_NW_SYNC_TIMEOUT:
    /*
     * The state CS_NW_SYNC_TIMEOUT was set and the MPHC_NETWORK_SYNC_REQ was
     * interrupted to limit the time for reading the BCCH. A possible
     * MPHC_NETWORK_SYNC_IND will be treated normal. Otherwise, no BSIC_CNF
     * will be sent to RR, and RR waits forever.
     */
    SET_STATE(STATE_CS, CS_ACTIVE_SYNC);
    /*lint -fallthrough */
  case CS_ACTIVE_SYNC:
    ma_bsic_cnf (mph_bsic_cnf);
    break;
  }

#ifdef GPRS
  if(alr_data->gprs_data.pcco_active)
  {
    USHORT index;
    /* store data in nc_data.cr_cell */
    alr_data->nc_data.cr_cell.ba_arfcn     =
      ARFCN_TO_G23(sync_ind->radio_freq)&ARFCN_MASK;
    alr_data->nc_data.cr_cell.bsic         = (UBYTE)(sync_ind->bsic & 63);
    alr_data->nc_data.cr_cell.frame_offset = sync_ind->fn_offset;
    alr_data->nc_data.cr_cell.time_align   = sync_ind->time_alignment;

    index = nc_get_index(alr_data->nc_data.cr_cell.ba_arfcn);
    if ((index NEQ NOT_PRESENT_16BIT) AND (index NEQ LAST_BSIC_REQ))
    {
      /*
       * update in nc_data also because this data is not valid
       * anymore after a network_sync_req and in some special cases
       * nc_start_reselect will use the data in nc_data.cell[index]
       */
      alr_data->nc_data.cell[index].bsic         = (UBYTE)(sync_ind->bsic & 63);
      alr_data->nc_data.cell[index].frame_offset = sync_ind->fn_offset;
      alr_data->nc_data.cell[index].time_align   = sync_ind->time_alignment;
    }
    SET_STATE(STATE_CS, CS_NULL);
    return;
  }
#endif
  if (sync_ind->sb_flag)
  {
    if (GET_STATE (STATE_CS) EQ CS_ACTIVE_SYNC)
    {
      USHORT arfcn;
      PALLOC(new_scell, MPHC_NEW_SCELL_REQ);

      arfcn = ARFCN_STD_TO_G23(sync_ind->radio_freq, alr_data->cs_data.std);
      ALR_TRACE_CS_SYNC_VALID(arfcn, sync_ind->fn_offset,
                              sync_ind->time_alignment);

      /* store data in nc_data.cr_cell */
      alr_data->nc_data.cr_cell.ba_arfcn     =
        ARFCN_TO_G23(sync_ind->radio_freq)&ARFCN_MASK;
      alr_data->nc_data.cr_cell.bsic         = sync_ind->bsic;
      alr_data->nc_data.cr_cell.frame_offset = 0;
      alr_data->nc_data.cr_cell.time_align   = 0;

      new_scell->radio_freq     = sync_ind->radio_freq;
      new_scell->fn_offset      = sync_ind->fn_offset;
      new_scell->time_alignment = sync_ind->time_alignment;
      new_scell->tsc            = sync_ind->bsic;

      ALR_EM_BSIC_CONFIRM(EM_AVAIL);

      /* after successful sync we can use narrow band search mode for 
       * subsequent syncs.
       */
      alr_data->cs_data.search_mode = SM_NARROW_MODE;
      alr_data->cs_data.sync_fail_count = CS_SYNC_FAIL_COUNT_MAX;

      alr_data->sc_band = get_band (arfcn);
      ma_new_scell_req(new_scell);
    }
  }
  else
  {
    ALR_TRACE_CS ("INVALID BLOCK");

    ALR_EM_BSIC_CONFIRM(EM_NOT_AVAIL);
    /* If there are too many failed sync attempts in a row the AFC value
     * in L1 might be screwed up somehow.
     */
    if(alr_data->cs_data.sync_fail_count EQ 0)
    {
      alr_data->cs_data.sync_fail_count = CS_SYNC_FAIL_COUNT_MAX;
      alr_data->cs_data.search_mode = SM_WIDE_MODE;
    }
    else
    {
      alr_data->cs_data.sync_fail_count -= 1;
    }

  }
  SET_STATE(STATE_CS, CS_NULL);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_stop                    |
+--------------------------------------------------------------------+

  PURPOSE : Process signal cs_stop from SDL process
            Main_Control. This function stops all cell selection
         activities of ALR.

*/

GLOBAL void cs_stop (void)
{
  GET_INSTANCE_DATA;
  switch (GET_STATE (STATE_CS))
  {
    case CS_ACTIVE_MEASURE:
    {
      PALLOC (stop_req, MPHC_STOP_RXLEV_REQ);
      PSENDX (L1, stop_req);
      if ( IS_EXT_MEAS_RUNNING )
      {
        /* wait for MPHC_RXLEV_IND */
        alr_data->cs_data.ext_meas_state_pend = CS_ACTIVE_MEASURE;
      }
      break;
    }
    case CS_ACTIVE_SYNC:
    {
      PALLOC (stop_req, MPHC_STOP_NETWORK_SYNC_REQ);
      TIMERSTOP(TIM_NW_SYNC_GUARD);
      PSENDX (L1, stop_req);
      break;
    }
    case CS_ACTIVE_BCCH:
      /*
       * Stop BCCH reading
       */
      ma_stop_scell_bcch_req ();
      break;
    default:
      break;
  }
  SET_STATE (STATE_CS, CS_NULL);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_read_scell_bcch         |
+--------------------------------------------------------------------+

  PURPOSE : Process signal cs_read_scell_bcch from SDL process
            Main_Control. This funtion requests reading of the full
            serving cell BCCH.

*/
GLOBAL void cs_read_scell_bcch (void)
{
  GET_INSTANCE_DATA;
    /*
     * send bcch req
     * do full normal BCCH reading(modulus=1,position=0)
     */
    SET_STATE(STATE_CS, CS_ACTIVE_BCCH);
    ma_scell_full_nbcch();
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_add_and_sort_channels   |
+--------------------------------------------------------------------+

  PURPOSE : Accumulate power measurements for all found channels
            sorted by highest fieldstrength.
*/

LOCAL void cs_add_and_sort_channels (void)
{
  GET_INSTANCE_DATA;
  T_MPH_POWER_CNF* mph_power_cnf = alr_data->cs_data.p_power_cnf;
  T_MPH_POWER_REQ* mph_power_req = alr_data->cs_data.p_power_req;
  T_POWER_MEAS *p_results[MAX_REGIONS];
  T_POWER_ARRAY *parray, *pbig, *last;
  SHORT    rxlev, min_rxlev[MAX_NUM_BANDS+1];
  /*lint -e644 (Warning -- Variable 'band_index'  may not have been initialized) */
  UBYTE x, band_index = 0;
  /*lint +e644 (Warning -- Variable 'band_index'  may not have been initialized) */
  U16      i, j, p_results_size[MAX_REGIONS], arfcn;
  U8       radio_band_config, std[MAX_REGIONS];
  U8       no_of_attempts, region, where_to_add;
  U8       i_cnf, extra_cnf, extra_space;
  U8       no_of_carriers_per_band[4] = {0, 0, 0, 0}; /* Counter for Multible frequency band in a Region
                                                       * Index 0 for GSM_900,
                                                       * Index 1 for DCS_1800,
                                                       * Index 2 for GSM_850,
                                                       * Index 3 for PCS_1900
                                                       */
  /* Obtain data for European region */
  p_results[EUROPEAN_REGION]      = alr_data->cs_data.p_results1;
  p_results_size[EUROPEAN_REGION] = alr_data->cs_data.p_results1 ? 
    (alr_data->cs_data.p_results1->power_array_size) : 0;

  /* Obtain data for American region */
  p_results[AMERICAN_REGION]      = alr_data->cs_data.p_results2;
  p_results_size[AMERICAN_REGION] = alr_data->cs_data.p_results2 ? 
    alr_data->cs_data.p_results2->power_array_size : 0;

  TRACE_FUNCTION ( "cs_add_and_sort_channels()" );

  if (!mph_power_cnf)
  {
    TRACE_EVENT ("mph_power_cnf EQ NULL");
    SET_STATE (STATE_CS, CS_NULL);
    return;
  }

  i_cnf = 0;
  extra_cnf = MAX_CHANNELS - 1;
  mph_power_cnf->num_of_chan = 0;


  /* Set the minimum signal level */
  if ( IS_EXT_MEAS_RUNNING  )
  {
    no_of_attempts = power_scan_attempts[FULL_SEARCH_MODE];
    for(x=0 ; x<=MAX_NUM_BANDS ; x++ )
        min_rxlev[x] = SHRT_MIN + 1;
  }
  else
  {
    if (!mph_power_req)
    {
      TRACE_EVENT ("mph_power_req EQ NULL");
      SET_STATE (STATE_CS, CS_NULL);
      return;
    }

    no_of_attempts = power_scan_attempts[mph_power_req->search_mode];
    for(x=0 ; x<MAX_NUM_BANDS ; x++ )
        min_rxlev[x]      = mph_power_req->lower_rxlevel_threshold[x] * no_of_attempts;
    /* If the std value cannot be retreived use the 
      * default lower_rxlev_threshold value of 4
      */
    min_rxlev[MAX_NUM_BANDS] = LOWER_RXLEV_THRESHOLD; 
  }

  TRACE_EVENT_P5 ("cs_add_and_sort_channels: std12=%02x max=%u/%u a='%c%c'",
    alr_data->cs_data.std12,
    p_results_size[EUROPEAN_REGION],
    p_results_size[AMERICAN_REGION],
    (alr_data->cs_data.freq_area & EUROPEAN_FREQ_AREA) ? 'E' : ' ',
    (alr_data->cs_data.freq_area & AMERICAN_FREQ_AREA) ? 'A' : ' ');

  if ((alr_data->cs_data.freq_area&ALL_FREQ_AREA) EQ ALL_FREQ_AREA)
  {
    /* use 'std' values saved by cs_prepare_power_req() */
    std[EUROPEAN_REGION] = alr_data->cs_data.std12&0x0f;
    std[AMERICAN_REGION] = alr_data->cs_data.std12>>4;
  }
  else
  {
    /* only one area */
    std[EUROPEAN_REGION] = std[AMERICAN_REGION] = alr_data->cs_data.std;
    if (alr_data->cs_data.freq_area & EUROPEAN_FREQ_AREA)
      p_results_size[AMERICAN_REGION] = 0;
    if (alr_data->cs_data.freq_area & AMERICAN_FREQ_AREA)
      p_results_size[EUROPEAN_REGION] = 0;
  }

  if( IS_EXT_MEAS_RUNNING )
  {
    /* 
     * According to 3GPP 05 08
     * Section "Range of parameter RxLev"
     *
     * The measured signal level shall be mapped to an RXLEV value between 0 and 63, as follows:
     * RXLEV 0 = less than    -110 dBm + SCALE.
     * RXLEV 1 =  -110 dBm + SCALE  to  -109 dBm + SCALE.
     * RXLEV 2 =  -109 dBm + SCALE  to  -108 dBm + SCALE.
     * :
     * :
     * RXLEV 62 =  -49 dBm + SCALE  to  -48 dBm + SCALE.
     * RXLEV 63 = greater than   -48 dBm + SCALE.
     * where SCALE is an offset that is used only in the ENHANCED MEASUREMENT REPORT message, 
     * otherwise it is set to 0. 
     */

    for(i=0; i < p_results_size[EUROPEAN_REGION]; i++)
      if( p_results[EUROPEAN_REGION]->power_array->accum_power_result < 0 )
        p_results[EUROPEAN_REGION]->power_array->accum_power_result = 0;

    for(i=0; i < p_results_size[AMERICAN_REGION]; i++)
      if( p_results[AMERICAN_REGION]->power_array->accum_power_result < 0 )
        p_results[AMERICAN_REGION]->power_array->accum_power_result = 0;
  }
  else
  {
    /* LLD Section : 4.1.3.4.2
     * Find all inactive carriers and add them to MPH_POER_CNF
     * Also set the Rxlev of all Black Listed carriers to less than
     * Lower_Rxlev_Threshold
     */

    TRACE_EVENT_P2("BIC->PWR array size, E:%d, A:%d", 
                    p_results_size[0], p_results_size[1]);

    cs_find_inactive_carriers(p_results, p_results_size,
                              std, no_of_attempts,
                              min_rxlev);

    TRACE_EVENT_P2("AIC->PWR array size, E:%d, A:%d",
                     p_results_size[0], p_results_size[1]);

    /*
     * If the search mode is BLACK_LIST_SEARCH_MODE no need for sorting 
     * (based on RXLEV) the carriers (RR will look only for
     * inactive carrier list)
     */
    if(mph_power_req->search_mode EQ BLACK_LIST_SEARCH_MODE)
    {
      /* Allow measurement indications posting to RR */
      SET_STATE(STATE_NC,NC_IDLE);
      return;
    }

    /* Put whitelist carriers at the top of power cnf list */
    if(mph_power_req->white_list.white_list_valid)
    {
      region = mph_power_req->white_list.region;

      switch(mph_power_req->white_list.region)
      {
        case EUROPEAN_REGION :
        case AMERICAN_REGION :
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
        case BOTH_REGIONS:
          i_cnf = cs_add_whitelist_carriers(p_results_size, std,
                                            no_of_attempts,
                                            min_rxlev, p_results,
                                            no_of_carriers_per_band);
#else
          i_cnf = cs_add_whitelist_carriers(p_results_size,
                                            std[region], no_of_attempts,
                                            min_rxlev, p_results[region],
                                            no_of_carriers_per_band);
#endif
          TRACE_EVENT_P5(
            "[%c]White list Area (B_GSM_EGSM:%d, B_1800:%d, B_850:%d, B_1900:%d)",
            (mph_power_req->white_list.region ? 'A' : 'E'),
            no_of_carriers_per_band[0], no_of_carriers_per_band[1],
            no_of_carriers_per_band[2], no_of_carriers_per_band[3]);          
          break;
        default :
          TRACE_EVENT_P1("Invalid whitelist region:%d",region);
          break;
      }
    } /* white list valid */
    else
    {
      TRACE_EVENT("WL is absent");
    }
  } /* !ext_meas */

  TRACE_EVENT_P3("AWL->PWR array size, E:%d A:%d i_cnf:%d",
                  p_results_size[0], p_results_size[1],i_cnf);

  while (i_cnf < MAX_CHANNELS)
  {
    pbig=NULL;
    rxlev = 0;
    radio_band_config = where_to_add =0x00;

    /* Loop through both regions */
    for (i=0;i<MAX_REGIONS;i++)
    {
      if((p_results_size[i]) AND (p_results[i] NEQ NULL))
      {
        parray = p_results[i]->power_array;

        for (j=0; j<p_results_size[i]; j++, parray++)
        {
          arfcn = ARFCN_STD_TO_G23(parray->radio_freq, std[i]);
          /*lint -e661 (Warning -- Possible access of out-of-bounds) */
          get_band_index_from_arfcn(arfcn, x, std[i]); 
          if (parray->accum_power_result >= min_rxlev[x] AND parray->accum_power_result > rxlev)
          {
            pbig = parray;
            rxlev = parray->accum_power_result;
            radio_band_config = std[i];
            region = (U8) i;
            band_index = x;
          }
          /*lint +e661 (Warning -- Possible access of out-of-bounds) */
        }
      }
    }

    if( pbig NEQ NULL )
    {
      arfcn = ARFCN_STD_TO_G23(pbig->radio_freq, radio_band_config);
      if (rxlev > (min_rxlev[band_index] -1))
      {
        /* fill mph_power_cnf */
        arfcn = STD_ADD_TO_ARFCN(arfcn, radio_band_config);

        /* US_BIT should be used to differentiate an US frequency channel. */
        switch (radio_band_config)
        {
          case STD_1900:
          case STD_850:
          case STD_DUAL_US:
            arfcn |= US_BIT;
            break;
          default:
            break;
        }

        where_to_add = cs_restrict_max_carriers_per_band(
                         arfcn&ARFCN_MASK, 
                         radio_band_config,
                         no_of_carriers_per_band,
                         p_results_size, min_rxlev[band_index]);

        if(where_to_add EQ ADD_AT_THE_TOP)
        {  
          /* First 40 Strongest Cariiers */
          mph_power_cnf->arfcn[i_cnf]  = arfcn;
          mph_power_cnf->rx_lev[i_cnf] = (U8)(rxlev/no_of_attempts);
  
          i_cnf++;
        }
        else if(where_to_add EQ ADD_AT_THE_BOTTOM)
        {
          /* Strongest Carriers which fall between 41 to 60 */
          if(extra_cnf >= i_cnf)
          {
            mph_power_cnf->arfcn[extra_cnf]  = arfcn;
            mph_power_cnf->rx_lev[extra_cnf] = (U8)(rxlev/no_of_attempts);

            extra_cnf--;
          }
          else
          {
            TRACE_EVENT_P2("MPH_POWER_CNF crossover, i_cnf: %d extra_cnf: %d",
              i_cnf, extra_cnf);
          }
        }

       /* After adding a carrier to MPH_POWER_CNF, the particular carrier will be 
        * replaced by the Last carrier of that region. So that we could avoid
        * searching the already added (MPH_POWER_CNF) carrier.
        */
        if(where_to_add NEQ REACHED_THE_MAXIMUM)
        {
          last = p_results[region]->power_array + (p_results_size[region]-1);/*lint !e644 region may not have been initialized */
  
          pbig->accum_power_result = min_rxlev[band_index] - 1;
        
          cs_power_array_swap_arfcn(pbig, last);
  
          p_results_size[region]--;
        }
        else
        {
          TRACE_EVENT_P4("RTM->PWR array size, E:%d A:%d i_cnf:%d extra_cnf:%d",
            p_results_size[0], p_results_size[1],i_cnf, 
            (MAX_CHANNELS-(extra_cnf+1)));
        }
      }
    }
    else
      break; /* no level found higher or equal than min_rxlev -> break sort/fill */

  }/* while (i_cnf < MAX_CHANNELS) */

  mph_power_cnf->num_of_chan = i_cnf;

  /* Obtain the number of extra channels(41 to 60) added to 
   * Power cnf array 
   */
  extra_cnf   = MAX_CHANNELS - (extra_cnf+1);

  /* Obtain the amount of space available for extra channels
   * in power_cnf array
   */
  extra_space = MAX_CHANNELS - i_cnf;

  TRACE_EVENT_P3("After Sorting, i_cnf:%d extra_cnf:%d extra_space:%d",
                 i_cnf,extra_cnf,(extra_space-extra_cnf));

  if(extra_cnf AND extra_space)
  {
    /* Extra channels are present and space to fit them is also available */
    if(extra_space < extra_cnf)
    {
      /* Some of the extra channels(41 to 60) are overwritten
       * Ignore them
       */
      extra_cnf = extra_space;
    }

     /* Reordering the carriers(41 to 60) from Strongest to Weakest */
     cs_reorder_the_extra_carriers(extra_cnf);

     /* Move the extra carriers up in power_cnf array, in case there
      * is empty gap between i_cnf and extra_cnf channels
      */
     if(extra_space > extra_cnf)
       cs_move_extra_carriers(i_cnf, extra_cnf);

     mph_power_cnf->num_of_chan += extra_cnf;
  }

  TRACE_EVENT_P5(
    "No. of carriers in POWER_CNF:%d (B_GSM_EGSM:%d, B_1800:%d, B_850:%d, B_1900:%d)",
    mph_power_cnf->num_of_chan,
    no_of_carriers_per_band[0], no_of_carriers_per_band[1],
    no_of_carriers_per_band[2], no_of_carriers_per_band[3]);
}



/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : get_band                   |
+--------------------------------------------------------------------+

  PURPOSE : The function extracts the frequency band from the given
            'arfcn' parameter.
*/

GLOBAL UBYTE get_band (USHORT arfcn)
{
  UBYTE local_std = STD_GET_FROM_ARFCN(arfcn);
  UBYTE sc_band;

  if (local_std EQ 0)
    local_std = std;

  switch (local_std)
  {
    case STD_900:
      sc_band = BAND_GSM_900;
      break;

    case STD_EGSM:
      sc_band = BAND_E_GSM;
      break;

    case STD_1800:
      sc_band = BAND_DCS_1800;
      break;

    case STD_1900:
      sc_band = BAND_PCS_1900;
      break;

    case STD_850:
      sc_band = BAND_GSM_850;
      break;

    case STD_DUAL:
      if (arfcn >= LOW_CHANNEL_1800)
        sc_band = BAND_DCS_1800;
      else
        sc_band = BAND_GSM_900;
      break;

    case STD_DUAL_EGSM:
      if (arfcn >= LOW_CHANNEL_EGSM)
        sc_band = BAND_E_GSM;
      else if (arfcn >= LOW_CHANNEL_1800)
        sc_band = BAND_DCS_1800;
      else if (arfcn EQ CHANNEL_0)
        sc_band = BAND_E_GSM;
      else
        sc_band = BAND_GSM_900;
      break;

    case STD_DUAL_US:
      if (arfcn >= LOW_CHANNEL_1900)
        sc_band = BAND_PCS_1900;
      else
        sc_band = BAND_GSM_850;
      break;

#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
    case STD_850_1800:
      if (arfcn >= LOW_CHANNEL_1800)
        sc_band = BAND_DCS_1800;
      else
        sc_band = BAND_GSM_850;
      break;

    case STD_900_1900:
      if (arfcn >= LOW_CHANNEL_EGSM)
        sc_band = BAND_E_GSM;
      else if (arfcn >= LOW_CHANNEL_1900)
        sc_band = BAND_PCS_1900;
      else if (arfcn EQ CHANNEL_0)
        sc_band = BAND_E_GSM;
      else
        sc_band = BAND_GSM_900;
      break;

    case STD_850_900_1800:
      if (arfcn >= LOW_CHANNEL_EGSM)
        sc_band = BAND_E_GSM;
      else if (arfcn >= LOW_CHANNEL_1800)
        sc_band = BAND_DCS_1800;
      else if (arfcn EQ CHANNEL_0)
        sc_band = BAND_E_GSM;
      else if (arfcn >= LOW_CHANNEL_850)
        sc_band = BAND_GSM_850;
      else
        sc_band = BAND_GSM_900;
      break;

    case STD_850_900_1900:
      if (arfcn >= LOW_CHANNEL_EGSM)
        sc_band = BAND_E_GSM;
      else if (arfcn >= LOW_CHANNEL_1900)
        sc_band = BAND_PCS_1900;
      else if (arfcn EQ CHANNEL_0)
        sc_band = BAND_E_GSM;
      else if (arfcn >= LOW_CHANNEL_850)
        sc_band = BAND_GSM_850;
      else
        sc_band = BAND_GSM_900;
      break;
#endif

    default:
      sc_band = 0;
      break;
  }
  /* this trace causes a lot of trace load; switch on only if needed
  TRACE_EVENT_P2 ("[%u] sc_band=%02x", arfcn&ARFCN_MASK, sc_band);
  */
  return sc_band;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_increment_bfc           |
+--------------------------------------------------------------------+

  PURPOSE : The function increments the BCCH fail counter. This 
            counter is decremented on every invalid BCCH block read 
            during CS. It is incremented on evry valid block read on
            BCCH during CS. Valid means in this case that there was a
            SYS Info decodable in the block on the BCCH. There is a 
            maximum value to start with and when the counter reaches 
            0 we switch back to wide band search mode for further
            MPHC_NETWORK_SYNC_REQs (if any).
*/

GLOBAL void cs_increment_bfc (void)
{
  GET_INSTANCE_DATA;
  alr_data->cs_data.bcch_fail_count += 1;
  if(alr_data->cs_data.bcch_fail_count > CS_BCCH_FAIL_COUNT_MAX)
    alr_data->cs_data.bcch_fail_count = CS_BCCH_FAIL_COUNT_MAX;
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_decrement_bfc           |
+--------------------------------------------------------------------+

  PURPOSE : The function decrements the BCCH fail counter. This 
            counter is decremented on every invalid BCCH block read 
            during CS. It is incremented on evry valid block read on
            BCCH during CS. Valid means in this case that there was a
            SYS Info decodable in the block on the BCCH. There is a 
            maximum value to start with and when the counter reaches 
            0 we switch back to wide band search mode for further
            MPHC_NETWORK_SYNC_REQs (if any).
*/

GLOBAL void cs_decrement_bfc (void)
{
  GET_INSTANCE_DATA;
  if(alr_data->cs_data.bcch_fail_count < 3)
  {
    alr_data->cs_data.bcch_fail_count = 0;
    alr_data->cs_data.search_mode = SM_WIDE_MODE;
  }
  else
    alr_data->cs_data.bcch_fail_count -= 2;

}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_set_wideband_sync       |
+--------------------------------------------------------------------+

  PURPOSE : The function sets wide band search mode for further
            MPHC_NETWORK_SYNC_REQs (if any).
*/

GLOBAL void cs_set_wideband_sync (void)
{
  GET_INSTANCE_DATA;
  alr_data->cs_data.search_mode = SM_WIDE_MODE;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_is_in_black_list        |
+--------------------------------------------------------------------+

  PURPOSE : The function checks whether the given carrier is in the
            Blacklist or not
            CSI-LLD section: 4.1.3.4.2.1
*/

LOCAL BOOL cs_is_in_black_list(U8 region,U16 arfcn)
{
  GET_INSTANCE_DATA;
  BOOL ret = FALSE;

  if((region EQ EUROPEAN_REGION) OR (region EQ AMERICAN_REGION))
  {
    if(alr_data->cs_data.p_power_req->search_mode EQ FULL_SEARCH_MODE)
    {
      return ret;
    }

    ret = srv_get_channel((T_LIST*)&alr_data->cs_data.p_power_req->black_list.list[region],
                            arfcn&ARFCN_MASK);

    if(ret)
    {
      if(srv_get_region_from_std(alr_data->cs_data.std) == region
         AND nc_is_in_ba(arfcn&ARFCN_MASK))
      {
        TRACE_EVENT_P1 ("ARFCN %d found in BA and Black list", arfcn & ARFCN_MASK);
        ret = FALSE;
      }
    }    

  }
  return ret;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_find_inactive_carriers  |
+--------------------------------------------------------------------+

  PURPOSE : 1. Finds all inactive carriers
            2. Sets the RxLev of all Blacklisted carriers to less than
               LOWER_RXLEV_THRESHOLD
            CSI-LLD Section: 4.1.3.8.2.2.1
            CSI-LLD Section: 4.2
*/

LOCAL void cs_find_inactive_carriers (T_POWER_MEAS **p_results,
                                      U16 p_results_size[2],U8 *std,
                                      U8 no_of_attempts, SHORT *min_rxlev)
{
  GET_INSTANCE_DATA;
  T_POWER_ARRAY* parray, *last;
  U16 j, arfcn;
  U8 i, x=0;
  T_MPH_POWER_CNF* mph_power_cnf = alr_data->cs_data.p_power_cnf;

  TRACE_FUNCTION("cs_find_inactive_carriers ()");

  /* Loop through both regions */
  for (i=0;i<MAX_REGIONS;i++)
  {
    if((p_results_size[i]) AND (p_results[i] NEQ NULL))
    {
      parray = p_results[i]->power_array;

      for (j=0; j<p_results_size[i];)
      {
        arfcn = ARFCN_STD_TO_G23(parray->radio_freq, std[i]);
        /* Pointer to the Last Power array for a particular region */
        last = (p_results[i]->power_array + (p_results_size[i]-1));
        /*lint -e661 (Warning -- Possible access of out-of-bounds) */
        get_band_index_from_arfcn(arfcn, x, std[i]);
        if (parray->accum_power_result < min_rxlev[x])
        {
        /*lint +e661 (Warning -- Possible access of out-of-bounds) */
          /* Inactive carrier */
          srv_set_channel((T_LIST*)&mph_power_cnf->inactive_carrier_list.list[i],
                          arfcn&ARFCN_MASK);
          
          /* Replace inactive carrier with the last active carrier */
          cs_power_array_swap_arfcn(parray,last);
 
          /* Decrement the power array size to exclude this carrier */
          p_results_size[i]--;
        }
        else if(cs_is_in_black_list(i, (U16)(arfcn&ARFCN_MASK)))
        {
          /* Carrier is black listed. No need to consider this */
          /*lint -e661 (Warning -- Possible access of out-of-bounds) */
          parray->accum_power_result = min_rxlev[x]-1;
          /*lint +e661 (Warning -- Possible access of out-of-bounds) */
          /* Replace inactive carrier with the last active carrier */
          cs_power_array_swap_arfcn(parray,last);
 
          /* Decrement the power array size to exclude this carrier */
          p_results_size[i]--;

        }
        else
        {
          j++, parray++;
        }
      } /* for size */
    } /* if size */
  }  /* MAX_REGIONS */
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE : cs_whitelist_handle        |
+--------------------------------------------------------------------+

  PURPOSE : This function puts the White carriers at the top of the 
            MPH_POWER_CNF list
            CSI-LLD 4.1.3.4.2.7
*/

#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
LOCAL U8 cs_add_whitelist_carriers(U16 p_results_size[2], U8 *r_std, U8 no_of_attempts, 
                                   SHORT *min_rxlev, T_POWER_MEAS **presults,
                                   U8 no_of_carriers_per_band[4])
#else
LOCAL U8 cs_add_whitelist_carriers(U16 p_results_size[2], U8 std, U8 no_of_attempts, 
                                   SHORT *min_rxlev,
                                   T_POWER_MEAS *presults,
                                   U8 no_of_carriers_per_band[4])
#endif
{
  GET_INSTANCE_DATA;
  T_MPH_POWER_CNF* mph_power_cnf = alr_data->cs_data.p_power_cnf;
  T_MPH_POWER_REQ* mph_power_req = alr_data->cs_data.p_power_req;
  U8  i_cnf,j, where_to_add = DO_NOT_ADD;
  U8  region = mph_power_req->white_list.region;
  U16 i,arfcn, temp_arfcn;
  U8  temp_rxlev;
  UBYTE x=0;
  T_POWER_ARRAY *parray, *last;
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
  U8 std, start_region, no_of_regions, k;
#endif

  TRACE_FUNCTION ("cs_add_whitelist_carriers()");

  i_cnf = 0;

#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
  if (region EQ BOTH_REGIONS)
  {
    if((!(p_results_size[EUROPEAN_REGION]) OR (presults[EUROPEAN_REGION] EQ NULL)) AND 
       (!(p_results_size[AMERICAN_REGION]) OR (presults[AMERICAN_REGION] EQ NULL)))
       return i_cnf;
  }
  else if(!(p_results_size[region]) OR (presults EQ NULL))
  {
#endif
    return i_cnf;
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
  }
#endif

  /* Move the white list carriers to MPH_POWER_CNF array first */
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
  if (region EQ BOTH_REGIONS)
  {
    start_region = EUROPEAN_REGION;
    no_of_regions = MAX_REGIONS;
  }
  else if (region EQ EUROPEAN_REGION)
  {
    start_region = region;
    no_of_regions = MAX_REGIONS - 1;
  }
  else
  {
    start_region = region;
    no_of_regions = MAX_REGIONS;
  }
  
  for (k=start_region; k< no_of_regions; k++)
  {
    std = r_std[k];
    parray = presults[k]->power_array;

    for (i=0; (i<p_results_size[k] AND i_cnf < 32); )
#else
  for (i=0; (i<p_results_size[region] AND i_cnf < 32); )
#endif
    {
    /* Convert to GSM standard format from L1 format*/
    arfcn = ARFCN_STD_TO_G23(parray->radio_freq,std);
    /*lint -e661 (Warning -- Possible access of out-of-bounds) */
    get_band_index_from_arfcn(arfcn, x, std);
    if (parray->accum_power_result > (min_rxlev[x] - 1))
    {
    /*lint +e661 (Warning -- Possible access of out-of-bounds) */
      if(srv_get_channel((T_LIST*)&mph_power_req->white_list.list, arfcn&ARFCN_MASK))
      {

        /* Channel is present in white list. Add this to top of MPH_POWER_CNF */
        arfcn = STD_ADD_TO_ARFCN(arfcn, std);

        /* US_BIT should be used to differentiate an US frequency channel. */
        switch (std)
        {
          case STD_1900:
          case STD_850:
          case STD_DUAL_US:
            arfcn |= US_BIT;
            break;
          default:
            break;
        }
        /*lint -e661 (Warning -- Possible access of out-of-bounds) */
        where_to_add = cs_restrict_max_carriers_per_band(arfcn&ARFCN_MASK, std,
                                       no_of_carriers_per_band, p_results_size, min_rxlev[x]);
        /*lint +e661 (Warning -- Possible access of out-of-bounds) */
        if(where_to_add NEQ DO_NOT_ADD)
        {
          /* White list carriers are always added at the top */
          mph_power_cnf->arfcn[i_cnf]  = arfcn;
          mph_power_cnf->rx_lev[i_cnf] = (U8)(parray->accum_power_result/no_of_attempts);
          i_cnf++;
        }
        else
        {
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
            TRACE_EVENT_P2("[WL] [DO_NOT_ADD] [%d] : [%c]", arfcn&ARFCN_MASK,
                            (k ? 'A' :'E'));
#else
            TRACE_EVENT_P2("[WL] [DO_NOT_ADD] [%d] : [%c]", arfcn&ARFCN_MASK,
                            (region ? 'A' :'E'));
#endif
          }

          /* Exclude this carrier */
          parray->accum_power_result = min_rxlev[x]-1;

#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
          last = presults[k]->power_array + (p_results_size[k] - 1);
#else
        last = presults->power_array + (p_results_size[region] - 1);
#endif

        /* Swapping the current carrier with the last carrier */
        cs_power_array_swap_arfcn(parray, last);

        /* Decrement the power array counter to exclude the above carrier */
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
          p_results_size[k]--;
#else
          p_results_size[region]--;
#endif

      } /* Present in White List */
      else
      {
        i++; parray++;
      }
    } /* Active Carrier */
    else 
    {
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
        TRACE_EVENT_P2("[WL] [IA] [%d] : [%c]", parray->radio_freq,
                        (k ? 'A' :'E'));
#else
        TRACE_EVENT_P2("[WL] [IA] [%d] : [%c]", parray->radio_freq,
                        (region ? 'A' :'E'));
#endif
      i++; parray++;
    }
  } /* i < max */
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
  }
#endif

  /* Assign the total Number of white list channels */
  mph_power_cnf->num_of_white_list_chan = i_cnf;

  TRACE_EVENT_P1("[WL] no. of channels : %d ",mph_power_cnf->num_of_white_list_chan);

  /*
   * Sort the white list carriers added to power_cnf array on the 
   * basis of their field strength
   */
  for(i=0; i < i_cnf; i++)
  {
    for(j=i+1; j<i_cnf; j++)
    {
      if(mph_power_cnf->rx_lev[i] < mph_power_cnf->rx_lev[j])
      {
        temp_rxlev = mph_power_cnf->rx_lev[i];
        temp_arfcn = mph_power_cnf->arfcn[i];

        mph_power_cnf->rx_lev[i] = mph_power_cnf->rx_lev[j];
        mph_power_cnf->arfcn[i]  = mph_power_cnf->arfcn[j];

        mph_power_cnf->rx_lev[j] = temp_rxlev;
        mph_power_cnf->arfcn[j]  = temp_arfcn;
      }
    }
  }

  return (i_cnf);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)       MODULE  : ALR_CS                     |
| STATE   : code                ROUTINE :                            |
|                                  cs_restrict_max_carriers_per_band |
+--------------------------------------------------------------------+
  PURPOSE : This function is to handle the Multiple Frequency Bands 
            in a Region. Will help to add the minimum(40) carriers per
            band on top of the power cnf and the remaining(40 to 60) 
            carriers will be added in at the end (Below the Normal (40)
            carriers of all band).
            CSI-LLD : 
*/

U8  cs_restrict_max_carriers_per_band (U16 arfcn, U8 std, 
                U8 no_of_carriers_per_band[4], U16 p_results_size[2], UBYTE min_rxlev)
{
  GET_INSTANCE_DATA;

  T_POWER_MEAS    *presults;
  T_POWER_ARRAY   *parray, *last;
  U16              i;
  U8              index = 0xff,just_reached_the_maximum=FALSE;
  U8              region, where_to_add = DO_NOT_ADD; 
  
  switch(std)
  {
    case STD_900       :
    case STD_DUAL      :
    case STD_EGSM      :
    case STD_DUAL_EGSM :
    case STD_1800      :
      if(INRANGE (CHANNEL_0, arfcn, HIGH_CHANNEL_900) OR 
         INRANGE(LOW_CHANNEL_EGSM, arfcn, HIGH_CHANNEL_EGSM))
      {
        index = 0;
      }
      else if(INRANGE (LOW_CHANNEL_1800, arfcn, HIGH_CHANNEL_1800))
      {
        index = 1;
      }
      else
      {
        TRACE_ERROR("[European]Invalid Carrier");
        return DO_NOT_ADD;
      }
      region = EUROPEAN_REGION;
      break; 
    case STD_DUAL_US :
    case STD_850     :
    case STD_1900    :
      if(INRANGE (LOW_CHANNEL_850, arfcn, HIGH_CHANNEL_850))
      {
        index = 2;
      }
      else if(INRANGE (LOW_CHANNEL_1900, arfcn, HIGH_CHANNEL_1900))
      {
        index = 3;
      }
      else
      {
        TRACE_ERROR("[American]Invalid Carrier");
        return DO_NOT_ADD;
      }
      region = AMERICAN_REGION;
      break;
  } /* end switch */

  if(index < 4)
  {
    if(no_of_carriers_per_band[index] < MIN_CHANNELS_PER_BAND)
    {
      /* Increment counter for corresponding band */
      no_of_carriers_per_band[index]++;

      if(no_of_carriers_per_band[index] EQ MIN_CHANNELS_PER_BAND)
      {      
        TRACE_EVENT_P5(
          "[%d]Band, 40 channels added (B_GSM_EGSM%d, B_1800:%d, B_850:%d, B_1900:%d)",
          index,
          no_of_carriers_per_band[0], no_of_carriers_per_band[1],
          no_of_carriers_per_band[2], no_of_carriers_per_band[3]);
      }

      /* Add at the top of MPH_POWER_CNF list */
      where_to_add = ADD_AT_THE_TOP;
    }
    else if(no_of_carriers_per_band[index] <= MAX_CHANNELS_PER_BAND)
    {
      /* Increment counter for corresponding band */
      no_of_carriers_per_band[index]++;

      /* Add at the bottom of MPH_POWER_CNF list */
      where_to_add = ADD_AT_THE_BOTTOM;

      if(no_of_carriers_per_band[index] EQ (MAX_CHANNELS_PER_BAND + 1))
      {
        TRACE_EVENT_P5(
          "[%d]Band, 60 channels added (B_GSM_EGSM%d, B_1800:%d, B_850:%d, B_1900:%d)",
          index,
          no_of_carriers_per_band[0], no_of_carriers_per_band[1],
          no_of_carriers_per_band[2], no_of_carriers_per_band[3]);

        just_reached_the_maximum = TRUE;

        where_to_add = REACHED_THE_MAXIMUM;
      }
    }
    else
    {
      where_to_add = DO_NOT_ADD;
    }
  }
  else
  {
    TRACE_ERROR("Unknown Band Index");
    return DO_NOT_ADD;
  } /* if index < 4 */

  /* When Max number of channels(60) are added for a particular band,
   * all the remaining carriers belonging to that band are excluded from
   * further sorting
   */
  if(just_reached_the_maximum)
  {
    BOOL exclude;
    U16  l3_arfcn;

    if (region EQ AMERICAN_REGION)/*lint !e644 region may not have been initialized */
    { /* American band */
      presults =  alr_data->cs_data.p_results2;
    }
    else
    { /* European band */
      presults =  alr_data->cs_data.p_results1;
    }

    TRACE_EVENT_P3("[%d]Index, E:%d A:%d",
      index, p_results_size[0], p_results_size[1]);
   
    if((presults NEQ NULL) AND (p_results_size[region]))/*lint !e644 region may not have been initialized */
    {
      for(i=0, parray = presults->power_array; i < p_results_size[region];)
      {
        exclude  = FALSE;
        l3_arfcn = ARFCN_STD_TO_G23(parray->radio_freq, std);
      
        switch(index)
        {
          case 0 :
            if(INRANGE (LOW_CHANNEL_900, l3_arfcn, HIGH_CHANNEL_900) OR 
               INRANGE(LOW_CHANNEL_EGSM, l3_arfcn, HIGH_CHANNEL_EGSM))
            {
              exclude = TRUE;
            }
            break;
          case 1:
            if(INRANGE (LOW_CHANNEL_1800, l3_arfcn, HIGH_CHANNEL_1800))
            {
              exclude = TRUE;
            }
            break;
          case 2 :
            if(INRANGE (LOW_CHANNEL_850, l3_arfcn, HIGH_CHANNEL_850))
            {
              exclude = TRUE;
            }
            break;
          case 3:
            if(INRANGE (LOW_CHANNEL_1900, l3_arfcn, HIGH_CHANNEL_1900))
            {
              exclude = TRUE;
            }
            break;
          default :
            break;
        } /* end switch */

        if(exclude)
        {
          last = presults->power_array + (p_results_size[region] - 1); /*lint !e644 region may not have been initialized */

          /* Exclude this carrier */
          parray->accum_power_result = min_rxlev-1;  

          /* Swaping the Current carrier with the last carrier */
          cs_power_array_swap_arfcn(parray, last);
  
          /* Decrement the power array counter to exclude the above carrier */
          p_results_size[region]--;
        }
        else
        {
          parray++; i++;
        }
      } /* power array size */
    } /* end if(just_reached_the_maximum */
  } /* presults NEQ NULL */

  return where_to_add;
}
#endif


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)    MODULE  : ALR_CS                        |
| STATE   : code             ROUTINE : cs_reorder_the_extra_carriers |
+--------------------------------------------------------------------+
  PURPOSE : Extra Carriers (More than 40 and below 60) are stored at
            the bottom of the MPH_POWER_CNF. But these are stored in
            ascending order (if you see from the TOP). This needs to 
            be reordered (means Strongest carrier should go to top).
*/

LOCAL void cs_reorder_the_extra_carriers(U8 extra_cnf)
{
  GET_INSTANCE_DATA;
  T_MPH_POWER_CNF* mph_power_cnf = alr_data->cs_data.p_power_cnf;
  U8     i,j,count,max_count,temp_rxlevel;
  U16    temp_arfcn;

  TRACE_FUNCTION("cs_reorder_the_extra_carriers");

  i         = MAX_CHANNELS - 1;
  j         = MAX_CHANNELS - extra_cnf;
  max_count = extra_cnf/2;


    for(count=0; count < max_count; i--, j++, count++)
    {
      temp_arfcn               = mph_power_cnf->arfcn[i];
      temp_rxlevel             = mph_power_cnf->rx_lev[i];

      mph_power_cnf->arfcn[i]  = mph_power_cnf->arfcn[j];
      mph_power_cnf->rx_lev[i] = mph_power_cnf->rx_lev[j];

      mph_power_cnf->arfcn[j]  = temp_arfcn;
      mph_power_cnf->rx_lev[j] = temp_rxlevel;

    }

}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403)     MODULE  : ALR_CS                       |
| STATE   : code              ROUTINE :                              |
|                              cs_move_extra_carriers                |
+--------------------------------------------------------------------+
  PURPOSE : Extra Carriers (More than 40 and below 60) are stored at
              the bottom of the MPH_POWER_CNF. These carriers needs to
              be rearranged below the normal (Strangest 40 Carriers)
              carriers
*/

LOCAL void cs_move_extra_carriers(U8 i_cnf, U8 extra_cnf)
{
  GET_INSTANCE_DATA;
  T_MPH_POWER_CNF* mph_power_cnf = alr_data->cs_data.p_power_cnf;

  /*
   *  Add the extra carriers below Normal carrier
   */
  TRACE_FUNCTION("cs_move_extra_carriers");

  /* Move the extra carriers below the Normal carriers */
  memmove (&mph_power_cnf->arfcn[i_cnf], 
           &mph_power_cnf->arfcn[MAX_CHANNELS - extra_cnf],
           sizeof (mph_power_cnf->arfcn[0]) * (extra_cnf));

  memmove (&mph_power_cnf->rx_lev[i_cnf],
           &mph_power_cnf->rx_lev[MAX_CHANNELS - extra_cnf],
           sizeof (mph_power_cnf->rx_lev[0]) * (extra_cnf));

}