FreeCalypso > hg > fc-tourmaline
view src/g23m-gprs/grlc/grlc_ruf.c @ 51:04aaa5622fa7
disable deep sleep when Iota LEDB is on
TI's Iota chip docs say that CLK13M must be running in order for
LEDB to work, and practical experience on Mot C139 which uses
Iota LEDB for its keypad backlight concurs: if Calypso enters
deep sleep while the keypad backlight is turned on, the light
flickers visibly as the chipset goes into and out of deep sleep.
TI's original L1 sleep manager code had logic to disable deep sleep
when LT_Status() returns nonzero, but that function only works
for B-Sample and C-Sample LT, always returns 0 on BOARD 41 - no
check of Iota LEDB status anywhere. Change this code for our
current hardware: disable deep sleep when Iota LEDB has been
turned on through LLS.
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Mon, 19 Oct 2020 05:11:29 +0000 |
| parents | fa8dc04885d8 |
| children |
line wrap: on
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 RU of | entity GRLC. +----------------------------------------------------------------------------- */ #ifndef GRLC_RUF_C #define GRLC_RUF_C #endif #define ENTITY_GRLC /*==== INCLUDES =============================================================*/ #include <stdio.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_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_f.h" #include "grlc_tms.h" #include "grlc_rds.h" #include "grlc_ruf.h" #include <string.h> #include "cl_rlcmac.h" /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : ru_init +------------------------------------------------------------------------------ | Description : The function ru_init() set init values in null state. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_init ( void ) { UBYTE i; UBYTE j; TRACE_FUNCTION( "ru_init" ); INIT_STATE(RU,RU_NULL); /* * UBYTE */ grlc_data->ru.nts = 0xFF; grlc_data->ru.nts_max = 0xFF; grlc_data->ru.ti = 0xFF; grlc_data->ru.next_prim = 0xFF; grlc_data->ru.active_prim = 0xFF; grlc_data->ru.vs = 0xFF; grlc_data->ru.va = 0xFF; grlc_data->ru.bsn_ret = 0xFF; grlc_data->ru.last_si_block = 0xFF; grlc_data->ru.cv = 0xFF; grlc_data->ru.N3104 = 0xFF; grlc_data->ru.N3104_MAX = 0xFF; grlc_data->ru.block_status = 0xFF; grlc_data->ru.poll_tn = 0xFF; grlc_data->ru.count_cv_0 = 0xFF; grlc_data->ru.nr_nacked_blks = 0xFF; grlc_data->ru.pdu_cnt = 0xFF; grlc_data->ru.pdu_sent = 0xFF; grlc_data->ru.pdu_rem = 0xFF; grlc_data->ru.pdu_boundaries = 0xFF; grlc_data->ru.write_pos_index = 0xFF; /* * USHORT */ grlc_data->ru.rlc_data_size = 0xFFFF; grlc_data->ru.sdu_len = 0xFFFF; grlc_data->ru.sdu_off = 0xFFFF; grlc_data->ru.rlc_octet_cnt = 0xFFFF; grlc_data->ru.tbc = 0xFFFF; grlc_data->ru.cnt_ts = 0xFFFF; /* * BOOL */ grlc_data->ru.tlli_cs_type = FALSE; grlc_data->ru.cd_active = TRUE; grlc_data->ru.first_usf = FALSE; grlc_data->ru.release_tbf = FALSE; #if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH grlc_data->ru.tbf_re_est = FALSE; #endif /* * Type */ grlc_data->ru.cs_type = CS_ZERO; /* * structs */ grlc_data->ru.pl_retrans_current.cnt = 0xFF; memset(grlc_data->ru.pl_retrans_current.blk, 0xFF, 4); /* * array */ for (i=0;i<WIN_SIZE;i++) grlc_data->ru.vb[i & WIN_MOD] = VB_INVALID; /* * global structs */ for (i=0;i<NEXT_POLL_ARRAY_SIZE;i++) { /* * set free list */ grlc_data->next_poll_array[i].next = i+1; grlc_data->next_poll_array[i].fn = 0xFFFFFFFF; grlc_data->next_poll_array[i].cnt = 0; for(j=0; j< POLL_TYPE_ARRAY_SIZE; j++) grlc_data->next_poll_array[i].poll_type[j] = CGRLC_POLL_NONE; } /* * last free entry points to 0xff */ grlc_data->next_poll_array[NEXT_POLL_ARRAY_SIZE-1].next = 0xFF; /* * indicates invalid paramters */ grlc_data->poll_start_free = 0; grlc_data->poll_start_tbf = 0xFF; } /* ru_init() */ /* +------------------------------------------------------------------------------ | Function : ru_within_window +------------------------------------------------------------------------------ | Description : The function ru_within_window() checks if the bsn_i value is | between high_value_i and low_value_i(modulo operating). | The return value is result. | | | Parameters : bsn_i - chech this value | high_value_i - right side of the window | low_value_i - left side of the window | +------------------------------------------------------------------------------ */ GLOBAL BOOL ru_within_window ( UBYTE bsn_i, UBYTE high_value_i,UBYTE low_value_i ) { BOOL result = FALSE; TRACE_FUNCTION( "ru_within_window" ); if( ( high_value_i >= low_value_i ) AND /* vs >= va */ ( bsn_i > low_value_i ) AND /* ssn > va */ ( bsn_i <= high_value_i ) /* vs >= ssn */ ) { result = TRUE; } else if( ( high_value_i < low_value_i ) /* va > vs */ AND ( ( ( bsn_i > low_value_i ) AND /* ssn > va */ ( bsn_i > high_value_i )) OR /* ssn > vs */ ( ( bsn_i < low_value_i ) AND /* ssn > va */ ( bsn_i <= high_value_i )) /* ssn <= vs */ ) ) { result = TRUE; } /* if(!result) { TRACE_EVENT_P3("BSN not in range: low=%d bsn=%d high=%d", low_value_i,bsn_i,high_value_i); } */ return result; } /* ru_within_window() */ /* +------------------------------------------------------------------------------ | Function : ru_recalc_rlc_oct_cnt +------------------------------------------------------------------------------ | Description : The function ru_recalc_rlc_oct_cnt() the number of octetcs | during the TBF. It is needed for starting the countdown procedure | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL USHORT ru_recalc_rlc_oct_cnt ( void ) { USHORT result; UBYTE next_cnt; UBYTE prev_cnt; UBYTE rem_pdu_bound; ULONG rest_of_pdu; UBYTE last_pdu_bound; TRACE_FUNCTION( "ru_recalc_rlc_oct_cnt" ); grlc_data->ru.next_prim = grlc_data->prim_queue[grlc_data->ru.active_prim].next; result = grlc_data->ru.sdu_len; next_cnt = grlc_data->ru.next_prim; if(grlc_data->ru.sdu_len) grlc_data->ru.pdu_rem = 1; /*init calculate nr of pdu boundaries*/ rest_of_pdu = grlc_data->ru.sdu_len%grlc_data->ru.rlc_data_size; if((rest_of_pdu EQ 0) AND ((next_cnt EQ 0xFF) OR /* either no primitive in queue */ grlc_data->prim_queue[next_cnt].start_new_tbf)) /* or next primitive belongs to new tbf */ rem_pdu_bound = 0; /*fills excatly in cv=0*/ else if(rest_of_pdu EQ 0) rem_pdu_bound = 2; /*fills exxalty, more pdus rerq, therefore 2 bounds*/ else rem_pdu_bound = 1; /*normal case*/ last_pdu_bound = rem_pdu_bound; #ifdef _SIMULATION_ TRACE_EVENT_P4("pdu_len=%d,rest_of_pdu=%d,rem_pdu_bound=%d,last_pdu_bound=%d", grlc_data->ru.sdu_len, rest_of_pdu, rem_pdu_bound, last_pdu_bound ); #endif /* #ifdef _SIMULATION_ */ prev_cnt = grlc_data->ru.active_prim; while((next_cnt < PRIM_QUEUE_SIZE_TOTAL) AND (grlc_data->prim_queue[next_cnt].start_new_tbf EQ 0) ) { ULONG sdu_len; result += grlc_data->prim_queue[next_cnt].prim_ptr->sdu.l_buf/8; sdu_len = grlc_data->prim_queue[next_cnt].prim_ptr->sdu.l_buf/8; grlc_data->prim_queue[next_cnt].previous = prev_cnt; grlc_data->prim_queue[next_cnt].cv_status = FALSE; grlc_data->prim_queue[next_cnt].rlc_status = FALSE; grlc_data->prim_queue[next_cnt].last_bsn = 0xFF; prev_cnt = next_cnt; next_cnt = grlc_data->prim_queue[next_cnt].next; grlc_data->ru.pdu_rem++; /*init calculate nr of pdu boundaries*/ rest_of_pdu = ((sdu_len+last_pdu_bound+rest_of_pdu)%grlc_data->ru.rlc_data_size); if((rest_of_pdu EQ 0) AND ((next_cnt EQ 0xFF) OR grlc_data->prim_queue[next_cnt].start_new_tbf)) { rem_pdu_bound += 0; /*fills excatly in cv=0*/ last_pdu_bound = 0; } else if(rest_of_pdu EQ 0) { rem_pdu_bound += 2; /*fills exxalty, more pdus rerq, therefore 2 bounds*/ last_pdu_bound = 2; } else { rem_pdu_bound += 1; /*normal case*/ last_pdu_bound = 1; } #ifdef _SIMULATION_ TRACE_EVENT_P4("pdu_len=%d,rest_of_pdu=%d,rem_pdu_bound=%d,last_pdu_bound=%d", sdu_len, rest_of_pdu, rem_pdu_bound, last_pdu_bound ); #endif /* #ifdef _SIMULATION_ */ } grlc_data->ru.pdu_cnt = grlc_data->ru.pdu_rem+grlc_data->ru.pdu_sent; grlc_data->ru.pdu_boundaries = rem_pdu_bound; #ifdef _SIMULATION_ TRACE_EVENT_P4("pdu_cnt=%d,pdu_sent=%d,pdu_rem=%d,needed pdu_boundaries=%d", grlc_data->ru.pdu_cnt, grlc_data->ru.pdu_sent, grlc_data->ru.pdu_rem, grlc_data->ru.pdu_boundaries ); #endif /* #ifdef _SIMULATION_ */ grlc_data->tbf_ctrl[grlc_data->ul_index].pdu_cnt = grlc_data->ru.pdu_cnt; return result; } /* ru_recalc_rlc_oct_cnt() */ /* +------------------------------------------------------------------------------ | Function : ru_get_next_sdu +------------------------------------------------------------------------------ | Description : The function ru_get_next_sdu() gets the next GRLC_DATA_REQ from | the queue. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_get_next_sdu ( void ) { TRACE_FUNCTION( "ru_get_next_sdu" ); grlc_data->ru.pdu_rem--; grlc_data->ru.pdu_sent++; grlc_data->prim_queue[grlc_data->ru.active_prim].last_bsn = grlc_data->ru.vs; if((grlc_data->prim_queue[grlc_data->ru.next_prim].start_new_tbf EQ 0) AND grlc_data->ru.next_prim NEQ 0xFF) { grlc_data->ru.active_prim = grlc_data->prim_queue[grlc_data->ru.active_prim].next; grlc_data->ru.sdu_len = grlc_data->prim_queue[grlc_data->ru.active_prim].prim_ptr->sdu.l_buf/8; grlc_data->ru.sdu_off = grlc_data->prim_queue[grlc_data->ru.active_prim].prim_ptr->sdu.o_buf/8; grlc_data->prim_queue[grlc_data->ru.active_prim].rlc_status = TRUE; grlc_data->ru.next_prim = grlc_data->prim_queue[grlc_data->ru.active_prim].next; } else { grlc_data->ru.sdu_len = 0; grlc_data->ru.sdu_off = 0; } #ifdef _SIMULATION_ TRACE_EVENT_P3("pdu_cnt=%d,pdu_sent=%d,pdu_rem=%d", grlc_data->ru.pdu_cnt, grlc_data->ru.pdu_sent, grlc_data->ru.pdu_rem ); #endif /* #ifdef _SIMULATION_ */ } /* ru_get_next_sdu() */ /* +------------------------------------------------------------------------------ | Function : ru_calc_rlc_data_size +------------------------------------------------------------------------------ | Description : The function ru_calc_rlc_data_size() calculates the Data size of | an RLC data block without header and TLLI. The size is described | in bytes. | | Parameters : cs_type_i - Coding scheme, determines the size of an RLC data block | +------------------------------------------------------------------------------ */ GLOBAL USHORT ru_calc_rlc_data_size ( T_CODING_SCHEME cs_type_i, UBYTE ti_bit_i ) { USHORT result=0; UBYTE tlli_size; TRACE_FUNCTION( "ru_calc_rlc_data_size" ); /* * check if tlli must be included in RLC data blocks */ if (ti_bit_i EQ 0) tlli_size = 0; else { tlli_size = TLLI_SIZE; if(!(grlc_data->ru.tlli_cs_type)) cs_type_i = CS_1; #ifdef REL99 if(grlc_data->pfi_support) { tlli_size++; } #endif } switch( cs_type_i) { 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: if (!result) { TRACE_EVENT_P2("Unknown coding scheme, tsize=%d, t_cs=%d", tlli_size, grlc_data->ru.tlli_cs_type); result = 20; /* Going by CS1 coding scheme by default */ } break; } result -= tlli_size; return result; } /* ru_calc_rlc_data_size() */ /* +------------------------------------------------------------------------------ | Function : ru_set_block_status +------------------------------------------------------------------------------ | Description : The function ru_set_block_status() sets the block status. | | Parameters : cs_type_i - Coding scheme, determines the block status | +------------------------------------------------------------------------------ */ GLOBAL USHORT ru_set_block_status ( T_CODING_SCHEME cs_type_i ) { USHORT result=0; TRACE_FUNCTION( "ru_set_block_status" ); if(!(grlc_data->ru.tlli_cs_type) AND grlc_data->ru.ti) cs_type_i = CS_1; switch( cs_type_i) { case CS_1: result = 2; break; case CS_2: result = 4; break; case CS_3: result = 5; break; case CS_4: result = 6; break; default: TRACE_EVENT_P3("Unknown CS cstype=%d t_cs=%d, ti=%d",cs_type_i, grlc_data->ru.tlli_cs_type, grlc_data->ru.ti); break; } return result; } /* ru_set_block_status() */ /* +------------------------------------------------------------------------------ | Function : ru_get_cs_type +------------------------------------------------------------------------------ | Description : The function ru_get_cs_type() returns the coding scheme | for the requeseted block status. | | Parameters : bs_i - requested block status | +------------------------------------------------------------------------------ */ GLOBAL T_CODING_SCHEME ru_get_cs_type ( USHORT bs_i ) { T_CODING_SCHEME result= CS_ZERO; ; TRACE_FUNCTION( "ru_get_cs_type" ); switch( bs_i) { case 2: result = CS_1; break; case 4: result = CS_2; break; case 5: result = CS_3; break; case 6: result = CS_4; break; default: TRACE_ERROR("unknown block status"); break; } return result; } /* ru_get_cs_type() */ /* +------------------------------------------------------------------------------ | Function : ru_tbf_init +------------------------------------------------------------------------------ | Description : The function ru_tbf_init() sets the parameters at tbf assignment | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_tbf_init ( void ) { UBYTE i; TRACE_FUNCTION( "ru_tbf_init" ); grlc_data->ru.rlc_mode = grlc_data->uplink_tbf.rlc_mode; grlc_data->ru.nts = grlc_data->uplink_tbf.nts; grlc_data->ru.nts_max = grlc_data->uplink_tbf.nts; grlc_data->ru.va = 0; grlc_data->ul_tn_mask = grlc_data->uplink_tbf.ts_mask; #if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH grlc_data->ru.tbf_re_est = FALSE; #endif /* * initate l1 queue parameters */ grlc_data->ru.write_pos_index = 0; for(i=0; i<MAX_UL_TN;i++) grlc_data->ru.ul_data[i].block_status = 0; if(grlc_data->ru.rlc_mode EQ CGRLC_RLC_MODE_ACK) { /* * parameters only used in acknowledged mode */ grlc_data->ru.bsn_ret = 0; grlc_data->ru.last_si_block = 0; grlc_data->ru.N3104_MAX = 3 * (grlc_data->uplink_tbf.bs_cv_max + 3 ) * grlc_data->ru.nts_max; grlc_data->ru.nr_nacked_blks = 0; grlc_data->ru.ti = grlc_data->uplink_tbf.ti; } else if(grlc_data->ru.rlc_mode EQ CGRLC_RLC_MODE_UACK) { /* * parameters only used in unacknowledged mode */ grlc_data->ru.count_cv_0 = 0; /* * tlli is not send within data blocks */ grlc_data->ru.ti = 0; } /* * read the first pdu */ grlc_data->ru.active_prim = grlc_data->prim_start_tbf; grlc_data->prim_queue[grlc_data->prim_start_tbf].previous = 0xFF; grlc_data->ru.next_prim = grlc_data->prim_queue[grlc_data->ru.active_prim].next; grlc_data->prim_queue[grlc_data->prim_start_tbf].cv_status = FALSE; grlc_data->prim_queue[grlc_data->prim_start_tbf].last_bsn = 0xFF; grlc_data->ru.vs = 0; grlc_data->ru.cv = 55; /* * USHORT */ grlc_data->ru.sdu_len = grlc_data->prim_queue[grlc_data->ru.active_prim].prim_ptr->sdu.l_buf/8; grlc_data->ru.sdu_off = grlc_data->prim_queue[grlc_data->ru.active_prim].prim_ptr->sdu.o_buf/8; grlc_data->prim_queue[grlc_data->ru.active_prim].rlc_status = TRUE; grlc_data->ru.pdu_sent = 0; grlc_data->ru.cnt_ts = 0; /* * ULONG */ grlc_data->missed_poll_fn = 1; /* * BOOL */ grlc_data->ru.tlli_cs_type = grlc_data->uplink_tbf.tlli_cs_type; grlc_data->ru.cd_active = FALSE; grlc_data->ru.reorg_l1_needed = FALSE; grlc_data->ru.v_next_tbf_params = FALSE; grlc_data->ul_tfi_changed = FALSE; grlc_data->ru.release_tbf = FALSE; /* * Type */ grlc_data->ru.cs_type = grlc_data->uplink_tbf.cs_type; grlc_data->ru.last_bsn = LAST_BSN_NOT_BULIT; /* * struct */ if(grlc_data->uplink_tbf.mac_mode EQ CGRLC_MAC_MODE_DA) { /* * Start t3164, when starting time is elapsed. * Only if contention resolution is needed and not fixed alloc is used. */ grlc_data->ru.first_usf = TRUE; } grlc_data->ru.rlc_data_size = ru_calc_rlc_data_size(grlc_data->ru.cs_type, grlc_data->ru.ti); grlc_data->ru.block_status = ru_set_block_status(grlc_data->ru.cs_type); /* * handle close ended TBF */ if (grlc_data->uplink_tbf.rlc_db_granted ) { ULONG rlc_oct_cnt ; UBYTE next = grlc_data->prim_queue[grlc_data->prim_start_tbf].next; rlc_oct_cnt = (grlc_data->prim_queue[grlc_data->prim_start_tbf].prim_ptr->sdu.l_buf/8)+1; grlc_data->uplink_tbf.rlc_db_granted *= grlc_data->ru.rlc_data_size; while( (next < PRIM_QUEUE_SIZE) AND (!grlc_data->prim_queue[next].start_new_tbf) AND ((rlc_oct_cnt+(grlc_data->prim_queue[next].prim_ptr->sdu.l_buf/8)+1) < grlc_data->uplink_tbf.rlc_db_granted)) { rlc_oct_cnt += (grlc_data->prim_queue[next].prim_ptr->sdu.l_buf/8)+1; next = grlc_data->prim_queue[next].next; } if(next < PRIM_QUEUE_SIZE) grlc_data->prim_queue[next].start_new_tbf = 1; TRACE_EVENT_P4("close ended TBF: rlc_g=%ld rlc_oct =%ld data_size=%d next=%d" ,grlc_data->uplink_tbf.rlc_db_granted ,rlc_oct_cnt ,grlc_data->ru.rlc_data_size ,next); } grlc_data->ru.rlc_octet_cnt = ru_recalc_rlc_oct_cnt(); /*rlc data size needed*/ grlc_data->ru.pl_retrans_current.cnt = 0; /* TRACE PARAMS*/ grlc_data->ul_index = 0; grlc_data->tbf_ctrl[grlc_data->ul_index].tbf_type = TBF_TYPE_UL; grlc_data->tbf_ctrl[grlc_data->ul_index].tfi = grlc_data->ul_tfi; grlc_data->tbf_ctrl[grlc_data->ul_index].rlc_oct_cnt = 0; grlc_data->tbf_ctrl[grlc_data->ul_index].ret_bsn = 0; grlc_data->tbf_ctrl[grlc_data->ul_index].ack_cnt = 0; grlc_data->tbf_ctrl[grlc_data->ul_index].fbi = 0; } /* ru_tbf_init() */ /* +------------------------------------------------------------------------------ | Function : ru_set_T3198 +------------------------------------------------------------------------------ | Description : The function ru_set_T3198() starts the timer T3198 of the rlc | data block with bsn as input parameter. The timer is handled in | BS_CV_MAX block periods. | | Parameters : bsn_i - bsn value of the data block | +------------------------------------------------------------------------------ */ GLOBAL void ru_set_T3198 ( UBYTE bsn_i ) { USHORT block_periods; TRACE_FUNCTION( "ru_set_T3198" ); block_periods = MAXIMUM(1,grlc_data->uplink_tbf.bs_cv_max); /* * set timer T3198 , * the framenumber is set, at which the block is set to negative acknowledged */ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].T3198 = grlc_decode_tbf_start_rel(grlc_data->ul_fn, --block_periods); #ifdef _SIMULATION_ TRACE_EVENT_P4("SET T3198: bsn %d t3198=%ld c_fn=%ld bs_cv_max=%d" ,bsn_i ,grlc_data->ru.rlc_data[bsn_i & WIN_MOD].T3198 ,grlc_data->ul_fn ,grlc_data->uplink_tbf.bs_cv_max); #endif } /* ru_set_T3198() */ /* +------------------------------------------------------------------------------ | Function : ru_send_mac_data_req +------------------------------------------------------------------------------ | Description : The function ru_send_mac_data_req() sends the data block with | bsn_i. The claculated block is matched in the PL buffer | (and MAC_DATA_REQ primitive, if SIMULATION is defined). | | Parameters : bsn_i - bsn value of the next to sent data block | +------------------------------------------------------------------------------ */ GLOBAL void ru_send_mac_data_req ( UBYTE bsn_i ) { UBYTE li_cnt; UBYTE data_cnt; UBYTE i; USHORT l_tlli; UBYTE len; USHORT off; UBYTE index; UBYTE *ptr_temp; TRACE_FUNCTION( "ru_send_mac_data_req" ); #ifdef _SIMULATION_ TRACE_EVENT_P2("BSN=%d mac_header=%x ",bsn_i, grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.mac); #endif /* #ifdef _SIMULATION_ */ { memset(&grlc_data->ru.ul_data[grlc_data->ru.write_pos_index], 0, sizeof(T_ul_data)); grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status = grlc_data->ru.rlc_data[bsn_i & WIN_MOD].block_status; ptr_temp = (UBYTE *) (grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].ul_block); /* * set MAC Header */ ptr_temp[0] = grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.mac; ptr_temp[1] = (grlc_data->ul_tfi << 1 | grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.ti); ptr_temp[2] = (bsn_i << 1 | grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.e_bit); /*lint !e415*/ /* * set Length Indicator field(s) if present */ li_cnt = grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_cnt; for(i=3; i<(3+li_cnt);i++) ptr_temp[i] = grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_me[i-3]; /*lint !e661 !e662*/ /* * set TLLI field, if present */ if(grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.ti) { grlc_set_tlli( &l_tlli, &off, &(ptr_temp[3+li_cnt]), grlc_data->uplink_tbf.tlli ); l_tlli /= 8; /* handled in bytes */ #ifdef REL99 if (grlc_data->pfi_support) { ptr_temp[1] |= 0x40; ptr_temp[3+li_cnt+l_tlli] =(grlc_data->pfi_value << 1) | 0x01;/*04.60 7.1.2.6(initial pfi)*/ /*E bit = 1*/ l_tlli++; } #endif } else l_tlli = 0; /* * copy LLC DATA */ index = 0; data_cnt = grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data_cnt; for(i=0;i<data_cnt;i++) { len = grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[i].l_buf / 8; off = grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[i].o_buf / 8; if(!grlc_test_mode_active()) { /* * get regular data */ memcpy(&(ptr_temp[3+li_cnt+l_tlli+index]), (grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[i].ptr_data->buf + off), len); /*lint !e797*/ } else { /* * test mode active, get test data */ if(grlc_data->testmode.mode EQ CGRLC_TEST_RANDOM) { /* * CGRLC_TEST_RANDOM */ if (!grlc_data->testmode.no_data_calculation) { /* * First call in this block */ grlc_prbs(COMPUTE_DATA, len, grlc_data->testmode.ptr_test_data); grlc_data->testmode.no_data_calculation = 1; } if (grlc_data->ru.nts EQ 1) { /* * this block is finished, allow prbs data calculation aigain */ grlc_data->testmode.no_data_calculation = 0; } /* * copy the prbs in */ memcpy(&(ptr_temp[3+li_cnt+l_tlli+index]), grlc_data->testmode.ptr_test_data, len); /*lint !e797*/ } else { /* * CGRLC_LOOP */ /* * If the downlink TBF is established on more than one timeslot, the MS shall transmit in * the second uplink timeslot (if present) RLC/MAC blocks received on the second downlink * timeslot, and shall transmit in the third uplink timeslot (if present) RLC/MAC blocks * received in the third downlink timeslot and so on. * It is assumed that while transmitting L1 will transmit data blocks in the sequence * in which it has received blocks from GRLC. */ if (grlc_data->downlink_tbf.nts > 1) { if (grlc_data->ru.write_pos_index EQ 0) { memcpy(&(ptr_temp[3+li_cnt+l_tlli+index]),grlc_data->testmode.rec_data[0].payload,len); TRACE_EVENT_P4("bsn =%d ready for send, cs_type=%ld, e_bit=%d, tn=%d" ,bsn_i ,grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status ,grlc_data->testmode.rec_data[0].e_bit ,grlc_data->ru.write_pos_index); } else { memcpy(&(ptr_temp[3+li_cnt+l_tlli+index]),grlc_data->testmode.rec_data[1].payload,len); TRACE_EVENT_P4("bsn =%d ready for send, cs_type=%ld, e_bit=%d, tn=%d" ,bsn_i ,grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status ,grlc_data->testmode.rec_data[1].e_bit ,grlc_data->ru.write_pos_index); } } else { memcpy(&(ptr_temp[3+li_cnt+l_tlli+index]),grlc_data->testmode.rec_data[0].payload,len); TRACE_EVENT_P3("bsn =%d ready for send, cs_type=%ld, e_bit=%d" ,bsn_i ,grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status ,grlc_data->testmode.rec_data[0].e_bit); } } } index += len; } if((grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.mac & 0x3C) EQ 0) /* countdown value is equal 0*/ { /* * fill rest of last block with 2B */ USHORT rlc_data_size; rlc_data_size = ru_calc_rlc_data_size( ru_get_cs_type(grlc_data->ru.rlc_data[bsn_i & WIN_MOD].block_status) , grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.ti); len = rlc_data_size-index-li_cnt; memset(&(ptr_temp[3+li_cnt+l_tlli+index]), 0x2B, len); /*lint !e797*/ } #ifdef _SIMULATION_ { PALLOC(mac_data_req,MAC_DATA_REQ); memset(&(mac_data_req->ul_data), 0, sizeof(T_ul_data)); memcpy(&(mac_data_req->ul_data), &(grlc_data->ru.ul_data[grlc_data->ru.write_pos_index]), sizeof(T_ul_data)); /*lint !e797*/ PSEND(hCommL1,mac_data_req); } TRACE_EVENT_P1("wpi %d",grlc_data->ru.write_pos_index); #else /* #ifdef _SIMULATION_ */ { TRACE_MEMORY_PRIM ( hCommGRLC, hCommL1, MAC_DATA_REQ, &grlc_data->ru.ul_data[grlc_data->ru.write_pos_index], sizeof(T_ul_data) ); } #endif /* #ifdef _SIMULATION_ */ grlc_data->ru.write_pos_index++; /* * indicates the PL, there is no more block */ grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status = 0; } grlc_data->ru.pl_retrans_current.blk[grlc_data->ru.pl_retrans_current.cnt] = bsn_i; grlc_data->ru.pl_retrans_current.cnt++; grlc_data->ru.nts--; grlc_data->ru.vb[bsn_i & WIN_MOD] = VB_PENDING_ACK; } /* ru_send_mac_data_req() */ /* +------------------------------------------------------------------------------ | Function : ru_set_prim_queue +------------------------------------------------------------------------------ | Description : The function ru_set_prim_queue() updates the primitive queue. | If the countdown procedure is started, all LLC PDUs which belongs | to the current tbf are signed with cv_status as true. In this case | these LLC PDUs can´t reorginized an more LLC PDU can sent during | his TBF. Additionally received LLC PDUs are sent in a new TBF. | If the countdown procedure is stopped (i.e. change of cpding | scheme) then this functions resets the cv_status to False. | | Parameters : cd_state_i - if true, the countdown procedue is started, else | it is stopped | +------------------------------------------------------------------------------ */ GLOBAL void ru_set_prim_queue ( BOOL cd_state_i ) { UBYTE next; TRACE_FUNCTION( "ru_set_prim_queue" ); next = grlc_data->ru.next_prim; grlc_data->prim_queue[grlc_data->ru.active_prim].cv_status = cd_state_i; while( (grlc_data->prim_queue[next].start_new_tbf EQ 0) AND (next NEQ 0xFF) ) { grlc_data->prim_queue[next].cv_status = cd_state_i; next = grlc_data->prim_queue[next].next; } } /* ru_set_prim_queue() */ /* +------------------------------------------------------------------------------ | Function : ru_countdown_procedure +------------------------------------------------------------------------------ | Description : The function ru_countdown_procedure() calculates the countdown | value. After Contention resoultion is succesfully completed or | at changing of the Coding scheme(indicateded in packet | uplink ack/nack or packet timeslot reconfigure), the countdown | value must be recalculated. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL UBYTE ru_countdown_procedure ( UBYTE ret_blocks ) { USHORT x; UBYTE result; TRACE_FUNCTION( "ru_countdown_procedure" ); /* * ret_blocks is the number of blocks which has to retransmit * formular for cv calculation: x = round((TBC-bsn´-1)/nts) * here tbc = (TBC-bsn) so that * x = round((tbc-1)/nts) * nr of pdu bundaries is also considered for calculating tbc */ #ifdef _SIMULATION_ TRACE_EVENT_P3("bs_cv_max=%d rlc_oct_cnt=%d data_size=%d",grlc_data->uplink_tbf.bs_cv_max,grlc_data->ru.rlc_octet_cnt,grlc_data->ru.rlc_data_size); #endif /* #ifdef _SIMULATION_ */ if(grlc_data->testmode.mode EQ CGRLC_LOOP) { TRACE_EVENT("testmode B: cv value=15"); return (15); } grlc_data->ru.tbc = (grlc_data->ru.rlc_octet_cnt+grlc_data->ru.pdu_boundaries) / grlc_data->ru.rlc_data_size; if( (grlc_data->ru.rlc_octet_cnt+grlc_data->ru.pdu_boundaries) % grlc_data->ru.rlc_data_size) /*round upwards*/ grlc_data->ru.tbc++; x = (grlc_data->ru.tbc -1 + ret_blocks) / grlc_data->ru.nts_max; if( (grlc_data->ru.tbc -1 + ret_blocks ) % grlc_data->ru.nts_max) /*round upwards*/ x++; if(x > grlc_data->uplink_tbf.bs_cv_max) { result = 15; if(grlc_data->ru.cd_active) { grlc_data->ru.cd_active = FALSE; ru_set_prim_queue(grlc_data->ru.cd_active); } } else { result = (UBYTE)x; if(!grlc_data->ru.cd_active AND ((grlc_data->ru.state NEQ RU_WAIT_FOR_FIRST_CALL_ACK) OR (grlc_data->ru.state NEQ RU_WAIT_FOR_FIRST_CALL_UACK))) { grlc_data->ru.cd_active = TRUE; ru_set_prim_queue(grlc_data->ru.cd_active); } } return result; } /* ru_countdown_procedure() */ /* +------------------------------------------------------------------------------ | Function : ru_update_vb +------------------------------------------------------------------------------ | Description : The function ru_update_vb() refreshs the VB array field after | receiving a packet uplink ack/nack. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_update_vb ( void ) { MCAST(d_ul_ack,D_GRLC_UL_ACK); UBYTE bsn, ssn, i; TRACE_FUNCTION( "ru_update_vb" ); ssn = d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.ssn; /* * Check if ssn is valid */ if(!ru_within_window(ssn,grlc_data->ru.vs,grlc_data->ru.va)) { TRACE_EVENT_P4( "SSN OUTSIDE WINDOW: ssn=%d, vs=%d, va=%d f_ack_ind=%d", ssn, grlc_data->ru.vs, grlc_data->ru.va, d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.f_ack_ind); return; } grlc_data->ru.nr_nacked_blks = 0; for(i = 1; i <= WIN_SIZE; i++) { bsn = (ssn - i) & 0x7F; /*mod 128*/ if(d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.rbb[WIN_SIZE-i]) { if(grlc_data->ru.vb[bsn & WIN_MOD] NEQ VB_ACKED) { grlc_data->ru.vb[bsn & WIN_MOD] = VB_ACKED; } } else if(grlc_check_if_tbf_start_is_elapsed ( grlc_data->ru.rlc_data[bsn & WIN_MOD].T3198, grlc_data->ul_fn)) { /* * timeout T3198 */ grlc_data->ru.vb[bsn & WIN_MOD] = VB_NACKED; grlc_data->ru.nr_nacked_blks++; } else { TRACE_EVENT_P3("BSN =%d not acked. T3198=%ld not expired (c_fn=%ld). vb not modified" ,bsn ,grlc_data->ru.rlc_data[bsn & WIN_MOD].T3198 ,grlc_data->ul_fn); } if (bsn EQ grlc_data->ru.va) i = WIN_SIZE+1; /* break cobdition*/ } } /* ru_update_vb() */ /* +------------------------------------------------------------------------------ | Function : ru_calc_rlc_data_block +------------------------------------------------------------------------------ | Description : The funcion ru_calc_rlc_data_block() builds a complete RLC | data block. | | Parameters : bsn_i - bsn value of the calculated RLC data block | +------------------------------------------------------------------------------ */ GLOBAL void ru_calc_rlc_data_block ( UBYTE bsn_i ) { USHORT rlc_len; UBYTE li_cnt, data_cnt; TRACE_FUNCTION( "ru_calc_rlc_data_block" ); /* * calculate the countdown value, no retransmission */ grlc_data->ru.cv = ru_countdown_procedure(0); grlc_data->ru.rlc_data[bsn_i & WIN_MOD].block_status = grlc_data->ru.block_status; /* * set MAC header */ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.mac = (grlc_data->ru.cv << 2 | grlc_data->r_bit ); /* * set RLC header values */ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.ti = grlc_data->ru.ti; /* * data handling */ rlc_len = grlc_data->ru.rlc_data_size; data_cnt = 0; li_cnt = 0; if(grlc_data->testmode.mode EQ CGRLC_LOOP) { grlc_data->ru.sdu_len = 7777; /* random value */ grlc_data->ru.sdu_off = 0; rlc_len = 50; grlc_data->ru.rlc_octet_cnt = 7777; /* to be in line with sdu_len*/ TRACE_EVENT("testmode B: get data from received downlink"); } while ( (grlc_data->ru.sdu_len < rlc_len) AND (grlc_data->ru.sdu_len > 0) ) { /* * end of pdu in block reached */ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_me[li_cnt]= (UBYTE) grlc_data->ru.sdu_len; grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_me[li_cnt] <<= 2; grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].ptr_data = &(grlc_data->prim_queue[grlc_data->ru.active_prim].prim_ptr->sdu); grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].l_buf = grlc_data->ru.sdu_len * 8; grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].o_buf = grlc_data->ru.sdu_off * 8; rlc_len -= grlc_data->ru.sdu_len + 1; grlc_data->ru.rlc_octet_cnt -= grlc_data->ru.sdu_len; grlc_data->ru.sdu_len -= grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].l_buf/8; grlc_data->ru.sdu_off += grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].l_buf/8; ru_get_next_sdu(); if((grlc_data->ru.sdu_len > 0) AND rlc_len) { /* * one more sdu in queue */ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_me[li_cnt] |= 0x02; } else { /* * no more sdu in queue */ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_me[li_cnt] |= 0x01; } data_cnt++; li_cnt++; if(li_cnt > NR_OF_PDUS_PER_RLCMAC_BLOCK) { TRACE_EVENT_P2("li_cnt=%d NR_OF_PDUS_PER_RLCMAC_BLOCK=%d",li_cnt,NR_OF_PDUS_PER_RLCMAC_BLOCK); TRACE_ERROR("ru li_cnt bigger than RD_LI_CNT_MAX (=8)"); TRACE_ASSERT( li_cnt > NR_OF_PDUS_PER_RLCMAC_BLOCK ); return; } } if((grlc_data->ru.sdu_len EQ rlc_len) AND (grlc_data->ru.sdu_len > 0) AND (grlc_data->ru.cv EQ 0)) { /* * end of pdu; rest of pdu match exactly into the rest of a rlc data block, last uplink block */ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].ptr_data = &(grlc_data->prim_queue[grlc_data->ru.active_prim].prim_ptr->sdu); /*lint !e661*/ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].l_buf = grlc_data->ru.sdu_len *8; /*lint !e661*/ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].o_buf = grlc_data->ru.sdu_off *8; /*lint !e661*/ data_cnt++; grlc_data->ru.rlc_octet_cnt -= rlc_len; ru_get_next_sdu(); } else if((grlc_data->ru.sdu_len EQ rlc_len) AND (grlc_data->ru.sdu_len > 0)) { /* * end of pdu; rest of pdu match exactly into the rest of a rlc data block, * split into two blocks, len set to zero, indicates that the end of pdu is not reached */ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_me[li_cnt] = 0x01; /*lint !e661*/ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].ptr_data = &(grlc_data->prim_queue[grlc_data->ru.active_prim].prim_ptr->sdu); /*lint !e661*/ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].l_buf = (grlc_data->ru.sdu_len-1) *8; /*lint !e661*/ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].o_buf = grlc_data->ru.sdu_off *8; /*lint !e661*/ data_cnt++; li_cnt++; rlc_len--; grlc_data->ru.sdu_len -= rlc_len; grlc_data->ru.sdu_off += rlc_len; grlc_data->ru.rlc_octet_cnt -= rlc_len; if(li_cnt > NR_OF_PDUS_PER_RLCMAC_BLOCK) { TRACE_EVENT_P2("li_cnt=%d NR_OF_PDUS_PER_RLCMAC_BLOCK=%d",li_cnt,NR_OF_PDUS_PER_RLCMAC_BLOCK); TRACE_ERROR("ru2 li_cnt bigger than RD_LI_CNT_MAX (=8)"); TRACE_ASSERT( li_cnt > NR_OF_PDUS_PER_RLCMAC_BLOCK ); return; } } else if( (grlc_data->ru.sdu_len > 0) AND rlc_len) { /* * only a part of the sdu matches into the rlc data block */ if(grlc_data->testmode.mode EQ CGRLC_LOOP) { grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].ptr_data = NULL; /*lint !e661*/ TRACE_EVENT("set data ptr for testmode B to NULL"); } else { grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].ptr_data = &(grlc_data->prim_queue[grlc_data->ru.active_prim].prim_ptr->sdu); /*lint !e661*/ } grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].l_buf = rlc_len * 8; /*lint !e661*/ grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data[li_cnt].o_buf = grlc_data->ru.sdu_off * 8; /*lint !e661*/ data_cnt++; grlc_data->ru.sdu_len -= rlc_len; grlc_data->ru.sdu_off += rlc_len; grlc_data->ru.rlc_octet_cnt -= rlc_len; } /* * LI fied parameters are set */ if(grlc_data->testmode.mode EQ CGRLC_LOOP) { grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.e_bit = grlc_data->testmode.rec_data[0].e_bit; } else if(li_cnt) { grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.e_bit = 0; grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_me[li_cnt-1] |= 0x01; grlc_data->ru.pdu_boundaries -= li_cnt; #ifdef _SIMULATION_ TRACE_EVENT_P2("li_cnt=%d,remaining pdu boundaries=%d", li_cnt, grlc_data->ru.pdu_boundaries); #endif /* #ifdef _SIMULATION_ */ } else { grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.e_bit = 1; } grlc_data->ru.rlc_data[bsn_i & WIN_MOD].header.li_cnt = li_cnt; grlc_data->ru.rlc_data[bsn_i & WIN_MOD].data_cnt = data_cnt; } /* ru_calc_rlc_data_block() */ /* +------------------------------------------------------------------------------ | Function : ru_handle_n3102 +------------------------------------------------------------------------------ | Description : The function ru_handle_n3102() handles the counter N3102. | If the input parameter ia PAN_INC, then the counter is | incremented. If the input parameter ia PAN_DEC, then the | counter is decremented. | | Parameters : pan_cnt_i - determines, if the counter is either in- or | decremented | +------------------------------------------------------------------------------ */ GLOBAL void ru_handle_n3102 ( T_PAN_CNT pan_cnt_i ) { TRACE_FUNCTION( "ru_handle_n3102" ); if((grlc_data->N3102 NEQ 0xFF) AND grlc_data->pan_struct.inc AND grlc_data->pan_struct.dec AND grlc_data->pan_struct.pmax) { switch( pan_cnt_i ) { case PAN_INC: grlc_data->N3102 += grlc_data->pan_struct.inc; grlc_data->N3102 = MINIMUM(grlc_data->N3102,grlc_data->pan_struct.pmax); /*TRACE_EVENT_P4( "INC N3102: inc=%d, dec=%d, pan_max=%d n3102=%d", grlc_data->pan_struct.inc, grlc_data->pan_struct.dec, pgrlc_data->pan_struct.pmax, grlc_data->N3102 );*/ break; case PAN_DEC: if( grlc_data->N3102 > grlc_data->pan_struct.dec ) { grlc_data->N3102 -= grlc_data->pan_struct.dec; TRACE_EVENT_P4( "DEC1 N3102: inc=%d, dec=%d, pan_max=%d n3102=%d", grlc_data->pan_struct.inc, grlc_data->pan_struct.dec, grlc_data->pan_struct.pmax, grlc_data->N3102 ); sig_ru_tm_error_ra(); } else { grlc_data->N3102 = 0; TRACE_EVENT_P4( "DEC2 N3102: inc=%d, dec=%d, pan_max=%d n3102=%d", grlc_data->pan_struct.inc, grlc_data->pan_struct.dec, grlc_data->pan_struct.pmax, grlc_data->N3102); sig_ru_tm_error_ra(); } break; default: TRACE_ERROR("unknown type for pan_cnt_i"); break; } } else if(pan_cnt_i EQ PAN_DEC) { TRACE_EVENT( "IGNORE N3102" ); sig_ru_tm_error_ra(); } } /* ru_handle_n3102() */ /* +------------------------------------------------------------------------------ | Function : ru_calc_va +------------------------------------------------------------------------------ | Description : The function ru_calc_va() claculates the block, that was | negatively acknowledged and must be retransmitted in the next | uplink block. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL UBYTE ru_calc_va ( void ) { UBYTE result; TRACE_FUNCTION( "ru_calc_va" ); result = (grlc_data->ru.va) & 0x7F /*mod 128*/; while( (grlc_data->ru.vb[result & WIN_MOD] EQ VB_ACKED) AND (result NEQ grlc_data->ru.vs)) { result = (result+1) & 0x7F /*mod 128*/; } return result; } /* ru_calc_va() */ /* +------------------------------------------------------------------------------ | Function : ru_set_next_bsn_ret() +------------------------------------------------------------------------------ | Description : The function ru_set_next_bsn_ret sets the next valid bsn, | which shall be transmitted as next retransmission | | Parameters : - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL UBYTE ru_set_next_bsn_ret ( void) { UBYTE new_bsn_ret; TRACE_FUNCTION( "ru_set_next_bsn_ret" ); new_bsn_ret = (grlc_data->ru.bsn_ret+1) & 0x7F; while( (grlc_data->ru.vb[new_bsn_ret & WIN_MOD] NEQ VB_PENDING_ACK) AND (grlc_data->ru.vb[new_bsn_ret & WIN_MOD] NEQ VB_NACKED) AND new_bsn_ret NEQ grlc_data->ru.vs ) { new_bsn_ret = (new_bsn_ret+1) & 0x7F; } if( new_bsn_ret EQ grlc_data->ru.vs ) { grlc_data->ru.nr_nacked_blks = 0 ; new_bsn_ret = grlc_data->ru.va; } return new_bsn_ret; } /* ru_set_next_bsn_ret() */ /* +------------------------------------------------------------------------------ | Function : ru_ret_bsn +------------------------------------------------------------------------------ | Description : The function ru_ret_bsn() is called in RU_REL_ACK. In this state | all RLC data blocks are transmitted, but not acknowledged. If | more uplink PDCHs are available(i.e. the PL reads valid USF | flags), then the blocks which currently where not acked are | retransmitted. The bsn value of the next block is controled by | bsn_ret. | | Parameters : dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_ret_bsn ( void ) { TRACE_FUNCTION( "ru_ret_bsn" ); /* TRACE_EVENT_P3("BSN RET: bsn=%d, cv=%d vb=%d" ,grlc_data->ru.bsn_ret ,grlc_data->ru.rlc_data[grlc_data->ru.bsn_ret & WIN_MOD].header.cv ,grlc_data->ru.vb[grlc_data->ru.bsn_ret & WIN_MOD]); */ ru_send_mac_data_req(grlc_data->ru.bsn_ret); grlc_data->ru.bsn_ret = ru_set_next_bsn_ret(); } /* ru_ret_bsn() */ /* +------------------------------------------------------------------------------ | Function : ru_change_of_cs +------------------------------------------------------------------------------ | Description : The function ru_change_of_cs() handles the change of the coding | scheme. Folling values must be recalculated. | 1. rlc_data_len | 2. rlc_octet_cnt | | Parameters : cs_type_i - new coding scheme | +------------------------------------------------------------------------------ */ GLOBAL void ru_change_of_cs ( T_CODING_SCHEME cs_type_i ) { TRACE_FUNCTION( "ru_change_of_cs" ); grlc_data->ru.rlc_data_size = ru_calc_rlc_data_size(cs_type_i,grlc_data->ru.ti); grlc_data->ru.block_status = ru_set_block_status(grlc_data->ru.cs_type); if(grlc_data->ru.last_bsn NEQ LAST_BSN_IS_SENT) { grlc_data->ru.rlc_octet_cnt = ru_recalc_rlc_oct_cnt(); grlc_data->ru.reorg_l1_needed = TRUE; } else { TRACE_EVENT_P3("No REORG dueto CS change requried: rlc_cnt=%ld l_bsn=%d cv=%d" ,grlc_data->ru.rlc_octet_cnt ,grlc_data->ru.last_bsn ,grlc_data->ru.cv); } } /* ru_change_of_cs() */ /* +------------------------------------------------------------------------------ | Function : ru_contention_resolution +------------------------------------------------------------------------------ | Description : The function ru_contention_resolution() checks at one phase | access after receiving a packet uplink ack/nack message the | contention resolution TLLI. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL BOOL ru_contention_resolution ( void ) { MCAST(d_ul_ack,D_GRLC_UL_ACK); BOOL result = FALSE; TRACE_FUNCTION( "ru_contention_resolution" ); if((grlc_data->ru.ti) AND (d_ul_ack->gprs_ul_ack_nack_info.v_cr_tlli) ) { ULONG tlli; /* * TLLI received and Contention resolution not yet processed */ tlli = grlc_buffer2ulong( &d_ul_ack->gprs_ul_ack_nack_info.cr_tlli ); if(tlli EQ grlc_data->uplink_tbf.tlli) result = TRUE; grlc_data->ru.N3104 = 0; vsi_t_stop(GRLC_handle,T3166); if(result) { /* * correct TLLI received, contention resolution succesful */ grlc_data->ru.ti = 0; grlc_data->ru.rlc_data_size = ru_calc_rlc_data_size(grlc_data->ru.cs_type,grlc_data->ru.ti); grlc_data->ru.block_status = ru_set_block_status(grlc_data->ru.cs_type); /* * needed, because nr of pdu boundaries could be change */ grlc_data->ru.rlc_octet_cnt = ru_recalc_rlc_oct_cnt(); sig_ru_tm_cs(); result = FALSE; grlc_data->ru.reorg_l1_needed = TRUE; } else { /* * wrong TLLI received, contention resolution failed, TBF will be aborted */ result = TRUE; TRACE_ERROR( "TLLI error occured" ); sig_ru_tm_error_ra(); } } else if(grlc_data->ru.ti EQ 0) result = FALSE; return result; } /* ru_contention_resolution() */ /* +------------------------------------------------------------------------------ | Function : ru_delete_prims +------------------------------------------------------------------------------ | Description : The function ru_delete_prims() deletes LLC PDUs from the | primitive queue which are positivlely acknowledged(indirectly | by the highest bsn value in the rrb field included in the | packet uplink ack/nack). | | Parameters : last_bsn_i - all primitives including last_bsn_i are deleted. | +------------------------------------------------------------------------------ */ GLOBAL void ru_delete_prims ( UBYTE last_bsn_i ) { UBYTE cnt=0, prim_type=CGRLC_PRIM_TYPE_OTHER; BOOL all_null_frames = TRUE; TRACE_FUNCTION( "ru_delete_prims" ); /* * check if last_bsn_i is outside window */ while( (grlc_data->prim_start_tbf < PRIM_QUEUE_SIZE_TOTAL) AND (grlc_data->prim_queue[grlc_data->prim_start_tbf].last_bsn NEQ 0xFF) AND (ru_within_window( last_bsn_i, grlc_data->ru.vs, grlc_data->prim_queue[grlc_data->prim_start_tbf].last_bsn))) { cnt++; if( (prim_type NEQ CGRLC_PRIM_TYPE_GMM) AND (grlc_data->prim_queue[grlc_data->prim_start_tbf].prim_ptr->cause EQ GRLC_DTACS_MOBILITY_MANAGEMENT) ) { prim_type = CGRLC_PRIM_TYPE_GMM; } if( (all_null_frames EQ TRUE) AND (grlc_data->prim_queue[grlc_data->prim_start_tbf].prim_ptr->cause NEQ GRLC_DTACS_CELL_NOTIFI_NULL_FRAME) ) { /* This variable is set to FALSE in case there is at least ont not NULL frame */ all_null_frames = FALSE; } sig_ru_tm_prim_delete(); } if(cnt) { if( grlc_data->ready_timer.handling EQ READY_TIMER_HANDLING_ENABLED AND all_null_frames EQ FALSE AND grlc_data->ready_timer.value NEQ CGRLC_STANDBY ) { if (grlc_data->ready_timer.value NEQ CGRLC_DEACTIVATED) { /* The Ready Timer will be restarted in case of at least one not NULL frame and valid value (<>0 and <> 0xFFFFFFFF) */ vsi_t_start(GRLC_handle,T3314, grlc_data->ready_timer.value ); } grlc_enter_ready_state( ); } if( grlc_data->ready_timer.handling EQ READY_TIMER_HANDLING_DISABLED OR ( grlc_data->ready_timer.handling EQ READY_TIMER_HANDLING_ENABLED AND prim_type EQ CGRLC_PRIM_TYPE_GMM ) ) { PALLOC(cgrlc_trigger_ind,CGRLC_TRIGGER_IND); /* T_CGRLC_TRIGGER_IND */ cgrlc_trigger_ind->prim_type = prim_type; PSEND(hCommGMM,cgrlc_trigger_ind); } } #ifdef _SIMULATION_ TRACE_EVENT_P5("%d PRIMS deleted: last_bsn=%d vs=%d prim_start_tbf=%d, prim_cnt=%d ", cnt,last_bsn_i,grlc_data->ru.vs,grlc_data->prim_start_tbf,grlc_data->grlc_data_req_cnt); TRACE_EVENT_P3("pdu_cnt=%d,pdu_sent=%d,pdu_rem=%d", grlc_data->ru.pdu_cnt, grlc_data->ru.pdu_sent, grlc_data->ru.pdu_rem ); #endif /* #ifdef _SIMULATION_ */ } /* ru_delete_prims() */ /* +------------------------------------------------------------------------------ | Function : ru_handle_n3104 +------------------------------------------------------------------------------ | Description : The function ru_handle_n3104() controls the counter N3104. If | the counter reaches it maximum value, then the tbf is released. | The counter is ignored, if the contention resolution is | successfully completed. Evry time at receiption a packet uplink | ack/nack without including TLLI the counter is incremented. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL BOOL ru_handle_n3104 ( void) { UBYTE result = FALSE; TRACE_FUNCTION( "ru_handle_n3104" ); if(grlc_data->ru.ti) { grlc_data->ru.N3104 = (UBYTE)grlc_data->ru.cnt_ts; if(grlc_data->ru.N3104 EQ grlc_data->ru.N3104_MAX) { result = TRUE; vsi_t_stop(GRLC_handle,T3166); } } return result; } /* ru_handle_n3104() */ /* +------------------------------------------------------------------------------ | Function : ru_send_control_block +------------------------------------------------------------------------------ | Description : The function ru_send_control_block() sends a control block | instead of RLC data block | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_send_control_block ( void ) { UBYTE index; TRACE_FUNCTION( "ru_send_control_block" ); #ifdef _SIMULATION_ memset( &grlc_data->ru.ul_data[grlc_data->ru.write_pos_index], 0, sizeof( T_ul_data ) ); #endif /* #ifdef _SIMULATION_ */ grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status = 2; index = tm_cpy_ctrl_blk_to_buffer ( ( UBYTE* )grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].ul_block ); #ifdef _SIMULATION_ { PALLOC(mac_data_req,MAC_DATA_REQ); memset(&(mac_data_req->ul_data), 0, sizeof(T_ul_data)); memcpy(&(mac_data_req->ul_data), &(grlc_data->ru.ul_data[grlc_data->ru.write_pos_index]), sizeof(T_ul_data)); PSEND(hCommL1,mac_data_req); } TRACE_EVENT_P1("wpi %d",grlc_data->ru.write_pos_index); #else /* #ifdef _SIMULATION_ */ { TRACE_MEMORY_PRIM ( hCommGRLC, hCommL1, MAC_DATA_REQ, &grlc_data->ru.ul_data[grlc_data->ru.write_pos_index], sizeof(T_ul_data) ); } #endif /* #ifdef _SIMULATION_ */ { UBYTE* ul_block = ( UBYTE* )grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].ul_block; TRACE_BINDUMP( hCommGRLC, TC_USER4, cl_rlcmac_get_msg_name ( ( UBYTE )( ul_block[1] >> 2 ), RLC_MAC_ROUTE_UL ), ul_block, MAX_L2_FRAME_SIZE ); /*lint !e569*/ } grlc_data->ru.write_pos_index++; grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status = 0; grlc_data->ru.pl_retrans_current.blk[grlc_data->ru.pl_retrans_current.cnt] = index + OFFSET_CTRL_BLOCK_IDX; grlc_data->ru.pl_retrans_current.cnt++; grlc_data->ru.nts--; } /* ru_send_control_block() */ /* +------------------------------------------------------------------------------ | Function : ru_stall_ind +------------------------------------------------------------------------------ | Description : The function ru_stall_ind() handles the stall indication. | If stall indication occurs, the the window is retransmitted if | uplink PDCHs are available. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_stall_ind ( void) { TRACE_FUNCTION( "ru_stall_ind" ); /* set the si bit */ grlc_data->ru.rlc_data[grlc_data->ru.last_si_block & WIN_MOD].header.mac |= 0x02; /* send block with set si bit */ ru_send_mac_data_req(grlc_data->ru.last_si_block); /* reset the si bit */ grlc_data->ru.rlc_data[grlc_data->ru.last_si_block & WIN_MOD].header.mac &= 0xFD; grlc_data->ru.last_si_block = (grlc_data->ru.last_si_block+1) & 0x7F; if(grlc_data->ru.last_si_block EQ grlc_data->ru.vs) grlc_data->ru.last_si_block = grlc_data->ru.va ; } /* ru_stall_ind() */ /* +------------------------------------------------------------------------------ | Function : ru_new_data +------------------------------------------------------------------------------ | Description : The function ru_new_data() calculates the next in sequence data | and transmits it. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_new_data ( void) { TRACE_FUNCTION( "ru_new_data" ); ru_calc_rlc_data_block(grlc_data->ru.vs); ru_send_mac_data_req(grlc_data->ru.vs); grlc_data->ru.rlc_data[grlc_data->ru.vs & WIN_MOD].cnt_pl_trans = 0; /*first try to transmit*/ grlc_data->ru.vs = (grlc_data->ru.vs+1) & 0x7F /*mod 128*/; } /* ru_new_data() */ /* +------------------------------------------------------------------------------ | Function : ru_reorg_l1 +------------------------------------------------------------------------------ | Description : The function ru_reorg_l1() recalculates data blocks which are | passed to l1 but wasn´t sent due to usf only after succesfull | contention resolution or change of coding scheme. | | Parameters : sent_blks_i - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_reorg_l1 ( UBYTE sent_blks_i ) { UBYTE cnt_reog_blks; /* number of reorged blks */ UBYTE reorged_blks = 0; /*counts the number of modified blocks*/ UBYTE i, bsn; TRACE_FUNCTION( "ru_reorg_l1" ); cnt_reog_blks = grlc_data->ru.nts_max - sent_blks_i; for (i=0; i < cnt_reog_blks; i++) { UBYTE index; index = grlc_data->ru.pl_retrans_current.cnt - 1 - i; bsn = grlc_data->ru.pl_retrans_current.blk[index]; if(bsn <= BSN_MAX) { #ifdef _SIMULATION_ TRACE_EVENT_P1("bsn %d",bsn); #endif if(!grlc_data->ru.rlc_data[bsn & WIN_MOD].cnt_pl_trans) {/* not transmitted over physical link */ UBYTE cnt_data_parts; reorged_blks++; grlc_data->ru.vs--; grlc_data->ru.vs = grlc_data->ru.vs & 0x7F; cnt_data_parts = grlc_data->ru.rlc_data[bsn & WIN_MOD].data_cnt - 1; grlc_data->ru.sdu_len += (grlc_data->ru.rlc_data[bsn & WIN_MOD].data[cnt_data_parts].l_buf/8); grlc_data->ru.sdu_off = (grlc_data->ru.rlc_data[bsn & WIN_MOD].data[cnt_data_parts].o_buf/8); grlc_data->ru.rlc_octet_cnt += (grlc_data->ru.rlc_data[bsn & WIN_MOD].data[cnt_data_parts].l_buf/8); if(cnt_data_parts) grlc_data->ru.sdu_len = 0; /* pdu bound in block*/ while(cnt_data_parts--) { grlc_data->ru.sdu_len += (grlc_data->ru.rlc_data[bsn & WIN_MOD].data[cnt_data_parts].l_buf/8); grlc_data->ru.sdu_off = grlc_data->ru.rlc_data[bsn & WIN_MOD].data[cnt_data_parts].o_buf/8; grlc_data->ru.rlc_octet_cnt += (grlc_data->ru.rlc_data[bsn & WIN_MOD].data[cnt_data_parts].l_buf/8); grlc_data->ru.next_prim = grlc_data->ru.active_prim; grlc_data->ru.active_prim = grlc_data->prim_queue[grlc_data->ru.active_prim].previous; grlc_data->prim_queue[grlc_data->ru.active_prim].last_bsn = grlc_data->prim_queue[grlc_data->ru.next_prim].last_bsn; TRACE_EVENT("parts of pdu present"); } /* * handle pdu parametes */ if((grlc_data->ru.rlc_data[bsn & WIN_MOD].header.mac & 0x3C) EQ 0) /* countdown value is equal 0*/ { grlc_data->ru.pdu_rem += grlc_data->ru.rlc_data[bsn & WIN_MOD].data_cnt; grlc_data->ru.pdu_sent -= grlc_data->ru.rlc_data[bsn & WIN_MOD].data_cnt; } else if(grlc_data->ru.rlc_data[bsn & WIN_MOD].header.li_cnt AND ((grlc_data->ru.rlc_data[bsn & WIN_MOD].header.li_me[grlc_data->ru.rlc_data[bsn & WIN_MOD].header.li_cnt-1] & 0xFC) EQ 0)) { grlc_data->ru.pdu_rem += grlc_data->ru.rlc_data[bsn & WIN_MOD].data_cnt; grlc_data->ru.pdu_sent -= grlc_data->ru.rlc_data[bsn & WIN_MOD].data_cnt; } else { grlc_data->ru.pdu_rem += grlc_data->ru.rlc_data[bsn & WIN_MOD].header.li_cnt; grlc_data->ru.pdu_sent -= grlc_data->ru.rlc_data[bsn & WIN_MOD].header.li_cnt; } if(grlc_data->ru.state EQ RU_REL_ACK) { SET_STATE(RU,RU_ACK); } else if(grlc_data->ru.state EQ RU_REL_UACK) { SET_STATE(RU,RU_UACK); } /* * Stop Countdown procedure, if bsn was the first block with CV NEQ 15 */ if(grlc_data->ru.cd_active AND (grlc_data->ru.rlc_data[((--bsn) & 0x7F) & WIN_MOD].header.mac & 0x3C) EQ 15) { TRACE_EVENT_P4("stop CNT DWN during reorg bsn-1 =%d bs_cv_max=%d,ru.cv=%d rlc_oc_ctn=%ld" ,((bsn--) & 0x7F) ,grlc_data->uplink_tbf.bs_cv_max ,grlc_data->ru.cv ,grlc_data->ru.rlc_octet_cnt); grlc_data->ru.cd_active = FALSE; ru_set_prim_queue(grlc_data->ru.cd_active); } } else { /* * block was once transmitted over physical link */ reorged_blks++; /* TRACE_EVENT("block was transmitted over pl link, do not modify"); */ } } else { TRACE_EVENT("CTRL BLK in L1 queue: reorg not needed"); } } if(reorged_blks) { grlc_data->ru.write_pos_index -= reorged_blks; grlc_data->ru.pl_retrans_current.cnt -= reorged_blks; memset(&grlc_data->ru.pl_retrans_current.blk[grlc_data->ru.pl_retrans_current.cnt], 0xFF, reorged_blks); } ru_recalc_rlc_oct_cnt(); } /* ru_reorg_l1() */ /* +------------------------------------------------------------------------------ | Function : ru_del_prim_in_uack_mode +------------------------------------------------------------------------------ | Description : The function ru_del_prim_in_uack_mode() deletes primitvies in | rlc unackknowledged mode | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_del_prim_in_uack_mode ( UBYTE rlc_blocks_sent_i) { UBYTE highest_bsn = BSN_MAX + 1; /* this represents the highest bsn sent on air */ UBYTE counter = 0; TRACE_FUNCTION( "ru_del_prim_in_uack_mode" ); for(counter = rlc_blocks_sent_i;counter > 0;counter--) { highest_bsn = grlc_data->ru.pl_retrans_current.blk[counter-1]; if( highest_bsn < (BSN_MAX + 1) ) { /* data block has been transmitted on air, valid bsn found. */ highest_bsn=(highest_bsn+1) & BSN_MAX; if(grlc_data->ru.cv NEQ 0) { ru_delete_prims(highest_bsn); } else if((grlc_data->ru.cv EQ 0) AND (grlc_data->ru.count_cv_0 EQ 4)) { ru_delete_prims(highest_bsn); } break; } /* if highest_bsn is greater than BSN_MAX then it is a control block. we should check in * next radio block */ } } /* ru_del_prim_in_uack_mode() */ /* +------------------------------------------------------------------------------ | Function : ru_handle_timers +------------------------------------------------------------------------------ | Description : The function ru_handle_timers handles the following timers: | T3164, T3166, T3180, T3182, T3198 | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_handle_timers ( UBYTE rlc_blocks_sent_i) { UBYTE i; TRACE_FUNCTION( "ru_handle_timers" ); /* * start timter T3198, l1 has transmitted a block */ for(i=0 ; i < rlc_blocks_sent_i;i++) { if (grlc_data->ru.pl_retrans_current.blk[i] <= BSN_MAX ) ru_set_T3198(grlc_data->ru.pl_retrans_current.blk[i]); } /* * first usf is read: stop T3164; wait for first ack/nack: start T3166 */ if( rlc_blocks_sent_i AND grlc_data->ru.first_usf) { vsi_t_stop(GRLC_handle,T3164); grlc_data->ru.first_usf = FALSE; grlc_data->t3164_to_cnt = 0; } if(grlc_data->ru.ti AND rlc_blocks_sent_i AND (!grlc_data->ru.cnt_ts)) { /* * Only started in phase access when first data block was sent * in case of fixed allocation, after sending the first rlc data block * T3166 must be started(Wait for the first acknowledge). */ vsi_t_start(GRLC_handle,T3166,T3166_VALUE); } /* * start T3182 if at stall indication or * start T3182 if final data block was sent or * restart T3180 if a data block was sent, only in dynamic allocation */ if (rlc_blocks_sent_i AND grlc_data->uplink_tbf.mac_mode EQ CGRLC_MAC_MODE_DA) { vsi_t_stop(GRLC_handle,T3180); vsi_t_start(GRLC_handle,T3180,T3180_VALUE); } if( grlc_data->ru.last_bsn EQ LAST_BSN_STALL_CONDITION AND (grlc_t_status( T3182 ) EQ 0)) { vsi_t_start(GRLC_handle,T3182,T3182_VALUE); TRACE_EVENT_P6("SI:T3182 is started: vs=%d va=%d dl_fn=%ld rlc_bs=%d bsn[0]=%d bsn[1]=%d" ,grlc_data->ru.vs ,grlc_data->ru.va ,grlc_data->dl_fn ,rlc_blocks_sent_i ,grlc_data->ru.pl_retrans_current.blk[0] ,grlc_data->ru.pl_retrans_current.blk[1]); } else if( (grlc_data->ru.last_bsn EQ LAST_BSN_IS_SENT) AND (grlc_t_status( T3182 ) EQ 0) /* timer is not running */ AND (!grlc_data->ru.nr_nacked_blks)) { vsi_t_start(GRLC_handle,T3182,T3182_VALUE); TRACE_EVENT_P3("T3182 started : vs=%d va=%d last_bsn=%d " ,grlc_data->ru.vs ,grlc_data->ru.va ,grlc_data->ru.last_bsn); } /* else { TRACE_EVENT_P6("NO TIMER START: vs=%d va=%d last_bsn=%d t3182=%ld t3180=%d rlc_blocks_sent_i=%d" ,grlc_data->ru.vs ,grlc_data->ru.va ,grlc_data->ru.last_bsn ,grlc_t_status( T3182 ) ,grlc_t_status( T3180 ) ,rlc_blocks_sent_i); } */ } /* ru_handle_timers() */ /* +------------------------------------------------------------------------------ | Function : ru_handle_nts +------------------------------------------------------------------------------ | Description : The function ru_handle_nts recalutates the parameter | grlc_data->ru.nts in case of layer 1 queue reorganisation | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_handle_nts (UBYTE rlc_blocks_sent_i) { UBYTE i; TRACE_FUNCTION( "ru_handle_nts" ); if( grlc_data->testmode.mode EQ CGRLC_LOOP AND (rlc_blocks_sent_i < grlc_data->ru.nts_max) ) { TRACE_EVENT_P2("TESTMODE B REORG L1: blk_sent = %d nts=nts_max=%d",rlc_blocks_sent_i,grlc_data->ru.nts_max); grlc_data->ru.reorg_l1_needed = TRUE; } grlc_data->ru.nts = rlc_blocks_sent_i; /* * check whether there is a reorganisation of the tansmit queue needed * due to pending control blocks */ if( tm_get_num_ctrl_blck( ) NEQ 0 ) { grlc_data->ru.reorg_l1_needed = TRUE; } if( grlc_data->ru.reorg_l1_needed AND (rlc_blocks_sent_i < grlc_data->ru.nts_max ) AND grlc_data->ru.pl_retrans_current.cnt AND grlc_data->ru.pl_retrans_current.blk[0] NEQ 0xFF) /* dummy blocks in queue*/ { ru_reorg_l1(rlc_blocks_sent_i); grlc_data->ru.nts = grlc_data->ru.nts_max; } else if (!grlc_data->ru.pl_retrans_current.cnt) { /* no data block in queue, put max nuber in queue*/ grlc_data->ru.nts = grlc_data->ru.nts_max; } /********otherwise check if a positive acknowledged block is queue**********/ else { for(i=0; i < grlc_data->ru.pl_retrans_current.cnt;i++) { if(grlc_data->ru.pl_retrans_current.blk[i] <= BSN_MAX AND (grlc_data->ru.vb[grlc_data->ru.pl_retrans_current.blk[i] & WIN_MOD] EQ VB_ACKED)) { grlc_data->ru.nts = (grlc_data->ru.nts_max -i); grlc_data->ru.pl_retrans_current.cnt -= (grlc_data->ru.nts - rlc_blocks_sent_i); memset(&grlc_data->ru.pl_retrans_current.blk[i], 0xFF, grlc_data->ru.nts); grlc_data->ru.write_pos_index -= grlc_data->ru.nts - rlc_blocks_sent_i; break; } } } /***********************check if a bsn_ret block is in queue*****************/ for(i=0; i < grlc_data->ru.pl_retrans_current.cnt;i++) { if(grlc_data->ru.pl_retrans_current.blk[i] EQ grlc_data->ru.bsn_ret) { grlc_data->ru.bsn_ret = ru_set_next_bsn_ret(); } } /****************************************************************************/ grlc_data->ru.reorg_l1_needed = FALSE; } /* ru_handle_nts() */ /* +------------------------------------------------------------------------------ | Function : ru_check_pl_ret +------------------------------------------------------------------------------ | Description : handles the restart of timer T3198, and first call of RU | (to stop T3164) | | Parameters : rlc_blocks_sent_i - number of needed blocks by PL(is equal to | the number of sent blocks in the previous radio block) | +------------------------------------------------------------------------------ */ GLOBAL void ru_check_pl_ret ( UBYTE rlc_blocks_sent_i) { UBYTE i; UBYTE bsn; TRACE_FUNCTION( "ru_check_pl_ret" ); /* * handle the sent blocks */ for(i=0;i<rlc_blocks_sent_i;i++) { bsn = grlc_data->ru.pl_retrans_current.blk[i]; /* * chek if the range is OK */ if( bsn <= BSN_MAX ) /* data block was sent */ { /* * trace parametes: 1. retranmission counter, byte counter */ grlc_data->ru.rlc_data[bsn & WIN_MOD].cnt_pl_trans++; if(grlc_data->ru.rlc_data[bsn & WIN_MOD].cnt_pl_trans > 1) grlc_data->tbf_ctrl[grlc_data->ul_index].ret_bsn++; else { UBYTE j; for(j=0;j<grlc_data->ru.rlc_data[bsn & WIN_MOD].data_cnt;j++) grlc_data->tbf_ctrl[grlc_data->ul_index].rlc_oct_cnt +=grlc_data->ru.rlc_data[bsn & WIN_MOD].data[j].l_buf/8; } /* * a retransmitted block was sent */ if(bsn EQ grlc_data->ru.bsn_ret) { grlc_data->ru.bsn_ret = ru_set_next_bsn_ret(); } /* * last bsn is sent */ if((grlc_data->ru.rlc_data[bsn & WIN_MOD].header.mac & 0x3C) EQ 0) /* countdown value is equal 0*/ { grlc_data->ru.last_bsn = LAST_BSN_IS_SENT; } else if(bsn EQ ((grlc_data->ru.va+WIN_SIZE-1) & 0x7F) AND (grlc_data->ru.last_bsn NEQ LAST_BSN_STALL_CONDITION)) { /* * stall indication detected */ grlc_data->ru.last_bsn = LAST_BSN_STALL_CONDITION; TRACE_EVENT_P6("NEXT DATA STALL INDICATION bsn=%d va=%d vs=%d cnt_ts=%d last_bsn=%ld dl_fn=%ld" ,bsn ,grlc_data->ru.va ,grlc_data->ru.vs ,grlc_data->ru.cnt_ts ,grlc_data->ru.last_bsn ,grlc_data->dl_fn); } } else if( bsn >= OFFSET_CTRL_BLOCK_IDX AND bsn < 0xFF ) /* control block was sent */ { sig_ru_tm_ctrl_blk_sent( (UBYTE)( bsn - OFFSET_CTRL_BLOCK_IDX ) ); } else if (bsn EQ 0xFF) { /* nothing to do : dummy block sent*/ } else /*invalid block was sent, should not appear */ { TRACE_ERROR("INVALID bsn range neither data or control block"); TRACE_EVENT("INVALID bsn range neither data or control block"); TRACE_EVENT_P1("bsn = %d ", bsn); } } ru_handle_timers(rlc_blocks_sent_i); /******************delete sent blocks from pl_retrans_current**************/ memcpy(grlc_data->ru.pl_retrans_current.blk, &grlc_data->ru.pl_retrans_current.blk[rlc_blocks_sent_i], (grlc_data->ru.nts_max - rlc_blocks_sent_i)); grlc_data->ru.pl_retrans_current.cnt -= rlc_blocks_sent_i; grlc_data->ru.cnt_ts += rlc_blocks_sent_i; } /* ru_check_pl_ret() */ /* +------------------------------------------------------------------------------ | Function : ru_send_ul_dummy_block +------------------------------------------------------------------------------ | Description : The function ru_send_ul_dummy_block() sends a uplink dummy | control block instead of RLC data block | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_send_ul_dummy_block ( void ) { MCAST (ul_dummy,U_GRLC_UL_DUMMY); TRACE_FUNCTION( "ru_send_ul_dummy_block" ); memset(&grlc_data->ru.ul_data[grlc_data->ru.write_pos_index], 0, sizeof(T_ul_data)); grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status = 2; /* * set uplink dummy block */ ul_dummy->msg_type = U_GRLC_UL_DUMMY_c; grlc_set_buf_tlli( &ul_dummy->tlli_value, grlc_data->uplink_tbf.tlli ); grlc_encode_ul_ctrl_block( ( UBYTE* ) grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].ul_block, ( UBYTE* )ul_dummy ); #ifdef _SIMULATION_ { PALLOC(mac_data_req,MAC_DATA_REQ); memset(&(mac_data_req->ul_data), 0, sizeof(T_ul_data)); memcpy(&(mac_data_req->ul_data), &(grlc_data->ru.ul_data[grlc_data->ru.write_pos_index]), sizeof(T_ul_data)); PSEND(hCommL1,mac_data_req); } TRACE_EVENT_P1("wpi %d",grlc_data->ru.write_pos_index); #else /* #ifdef _SIMULATION_ */ { TRACE_MEMORY_PRIM ( hCommGRLC, hCommL1, MAC_DATA_REQ, &grlc_data->ru.ul_data[grlc_data->ru.write_pos_index], sizeof(T_ul_data) ); } #endif /* #ifdef _SIMULATION_ */ { UBYTE* ul_block = ( UBYTE* )grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].ul_block; TRACE_BINDUMP( hCommGRLC, TC_USER5, cl_rlcmac_get_msg_name ( ( UBYTE )( ul_block[1] >> 2 ), RLC_MAC_ROUTE_UL ), ul_block, MAX_L2_FRAME_SIZE ); /*lint !e569*/ } grlc_data->ru.write_pos_index++; grlc_data->ru.ul_data[grlc_data->ru.write_pos_index].block_status = 0; grlc_data->ru.pl_retrans_current.blk[grlc_data->ru.pl_retrans_current.cnt] = 255; grlc_data->ru.pl_retrans_current.cnt++; grlc_data->ru.nts--; } /* ru_send_ul_dummy_block() */ /* +------------------------------------------------------------------------------ | Function : ru_handle_stall_ind +------------------------------------------------------------------------------ | Description : The function ru_handle_stall_ind() checks, if there was a stall | condition, and if it is canceled. | | Parameters : dummy - description of parameter dummy | +------------------------------------------------------------------------------ */ GLOBAL void ru_handle_stall_ind ( void ) { TRACE_FUNCTION( "ru_handle_stall_ind" ); if(grlc_data->ru.last_bsn EQ LAST_BSN_STALL_CONDITION) { if(!(grlc_data->ru.vs EQ ((grlc_data->ru.va + WIN_SIZE) & 0x7F))) {/*stall condition eliminated*/ grlc_data->ru.reorg_l1_needed = TRUE; /* remove stalled blocks from data queue */ vsi_t_stop(GRLC_handle,T3182); ru_handle_n3102(PAN_INC); if(grlc_data->ru.rlc_mode EQ CGRLC_RLC_MODE_UACK) { /*resume with data transfer after stall indication in rlc unacknowledged problem*/ grlc_data->ru.last_bsn = LAST_BSN_RESUME_UACK_MODE_AFTER_SI; } else { grlc_data->ru.last_bsn = LAST_BSN_NOT_BULIT; } } } else { ru_handle_n3102(PAN_INC); grlc_data->ru.last_si_block = grlc_data->ru.va; } } /* ru_handle_stall_ind() */ /* +------------------------------------------------------------------------------ | Function : ru_handle_tbf_start_in_ptm +------------------------------------------------------------------------------ | Description : The function ru_handle_tbf_start_in_ptm() modifies the parameters | for the tbf at reaching the starting time | | Parameters : rlc_blocks_sent_i - number of blocks sent in current in radio block | return value is set, if only nts is decrased and not all blocks are sent | +------------------------------------------------------------------------------ */ GLOBAL void ru_handle_tbf_start_in_ptm ( UBYTE rlc_blocks_sent_i ) { UBYTE ctrl_blk_active_idx; BOOL realloc_prr_allowed = FALSE; TRACE_FUNCTION( "ru_handle_tbf_start_in_ptm" ); /* * reassignment of uplink and tbf starting time elapsed, received either with packet uplink assignment * or packet timeslot reconfigure */ if(grlc_data->ul_tfi_changed) { if((rlc_blocks_sent_i < grlc_data->ru.nts_max) AND /* nr of locks which are not sent */ (grlc_data->ru.cs_type EQ grlc_data->ru.next_tbf_params.cs_type) AND /* coding scheme has not changed */ (grlc_data->ru.nts_max <= grlc_data->ru.next_tbf_params.nts)) /* nts increased or equal */ { UBYTE i, bsn[4],cnt; /* * change the tfi for blocks which are in l1 queue */ cnt = grlc_data->ru.pl_retrans_current.cnt; bsn[0] = grlc_data->ru.pl_retrans_current.blk[0]; bsn[1] = grlc_data->ru.pl_retrans_current.blk[1]; grlc_data->ru.pl_retrans_current.cnt = 0; for (i = 0; i< cnt;i++) { if(bsn[i] <= BSN_MAX) { grlc_data->ru.write_pos_index--; ru_send_mac_data_req(bsn[i]); TRACE_EVENT_P1("bsn %d modified while tfi is changed",bsn[i]); } else { TRACE_EVENT_P1("bsn %d :TFI FOR CTRL BLOCK CHANGED. no modification",bsn[i]); } } } grlc_data->ul_tfi_changed = FALSE; } grlc_data->ru.tlli_cs_type = grlc_data->ru.next_tbf_params.tlli_cs_type; if(grlc_data->ru.cs_type NEQ grlc_data->ru.next_tbf_params.cs_type) { TRACE_EVENT_P2("UL assign: CS changed from %d to %d ",grlc_data->ru.cs_type,grlc_data->ru.next_tbf_params.cs_type); grlc_data->ru.cs_type = grlc_data->ru.next_tbf_params.cs_type; ru_change_of_cs(grlc_data->ru.cs_type); } if(grlc_data->ru.nts_max < grlc_data->ru.next_tbf_params.nts) { TRACE_EVENT_P6("nts increased from %d to %d, tfi=%d,cnt_ts=%d,vs=%d,va=%d", grlc_data->ru.nts_max, grlc_data->ru.next_tbf_params.nts, grlc_data->ul_tfi, grlc_data->ru.cnt_ts, grlc_data->ru.vs, grlc_data->ru.va); grlc_data->ru.nts = (grlc_data->ru.next_tbf_params.nts - grlc_data->ru.nts_max); grlc_data->ru.nts_max = grlc_data->ru.next_tbf_params.nts; while( grlc_data->ru.nts AND tm_get_num_ctrl_blck( ) NEQ 0 AND ru_ctrl_blk_selection_allowed() ) { /* * next uplink block is a control block, * check if countdown procedure is statred or not */ ru_send_control_block( ); } while(grlc_data->ru.nts) { ctrl_blk_active_idx = ru_peek_for_ctrl_blk(); if ((ctrl_blk_active_idx EQ 0xFF) OR realloc_prr_allowed EQ TRUE) /*No control block , form data block*/ { while(grlc_data->ru.nts AND grlc_data->ru.sdu_len) { ru_new_data(); } while(grlc_data->ru.nts) { ru_ret_bsn(); } realloc_prr_allowed = FALSE; break; } else { TRACE_EVENT_P1("reallocation of llc pdu (index)=%d",ctrl_blk_active_idx); /* if already one PRR in L1 Buffer , replace it with new PRR */ if (grlc_data->ru.pl_retrans_current.blk[0] EQ (BLK_INDEX_TM + OFFSET_CTRL_BLOCK_IDX)) { grlc_data->ru.write_pos_index--; grlc_data->ru.pl_retrans_current.cnt--; grlc_data->ru.nts++; TRACE_EVENT("prr in l1 buffer queue,replace with new prr"); } sig_ru_tm_end_of_pdu(ctrl_blk_active_idx); ru_send_control_block(); realloc_prr_allowed = TRUE; } } if(grlc_data->ru.cv EQ 0 AND grlc_data->ru.rlc_mode EQ CGRLC_RLC_MODE_ACK ) { SET_STATE(RU,RU_REL_ACK); } else if(grlc_data->ru.rlc_mode EQ CGRLC_RLC_MODE_ACK) { SET_STATE(RU,RU_ACK); } else if(grlc_data->ru.cv EQ 0 AND grlc_data->ru.rlc_mode EQ CGRLC_RLC_MODE_UACK ) { SET_STATE(RU,RU_REL_UACK); } else if(grlc_data->ru.rlc_mode EQ CGRLC_RLC_MODE_UACK) { SET_STATE(RU,RU_UACK); } else { TRACE_EVENT_P2("RLC MODE ??? cv=%d rlc_mode=%d",grlc_data->ru.cv,grlc_data->ru.rlc_mode); } } else if(grlc_data->ru.nts_max > grlc_data->ru.next_tbf_params.nts) { /* Reorg layer 1 */ ru_reorg_l1((UBYTE)(rlc_blocks_sent_i)); TRACE_EVENT_P7("nts decrased from %d to %d tfi=%d,cnt_ts=%d,va=%d,vs=%d blk_s=%d ", grlc_data->ru.nts_max, grlc_data->ru.next_tbf_params.nts, grlc_data->ul_tfi, grlc_data->ru.cnt_ts, grlc_data->ru.va, grlc_data->ru.vs, rlc_blocks_sent_i); grlc_data->ru.nts_max = grlc_data->ru.next_tbf_params.nts; } else { TRACE_EVENT_P6("ul tbf reassignment with tfi=%d,cnt_ts=%d,va=%d,vs=%d,nts_max=%d tbf_st_time=%ld", grlc_data->ul_tfi, grlc_data->ru.cnt_ts, grlc_data->ru.va, grlc_data->ru.vs, grlc_data->ru.nts_max, grlc_data->ul_tbf_start_time); } grlc_data->ru.v_next_tbf_params = FALSE; } /* ru_handle_tbf_start_in_ptm() */ /* +------------------------------------------------------------------------------ | Function : ru_switch_ul_buffer +------------------------------------------------------------------------------ | Description : The function ru_switch_ul_buffer () .... | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void ru_switch_ul_buffer ( UBYTE rlc_blocks_sent_i ) { UBYTE i; TRACE_FUNCTION( "ru_switch_ul_buffer " ); /* * switch uplink buffer, it means, rlc blocks which are not sent * by PL are switched to the top of the ul buffer */ if (rlc_blocks_sent_i) { i = rlc_blocks_sent_i; while((i < MAX_UL_TN) AND (grlc_data->ru.ul_data[i].block_status NEQ 0)) { grlc_data->ru.ul_data[i - rlc_blocks_sent_i] = grlc_data->ru.ul_data[i]; i++; } grlc_data->ru.write_pos_index -= rlc_blocks_sent_i; } } /* ru_switch_ul_buffer () */ /* +------------------------------------------------------------------------------ | Function : ru_cgrlc_st_time_ind +------------------------------------------------------------------------------ | Description : The function ru_cgrlc_st_time_ind () informs higher layers | that the starting time is elapsed | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void ru_cgrlc_st_time_ind ( void ) { PALLOC(cgrlc_starting_time_ind,CGRLC_STARTING_TIME_IND); /* T_CGRLC_STARTING_TIME_IND */ TRACE_FUNCTION( "ru_cgrlc_st_time_ind " ); cgrlc_starting_time_ind->tbf_mode = CGRLC_TBF_MODE_UL; cgrlc_starting_time_ind->tfi = grlc_data->ul_tfi; PSEND(hCommGRR,cgrlc_starting_time_ind); grlc_data->ul_tn_mask = grlc_data->uplink_tbf.ts_mask; } /* ru_cgrlc_st_time_ind () */ /* +------------------------------------------------------------------------------ | Function : ru_ctrl_blk_selection_allowed +------------------------------------------------------------------------------ | Description : This function gets called from sig_gff_ru_mac_ready_ind handler | and also from the function which handles ul reassignment | (ru_handle_tbf_start_in_ptm). In mac ready indicate handler | this is calld only when ru is in rel_ack state. | This function returns true or false according to the following | table. The table applies for uack mode also. | When this function returns true, then control block should be | selected for transmission by RU. | When it returns False, then control block is selected by RD. | | ru_rel_ack state rd_rel_ack - TRUE | ru_ack rd_ack - TRUE | ru_ack rd_rel_ack - TRUE | ru_rel_ack rd_ack - FALSE | ru_ack NO DL TBF(rd_null) - TRUE | ru_rel_ack NO DL TBF(rd_null) - TRUE | | This function should be called only in PTM. | | Parameters : None +------------------------------------------------------------------------------ */ GLOBAL BOOL ru_ctrl_blk_selection_allowed() { BOOL ru_in_release_mode = FALSE, ctrl_blk_allowed = TRUE, dl_release_started = TRUE; if(grlc_data->tbf_type EQ TBF_TYPE_CONC) { /* In ru_send_pca stete, ctrl blocks are not sent. No need to * check for that here. */ if((GET_STATE(RU) EQ RU_REL_ACK) OR (GET_STATE(RU) EQ RU_REL_UACK)) { ru_in_release_mode = TRUE; } sig_ru_rd_get_downlink_release_state(&dl_release_started); /* rd_rel_state would be true if fbi=1 has been received * in downlink. */ if(ru_in_release_mode AND (dl_release_started EQ FALSE) ) { ctrl_blk_allowed = FALSE; } } return ctrl_blk_allowed; } /* +------------------------------------------------------------------------------ | Function : ru_peek_for_ctrl_blk +------------------------------------------------------------------------------ | Description : The function would peek to see if there is reallocation set, | then it returns TRUE, so that PRR can be constructed. | Also if the rlc block has more than one llc pdu with re-allocation | set , then prr os sent for the latest llc pdu. | Parameters : None. | +------------------------------------------------------------------------------ */ #ifndef CF_FAST_EXEC GLOBAL UBYTE ru_peek_for_ctrl_blk() { BOOL ctrlblk_found = FALSE; USHORT rlc_len; USHORT sdu_len; UBYTE active_prim,next_prim,active_prr_idx = 0xFF; TRACE_FUNCTION( "ru_peek_for_ctrl_blk" ); sdu_len = grlc_data->ru.sdu_len; active_prim = grlc_data->ru.active_prim; next_prim = grlc_data->ru.next_prim; rlc_len = grlc_data->ru.rlc_data_size; while ( (sdu_len < rlc_len) AND (sdu_len > 0) ) { rlc_len -= sdu_len + 1; /* 1 is for length indicator */ if (!grlc_data->ru.cd_active) { ctrlblk_found = ru_peek_next_sdu(&sdu_len,&active_prim,&next_prim); active_prr_idx = ctrlblk_found ? active_prim:0xFF; } else { #ifdef _SIMULATION_ TRACE_EVENT("countdown in progress and extended tbf not supported,cant build PRR"); #endif return active_prr_idx; } } return (ctrlblk_found ? active_prr_idx : 0xFF); }/*ru_peek_for_ctrl_blk*/ #endif /* CF_FAST_EXEC */ /* +------------------------------------------------------------------------------ | Function : ru_peek_next_sdu +------------------------------------------------------------------------------ | Description : The function would peek to see if there is reallocation set, | for the current llc PDU. | | Parameters : None. | +------------------------------------------------------------------------------ */ #ifndef CF_FAST_EXEC GLOBAL BOOL ru_peek_next_sdu(USHORT *sdu_len,UBYTE *active_prim,UBYTE *next_prim) { BOOL prr_build = FALSE; TRACE_FUNCTION( "ru_peek_next_sdu"); if( *next_prim NEQ 0xFF AND (grlc_data->prim_queue[*next_prim].start_new_tbf EQ 0)) { *active_prim = grlc_data->prim_queue[*active_prim].next; /* This signal allows TM to initiate resource re-allocation * if required */ prr_build = grlc_data->prim_queue[*active_prim].re_allocation; *sdu_len = grlc_data->prim_queue[*active_prim].prim_ptr->sdu.l_buf/8; *next_prim = grlc_data->prim_queue[*active_prim].next; } else { *sdu_len = 0; } return prr_build; }/*ru_peek_next_sdu*/ #endif /* CF_FAST_EXEC */