/* 
+----------------------------------------------------------------------------- 
|  Project :  GPRS (8441)
|  Modul   :  GRLC
+----------------------------------------------------------------------------- 
|  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 RD of
|             entity GRLC.
+----------------------------------------------------------------------------- 
*/ 

#ifndef GRLC_RDF_C
#define GRLC_RDF_C
#endif

#define ENTITY_GRLC

/*==== INCLUDES =============================================================*/

#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_grlc.h"    /* to get cnf-definitions */
#include "mon_grlc.h"    /* to get mon-definitions */
#include "prim.h"       /* to get the definitions of used SAP and directions */
#include "message.h"
#include "grlc.h"        /* to get the global entity definitions */
#include "grlc_tms.h" 
#include <string.h>      /* memcpy */
#include "grlc_f.h" 
#include "grlc_rdf.h" 
#include "grlc_meass.h"

/*==== CONST ================================================================*/

/*==== LOCAL VARS ===========================================================*/

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

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


/*
+------------------------------------------------------------------------------
| Function    : rd_init
+------------------------------------------------------------------------------
| Description : The function rd_init() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_init ( void )
{ 
  TRACE_FUNCTION( "rd_init" );

  /*
   * UBYTE
   */
  grlc_data->rd.vq              = 0xFF;
  grlc_data->rd.vr              = 0xFF;
  grlc_data->rd.li_cnt          = 0xFF;
  grlc_data->rd.rlc_data_len    = 0xFF;
  grlc_data->rd.f_ack_ind       = 0xFF;
  grlc_data->rd.ssn             = 0xFF;      
        
  /*
   * USHORT
   */
  grlc_data->rd.pdu_len         = 0xFFFF;
  /*
   * BOOL
   */
  grlc_data->rd.pdu_complete        = TRUE;
  grlc_data->rd.channel_req         = FALSE;
  grlc_data->rd.ch_req_in_ack_prog  = FALSE;  
  grlc_data->rd.inSequence          = TRUE;
  /*
   * struct
   */
  grlc_data->rd.ptr_grlc               = NULL;
  grlc_data->rd.next_poll_block        = NEXT_POLL_BLOCK_NONE;
  
  INIT_STATE(RD,RD_NULL);

} /* rd_init() */





/*
+------------------------------------------------------------------------------
| Function    : rd_tbf_init
+------------------------------------------------------------------------------
| Description : The function rd_tbf_init() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_tbf_init ( void )
{ 
  TRACE_FUNCTION( "rd_tbf_init" );

  /* 
   * UBYTE
   */
  grlc_data->rd.vq              = 0;
  grlc_data->rd.vr              = 0;
  grlc_data->rd.li_cnt          = 0;
  grlc_data->rd.ssn             = 0;      
  grlc_data->rd.last_bsn        = 0xFF;
  grlc_data->rd.bsn_pdu_start   = 0xFF; /*set to zero at receiving the first data block*/
  grlc_data->rd.cnt_sent_f_ack  = 0;
  grlc_data->rd.f_ack_ind       = 0;
  grlc_data->dl_tn_mask         = grlc_data->downlink_tbf.ts_mask;

  /*
   * USHORT
   */
  grlc_data->rd.pdu_len         = 0;

  /*
   * BOOL
   */
  grlc_data->rd.release_tbf        = FALSE;
  grlc_data->rd.pdu_complete       = TRUE;
  grlc_data->rd.ch_req_in_ack_prog = FALSE;  
  grlc_data->rd.v_next_tbf_params  = FALSE;
  grlc_data->rd.ignore_pdu         = FALSE;


  grlc_data->rd.fn_p_tbf_rel       = 0xFFFFFFFF;
  /*
   * struct
   */
  grlc_data->rd.rlc_mode               = grlc_data->downlink_tbf.rlc_mode;
  grlc_data->rd.cs_type                = CS_ZERO;
  /*
   * arrays
   */
  
  memset(grlc_data->rd.data_array, 0         , WIN_SIZE      * sizeof(grlc_data->rd.data_array[0]) );
  memset(grlc_data->rd.vn        , VN_INVALID, WIN_SIZE      * sizeof(grlc_data->rd.vn[0])         );
  memset(grlc_data->rd.li        , 0         , RD_LI_CNT_MAX * sizeof(grlc_data->rd.li[0])         );
  memset(grlc_data->rd.m         , 0         , RD_LI_CNT_MAX );

} /* rd_tbf_init() */



