/* 
+----------------------------------------------------------------------------- 
|  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 */