+
−/*
+
−+-----------------------------------------------------------------------------
+
−|  Project :  GSM-PS
+
−|  Modul   :  ALR_CBCH
+
−+-----------------------------------------------------------------------------
+
−|  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 CBCH_control.
+
−+-----------------------------------------------------------------------------
+
−*/
+
−
+
−#ifndef ALR_CBCH_C
+
−#define ALR_CBCH_C
+
−
+
−#define ENTITY_PL
+
−
+
−/*==== INCLUDES ===================================================*/
+
−#include <string.h>
+
−#include <stdlib.h>
+
−#include <ctype.h>
+
−#include "typedefs.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_alr.h"
+
−#include "mon_alr.h"
+
−#include "pei.h"
+
−#include "tok.h"
+
−
+
−#include "pcm.h"
+
−#ifdef GPRS
+
−#include "alr_gprs.h"
+
−#endif
+
−#include "alr.h"
+
−#include "alr_em.h"
+
−
+
−/*==== EXPORT =====================================================*/
+
−/*==== PRIVAT =====================================================*/
+
−LOCAL void   cb_read_cbch               (UBYTE  flags);
+
−LOCAL void   cb_check_ci_lai_plmn       (void);
+
−LOCAL void   cb_remove_message          (USHORT i);
+
−LOCAL void   cb_first_block             (UBYTE  status);
+
−LOCAL UBYTE* cb_create_schedule_entries (UBYTE* msg_ptr, BOOL read_old_msg);
+
−LOCAL void   cb_create_schedule_map     (UBYTE  old_cb_msg);
+
−LOCAL UBYTE  cb_check_old_msg           (void);
+
−LOCAL UBYTE  cb_check_data_coding_scheme(UBYTE  dcs_id);
+
−LOCAL UBYTE  cb_check_message_id        (USHORT msg_id);
+
−LOCAL void   cb_store_cbch_msg          (void);
+
−LOCAL void   cb_error_ind               (void);
+
−LOCAL void   cb_cbch_message            (UBYTE  length);
+
−LOCAL void   cb_null_message            (void);
+
−LOCAL void   cb_schedule_message        (void);
+
−LOCAL void   cb_next_scheduled_msg      (void);
+
−LOCAL UBYTE  cb_sat_check_message_id    (USHORT msg_id);
+
−LOCAL void   cb_sat_cbch_message        (UBYTE length);
+
−LOCAL void cb_stop_next_blocks (void);
+
−LOCAL void cb_read_next_3_blocks(void);
+
−void set_cbch_state( UBYTE extended, UBYTE new_state);
+
−UBYTE get_cbch_state( UBYTE extended);
+
−
+
−#if defined(FF_HOMEZONE)
+
−LOCAL UBYTE cb_check_homezone (UBYTE length);
+
−#endif  /* FF_HOMEZONE */
+
−
+
−LOCAL void cb_alr_trace_msghead (T_CBMSG_HEADER *ph);
+
−
+
−/*
+
− * support indication of geographical scope change to MMI
+
− * it is important that these defitions match the GS definition from GSM 03.41
+
− * the MMI uses this also to compare with real CBCH messages!
+
− */
+
−#define CB_GEOGR_CHANGE_NONE 0x00
+
−#define CB_GEOGR_CHANGE_CELL 0xC0
+
−#define CB_GEOGR_CHANGE_LAC  0x80
+
−#define CB_GEOGR_CHANGE_PLMN 0x40
+
−
+
−#define CB_GEOGR_SCOPE_CELLI 0x00
+
−#define CB_GEOGR_SCOPE_PLMN  0x01
+
−#define CB_GEOGR_SCOPE_LAC   0x02
+
−#define CB_GEOGR_SCOPE_CELLN 0x03
+
−
+
−#define CBCH_NO_MSG           0
+
−#define CBCH_NORM_MSG         1
+
−#define CBCH_SCHEDULE_MSG     2
+
−#define CBCH_SAT_MSG          3
+
−#define CBCH_LAST_BLOCK    0x10
+
−
+
−#define CBCH_BLOCK_0          0
+
−#define CBCH_BLOCK_1          1
+
−#define CBCH_BLOCK_2          2
+
−#define CBCH_BLOCK_3          3
+
−#define CBCH_FIRST_SCHED_MSG  8
+
−#define CBCH_NULL_MSG      0x0F
+
−#define CBCH_SCHED            2
+
−
+
−#define MAX_UPDATE_NO   16
+
−#define MAX_UPDATE_NO_DIFF    8
+
−
+
−#if 1 || defined (WIN32)
+
−#define TRACING
+
−#endif
+
−
+
−#define CB_SERIAL_NO(ph)            ((USHORT)\
+
−                                    ((((T_CBMSG_HEADER*)(ph))->serial_no1)<<8)+\
+
−                                    (((T_CBMSG_HEADER*)(ph))->serial_no2))
+
−
+
−#define CB_GS_CODE(ph)              (((UBYTE)(((T_CBMSG_HEADER*)(ph))->serial_no1))>>6)
+
−
+
−#define CB_MSG_CODE(ph)             ((USHORT)\
+
−                                    (((((T_CBMSG_HEADER*)(ph))->serial_no1)&0x3f)<<4)+\
+
−                                    ((((T_CBMSG_HEADER*)(ph))->serial_no2)>>4))
+
−
+
−#define CB_UPDATE_NO(ph)            ((((T_CBMSG_HEADER*)(ph))->serial_no2)&0x0f)
+
−
+
−#define CB_MESSAGE_ID(ph)           ((USHORT)\
+
−                                    ((((T_CBMSG_HEADER*)(ph))->msg_id3)<<8)+\
+
−                                    (((T_CBMSG_HEADER*)(ph))->msg_id4))
+
−#if 0
+
−#define CB_MESSAGE_ID(ph)           ((((USHORT)(((T_CBMSG_HEADER*)(ph))->msg_id3))<<8)+\
+
−                                      ((USHORT)(((T_CBMSG_HEADER*)(ph))->msg_id4)))
+
−
+
−#endif /* 0 */
+
−#define CB_DCS(ph)                  (((T_CBMSG_HEADER*)(ph))->dcs)
+
−
+
−#define CB_PAGE(ph)                 (((T_CBMSG_HEADER*)(ph))->page>>4)
+
−#define CB_PAGETOTAL(ph)            (((T_CBMSG_HEADER*)(ph))->page&0x0f)
+
−
+
−
+
−#if defined (TRACING)
+
−#define ALR_TRACE_CB(a)             TRACE_EVENT("CBCH: " a)
+
−#define ALR_TRACE_CB_MODUS(m)       TRACE_EVENT_P1("CBCH: modus=%d", m)
+
−#define ALR_TRACE_CB_ERROR(e)       TRACE_EVENT_P1("CBCH: error=%d", e)
+
−#define ALR_TRACE_CB_BLOCK_NO(b)    TRACE_EVENT_P2("CBCH: block=%02x no=%u", b, b&0x0f)
+
−#define ALR_TRACE_CB_MSGHEAD(ph)    cb_alr_trace_msghead(ph)
+
−
+
−#define ALR_TRACE_CB_MSGID(m)         TRACE_EVENT_P1("CBCH: ID=%u", m)
+
−#define ALR_TRACE_CB_START_READ(f)    TRACE_EVENT_P1("CBCH: Start Read %d", f)
+
−#define ALR_TRACE_CB_SCHEDULE(a1,a2)  TRACE_EVENT_P2("CBCH: schedule i=%d result=%d", a1,a2)
+
−#define ALR_TRACE_CB_HZREQ(a1,a2)     TRACE_EVENT_P2("CBCH: Homezone ID=%u, t=%u", a1,a2)
+
−#define ALR_TRACE_CB_SCOPE_CHANGE(i,s)  TRACE_EVENT_P2 ("CBCH: Geogr. scope change %u, deleting msg of scope %u",\
+
−                                          i,s);
+
−#else  /* TRACING */
+
−#define ALR_TRACE_CB(a)
+
−#define ALR_TRACE_CB_MODUS(m)
+
−#define ALR_TRACE_CB_ERROR(e)
+
−#define ALR_TRACE_CB_BLOCK_NO(b)
+
−#define ALR_TRACE_CB_MSGID(m)
+
−#define ALR_TRACE_CB_START_READ(f)
+
−#define ALR_TRACE_CB_SCHEDULE(a1,a2)
+
−#define ALR_TRACE_CB_HZREQ(a1,a2)
+
−#endif  /* TRACING */
+
−
+
−/*==== VARIABLES ==================================================*/
+
−/*==== FUNCTIONS ==================================================*/
+
−
+
−#if 0
+
−#if 0
+
−#define TRACE_ALIGN_P(ps,m,t)  TRACE_EVENT_P5(" %08x %3u.%u %08x=%u " \
+
−                                "T_" #t " " #m, \
+
−                                (BYTE*)&(m), (BYTE*)&(m)-(BYTE*)ps, \
+
−                                sizeof (m),
+
−                                sizeof (m) > 1 ? (USHORT)(m) : (UBYTE)(m), m \
+
−                              )
+
−#else
+
−#define TRACE_ALIGN_P(ps,m,t)  TRACE_EVENT_P4 (" %08x %3u.%u %08x " \
+
−                                "T_" #t " " #m, \
+
−                                (BYTE*)&(m), (BYTE*)&(m)-(BYTE*)ps, \
+
−                                sizeof (m), m\
+
−                                )
+
−#endif
+
−int test_alignment (T_CBMSG_HEADER *ph)
+
−{
+
−  TRACE_ALIGN_P (ph, ph->serial_no1, CBMSG_HEADER);
+
−  TRACE_ALIGN_P (ph, ph->serial_no2, CBMSG_HEADER);
+
−  TRACE_ALIGN_P (ph, ph->msg_id3, CBMSG_HEADER);
+
−  TRACE_ALIGN_P (ph, ph->msg_id4, CBMSG_HEADER);
+
−  TRACE_ALIGN_P (ph, ph->dcs, CBMSG_HEADER);
+
−  TRACE_ALIGN_P (ph, ph->page, CBMSG_HEADER);
+
−}
+
−#endif
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_init                    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Initialize CBCH Control Process.
+
−*/
+
−
+
−GLOBAL void cb_init (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  ALR_TRACE_CB ("cb_init()");
+
−  alr_data->state[STATE_NORMAL_CBCH] = CBCH_NULL;
+
−  alr_data->state[STATE_EXT_CBCH] = CBCH_NULL;
+
−  pcbch->modus   = NOT_PRESENT_8BIT;
+
−  pcbch->old_cbch_msg.cnt = 0;
+
−#if defined(FF_HOMEZONE)
+
−  pcbch->homezone = CBCH_HZ_OFF;
+
−  pcbch->hz_timeout = 0;
+
−#endif  /* FF_HOMEZONE */
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_stop                    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Stop CBCH Control Process.
+
−
+
−            cb_stop will be called in the following three scenarios - 
+
−            1. Moving from IDLE to DEDICATED state 
+
−            2. ALR has received HomeZone information. 
+
−            3. MMI indicates stop reading CBCH. 
+
−
+
−            In all three cases ALR need to forward this to L1.
+
−            Eventhough the homezone request is pending we need to stop 
+
−            the CBCH reading.
+
−*/
+
−
+
−GLOBAL void cb_stop (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE normal_cbch, extended_cbch;
+
−
+
−  normal_cbch = GET_STATE(STATE_NORMAL_CBCH);
+
−  extended_cbch = GET_STATE(STATE_EXT_CBCH);
+
−
+
−  if ( 
+
−        (normal_cbch NEQ CBCH_NULL AND normal_cbch NEQ CBCH_IDLE) 
+
−        OR
+
−        (extended_cbch NEQ CBCH_NULL AND extended_cbch NEQ CBCH_IDLE) 
+
−     )
+
−  {
+
−    /*
+
−     * if CBCH process is really active, initialize
+
−     * CBCH process and stop CBCH process in layer 1.
+
−     */
+
−    pcbch->msg_type = CBCH_NO_MSG;
+
−
+
−    SET_STATE(STATE_NORMAL_CBCH, CBCH_IDLE);
+
−    SET_STATE(STATE_EXT_CBCH, CBCH_IDLE);
+
−
+
−    ALR_EM_STOP_CBCH_READING;
+
−
+
−    ma_cb_stop_cbch_req();
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_start                   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Re-configure layer 1 and go back to CBCH reading without
+
−            scheduling information.
+
−*/
+
−
+
−LOCAL void cb_start_no_drx_reading (UBYTE config)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  if (config)
+
−  {
+
−    /*
+
−     * configure layer 1
+
−     */
+
−    PALLOC (config_cbch, MPHC_CONFIG_CBCH_REQ);
+
−
+
−    /*
+
−     * copy the stored configuration received earlier from RR and send to layer 1.
+
−     */
+
−    memcpy (config_cbch, &pcbch->mphc_config_cbch, sizeof (T_MPHC_CONFIG_CBCH_REQ));
+
−    ma_cb_config_cbch(config_cbch);
+
−  }
+
−
+
−  /*
+
−   * start reading in layer 1 for normal and extended CBCH.
+
−   * The initial mode is no Scheduling information available.
+
−   */
+
−  cb_read_cbch (CBCH_NO_SCHED | CBCH_READ_NORM);
+
−  cb_read_cbch (CBCH_NO_SCHED  | CBCH_READ_EXT);
+
−
+
−  SET_STATE(STATE_NORMAL_CBCH, CBCH_NO_DRX);
+
−  SET_STATE(STATE_EXT_CBCH, CBCH_NO_DRX);
+
−  
+
−#if defined(FF_HOMEZONE)
+
−  if (pcbch->homezone EQ CBCH_HZ_IDLE)
+
−  {
+
−    pcbch->homezone = CBCH_HZ_PENDING;
+
−    /* start timer new */
+
−    if (pcbch->hz_timeout)
+
−      TIMERSTART(TIM_HOMEZONE, pcbch->hz_timeout);
+
−    ALR_TRACE_CB ("HOMEZONE is pending");
+
−  }
+
−#endif /* FF_HOMEZONE */
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_start                   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Start CBCH Control Process.
+
−*/
+
−
+
−GLOBAL void cb_start (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  if (    (GET_STATE(STATE_NORMAL_CBCH) EQ CBCH_IDLE)
+
−      AND (     (pcbch->modus NEQ NOT_PRESENT_8BIT)
+
−            OR  (pcbch->sat_enabled)
+
−#if defined(FF_HOMEZONE)
+
−            OR  (pcbch->homezone EQ CBCH_HZ_IDLE)
+
−#endif /* FF_HOMEZONE */
+
−          )
+
−      )
+
−  {
+
−    /*
+
−     * if a definition of needed message identifiers
+
−     * and data coding schemes is available, then configure
+
−     * layer 1
+
−     */
+
−    ALR_TRACE_CB ("restart");
+
−    cb_start_no_drx_reading (TRUE);
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : TIL_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_mph_cbch_req            |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Configuration of the layer 1 process for CBCH.
+
−
+
−            The compile-switch is not defined with the standard TI-layer 1.
+
−
+
−            But there shall be a little modification possible (and it is
+
−            done by some source code customer of layer 1), which does not
+
−            need any storing in ALR. Then the compile switch must be set
+
−
+
−  REMARK  : Setting of compile switch has problems with function cbch_start ???
+
−
+
−*/
+
−
+
−GLOBAL void cb_mph_cbch_req  (T_cbch * cbch)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  USHORT i;
+
−  T_CBCH_DATA      *pcbch = &alr_data->cbch_data;
+
−  T_cbch_desc      *pcbch_desc = &pcbch->mphc_config_cbch.cbch_desc;
+
−  T_chan_sel       *pchan_sel = &pcbch_desc->chan_sel;
+
−  T_cbch_freq_list *pcbch_freq_list = &pcbch->mphc_config_cbch.cbch_freq_list;
+
−
+
−  ALR_TRACE_CB ("MPH_CBCH_REQ");
+
−
+
−  ALR_EM_CONFIGURE_CBCH_CHANNEL;
+
−
+
−#if defined(FF_HOMEZONE)
+
−  if (pcbch->homezone NEQ CBCH_HZ_OFF)
+
−    pcbch->homezone = CBCH_HZ_IDLE; /* starts HZ request again */
+
−#endif /* FF_HOMEZONE */
+
−
+
−  /*   check which messages have to be deleted
+
−   *   even if the new cell has CBCH disabled! We still need to
+
−   *   to delete the corresponding messages and inform the MMI!
+
−   */
+
−  if (pcbch->modus EQ CBCH_ACCEPT)
+
−    cb_check_ci_lai_plmn ();
+
−
+
−  if (cbch->stat EQ STAT_ACT)
+
−  {
+
−    /*
+
−     * A CBCH channel is available
+
−     */
+
−
+
−#if !defined (L1_STORES_CBCH_CONFIG)
+
−    /*
+
−     * Layer 1 does not store any CBCH configuration (default)
+
−     * first set the channel configuration
+
−     */
+
−    if (cbch->h EQ H_FREQ)
+
−    {
+
−      /*
+
−       * with frequency hopping, set hopping flag, maio, hsn and hopping list.
+
−       */
+
−      pchan_sel->h = HOPPING;
+
−      pchan_sel->rf_channel.maio = cbch->maio;
+
−      pchan_sel->rf_channel.hsn  = cbch->hsn;
+
−
+
−      i=0;
+
−      pcbch_freq_list->rf_chan_cnt=0;
+
−      while ((i < 64) AND (cbch->ma[i] NEQ NOT_PRESENT_16BIT))
+
−      {
+
−        pcbch_freq_list->rf_chan_no.radio_freq[i] = ARFCN_TO_L1(cbch->ma[i]);
+
−        i++;
+
−        pcbch_freq_list->rf_chan_cnt++;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      /*
+
−       * Layer 1 uses a union definition. This is not applicable for the Condat-SAP model.
+
−       * Therefore the rf channel number is configured by maio and hsn. In general a Avoid the union !!!
+
−       */
+
−      pchan_sel->h = NO_HOPPING;
+
−      pchan_sel->rf_channel.maio = (UBYTE)(ARFCN_TO_L1(cbch->arfcn) & 0xFF);
+
−      pchan_sel->rf_channel.hsn  = (UBYTE)((ARFCN_TO_L1(cbch->arfcn) >> 8) & 0xFF);
+
−      memset (pcbch_freq_list, 0, sizeof (T_cbch_freq_list));
+
−    }
+
−
+
−    /*
+
−     * configure the CBCH channel type (SDCCH/8 or SDCCH/4)
+
−     */
+
−    if (cbch->ch < CH_SDCCH_8_0)
+
−      pcbch_desc->channel_type = CH_SDCCH_4;
+
−    else
+
−      pcbch_desc->channel_type = CH_SDCCH_8;
+
−
+
−    pcbch_desc->sub_channel   = 0;    /* not relevant */
+
−    pcbch_desc->timeslot_no  = cbch->tn;
+
−    pcbch_desc->tsc          = cbch->tsc;
+
−
+
−#else
+
−    /*
+
−     * Compile option set: L1 stores actual CBCH configuration.
+
−     * So it is not necessary to store the configuration in ALR.
+
−     * Just parse the configuration to Layer 1.
+
−     */
+
−    {
+
−      PALLOC (config_cbch, MPHC_CONFIG_CBCH);
+
−
+
−      if (cbch->h EQ H_FREQ)
+
−      {
+
−        /*
+
−         * with frequency hopping, set hopping flag, maio, hsn and hopping list.
+
−         */
+
−        config_cbch->cbch_desc.chan_sel.h = HOPPING;
+
−        config_cbch->cbch_desc.chan_sel.rf_channel.maio = cbch->maio;
+
−        config_cbch->cbch_desc.chan_sel.rf_channel.hsn  = cbch->hsn;
+
−
+
−        i=0;
+
−        config_cbch->cbch_freq_list.rf_chan_cnt=0;
+
−        while (cbch->ma[i] NEQ NOT_PRESENT_16BIT AND i < 64)
+
−        {
+
−          config_cbch->cbch_freq_list.rf_chan_no.hop_chan[i] = ARFCN_TO_L1(cbch->ma[i]);
+
−          i++; config_cbch->cbch_freq_list.rf_chan_cnt++;
+
−        }
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * Layer 1 uses a union definition. This is not applicable for the Condat-SAP model.
+
−         * Therefore the rf channel number is configured by maio and hsn. In general a Avoid the union !!!
+
−         */
+
−        config_cbch->cbch_desc.chan_sel.h = NO_HOPPING;
+
−        config_cbch->cbch_desc.chan_sel.rf_channel.maio = ARFCN_TO_L1(cbch->arfcn) & 0xFF;
+
−        config_cbch->cbch_desc.chan_sel.rf_channel.hsn  = (ARFCN_TO_L1(cbch->arfcn) >> 8) & 0xFF;
+
−        memset (&config_cbch->cbch_freq_list, 0, sizeof (T_cbch_freq_list));
+
−      }
+
−
+
−      /*
+
−       * configure the CBCH channel type (SDCCH/8 or SDCCH/4)
+
−       */
+
−      if (cbch->ch < CH_SDCCH_8_0)
+
−        config_cbch->cbch_desc.channel_type = CH_SDCCH_4;
+
−      else
+
−        config_cbch->cbch_desc.channel_type = CH_SDCCH_8;
+
−
+
−      config_cbch->cbch_desc.sub_channel    = 0;    /* not relevant */
+
−      config_cbch->cbch_desc.timeslot_no    = cbch->tn;
+
−      config_cbch->cbch_desc.tsc            = cbch->tsc;
+
−
+
−      ma_cb_config_cbch(config_cbch);
+
−    }
+
−#endif
+
−
+
−    if (    (pcbch->modus NEQ NOT_PRESENT_8BIT)
+
−         OR (pcbch->sat_enabled)
+
−#if defined(FF_HOMEZONE)
+
−         OR (pcbch->homezone EQ CBCH_HZ_IDLE)
+
−#endif /* FF_HOMEZONE */
+
−       )
+
−    {
+
−      /*
+
−       * MMI has requested data
+
−       * Start with NO_DRX mode
+
−       * Read each first CBCH block
+
−       */
+
−#if defined (L1_STORES_CBCH_CONFIG)
+
−      cb_start_no_drx_reading (FALSE);
+
−#else  /* L1_STORES_CBCH_CONFIG */
+
−      ALR_TRACE_CB ("switch on, send config");
+
−      cb_start_no_drx_reading (TRUE);
+
−#endif  /* L1_STORES_CBCH_CONFIG */
+
−    }
+
−    else
+
−    {
+
−      UBYTE   *si3 = &alr_data->ma_data.sys_info_3[0];
+
−      UBYTE   *lac = &alr_data->cbch_data.old_cid_plmn_lac[0];
+
−
+
−      ALR_TRACE_CB ("switch on, wait for MMI");
+
−      /*
+
−       * wait for MMI request
+
−       */
+
−      SET_STATE(STATE_NORMAL_CBCH, CBCH_IDLE);
+
−      SET_STATE(STATE_EXT_CBCH, CBCH_IDLE);
+
−      /*
+
−       * update old_cid_plmn_lac
+
−       */
+
−      memcpy (lac, &si3[2], 7);
+
−    }
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * The new configuration indicates no CBCH, so stop the CBCH process in Layer 1
+
−     */
+
−    ALR_TRACE_CB ("switch off");
+
−
+
−    cb_stop();
+
−    SET_STATE(STATE_NORMAL_CBCH, CBCH_NULL);
+
−    SET_STATE(STATE_EXT_CBCH, CBCH_NULL);
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : AKR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_mmi_cbch_req            |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : MMI sends a definition of the expected message identifier
+
−            and data coding schemes for the CBCH messages.
+
−
+
−*/
+
−
+
−GLOBAL void cb_mmi_cbch_req (T_MMI_CBCH_REQ *cbch)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  ALR_TRACE_CB ("MMI req");
+
−
+
−#if defined(FF_HOMEZONE)
+
−  if (cbch->modus NEQ CBCH_HOMEZONE)
+
−  {
+
−    pcbch->modus = cbch->modus;
+
−    TRACE_EVENT_P1 ("CBCH: homezone=%u", pcbch->homezone);
+
−  }
+
−  else if (cbch->msg_id[0] EQ NOT_PRESENT_16BIT)
+
−  {
+
−    /*
+
−     * switch off automatically homezone request
+
−     * - homezone state to off
+
−     * - clear old message
+
−     * - stop timer
+
−     */
+
−     pcbch->msg_hz_id = NOT_PRESENT_16BIT;
+
−     pcbch->homezone = CBCH_HZ_OFF;
+
−     TIMERSTOP (TIM_HOMEZONE);
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * switch on automatically homezone request
+
−     * - set homezone state to idle whatever are before
+
−     * - set new homezone id
+
−     * - clear old message
+
−     */
+
−    pcbch->msg_hz_id = cbch->msg_id[0];
+
−    pcbch->dcs_hz_id = cbch->dcs_id[0];
+
−    pcbch->hz_timeout = cbch->dcs_id[1]*1000;
+
−    ALR_TRACE_CB_HZREQ (pcbch->msg_hz_id,
+
−      pcbch->hz_timeout);
+
−    if (pcbch->homezone EQ CBCH_HZ_OFF)
+
−    {
+
−      UBYTE cbch_state = GET_STATE (STATE_NORMAL_CBCH);
+
−      pcbch->homezone = CBCH_HZ_IDLE;
+
−      if (cbch_state NEQ CBCH_NULL)
+
−      {/* CBCH system is prepared */
+
−        if (cbch_state EQ CBCH_IDLE)
+
−        { /* start timer only if CBCH system is prepared */
+
−          TIMERSTART (TIM_HOMEZONE, 1000);
+
−        }
+
−        else
+
−        { /* CBCH system is already active -> wait for HZ message */
+
−          pcbch->homezone = CBCH_HZ_PENDING;
+
−          TIMERSTART (TIM_HOMEZONE, pcbch->hz_timeout);
+
−          ALR_TRACE_CB ("HOMEZONE is pending");
+
−        }
+
−      }
+
−    }
+
−    return;
+
−  }
+
−#else  /* FF_HOMEZONE */
+
−  pcbch->modus = cbch->modus;
+
−#endif  /* FF_HOMEZONE */
+
−  /*
+
−   * Storing of Parameter and clearing of
+
−   * the received CB memory
+
−   */
+
−  memcpy (&pcbch->msg_id[0], cbch->msg_id, sizeof (pcbch->msg_id));
+
−  memcpy (&pcbch->dcs_id[0], cbch->dcs_id, sizeof (pcbch->dcs_id));
+
−
+
−#if !defined(NTRACE)
+
−{
+
−  int i;
+
−
+
−  ALR_TRACE_CB_MODUS(cbch->modus);
+
−
+
−  for (i=0;
+
−    (i < MAX_IDENTS) AND (pcbch->msg_id[i] NEQ NOT_PRESENT_16BIT);
+
−    i++)
+
−  {
+
−    TRACE_EVENT_P2 ("CBCH: id[%u]=%u", i, pcbch->msg_id[i]);
+
−  }
+
−  for (i=0;
+
−    (i < MAX_IDENTS) AND (pcbch->dcs_id[i] NEQ NOT_PRESENT_8BIT);
+
−    i++)
+
−  {
+
−    TRACE_EVENT_P2 ("CBCH:dcs[%u]=%u", i, pcbch->dcs_id[i]);
+
−  }
+
−}
+
−#endif /* !NTRACE */
+
−
+
−  /* old messages should only be erased when MMI turns CBCH off */
+
−  if (pcbch->modus EQ MMI_CBCH_STOP)
+
−  {
+
−    /* also erases the count of old message */
+
−    memset (&pcbch->old_cbch_msg, 0, sizeof (T_CB_MSG));
+
−    memset (&pcbch->msg[0], 0, CBCH_MSG_SIZE);
+
−  }
+
−
+
−  /*
+
−    TRACE_EVENT_P2 ("CBCH: STATE_MA=%u STATE_CBCH=%u", GET_STATE(STATE_MA), GET_STATE (STATE_CBCH));
+
−  */
+
−
+
−#ifdef GPRS
+
−  if ((GET_STATE(STATE_MA) EQ MA_IDLE AND !alr_data->gprs_data.pbcch) OR
+
−      (alr_data->gprs_data.pbcch AND alr_data->gprs_data.pim))
+
−#else
+
−  if (GET_STATE(STATE_MA) EQ MA_IDLE)
+
−#endif
+
−  {
+
−    /*
+
−     * layer 1 is only configured, if ALR is in idle state, else the configuration
+
−     * is delayed until the cell is selected.
+
−     */
+
−    switch (GET_STATE (STATE_NORMAL_CBCH))
+
−    {
+
−      case CBCH_NULL:
+
−        /*
+
−         * no CBCH channel is available
+
−         */
+
−        break;
+
−
+
−      case CBCH_IDLE:
+
−        if (pcbch->modus EQ MMI_CBCH_STOP AND
+
−            !pcbch->sat_enabled)
+
−        {
+
−          /*
+
−           * CBCH download is not enabled and the MMI indicates stop of
+
−           * the CBCH channel, then stop CBCH process in layer 1.
+
−           */
+
−          cb_stop();
+
−        }
+
−        else
+
−        {
+
−          /*
+
−           * new definitions of message identifier or data coding schemes
+
−           * then re-configure layer 1 and go back to CBCH reading without
+
−           * scheduling information.
+
−           */
+
−          cb_start_no_drx_reading (TRUE);
+
−        }
+
−        break;
+
−
+
−      default:
+
−        /*
+
−         * we already received a MMI CBCH REQ before
+
−         */
+
−        if (pcbch->modus EQ MMI_CBCH_STOP AND
+
−            !pcbch->sat_enabled)
+
−        {
+
−          /*
+
−           * CBCH download is not enabled and the MMI indicates stop of
+
−           * the CBCH channel, then stop CBCH process in layer 1.
+
−           */
+
−          cb_stop();
+
−          SET_STATE(STATE_NORMAL_CBCH, CBCH_IDLE);
+
−          SET_STATE(STATE_EXT_CBCH, CBCH_IDLE);
+
−        }
+
−        break;
+
−    }
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : TIL_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_mmi_sat_cbch_req        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Reception of a list of identifiers for SIM TOOLKIT
+
−            CBCH Download.
+
−
+
−*/
+
−
+
−GLOBAL void cb_mmi_sat_cbch_req (T_MMI_SAT_CBCH_DWNLD_REQ * cbch_req)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  unsigned i;
+
−  ALR_TRACE_CB ("MMI SAT req");
+
−
+
−  /*
+
−   * clear the list of needed message identifier for CBCH download
+
−   * and fill it with the definiton of MMI.
+
−   */
+
−   memset (pcbch->msg_id_sat, NOT_PRESENT_16BIT,
+
−           sizeof(pcbch->msg_id_sat));
+
−   memcpy (pcbch->msg_id_sat, cbch_req->msg_id,
+
−           sizeof(cbch_req->msg_id[0])*(cbch_req->count));
+
−
+
−   /*
+
−    * CBCH download is disabled
+
−    */
+
−  pcbch->sat_enabled = FALSE;
+
−  for (i = 0; i < cbch_req->count; i++)
+
−  {
+
−    if (pcbch->msg_id_sat[i] NEQ NOT_PRESENT_16BIT)
+
−    {
+
−      pcbch->sat_enabled = TRUE;
+
−      break;
+
−    }
+
−  }
+
−  vsi_o_error_ttrace ("HM cb_mmi_sat_cbch_req(), sat_enabled = %d, modus = %d", 
+
−                      pcbch->sat_enabled, pcbch->modus);
+
−#ifdef GPRS
+
−  if ((GET_STATE(STATE_MA) EQ MA_IDLE AND !alr_data->gprs_data.pbcch) OR
+
−      (alr_data->gprs_data.pbcch AND alr_data->gprs_data.pim))
+
−#else
+
−  if (GET_STATE(STATE_MA) EQ MA_IDLE)
+
−#endif
+
−  {
+
−          /*
+
−           * Current state is compatible with enabling of CBCH reading, 
+
−           * configure L1 to read CBCH. Otherwise configuration is delayed
+
−           * until ALR reaches a compatible state.
+
−           */    
+
−    switch (GET_STATE (STATE_NORMAL_CBCH))
+
−    {
+
−      case CBCH_NULL:
+
−            /*
+
−             * No CBCH channel is available.
+
−             */
+
−        break;
+
−
+
−      default:
+
−      {
+
−        if (pcbch->modus EQ MMI_CBCH_STOP AND !pcbch->sat_enabled)
+
−        {
+
−            /* No CBCH to read. Stop reading CBCH in L1. */
+
−          cb_stop();
+
−        }
+
−        else
+
−        {
+
−
+
−            /* 
+
−             * CBCH channel is available. 
+
−             * Configure layer 1 for catching the CBCH download messages.
+
−             */
+
−          PALLOC (config_cbch, MPHC_CONFIG_CBCH_REQ);
+
−          memcpy (config_cbch, &pcbch->mphc_config_cbch, sizeof (T_MPHC_CONFIG_CBCH_REQ));
+
−          ma_cb_config_cbch(config_cbch);
+
−          cb_read_cbch (CBCH_NO_SCHED | CBCH_READ_NORM);
+
−          cb_read_cbch (CBCH_NO_SCHED | CBCH_READ_EXT);
+
−          SET_STATE(STATE_NORMAL_CBCH, CBCH_NO_DRX);
+
−          SET_STATE(STATE_EXT_CBCH, CBCH_NO_DRX);         
+
−        }
+
−      }
+
−      break;
+
−    } /* End of switch (GET_STATE (STATE_NORMAL_CBCH)) */
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : TIL_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_data_ind                |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : A CBCH message is received.
+
−
+
−*/
+
−
+
−GLOBAL void cb_data_ind (T_MPHC_DATA_IND  *cbch_ind)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  UBYTE block_no;
+
−  UBYTE block_description;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE * expected_seq_number  = &(pcbch->expected_seq_number[0]);
+
−
+
−  /*
+
−   * check whether the CBCH message has been received on the
+
−   * normal CBCH channel or the extended CBCH channel
+
−   */
+
−  if (cbch_ind->tc >= 4)
+
−  {
+
−    pcbch->msg_is_extended = CBCH_READ_EXT;
+
−    expected_seq_number  = &(pcbch->expected_seq_number[1]);
+
−  }
+
−  else if(cbch_ind->tc < 4)
+
−    pcbch->msg_is_extended = CBCH_READ_NORM;
+
−
+
−  if (cbch_ind->error_flag EQ VALID_BLOCK)
+
−  {
+
−    /*
+
−     * if the CBCH block is valid, calculate the block number
+
−     */
+
−    block_description = cbch_ind->l2_frame.content[0];
+
−    block_no = (UBYTE)(block_description & 0x0F);
+
−    if (block_no < CBCH_NULL_MSG)
+
−    {
+
−      ALR_TRACE_CB_BLOCK_NO (block_description);
+
−    }
+
−    TRACE_EVENT_P2("expected_block_number = %d, schedule_length =%d", (*expected_seq_number), pcbch->schedule_length[0]);
+
−    switch(block_no)
+
−    {
+
−      case CBCH_BLOCK_0:
+
−        memcpy (&pcbch->msg[0], &cbch_ind->l2_frame.content[1], CBCH_BLOCK_SIZE);
+
−#if defined(FF_HOMEZONE)
+
−        if (!cb_check_homezone ((UBYTE)(CBCH_BLOCK_SIZE*(block_no+1))))
+
−#endif  /* FF_HOMEZONE */
+
−          cb_first_block(block_description);
+
−        break;
+
−
+
−      case CBCH_BLOCK_1:
+
−      case CBCH_BLOCK_2:
+
−      case CBCH_BLOCK_3:
+
−       /*
+
−         * check for sequence number 
+
−         */
+
−       if(*expected_seq_number NEQ block_no)
+
−       {
+
−         ALR_TRACE_CB("Sequence error");
+
−         cb_error_ind();        
+
−       }
+
−       else
+
−       {
+
−         memcpy (&pcbch->msg[CBCH_BLOCK_SIZE*(block_no & 3)],
+
−          &cbch_ind->l2_frame.content[1], CBCH_BLOCK_SIZE);
+
−
+
−         (*expected_seq_number)++;
+
−         if( *expected_seq_number > CBCH_BLOCK_3 )
+
−           *expected_seq_number = CBCH_BLOCK_0;
+
−         
+
−         
+
−         if ( (block_description & CBCH_LAST_BLOCK)  OR  (block_no EQ CBCH_BLOCK_3)  )
+
−         {
+
−           /*
+
−             * last block of msg
+
−             */
+
−           if(pcbch->msg_type EQ CBCH_NORM_MSG)
+
−             /*
+
−               * +1, because parameter is length not offset
+
−               */
+
−             cb_cbch_message((UBYTE)(CBCH_BLOCK_SIZE*(block_no+1)));
+
−           else if(pcbch->msg_type EQ CBCH_SCHEDULE_MSG)
+
−             cb_schedule_message();
+
−           else if(pcbch->msg_type EQ CBCH_SAT_MSG)
+
−             cb_sat_cbch_message((UBYTE)(CBCH_BLOCK_SIZE*(block_no+1)));
+
−         }
+
−       }
+
−       break;
+
−
+
−      case CBCH_FIRST_SCHED_MSG:
+
−        /*
+
−         * first SCHEDULE block
+
−         */
+
−
+
−        ALR_TRACE_CB ("SCHEDULE");
+
−        memcpy (&pcbch->msg[0],  &cbch_ind->l2_frame.content[1], CBCH_BLOCK_SIZE);
+
−        cb_read_next_3_blocks();
+
−
+
−        pcbch->msg_type = CBCH_SCHEDULE_MSG;
+
−        break;
+
−
+
−      case CBCH_NULL_MSG:
+
−        /*
+
−         * NULL Message
+
−         */
+
−
+
−        /*
+
−        ALR_TRACE_CB ("null msg");
+
−        */
+
−        cb_null_message ();
+
−        break;
+
−
+
−      default:
+
−        ALR_TRACE_CB ("unknown");
+
−        cb_error_ind();
+
−        break;
+
−    }
+
−
+
−    ALR_EM_RECEIVE_CBCH_MESSAGE;
+
−
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * Invalid block
+
−     */
+
−    /*
+
−    ALR_TRACE_CB_ERROR(cbch_ind->error_flag);
+
−    */
+
−
+
−    pcbch->msg_type = CBCH_NO_MSG;
+
−    cb_error_ind ();
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_first_block             |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Reception of the first CBCH block.
+
−
+
−*/
+
−
+
−LOCAL void cb_first_block (UBYTE status)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  UBYTE  result;
+
−  T_CBMSG_HEADER  *p_cbh;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  /*
+
−   * extract message id and data coding scheme from the message
+
−   */
+
−  p_cbh = (T_CBMSG_HEADER*)(&pcbch->msg[0]);
+
−
+
−  ALR_TRACE_CB_MSGHEAD (p_cbh);
+
−
+
−  /*
+
−   * check the incoming message:
+
−   * 1. matches the message identifier
+
−   * 2. matches the data coding scheme
+
−   * 3. is this message not received yet
+
−   */
+
−  result =  cb_check_message_id (CB_MESSAGE_ID(p_cbh));
+
−  result += cb_check_data_coding_scheme (CB_DCS(p_cbh));
+
−  result += cb_check_old_msg ();
+
−
+
−  if (result EQ 3)
+
−  {
+
−    /*
+
−     * all checks are passed
+
−     */
+
−    if (! pcbch->sat_enabled OR
+
−        ! cb_sat_check_message_id(CB_MESSAGE_ID(p_cbh)))
+
−    {
+
−      /*
+
−       * it is not a CBCH download message or
+
−       * CBCH download is not enabled
+
−       */
+
−      if (status & CBCH_LAST_BLOCK)
+
−      {
+
−        /*
+
−         * the first is the only block, then forward it
+
−         * to MMI.
+
−         */
+
−        cb_cbch_message (CBCH_BLOCK_SIZE*(CBCH_BLOCK_0+1));
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * store the block and request the three remaining
+
−         * blocks in layer 1.
+
−         */
+
−        pcbch->msg_type = CBCH_NORM_MSG;
+
−        cb_read_next_3_blocks();
+
−      }
+
−    }
+
−    else
+
−    {
+
−      /*
+
−       * It is a CBCH download message and CBCH download is enabled.
+
−       */
+
−      if (status & CBCH_LAST_BLOCK)
+
−      {
+
−        /*
+
−         * the first block is the only block, so forward the
+
−         * message to MMI.
+
−         */
+
−        cb_sat_cbch_message (CBCH_BLOCK_SIZE*(CBCH_BLOCK_0+1));
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * store the data and request the three remaining blocks.
+
−         */
+
−        pcbch->msg_type = CBCH_SAT_MSG;
+
−        cb_read_next_3_blocks();
+
−      }
+
−    }
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * the message has not passed the checks.
+
−     * So it can be only a CBCH download message.
+
−     */
+
−    if(! pcbch->sat_enabled OR
+
−       ! cb_sat_check_message_id(CB_MESSAGE_ID(p_cbh)))
+
−    {
+
−      /*
+
−       * SAT is not enabled or it is not a CBCH download
+
−       * message. So start reading of next scheduled message.
+
−       */
+
−      memset (&pcbch->msg[0], 0, 88);
+
−      cb_next_scheduled_msg();
+
−
+
−    }
+
−    else
+
−    {
+
−      /*
+
−       * it is CBCH download message and SAT is enabled
+
−       */
+
−      if (status & CBCH_LAST_BLOCK)
+
−      {
+
−        /*
+
−         * the first block is the last one, so send the
+
−         * message to MMI.
+
−         */
+
−        cb_sat_cbch_message (CBCH_BLOCK_SIZE*(CBCH_BLOCK_0+1));
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * store the first block and request the remaining three.
+
−         */
+
−        pcbch->msg_type = CBCH_SAT_MSG;
+
−        cb_read_next_3_blocks();
+
−      }
+
−    }
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : TIL_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_sat_cbch_message        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Reception of a complete CBCH message for CBCH download.
+
−
+
−*/
+
−
+
−LOCAL void cb_sat_cbch_message (UBYTE length)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  PALLOC (mmi_cbch_ind, MMI_SAT_CBCH_DWNLD_IND);
+
−
+
−  ALR_EM_CBCH_MESSAGE_COMPLETE;
+
−
+
−  TRACE_FUNCTION ("cb_sat_cbch_message()");
+
−
+
−  /*
+
−   * copy the content of the message into the primitive.
+
−   */
+
−  memcpy (mmi_cbch_ind->cbch_msg, pcbch->msg, 88);
+
−  mmi_cbch_ind->cbch_len = length;
+
−
+
−  /*
+
−   * send to MMI
+
−   */
+
−  PSENDX(MMI, mmi_cbch_ind);
+
−
+
−  /*
+
−   * prepare for next reception
+
−   */
+
−  pcbch->msg_type = CBCH_NO_MSG;
+
−  pcbch->expected_seq_number[0] = CBCH_BLOCK_0;
+
−  pcbch->expected_seq_number[1] = CBCH_BLOCK_0;
+
−  /*
+
−   * start reading of next scheduled message.
+
−   */
+
−  cb_next_scheduled_msg();
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : TIL_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_schedule_message        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Reception of a SCHEDULE message.
+
−
+
−*/
+
−
+
−LOCAL void cb_schedule_message (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE extended = pcbch->msg_is_extended;
+
−  UBYTE *p_sched_msg = &pcbch->scheduled_sched_msg[extended];
+
−
+
−  ALR_EM_RECEIVE_SCHEDULE_MESSAGE;
+
−
+
−  switch ( get_cbch_state(extended) )
+
−  {
+
−    case CBCH_NO_DRX:
+
−      /*
+
−       * change from NO DRX mode (no knowledge about Scheduling)
+
−       * to DRX mode.
+
−       */
+
−      
+
−      set_cbch_state (extended, CBCH_DRX);
+
−      
+
−
+
−      /*
+
−       * check whether it is a scheduled schedule message or not.
+
−       */
+
−      if(pcbch->msg[0] EQ 1)
+
−        *p_sched_msg = 1;
+
−      else
+
−        *p_sched_msg = 0;
+
−
+
−      /*
+
−       * create schedule map with new and old messages
+
−       */
+
−      cb_create_schedule_map (TRUE);
+
−
+
−      /*
+
−       * forward the schedule map to layer 1.
+
−       */
+
−      cb_read_cbch((UBYTE)(CBCH_SCHED | extended));
+
−
+
−      break;
+
−
+
−    case CBCH_DRX:
+
−      if (pcbch->msg[0] EQ 1)
+
−      {
+
−        /*
+
−         * scheduled SCHEDULE message
+
−         */
+
−         if(*p_sched_msg <= 2)
+
−            (*p_sched_msg)++;
+
−
+
−         if (*p_sched_msg > 1)
+
−           /*
+
−            * we have read a full schedule period
+
−            * so we dont need to read the old messages
+
−            */
+
−           cb_create_schedule_map (FALSE);
+
−         else
+
−           cb_create_schedule_map (TRUE);
+
−
+
−        cb_read_cbch((UBYTE)(CBCH_SCHED | extended));
+
−      }      
+
−      break;
+
−    default:
+
−      break;
+
−  }
+
−  /*
+
−   * prepare for next reception
+
−   */
+
−  pcbch->msg_type = CBCH_NO_MSG;
+
−  pcbch->expected_seq_number[0] = CBCH_BLOCK_0;
+
−  pcbch->expected_seq_number[1] = CBCH_BLOCK_0;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_null_message            |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Reception of a NULL message.
+
−
+
−*/
+
−LOCAL void cb_null_message (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE extended = pcbch->msg_is_extended;
+
−
+
−  ALR_EM_RECEIVE_NULL_MESSAGE;
+
−
+
−  switch ( get_cbch_state(extended) )
+
−  {
+
−    case CBCH_DRX:
+
−      if (pcbch->schedule_length[extended] EQ 0)
+
−      {
+
−        /*
+
−         * instead of the scheduled SCHEDULE message
+
−         * a NULL message has received.
+
−         * Restarting with NO DRX mode
+
−         */
+
−        set_cbch_state (extended, CBCH_NO_DRX);
+
−        cb_read_cbch ((UBYTE)(CBCH_NO_SCHED | extended));
+
−      }
+
−      else
+
−      {
+
−        cb_next_scheduled_msg();
+
−      }
+
−      break;
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_error_ind               |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Indicates an invalid block.
+
−                   1) with error_flag =TRUE
+
−                   2) invalid sequence number
+
−                   3) out of sequence block
+
−*/
+
−
+
−LOCAL void cb_error_ind (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE extended = pcbch->msg_is_extended;
+
−                     
+
−  if( pcbch->expected_seq_number[extended] NEQ CBCH_BLOCK_0)
+
−  {
+
−    /*
+
−      * stop the next blocks
+
−      */
+
−    cb_stop_next_blocks();      
+
−  }
+
−  switch ( get_cbch_state(extended) )
+
−  {
+
−    case CBCH_DRX:
+
−      if (pcbch->schedule_length[extended] EQ 0)
+
−      {
+
−        /*
+
−         * instead of the scheduled SCHEDULE message
+
−         * an invalid message has been received.
+
−         * Restarting with NO DRX mode
+
−         */
+
−        set_cbch_state (extended, CBCH_NO_DRX);
+
−        cb_read_cbch ((UBYTE)(CBCH_NO_SCHED | extended));
+
−      }
+
−      else
+
−        /*
+
−         * Go back to FIRST DRX mode.
+
−         */
+
−      {
+
−        pcbch->scheduled_sched_msg[extended] = 1;       
+
−       cb_next_scheduled_msg();
+
−      }
+
−      break;
+
−    default:
+
−      break;
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_ind                     |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Indication of the CBCH message.
+
−
+
−*/
+
−
+
−LOCAL void cb_ind (UBYTE length)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  PALLOC (mmi_cbch_ind, MMI_CBCH_IND);
+
−
+
−  ALR_EM_CBCH_MESSAGE_COMPLETE;
+
−
+
−  /*
+
−   * copy the message content to the primitive.
+
−   */
+
−  memcpy (mmi_cbch_ind->cbch_msg, pcbch->msg, CBCH_MSG_SIZE);
+
−  mmi_cbch_ind->cbch_len = length;
+
−
+
−  ma_cb_mmi_cbch_ind(mmi_cbch_ind);
+
−
+
−  {
+
−    T_CBMSG_HEADER *p_cbh = (T_CBMSG_HEADER*)(&pcbch->msg[0]);
+
−    ALR_TRACE_CB_MSGHEAD (p_cbh);
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_read_next_3_blocks         |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Starts read of next 3 blocks.
+
−
+
−*/
+
−
+
−LOCAL void cb_read_next_3_blocks(void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE extended = pcbch->msg_is_extended;
+
−
+
−  if( extended EQ CBCH_READ_EXT)
+
−    ma_cb_info_req (CBCH_EXT_BLOCK234);
+
−  else
+
−    ma_cb_info_req (CBCH_NORM_BLOCK234);
+
−
+
−  pcbch->expected_seq_number[extended] = CBCH_BLOCK_1;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_stop_next_blocks        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Stop next blocks.
+
−
+
−*/
+
−
+
−LOCAL void cb_stop_next_blocks (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  /*
+
−   * stop the next blocks
+
−   */
+
−
+
−  /*
+
−    * Upper layers / L1 Circuit Switched interfaces
+
−    * S922.doc , Ver 1.9
+
−    * Section 11.3 MPHC_CBCH_INFO_REQ 
+
−    *
+
−    * This message can be used to update on fly L1 
+
−    * with new tb_bitmap which then replaces the current one. 
+
−    * In such a case, 0 in the bitmap means abort any pending reading of TB1/2/3 or TB5/6/7.
+
−    *
+
−    * A previous "schedule_length=0" is used to specify "No schedule present".
+
−    * In such a case, L1 starts reading continuously TB0 for normal CBCH or TB4 for Extended CBCH.
+
−    */
+
−  ma_cb_info_req (0);
+
−  
+
−  pcbch->msg_type = CBCH_NO_MSG;
+
−  pcbch->expected_seq_number[0] = CBCH_BLOCK_0;
+
−  pcbch->expected_seq_number[1] = CBCH_BLOCK_0;
+
−}
+
−
+
−#if defined(FF_HOMEZONE) && defined(INDICATE_HZ_ERROR)
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_ind_hz_err              |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Indication of the CBCH message and stop the next blocks.
+
−
+
−*/
+
−
+
−LOCAL void cb_ind_hz_err (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  PALLOC (mmi_cbch_ind, MMI_CBCH_IND);
+
−
+
−  memset (mmi_cbch_ind->cbch_msg, 0xff, CBCH_MSG_SIZE);
+
−  mmi_cbch_ind->cbch_msg[2] = pcbch->msg_hz_id >> 8;
+
−  mmi_cbch_ind->cbch_msg[3] = pcbch->msg_hz_id & 0xff;
+
−  mmi_cbch_ind->cbch_len = 0; /* error indication */
+
−  ALR_TRACE_CB ("cb_ind_hz_err()");
+
−
+
−  ma_cb_mmi_cbch_ind(mmi_cbch_ind);
+
−}
+
−#endif /* FF_HOMEZONE */
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_cbch_message            |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Reception of a complete CBCH message.
+
−
+
−*/
+
−
+
−LOCAL void cb_cbch_message (UBYTE length)
+
−{
+
−  /*
+
−   * Indicate the message
+
−   */
+
−  cb_ind (length);
+
−  /*
+
−   * stop the next blocks
+
−   */
+
−  cb_stop_next_blocks ();
+
−  /*
+
−   * store the cbch message to avoid double reception
+
−   */
+
−  cb_store_cbch_msg ();
+
−  /*
+
−   * start reading of the next scheduled message
+
−   */
+
−  cb_next_scheduled_msg();  
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_store_cbch_msg          |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Store key parameter of a CBCH message to avoid
+
−            forwarding of a CBCH message twice.
+
−
+
−*/
+
−LOCAL void cb_store_cbch_msg (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  USHORT x;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  ALR_TRACE_CB ("Store msg");
+
−
+
−  /*
+
−   *  It is not permitted to save the cbch message,
+
−   *  if the following pattern are in the
+
−   *  lacation area identification (bcch:sys_info_3) :
+
−   *                   [4]  0x00
+
−   *                   [5]  0xF1
+
−   *                   [6]  0x10
+
−   *
+
−   *  that means FTA in testhouse
+
−   */
+
−  if (alr_data->ma_data.sys_info_3[4] EQ 0     AND
+
−      alr_data->ma_data.sys_info_3[5] EQ 0xF1  AND
+
−      alr_data->ma_data.sys_info_3[6] EQ 0x10)
+
−    return;
+
−
+
−  /*
+
−   * If storage is full, remove the first one.
+
−   */
+
−  if (pcbch->old_cbch_msg.cnt EQ MAX_OLD_CB)
+
−    cb_remove_message (0);
+
−
+
−  /*
+
−   * store the new one
+
−   */
+
−  x = pcbch->old_cbch_msg.cnt++;
+
−  memcpy (&pcbch->old_cbch_msg.header[x],
+
−          &pcbch->msg, sizeof (T_CBMSG_HEADER));
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_check_message_id        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Check Message Identifier of the first CBCH block.
+
−
+
−*/
+
−
+
−LOCAL UBYTE cb_check_message_id (USHORT msg_id)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  USHORT i;
+
−  UBYTE  result = TRUE;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  /*
+
−   * if no message identifier are defined for comparision
+
−   * make a shortcut and return immediately. 
+
−   * MODUS CBCH_ACCEPT,but no msg_id defined,accept NO messages
+
−   * MODUS CBCH_IGNORE,but no msg_id define, accept all messages
+
−   * MODUS CBCH_STOP,but no msg_id defined,  accept NO messages
+
−   * MODUS CBCH_HOMEZONE,but no msg_id defined, accept NO messages/ 
+
−   */
+
−  if ( pcbch->msg_id[0] EQ NOT_PRESENT_16BIT )
+
−  {
+
−    if (pcbch->modus EQ CBCH_IGNORE) 
+
−    {
+
−      return TRUE;
+
−    }
+
−    else
+
−    {
+
−      return FALSE;
+
−    }
+
−  }
+
−
+
−  /*
+
−   * initialise result
+
−   * if the msg_id is not found and MMI specified
+
−   * a positive range(CBCH_ACCEPT) return 0
+
−   */
+
−  result = (UBYTE)(pcbch->modus EQ CBCH_ACCEPT ? FALSE : TRUE);
+
−
+
−  /*
+
−   * message identifier are stored as a pair to express a range
+
−   */
+
−  for (i=0; i < MAX_IDENTS-1; i+=2)
+
−  {
+
−    /*
+
−     * end of list reached
+
−     */
+
−    if (pcbch->msg_id[i] EQ NOT_PRESENT_16BIT)
+
−      break;
+
−
+
−    /*
+
−     * check whether the message identifier is inside or outside
+
−     * the range. Result depends on what MMI has requested.
+
−     */
+
−    if ((pcbch->msg_id[i]   <= msg_id) AND
+
−        (pcbch->msg_id[i+1] >= msg_id))
+
−      result = (UBYTE)(pcbch->modus EQ CBCH_ACCEPT ? TRUE : FALSE);
+
−  }
+
−
+
−  return result;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_sat_check_message_id    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Check Message Identifier of the first CBCH block for CBCH
+
−            download purposes.
+
−
+
−*/
+
−
+
−LOCAL UBYTE cb_sat_check_message_id (USHORT msg_id)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  USHORT i;
+
−  UBYTE  result;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  /*
+
−   * initialize result
+
−   */
+
−  result = FALSE;
+
−
+
−  /*
+
−   * for all stored message identifier of CBCH download
+
−   */
+
−  for (i = 0; i < MAX_IDENTS_SAT; i++)
+
−  {
+
−    /*
+
−     * end of list reached
+
−     */
+
−    if (pcbch->msg_id_sat[i] EQ NOT_PRESENT_16BIT)
+
−      break;
+
−
+
−    /*
+
−     * if message identifier matches
+
−     */
+
−    if (pcbch->msg_id_sat[i] EQ msg_id)
+
−    {
+
−      result = TRUE;
+
−      break;
+
−    }
+
−  }
+
−
+
−  return result;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_check_data_coding_scheme|
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Check Data Coding Scheme of the first CBCH block.
+
−
+
−*/
+
−LOCAL UBYTE cb_check_data_coding_scheme (UBYTE dcs_id)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  USHORT i;
+
−  UBYTE  result = TRUE;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  /*
+
−   * if the list is empty, result is positive
+
−   */
+
−  if (pcbch->dcs_id [0] EQ NOT_PRESENT_8BIT)
+
−    return result;
+
−
+
−  /*
+
−   * initialise result
+
−   * if the dcs_id is not found and MMI specified
+
−   * a positive range(CBCH_ACCEPT) return 0
+
−   */
+
−  result = (UBYTE)(pcbch->modus EQ CBCH_ACCEPT ? 0 : 1);
+
−
+
−
+
−  for (i=0;i<MAX_IDENTS-1;i+=2)
+
−  {
+
−    /*
+
−     * end of list reached
+
−     */
+
−    if (pcbch->dcs_id[i] EQ NOT_PRESENT_8BIT)
+
−      break;
+
−
+
−      /*
+
−       * Data Coding Scheme identifier matches
+
−       */
+
−      if (pcbch->dcs_id[i] <= dcs_id AND
+
−          pcbch->dcs_id[i+1] >= dcs_id)
+
−        result = (UBYTE)(pcbch->modus EQ CBCH_ACCEPT ? 1 : 0);
+
−  }
+
−
+
−  return result;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_check_old_msg           |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Check against old messages.
+
−
+
−*/
+
−LOCAL UBYTE cb_check_old_msg (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  int i;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  T_CBMSG_HEADER  *p_cbh = (T_CBMSG_HEADER*)&pcbch->msg[0];
+
−
+
−  ALR_TRACE_CB ("compare with stored msg");
+
−  for (i=0; i < pcbch->old_cbch_msg.cnt; i++)
+
−  {
+
−    ALR_TRACE_CB_MSGHEAD (&pcbch->old_cbch_msg.header[i]);
+
−
+
−    if (memcmp (&pcbch->old_cbch_msg.header[i], p_cbh, 6) EQ 0)
+
−    {
+
−      return FALSE; /* already stored message */
+
−    }
+
−    else
+
−    {
+
−      /* if the difference is only in the update number,
+
−       * then we need to delete the old version of the message (so that the different
+
−       * versions do not fill up the storage) and we can even abandon the comparison;
+
−       * a message that is resent with a different update number should only use
+
−       * one entry in the list; otherwise it may throw out other messages that should be kept;
+
−       * think of German network that sends every minute a new update; would use up 15 entries
+
−       *
+
−       * some change, now check if it is only the update number that has changed
+
−       * (memcmp covers 4 header bytes: msg_id3,  msg_id4, dcs and page
+
−       *  => ignore lint warning)
+
−       */
+
−      /*lint -e{420} (Warning -- Apparent access beyond array) */
+
−      if ((CB_GS_CODE(&pcbch->old_cbch_msg.header[i]) == CB_GS_CODE(p_cbh)) AND
+
−          (CB_MSG_CODE(&pcbch->old_cbch_msg.header[i]) == CB_MSG_CODE(p_cbh)) AND
+
−          !memcmp (&(((T_CBMSG_HEADER*)&pcbch->old_cbch_msg.header[i])->msg_id3),
+
−                     &p_cbh->msg_id3, 4)) 
+
−      { /* all these fields match, therefore the change must have been only in the update number */
+
−
+
−        SHORT old_update_nr, new_update_nr;
+
−        old_update_nr = CB_UPDATE_NO(&pcbch->old_cbch_msg.header[i]);
+
−        new_update_nr = CB_UPDATE_NO(p_cbh);
+
−        /*
+
−          * 3GPP 03 41
+
−          * Any Update Number eight or less higher (modulo 16) than the last received Update Number 
+
−          * will be considered more recent, and shall be treated as a new message
+
−          */          
+
−        if((!new_update_nr) OR 
+
−           ((new_update_nr - old_update_nr + MAX_UPDATE_NO) % MAX_UPDATE_NO <= MAX_UPDATE_NO_DIFF))
+
−        {
+
−           ALR_TRACE_CB ("change update num, delete old message");
+
−           /* remove the old message so that we do not use up another entry for this new version of the message */
+
−           cb_remove_message (i);
+
−           /* skip out of loop because we found the match  */
+
−           break;
+
−        }
+
−        else
+
−          return FALSE;
+
−      }
+
−    }
+
−  }
+
−
+
−  return TRUE;  /* new message */
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_read_cbch               |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Starts reading of the first block of CBCH.
+
−            The parameter defines if the extended or the normal CBCH
+
−            should be read and if scheduling should be used.
+
−
+
−*/
+
−
+
−LOCAL void cb_read_cbch (UBYTE flags)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE extended = (UBYTE)(flags & CBCH_READ_EXT);
+
−  ULONG first_block = pcbch->schedule_map[extended][0];
+
−  ULONG second_block = pcbch->schedule_map[extended][1];
+
−  
+
−  PALLOC (sched_req, MPHC_CBCH_SCHEDULE_REQ);
+
− 
+
−  ALR_TRACE_CB_START_READ(flags);
+
−
+
−  sched_req->cbch_select     = extended;
+
−
+
−  ALR_EM_START_CBCH_READING;
+
−
+
−  if(flags & CBCH_SCHED)
+
−  {
+
−    UBYTE n = pcbch->begin_schedule[extended] -1;
+
−    
+
−    sched_req->schedule_length = pcbch->end_schedule[extended] - 
+
−                                 pcbch->begin_schedule[extended] +1;
+
−
+
−    /*
+
−     * the MPHC SAP uses first_blocks_1 as USHORT although the internal data base 
+
−     * of ALR uses for convinience an array of 2 ULONG for first_blocks_0 and 
+
−     * first_blocks_1; ergo: do a cast for first_blocks_1 here
+
−     */
+
−
+
−    if(  pcbch->begin_schedule[extended] EQ 1)
+
−    {
+
−      sched_req->first_blocks_0  = first_block;
+
−      sched_req->first_blocks_1  = (USHORT)second_block;
+
−    }
+
−    else if(pcbch->begin_schedule[extended] < 32)
+
−    {
+
−      sched_req->first_blocks_0  = (first_block >> n) | ((second_block << (32 - n)));
+
−      sched_req->first_blocks_1  = (USHORT) (second_block >> n);
+
−    }
+
−    else
+
−    {
+
−      sched_req->first_blocks_0 = (USHORT)(second_block >> (n - 32));
+
−      sched_req->first_blocks_1  = 0;      
+
−    }    
+
−  }
+
−  else
+
−  {
+
−    sched_req->schedule_length = 0;
+
−  }
+
−
+
−  ma_cb_sched_req(sched_req);
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_check_ci_lai_plmn       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Checking the Cell Identity and the Location Area Identification
+
−            to handle the geographical zone parameter.
+
−*/
+
−
+
−LOCAL void cb_check_ci_lai_plmn (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  USHORT  i;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE   keep = 0x00;
+
−  UBYTE   *si3 = &alr_data->ma_data.sys_info_3[0];
+
−  UBYTE   *lac = &pcbch->old_cid_plmn_lac[0];
+
−  UCHAR  gs_scope_change_ind = CB_GEOGR_CHANGE_NONE;
+
−
+
−  /*
+
−   *  it is not permitted to save the cbch message,
+
−   *  if the following pattern are in the
+
−   *  location area identification (bcch:sys_info_3) :
+
−   *                   [4]  0x00
+
−   *                   [5]  0xF1
+
−   *                   [6]  0x10
+
−   *
+
−   *   that means FTA in testhouse.
+
−   */
+
−  if ((si3[4] EQ 0x00) AND
+
−      (si3[5] EQ 0xF1) AND
+
−      (si3[6] EQ 0x10)
+
−     )
+
−    return;
+
−
+
−  if ((si3[4] NEQ lac[2]) OR
+
−      (si3[5] NEQ lac[3]) OR
+
−      (si3[6] NEQ lac[4])
+
−     )
+
−  {
+
−    /*
+
−     *  The PLNM has changed
+
−     */
+
−    gs_scope_change_ind = CB_GEOGR_CHANGE_PLMN;
+
−    pcbch->old_cbch_msg.cnt = 0; /* clear all messages */
+
−  }
+
−  else if ((si3[7] NEQ lac[5]) OR
+
−           (si3[8] NEQ lac[6])
+
−          )
+
−  {
+
−    /*
+
−     *  The location area identification has changed
+
−     */
+
−    keep = CB_GEOGR_SCOPE_PLMN; /* keep PLMN wide messages */
+
−    gs_scope_change_ind = CB_GEOGR_CHANGE_LAC;
+
−  }
+
−  else if ((si3[2] NEQ lac[0]) OR
+
−           (si3[3] NEQ lac[1])
+
−          )
+
−  {
+
−    /*
+
−     *  The Cell Identity has changed
+
−     */
+
−
+
−    /* indicate cell change to MMI only if we have received any CBCH broadcast messages */
+
−    if (pcbch->old_cbch_msg.cnt > 0)
+
−		  gs_scope_change_ind = CB_GEOGR_CHANGE_CELL;
+
−    keep = CB_GEOGR_SCOPE_CELLN; /* keep PLMN and Location Area wide messages */
+
−  }
+
−
+
−
+
−  /*
+
−   * update old_cid_plmn_lac
+
−   */
+
−  memcpy (lac, &si3[2], 7);
+
−
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_remove_message          |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Removes the indicated CBCH message from the internal
+
−            storage.
+
−
+
−*/
+
−LOCAL void cb_remove_message (USHORT i)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  if ((pcbch->old_cbch_msg.cnt) AND
+
−      (i < pcbch->old_cbch_msg.cnt))
+
−  {
+
−    ALR_TRACE_CB ("remove msg");
+
−    ALR_TRACE_CB_MSGHEAD (&pcbch->old_cbch_msg.header[i]);
+
−
+
−    /*
+
−     * decrement number of stored messages.
+
−     */
+
−    pcbch->old_cbch_msg.cnt--;
+
−    memmove (&pcbch->old_cbch_msg.header[i],
+
−             &pcbch->old_cbch_msg.header[i+1],
+
−             (pcbch->old_cbch_msg.cnt-i) * sizeof(T_CBMSG_HEADER));
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_create_schedule_map     |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Creation of a schedule map.
+
−
+
−*/
+
−LOCAL void cb_create_schedule_map (UBYTE old_cb_msg)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE  extended = pcbch->msg_is_extended;
+
−  UBYTE* msg_ptr;
+
−
+
−  /*
+
−   * Store begin and end slot number
+
−   */
+
−  pcbch->begin_schedule [extended] = (UBYTE)(pcbch->msg [0] & 0x3F);
+
−  pcbch->end_schedule   [extended] = pcbch->msg [1];
+
−
+
−  /*
+
−   * clear schedule bitmap
+
−   */
+
−  pcbch->schedule_length[extended] = 0;
+
−  memset (&pcbch->schedule_map[extended][0], 0,
+
−        2*sizeof (pcbch->schedule_map[extended][0]));
+
−  /*
+
−   * Check all new entries,
+
−   * msg_ptr to first message description
+
−   */
+
−  msg_ptr = &pcbch->msg[8];
+
−
+
−  msg_ptr = cb_create_schedule_entries (msg_ptr, 1);
+
−
+
−  if (old_cb_msg)
+
−  {
+
−    cb_create_schedule_entries (msg_ptr, FALSE);
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_create_schedule_entries |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Creation of schedule entries.
+
−
+
−*/
+
−LOCAL UBYTE* cb_create_schedule_entries (UBYTE* msg_ptr, BOOL flag)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  unsigned    i;
+
−  BOOL        result;
+
−  UBYTE       x;
+
−  USHORT      msg_id;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE       extended = pcbch->msg_is_extended;
+
−
+
−  pcbch->last_slot_read[extended] = 0;
+
−  for (i=0; i < pcbch->end_schedule[extended]; i++)
+
−  {
+
−    result = (pcbch->msg [2 + ((i+1)>>3)] & (1 <<(8-((i+1)&7))));
+
−
+
−    ALR_TRACE_CB_SCHEDULE(i+1,result);
+
−
+
−    if ((flag AND result) OR (!flag AND !result))
+
−    {
+
−      /*
+
−       * result and bit are set, that means the msg:
+
−       *  - was not send during the previous schedule period
+
−       *  - or the msg was sent unscheduled during the last period
+
−       *  - or is free of charge, reading advised
+
−       * result and bit are both not set , that means the msg:
+
−       *  - the msg doesn't match the above
+
−       *  - these msgs are read only during the first 2 schedule periods
+
−       */
+
−      if (*msg_ptr & 0x80)
+
−      {
+
−        /*
+
−         * First transmission of an SMSCB within the
+
−         * Schedule Period
+
−         */
+
−
+
−        msg_id = (UBYTE)((*msg_ptr) & 0x7F);
+
−        msg_ptr++;
+
−        msg_id = (USHORT)(msg_id + *msg_ptr);
+
−        if (cb_check_message_id (msg_id))
+
−        {
+
−          /*
+
−           * Message Identifier is expected
+
−           * then set slot bit in schedule map
+
−           */
+
−          pcbch->schedule_map[extended][i>>5] |= 1 << (i&31);
+
−          if( (i+1) >= pcbch->begin_schedule[extended] )
+
−          {
+
−            pcbch->schedule_length[extended]++;
+
−            pcbch->last_slot_read[extended] = (i+1);
+
−          }
+
−        }
+
−      }
+
−      else
+
−      {
+
−        if ((*msg_ptr & 0xC0) EQ 0)
+
−        {
+
−          /*
+
−           * Retransmission indication
+
−           * Extract original message slot number
+
−           */
+
−          x = (UBYTE)(*msg_ptr & 0x3F);
+
−          if (x)
+
−          {
+
−            x--;
+
−            if (pcbch->schedule_map[extended][x>>5] & (1 << (x&31)) )
+
−            {
+
−              /*
+
−               * original message will be read, then set also
+
−               * repetition of message in schedule map
+
−               */
+
−              pcbch->schedule_map[extended][i>>5] |= 1 << (i&31);
+
−              if( (i+1) >= pcbch->begin_schedule[extended] )
+
−              {
+
−                pcbch->schedule_length[extended]++;
+
−                pcbch->last_slot_read[extended] = (i+1);
+
−              }
+
−            }
+
−          }
+
−        }
+
−        else
+
−        {
+
−          if (*msg_ptr EQ 0x41)
+
−          {
+
−            /*
+
−             * Free Message Slot, reading advised
+
−             * Set bit in schedule map
+
−             */
+
−            pcbch->schedule_map[extended][i>>5] |= 1 << (i&31);
+
−            if( (i+1) >= pcbch->begin_schedule[extended] )
+
−            {
+
−              pcbch->schedule_length[extended]++;
+
−              pcbch->last_slot_read[extended] = (i+1);
+
−            }
+
−          }
+
−        }
+
−      }
+
−      /*
+
−       * increment message description pointer
+
−       */
+
−      msg_ptr++;
+
−    }
+
−  }
+
−  return msg_ptr;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : cb_next_scheduled_msg      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Looks for end of scheduling period.
+
−
+
−*/
+
−LOCAL void cb_next_scheduled_msg(void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−  UBYTE extended = pcbch->msg_is_extended;
+
−
+
−  if ((get_cbch_state(extended)) EQ CBCH_DRX )
+
−  {
+
−    if( pcbch->schedule_length[extended] EQ 0 )
+
−    {
+
−      /*
+
−        * instead of the scheduled SCHEDULE message
+
−        * an invalid message has been received.
+
−        * Restarting with NO DRX mode
+
−        */
+
−      set_cbch_state (extended, CBCH_NO_DRX);
+
−      cb_read_cbch ((UBYTE)(CBCH_NO_SCHED | extended));
+
−      return;
+
−    }
+
−    pcbch->schedule_length[extended]--;
+
−
+
−    if(pcbch->schedule_length[extended] EQ 0)
+
−    {
+
−     /*
+
−       * clear schedule map
+
−       * all message slots have been read
+
−       *
+
−       * NO need to reconfigure L1 to re-read schedule message 
+
−       * that follows slot 48
+
−       */
+
−      memset (&pcbch->schedule_map[extended][0], 0,
+
−        2*sizeof (pcbch->schedule_map[extended][0]));
+
−      TRACE_EVENT("Scheduled Schedule message expected");
+
−
+
−    }
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : get_cbch_state      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Returns the state of STATE_EXT_CBCH or STATE_NORMAL_CBCH
+
−                   depending upon the input parameter "extended"
+
−
+
−*/
+
−
+
−UBYTE get_cbch_state( UBYTE extended)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  if( extended)
+
−    return GET_STATE(STATE_EXT_CBCH);
+
−  else
+
−    return GET_STATE(STATE_NORMAL_CBCH);
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6103)       MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE : set_cbch_state      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Sets  the state of STATE_EXT_CBCH or STATE_NORMAL_CBCH
+
−                   depending upon the input parameter "extended"
+
−
+
−*/
+
−
+
−void set_cbch_state( UBYTE extended, UBYTE new_state)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  if(extended)
+
−  {
+
−    SET_STATE(STATE_EXT_CBCH,new_state);
+
−  }
+
−  else
+
−    SET_STATE(STATE_NORMAL_CBCH,new_state);
+
−}
+
−
+
−
+
−#if defined(FF_HOMEZONE)
+
−GLOBAL void cb_tim_homezone (void)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  if (pcbch->homezone EQ CBCH_HZ_IDLE)
+
−  {
+
−    if (GET_STATE(STATE_MA) EQ MA_IDLE)
+
−    {
+
−      ALR_TRACE_CB ("call cb_start()");
+
−      cb_start ();
+
−    }
+
−    else
+
−    {
+
−      TIMERSTART (TIM_HOMEZONE, 1000);
+
−    }
+
−  }
+
−  else if (pcbch->homezone EQ CBCH_HZ_PENDING)
+
−  {
+
−    /*
+
−     * mark as received, indicate error, stop CBCH reading
+
−     */
+
−    ALR_TRACE_CB ("cb_ind_hz_err()");
+
−    pcbch->homezone = CBCH_HZ_RECEIVED;
+
−#if defined(INDICATE_HZ_ERROR)
+
−    cb_ind_hz_err ();
+
−#endif  /* INDICATE_HZ_ERROR */
+
−    if (    (pcbch->modus EQ NOT_PRESENT_8BIT)
+
−        AND (!pcbch->sat_enabled))
+
−      cb_stop ();
+
−  }
+
−}
+
−
+
−LOCAL UBYTE cb_check_homezone (UBYTE length)
+
−{
+
−  GET_INSTANCE_DATA;
+
−  UBYTE  result = FALSE;/* no special handling of homezone CBCH message */
+
−  T_CBCH_DATA *pcbch = &alr_data->cbch_data;
+
−
+
−  if (pcbch->homezone EQ CBCH_HZ_PENDING)
+
−  {
+
−    T_CBMSG_HEADER  *p_cbh;
+
−    p_cbh = (T_CBMSG_HEADER*)(&pcbch->msg[0]);
+
−
+
−    if (    (CB_MESSAGE_ID (p_cbh) EQ pcbch->msg_hz_id)
+
−        AND (CB_DCS (p_cbh)        EQ pcbch->dcs_hz_id)
+
−       )
+
−    {
+
−      /* one-time request of homezone CBCH message after cell reselection */
+
−      TIMERSTOP (TIM_HOMEZONE);
+
−      pcbch->homezone = CBCH_HZ_RECEIVED;
+
−      ALR_TRACE_CB_MSGHEAD (p_cbh);
+
−      ALR_TRACE_CB ("homezone msg received");
+
−      cb_ind (length);
+
−      result = TRUE;
+
−
+
−      if (    (pcbch->modus EQ NOT_PRESENT_8BIT)
+
−          AND (!pcbch->sat_enabled))
+
−      {
+
−        ALR_TRACE_CB ("no other msg req.");
+
−        cb_stop ();
+
−      }
+
−      else
+
−        cb_stop_next_blocks ();
+
−    }
+
−  }
+
−
+
−  return result;
+
−}
+
−#endif  /* FF_HOMEZONE */
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT :                     MODULE  : ALR_CBCH                   |
+
−| STATE   : code                ROUTINE  : cb_alr_trace_msghead      |
+
−+--------------------------------------------------------------------+
+
−
+
−PURPOSE : Function to replace the ALR_TRACE_CB_MSGHEAD macro.
+
−
+
−*/
+
−
+
−/* Implements measures 2,3,4 */
+
−LOCAL void cb_alr_trace_msghead (T_CBMSG_HEADER *ph)
+
−{
+
−  ALR_TRACE_CB ("cb_alr_trace_msghead()");
+
−  if (CB_MSG_CODE(ph) < 1000) 
+
−  {
+
−    TRACE_EVENT_P7("CBCH ID=%3u, gs=%u, msg=%4u, upd=%u, dcs=%02x, p=%u/%u",
+
−                    CB_MESSAGE_ID(ph), CB_GS_CODE(ph),
+
−                    CB_MSG_CODE(ph), CB_UPDATE_NO(ph),
+
−                    CB_DCS(ph), CB_PAGE(ph), CB_PAGETOTAL(ph));
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT_P7("CBCH ID=%3u, gs=%u, msg=%04x, upd=%u, dcs=%02x, p=%u/%u",
+
−                    CB_MESSAGE_ID(ph), CB_GS_CODE(ph),
+
−                    CB_MSG_CODE(ph), CB_UPDATE_NO(ph),
+
−                    CB_DCS(ph), CB_PAGE(ph), CB_PAGETOTAL(ph));
+
−  }
+
−}
+
−#endif