/*
+------------------------------------------------------------------------------
| Function    : rd_read_li_m_of_block
+------------------------------------------------------------------------------
| Description : The function rd_read_li_m_of_block() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL rd_read_li_m_of_block ( UBYTE * ptr_data_i, UBYTE e_bit_i )
{
  USHORT  len_sum;
  BOOL    result;

  TRACE_FUNCTION( "rd_read_li_m_of_block" );
  
  len_sum = 0;
  grlc_data->rd.li_cnt = 0;

  while(!(e_bit_i))
  {
    grlc_data->rd.li[grlc_data->rd.li_cnt] = 
               (ptr_data_i[grlc_data->rd.li_cnt] & 0xFC) >> 2;
    grlc_data->rd.m [grlc_data->rd.li_cnt] = 
               (ptr_data_i[grlc_data->rd.li_cnt] & 0x02) >> 1;
    e_bit_i  = (ptr_data_i[grlc_data->rd.li_cnt] & 0x01);
    len_sum += grlc_data->rd.li[grlc_data->rd.li_cnt];
    if((e_bit_i EQ 0) 
	      AND (!grlc_data->rd.m [grlc_data->rd.li_cnt]))
    {
	    /*SZML-RD/001*/
	    return FALSE;
    }
    else if(!(grlc_data->rd.li[grlc_data->rd.li_cnt])
	    AND (grlc_data->rd.m [grlc_data->rd.li_cnt]))
    {
	    TRACE_ERROR("dl block with li=0 and m=1: NOT ALLOWED");
	    return FALSE;
    }
    grlc_data->rd.li_cnt++;
  }

  if(grlc_data->rd.li_cnt > RD_LI_CNT_MAX)
  {
    TRACE_EVENT_P2("li_cnt=%d RD_LI_CNT_MAX=%d",grlc_data->rd.li_cnt,RD_LI_CNT_MAX);
    TRACE_ERROR("rd li_cnt bigger than RD_LI_CNT_MAX (=8)");
    TRACE_ASSERT( grlc_data->rd.li_cnt > RD_LI_CNT_MAX );
    return FALSE;
  }

  /* 
   * check if sum of LIs is longer than a rlc data block len 
   */
  len_sum += grlc_data->rd.li_cnt;
  if( (len_sum > grlc_data->rd.rlc_data_len) 
     OR 
      ((len_sum EQ grlc_data->rd.rlc_data_len) AND (grlc_data->rd.m [grlc_data->rd.li_cnt-1])) )
    result = FALSE;
  else
    result = TRUE;

  return result;

} /* rd_read_li_m_of_block() */



/*
+------------------------------------------------------------------------------
| Function    : rd_out_grlc_data_ind
+------------------------------------------------------------------------------
| Description : The function rd_out_grlc_data_ind() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_out_grlc_data_ind( void )
{ 
  T_GRLC_DATA_IND  *prim_ptr;
  TRACE_FUNCTION( "rd_out_grlc_data_ind" );

  if(grlc_data->rd.ignore_pdu OR
     grlc_test_mode_active())
  {
    /*
     * this pdu is not passed to LLC because MAX_LLC_PDU_SIZE was exceed or testmode is active
     */
    grlc_data->rd.ignore_pdu = FALSE;

    TRACE_EVENT_P4("TARGET PDU END reached at will be ignored: len=%ld, bsn=pdu_start=%d vr = %d testmode=%d "
                                                                                ,grlc_data->rd.pdu_len
                                                                                ,grlc_data->rd.bsn_pdu_start
                                                                                ,grlc_data->rd.vr
                                                                                ,grlc_test_mode_active());

    rd_free_desc_list_partions();
    return;
  }

  if(grlc_data->rd.rlc_mode EQ CGRLC_RLC_MODE_ACK)
  {
    PALLOC_DESC (grlc_data_ind, GRLC_DATA_IND);//lint !e413
    prim_ptr  = grlc_data_ind;
  }
  else
  {
    PALLOC_DESC (grlc_unitdata_ind, GRLC_UNITDATA_IND);//lint !e413
    prim_ptr  = (T_GRLC_DATA_IND*)grlc_unitdata_ind;
  }

  memcpy(  prim_ptr,
           &grlc_data->rd.grlc_data_ind,
           sizeof(T_GRLC_DATA_IND) );
  PSEND(hCommLLC, prim_ptr);

  grlc_data->rd.grlc_data_ind.desc_list.first           = NULL;
  grlc_data->rd.pdu_complete                            = TRUE;
  grlc_data->tbf_ctrl[grlc_data->dl_index].rlc_oct_cnt += grlc_data->rd.pdu_len;
  grlc_data->tbf_ctrl[grlc_data->dl_index].pdu_cnt++;

} /* rd_out_grlc_data_ind() */
  
#ifdef _SIMULATION_

