line source
/*
+-----------------------------------------------------------------------------
| 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 GFF of
| entity GRLC.
+-----------------------------------------------------------------------------
*/
#ifndef GRLC_GFFF_C
#define GRLC_GFFF_C
#endif
#define ENTITY_GRLC
/*==== INCLUDES =============================================================*/
#include <string.h>
#include "typedefs.h" /* to get Condat data types */
#include <stdio.h>
#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 "prim.h" /* to get the definitions of used SAP and directions */
#include "message.h"
#include "grlc.h"
#include "grlc_f.h"
#include "grlc_tms.h"
#include "grlc_rus.h"
#include "grlc_rds.h"
#include "grlc_gfff.h"
#include "cl_rlcmac.h"
/*==== CONST ================================================================*/
#define D_DL_DUMMY_c 0x25
/*==== LOCAL VARS ===========================================================*/
/*==== PRIVATE FUNCTIONS ====================================================*/
/*==== PUBLIC FUNCTIONS =====================================================*/
/*
+------------------------------------------------------------------------------
| Function : gff_init
+------------------------------------------------------------------------------
| Description : The function gff_init() ....
|
| Parameters : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void gff_init ( void )
{
TRACE_FUNCTION( "gff_init" );
grlc_data->gff.rlc_status = RLC_STATUS_NULL;
grlc_data->ul_tfi = 0xFF;
grlc_data->dl_tfi = 0xFF;
grlc_data->next_poll_fn = 1;
grlc_data->ul_poll_pos_index = 0xFF;
grlc_data->nr_of_crc_errors = 0xFFFF;
grlc_data->ta_value = 0xFF;
INIT_STATE(GFF,GFF_DEACTIVE);
} /* gff_init() */
/*
+------------------------------------------------------------------------------
| Function : gff_tbf_init
+------------------------------------------------------------------------------
| Description : The function gff_tbf_init() ....
|
| Parameters : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void gff_tbf_init ( void )
{
TRACE_FUNCTION( "gff_tbf_init" );
/*
* set segmented control block array
*/
grlc_data->ul_poll_pos_index = 0;
grlc_data->nr_of_crc_errors = 0;
#if defined (_TARGET_)
{
UBYTE i;
/* target debugging*/
grlc_data->last_dl_fn = 1;
for (i=0; i < CALL_ERROR_NR_OF_ST_FN;i++)
{
grlc_data->ul_fn_store[i] = 0;
grlc_data->ul_fn_errors[i] = 0;
grlc_data->dl_fn_store[i] = 0;
grlc_data->dl_fn_errors[i] = 0;
}
grlc_data->ul_cnt_syn = 0; /*for target, count calls in rlc uplink*/
grlc_data->ul_cnt_asyn = 0; /*for target, count calls in gffp mac_ready_ind*/
grlc_data->dl_cnt_syn = 0; /*for target, count calls in rlc downlink*/
grlc_data->dl_cnt_asyn = 0; /*for target, count calls in gffp mac_data_ind*/
grlc_data->ul_call_errors = 0; /*for target, count calls in rlc uplink during grlc is active*/
grlc_data->dl_call_errors = 0; /*for target, count calls in rlc downlink during grlc is active*/
}
#endif /* defined (_TARGET_) */
} /* gff_tbf_init() */
/*
+------------------------------------------------------------------------------
| Function : gff_send_ctrl_block
+------------------------------------------------------------------------------
| Description : The function gff_send_ctrl_block() ....
|
| Parameters : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void gff_send_ctrl_block (ULONG fn_i, UBYTE tn_i, UBYTE * ptr_ctrl_block_i )
{
PALLOC(cgrlc_data_ind,CGRLC_DATA_IND); /*T_CGRLC_DATA_IND*/
TRACE_FUNCTION( "gff_send_ctrl_block" );
cgrlc_data_ind->fn = fn_i;
cgrlc_data_ind->tn = tn_i;
memcpy( cgrlc_data_ind->data_array,
ptr_ctrl_block_i,
CGRLC_MAX_CTRL_MSG_SIZE );
PSEND(hCommGRR,cgrlc_data_ind);
}/* gff_send_ctrl_block() */
/*
+------------------------------------------------------------------------------
| Function : gff_analyse_dl_data
+------------------------------------------------------------------------------
| Description : The function gff_analyse_dl_data() .... It returns whether
| the downlink block was intended for that MS or not.
|
| Parameters : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL gff_analyse_dl_data (ULONG fn_i, T_dl_data * ptr_dl_data_i )
{
BOOL tfi_correct = FALSE;
UBYTE payload,rrbp,sp,tfi,*ptr_blk;
TRACE_FUNCTION( "gff_analyse_dl_data" );
/*
* Layer 1 buffer
* B1 B0 --> ptr_dl_data_i->dl_block[0]
* B3 B2
*
* B0 is the mac header
*/
ptr_blk = (UBYTE *) (&ptr_dl_data_i->dl_block[0]);
payload = (ptr_blk[0] & 0xC0) >> 6;
rrbp = (ptr_blk[0] & 0x30) >> 4;
sp = (ptr_blk[0] & 0x08) >> 3;
/*
* In Test mode B,if there is CRC error on the payload data the MS will,
* where required by the USF, transmit the decoded payload data. The block
* transmitted will be a valid uplink block format.
*/
if(((ptr_dl_data_i->block_status & 0x0100) NEQ 0x0000) AND ((grlc_data->testmode.mode EQ CGRLC_LOOP)))
{
UBYTE bsn,e_bit;
bsn = (ptr_blk[2] & 0xFE)>>1;
e_bit = (ptr_blk[2] & 0x01);
TRACE_EVENT(" Bad CRC - In Testmode B ");
sig_gff_rd_data( fn_i,
(UBYTE)ptr_dl_data_i->tn,
ptr_dl_data_i->block_status,
rrbp,
sp,
bsn,
0,
e_bit,
ptr_blk);
}
else
{
if(payload EQ RLC_DATA_BLOCK)
{
UBYTE bsn,fbi,e_bit;
tfi = (ptr_blk[1] & 0x3E) >> 1;
bsn = (ptr_blk[2] & 0xFE)>>1;
fbi = (ptr_blk[1] & 0x01);
e_bit = (ptr_blk[2] & 0x01);
ptr_blk = (UBYTE *) (&ptr_blk[3]);
if((tfi EQ grlc_data->dl_tfi) AND
((0x80>>ptr_dl_data_i->tn) & grlc_data->dl_tn_mask))
{
tfi_correct = TRUE;
if(sp)
{
grlc_save_poll_pos ( fn_i,(UBYTE)ptr_dl_data_i->tn,rrbp, CGRLC_POLL_DATA, 3);
}
sig_gff_rd_data( fn_i,
(UBYTE)ptr_dl_data_i->tn,
ptr_dl_data_i->block_status,
rrbp,
sp,
bsn,
fbi,
e_bit,
ptr_blk);
#ifdef _TARGET_
TRACE_BINDUMP( hCommGRLC, TC_USER6,
"D_DATA_BLOCK including MAC header", &ptr_dl_data_i->dl_block[0],53);
#endif /* _TARGET_ */
}
else
{
TRACE_EVENT_P6("wrong tfi in data block ad.tfi=%d dl_tfi=%d bsn=%d || tn=%d->mask=%x tn_mask=%x"
,tfi
,grlc_data->dl_tfi
,bsn
,ptr_dl_data_i->tn
,(0x80>>ptr_dl_data_i->tn)
,grlc_data->dl_tn_mask);
}
}
else
{
/*
* any rlc control message received.
* check if it is a packet uplink ack/nack and if it is adressed to MS
*/
ULONG tc_user = TC_USER4;
UBYTE trace_msg_type = D_MSG_TYPE_UNKNOWN_c;
UBYTE msg_type=0,i=0;
if( payload EQ CTRL_BLK_NO_OPT )
{
msg_type = trace_msg_type = ptr_blk[1]>>2;
i = 2; /* Byte position of tfi in puan */
}
else if( payload EQ CTRL_BLK_OPT )
{
if( !(ptr_blk[1] & 0x01) ) /* no tfi octet present: ac = 0 */
{
if( !(ptr_blk[1] & 0x80) ) /* not segmented : rbsn = 0 */
{
if( (ptr_blk[1] & 0x02) ) /* not segmented : fs = 1 */
{
msg_type = trace_msg_type = ptr_blk[2]>>2;
i = 3; /* Byte position of tfi in puan */
}
else /* segmented : fs = 0 */
{
trace_msg_type = ptr_blk[2]>>2;
}
}
else /* segmented : rbsn = 1 */
{
trace_msg_type = D_MSG_TYPE_2ND_SEGMENT_c;
}
}
else /* tfi octet present : ac = 1 */
{
if( !(ptr_blk[1] & 0x80) ) /* not segmented : rbsn = 0 */
{
if( (ptr_blk[1] & 0x02) ) /* not segmented : fs = 1 */
{
msg_type = trace_msg_type = ptr_blk[3]>>2;
i = 4; /* Byte position of tfi in puan */
}
else /* segmented : fs = 0 */
{
trace_msg_type = ptr_blk[3]>>2;
}
}
else /* segmented : rbsn = 1 */
{
trace_msg_type = D_MSG_TYPE_2ND_SEGMENT_c;
}
}
}
/*
* send control message to GRR
*/
if(msg_type NEQ D_DL_DUMMY_c ) /* No Dummy blocks sent to GRR , to primitive load between GRR and GRLC*/
{
gff_send_ctrl_block(fn_i, (UBYTE)ptr_dl_data_i->tn,ptr_blk);
}
if( trace_msg_type EQ D_DL_DUMMY_c )
{
tc_user = TC_USER5;
}
TRACE_BINDUMP( hCommGRLC, tc_user,
cl_rlcmac_get_msg_name( trace_msg_type, RLC_MAC_ROUTE_DL ),
ptr_blk, MAX_L2_FRAME_SIZE ); /*lint !e569*/
if(msg_type EQ D_GRLC_UL_ACK_c)
{
/*
* tfi check for packet uplink ack nack
*/
if(i EQ 4 AND /* tfi in header present */
!(ptr_blk[2] & 0x01) AND /* D=0 packet uplink tfi add. */
(((ptr_blk[2]) & 0x3E)>>1) EQ grlc_data->ul_tfi) /* header tfi addressed to MS */
{
tfi = ((ptr_blk[2]) & 0x3E)>>1;
}
else
{
tfi = ((ptr_blk[i]) & 0x3E)>>1; /* Take tfi from airmessage*/
}
if((grlc_data->ul_tfi EQ tfi) AND
((0x80>>ptr_dl_data_i->tn) & grlc_data->ul_tn_mask))
{
T_MSGBUF msg;
UBYTE data[22];
memset(data,0xEE,22);
msg.l_buf = (23 - i + 1) * 8;
msg.o_buf = 0;
msg.buf[0] = data[0];
memcpy(msg.buf, &(ptr_blk[i-1]), (msg.l_buf)/8);
if(sp)
{
grlc_save_poll_pos ( fn_i,(UBYTE)ptr_dl_data_i->tn,rrbp, CGRLC_POLL_UACK, 3);
}
grlc_decode_grlc (&msg);
sig_gff_ru_ul_ack ( fn_i,(UBYTE)ptr_dl_data_i->tn,rrbp,sp);
}
}
}
}
return( tfi_correct );
} /* gff_analyse_dl_data() */
/*
+------------------------------------------------------------------------------
| Function : gff_handle_continious_ta
+------------------------------------------------------------------------------
| Description : store the new ta value, and pass it to L1
|
| Parameters :
|
+------------------------------------------------------------------------------
*/
GLOBAL void gff_handle_continious_ta ( void )
{
TRACE_FUNCTION( "gff_handle_continious_ta" );
if(grlc_data->func.mac_ready_ind.ta_value NEQ 0xFF)
{
/*
* valid TA in L1
*/
if(grlc_data->ta_value NEQ grlc_data->func.mac_ready_ind.ta_value )
{
PALLOC(cgrlc_ta_value_ind,CGRLC_TA_VALUE_IND);
/*
* Current TA in GRLC differs from the TA in L1: store in GRLC
*/
grlc_data->ta_value = grlc_data->func.mac_ready_ind.ta_value;
cgrlc_ta_value_ind->ta_value = grlc_data->ta_value;
PSEND(hCommGRR,cgrlc_ta_value_ind);
}
}
} /* gff_handle_continious_ta */
/*
+------------------------------------------------------------------------------
| Function : gff_clip_rxlev
+------------------------------------------------------------------------------
| Description : This function is used to clip received signal level values.
|
| Parameters : clipp - pointer to clipped received signal level values
| rxlev - pointer to received signal level values
| number - number of received signal level values
|
+------------------------------------------------------------------------------
*/
GLOBAL void gff_clip_rxlev ( UBYTE *clipp, UBYTE *rxlev, UBYTE number )
{
UBYTE i; /* used for counting */
TRACE_FUNCTION( "gff_clip_rxlev" );
for( i = 0; i < number; i++ )
{
if( (signed char)( rxlev[i] ) < MAC_RXLEV_MIN AND
rxlev[i] NEQ MAC_RXLEV_NONE )
{
clipp[i] = MAC_RXLEV_MIN;
}
else if ( (signed char)( rxlev[i] ) > MAC_RXLEV_MAX )
{
clipp[i] = MAC_RXLEV_MAX;
}
else if( rxlev[i] EQ MAC_RXLEV_NONE )
{
clipp[i] = MAC_RXLEV_NONE;
}
else
{
clipp[i] = rxlev[i];
}
}
} /* gff_clip_rxlev() */
