FreeCalypso > hg > fc-tourmaline

view src/g23m-gprs/grr/grr_cpapf.c @ 268:f2e52cab0a73

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
abb_inth.c: check all interrupt causes, not just one The original code used if - else if - else if etc constructs, thus the first detected interrupt was the only one handled. However, Iota ITSTATREG is a clear-on-read register, thus if we only handle the first detected interrupt and skip checking the others, then the other interrupts will be lost, if more than one interrupt happened to occur in one ABB interrupt handling cycle - a form of rare race condition. Change the code to check all interrupts that were read in this cycle.
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 13 Jun 2021 18:17:53 +0000
parents fa8dc04885d8
children
line wrap: on
line source

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