/*
+------------------------------------------------------------------------------
| Function    : rd_out_grlc_data_ind_test
+------------------------------------------------------------------------------
| Description : The function rd_out_grlc_data_ind_test() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_out_grlc_data_ind_test( void )
{ 
  T_NEXT_ARRAY          *ptr_next_array = NULL;
  T_NEXT_ARRAY          *ptr_help = NULL;
  UBYTE                 *ptr_pos  = NULL,cnt=0;
  USHORT                sdu_len_in_bits;
  T_GRLC_DATA_IND_TEST   *prim_ptr = NULL;

  TRACE_FUNCTION( "rd_out_grlc_data_ind_test" );

   
   if(grlc_data->rd.ignore_pdu OR 
     grlc_test_mode_active())
  {
    /*
     * this pdu is not passed to LLC because MAX_LLC_PDU_SIZE was exceed or testmode is active
     */
    grlc_data->rd.ignore_pdu = FALSE;

    TRACE_EVENT_P4("SIMULATION PDU END reached at will be ignored: len=%ld, bsn=pdu_start=%d vr = %d testmode=%d"
                                                                                ,grlc_data->rd.pdu_len
                                                                                ,grlc_data->rd.bsn_pdu_start
                                                                                ,grlc_data->rd.vr
                                                                                ,grlc_test_mode_active());
    rd_free_desc_list_partions();
    return;
  }
  sdu_len_in_bits = grlc_data->rd.pdu_len * 8;

  if(grlc_data->rd.rlc_mode EQ CGRLC_RLC_MODE_ACK)
  {
    PALLOC_SDU (grlc_data_ind_test, GRLC_DATA_IND_TEST, sdu_len_in_bits);
    prim_ptr  = grlc_data_ind_test;
  }
  else
  {
    PALLOC_SDU (grlc_unitdata_ind_test, GRLC_UNITDATA_IND_TEST, sdu_len_in_bits);
    prim_ptr  = (T_GRLC_DATA_IND_TEST*)grlc_unitdata_ind_test;
  }
  {
    /* 
     * copy from description list to test primitive
     */  
    prim_ptr->tlli      = grlc_data->downlink_tbf.tlli;
    prim_ptr->sdu.l_buf = grlc_data->rd.pdu_len * 8;
    prim_ptr->sdu.o_buf = 0;
    ptr_next_array      = 
      (T_NEXT_ARRAY*)grlc_data->rd.grlc_data_ind.desc_list.first;
    ptr_pos = prim_ptr->sdu.buf;
    cnt=0;
    do
    {
      cnt++;
      memcpy(ptr_pos,
            ptr_next_array->data,
            ptr_next_array->len );
      ptr_pos = &ptr_pos[ptr_next_array->len];
      ptr_next_array = (T_NEXT_ARRAY*)ptr_next_array->next;
    }
    while(ptr_next_array NEQ NULL);
    PSEND(hCommLLC, prim_ptr);
    TRACE_EVENT_P1("SEND PARTIONS =%d",cnt);

  }

  grlc_data->tbf_ctrl[grlc_data->dl_index].rlc_oct_cnt += grlc_data->rd.pdu_len;
  grlc_data->tbf_ctrl[grlc_data->dl_index].pdu_cnt++;


  /* delete blocks which are sent to LLC: only possible in test environment
   * usally, deleting of the description list is task of LLC
   */
   rd_free_desc_list_partions();

} /* rd_out_grlc_data_ind_test() */  

#endif /* _SIMULATION_ */




/*
+------------------------------------------------------------------------------
| Function    : rd_send_grlc_data_ind
+------------------------------------------------------------------------------
| Description : The function rd_send_grlc_data_ind() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_send_grlc_data_ind ( UBYTE bsn_i )
{ 
  T_NEXT_ARRAY  *ptr_block;
  UBYTE         pdu_cnt;
  UBYTE         compl_pdu;
  TRACE_FUNCTION( "rd_send_grlc_data_ind" );
  
  
  pdu_cnt   = grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_cnt;

  if(grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_complete)
    compl_pdu   = grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_cnt;
  else if (pdu_cnt)
    compl_pdu   = grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_cnt -1;
  else
    compl_pdu   = 0;

  if ((ptr_block = grlc_data->rd.data_array[bsn_i & WIN_MOD].first) EQ NULL)
  {
    TRACE_EVENT_P4("NO DATA IND first empty bsn=%d bsn_mod=%d vr=%d vq=%d", bsn_i, bsn_i&WIN_MOD,grlc_data->rd.vr,grlc_data->rd.vq);
    return;
  }
  
  do
  {
    if(grlc_data->rd.pdu_complete)
    {
      grlc_data->rd.ptr_grlc                       = ptr_block;
      grlc_data->rd.grlc_data_ind.desc_list.first  = (ULONG) grlc_data->rd.ptr_grlc;
      grlc_data->rd.pdu_len                        = ptr_block->len;
      grlc_data->rd.bsn_pdu_start                  = bsn_i;
    }
    else
    {
      grlc_data->rd.pdu_len        += ptr_block->len;
      grlc_data->rd.ptr_grlc->next  = (ULONG*) ptr_block;
      grlc_data->rd.ptr_grlc        = (T_NEXT_ARRAY*) grlc_data->rd.ptr_grlc->next;
    }
    grlc_data->rd.pdu_complete    = FALSE;
 
    if(grlc_data->rd.pdu_len > MAX_LLC_PDU_SIZE)
    {
      TRACE_EVENT_P5("PDU SIZE TO BIG = %ld  pdu_st=%d vr=%d compl_pdu=%d pdu_cnt=%d"
                                                              ,grlc_data->rd.pdu_len
                                                              ,grlc_data->rd.bsn_pdu_start
                                                              ,grlc_data->rd.vr
                                                              ,compl_pdu
                                                              ,pdu_cnt);
      if(!compl_pdu)
      {
        /* no pdu in data block */
        grlc_data->rd.ignore_pdu    = TRUE;
        
        /* free only linked partions */
        rd_free_desc_list_partions();

        return;
      }
      else
      {
        /* pdu boundary in data block */
        ptr_block = (T_NEXT_ARRAY*) ptr_block->next;
        grlc_data->rd.ptr_grlc->next = NULL;

        /*
         * free only linked partions
         */
        rd_free_desc_list_partions();
        
        compl_pdu--;       
      }

    }
    else if( compl_pdu )
    {

      TRACE_EVENT_P5("GRLC_DATA_IND len=%ld bsn_start=%d bsn_end=%d las_len=%d dl_fn=%ld"





















                                                                              ,grlc_data->rd.pdu_len
                                                                              ,grlc_data->rd.bsn_pdu_start
                                                                              ,bsn_i
                                                                              ,ptr_block->len
                                                                              ,grlc_data->dl_fn);    
      ptr_block                                      = (T_NEXT_ARRAY*) ptr_block->next;
      grlc_data->rd.ptr_grlc->next                   = NULL;
      grlc_data->rd.grlc_data_ind.desc_list.list_len = grlc_data->rd.pdu_len;
      grlc_data->rd.grlc_data_ind.tlli               = grlc_data->downlink_tbf.tlli;

      #ifdef _TARGET_
      {
          rd_out_grlc_data_ind();
      }
      #     endif   
          
#     ifdef _SIMULATION_
      {
        rd_out_grlc_data_ind_test();
      }
#     endif      
      grlc_data->rd.pdu_complete = TRUE;
      compl_pdu--;
    }
    if(!pdu_cnt)
      pdu_cnt = 0;
    else
      pdu_cnt--;
  }
  while(pdu_cnt);

  grlc_data->rd.pdu_complete = grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_complete;

  /*
   * block combined, first element reseted
   */
  grlc_data->rd.data_array[bsn_i & WIN_MOD].first = NULL;

} /* rd_send_grlc_data_ind() */



