--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gprs/grr/grr_cpapf.c	Sun Jul 15 04:40:46 2018 +0000
@@ -0,0 +1,1762 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  GPRS (8441)
+|  Modul   :  GRR
++----------------------------------------------------------------------------- 
+|  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 module implements local functions for service CPAP of
+|             entity GRR.
++----------------------------------------------------------------------------- 
+*/ 
+
+#ifndef GRR_CPAPF_C
+#define GRR_CPAPF_C
+#endif
+
+#define ENTITY_GRR
+
+/*==== INCLUDES =============================================================*/
+
+#include <string.h>
+#include "typedefs.h"    /* to get Condat data types */
+
+#include "vsi.h"        /* to get a lot of macros */
+#include "macdef.h"
+#include "gprs.h"
+#include "gsm.h"        /* to get a lot of macros */
+#include "ccdapi.h"     /* to get CCD API */
+#include "cnf_grr.h"    /* to get cnf-definitions */
+#include "mon_grr.h"    /* to get mon-definitions */
+#include "prim.h"       /* to get the definitions of used SAP and directions */
+#include "message.h"
+#include "pcm.h"        /* to get a lot of macros */
+#include "grr.h"        /* to get the global entity definitions */
+#include "grr_f.h"      /* to get the global function definitions */
+#include "grr_tcf.h"    /* to get the tc function definitions */
+#include "grr_tcs.h"    /* to get the tc sig function definitions */
+#include "grr_cpapf.h"
+#include "grr_meass.h"  /* to get the definitions for interference measurements */
+
+/*==== CONST ================================================================*/
+
+/*==== LOCAL VARS ===========================================================*/
+
+/*==== PRIVATE FUNCTIONS ====================================================*/
+
+LOCAL void cpap_set_da_assignment_pdch (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i);
+LOCAL void cpap_set_dl_assignment_pdch (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i);
+LOCAL BOOL cpap_check_and_save_freq (void);
+
+
+/*==== PUBLIC FUNCTIONS =====================================================*/
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_init
++------------------------------------------------------------------------------
+| Description : The function cpap_init() .... 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_init ( void )
+{ 
+  TRACE_FUNCTION( "cpap_init" );
+
+  INIT_STATE(CPAP,CPAP_IDLE);
+  grr_data->cpap.new_tbf_type   = CGRLC_TBF_MODE_NULL;
+  grr_data->cpap.v_tma_ia       = FALSE;
+  grr_data->cpap.p_d_imm_assign = NULL;
+} /* cpap_init() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_eval_ia
++------------------------------------------------------------------------------
+| Description : The function cpap_eval_ia() .... 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_EVAL_IA cpap_eval_ia ( void )
+{ 
+  MCAST(d_imm_assign,D_IMM_ASSIGN);/*  T_D_IMM_ASSIGN T_U_CTRL_ACK */
+  T_EVAL_IA result = E_IA_NULL;
+  T_tfi_ass_alloc * p_tfi_ass;
+  TRACE_FUNCTION( "cpap_eval_ia" );
+
+  if(d_imm_assign->tma EQ TMA_1) 
+  {
+    /* the 1st message is only delivered by rr if the 2nd message has arrived */
+    /* with correct request reference so it has not to be checked here again  */
+    result = E_IA_TMA;       /* 1st part of TWO MESSAGE ASSIGNMENT */
+  }
+  else if(d_imm_assign->d_t EQ D_T_DED)
+  {
+    result = E_IA_DCCH;
+  }
+  else if(d_imm_assign->ia_rest_oct.v_ia_assign_par AND
+       d_imm_assign->ia_rest_oct.ia_assign_par.v_pck_upl_ass_ia AND
+       d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia.v_tfi_ass_alloc)
+  {
+    T_pck_upl_ass_ia *pck_upl_ass_ia = 
+      &(d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia);
+    p_tfi_ass = &(pck_upl_ass_ia->tfi_ass_alloc); /* more contents than before*/
+
+    grr_data->uplink_tbf.ts_usage     = (0x80>>d_imm_assign->pck_chan_desc.tn);
+    grr_data->uplink_tbf.nts          = 1;
+    /*
+     * handle polling bit
+     */
+    if(p_tfi_ass->poll AND
+        (!grr_check_if_tbf_start_is_elapsed(grr_decode_tbf_start_abs((T_abs *)&d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia.tfi_ass_alloc.tbf_start_time ),grr_data->ul_fn)))
+      grr_data->uplink_tbf.polling_bit  = d_imm_assign->pck_chan_desc.tn;
+    else
+      grr_data->uplink_tbf.polling_bit  = 0xFF;  
+    
+    grr_data->uplink_tbf.cs_mode      = p_tfi_ass->ccm;
+    grr_data->uplink_tbf.tlli_cs_mode = p_tfi_ass->tlli_bcc;
+
+
+    
+    if(p_tfi_ass->allo_flag EQ 0)    /* Dynamic Allocation */
+    { 
+      if(p_tfi_ass->v_usf AND p_tfi_ass->v_usf_gran)
+      {
+        result = E_IA_UL;             /* Dynamic Allocation */
+        grr_data->uplink_tbf.mac_mode = CGRLC_MAC_MODE_DA;
+      }
+      else /* dynamic alloc but no usf value */
+      {
+        result = E_IA_ERROR_RA;
+        TRACE_ERROR("dynamic alloc but no usf value!");
+      }
+    }
+    else /*fixed alloc*/
+      if (p_tfi_ass->v_allo_len5 AND p_tfi_ass->v_allo_bmp5 AND 
+                                         p_tfi_ass->v_tbf_start_time)
+    {
+      result = E_IA_UL;               /* Fixed Allocation */
+      grr_data->uplink_tbf.mac_mode = CGRLC_MAC_MODE_FA;
+    }
+    else /* fixed alloc but no alloc bitmap or tbf starting time */
+    {
+      result = E_IA_ERROR_RA;
+      TRACE_ERROR("fixed alloc but no alloc bitmap or tbf starting time!");
+    }
+
+    if (!cpap_check_and_save_freq())
+    {
+      result = E_IA_ERROR_RA;
+      TRACE_EVENT("cpap_eval_ia: return E_IA_ERROR_RA (frequencies wrong)");
+    }
+
+    if( result NEQ E_IA_ERROR_RA )
+    {
+      /* process power control parameter */
+      grr_store_type_pck_upl_ass_ia( p_tfi_ass,
+                                     d_imm_assign->pck_chan_desc.tn );
+    }
+  }
+  else if(d_imm_assign->ia_rest_oct.v_ia_assign_par AND
+     d_imm_assign->ia_rest_oct.ia_assign_par.v_pck_upl_ass_ia AND
+     d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia.v_sngl_block_alloc)
+  { /* single block */
+    T_sngl_block_alloc *sngl_block_ass = 
+        &d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia.sngl_block_alloc;
+
+    if( grr_data->tc.v_sb_without_tbf )
+    {
+      result = E_IA_SB_WITHOUT_TBF;
+    }
+    else
+    {
+      result = E_IA_SB_2PHASE_ACCESS;
+    }
+
+    if (!cpap_check_and_save_freq())
+    {
+      result = E_IA_ERROR_RA;
+      TRACE_EVENT("cpap_eval_ia: return E_IA_ERROR_RA (frequencies wrong)");
+    }
+
+    if( result NEQ E_IA_ERROR_RA )
+    {
+      /* process power control parameter */
+      grr_store_type_pck_snbl_ass_ia( sngl_block_ass,
+                                      d_imm_assign->pck_chan_desc.tn );
+    }
+  }
+  else if(d_imm_assign->ia_rest_oct.v_ia_assign_par AND
+     d_imm_assign->ia_rest_oct.ia_assign_par.v_ia_2nd_part)
+  {
+    result = E_IA_TMA_SECOND;
+  }
+  else
+  {
+    result = E_IA_ERROR_RA;
+    TRACE_ERROR("corrupted message recieved!");
+  }
+  return(result);
+} /* cpap_eval_ia() */
+
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_eval_ia_dl
++------------------------------------------------------------------------------
+| Description : The function cpap_eval_ia_dl() .... 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_EVAL_IA_DL cpap_eval_ia_dl ( void )
+{ 
+  MCAST(d_imm_assign,D_IMM_ASSIGN);/*  T_D_IMM_ASSIGN */
+  T_EVAL_IA_DL result = E_IA_DL_IGNORE;
+  T_pck_downl_ass_ia * p_dl_assign;
+
+  TRACE_FUNCTION( "cpap_eval_ia_dl" );
+
+  if(d_imm_assign->d_t EQ D_T_DED)
+  {
+    result = E_IA_DL_DCCH;
+  }
+  else if(d_imm_assign->tma EQ TMA_1) 
+  {
+    /* the 1st message is only delivered by rr if the 2nd message has arrived */
+    /* with correct request reference so it has not to be checked here again  */
+    if(d_imm_assign->ia_rest_oct.v_ia_assign_par AND
+    d_imm_assign->ia_rest_oct.ia_assign_par.v_pck_downl_ass_ia AND
+    d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia.v_tfi_ass_rlc)
+    {
+      p_dl_assign =
+        &(d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia);
+      if(grr_check_all_tlli((BUF_tlli_value *)&(p_dl_assign->ded_tlli)))
+      {
+        result = E_IA_DL_TMA;        
+      }
+      else
+      {
+        result = E_IA_DL_NOT_OURS;
+      }
+    }
+    else
+    {
+      result = E_IA_DL_IGNORE;
+      TRACE_ERROR("the 1st message is only delivered by rr if the 2nd message has arrived");
+    }
+  }
+  else if(d_imm_assign->ia_rest_oct.v_ia_assign_par AND
+    d_imm_assign->ia_rest_oct.ia_assign_par.v_pck_downl_ass_ia AND
+    d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia.v_tfi_ass_rlc)
+  {
+    p_dl_assign =
+      &(d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia);
+    if(grr_check_all_tlli((BUF_tlli_value *)&(p_dl_assign->ded_tlli)))
+    {
+      result = E_IA_DL_ASSIGN;
+      grr_data->downlink_tbf.ts_usage    = (0x80>>d_imm_assign->pck_chan_desc.tn);
+      grr_data->downlink_tbf.nts         = 1; 
+      /*
+       * handle polling bit
+       */
+      if(p_dl_assign->tfi_ass_rlc.poll AND
+         (!grr_check_if_tbf_start_is_elapsed(grr_decode_tbf_start_abs((T_abs *)&d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia.tbf_start_time ),grr_data->ul_fn)))
+        grr_data->downlink_tbf.polling_bit = d_imm_assign->pck_chan_desc.tn;
+      else
+        grr_data->downlink_tbf.polling_bit = 0xFF;
+ 
+      grr_data->downlink_tbf.mac_mode    = DA;                          /* by default set to */
+      grr_data->downlink_tbf.t3192       = FALSE;                      /* indicates if t3192 is running*/
+      grr_data->downlink_tbf.rlc_mode    = p_dl_assign->tfi_ass_rlc.rlc_mode;
+      grr_data->downlink_tbf.ctrl_ack_bit= 0;   
+
+      if (!cpap_check_and_save_freq())
+      {
+        result = E_IA_DL_IGNORE;
+        TRACE_EVENT("cpap_eval_ia_dl: return E_IA_DL_IGNORE (frequencies wrong)");
+      }
+
+      if( result EQ E_IA_DL_ASSIGN )
+      {
+        grr_store_type_tfi_ass_rlc( &p_dl_assign->tfi_ass_rlc,
+                                    d_imm_assign->pck_chan_desc.tn );
+      }
+    }
+    else
+    {
+      result = E_IA_DL_NOT_OURS;
+    }
+  }
+  else if(d_imm_assign->ia_rest_oct.v_ia_assign_par AND
+    d_imm_assign->ia_rest_oct.ia_assign_par.v_pck_downl_ass_ia AND
+    d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia.v_tbf_start_time)
+  {
+    p_dl_assign =
+      &(d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia);
+    if(grr_check_all_tlli((BUF_tlli_value *)&(p_dl_assign->ded_tlli)))
+    {
+      result = E_IA_DL_SB;
+      if (!cpap_check_and_save_freq())
+      {
+        result = E_IA_DL_IGNORE;
+        TRACE_EVENT("cpap_eval_ia_dl: return E_IA_DL_IGNORE (frequencies wrong)");
+      }
+    }
+    else
+    {
+      result = E_IA_DL_NOT_OURS;
+    }
+  }
+  else if(d_imm_assign->ia_rest_oct.v_ia_assign_par AND
+    d_imm_assign->ia_rest_oct.ia_assign_par.v_ia_2nd_part)
+  {
+    result = E_IA_DL_TMA_SECOND;
+  }
+
+  if(result EQ E_IA_DL_IGNORE)
+  {
+    TRACE_ERROR("None of the if switches were reached LINE 330 cpapf");
+  }
+  return(result);
+} /* cpap_eval_ia_dl() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_eval_pdch_assignment
++------------------------------------------------------------------------------
+| Description : The function cpap_eval_pdch_assignment() .... 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_EVAL_PDCH_ASSIGN cpap_eval_pdch_assignment ( void )
+{ 
+  MCAST(d_pdch_ass_cmd,D_PDCH_ASS_CMD);/*  T_D_PDCH_ASS_CMD */
+  T_EVAL_PDCH_ASSIGN result = E_PDCH_ASSIGN_IGNORE;
+
+  TRACE_FUNCTION( "cpap_eval_pdch_assignment" );
+
+  if(d_pdch_ass_cmd->msg_type EQ D_PDCH_ASS_CMD)
+  {
+    if(!(d_pdch_ass_cmd->v_pck_ul_ass OR d_pdch_ass_cmd->v_pck_dl_ass))
+    {
+      result = E_PDCH_ASSIGN_ERROR;
+      TRACE_ERROR("no Packet Assignment included in message");
+    }
+    else if(d_pdch_ass_cmd->v_pck_ul_ass AND d_pdch_ass_cmd->pck_ul_ass.v_dyn_alloc)
+    {
+      UBYTE tx_slots = 0, ts_usage = 0,i,mask;
+      grr_data->uplink_tbf.mac_mode = CGRLC_MAC_MODE_DA;
+      result = E_PDCH_ASSIGN_UL;
+      if(d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.v_tagged_usf_tn)
+      {
+        for(i = 0,mask = 0x80;i < 8;i++)
+        {
+          if(d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.tagged_usf_tn[i].v_usf)
+          {
+            ts_usage |= mask;
+            tx_slots++;
+          }
+          mask >>= 1;
+        }
+      }
+      else if(d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.v_usf_gamma_csn1)
+      {
+        for(i = 0,mask = 0x80;i < 8;i++)
+        {
+          if(d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.usf_gamma_csn1[i].v_usf_gamma)
+          {
+            ts_usage |= mask;
+            tx_slots++;
+          }
+          mask >>= 1;
+        }
+      }
+      grr_store_type_dyn_alloc( &d_pdch_ass_cmd->pck_ul_ass.dyn_alloc );
+     
+      grr_data->uplink_tbf.ts_usage = ts_usage;
+      grr_data->uplink_tbf.nts = tx_slots;
+      if( !handle_ms_cap(UL_ASSIGNMENT) )
+      {
+        result = E_PDCH_ASSIGN_ERROR;
+        TRACE_ERROR("too much or no timeslot(s) assigned!");
+      }
+    }
+    else if(d_pdch_ass_cmd->v_pck_ul_ass AND 
+                                    d_pdch_ass_cmd->pck_ul_ass.v_single_alloc)
+    {
+      result = E_PDCH_ASSIGN_SB;
+      if( d_pdch_ass_cmd->pck_ul_ass.single_alloc.v_alpha_gamma EQ TRUE )
+      {
+        grr_store_type_alpha_gamma
+                 ( &d_pdch_ass_cmd->pck_ul_ass.single_alloc.alpha_gamma,
+                    d_pdch_ass_cmd->pck_ul_ass.single_alloc.tn );
+      }
+
+      /* SZML-CPAP/029 */
+    }
+    else if(d_pdch_ass_cmd->v_pck_ul_ass AND 
+                                       d_pdch_ass_cmd->pck_ul_ass.v_fix_alloc)
+    {
+      result = E_PDCH_ASSIGN_UL;
+      grr_data->uplink_tbf.mac_mode = CGRLC_MAC_MODE_FA;
+      if( d_pdch_ass_cmd->pck_ul_ass.fix_alloc.v_pwr_ctrl EQ TRUE )
+      {
+        grr_store_type_pwr_ctrl( &d_pdch_ass_cmd->pck_ul_ass.fix_alloc.pwr_ctrl );
+      }
+
+      /* SZML-CPAP/030 */
+    }
+    else if(d_pdch_ass_cmd->v_pck_dl_ass)
+    {
+      result = E_PDCH_ASSIGN_DL;
+      if( d_pdch_ass_cmd->pck_dl_ass.v_pwr_ctrl EQ TRUE )
+      {
+        grr_store_type_pwr_ctrl( &d_pdch_ass_cmd->pck_dl_ass.pwr_ctrl );
+      }
+
+      /* SZML-CPAP/031 */
+    }
+  }
+  else
+  {
+    TRACE_ERROR("wrong message type!");
+  }
+  return(result);
+} /* cpap_eval_pdch_assignment() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_build_gprs_data_request
++------------------------------------------------------------------------------
+| Description : The function cpap_build_gprs_data_request() .... 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_build_gprs_data_request (T_RRGRR_GPRS_DATA_REQ *rrgrr_gprs_data_req)
+{ 
+  /* T_D_RR_INIT_REQ */ /* T_PRIM_QUEUE */
+  /*  T_D_IMM_ASSIGN */ /* T_GRR_DATA_REQ */
+
+  TRACE_FUNCTION( "cpap_build_gprs_data_request" );
+
+  rrgrr_gprs_data_req->new_ptmsi = grr_data->db.ms_id.new_ptmsi;
+  rrgrr_gprs_data_req->old_ptmsi = grr_data->db.ms_id.old_ptmsi;
+
+  rrgrr_gprs_data_req->tlli = grr_data->db.ms_id.new_tlli;
+  rrgrr_gprs_data_req->rai  = grr_data->db.ms_id.rai;
+  rrgrr_gprs_data_req->mac_req = DA;
+  rrgrr_gprs_data_req->cs_req  = COD_S_1;
+  rrgrr_gprs_data_req->p_chan_req_des.mo_mt = OR_TY_MO;
+  if( grr_data->tc.v_sb_without_tbf )
+  {
+    rrgrr_gprs_data_req->p_chan_req_des.llc_type     = LLC_NOT_ACK;
+    rrgrr_gprs_data_req->p_chan_req_des.rlc_mode_req = RLC_UNACK_MODE;
+    rrgrr_gprs_data_req->p_chan_req_des.prio = RADIO_PRIO_4;
+    rrgrr_gprs_data_req->p_chan_req_des.req_bwd = 80;/* 8000 bit/s */
+    rrgrr_gprs_data_req->p_chan_req_des.rlc_octets = 22;/* one RLC/MAC block */
+  }
+  else
+  {
+    UBYTE i=0;
+    USHORT j =1;
+    if(grr_data->uplink_tbf.prim_type EQ CGRLC_LLC_PRIM_TYPE_DATA_REQ)
+    { /* CGRLC_LLC_PRIM_TYPE_DATA_REQ */
+      rrgrr_gprs_data_req->p_chan_req_des.llc_type     = LLC_NOT_ACK;
+      rrgrr_gprs_data_req->p_chan_req_des.rlc_mode_req = RLC_ACK_MODE;
+    } 
+    else
+    { /* CGRLC_LLC_PRIM_TYPE_UNITDATA_REQ*/
+      rrgrr_gprs_data_req->p_chan_req_des.llc_type     = LLC_IS_ACK;
+      rrgrr_gprs_data_req->p_chan_req_des.rlc_mode_req = RLC_UNACK_MODE;
+    }
+    rrgrr_gprs_data_req->p_chan_req_des.prio =  grr_data->uplink_tbf.prio;
+
+    rrgrr_gprs_data_req->p_chan_req_des.req_bwd    = 0;
+
+    for(i=2; i<=grr_data->uplink_tbf.peak;i++)
+    {
+      j *= 2;
+    }
+    if(grr_data->uplink_tbf.peak)
+      rrgrr_gprs_data_req->p_chan_req_des.req_bwd = j*80;
+
+    rrgrr_gprs_data_req->p_chan_req_des.rlc_octets = grr_data->uplink_tbf.rlc_oct_cnt; 
+  }
+
+  rrgrr_gprs_data_req->gprs_meas_results.c_value  = meas_c_get_value( );
+  rrgrr_gprs_data_req->gprs_meas_results.rxqual   = 0;
+  rrgrr_gprs_data_req->gprs_meas_results.sign_var = 0;
+
+} /* cpap_build_gprs_data_request() */
+
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_send_ass_fail
++------------------------------------------------------------------------------
+| Description : The function cpap_send_ass_fail() .... 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_send_ass_fail (UBYTE cause)
+{  
+  TRACE_FUNCTION( "cpap_send_ass_fail" );
+  {
+    PALLOC_SDU(rrgrr_data_req,RRGRR_DATA_REQ,3*8);
+
+    rrgrr_data_req->sdu.l_buf  = 3*8;
+    rrgrr_data_req->sdu.o_buf  = 0;
+    rrgrr_data_req->sdu.buf[0] = 0x06;            /* protocol discriminator & skip indicator */
+    rrgrr_data_req->sdu.buf[1] = U_ASSIGN_FAIL;   /* message type */                                   /*lint !e415*/
+    rrgrr_data_req->sdu.buf[2] = cause;           /* RRC_CHANNEL_MODE*/ /* assignment failure cause */ /*lint !e415 !e416*/
+    sig_cpap_tc_dcch_data_req(rrgrr_data_req);
+  }
+} /* cpap_send_ass_fail() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_send_assign_req_pdch
++------------------------------------------------------------------------------
+| Description : The function cpap_send_assign_req_pdch() builds MPHP_ASSIGNMENT_REQ
+|               and send it.
+|
+| Parameters  : tbf_type_i - type of TBF that is to activate
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_send_assign_req_pdch (T_TBF_TYPE tbf_type_i)
+{ 
+  TRACE_FUNCTION( "cpap_send_assign_req_pdch" );
+  {
+    PALLOC(ptr2prim,MPHP_ASSIGNMENT_REQ);
+    
+    memset(ptr2prim,0,sizeof(T_MPHP_ASSIGNMENT_REQ));
+  
+    grr_set_tbf_cfg_req_param( ptr2prim );
+    
+    switch( tbf_type_i )
+    {
+      case CGRLC_TBF_MODE_UL:
+        ptr2prim->assign_cmd = UL_ASSIGNMENT;
+        if(grr_data->uplink_tbf.mac_mode EQ CGRLC_MAC_MODE_DA)
+          cpap_set_da_assignment_pdch(ptr2prim);
+        else
+        {
+          /* SZML-CPAP/032 */
+        }
+
+        sig_cpap_tc_assign_pdch(ptr2prim, PDCH_UL_ASS_CMD);
+        break;
+      case CGRLC_TBF_MODE_DL:
+        ptr2prim->assign_cmd = DL_ASSIGNMENT;
+        cpap_set_dl_assignment_pdch(ptr2prim);
+        sig_cpap_tc_assign_pdch(ptr2prim, PDCH_DL_ASS_CMD);
+        break;
+      default:
+        PFREE(ptr2prim);
+        TRACE_ERROR ( "unknown tbf type!" );
+        break;
+    } /* switch (tbf_type_i) */
+  }
+} /* cpap_send_assign_req_pdch() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_set_da_assignment_pdch
++------------------------------------------------------------------------------
+| Description : This function sets some parameter of MPHP_ASSIGFNMENT_REQ in 
+|               case of uplink dynamic allocation.
+|
+| Parameters  : ptr2prim_i -  ptr to mphp_assignment_req
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cpap_set_da_assignment_pdch (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i)
+{
+  UBYTE i;
+  MCAST(d_pdch_ass_cmd,D_PDCH_ASS_CMD); /* T_D_PDCH_ASS_CMD */
+                                        /* T_D_IMM_ASSIGN   */
+
+  TRACE_FUNCTION( "cpap_set_da_assignment_pdch" );
+  if( d_pdch_ass_cmd->msg_type EQ D_PDCH_ASS_CMD) 
+  {
+    /* bts downlink power control parameters */
+    if(d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.v_p0)
+      ptr2prim_i->p_dl_power.p0 = d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.p0;
+    else
+      ptr2prim_i->p_dl_power.p0 = 0xff;
+    /* dynamic allocation must use mode a */
+    ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = MODE_A;
+    ptr2prim_i->p_dl_power.pr_mode = PR_MODE_A_ONE;
+    /*
+     * timing advance
+     */
+    if(d_pdch_ass_cmd->pck_ul_ass.pck_ta.v_ta)
+    {
+      ptr2prim_i->p_timing_advance.ta_value =
+                                         d_pdch_ass_cmd->pck_ul_ass.pck_ta.ta;
+    }
+    else
+    {
+      ptr2prim_i->p_timing_advance.ta_value = 0xff;
+    }
+    if(d_pdch_ass_cmd->pck_ul_ass.pck_ta.v_ta_idx_nm)
+    {
+      ptr2prim_i->p_timing_advance.ta_index =
+                           d_pdch_ass_cmd->pck_ul_ass.pck_ta.ta_idx_nm.ta_idx;
+      ptr2prim_i->p_timing_advance.tn = 
+                            d_pdch_ass_cmd->pck_ul_ass.pck_ta.ta_idx_nm.ta_nm;
+    }
+    else
+    {
+      ptr2prim_i->p_timing_advance.ta_index = 0xff;
+      ptr2prim_i->p_timing_advance.tn = 0xff;
+    }
+    /*
+     *  trainings sequence
+     */    
+    ptr2prim_i->tsc = d_pdch_ass_cmd->chan_desc.tsc; 
+    /*
+     *  frequency parameters
+     */
+    if(!d_pdch_ass_cmd->chan_desc.hop)
+    {
+      if(d_pdch_ass_cmd->chan_desc.v_arfcn)
+      {
+        ptr2prim_i->p_frequency_par.p_chan_sel.hopping=0;
+        memset(ptr2prim_i->p_frequency_par.p_freq_list.p_rf_chan_no.p_radio_freq,0,MPHP_NUMC_MA);
+        ptr2prim_i->p_frequency_par.p_chan_sel.p_rf_ch.arfcn = 
+          grr_g23_arfcn_to_l1(d_pdch_ass_cmd->chan_desc.arfcn);
+      }
+    }
+    /* SZML-CPAP/002 */
+    /* SZML-CPAP/003 */
+   /*
+    * mac mode 
+    */
+    ptr2prim_i->mac_mode = 
+                    (d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.ext_dyn_all)? EDA:DA;
+   /*
+    * uplink allocation structure 
+    */
+    if(d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.v_tfi)
+      ptr2prim_i->p_ul_alloc.ul_tfi = d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.tfi;
+    else
+      ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi; 
+    ptr2prim_i->p_ul_alloc.ts_mask  = grr_data->uplink_tbf.ts_usage; 
+   /*
+    *  dynamic allocation structure
+    */
+    ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_gran = 
+                               d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.usf_gran;
+    if(d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.v_tagged_usf_tn)
+    {
+      for(i = 0;i < 8;i++)
+      {
+        ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] = 
+                    d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.tagged_usf_tn[i].usf;
+      }
+    }
+    else if(d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.v_usf_gamma_csn1)
+    {
+      for(i = 0;i < 8;i++)
+      {
+        ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] = 
+         d_pdch_ass_cmd->pck_ul_ass.dyn_alloc.usf_gamma_csn1[i].usf_gamma.usf;
+      }
+    }
+    else
+    {
+      ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[0] = 5;
+      TRACE_EVENT("USF-Error: set (hardcoded) USF_TN0 = 0x05");
+    }
+    /*  
+     * TBF starting time
+     */
+    if(d_pdch_ass_cmd->v_start_time)
+    {
+      ptr2prim_i->p_tbf_start.tbf_start_present = 1;
+      ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs((T_abs *)&d_pdch_ass_cmd->start_time);
+      if(d_pdch_ass_cmd->v_chan_desc_before)
+      {
+        PALLOC(ptr2prim2,MPHP_ASSIGNMENT_REQ);
+        memset(ptr2prim2,0,sizeof(T_MPHP_ASSIGNMENT_REQ));
+
+        grr_set_tbf_cfg_req_param( ptr2prim2 );
+  
+        ptr2prim2->assign_cmd = UL_ASSIGNMENT;
+        ptr2prim2->p_dl_power.p0 = ptr2prim_i->p_dl_power.p0;
+        ptr2prim2->p_dl_power.bts_pwr_ctl_mode = 
+                                  ptr2prim_i->p_dl_power.bts_pwr_ctl_mode;
+        ptr2prim2->p_dl_power.pr_mode = ptr2prim_i->p_dl_power.pr_mode;
+        ptr2prim2->p_timing_advance.ta_value =
+                                    ptr2prim_i->p_timing_advance.ta_value;
+        ptr2prim2->p_timing_advance.ta_index =
+                                    ptr2prim_i->p_timing_advance.ta_index;
+        ptr2prim2->p_timing_advance.tn = ptr2prim_i->p_timing_advance.tn;
+        /*  trainings sequence  */    
+        ptr2prim2->tsc = d_pdch_ass_cmd->chan_desc_before.tsc; 
+        /*  frequency parameters  */
+        if(!d_pdch_ass_cmd->chan_desc_before.hop)
+        {
+          if(d_pdch_ass_cmd->chan_desc_before.v_arfcn)
+          {
+            ptr2prim_i->p_frequency_par.p_chan_sel.hopping=0;
+            memset(ptr2prim_i->p_frequency_par.p_freq_list.p_rf_chan_no.p_radio_freq,0,MPHP_NUMC_MA);
+            ptr2prim_i->p_frequency_par.p_chan_sel.p_rf_ch.arfcn = 
+                  grr_g23_arfcn_to_l1(d_pdch_ass_cmd->chan_desc_before.arfcn);
+          }
+        }
+        /* SZML-CPAP/004 */
+        /* SZML-CPAP/005 */
+        /*  mac mode  */
+        ptr2prim2->mac_mode = ptr2prim_i->mac_mode;
+        /*  uplink allocation structure  */
+        /* take from grr_data to avoide mistakes */
+        ptr2prim2->p_ul_alloc.ul_tfi  = ptr2prim_i->p_ul_alloc.ul_tfi; 
+        ptr2prim2->p_ul_alloc.ts_mask = ptr2prim_i->p_ul_alloc.ts_mask; 
+        /*  dynamic allocation structure  */
+        ptr2prim2->p_ul_alloc.p_dynamic_alloc.usf_gran = 
+                        ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_gran;
+        for(i = 0;i < 8;i++)
+        {
+          ptr2prim2->p_ul_alloc.p_dynamic_alloc.usf_table[i] = 
+                    ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i];
+        }
+        ptr2prim2->p_tbf_start.tbf_start_present = 0;
+        sig_cpap_tc_assign_pdch(ptr2prim2, PDCH_UL_ASS_CMD);
+      } /* if(d_pdch_ass_cmd->v_chan_desc_before) */
+    }
+    else /* if(d_pdch_ass_cmd->v_start_time) */
+    {
+      ptr2prim_i->p_tbf_start.tbf_start_present  = 0;
+      ptr2prim_i->p_tbf_start.fn = 0xFFFFFFFF;
+    }
+  } 
+  else /* if( d_pdch_ass_cmd->msg_type EQ D_PDCH_ASS_CMD) */
+  {
+    TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" );
+  }
+
+
+  if(ptr2prim_i->p_tbf_start.tbf_start_present)
+    grr_data->uplink_tbf.tbf_start_fn = ptr2prim_i->p_tbf_start.fn;
+  else
+    grr_data->uplink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT;
+  
+  grr_data->uplink_tbf.st_tfi   = ptr2prim_i->p_ul_alloc.ul_tfi;
+  grr_data->uplink_tbf.mac_mode = DA;
+
+  return; 
+}  /* cpap_set_da_assignment_pdch */
+
+
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_set_dl_assignment_pdch
++------------------------------------------------------------------------------
+| Description : This function sets some parameter of T_MPHP_ASSIGNMENT_REQ is 
+|               case of ia downlink allocation
+|
+| Parameters  : ptr2prim_i -  ptr to MPHP_ASSIGNMENT_REQ
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cpap_set_dl_assignment_pdch (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i)
+{
+  MCAST(d_imm_assign,D_IMM_ASSIGN); /* T_D_IMM_ASSIGN */
+  T_pck_downl_ass_ia *ptr2dl_assign;
+
+  TRACE_FUNCTION( "cpap_set_dl_assignment_pdch" );
+  if( d_imm_assign->msg_type EQ D_IMM_ASSIGN)
+  {
+    ptr2dl_assign = 
+      &d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia;
+    /*
+     * timing advance
+     */
+    if (ptr2dl_assign->tfi_ass_rlc.ta_valid)
+    {
+      ptr2prim_i->p_timing_advance.ta_value = d_imm_assign->time_advance.ta;
+    }
+    else
+    {
+      ptr2prim_i->p_timing_advance.ta_value = 0xff;
+    }
+    if(ptr2dl_assign->v_ta_idx)
+    {
+      ptr2prim_i->p_timing_advance.ta_index = ptr2dl_assign->ta_idx;
+      ptr2prim_i->p_timing_advance.tn      = d_imm_assign->pck_chan_desc.tn;
+    }
+    else
+    {
+      ptr2prim_i->p_timing_advance.ta_index = 0xff;
+      ptr2prim_i->p_timing_advance.tn = 0xff;
+    }
+    /*
+     *  trainings sequence
+     */    
+    ptr2prim_i->tsc = d_imm_assign->pck_chan_desc.tsc; 
+    /*
+     * TBF starting time
+     */
+    if(ptr2dl_assign->v_tbf_start_time)
+    {
+      ptr2prim_i->p_tbf_start.tbf_start_present  = 1;
+      ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs((T_abs *)&ptr2dl_assign->tbf_start_time);
+    }
+    else
+    {
+      ptr2prim_i->p_tbf_start.tbf_start_present = 0;
+    }
+   /* 
+    * mac mode 
+    */
+    ptr2prim_i->mac_mode = DA;
+   /*
+    *  downlink allocation structure
+    */
+    ptr2prim_i->p_dl_alloc.dl_tfi  = grr_data->downlink_tbf.tfi; /* take from grr_data to avoide mistakes */
+    ptr2prim_i->p_dl_alloc.ts_mask = grr_data->downlink_tbf.ts_usage;
+
+
+    if(ptr2prim_i->p_tbf_start.tbf_start_present)
+      grr_data->downlink_tbf.tbf_start_fn = ptr2prim_i->p_tbf_start.fn;
+    else
+      grr_data->downlink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT;
+    
+    grr_data->downlink_tbf.st_tfi   = ptr2prim_i->p_dl_alloc.dl_tfi;
+    grr_data->downlink_tbf.mac_mode = DA;
+
+  } 
+  return; 
+}  /* cpap_set_dl_assignment_pdch()  */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_send_assign_req_ia
++------------------------------------------------------------------------------
+| Description : The function cpap_send_assign_req_ia() builds MPHP_ASSIGNMENT_REQ
+|               and send it.
+|
+| Parameters  : tbf_type_i - type of TBF that is to activate
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL cpap_send_assign_req_ia ( T_TBF_TYPE tbf_type_i )
+{ 
+  T_MPHP_ASSIGNMENT_REQ *ptr2prim = NULL;
+
+  TRACE_FUNCTION( "cpap_send_assign_req_ia" );
+
+  ptr2prim = tc_set_freq();
+  if(NULL EQ ptr2prim)
+  {
+    return FALSE;
+  }
+
+  grr_set_tbf_cfg_req_param( ptr2prim );
+
+  switch( tbf_type_i )
+  {
+    case CGRLC_TBF_MODE_UL:
+      ptr2prim->assign_cmd = UL_ASSIGNMENT;
+      if(grr_data->uplink_tbf.mac_mode EQ CGRLC_MAC_MODE_DA)
+        cpap_set_da_assignment_ia(ptr2prim);
+      else if(!cpap_set_fa_assignment_ia(ptr2prim))
+      {
+        PFREE(ptr2prim);
+        return FALSE;
+      }
+      sig_cpap_tc_assign_pdch( ptr2prim, IA_UL );
+      break;
+    case CGRLC_TBF_MODE_DL:
+      ptr2prim->assign_cmd = DL_ASSIGNMENT;
+      cpap_set_dl_assignment_ia(ptr2prim);
+      sig_cpap_tc_assign_pdch( ptr2prim, IA_DL );
+      break;
+    default:
+      return FALSE;
+  } /* switch (tbf_type_i) */
+  return TRUE;
+} /* cpap_send_assign_req_ia() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_set_da_assignment_ia
++------------------------------------------------------------------------------
+| Description : This function sets some parameter of MPHP_ASSIGFNMENT_REQ in 
+|               case of uplink dynamic allocation.
+|
+| Parameters  : ptr2prim_i -  ptr to mphp_assignment_req
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_set_da_assignment_ia (T_MPHP_ASSIGNMENT_REQ *ptr2prim)
+{
+  MCAST(d_imm_assign,D_IMM_ASSIGN); /* T_D_IMM_ASSIGN */
+  T_pck_upl_ass_ia *ptr2ul_assign;
+
+  TRACE_FUNCTION( "cpap_set_da_assignment_ia" );
+
+  if( d_imm_assign->msg_type EQ D_IMM_ASSIGN) 
+  {
+    /*
+     * timing advance
+     */
+    ptr2ul_assign =
+      &d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia;
+    if(ptr2ul_assign->v_tfi_ass_alloc AND ptr2ul_assign->tfi_ass_alloc.v_p0_prmode)
+    {
+      ptr2prim->p_dl_power.p0 = ptr2ul_assign->tfi_ass_alloc.p0_prmode.p0;
+      ptr2prim->p_dl_power.pr_mode =
+                                   ptr2ul_assign->tfi_ass_alloc.p0_prmode.pr_mode;
+    }
+    else
+    {
+      ptr2prim->p_dl_power.p0 = 0xff;
+    }
+  /* Timing Advance */
+    grr_data->ta_params.ta_valid = TRUE;
+    grr_handle_ta ( 1, /* always present in Immediate Assignment*/
+          d_imm_assign->time_advance.ta,
+          ptr2ul_assign->tfi_ass_alloc.v_ta_idx, 
+          ptr2ul_assign->tfi_ass_alloc.ta_idx,
+          d_imm_assign->pck_chan_desc.tn,
+          0xFF,
+          0,
+          0,
+          &ptr2prim->p_timing_advance);
+
+    /*  TBF starting time  */
+    if(ptr2ul_assign->tfi_ass_alloc.v_tbf_start_time)
+    {
+      ptr2prim->p_tbf_start.tbf_start_present   = 1;
+      ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_abs((T_abs *)&ptr2ul_assign->tfi_ass_alloc.tbf_start_time);      
+    }
+    else
+    {
+      ptr2prim->p_tbf_start.tbf_start_present  = 0;
+    } 
+   /*
+    * mac mode 
+    */
+    ptr2prim->mac_mode = DA;   
+   /*
+    * uplink allocation structure 
+    */
+    /* take from grr_data to avoide mistakes */
+    ptr2prim->p_ul_alloc.ul_tfi  = ptr2ul_assign->tfi_ass_alloc.tfi; 
+    ptr2prim->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage; 
+   /*
+    *  dynamic allocation structure
+    */    
+    ptr2prim->p_ul_alloc.p_dynamic_alloc.usf_gran = 
+                                        ptr2ul_assign->tfi_ass_alloc.usf_gran;
+    if(ptr2ul_assign->tfi_ass_alloc.v_usf)
+    {
+      ptr2prim->p_ul_alloc.p_dynamic_alloc.usf_table[
+           d_imm_assign->pck_chan_desc.tn] = ptr2ul_assign->tfi_ass_alloc.usf;
+    }
+    else
+    {
+      ptr2prim->p_ul_alloc.p_dynamic_alloc.usf_table[
+                                          d_imm_assign->pck_chan_desc.tn] = 5;
+      TRACE_EVENT("USF-Error: set (hardcoded) USF_TN0 = 0x05");
+    }
+  } 
+  else
+  {
+    TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" );
+  }
+
+
+  if(ptr2prim->p_tbf_start.tbf_start_present)
+    grr_data->uplink_tbf.tbf_start_fn = ptr2prim->p_tbf_start.fn;
+  else
+    grr_data->uplink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT;
+  
+  grr_data->uplink_tbf.st_tfi   = ptr2prim->p_ul_alloc.ul_tfi;
+  grr_data->uplink_tbf.mac_mode = DA;
+
+
+  return; 
+}  /* cpap_set_da_assignment_ia */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_set_fa_assignment_ia
++------------------------------------------------------------------------------
+| Description : This function sets some parameter of MPHP_ASSIGFNMENT_REQ in 
+|               case of uplink fixed allocation.
+|
+| Parameters  : ptr2prim_i -  ptr to mphp_assignment_req
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE cpap_set_fa_assignment_ia (T_MPHP_ASSIGNMENT_REQ *ptr2prim)
+{
+  MCAST(d_imm_assign,D_IMM_ASSIGN); /* T_D_IMM_ASSIGN */
+  T_pck_upl_ass_ia *ptr2ul_assign;
+
+  TRACE_FUNCTION( "cpap_set_fa_assignment_ia" );
+
+  ptr2ul_assign =
+      &d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia;
+  if( d_imm_assign->msg_type EQ D_IMM_ASSIGN) 
+  {
+    /* PO, BTS_POWER_MODE and PR_ MODE */
+    if(ptr2ul_assign->v_tfi_ass_alloc AND ptr2ul_assign->tfi_ass_alloc.v_p0_bts_prmode)
+    {      
+      ptr2prim->p_dl_power.p0      = ptr2ul_assign->tfi_ass_alloc.p0_bts_prmode.p0;
+      ptr2prim->p_dl_power.bts_pwr_ctl_mode  = ptr2ul_assign->tfi_ass_alloc.p0_bts_prmode.pwr_ctrl_mode;
+      ptr2prim->p_dl_power.pr_mode = ptr2ul_assign->tfi_ass_alloc.p0_bts_prmode.pr_mode;
+    }
+    else
+    {
+      ptr2prim->p_dl_power.p0 = 0xff;
+    }
+    /* 
+   * timing advance
+   */
+    grr_data->ta_params.ta_valid = TRUE;
+    grr_handle_ta ( 1, /* always present in Immediate Assignment*/
+          d_imm_assign->time_advance.ta,
+          ptr2ul_assign->tfi_ass_alloc.v_ta_idx, 
+          ptr2ul_assign->tfi_ass_alloc.ta_idx,
+          d_imm_assign->pck_chan_desc.tn,
+          0xFF,
+          0,
+          0,
+          &ptr2prim->p_timing_advance);
+    /*
+     * mac mode 
+     */
+    ptr2prim->mac_mode = FA;   
+   /*
+    * uplink allocation structure 
+    */
+    /* take from grr_data to avoide mistakes */
+    ptr2prim->p_ul_alloc.ul_tfi  = ptr2ul_assign->tfi_ass_alloc.tfi; 
+    ptr2prim->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage; 
+    /*  TBF starting time  */
+    if(ptr2ul_assign->tfi_ass_alloc.v_tbf_start_time)
+    {
+      ptr2prim->p_tbf_start.tbf_start_present  = 1;
+      ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_abs((T_abs *)&ptr2ul_assign->tfi_ass_alloc.tbf_start_time);
+    }
+    else
+    {
+      TRACE_ERROR("IA FIX ALLOC WITHOUT TBF STARTING TIME");
+      return FALSE;
+    }
+    /*  
+     * DOWNLINK_CONTROL_TIMESLOT parameter shall always indicate a timeslot number 
+     * which is used for TBF uplink.  GSM 04.60 Chapter 8.1.1.3.4 
+     */
+    switch(grr_data->uplink_tbf.ts_usage)
+    {
+    case 1:
+      ptr2prim->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = 7;
+      break;    
+    case 2:
+      ptr2prim->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = 6;
+      break;
+    case 4:
+      ptr2prim->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = 5;
+      break;
+    case 8:
+      ptr2prim->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = 4;
+      break;
+    case 16:
+      ptr2prim->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = 3;
+      break;
+    case 32:
+      ptr2prim->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = 2;
+      break;
+    case 64:
+      ptr2prim->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = 1;
+      break;
+    case 128:
+      ptr2prim->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = 0;
+      break;
+}
+    
+    /*
+     * ALLOCATION BITMAP tc function call not allowed
+     */
+     grr_data->tc.fa_ctrl.fa_type        = FA_NO_CURRENT;
+     tc_calc_fa_bitmap(ptr2prim->p_tbf_start.fn,                 /* starting time of cuurent tbf*/
+                        1,                                          /* block periods*/
+                        ptr2ul_assign->tfi_ass_alloc.allo_len5,     /* bitmap length */
+                        ptr2ul_assign->tfi_ass_alloc.allo_bmp5,     /* ptr to alloc struct*/
+                        &ptr2prim->p_ul_alloc.p_fixed_alloc); /* ptr to fix sttruct*/
+  } 
+  else
+  {
+    TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" );
+  }
+
+    
+  if(ptr2prim->p_tbf_start.tbf_start_present)
+    grr_data->uplink_tbf.tbf_start_fn = ptr2prim->p_tbf_start.fn;
+  else
+    grr_data->uplink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT;
+  
+  grr_data->uplink_tbf.st_tfi   = ptr2prim->p_ul_alloc.ul_tfi;
+  grr_data->uplink_tbf.mac_mode = FA;
+
+  return TRUE; 
+}  /* cpap_set_fa_assignment_ia */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_set_dl_assignment_ia
++------------------------------------------------------------------------------
+| Description : This function sets some parameter of T_MPHP_ASSIGNMENT_REQ is 
+|               case of ia downlink allocation
+|
+| Parameters  : ptr2prim_i -  ptr to MPHP_ASSIGNMENT_REQ
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_set_dl_assignment_ia (T_MPHP_ASSIGNMENT_REQ *ptr2prim)
+{
+  MCAST(d_imm_assign,D_IMM_ASSIGN); /* T_D_IMM_ASSIGN */
+  T_pck_downl_ass_ia *ptr2dl_assign;
+  TRACE_FUNCTION( "cpap_set_dl_assignment_ia" );
+  if( d_imm_assign->msg_type EQ D_IMM_ASSIGN)
+  {
+    ptr2dl_assign = &d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia;
+    if(ptr2dl_assign->v_p0_bts_prmode)
+    {
+      ptr2prim->p_dl_power.p0 = ptr2dl_assign->p0_bts_prmode.p0;
+      ptr2prim->p_dl_power.bts_pwr_ctl_mode =
+                                   ptr2dl_assign->p0_bts_prmode.pwr_ctrl_mode;
+      ptr2prim->p_dl_power.pr_mode = ptr2dl_assign->p0_bts_prmode.pr_mode;
+    }
+    else
+    {
+      ptr2prim->p_dl_power.p0 = 0xff;
+    }
+    /*
+     * timing advance
+     */
+    grr_handle_ta ( ptr2dl_assign->tfi_ass_rlc.ta_valid, 
+          d_imm_assign->time_advance.ta,
+          0xFF, 
+          0,
+          0,
+          ptr2dl_assign->v_ta_idx,
+          ptr2dl_assign->ta_idx,
+          d_imm_assign->pck_chan_desc.tn,
+          &ptr2prim->p_timing_advance);
+    /*
+     * TBF starting time
+     */
+    if(ptr2dl_assign->v_tbf_start_time)
+    {
+      ptr2prim->p_tbf_start.tbf_start_present  = 1;
+      ptr2prim->p_tbf_start.fn  = grr_decode_tbf_start_abs((T_abs *)&ptr2dl_assign->tbf_start_time);    
+    }
+    else
+    {
+      ptr2prim->p_tbf_start.tbf_start_present  = 0;
+    }
+
+   /* SZML-CPAP/008 */
+    ptr2prim->mac_mode = DA;
+   /*
+    *  downlink allocation structure
+    */
+    ptr2prim->p_dl_alloc.dl_tfi  = ptr2dl_assign->tfi_ass_rlc.tfi;
+    ptr2prim->p_dl_alloc.ts_mask = grr_data->downlink_tbf.ts_usage;
+
+ 
+    if(ptr2prim->p_tbf_start.tbf_start_present)
+      grr_data->downlink_tbf.tbf_start_fn = ptr2prim->p_tbf_start.fn;
+    else
+      grr_data->downlink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT;
+
+    grr_data->downlink_tbf.st_tfi      = ptr2prim->p_dl_alloc.dl_tfi;
+
+  } 
+  return; 
+}  /* cpap_set_dl_assignment_ia()  */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_send_resource_request_ia
++------------------------------------------------------------------------------
+| Description : The function cpap_send_resource_request_ia() sends the primitive 
+|               MPHP_SINGLE_BLOCK_REQ with Packet Resource Request
+|               for two phase access due to the reception of a Immediate
+|               Assignment message. 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE cpap_send_resource_request_ia ( void )
+{
+  { 
+    MCAST(d_imm_assign,D_IMM_ASSIGN);  /* T_D_IMM_ASSIGN */
+    
+    T_pck_upl_ass_ia *ptr2ul_assign;
+    UBYTE frame[23];
+    ULONG start_fn;
+
+
+    TRACE_FUNCTION( "cpap_send_resource_request_ia" );
+
+    ptr2ul_assign = &d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia;
+
+    start_fn = grr_decode_tbf_start_abs((T_abs *)&ptr2ul_assign->sngl_block_alloc.tbf_start_time);
+    if( !(grr_check_if_tbf_start_is_elapsed ( start_fn, grr_data->ul_fn)))
+    {
+      T_U_RESOURCE_REQ resource_req;
+      sig_cpap_tc_build_res_req( &resource_req );
+      grr_encode_ul_ctrl_block( frame, ( UBYTE* )&resource_req );
+    }
+    else
+    {
+      TRACE_ERROR("TBF Starting time is elpased in single block allocation!");
+      return FALSE;
+    }
+    {
+      PALLOC(ptr2prim,MPHP_SINGLE_BLOCK_REQ);
+      memcpy( ptr2prim->l2_frame, frame, 23 );
+      ptr2prim->p_tbf_start.tbf_start_present = 1; 
+      ptr2prim->p_tbf_start.fn                = start_fn;
+
+      if( ptr2ul_assign->v_sngl_block_alloc AND ptr2ul_assign->sngl_block_alloc.v_p0_bts_prmode )
+      {
+        ptr2prim->p_dl_power.p0               = ptr2ul_assign->sngl_block_alloc.p0_bts_prmode.p0;
+        ptr2prim->p_dl_power.bts_pwr_ctl_mode = ptr2ul_assign->sngl_block_alloc.p0_bts_prmode.pwr_ctrl_mode;
+        ptr2prim->p_dl_power.pr_mode          = ptr2ul_assign->sngl_block_alloc.p0_bts_prmode.pr_mode;
+      }
+      else
+      {
+        ptr2prim->p_dl_power.p0      = 0xff;
+      }
+   
+      /*
+       *   mark that single block is because of two phase access procedure 
+       */
+      ptr2prim->purpose      = TWO_PHASE_ACESS;
+      ptr2prim->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan;
+      ptr2prim->burst_type   = (psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT)
+                               ?AB_8_BIT
+                               :AB_11_BIT;
+     
+      grr_handle_ta ( 1, /*Ta is mandatory in immediate assignment*/
+                      d_imm_assign->time_advance.ta,
+                      0, 
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      &ptr2prim->p_timing_advance);
+
+      /*
+       *  trainings sequence
+       */    
+      ptr2prim->tsc = d_imm_assign->pck_chan_desc.tsc; 
+      ptr2prim->tn  = d_imm_assign->pck_chan_desc.tn;
+
+      /*
+       *  frequency parameters
+       */
+      grr_set_freq_par( &ptr2prim->p_frequency_par );
+      sig_cpap_tc_assign_sb( ( void* )ptr2prim, TWO_PHASE_ACESS );
+    }
+    return TRUE;
+  }
+} /* cpap_send_resource_request_ia() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_send_single_block_without_tbf
++------------------------------------------------------------------------------
+| Description : The function cpap_send_single_block_without_tbf() sends 
+|               the primitive MPHP_SINGLE_BLOCK_REQ with single
+|               block request without TBF establishment due to the reception
+|               of an immediate assignment message. 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE cpap_send_single_block_without_tbf ( void )
+{
+  PALLOC( prim, MPHP_SINGLE_BLOCK_REQ );
+  {
+    MCAST( d_imm_assign, D_IMM_ASSIGN );
+
+    T_pck_upl_ass_ia                   *assign;
+    UBYTE                               result = FALSE;
+
+    TRACE_FUNCTION( "cpap_send_single_block_without_tbf" );
+
+    assign = &d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia;
+
+    if( assign->v_sngl_block_alloc AND assign->sngl_block_alloc.v_p0_bts_prmode )
+    {
+      prim->p_dl_power.p0               = assign->sngl_block_alloc.p0_bts_prmode.p0;
+      prim->p_dl_power.bts_pwr_ctl_mode = assign->sngl_block_alloc.p0_bts_prmode.pwr_ctrl_mode;
+      prim->p_dl_power.pr_mode          = assign->sngl_block_alloc.p0_bts_prmode.pr_mode;
+    }
+    else
+    {
+      prim->p_dl_power.p0      = 0xff;
+    }
+
+    /*
+     *   mark that single block is because of two phase access procedure 
+     */
+    prim->purpose      = SINGLE_BLOCK_TRANSFER_UL;
+    prim->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan;
+    prim->burst_type   = ( psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT )
+                         ? AB_8_BIT : AB_11_BIT;
+
+    prim->p_timing_advance.ta_value = d_imm_assign->time_advance.ta;
+
+    grr_data->ta_params.ta_value = d_imm_assign->time_advance.ta;
+    grr_data->ta_params.ta_valid = TRUE;
+
+    if( assign->tfi_ass_alloc.v_ta_idx )
+    {
+      prim->p_timing_advance.ta_index = assign->tfi_ass_alloc.ta_idx;
+      prim->p_timing_advance.tn       = d_imm_assign->pck_chan_desc.tn;
+    }
+    else
+    {
+      prim->p_timing_advance.ta_index = 0xff;
+      prim->p_timing_advance.tn       = 0xff;
+    }
+
+    /*
+     *  trainings sequence
+     */    
+    prim->tsc = d_imm_assign->pck_chan_desc.tsc; 
+
+    /*
+    TRACE_EVENT_P4( "request_ia1 tn:%d tsc: %d p0:%d pr_mode:%d", 
+                    d_imm_assign->pck_chan_desc.tn, prim->tsc, 
+                    prim->p_dl_power.p0, prim->p_dl_power.pr_mode );
+    */
+
+
+    /* SZML-CPAP/009 */
+    /*
+     * handle TBF starting time is always present in single block allocation,
+     * otherwise something is wrong
+     */  
+
+    if( assign->v_sngl_block_alloc)
+    {
+      prim->p_tbf_start.tbf_start_present  = 1; 
+      prim->p_tbf_start.fn = grr_decode_tbf_start_abs((T_abs*) &assign->sngl_block_alloc.tbf_start_time);     
+      if(grr_check_if_tbf_start_is_elapsed ( prim->p_tbf_start.fn, grr_data->ul_fn))
+      {
+        TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!");
+        TRACE_EVENT_P2("CPAP SBR TBF ST ELAPSED st=%ld  c_fn=%ld  ", prim->p_tbf_start.fn,grr_data->dl_fn);
+      }
+      else
+      {
+        result = TRUE;    
+      }
+    }
+ 
+    if( result )
+    {
+      tc_cpy_ctrl_blk_to_buffer( prim->l2_frame );
+
+      prim->tsc = grr_data->tc.freq_set.tsc;
+      prim->tn  = d_imm_assign->pck_chan_desc.tn;
+
+      /*
+       *  frequency parameters
+       */
+      grr_set_freq_par( &prim->p_frequency_par );
+      sig_cpap_tc_assign_sb( (void*)prim, SINGLE_BLOCK_TRANSFER_UL );
+
+    /*
+    TRACE_EVENT_P8("request_ia2 tn:%d tsc: %d ta:%d arfcn:%ld : nr: %d p0:%d pr:%d ctrl:%d", 
+      prim_i->tn,
+      prim_i->tsc, 
+      prim_i->p_timing_advance, 
+      prim_i->p_chan_sel.p_rf_ch.arfcn,
+      prim_i->ptr2prim->p_frequency_par.p_freq_list.p_rf_chan_cnt,
+      prim_i->p_dl_power.p0,
+      prim_i->p_dl_power.pr_mode,
+      prim_i->p_dl_power.bts_pwr_ctl_mode);    
+    */
+    }
+    else
+    {
+      PFREE(prim);
+    }
+
+    return result;
+  }
+} /* cpap_send_single_block_without_tbf() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_send_receive_normal_burst
++------------------------------------------------------------------------------
+| Description : The function cpap_send_receive_normal_burst() sends the 
+|               primitive MPHP_SINGLE_BLOCK_REQ to receive a single packet 
+|               control block on the specified radio resource.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE cpap_send_receive_normal_burst ( void )
+{ 
+  MCAST( d_imm_assign, D_IMM_ASSIGN );
+
+  T_pck_downl_ass_ia *ptr2dl_assign =
+    &d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia;
+  UBYTE               result        = FALSE;
+
+  PALLOC( mphp_single_block_req, MPHP_SINGLE_BLOCK_REQ );
+
+  TRACE_FUNCTION( "cpap_send_receive_normal_burst" );
+
+  memset( mphp_single_block_req, 0, sizeof( T_MPHP_SINGLE_BLOCK_REQ ) );
+
+  mphp_single_block_req->assign_id = 0;
+  grr_data->tc.last_rec_nb_id      = mphp_single_block_req->assign_id;
+  mphp_single_block_req->purpose   = SINGLE_BLOCK_TRANSFER_DL;
+  mphp_single_block_req->tsc       = grr_data->tc.freq_set.tsc;
+  mphp_single_block_req->tn        = d_imm_assign->pck_chan_desc.tn;
+
+  grr_set_freq_par( &mphp_single_block_req->p_frequency_par );
+
+  if( ptr2dl_assign->v_p0_bts_prmode )
+  {
+    mphp_single_block_req->p_dl_power.p0 = ptr2dl_assign->p0_bts_prmode.p0;
+    mphp_single_block_req->p_dl_power.bts_pwr_ctl_mode = 
+                                    ptr2dl_assign->p0_bts_prmode.pwr_ctrl_mode;
+    mphp_single_block_req->p_dl_power.pr_mode = ptr2dl_assign->p0_bts_prmode.pr_mode;
+  }
+  else
+  {
+    mphp_single_block_req->p_dl_power.p0               = 0xff;
+    mphp_single_block_req->p_dl_power.bts_pwr_ctl_mode = 0xff;
+    mphp_single_block_req->p_dl_power.pr_mode          = 0xff;
+  }
+
+  mphp_single_block_req->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan;
+  mphp_single_block_req->burst_type   = (psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT)
+                                        ?AB_8_BIT
+                                        :AB_11_BIT;
+
+  /* a downlink single block don't need timing advance!! */
+  mphp_single_block_req->p_timing_advance.ta_value = 0xff;
+  mphp_single_block_req->p_timing_advance.ta_index = 0xff;
+  mphp_single_block_req->p_timing_advance.tn       = 0xff;
+  /*
+   * handle TBF starting time
+   * is always present in single block allocation (otherwise something is wrong)
+   */
+  if(ptr2dl_assign->v_tbf_start_time)
+  {
+    mphp_single_block_req->p_tbf_start.tbf_start_present = 1; 
+    mphp_single_block_req->p_tbf_start.fn = grr_decode_tbf_start_abs((T_abs *)&ptr2dl_assign->tbf_start_time);
+    if(grr_check_if_tbf_start_is_elapsed ( mphp_single_block_req->p_tbf_start.fn, grr_data->ul_fn))
+    {
+      TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!");
+      TRACE_EVENT_P2("CPAP SBR TBF ST ELAPSED st=%ld  c_fn=%ld  ", mphp_single_block_req->p_tbf_start.fn,grr_data->dl_fn);
+    }
+    else
+    {
+      result = TRUE;  
+      grr_data->tc.last_rec_nb_fn = mphp_single_block_req->p_tbf_start.fn;
+    }
+  }
+  else
+  {
+    TRACE_ERROR("TBF Starting time is missing in single block allocation!");
+    /* SZML-CPAP/013 */
+  }
+
+  if(result)
+  {
+    sig_cpap_tc_assign_sb((void*)mphp_single_block_req,SINGLE_BLOCK_TRANSFER_DL);
+  }
+  else
+  {
+    PFREE(mphp_single_block_req);
+    TRACE_ERROR("SINGLE BLOCK STARTING TIME HAS ALREADY BEEN ELAPSED");
+  }
+
+  return result;
+} /* cpap_send_receive_normal_burst() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_store_ia_message
++------------------------------------------------------------------------------
+| Description : The function cpap_store_ia_message() stores the 1st message of
+|               a two message assignment.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_store_ia_message ( void )
+{ 
+  MCAST(d_imm_assign,D_IMM_ASSIGN);  /* T_D_IMM_ASSIGN */
+
+  TRACE_FUNCTION( "cpap_store_ia_message" );
+
+  memcpy(&grr_data->cpap.tma_ia, d_imm_assign, sizeof(T_D_IMM_ASSIGN));
+  grr_data->cpap.v_tma_ia = TRUE;
+
+} /* cpap_store_ia_message() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_join_tma_messages
++------------------------------------------------------------------------------
+| Description : The function cpap_join_tma_messages() join the stored 1st and
+|               the 2nd message of a two message assignment.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_join_tma_messages ( void )
+{ 
+  MCAST(d_imm_assign,D_IMM_ASSIGN);  /* T_D_IMM_ASSIGN */
+
+  TRACE_FUNCTION( "cpap_join_tma_messages" );
+
+  /* the 2nd message contains only the packet channel description and the 
+   * mobile allocation if needed.
+   */
+
+  d_imm_assign->tma = TMA_0;
+  d_imm_assign->page_mode.pm = grr_data->cpap.tma_ia.page_mode.pm;
+  d_imm_assign->time_advance.ta = grr_data->cpap.tma_ia.time_advance.ta;
+  if(grr_data->cpap.tma_ia.v_start_time)
+  {
+    d_imm_assign->v_start_time = TRUE;
+    d_imm_assign->start_time.t1 = grr_data->cpap.tma_ia.start_time.t1;
+    d_imm_assign->start_time.t2 = grr_data->cpap.tma_ia.start_time.t2;
+    d_imm_assign->start_time.t3 = grr_data->cpap.tma_ia.start_time.t3;
+  }
+  memcpy( &d_imm_assign->ia_rest_oct,
+          &grr_data->cpap.tma_ia.ia_rest_oct, 
+          sizeof(T_ia_rest_oct)                );
+  grr_data->cpap.v_tma_ia = FALSE;
+
+} /* cpap_join_tma_messages() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_malloc_ia
++------------------------------------------------------------------------------
+| Description : The function cpap_malloc_ia() .... 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_malloc_ia ( void )
+{ 
+  TRACE_FUNCTION( "cpap_malloc_ia" );
+
+  if( grr_data->cpap.p_d_imm_assign EQ NULL )
+  {
+    MALLOC( grr_data->cpap.p_d_imm_assign, sizeof( T_D_IMM_ASSIGN ) );
+  }
+  else
+  {
+    TRACE_ERROR( "cpap_malloc_ia: fatal error, memory reallocation not implemented" );
+  }
+
+  *grr_data->cpap.p_d_imm_assign = *( ( T_D_IMM_ASSIGN * )_decodedMsg );
+
+} /* cpap_malloc_ia() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_mfree_ia
++------------------------------------------------------------------------------
+| Description : The function cpap_mfree_ia() .... 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cpap_mfree_ia ( BOOL restore_data )
+{ 
+  TRACE_FUNCTION( "cpap_mfree_ia" );
+
+  if( grr_data->cpap.p_d_imm_assign NEQ NULL )
+  {
+    if( restore_data )
+    {
+      *( ( T_D_IMM_ASSIGN * )_decodedMsg ) = *grr_data->cpap.p_d_imm_assign;
+    }
+
+    MFREE( grr_data->cpap.p_d_imm_assign );
+    grr_data->cpap.p_d_imm_assign = NULL;
+  }
+  else
+  {
+    TRACE_ERROR( "cpap_mfree_ia: fatal error, no memory allocated" );
+  }
+} /* cpap_mfree_ia() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : cpap_check_and_save_freq
++------------------------------------------------------------------------------
+| Description : This function check if the freq_par is valid or not..
+|               If it is hopping case, save the hoppinging freq. 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL cpap_check_and_save_freq (void)
+{
+  MCAST(d_imm_assign,D_IMM_ASSIGN); /* T_D_IMM_ASSIGN */
+  T_pck_chan_desc *chan_desc = &d_imm_assign->pck_chan_desc;
+  T_mob_alloc *mob_alloc = &d_imm_assign->mob_alloc;
+  BOOL result = FALSE;
+  T_freq_par   freq_par;
+  TRACE_FUNCTION( "cpap_check_and_save_freq" );
+
+  if(chan_desc->hop OR (!chan_desc->hop AND chan_desc->indir))
+  { /* hopping*/
+
+    if (chan_desc->indir)
+    { 
+      /* indirect encoding */
+      /* set up tc's freq_par struct */
+      memset(&freq_par,0,sizeof(T_freq_par));
+      freq_par.v_indi_encod      = TRUE;
+      freq_par.indi_encod.maio   = chan_desc->maio;
+      freq_par.tsc               = chan_desc->tsc;
+      freq_par.indi_encod.ma_num = 
+                          chan_desc->ma_num + MA_NUMBER_4_PSI13_OR_CELL_ALLOC;
+      if( chan_desc->v_ch_mark1)
+      {
+        freq_par.indi_encod.v_chamge_ma_sub   = TRUE;
+        freq_par.indi_encod.chamge_ma_sub.cm1 = chan_desc->ch_mark1;
+      }
+
+      result = tc_set_hopping_par( &freq_par );
+    }
+    else if( chan_desc->v_maio AND chan_desc->v_hsn )
+    { /* direct encoding  */ 
+
+      UBYTE i;
+      memset(&freq_par,0,sizeof(T_freq_par));
+      freq_par.v_di_encod1       = TRUE;
+      freq_par.di_encod1.maio    = chan_desc->maio;
+      freq_par.tsc               = chan_desc->tsc;
+      freq_par.di_encod1.gprs_ms_alloc_ie.hsn = chan_desc->hsn;
+
+      if(0 NEQ mob_alloc->c_mac)
+      {
+        freq_par.di_encod1.gprs_ms_alloc_ie.v_ma_struct = TRUE;
+        freq_par.di_encod1.gprs_ms_alloc_ie.ma_struct.c_ma_map 
+                                                         = mob_alloc->c_mac*8;
+        freq_par.di_encod1.gprs_ms_alloc_ie.ma_struct.ma_len =
+                                                       (mob_alloc->c_mac*8)-1;
+        for(i = 0;i < (mob_alloc->c_mac*8);i++)
+        { /* convert bitbuffer type of rr to type of grr */
+          freq_par.di_encod1.gprs_ms_alloc_ie.ma_struct.ma_map[i]
+                                      = (mob_alloc->mac[i/8]>>(7-(i%8)))&0x01;
+        }
+      }
+
+      result = tc_set_hopping_par( &freq_par );
+    }
+    else
+    { /* corrupted message decoding  */
+        grr_data->tc.v_freq_set = FALSE;
+        result = FALSE;
+    }
+
+  }
+  else if(chan_desc->v_arfcn)
+  {
+    /* absolut radio frequency channel number */
+    grr_data->tc.v_freq_set = TRUE;
+    result                  = TRUE;
+    grr_data->tc.freq_set.freq_par.p_chan_sel.hopping      = FALSE;
+    grr_data->tc.freq_set.tsc        = chan_desc->tsc;
+    grr_data->tc.freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn  = grr_g23_arfcn_to_l1(chan_desc->arfcn);    
+    /* set up tc's freq_par struct */
+    memset(&grr_data->tc.freq_set.freq_par.p_freq_list.p_rf_chan_no.p_radio_freq,0,sizeof(grr_data->tc.freq_set.freq_par.p_freq_list.p_rf_chan_no.p_radio_freq));
+    grr_data->tc.freq_set.freq_par.p_freq_list.p_rf_chan_cnt = 0;
+  }
+  else
+  {
+    grr_data->tc.v_freq_set = FALSE;
+    result = FALSE;
+  }
+
+  grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE;
+  grr_data->pwr_ctrl_valid_flags.v_freq_param          = TRUE;
+
+  return result;
+}  /* cpap_check_and_save_freq */
+
+
+
+