/*
+------------------------------------------------------------------------------
| Function    : rd_check_window_size
+------------------------------------------------------------------------------
| Description : The function rd_check_window_size() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL rd_check_window_size ( UBYTE bsn_i )
{ 
  BOOL  result;

  TRACE_FUNCTION( "rd_check_window_size" );

  if(grlc_data->rd.rlc_mode EQ CGRLC_RLC_MODE_ACK)
  {
    if( bsn_i >= grlc_data->rd.ssn )
    {
      if((bsn_i - grlc_data->rd.ssn) < WIN_SIZE)
      {
        result = TRUE;
      }
      else
      {
        result = FALSE;
      }
    }
    else 
    {
      if((bsn_i + 128 - grlc_data->rd.ssn) < WIN_SIZE)
      {
        result = TRUE;
      }
      else
      {
        result = FALSE;
      }
    }
  }
  else if(grlc_data->rd.rlc_mode EQ CGRLC_RLC_MODE_UACK)
  {
    if( bsn_i >= grlc_data->rd.vr )
    {
      if((bsn_i - grlc_data->rd.vr) < WIN_SIZE)
      {
        result = TRUE;
      }
      else
      {
        result = FALSE;
      }
    }
    else 
    {
      if((bsn_i + 128 - grlc_data->rd.vr) < WIN_SIZE)
      {
        result = TRUE;
      }
      else
      {
        result = FALSE;
      }
    }
  }
  else
  {
    result =FALSE;
    TRACE_EVENT_P4("unknown rlc mode in rd_check_window_size: rlc_mode=%d, bsn_i=%d,ssn=%d,vr=%d "
                                                                                                  ,grlc_data->rd.rlc_mode
                                                                                                  ,bsn_i
                                                                                                  ,grlc_data->rd.ssn
                                                                                                  ,grlc_data->rd.vr);
  }


  return result;
} /* rd_check_window_size() */



/*
+------------------------------------------------------------------------------
| Function    : rd_save_block
+------------------------------------------------------------------------------
| Description : The function rd_save_block() .... 
|
| Parameters  : bsn_i             - block sequence number of the saved block
|               *ptr_data_block_i - pointer the data field of the rlc data 
|                                   block without header and li field
|               fbi_i             - final block indication bit of the received
|                                   data block
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_save_block ( UBYTE bsn_i, UBYTE * ptr_data_block_i, UBYTE fbi_i)
{ 
  T_NEXT_ARRAY  *ptr_temp=NULL;
  UBYTE         block_nr;
  UBYTE         i;
  UBYTE         *ptr_data;
  USHORT        len;  
  TRACE_FUNCTION( "rd_save_block" );

  if(!(grlc_data->rd.li_cnt))
  {
    /*
     * only a part of a pdu
     */
    MALLOC(ptr_temp, sizeof(T_NEXT_ARRAY));
    ptr_temp->next = NULL;
    ptr_temp->len  = grlc_data->rd.rlc_data_len;
    memcpy((ptr_temp->data),(ptr_data_block_i),(ptr_temp->len));
    grlc_data->rd.data_array[bsn_i & WIN_MOD].first = ptr_temp;
    if(fbi_i)
    {
      grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_cnt = 1;
      grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_complete =TRUE;
    }
    else
    {
      grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_cnt = 0;
      grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_complete =FALSE;
    }

  }
  else
  {
    /* 
     * for the first part 
     */
    MALLOC(ptr_temp, sizeof(T_NEXT_ARRAY));
    if(grlc_data->rd.li[0] EQ 0 )
      ptr_temp->len  = grlc_data->rd.rlc_data_len-1;
    else
      ptr_temp->len  = grlc_data->rd.li[0];

    ptr_data = ptr_data_block_i;
    memcpy((ptr_temp->data),
           (ptr_data),
           (ptr_temp->len));
    grlc_data->rd.data_array[bsn_i & WIN_MOD].first = ptr_temp;            
    block_nr = 1;
    while((block_nr <= grlc_data->rd.li_cnt) AND (grlc_data->rd.m[block_nr-1]))
    {
      ptr_data       = &(ptr_data[ptr_temp->len]);
      MALLOC(ptr_temp->next, sizeof(T_NEXT_ARRAY));
      ptr_temp       = (T_NEXT_ARRAY *)ptr_temp->next;
      /*
       * check if it islast pdu in rlc data block
       */
      if((block_nr EQ grlc_data->rd.li_cnt)
		      OR (grlc_data->rd.li[block_nr] EQ 0))
      {
        /*
         * last block, len is REST
         */
        len = 0;
        for(i=0; i < grlc_data->rd.li_cnt; i++)
          len += grlc_data->rd.li[i];
        ptr_temp->len  = grlc_data->rd.rlc_data_len - grlc_data->rd.li_cnt - len;
      }
      else
      {
        /* 
         * not last part 
         */
        ptr_temp->len  = grlc_data->rd.li[block_nr];
      }
      memcpy((ptr_temp->data),
             (ptr_data),
             (ptr_temp->len));
      block_nr++;
    }    
    ptr_temp->next = NULL;
    if(grlc_data->rd.m[grlc_data->rd.li_cnt-1] EQ 0)
	    grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_cnt = grlc_data->rd.li_cnt;
	  else
	    grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_cnt = grlc_data->rd.li_cnt + 1;

	  if(fbi_i
		  OR 
		  ((grlc_data->rd.li[grlc_data->rd.li_cnt-1])
		    AND (grlc_data->rd.m[grlc_data->rd.li_cnt-1] EQ 0)))
	    grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_complete = TRUE;
	  else
	    grlc_data->rd.data_array[bsn_i & WIN_MOD].pdu_complete = FALSE;

  }
  
} /* rd_save_block() */



/*
+------------------------------------------------------------------------------
| Function    : rd_comp_rec_par
+------------------------------------------------------------------------------
| Description : The function rd_comp_rec_par() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_comp_rec_par ( UBYTE bsn_i )
{ 
  UBYTE vq_help;
  TRACE_FUNCTION( "rd_comp_rec_par" );

  if(grlc_data->rd.rlc_mode EQ CGRLC_RLC_MODE_ACK)
  {
    if( ( grlc_data->rd.vr >= grlc_data->rd.ssn)  && 
        ( (bsn_i >= grlc_data->rd.vr ) || 
          (bsn_i < grlc_data->rd.ssn) ) )
      grlc_data->rd.vr = (bsn_i+1) & 0x7F;
    else if( ( grlc_data->rd.vr < grlc_data->rd.ssn)  && 
             ( (bsn_i >= grlc_data->rd.vr ) && 
               (bsn_i < grlc_data->rd.ssn) ) )
      grlc_data->rd.vr = (bsn_i+1) & 0x7F;
    
    grlc_data->rd.vn[bsn_i & WIN_MOD] = VN_RECEIVED;
    vq_help = grlc_data->rd.vq;
    while( (grlc_data->rd.vn[vq_help & WIN_MOD]  EQ VN_RECEIVED) AND 
            vq_help NEQ grlc_data->rd.vr)
    {
      vq_help = (vq_help+1) & 0x7F;
    }
    grlc_data->rd.vq = vq_help;
  }
  else if(grlc_data->rd.rlc_mode EQ CGRLC_RLC_MODE_UACK)
  {
    if(grlc_data->rd.vr EQ bsn_i)
    {
      grlc_data->rd.vr         = (1+grlc_data->rd.vr) % 128;
      grlc_data->rd.vq         = (1+grlc_data->rd.vq) % 128;
      grlc_data->rd.inSequence = TRUE;
    }
    else
    {
      grlc_data->rd.vr         = bsn_i;
      grlc_data->rd.inSequence = FALSE;    
    }
  }
  else
    TRACE_ERROR(" unknown RLC Mode during dl tbf in rd_comp_rec_par");


  
} /* rd_comp_rec_par() */




/*
+------------------------------------------------------------------------------
| Function    : rd_check_fbi
+------------------------------------------------------------------------------
| Description : The function rd_check_fbi() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE rd_check_fbi ( UBYTE fbi_i, UBYTE sp , ULONG fn , UBYTE rrbp  )
{ 
  TRACE_FUNCTION( "rd_check_fbi" );
 
  /*
   * mark the bsn with fbi=1
   */
  if(fbi_i)
  {
    grlc_data->rd.last_bsn = grlc_data->rd.vr;
    if(!sp)
    {
      TRACE_EVENT_P1("NO SP BUT FINAL DATA BLOCK t3192=%d",grlc_data->downlink_tbf.t3192_val);
    }
  }


  /*
   * if last bsn is left window element, than tbf is going to be released
   */
  if(grlc_data->rd.last_bsn EQ grlc_data->rd.vq AND
     !grlc_data->rd.f_ack_ind) /* to avoid retransmission */ 
  {
    PALLOC(prim,CGRLC_T3192_STARTED_IND);
    PSEND(hCommGRR,prim);
    if(grlc_data->rd.rlc_mode EQ CGRLC_RLC_MODE_ACK )
    {
      SET_STATE(RD,RD_REL_ACK);
    }
    else
    {
      SET_STATE(RD,RD_REL_UACK);
    }
    
    grlc_data->tbf_ctrl[grlc_data->dl_index].fbi = 1;

    if(sp)
    {
      grlc_data->rd.fn_p_tbf_rel = grlc_decode_tbf_start_rel(fn,(USHORT)(rrbp+3));
    }
    return 1;
  }
  else
  {
    return 0;
  }
}/* rd_check_fbi() */




/*
+------------------------------------------------------------------------------
| Function    : rd_set_acknack
+------------------------------------------------------------------------------
| Description : The function rd_set_acknack() .... 
|
| Parameters  : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE* rd_set_acknack ( void )
{ 
  MCAST (u_dl_ack,U_GRLC_DL_ACK);
  UBYTE * ptr_block;
  UBYTE i;
  UBYTE index;
  UBYTE help,neg_ack=0;
  ULONG rbb1=0,rbb2=0,dummy1=0,dummy2=0;

  TRACE_FUNCTION( "rd_set_acknack" );

  
  if(grlc_data->rd.channel_req AND (grlc_data->tbf_type EQ TBF_TYPE_DL))
  {
    u_dl_ack->v_chan_req_des = 1;
    u_dl_ack->chan_req_des   = grlc_data->chan_req_des;    
    grlc_data->rd.channel_req = 0;
    grlc_data->rd.ch_req_in_ack_prog = TRUE;
	 /* TRACE_EVENT_P6("channel req des in dl ack nack:ptp=%d,rp=%d,rlc_mode=%d,llc_pt=%d,rlc_oc=%d, pst=%d",
                                  grlc_data->chan_req_des.peak_thr_class,
                                  grlc_data->chan_req_des.radio_prio,
                                  grlc_data->chan_req_des.rlc_mode,
                                  grlc_data->chan_req_des.llc_pdu_type,
                                  grlc_data->chan_req_des.rlc_octet_cnt,
                                  grlc_data->prim_start_tbf);*/
    if(grlc_data->prim_start_tbf >= PRIM_QUEUE_SIZE_TOTAL)
    {
      TRACE_EVENT_P3("PST=%d PSF=%d PDU=%d: rd_set_acknack"
                                                           ,grlc_data->prim_start_tbf
                                                           ,grlc_data->prim_start_free
                                                           ,grlc_data->grlc_data_req_cnt);
    }

  }
  else
  {
    u_dl_ack->v_chan_req_des = 0;
    grlc_data->rd.channel_req = 0; 
  }
  
  u_dl_ack->msg_type               = U_GRLC_DL_ACK_c;
  u_dl_ack->dl_tfi                 = grlc_data->dl_tfi;
  u_dl_ack->ack_nack_des.f_ack_ind = grlc_data->rd.f_ack_ind;
  u_dl_ack->ack_nack_des.ssn       = grlc_data->rd.vr;
  memset(u_dl_ack->ack_nack_des.rbb, 1, WIN_SIZE );
  for(i=0; i< WIN_SIZE; i++)
  {
    if(grlc_data->rd.vr EQ grlc_data->rd.ssn OR grlc_data->rd.rlc_mode EQ CGRLC_RLC_MODE_UACK)
      break;
    index = (grlc_data->rd.vr-1-i) & 0x7F;
    if(grlc_data->rd.vn[index & WIN_MOD] NEQ VN_RECEIVED)
    {
      u_dl_ack->ack_nack_des.rbb[WIN_SIZE-1-i] = 0; 
      neg_ack++;
    }
    if(grlc_data->rd.ssn EQ index )      
    {
      help  =  grlc_data->rd.ssn;
      while(help NEQ grlc_data->rd.vq)
      {
        grlc_data->rd.vn[help & WIN_MOD] = VN_INVALID;
        help = (help + 1) & 0x7F; 
      }
      break;
    }
  }

  /* TRACE ONLY if there is channel desc or negative ack or the final ack*/
  if(u_dl_ack->v_chan_req_des OR
     u_dl_ack->ack_nack_des.f_ack_ind OR
     neg_ack)
  {
    if(neg_ack AND !u_dl_ack->ack_nack_des.f_ack_ind)
    {
      for(i=0; i<32;i++)
      {
        dummy1 = u_dl_ack->ack_nack_des.rbb[WIN_SIZE-1-i];
        dummy2 = u_dl_ack->ack_nack_des.rbb[WIN_SIZE-1-i-32];
        rbb1  += dummy1 <<i;
        rbb2  += dummy2 <<i;
      }
      TRACE_EVENT_P7("dl_ack:p_fn=%ld,CD=%d  ssn=%d nacks=%d vq=%d rbb2=%lx rbb1=%lx",
                                          grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn,
                                          u_dl_ack->v_chan_req_des,
                                          u_dl_ack->ack_nack_des.ssn,
                                          neg_ack,                                         
                                          grlc_data->rd.vq,
                                          rbb2,
                                          rbb1); 
    }
    else
    {
      rbb1 = 0xFFFFFFFF;
      rbb2 = 0xFFFFFFFF;
      TRACE_EVENT_P6("dl_ack:p_fn=%ld,CD=%d fbi=%d ssn=%d nacks=%d vq=%d",
                                          grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn,
                                          u_dl_ack->v_chan_req_des,
                                          u_dl_ack->ack_nack_des.f_ack_ind,
                                          u_dl_ack->ack_nack_des.ssn,
                                          neg_ack,                                         
                                          grlc_data->rd.vq);
    }
  }
  else
  {
    rbb1 = 0xFFFFFFFF;
    rbb2 = 0xFFFFFFFF;  
  }

  u_dl_ack->chan_qual_rep.c_value = 0;
  u_dl_ack->chan_qual_rep.rxqual  = 0;
  u_dl_ack->chan_qual_rep.signvar = 0;

  {
    /* processing channel quality report */

    /* processing of C value */
    u_dl_ack->chan_qual_rep.c_value = meas_grlc_c_get_value( );

    /* processing of RXQUAL value */
    u_dl_ack->chan_qual_rep.rxqual  = meas_sq_get_rxqual_value( );

    /* processing of signal variance */
    u_dl_ack->chan_qual_rep.signvar = meas_sv_get_value( );

    /* processing of relative interference levels */
    meas_int_get_rel_i_level( &u_dl_ack->chan_qual_rep.ilev );
  } 

#if !defined (NTRACE)

  if( grlc_data->meas.v_im_trace NEQ 0 )
  {
    TRACE_EVENT_P3( "rd_set_acknack: %d %d %d",
                    u_dl_ack->chan_qual_rep.c_value,
                    u_dl_ack->chan_qual_rep.rxqual,
                    u_dl_ack->chan_qual_rep.signvar );
  }

#endif /* #if !defined (NTRACE) */

#ifdef REL99

  u_dl_ack->v_release_99_str_u_grlc_dl_ack = 1;
  
  if (grlc_data->pfi_support AND u_dl_ack->v_chan_req_des )
  {
    u_dl_ack->release_99_str_u_grlc_dl_ack.v_pfi = 1;
    u_dl_ack->release_99_str_u_grlc_dl_ack.pfi = grlc_data->pfi_value;  
  }
  else
  {
    u_dl_ack->release_99_str_u_grlc_dl_ack.v_pfi = 0;
  }

#endif


  grlc_data->rd.ssn   = grlc_data->rd.vq;  
  ptr_block = (_decodedMsg);


  return ptr_block;
} /* rd_set_acknack() */


/*
+------------------------------------------------------------------------------
| Function    : rd_calc_rlc_data_len
+------------------------------------------------------------------------------
| Description : The function rd_calc_rlc_data_len() calculates the Data size of
|               an RLC data block depending on coding scheme. 
|               The size is described in bytes.
|               
| Parameters  : block_status_i - includes the Coding scheme which 
|               determines the size of an RLC data block
|                 
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE rd_calc_rlc_data_len ( USHORT  block_status_i )
{ 
  UBYTE result=0;
  TRACE_FUNCTION( "rd_calc_rlc_data_len" );
  
  /*
   * the coding scheme is only in the first four bits
   */
  block_status_i = block_status_i & 0x000F; 

  switch( block_status_i)
  {
  case 2:
    grlc_data->rd.cs_type  = CS_1;
    break;
  case 4:
    grlc_data->rd.cs_type  = CS_2;
    break;
  case 5:
    grlc_data->rd.cs_type  = CS_3;
    break;
  case 6:
    grlc_data->rd.cs_type  = CS_4;
    break;
  default:
    TRACE_EVENT("No Coding Scheme in RLC data block defined, old CS is used");
    break;
  }
  
  
  switch( grlc_data->rd.cs_type)
  {
  /*
   * NO CS defined in all previously received RLC data blocks, 
   * therefore default CS_1 is used
   */
  case CS_ZERO: 
  case CS_1:
    result = 20;
    break;
  case CS_2:
    result = 30;
    break;
  case CS_3:
    result = 36;
    break;
  case CS_4:
    result = 50;
    break;
  default:
    TRACE_ERROR("unknown Coding Scheme");
    break;
  }

  return result;
} /* rd_calc_rlc_data_len() */



/*
+------------------------------------------------------------------------------
| Function    : rd_fill_blocks
+------------------------------------------------------------------------------
| Description : The function rd_fill_blocks() fills not received but needed 
|               RLC data blocks with the value Zero.
|
| Parameters  : bsn_i - bsn value of the recently received RLC data block, 
|               which is not inSequence(not equal VR at receiving the block)
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_fill_blocks ( UBYTE bsn_i )
{ 
  T_NEXT_ARRAY * ptr_temp=NULL;
  TRACE_FUNCTION( "rd_fill_blocks" );

  do
  {
    MALLOC(ptr_temp, sizeof(T_NEXT_ARRAY));
    ptr_temp->next = NULL;
    ptr_temp->len  = grlc_data->rd.rlc_data_len;
    memset(ptr_temp->data,0,ptr_temp->len);
    grlc_data->rd.data_array[grlc_data->rd.vq & WIN_MOD].first = ptr_temp;
    grlc_data->rd.data_array[grlc_data->rd.vq & WIN_MOD].pdu_cnt = 0;
    grlc_data->rd.data_array[grlc_data->rd.vq & WIN_MOD].pdu_complete =FALSE;
    rd_send_grlc_data_ind(grlc_data->rd.vq);
    grlc_data->rd.vq = (1+grlc_data->rd.vq) % 128; /*modulo 128*/
  }
  while(grlc_data->rd.vq NEQ bsn_i);

  grlc_data->rd.vq         = (1+grlc_data->rd.vq) % 128; /*modulo 128*/
  grlc_data->rd.vr         = grlc_data->rd.vq;
  grlc_data->rd.inSequence = TRUE;



} /* rd_fill_blocks() */




/*
+------------------------------------------------------------------------------
| Function    : rd_calc_delta_fn
+------------------------------------------------------------------------------
| Description : The function rd_calc_delta_fn() calculates delta_fn. It is 
|               needed at receiving mac_ready_ind to send a poll block.
|               In Target Enviroment, the poll block(Ack/nack or Control block)
|               must be calculated one radio block earlier then the send time.
|               This is needed due to the functional interface.
| Parameters  : fn_i - framenumber for the uplink call 
|               
|
+------------------------------------------------------------------------------
*/
GLOBAL ULONG rd_calc_delta_fn ( ULONG fn_i )
{ 
  ULONG result;
  TRACE_FUNCTION( "rd_calc_delta_fn" );

  #ifdef _TARGET_
  {
    if(fn_i EQ FN_MAX-5)
      result = grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn + 5;
    else
      result = grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn - fn_i;
  }
#endif

#ifdef _SIMULATION_
  {
    if(fn_i EQ grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn)
      result = 4; /*valid: send block*/
    else
      result = 0; /*no poll sending*/
  }
#endif

  return result;


} /* rd_calc_delta_fn() */

/*
+------------------------------------------------------------------------------
| Function    : rd_free_desc_list_partions
+------------------------------------------------------------------------------
| Description : The function rd_free_desc_list_partions() frees the partions,
|               which are linked for a candidate LLC pdu. PDU is stored as a 
|               description list, but not passed to LLC because of incomplete.
| Parameters  :  
|               
+------------------------------------------------------------------------------
*/
GLOBAL void rd_free_desc_list_partions ( void )
{
  UBYTE          cnt  = 0;
  T_NEXT_ARRAY  *help = NULL;

  TRACE_FUNCTION( "rd_free_desc_list_partions" );

  help = (T_NEXT_ARRAY*)grlc_data->rd.grlc_data_ind.desc_list.first;

  grlc_data->rd.grlc_data_ind.desc_list.first = NULL;

  while(help != NULL)
  {
    T_NEXT_ARRAY  *ptr = (T_NEXT_ARRAY*) help->next;
    MFREE(help);
    help = ptr;
    cnt++;
  }


  #ifdef _SIMULATION_
  TRACE_EVENT_P1("freed partion (linked)  : cnt=%d",cnt);
#endif /* _SIMULATION_*/


  grlc_data->rd.pdu_complete  = TRUE;
  grlc_data->rd.pdu_len       = 0;


} /* rd_free_desc_list_partions() */

/*
+------------------------------------------------------------------------------
| Function    : rd_free_database_partions
+------------------------------------------------------------------------------
| Description : The function rd_free_database_partions() frees the partions,
|               which are stored in the RD database. They are not linked to a
|               LLC pdu because data blocks are not received in sequence. 
|               Partions are removed from left window size (vq) up to the 
|               right window size (vr).
| Parameters  :  
|               
+------------------------------------------------------------------------------
*/
GLOBAL void rd_free_database_partions ( void )
{
  USHORT bsn;

  UBYTE  cnt=0;

  T_NEXT_ARRAY  *help = NULL;

  TRACE_FUNCTION( "rd_free_database_partions" );

  bsn = grlc_data->rd.vq;  

  while (bsn NEQ grlc_data->rd.vr) 
  {
    help = grlc_data->rd.data_array[bsn & WIN_MOD].first; 
#ifdef _SIMULATION_
    TRACE_EVENT_P2("candiate bsn=%d  vn=%d",bsn,grlc_data->rd.vn[bsn & WIN_MOD]);
#endif /* _SIMULATION_*/

    while (help != NULL) 
    {
      grlc_data->rd.data_array[bsn & WIN_MOD].first = 
        (T_NEXT_ARRAY *)grlc_data->rd.data_array[bsn & WIN_MOD].first->next;

      MFREE(help);

      cnt++;
#ifdef _SIMULATION_
      TRACE_EVENT_P1("element free : bsn=%d",bsn);
#endif /* _SIMULATION_*/
      if(grlc_data->rd.data_array[bsn & WIN_MOD].pdu_cnt)
		    help = grlc_data->rd.data_array[bsn & WIN_MOD].first;
	    else
		    help = NULL;
	  }
    grlc_data->rd.data_array[bsn & WIN_MOD].pdu_complete = FALSE;
    grlc_data->rd.data_array[bsn & WIN_MOD].pdu_cnt      = 0xFF;
    grlc_data->rd.data_array[bsn & WIN_MOD].first        = NULL;   
    
    bsn = (bsn + 1) & 0x7F;
  }
  TRACE_EVENT_P2("rd_free_database_partions after:  bsn=%d  cnt=%d ", bsn,  cnt);


} /* rd_free_database_partions() */


/*
+------------------------------------------------------------------------------
| Function    : rd_cgrlc_st_time_ind 
+------------------------------------------------------------------------------
| Description : The function rd_cgrlc_st_time_ind () informs higher layers
|               that the starting time is elapsed
|
| Parameters  : -
|
+------------------------------------------------------------------------------
*/
GLOBAL void rd_cgrlc_st_time_ind  ( void )
{ 
  PALLOC(cgrlc_starting_time_ind,CGRLC_STARTING_TIME_IND); /* T_CGRLC_STARTING_TIME_IND */

  TRACE_FUNCTION( "rd_cgrlc_st_time_ind " );

  cgrlc_starting_time_ind->tbf_mode = CGRLC_TBF_MODE_DL;
  cgrlc_starting_time_ind->tfi      = grlc_data->dl_tfi;
 
  PSEND(hCommGRR,cgrlc_starting_time_ind);

  grlc_data->dl_tn_mask = grlc_data->downlink_tbf.ts_mask;
  

} /* rd_cgrlc_st_time_ind () */