FreeCalypso > hg > fc-magnetite
view src/g23m-gprs/grlc/grlc_f.c @ 395:11e279107681
Magnetite fw can now be compiled to target Calypso C05 (F741979B) silicon
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Thu, 18 Jan 2018 00:03:48 +0000 |
| parents | 219afcfc6250 |
| 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 global functions for GRLC +----------------------------------------------------------------------------- */ #ifndef GRLC_F_C #define GRLC_F_C #endif #define ENTITY_GRLC /*==== INCLUDES =============================================================*/ #include <stdio.h> #include <string.h> /* to get definition of memcpy() */ #include <math.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" /* to get message describtion */ #include "pcm.h" #include "grlc.h" /* to get the global entity definitions */ #include "grlc_f.h" /* to check own definitions */ #include "grlc_tmf.h" /* to get definition of tm_grlc_init() */ #include "grlc_gfff.h" /* to get definition of gff_init() */ #include "grlc_rdf.h" /* to get definition of rd_init() */ #include "grlc_ruf.h" /* to get definition of ru_init() */ #include "grlc_rus.h" #include "grlc_rds.h" #include "grlc_tms.h" #include "grlc_tpcs.h" #include "grlc_meass.h" #include "cl_rlcmac.h" /*==== CONST ================================================================*/ /*==== DIAGNOSTICS ==========================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== GLOBAL VARS ===========================================================*/ /*==== LOCAL MACROS =========================================================*/ /*==== FUNCTIONS PROTOTYPES =================================================*/ LOCAL void grlc_encode_dl_acknack ( UBYTE * ptr_out ); LOCAL void grlc_encode_ul_dummy ( UBYTE * ptr_out ); LOCAL void grlc_encode_pca ( UBYTE * ptr_out ); LOCAL UBYTE grlc_decode_ul_acknack ( UBYTE * ptr_blk ); LOCAL UBYTE grlc_ccd_error_handling ( UBYTE entity_i ); LOCAL USHORT grlc_convert_11bit_2_etsi ( USHORT eleven_bit ); /*==== FUNCTIONS ============================================================*/ /* +------------------------------------------------------------------------------ | Function : grlc_encode_dl_acknack +------------------------------------------------------------------------------ | Description : The function grlc_encode_dl_acknack() encodes the packet downlink | ack/nack block without CCD | | Parameters : *ptr_out_i- ptr to the buffer where the air message will be placed | | +------------------------------------------------------------------------------ */ LOCAL void grlc_encode_dl_acknack ( UBYTE * ptr_out) { MCAST (u_dl_ack,U_GRLC_DL_ACK); /* T_U_GRLC_DL_ACK */ UBYTE i=0, bit=0,byte,bit_in_byte,j; TRACE_FUNCTION( "grlc_encode_dl_acknack" ); /******************* mandatory elements ****************************/ /* MESSAGE TYPE 6 bit */ ptr_out[0] = u_dl_ack->msg_type << 2; bit +=6; /* DL TFI 5 bit */ ptr_out[0] |= (u_dl_ack->dl_tfi >> 3) & 0x03; ptr_out[1] = (u_dl_ack->dl_tfi << 5); bit +=5; /* ACK NACK DESCRIPTION */ /* final ack indication 1 bit */ ptr_out[1] |= (u_dl_ack->ack_nack_des.f_ack_ind << 4); bit +=1; /* ssn 7 bit */ ptr_out[1] |= (u_dl_ack->ack_nack_des.ssn >> 3); ptr_out[2] = (u_dl_ack->ack_nack_des.ssn << 5); bit +=7; for (i=0;i<64; i++) { byte = bit / 8; /* byte pos */ bit_in_byte = bit % 8; /* rel bit pos in the current byte */ ptr_out[byte] |= u_dl_ack->ack_nack_des.rbb[i] << (7-bit_in_byte); bit +=1; } /* CHANNEL REQUEST DESCRIPTION */ /* valid flag*/ byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= u_dl_ack->v_chan_req_des << (7-bit_in_byte); bit +=1; if(u_dl_ack->v_chan_req_des) { /* peak_thr_class */ for(i=0;i<4;i++) { byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->chan_req_des.peak_thr_class >> (3-i)) << (7-bit_in_byte); bit +=1; } /* radio prio */ for(i=0;i<2;i++) { byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->chan_req_des.radio_prio >> (1-i)) << (7-bit_in_byte); bit +=1; } /* rlc_mode*/ byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->chan_req_des.rlc_mode) << (7-bit_in_byte); bit +=1; /* llc pdu type*/ byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->chan_req_des.llc_pdu_type) << (7-bit_in_byte); bit +=1; /* rlc_oct_cnt */ for(i=0;i<16;i++) { byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->chan_req_des.rlc_octet_cnt >> (15-i)) << (7-bit_in_byte); bit +=1; } } /* CHANNEL QUALITY REPORT */ /* c_value */ for(i=0;i<6;i++) { byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->chan_qual_rep.c_value >> (5-i)) << (7-bit_in_byte); bit +=1; } /* rxqual */ for(i=0;i<3;i++) { byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->chan_qual_rep.rxqual >> (2-i)) << (7-bit_in_byte); bit +=1; } /* signvar */ for(i=0;i<6;i++) { byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->chan_qual_rep.signvar >> (5-i)) << (7-bit_in_byte); bit +=1; } /* c_value */ for(j=0;j<8;j++) { UBYTE flag,value; switch(j) { case 0: flag = u_dl_ack->chan_qual_rep.ilev.v_ilev0; value = u_dl_ack->chan_qual_rep.ilev.ilev0; break; case 1: flag = u_dl_ack->chan_qual_rep.ilev.v_ilev1; value = u_dl_ack->chan_qual_rep.ilev.ilev1; break; case 2: flag = u_dl_ack->chan_qual_rep.ilev.v_ilev2; value = u_dl_ack->chan_qual_rep.ilev.ilev2; break; case 3: flag = u_dl_ack->chan_qual_rep.ilev.v_ilev3; value = u_dl_ack->chan_qual_rep.ilev.ilev3; break; case 4: flag = u_dl_ack->chan_qual_rep.ilev.v_ilev4; value = u_dl_ack->chan_qual_rep.ilev.ilev4; break; case 5: flag = u_dl_ack->chan_qual_rep.ilev.v_ilev5; value = u_dl_ack->chan_qual_rep.ilev.ilev5; break; case 6: flag = u_dl_ack->chan_qual_rep.ilev.v_ilev6; value = u_dl_ack->chan_qual_rep.ilev.ilev6; break; case 7: flag = u_dl_ack->chan_qual_rep.ilev.v_ilev7; value = u_dl_ack->chan_qual_rep.ilev.ilev7; break; default: TRACE_EVENT_P1("no valid j=%d value during grlc_encode_dl_acknack should not appear ",j); flag = 0; value = 0; break; } byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (flag) << (7-bit_in_byte); bit +=1; if(flag) { for(i=0;i<4;i++) { byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (value >> (3-i)) << (7-bit_in_byte); bit +=1; } } } /* RELEASE 99*/ #ifdef REL99 byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= u_dl_ack->v_release_99_str_u_grlc_dl_ack << (7-bit_in_byte); bit +=1; if(u_dl_ack->v_release_99_str_u_grlc_dl_ack) { byte = bit / 8; bit_in_byte = bit % 8; if(u_dl_ack->release_99_str_u_grlc_dl_ack.v_pfi) { ptr_out[byte] |= u_dl_ack->release_99_str_u_grlc_dl_ack.v_pfi << (7-bit_in_byte); bit +=1; for(i=0;i<6;i++) { byte = bit / 8; bit_in_byte = bit % 8; ptr_out[byte] |= (u_dl_ack->release_99_str_u_grlc_dl_ack.pfi >> (6-i)) << (7-bit_in_byte); bit +=1; } } else { ptr_out[byte] |= u_dl_ack->release_99_str_u_grlc_dl_ack.v_pfi << (7-bit_in_byte); bit +=1; } } bit++; #endif /* SPARE PADDINGS */ byte = bit / 8; bit_in_byte = bit % 8; if(bit_in_byte < 7) { UBYTE mask; mask= 0xff >> (bit_in_byte); mask &= 0x2B; ptr_out[byte] |= mask; } for(i=byte;i<22;i++) { byte++; ptr_out[byte] = 0x2B; } } /* grlc_encode_dl_acknack() */ /* +------------------------------------------------------------------------------ | Function : grlc_encode_ul_dummy +------------------------------------------------------------------------------ | Description : The function grlc_encode_ul_dummy() encodes the packet uplink | dummy block without CCD | | Parameters : *ptr_out_i- ptr to the buffer where the air message will be placed | | +------------------------------------------------------------------------------ */ LOCAL void grlc_encode_ul_dummy ( UBYTE * ptr_out) { MCAST (ul_dummy,U_GRLC_UL_DUMMY); /* T_U_GRLC_UL_DUMMY */ UBYTE i; TRACE_FUNCTION( "grlc_encode_ul_dummy" ); /******************* mandatory elements ****************************/ ptr_out[0] = ul_dummy->msg_type << 2; ptr_out[0] |= (UBYTE) (grlc_data->uplink_tbf.tlli >> 30); /* 1100 0000 0000 0000 0000 0000 0000 0000 */ ptr_out[1] = (UBYTE) ((grlc_data->uplink_tbf.tlli & 0x3FC00000) >> 22); /* 0011 1111 1100 0000 0000 0000 0000 0000 */ ptr_out[2] = (UBYTE) ((grlc_data->uplink_tbf.tlli & 0x003FC000) >> 14); /* 0000 0000 0011 1111 1100 0000 0000 0000 */ ptr_out[3] = (UBYTE) ((grlc_data->uplink_tbf.tlli & 0x00003FC0) >> 6); /* 0000 0000 0000 0000 0011 1111 1100 0000 */ ptr_out[4] = (UBYTE) ((grlc_data->uplink_tbf.tlli & 0x0000003F) << 2); /* 0000 0000 0000 0000 0000 0000 0011 1111 */ ptr_out[4] |= 0x01; /* spare paddings */ for(i=5;i<22;i++) ptr_out[i] = 0x2B; } /* grlc_encode_ul_dummy() */ /* +------------------------------------------------------------------------------ | Function : grlc_encode_pca +------------------------------------------------------------------------------ | Description : The function grlc_encode_pca() encodes the packet control | acknowledgement block without CCD | | Parameters : *ptr_out_i- ptr to the buffer where the air message will be placed | | +------------------------------------------------------------------------------ */ LOCAL void grlc_encode_pca ( UBYTE * ptr_out) { MCAST(u_ctrl_ack,U_GRLC_CTRL_ACK); /* T_U_GRLC_CTRL_ACK */ UBYTE i; TRACE_FUNCTION( "grlc_encode_pca" ); /******************* mandatory elements ****************************/ ptr_out[0] = u_ctrl_ack->msg_type << 2; ptr_out[0] |= (UBYTE) (grlc_data->uplink_tbf.tlli >> 30); /* 1100 0000 0000 0000 0000 0000 0000 0000 */ ptr_out[1] = (UBYTE) ((grlc_data->uplink_tbf.tlli & 0x3FC00000) >> 22); /* 0011 1111 1100 0000 0000 0000 0000 0000 */ ptr_out[2] = (UBYTE) ((grlc_data->uplink_tbf.tlli & 0x003FC000) >> 14); /* 0000 0000 0011 1111 1100 0000 0000 0000 */ ptr_out[3] = (UBYTE) ((grlc_data->uplink_tbf.tlli & 0x00003FC0) >> 6); /* 0000 0000 0000 0000 0011 1111 1100 0000 */ ptr_out[4] = (UBYTE) ((grlc_data->uplink_tbf.tlli & 0x0000003F) << 2); /* 0000 0000 0000 0000 0000 0000 0011 1111 */ ptr_out[4] |= u_ctrl_ack->pctrl_ack & 0x03; for(i=5;i<22;i++) ptr_out[i] = 0x2B; } /* grlc_encode_pca() */ /* +------------------------------------------------------------------------------ | Function : grlc_decode_ul_acknack +------------------------------------------------------------------------------ | Description : The function grlc_decode_ul_acknack() decodes the packet uplink | ack/nack without CCD | | Parameters : *ptr_blk- ptr to the air message | | Return value: returns decode status of air message:ccdOK,ccdWarning,ccdError | +------------------------------------------------------------------------------ */ LOCAL UBYTE grlc_decode_ul_acknack ( UBYTE *ptr_blk ) { MCAST(d_ul_ack,D_GRLC_UL_ACK);/* T_D_GRLC_UL_ACK */ UBYTE i,j,k; UBYTE bit_pos; #ifdef REL99 UBYTE flag; #endif UBYTE result =ccdOK; TRACE_FUNCTION( "grlc_decode_ul_acknack" ); /******************* mandatory elements ****************************/ d_ul_ack->msg_type = (ptr_blk[0] & 0xFC) >> 2 ; d_ul_ack->page_mode = ptr_blk[0] & 0x03; if((ptr_blk[1] & 0xC0)) /* distrubiton part error check */ { TRACE_ERROR("P UL ACK: DISTRUBITION PART ERROR"); TRACE_EVENT_P2("P UL ACK: DISTRUBITION PART ERROR byte = 0x2%x res = 0x%2x",ptr_blk[1] ,ptr_blk[1] & 0xC0); return ccdError; } d_ul_ack->ul_tfi = (ptr_blk[1] & 0x3E) >> 1; if((ptr_blk[1] & 0x01)) /* message escape bit check */ { #ifdef REL99 d_ul_ack->egprs_flag = TRUE; #endif TRACE_ERROR("P UL ACK: MESSAGE ESCAPE ERROR"); TRACE_EVENT_P2("P UL ACK: MESSAGE ESCAPE ERROR byte = 0x2%x res = 0x%2x",ptr_blk[1] ,ptr_blk[1] & 0x01); return ccdError; } d_ul_ack->v_gprs_ul_ack_nack_info = TRUE; d_ul_ack->gprs_ul_ack_nack_info.chan_coding_cmd = (ptr_blk[2] & 0xC0) >> 6; #ifdef _SIMULATION_ TRACE_EVENT_P2("tfi=%d ch_c_cmd=%d",d_ul_ack->ul_tfi,d_ul_ack->gprs_ul_ack_nack_info.chan_coding_cmd); #endif /* _SIMULATION_ */ /******************* Ack/Nack description ****************************/ d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.f_ack_ind = (ptr_blk[2] & 0x20) >> 5; d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.ssn = (ptr_blk[2] << 2) & 0x7C; d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.ssn |= (ptr_blk[3] >> 6) & 0x03; j= 3; /* inital byte of rbb field */ k= 2; /* inital bit of rbb field */ for(i=0; i< 64;i++) { d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.rbb[i] = (ptr_blk[j] & (0x80>>k)) >> (7-k); k++; if(k EQ 8) { k=0; j++; } } #ifdef _SIMULATION_ TRACE_EVENT_P2("fai=%d ssn=%d",d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.f_ack_ind,d_ul_ack->gprs_ul_ack_nack_info.ack_nack_des.ssn); #endif /* _SIMULATION_ */ bit_pos = 91; /* abs bit position */ /******************* contention resolution tlli ***********************/ j = bit_pos / 8; /* byte pos */ k = bit_pos % 8; /* rel bit pos */ d_ul_ack->gprs_ul_ack_nack_info.v_cr_tlli = (ptr_blk[j] >> (8-k)) & 0x01; bit_pos++; if(d_ul_ack->gprs_ul_ack_nack_info.v_cr_tlli) { d_ul_ack->gprs_ul_ack_nack_info.cr_tlli.l_cr_tlli = 32; d_ul_ack->gprs_ul_ack_nack_info.cr_tlli.o_cr_tlli = 3; d_ul_ack->gprs_ul_ack_nack_info.cr_tlli.b_cr_tlli[0] = ptr_blk[j]; d_ul_ack->gprs_ul_ack_nack_info.cr_tlli.b_cr_tlli[1] = ptr_blk[j+1]; d_ul_ack->gprs_ul_ack_nack_info.cr_tlli.b_cr_tlli[2] = ptr_blk[j+2]; d_ul_ack->gprs_ul_ack_nack_info.cr_tlli.b_cr_tlli[3] = ptr_blk[j+3]; d_ul_ack->gprs_ul_ack_nack_info.cr_tlli.b_cr_tlli[4] = ptr_blk[j+4]; bit_pos+=32; } #ifdef REL99 /******************* packet timing advance ****************************/ j = bit_pos / 8; /* byte pos */ k = bit_pos % 8; /* rel bit pos */ flag = (ptr_blk[j] >> (8-k)) & 0x01; bit_pos++; if(flag) { } /******************* power control params ****************************/ j = bit_pos / 8; /* byte pos */ k = bit_pos % 8; /* rel bit pos */ flag = (ptr_blk[j] >> (8-k)) & 0x01; bit_pos++; if(flag) { } /******************* Extension bits ****************************/ j = bit_pos / 8; /* byte pos */ k = bit_pos % 8; /* rel bit pos */ flag = (ptr_blk[j] >> (8-k)) & 0x01; bit_pos++; if(flag) { } /******************* Fixed Alloc ****************************/ j = bit_pos / 8; /* byte pos */ k = bit_pos % 8; /* rel bit pos */ flag = (ptr_blk[j] >> (8-k)) & 0x01; bit_pos++; if(flag) { } /******************* R99 FLAG ****************************/ j = bit_pos / 8; /* byte pos */ k = bit_pos % 8; /* rel bit pos */ bit_pos++; d_ul_ack->gprs_ul_ack_nack_info.v_release_99_str_d_ul_ack = (ptr_blk[j] >> (8-k)) & 0x01; /******************* Extended PTA ****************************/ j = bit_pos / 8; /* byte pos */ k = bit_pos % 8; /* rel bit pos */ flag = (ptr_blk[j] >> (8-k)) & 0x01; bit_pos++; if(flag) { } /**********************************************************************/ j = bit_pos / 8; /* byte pos */ k = bit_pos % 8; /* rel bit pos */ d_ul_ack->gprs_ul_ack_nack_info.release_99_str_d_ul_ack.tbf_est = (ptr_blk[j] >> (8-k)) & 0x01; #endif return(result); } /* grlc_decode_ul_acknack() */ /* +------------------------------------------------------------------------------ | Function : grlc_ccd_error_handling +------------------------------------------------------------------------------ | Description : The function grlc_ccd_error_handling() ... | | Parameters : entity_i - the CCD was called for this entity | +------------------------------------------------------------------------------ */ LOCAL UBYTE grlc_ccd_error_handling ( UBYTE entity_i ) { UBYTE result = DELETE_MESSAGE; USHORT parlist [MAX_ERR_PAR]; UBYTE first_error; TRACE_FUNCTION( "grlc_ccd_error_handling" ); memset (parlist, 0, sizeof (parlist)); first_error = ccd_getFirstError (entity_i, parlist); switch (first_error) { case ERR_PATTERN_MISMATCH: /* A spare pattern does not match with */ /* the specified content */ /* Error params[0] = bitposition */ { MCAST(ptr,D_GRLC_UL_ACK); result = ptr->msg_type; } break; default: /* SZML-GLBL/010 */ TRACE_ERROR( "Ctrl-Message will be deleted" ); break; } return(result); } /* grlc_ccd_error_handling() */ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : grlc_buffer2ulong +------------------------------------------------------------------------------ | Description : The function grlc_buffer2ulong() copy a 32-Bit-Buffer in a ULONG | variable | | SZML-GLBL/002 | | Parameters : ptmsi - pointer to buffer that contains the 32bit for the ULONG | +------------------------------------------------------------------------------ */ GLOBAL ULONG grlc_buffer2ulong ( BUF_cr_tlli *tlli) { ULONG ul; UBYTE l, dummy; USHORT i, ii; UBYTE off1, off2; TRACE_FUNCTION( "grlc_buffer2ulong "); ul= 0; l = (UBYTE)tlli->l_cr_tlli; off1 = tlli->o_cr_tlli / 8; off2 = tlli->o_cr_tlli % 8; dummy = 0; dummy = tlli->b_cr_tlli[off1] << off2; if(l <= (8-off2)) { dummy = dummy >> (8-l); ul |= dummy; return ul; } dummy = dummy >> off2; ul |= dummy; l -= (8-off2); do { off1++; if(l < 8) { dummy = tlli->b_cr_tlli[off1] >> (8-l); ii = 1; ul = ul << l; for(i=0; i< l; i++) { ul = ul | (dummy & ii); ii *= 2; } return ul; } else { ul = ul << 8; ul |= tlli->b_cr_tlli[off1]; l -= 8; if(l EQ 0) return ul; } } while(TRUE); } /* +------------------------------------------------------------------------------ | Function : grlc_delete_prim +------------------------------------------------------------------------------ | Description : The function grlc_delete_prim() deletes the primitive that is | pointed by the grlc_data->prim_start_tbf and sets the | grlc_data->prim_start_tbf to the next entry in the tbf list. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grlc_delete_prim ( void ) { TRACE_FUNCTION( "grlc_delete_prim" ); /* * access type is reseted */ grlc_data->uplink_tbf.access_type = CGRLC_AT_NULL; if(grlc_data->prim_start_tbf < PRIM_QUEUE_SIZE_TOTAL) { UBYTE i; /* * get first entry from tbf list */ i = grlc_prim_get_first (&grlc_data->prim_start_tbf); if(i >= PRIM_QUEUE_SIZE) { TRACE_EVENT_P5("delete prim VOR i=%d ps=%d, pf=%d,sps=%d,spf=%d", i, grlc_data->prim_start_tbf, grlc_data->prim_start_free, grlc_data->save_prim_start_tbf, grlc_data->save_prim_start_free); } /* * estimate new user data amount in queue */ grlc_data->prim_user_data -= BYTELEN(grlc_data->prim_queue[i].prim_ptr->sdu.l_buf); /* * free primitive before reset old primitive entry */ PFREE ( grlc_data->prim_queue[i].prim_ptr ); /* * reset old primitive */ grlc_data->prim_queue[i].prim_ptr = NULL; grlc_data->prim_queue[i].prim_type = CGRLC_LLC_PRIM_TYPE_NULL; grlc_data->prim_queue[i].cv_status = FALSE; grlc_data->prim_queue[i].rlc_status = FALSE; grlc_data->prim_queue[i].re_allocation = FALSE; grlc_data->prim_queue[i].start_new_tbf = FALSE; grlc_data->prim_queue[i].last_bsn = 0xff; grlc_data->prim_queue[i].previous = 0xff; /* * put new entry at the end of free list */ if(i < PRIM_QUEUE_SIZE) { grlc_prim_put(&grlc_data->prim_start_free,i,END_OF_LIST); } else if(grlc_data->gmm_procedure_is_running) { grlc_prim_put(&grlc_data->prim_start_free,i,END_OF_LIST); TRACE_EVENT_P5("delete prim %d AFTER PST=%d, PSF=%d,spst=%d,spsf=%d", i, grlc_data->prim_start_tbf, grlc_data->prim_start_free, grlc_data->save_prim_start_tbf, grlc_data->save_prim_start_free); } /* * update LLC flow control state */ if ((grlc_data->tm.send_grlc_ready_ind EQ PRIM_QUEUE_FULL) AND /* PRIM QUEUE IS FULL */ ( (!grlc_data->gmm_procedure_is_running AND (i < PRIM_QUEUE_SIZE)) OR /* LLC QUEUE IS ACTIVE, PDU FROM LLC QUEUE DELETED */ (grlc_data->gmm_procedure_is_running AND !(i < PRIM_QUEUE_SIZE)))) /* GMM QUEUE IS ACTIVE, PDU FROM GMM QUEUE DELETED */ { TRACE_EVENT_P3("Flow control activated gmm_q=%d,i=%d,ready=%d",grlc_data->gmm_procedure_is_running,i,grlc_data->tm.send_grlc_ready_ind); grlc_data->tm.send_grlc_ready_ind = SEND_A_GRLC_READY_IND; } grlc_data->grlc_data_req_cnt--; } else { TRACE_EVENT_P3("PST=%d PSF=%d PDU=%d: grlc_delete_prim" ,grlc_data->prim_start_tbf ,grlc_data->prim_start_free ,grlc_data->grlc_data_req_cnt); return; } } /* grlc_delete_prim() */ /* +------------------------------------------------------------------------------ | Function : grlc_calc_new_poll_pos +------------------------------------------------------------------------------ | Description : The function grlc_calc_new_poll_pos() calculates the fn of the | new poll position | | Parameters : fn_i - framenumber | rrbp_i - relative position | +------------------------------------------------------------------------------ */ GLOBAL ULONG grlc_calc_new_poll_pos ( ULONG fn_i, UBYTE rrbp_i ) { ULONG result=0; TRACE_FUNCTION( "grlc_calc_new_poll_pos" ); switch( rrbp_i ) { case 0: result = (fn_i+13); break; case 1: if((fn_i+18)%13) result = (fn_i+17); else result = (fn_i+18); break; case 2: if(((fn_i+21)%13) EQ 8) result = (fn_i+21); else result = (fn_i+22); break; case 3: result = (fn_i+26); break; default: TRACE_ERROR( "unexpected rrbp value" ); break; } /* switch (rrbp_i) */ result = result % 0x297000; return result; } /* grlc_calc_new_poll_pos() */ /* +------------------------------------------------------------------------------ | Function : grlc_get_new_poll_index +------------------------------------------------------------------------------ | Description : The function grlc_get_new_poll_index() | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL UBYTE grlc_get_new_poll_index ( UBYTE * ptr_list_start_i ) { UBYTE result; TRACE_FUNCTION( "grlc_get_new_poll_index" ); result = *ptr_list_start_i; /* set to new first entry */ if (result NEQ 0xFF) { *ptr_list_start_i = grlc_data->next_poll_array[*ptr_list_start_i].next; /* remove first entry from list */ grlc_data->next_poll_array[result].next = 0xff; } else { TRACE_EVENT ("Poll array is full"); } return(result); } /* grlc_get_new_poll_index() */ /* +------------------------------------------------------------------------------ | Function : grlc_save_poll_pos +------------------------------------------------------------------------------ | Description : The function grlc_save_poll_pos() | | Parameters : fn_i - framenumber | tn_i - timeslot number | rrbp_i - fn of the poll block| | poll_type_i - kind of dl data | pctrl_ack_i - packet control ack value, needed fo p ctr ack msg | | +------------------------------------------------------------------------------ */ GLOBAL void grlc_save_poll_pos ( ULONG fn_i, USHORT tn_i, UBYTE rrbp_i, UBYTE poll_type_i,UBYTE pctrl_ack_i) { ULONG new_poll_pos; UBYTE i, next, help_index; TRACE_FUNCTION( "grlc_save_poll_pos" ); if( tn_i >= POLL_TYPE_ARRAY_SIZE ) { TRACE_EVENT_P5( "grlc_save_poll_pos: fn = %d, tn = %d, rrbp = %d, poll_type = %d, pctrl_ack = %d", fn_i, tn_i, rrbp_i, poll_type_i, pctrl_ack_i ); return; } if(0xFF NEQ rrbp_i) { new_poll_pos = grlc_calc_new_poll_pos(fn_i, rrbp_i); } else { new_poll_pos = fn_i; } /*TRACE_EVENT_P6("SAVE BEF: fn_i= %ld,rrbp=%ld,new_poll_pos=%ld, poll_type=%d,ps=%d ps_fn=%ld", fn_i, rrbp_i, new_poll_pos, poll_type_i, grlc_data->poll_start_tbf, grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn); */ /* delete the poll position when it is older than 26 frames */ while( grlc_data->poll_start_tbf NEQ 0xFF AND grlc_check_dist(new_poll_pos, grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn, 26) EQ FALSE) { /* move the expired poll position to the list of unused entries */ TRACE_EVENT_P1("Remove expired poll at pst=%d",grlc_data->poll_start_tbf); help_index = grlc_data->poll_start_tbf; grlc_data->poll_start_tbf = grlc_data->next_poll_array[help_index].next; grlc_data->next_poll_array[help_index].next = grlc_data->poll_start_free; grlc_data->poll_start_free = help_index; /* clear the poll position */ grlc_data->next_poll_array[help_index].fn = 0xFFFFFFFF; grlc_data->next_poll_array[help_index].cnt = 0; for( i = 0; i < POLL_TYPE_ARRAY_SIZE; i++ ) { grlc_data->next_poll_array[help_index].poll_type[i] = CGRLC_POLL_NONE; } } next = 0xFF; help_index = grlc_data->poll_start_tbf; /* * find the position of the new fn */ while( help_index NEQ 0xFF ) { if( grlc_data->next_poll_array[help_index].fn EQ new_poll_pos ) { next = help_index; help_index = 0xFF; } else if( grlc_check_dist( new_poll_pos, grlc_data->next_poll_array[help_index].fn, 26 ) ) { next = help_index; help_index = grlc_data->next_poll_array[help_index].next; } else { help_index = 0xFF; } } /* * new_poll_pos is present in the poll array */ if( next NEQ 0xFF AND grlc_data->next_poll_array[next].fn EQ new_poll_pos AND grlc_data->next_poll_array[next].poll_type[tn_i] EQ CGRLC_POLL_NONE ) { /* * no collision */ grlc_data->next_poll_array[next].poll_type[tn_i] = poll_type_i; grlc_data->next_poll_array[next].cnt++; grlc_data->next_poll_array[next].ctrl_ack = pctrl_ack_i; } else if( next NEQ 0xFF AND grlc_data->next_poll_array[next].fn EQ new_poll_pos ) { /* * collision detected, if both pos were received with data blocks, the sent * RLC/MAC block otherwise send packet control ack. */ if ((poll_type_i NEQ CGRLC_POLL_DATA) OR (grlc_data->next_poll_array[next].poll_type[tn_i] NEQ CGRLC_POLL_DATA)) { grlc_data->next_poll_array[next].poll_type[tn_i] = CGRLC_POLL_COLLISION; TRACE_EVENT("collision detected: pca will sent"); } else { TRACE_EVENT("collision detected: rlc/mac will be sent"); } if(pctrl_ack_i NEQ 3) grlc_data->next_poll_array[next].ctrl_ack = pctrl_ack_i; } else { /* * fn does not exist in the poll list, included in poll list * * get new free index from the free list */ i = grlc_get_new_poll_index(&(grlc_data->poll_start_free)); if( i EQ 0xFF ) { TRACE_EVENT ("Poll array is full"); /*This should not happen */ return; } grlc_data->next_poll_array[i].cnt = 1; grlc_data->next_poll_array[i].fn = new_poll_pos; grlc_data->next_poll_array[i].poll_type[tn_i] = poll_type_i; grlc_data->next_poll_array[i].ctrl_ack = pctrl_ack_i; if( next EQ 0xFF ) { /* * first entry in poll array */ grlc_data->next_poll_array[i].next = grlc_data->poll_start_tbf; grlc_data->poll_start_tbf = i; } else if( next < NEXT_POLL_ARRAY_SIZE ) { /* * include in description list, is not first element */ grlc_data->next_poll_array[i].next = grlc_data->next_poll_array[next].next; grlc_data->next_poll_array[next].next = i; } else { TRACE_ASSERT( next < NEXT_POLL_ARRAY_SIZE ); } } /*TRACE_EVENT_P6("SAVE AFTER: fn_i= %ld,rrbp=%ld,new_poll_pos=%ld, poll_type=%d,ps=%d ps_fn=%ld", fn_i, rrbp_i, new_poll_pos, poll_type_i, grlc_data->poll_start_tbf, grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn); */ } /* grlc_save_poll_pos() */ /* +------------------------------------------------------------------------------ | Function : grlc_encode_ctrl +------------------------------------------------------------------------------ | Description : The function grlc_encode_ctrl() build a T_SDU buffer that | contains the encode Ctrl Block ready to transmit. | | Parameters : ULONG ptr_in_i - ptr to the input structure | ULONG ptr_out_i - ptr to begin of output buffer | UBYTE r_bit_i - value of r_bit +------------------------------------------------------------------------------ */ GLOBAL void grlc_encode_ctrl ( UBYTE * ptr_in_i, T_MSGBUF * ptr_out_i, UBYTE r_bit_i) { TRACE_FUNCTION( "grlc_encode_ctrl" ); ptr_out_i->buf[0] = 0x40 | r_bit_i; ptr_out_i->o_buf = BIT_UL_CTRL_BLOCK_MAC_HEADER; ptr_out_i->l_buf = BIT_UL_CTRL_BLOCK_CONTENTS; if(!grlc_data->grlc_wo_ccd) { ccd_codeMsg ( CCDENT_GRLC, UPLINK, ptr_out_i, ptr_in_i, NOT_PRESENT_8BIT); } else { switch(ptr_in_i[0]) /* msg_type */ { case U_GRLC_UL_DUMMY_c: grlc_encode_ul_dummy(&ptr_out_i->buf[1]); break; case U_GRLC_CTRL_ACK_c: grlc_encode_pca(&ptr_out_i->buf[1]); break; case U_GRLC_DL_ACK_c: memset(&ptr_out_i->buf[1],0,22); /*lint !e419*/ grlc_encode_dl_acknack(&ptr_out_i->buf[1]); break; default: ccd_codeMsg ( CCDENT_GRLC, UPLINK, ptr_out_i, ptr_in_i, NOT_PRESENT_8BIT); break; } } ptr_out_i->l_buf += ptr_out_i->o_buf; ptr_out_i->o_buf = 0; } /* grlc_encode_ctrl() */ /* +------------------------------------------------------------------------------ | Function : grlc_init +------------------------------------------------------------------------------ | Description : The function grlc_init initializes the entity GRLC | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grlc_init ( void ) { TRACE_FUNCTION( "grlc_init" ); /* initialize all GRLC data */ grlc_data = &grlc_data_base; memset( grlc_data, 0, sizeof( T_GRLC_DATA ) ); grlc_data->grlc_data_req_cnt = 0; grlc_data->testmode.mode = CGRLC_NO_TEST_MODE; grlc_data->meas.sq_restart = TRUE; /* * call of service init functions */ tm_grlc_init(); rd_init(); ru_init(); meas_grlc_init(); tpc_grlc_init(); gff_init(); ccd_register(CCD_REENTRANT); #ifdef _SIMULATION_ /* * to make sure that the structure definitions of T_GRLC_DATA_REQ and * T_GRLC_UNITDATA_REQ have the same layout. */ { T_GRLC_DATA_REQ * ptr_grlc_data_req = (T_GRLC_DATA_REQ *)_decodedMsg; T_GRLC_UNITDATA_REQ * ptr_grlc_unitdata_req = (T_GRLC_UNITDATA_REQ *)_decodedMsg; if( &(ptr_grlc_data_req->grlc_qos) NEQ &(ptr_grlc_unitdata_req->grlc_qos) AND &(ptr_grlc_data_req->radio_prio) NEQ &(ptr_grlc_unitdata_req->radio_prio) AND &(ptr_grlc_data_req->sdu) NEQ &(ptr_grlc_unitdata_req->sdu) AND &(ptr_grlc_data_req->tlli) NEQ &(ptr_grlc_unitdata_req->tlli) ) { /* * In this case the primitive handling will not work correctly!!! */ TRACE_ERROR("Fatal ERROR: T_GRLC_UNITDATA_REQ and T_GRLC_DATA_REQ are not equal!!"); } } /* _SIMULATION_ */ #endif grlc_data->t3164_to_cnt = 0; grlc_data->ul_tfi_changed = FALSE; grlc_data->uplink_tbf.access_type = CGRLC_AT_NULL; /* NO CELL UPDATE NEED */ grlc_data->grlc_wo_ccd = 0; /* as default ccd used for air message handling */ /* * Ready Timer state initialization */ #ifdef FF_GRLC_4_TWO_2_ONE grlc_data->ready_timer.handling = READY_TIMER_HANDLING_ENABLED; #else grlc_data->ready_timer.handling = READY_TIMER_HANDLING_DISABLED; #endif grlc_data->ready_timer.state = STANDBY_STATE; grlc_data->ready_timer.value = CGRLC_T3314_DEFAULT; } /* grlc_init() */ /* +------------------------------------------------------------------------------ | Function : grlc_prim_put +------------------------------------------------------------------------------ | Description : The function grlc_prim_put() put a Element (object_i) behind | pos_i in the prim_queue. | | Parameters : list_start_i - address of the list should be manipulted | object_i - index of element that should be added to the list | pos_i - index of the position behind that the object | should be added | +------------------------------------------------------------------------------ */ GLOBAL void grlc_prim_put(UBYTE * list_start_i, UBYTE object_i, UBYTE pos_i) { TRACE_FUNCTION( "grlc_prim_put" ); if(* list_start_i EQ 0xff) { /* no elements in the list */ * list_start_i = object_i; } else { /* elements in the list */ UBYTE i = * list_start_i; UBYTE j; BOOL put= FALSE; /* * SZML-GLBL/004 */ for(j=0;j<PRIM_QUEUE_SIZE_TOTAL;j++) { if (grlc_data->prim_queue[i].next NEQ pos_i) { i = grlc_data->prim_queue[i].next; } else { /* * put new object at pos_i of queue */ put = TRUE; grlc_data->prim_queue[object_i].next = grlc_data->prim_queue[i].next; grlc_data->prim_queue[i].next = object_i; break; } } if(!put) TRACE_EVENT_P3("PST=%d PSF=%d PDU=%d: grlc_prim_put failed" ,grlc_data->prim_start_tbf ,grlc_data->prim_start_free ,grlc_data->grlc_data_req_cnt); } } /* grlc_prim_put() */ /* +------------------------------------------------------------------------------ | Function : grlc_prim_get_first +------------------------------------------------------------------------------ | Description : The function grlc_prim_get_first() removes the first element | and returns the index of the first element. | | Parameters : list_start_i - address of the list that should be used | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grlc_prim_get_first(UBYTE * list_start_i) { UBYTE result; TRACE_FUNCTION( "grlc_prim_get_first" ); result = *list_start_i; /* * set to new first entry */ *list_start_i = grlc_data->prim_queue[*list_start_i].next; /* * remove first entry from list */ grlc_data->prim_queue[result].next = 0xff; return(result); } /* grlc_prim_get_first() */ /* +------------------------------------------------------------------------------ | Function : grlc_set_packet_ctrl_ack +------------------------------------------------------------------------------ | Description : The function grlc_set_packet_ctrl_ack() | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL UBYTE * grlc_set_packet_ctrl_ack(void) { MCAST(u_ctrl_ack,U_GRLC_CTRL_ACK); UBYTE * result; TRACE_FUNCTION( "grlc_set_packet_ctrl_ack" ); u_ctrl_ack->msg_type = U_GRLC_CTRL_ACK_c; grlc_set_buf_tlli( &u_ctrl_ack->tlli_value, grlc_data->uplink_tbf.tlli ); if(grlc_data->poll_start_tbf NEQ 0xFF) u_ctrl_ack->pctrl_ack = grlc_data->next_poll_array[grlc_data->poll_start_tbf].ctrl_ack; else /* response to IA poll */ u_ctrl_ack->pctrl_ack = 3; result = _decodedMsg; return(result); } /* grlc_set_packet_ctrl_ack() */ /* +------------------------------------------------------------------------------ | Function : grlc_send_access_burst +------------------------------------------------------------------------------ | Description : The function grlc_send_access_burst() sents the poll as | four access burst type | | Parameters : tn_i : timeslot where the access burst shall send | +------------------------------------------------------------------------------ */ GLOBAL void grlc_send_access_burst(UBYTE tn_i) { TRACE_FUNCTION( "grlc_send_access_burst" ); if(grlc_data->poll_start_tbf NEQ 0xFF) { grlc_data->next_poll_array[grlc_data->poll_start_tbf].cnt--; grlc_data->next_poll_array[grlc_data->poll_start_tbf].poll_type[tn_i] = CGRLC_POLL_NONE; grlc_data->next_poll_fn = grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn; } grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].tn = tn_i; if(grlc_data->ab_type EQ CGRLC_AB_11_BIT) { /*11 bit access burst*/ USHORT elevenBit = 0x07E4+grlc_data->next_poll_array[grlc_data->poll_start_tbf].ctrl_ack; grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].block_status = 8; grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].ul_block[0] = grlc_convert_11bit_2_etsi(elevenBit); /* TRACE_EVENT_P2("PCA AB_11_BIT sent fn_i= %ld PRACH11: %d" ,grlc_data->next_poll_fn ,grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].ul_block[0]); */ } else { /*8 bit access burst*/ grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].block_status = 7; grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].ul_block[0] = (0x7C+grlc_data->next_poll_array[grlc_data->poll_start_tbf].ctrl_ack); /* TRACE_EVENT_P1 ("PCA 8 bit access burst sent fn_i= %ld ",grlc_data->next_poll_fn); */ } #ifdef _SIMULATION_ { PALLOC(mac_poll_req,MAC_POLL_REQ); memset(mac_poll_req,0, sizeof(T_MAC_POLL_REQ)); memcpy(&(mac_poll_req->ul_poll_resp), &(grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index]), sizeof(T_ul_poll_resp)); PSEND(hCommL1,mac_poll_req); } #else /* #ifdef _SIMULATION_ */ { TRACE_MEMORY_PRIM ( hCommGRLC, hCommL1, MAC_POLL_REQ, &grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index], sizeof(T_ul_poll_resp) ); } #endif /* #ifdef _SIMULATION_ */ TRACE_BINDUMP ( hCommGRLC, TC_USER4, cl_rlcmac_get_msg_name( U_MSG_TYPE_CHANNEL_REQ_c, RLC_MAC_ROUTE_UL ), grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].ul_block, RLC_MAC_MAX_LEN_CHANNEL_REQ ); /*lint !e569*/ grlc_data->ul_poll_pos_index++; /* * next poll block invalid */ grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].block_status = 0; } /* grlc_send_access_burst() */ /* +------------------------------------------------------------------------------ | Function : grlc_send_normal_burst +------------------------------------------------------------------------------ | Description : The function grlc_send_normal_burst() sents the poll as | normal burst type | | Parameters : ptr_block_i : ptr to the ctrl message | Parameters : tn_i : timeslot where the access burst shall send | Parameters : r_bit_i : r bit needed for the mac header | +------------------------------------------------------------------------------ */ GLOBAL void grlc_send_normal_burst (UBYTE * struct_data, UBYTE * encoded_data, UBYTE tn_i) { TRACE_FUNCTION( "grlc_send_normal_burst" ); if( (grlc_data->poll_start_tbf NEQ 0xFF) AND (grlc_data->ta_value EQ 0xFF) ) { TRACE_EVENT_P2("No TA VALUE IN GRLC --> NB POLL NOT SENT ta=%d poll_st_tbf=%d" ,grlc_data->ta_value ,grlc_data->poll_start_tbf); TRACE_ERROR("No TA VALUE IN GRLC --> NB POLL NOT SENT"); grlc_data->next_poll_array[grlc_data->poll_start_tbf].cnt--; grlc_data->next_poll_array[grlc_data->poll_start_tbf].poll_type[tn_i] = CGRLC_POLL_NONE; return; } /* * either encoded data or structured data are passed by reference */ if( struct_data NEQ NULL ) { grlc_encode_ul_ctrl_block( ( UBYTE* )grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].ul_block, struct_data ); } else if( encoded_data NEQ NULL ) { memcpy( ( UBYTE* )grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].ul_block, encoded_data, BYTE_UL_CTRL_BLOCK ); } else { TRACE_ERROR( "grlc_send_normal_burst: no data available" ); } grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].tn = tn_i; grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].block_status = 3; if(grlc_data->poll_start_tbf NEQ 0xFF) { grlc_data->next_poll_array[grlc_data->poll_start_tbf].cnt--; grlc_data->next_poll_array[grlc_data->poll_start_tbf].poll_type[tn_i] = CGRLC_POLL_NONE; grlc_data->next_poll_fn = grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn; } #ifdef _SIMULATION_ { PALLOC(mac_poll_req,MAC_POLL_REQ); memset(mac_poll_req,0, sizeof(T_MAC_POLL_REQ)); memcpy(&(mac_poll_req->ul_poll_resp), &(grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index]), sizeof(T_ul_poll_resp)); PSEND(hCommL1,mac_poll_req); } #else /* #ifdef _SIMULATION_ */ { TRACE_MEMORY_PRIM ( hCommGRLC, hCommL1, MAC_POLL_REQ, &grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index], sizeof(T_ul_poll_resp) ); } #endif /* #ifdef _SIMULATION_ */ { UBYTE* ul_block = ( UBYTE* )grlc_data->ul_poll_resp[grlc_data->ul_poll_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->ul_poll_pos_index++; /* * next poll block invalid */ grlc_data->ul_poll_resp[grlc_data->ul_poll_pos_index].block_status = 0; /* TRACE_EVENT_P1 ("Normal burst sent at fn_i= %ld ",grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn); */ } /* grlc_send_normal_burst() */ /* +------------------------------------------------------------------------------ | Function : grlc_del_sent_poll +------------------------------------------------------------------------------ | Description : The function grlc_del_sent_poll() deletes the poll pos which was | sent to L1 | | Parameters | +------------------------------------------------------------------------------ */ GLOBAL void grlc_del_sent_poll(void ) { UBYTE help_index; UBYTE next_index; TRACE_FUNCTION( "grlc_del_sent_poll" ); if( grlc_data->next_poll_array[grlc_data->poll_start_tbf].cnt EQ 0 ) { help_index = grlc_data->poll_start_tbf; grlc_data->poll_start_tbf = grlc_data->next_poll_array[grlc_data->poll_start_tbf].next; next_index = grlc_data->poll_start_free; while(grlc_data->next_poll_array[next_index].next NEQ 0xFF) { next_index = grlc_data->next_poll_array[next_index].next; } grlc_data->next_poll_array[next_index].next = help_index; grlc_data->next_poll_array[help_index].next = 0xFF; } } /* grlc_del_sent_poll() */ /* +------------------------------------------------------------------------------ | Function : grlc_decode_tbf_start_rel |------------------------------------------------------------------------------ | Description : The function grlc_decode_tbf_start_rel() translates the TBF- | Starting-Time-Relative into full frame number. Therefore the | received frame number is needed in start_fn !! | | Parameters : rel_pos - number in blocks added to current framenuber | +------------------------------------------------------------------------------ */ GLOBAL ULONG grlc_decode_tbf_start_rel(ULONG start_fn, USHORT rel_pos) { ULONG result; TRACE_FUNCTION( "grlc_decode_tbf_start_rel" ); result = 4+4*rel_pos + start_fn + rel_pos/3; if ((12 EQ (result%13)) OR (7 EQ (result%13)) OR (3 EQ (result%13))) { result += 1; } if(FN_MAX <= result) { result %= FN_MAX; } return result; } /* grlc_decode_tbf_start_rel */ /* +------------------------------------------------------------------------------ | Function : grlc_get_sdu_len_and_used_ts +------------------------------------------------------------------------------ | Description : | | Parameters : * sdu_len - len of the current sdu in progress | * used_ul_resources - used uplink resources in fixed alloc mode | +------------------------------------------------------------------------------ */ GLOBAL void grlc_get_sdu_len_and_used_ts ( T_RLC_VALUES * values ) { TRACE_FUNCTION( "grlc_get_sdu_len_and_used_ts" ); switch( GET_STATE( RU ) ) { case RU_NULL: values->sdu_len = grlc_data->prim_queue[grlc_data->prim_start_tbf].prim_ptr->sdu.l_buf/8; values->cnt_ts = 0; break; default: values->sdu_len = grlc_data->ru.sdu_len; values->cnt_ts = grlc_data->ru.cnt_ts; break; } /* grlc_get_sdu_len_and_used_ts() */ } /* +------------------------------------------------------------------------------ | Function : grlc_check_dist +------------------------------------------------------------------------------ | Description : The function grlc_check_dist() checks if high_i is bigger/equal | than low_i(modulo calculation). | The return value is true, if high_i is equal to low_i or | bigger than low_i. | Parameters : high_i - expected high value | low_i - expected low value | dist_i - max. allowed distance between high_i and low_i +------------------------------------------------------------------------------ */ GLOBAL BOOL grlc_check_dist ( ULONG high_i, ULONG low_i, ULONG dist_i) { BOOL result = FALSE; ULONG real_dist; TRACE_FUNCTION( "grlc_check_dist" ); if (high_i >= low_i) real_dist = high_i - low_i; else real_dist = high_i + (FN_MAX-low_i); if (real_dist <= dist_i ) { result = TRUE; } return result; } /* grlc_check_dist() */ /* +------------------------------------------------------------------------------ | Function : grlc_handle_poll_pos +------------------------------------------------------------------------------ | Description : The function grlc_handle_poll_pos() | | Parameters : - +------------------------------------------------------------------------------ */ GLOBAL void grlc_handle_poll_pos (ULONG current_fn) { UBYTE help_index; UBYTE next_index; TRACE_FUNCTION( "grlc_handle_poll_pos" ); while ( (grlc_data->poll_start_tbf NEQ 0xFF) AND (grlc_check_dist(current_fn,grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn,26)) AND (current_fn NEQ grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn)) { TRACE_EVENT_P4("current_fn= %ld missed poll_fn=%ld ps_tbf=%d cnt=%d", current_fn, grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn, grlc_data->poll_start_tbf, grlc_data->next_poll_array[grlc_data->poll_start_tbf].cnt); /* * delete elememnt from tbf_list if all pollType = POLL_NONE, and add to free list */ grlc_data->missed_poll_fn = grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn; grlc_data->next_poll_array[grlc_data->poll_start_tbf].cnt = 0; help_index = grlc_data->poll_start_tbf; grlc_data->poll_start_tbf = grlc_data->next_poll_array[grlc_data->poll_start_tbf].next; next_index = grlc_data->poll_start_free; while(grlc_data->next_poll_array[next_index].next NEQ 0xFF) { next_index = grlc_data->next_poll_array[next_index].next; } grlc_data->next_poll_array[next_index].next = help_index; grlc_data->next_poll_array[help_index ].next = 0xFF; TRACE_ERROR( "Poll Position missed" ); } } /* grlc_handle_poll_pos() */ /* +------------------------------------------------------------------------------ | Function : grlc_send_rem_poll_pos +------------------------------------------------------------------------------ | Description : The function grlc_send_rem_poll_pos() | | Parameters : - +------------------------------------------------------------------------------ */ GLOBAL void grlc_send_rem_poll_pos (ULONG current_fn) { ULONG delta_fn = 0; UBYTE *ptr_block=NULL; TRACE_FUNCTION( "grlc_send_rem_poll_pos" ); if (grlc_data->poll_start_tbf EQ 0xFF) return; #ifdef _TARGET_ delta_fn = grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn; if(current_fn EQ FN_MAX-5) delta_fn += 5; else delta_fn -= current_fn; #endif #ifdef _SIMULATION_ if(current_fn EQ grlc_data->next_poll_array[grlc_data->poll_start_tbf].fn) delta_fn = 4; else delta_fn = 0; #endif if( (delta_fn EQ 4) OR (delta_fn EQ 5) ) { UBYTE tn=0; UBYTE index; while(grlc_data->next_poll_array[grlc_data->poll_start_tbf].cnt AND (tn < 8)) { switch(grlc_data->next_poll_array[grlc_data->poll_start_tbf].poll_type[tn]) { case CGRLC_POLL_CTRL: case CGRLC_POLL_UACK: case CGRLC_POLL_COLLISION: if(grlc_data->burst_type EQ CGRLC_BURST_TYPE_NB) { ptr_block = grlc_set_packet_ctrl_ack(); grlc_send_normal_burst(ptr_block, NULL, tn); } else grlc_send_access_burst(tn); break; case CGRLC_POLL_RES_AB: grlc_send_access_burst(tn); break; case CGRLC_POLL_RES_NB: ptr_block = grlc_set_packet_ctrl_ack(); grlc_send_normal_burst(ptr_block, NULL, tn); break; case CGRLC_POLL_DATA: if( grlc_data->tbf_type EQ TBF_TYPE_UL ) { /* * no downlink active , send ctrl block or pca */ if( tm_get_num_ctrl_blck( ) NEQ 0 ) { ptr_block = tm_get_ctrl_blk( &index, TRUE ); grlc_send_normal_burst(NULL, ptr_block, tn); grlc_data->rd.next_poll_block = NEXT_POLL_BLOCK_DL_DATA; } else if(grlc_data->burst_type EQ CGRLC_BURST_TYPE_NB) { ptr_block = grlc_set_packet_ctrl_ack(); grlc_send_normal_burst(ptr_block, NULL, tn); } else grlc_send_access_burst(tn); } break; #if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH case CGRLC_POLL_RE_ASS: /* TBF re assignment on PACCH */ if(grlc_data->burst_type EQ CGRLC_BURST_TYPE_NB) { T_U_GRLC_RESOURCE_REQ resource_req; tm_build_res_req( &resource_req,R_BUILD_2PHASE_ACCESS); grlc_send_normal_burst((UBYTE *)&resource_req, NULL, tn); } else /* PCA CTRL ACK 00 */ { grlc_data->next_poll_array[grlc_data->poll_start_tbf].ctrl_ack = 0; grlc_send_access_burst(tn); } break; #endif } tn++; } grlc_del_sent_poll(); } }/* grlc_send_rem_poll_pos() */ /* +------------------------------------------------------------------------------ | Function : grlc_test_mode_active +------------------------------------------------------------------------------ | Description : This functions returns 0 if the GPRS test mode is not activated. | Otherwise a value greater then 0. | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grlc_test_mode_active () { if(grlc_data->testmode.mode NEQ CGRLC_NO_TEST_MODE) return TRUE; else return FALSE; }/* grlc_test_mode_active*/ /* +------------------------------------------------------------------------------ | Function : grlc_prbs +------------------------------------------------------------------------------ | Description : | This function generates a pseodo random bis sequence. | The implementation is related to CCITT O.151 Okt. 92 chapter 2.1 . | | This functions generates the next length_i bytes of a 32767-bit | pseudo-random test sequence if action_i is set to COMPUTE_DATA | and writes the data at address ptr_i. | | The function stores the position where it stops to calculate. | In case of action_i EQ INITIALIZE the function erase his history. | On its next call the function continues with its intial values | | Parameters : UBYTE action_i (INITIALIZE or COMPUTE_DATA) | and only | UBYTE length_i (number of data bytes which shall callculated and copied) | UBYTE * out_i (location where this dada have to be placed, only valid) | +------------------------------------------------------------------------------ */ GLOBAL void grlc_prbs(UBYTE action_i, UBYTE length_i, UBYTE * ptr_i) { TRACE_FUNCTION( "grlc_prbs" ); switch(action_i) { case INITIALIZE: #define FEED_BACK_MASK 0x6000 /* * 14th and 15 stage will be feeded back */ /* * Initialize the prbs generation * * This value is the value of the shift register 8 cycles * before shift register value 0x7fff */ grlc_data->testmode.prbs_shift_reg = 0x55ff; break; case COMPUTE_DATA: { /* * get prbs computing values */ USHORT i,reg = grlc_data->testmode.prbs_shift_reg; UBYTE * out_ptr = ptr_i; for(i=0; i < (8 * length_i); i++) { /* * write a byte in output if neccessary */ if(i % 8 EQ 0) { *out_ptr++ = (UBYTE)(0x00ff®); } { USHORT temp = reg & FEED_BACK_MASK; /* * shift the register and but new data in */ reg = reg << 1; if ( (temp EQ FEED_BACK_MASK) OR (temp EQ 0) ) { /* * put a "0" in */; } else { /* * put a "1" in */ reg +=1; } } /* for(i=0; i < (8 * length_i); i++) */ } /* * store prbs computing values */ grlc_data->testmode.prbs_shift_reg = reg; } break; default: break; } return; }/*grlc_prbs*/ /* +------------------------------------------------------------------------------ | Function : grlc_trace_tbf_par +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grlc_trace_tbf_par ( UBYTE tbf_index ) { TRACE_FUNCTION( "grlc_trace_tbf_par" ); TRACE_EVENT_P9("tbf_type=%d;start_fn=%ld (%ld);end_fn=%ld(%ld);rlc_oct_cnt=%d; pdu_cnt=%ld;vs_vr=%d;va_vq=%d ", grlc_data->tbf_ctrl[tbf_index].tbf_type, grlc_data->tbf_ctrl[tbf_index].start_fn, grlc_data->tbf_ctrl[tbf_index].start_fn%42432, grlc_data->tbf_ctrl[tbf_index].end_fn, grlc_data->tbf_ctrl[tbf_index].end_fn%42432, grlc_data->tbf_ctrl[tbf_index].rlc_oct_cnt, grlc_data->tbf_ctrl[tbf_index].pdu_cnt, grlc_data->tbf_ctrl[tbf_index].vs_vr, grlc_data->tbf_ctrl[tbf_index].va_vq); TRACE_EVENT_P9("cnt_ts=%d;ack_cnt=%d;fbi=%d;ret_bsn=%d;N_ACC=%d,tlli=%lx rem_ul_data=%d,PST=%d,PSF=%d", grlc_data->tbf_ctrl[tbf_index].cnt_ts, grlc_data->tbf_ctrl[tbf_index].ack_cnt, grlc_data->tbf_ctrl[tbf_index].fbi, grlc_data->tbf_ctrl[tbf_index].ret_bsn, grlc_data->tm.n_acc_req_procedures, grlc_data->uplink_tbf.tlli, grlc_data->grlc_data_req_cnt, grlc_data->prim_start_tbf, grlc_data->prim_start_free); } /* grlc_trace_tbf_par */ /* +------------------------------------------------------------------------------ | Function : grlc_set_buf_tlli +------------------------------------------------------------------------------ | Description : The function grlc_set_buf_tlli() fills the TLLI buffer. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grlc_set_buf_tlli ( BUF_tlli_value *buf_tlli_o, ULONG tlli_i ) { TRACE_FUNCTION( "grlc_set_buf_tlli" ); grlc_set_tlli( &buf_tlli_o->l_tlli_value, &buf_tlli_o->o_tlli_value, &buf_tlli_o->b_tlli_value[0], tlli_i ); } /* grlc_set_buf_tlli */ /* +------------------------------------------------------------------------------ | Function : grlc_set_tlli +------------------------------------------------------------------------------ | Description : The function grlc_set_tlli() fills the TLLI buffer. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grlc_set_tlli ( USHORT *l_tlli, USHORT *o_tlli, UBYTE *b_tlli, ULONG tlli ) { TRACE_FUNCTION( "grlc_set_tlli" ); *l_tlli = 32; *o_tlli = 0; b_tlli[0] = (UBYTE)((tlli >> 24) & 0x000000ff); b_tlli[1] = (UBYTE)((tlli >> 16) & 0x000000ff); b_tlli[2] = (UBYTE)((tlli >> 8 ) & 0x000000ff); b_tlli[3] = (UBYTE)((tlli ) & 0x000000ff); /* unused byte must be set to 0x00, otherwise CCD has some problems */ b_tlli[4] = 0; } /* grlc_set_tlli */ /* +------------------------------------------------------------------------------ | Function : grlc_encode_ul_ctrl_block +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grlc_encode_ul_ctrl_block ( UBYTE *ul_ctrl_block, UBYTE *ul_ctrl_data ) { T_CTRLBUF enc_block; TRACE_FUNCTION( "grlc_encode_ul_ctrl_block" ); grlc_encode_ctrl( ul_ctrl_data, ( T_MSGBUF* )&enc_block , grlc_data->r_bit ); memcpy( ul_ctrl_block, enc_block.buf, BYTELEN( enc_block.l_buf ) ); } /* grlc_encode_ul_ctrl_block */ /* +------------------------------------------------------------------------------ | Function : grlc_check_if_tbf_start_is_elapsed +------------------------------------------------------------------------------ | Description : The function grlc_check_if_tbf_start_is_elapsed() checks if | tbf starting time is elapsed or not, modulo calculation is | needed | Parameters : start_fn - tbf starting time | current_fn - current frame number +------------------------------------------------------------------------------ */ GLOBAL BOOL grlc_check_if_tbf_start_is_elapsed ( ULONG start_fn, ULONG current_fn) { BOOL result = FALSE; ULONG d1; /* ULONG d2; */ /* FN_MAX=0x297000 == 2715648 ==125463 seconds(4.62ms per frame) * the starting time is within current_fn-10808 and current_fn+31623 * modulo operation must be taken in account */ TRACE_FUNCTION( "grlc_check_if_tbf_start_is_elapsed" ); /* * handle maximum distance for tbf starting time */ if(start_fn EQ CGRLC_STARTING_TIME_NOT_PRESENT) /*lint !e650*/ { result =TRUE; return result; } d1 = 10808; /* d2 = 31623; */ if( (start_fn <= current_fn) AND ((current_fn-start_fn) <= d1)) { result = TRUE; /*TRACE_EVENT_P2(" case 1: st time elapsed st_fn=%ld c_fn=%ld",start_fn,current_fn);*/ } else if((start_fn >= current_fn) AND (FN_MAX-start_fn+current_fn) <= d1) { result = TRUE; /* TRACE_EVENT_P2("case 2: st time elapsed st_fn=%ld c_fn=%ld",start_fn,current_fn);*/ } /* else { TRACE_EVENT_P2("case 3: WAIT FOR ST TIME st_fn=%ld c_fn=%ld",start_fn,current_fn); } */ return result; } /* grlc_check_if_tbf_start_is_elapsed() */ /* +------------------------------------------------------------------------------ | Function : grlc_decode_grlc +------------------------------------------------------------------------------ | Description : The function grlc_decode_grlc() calls the function ccd_decodeMsg. | After the call the decoded Message is in _decodeCtrlMsg. | | Parameters : msg_ptr_i - pointer to buffer that should be decoded | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grlc_decode_grlc (T_MSGBUF * msg_ptr_i) { UBYTE result; UBYTE msg_type = msg_ptr_i->buf[0] >> 2;; TRACE_FUNCTION( "grlc_decode_grlc" ); /* * Offset must be zero, else code to get msg_type is illegal */ TRACE_ASSERT (msg_ptr_i->o_buf==0); switch (msg_type) { case D_UL_ACK: if(!grlc_data->grlc_wo_ccd) { result = ccd_decodeMsg (CCDENT_GRLC, DOWNLINK, msg_ptr_i, _decodedMsg, NOT_PRESENT_8BIT); } else { result = grlc_decode_ul_acknack(msg_ptr_i->buf); } break; default: TRACE_ERROR(" not Packet ul ack decoded: should nor happen "); result = DELETE_MESSAGE; break; } if ( result EQ ccdError ) { return grlc_ccd_error_handling( CCDENT_GRLC ); } return msg_type; } /* grlc_decode_grlc() */ /* +------------------------------------------------------------------------------ | Function : grlc_activate_tfi +------------------------------------------------------------------------------ | Description : | grlc_activate_tfi modifies tfi´s if tbf starting time is reached | | | Parameters : fn_i is the current framenuber in tbf mode | +------------------------------------------------------------------------------ */ GLOBAL void grlc_activate_tfi (ULONG fn_i) { TRACE_FUNCTION( "grlc_activate_tfi" ); /* 1. check if starting time is reached */ switch(grlc_data->tfi_change) { case TFI_CHANGE_UL: if(grlc_check_if_tbf_start_is_elapsed ( grlc_data->ul_tbf_start_time, ((fn_i+5)%FN_MAX))) { grlc_data->tfi_change = TFI_CHANGE_NULL; grlc_data->ul_tfi = grlc_data->start_fn_ul_tfi; grlc_data->start_fn_ul_tfi = 0xFF; TRACE_EVENT_P2("UL TFI CHANGE St reached st_fn=%ld c_fn=%ld",grlc_data->ul_tbf_start_time,fn_i ); grlc_data->ul_tbf_start_time = CGRLC_STARTING_TIME_NOT_PRESENT; grlc_data->tbf_ctrl[grlc_data->ul_index].tfi = grlc_data->ul_tfi; grlc_data->ul_tfi_changed = TRUE; } break; case TFI_CHANGE_DL: if(grlc_check_if_tbf_start_is_elapsed ( grlc_data->dl_tbf_start_time, fn_i)) { grlc_data->tfi_change = TFI_CHANGE_NULL; grlc_data->dl_tfi = grlc_data->start_fn_dl_tfi; grlc_data->start_fn_dl_tfi = 0xFF; TRACE_EVENT_P2("DL TFI CHANGE St reached st_fn=%ld c_fn=%ld",grlc_data->dl_tbf_start_time,fn_i ); grlc_data->dl_tbf_start_time = CGRLC_STARTING_TIME_NOT_PRESENT; grlc_data->tbf_ctrl[grlc_data->dl_index].tfi = grlc_data->dl_tfi; } break; case TFI_CHANGE_ALL: if(grlc_check_if_tbf_start_is_elapsed ( grlc_data->ul_tbf_start_time, ((fn_i+5)%FN_MAX))) { grlc_data->tfi_change = TFI_CHANGE_DL; grlc_data->ul_tfi = grlc_data->start_fn_ul_tfi; grlc_data->start_fn_ul_tfi = 0xFF; TRACE_EVENT_P2("UL TFI CHANGE(ALL) St reached st_fn=%ld c_fn=%ld",grlc_data->ul_tbf_start_time,fn_i ); grlc_data->ul_tbf_start_time = CGRLC_STARTING_TIME_NOT_PRESENT; grlc_data->tbf_ctrl[grlc_data->ul_index].tfi = grlc_data->ul_tfi; grlc_data->tbf_ctrl[grlc_data->dl_index].tfi = grlc_data->dl_tfi; grlc_data->ul_tfi_changed = TRUE; } if(grlc_check_if_tbf_start_is_elapsed ( grlc_data->dl_tbf_start_time, fn_i)) { if (grlc_data->tfi_change EQ TFI_CHANGE_DL) grlc_data->tfi_change = TFI_CHANGE_NULL; else grlc_data->tfi_change = TFI_CHANGE_UL; grlc_data->dl_tfi = grlc_data->start_fn_dl_tfi; grlc_data->start_fn_dl_tfi = 0xFF; TRACE_EVENT_P2("DL TFI CHANGE(ALL) St reached st_fn=%ld c_fn=%ld",grlc_data->dl_tbf_start_time,fn_i ); grlc_data->dl_tbf_start_time = CGRLC_STARTING_TIME_NOT_PRESENT; } break; } } /* +------------------------------------------------------------------------------ | Function : grlc_t_status +------------------------------------------------------------------------------ | Description : This function returns the remaining time in milliseconds. | A value of 0L is returned in case the timer is not existing or | not running. | | Parameters : t_index : timer index | +------------------------------------------------------------------------------ */ GLOBAL T_TIME grlc_t_status( USHORT t_index ) { T_TIME t_time = 0L; TRACE_FUNCTION( "grlc_t_status" ); vsi_t_status( GRLC_handle, t_index, &t_time ); return( t_time ); } /* grlc_t_status */ /* +------------------------------------------------------------------------------ | Function : grlc_enter_standby_state +------------------------------------------------------------------------------ | Description : This function is called in case the STANDBY state should be | entered. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grlc_enter_standby_state ( void ) { TRACE_FUNCTION( "grlc_enter_standby_state" ); if( grlc_data->ready_timer.handling EQ READY_TIMER_HANDLING_ENABLED ) { if( grlc_data->ready_timer.state EQ READY_STATE ) { /* The ready_timer.state is set to STANDBY_STATE just in case we are not already in this state. The CGRLC_STANDBY_STATE_IND primitives are sent if we move from READY_STATE to STANDBY_STATE only. */ if( grlc_data->ready_timer.value NEQ CGRLC_DEACTIVATED ) { /* If the timer T3314 expires while we are in READY_STATE but the timer is deactivated then the transition to STANDBY_STATE will never occur */ /* If the primitive CGRLC_FORCE_TO_STANDBY_REQ is received when we are in Ready State but the timer is deactivated then the transition to STANDBY_STATE will never occur */ grlc_data->ready_timer.state = STANDBY_STATE; vsi_t_stop( GRLC_handle, T3314 ); { PALLOC(cgrlc_standby_state_ind,CGRLC_STANDBY_STATE_IND); /* T_CGRLC_STANDBY_STATE_IND sent to GMM */ PSEND(hCommGMM,cgrlc_standby_state_ind); } { PALLOC(cgrlc_standby_state_ind,CGRLC_STANDBY_STATE_IND); /* T_CGRLC_STANDBY_STATE_IND sent to GRR */ PSEND(hCommGRR,cgrlc_standby_state_ind); } } else { TRACE_EVENT( "grlc_enter_standby_state: MS enters STANDBY state while T3314 is deactivated" ); } } else { TRACE_EVENT( "grlc_enter_standby_state: MS is already in STANDBY state" ); } } } /* grlc_enter_standby_state */ /* +------------------------------------------------------------------------------ | Function : grlc_enter_ready_state +------------------------------------------------------------------------------ | Description : This function is called in case the READY state should be | entered. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grlc_enter_ready_state ( void ) { TRACE_FUNCTION( "grlc_enter_ready_state" ); if (grlc_data->ready_timer.state EQ STANDBY_STATE) { /* The ready_timer.state is set to READY_STATE just in case we are not already in this state. The CGRLC_READY_STATE_IND primitives are sent only if we move from STANDBY_STATE to READY_STATE */ /* If we receive the primitive CGRLC_READY_TIMER_CONFIG_REQ with timer value CGRLC_DEACTIVATED when we are in CGRLC_STANDBY, the state will immediately switch to READY and the CGRLC_READY_STATE_IND primitives will be sent */ grlc_data->ready_timer.state = READY_STATE; { PALLOC(cgrlc_ready_state_ind,CGRLC_READY_STATE_IND); /* T_CGRLC_READY_STATE_IND sent to GMM */ PSEND(hCommGMM,cgrlc_ready_state_ind); } { PALLOC(cgrlc_ready_state_ind,CGRLC_READY_STATE_IND); /* T_CGRLC_READY_STATE_IND sent to GRR */ PSEND(hCommGRR,cgrlc_ready_state_ind); } } else { TRACE_EVENT( "grlc_enter_ready_state: MS is already in READY state" ); } } /* grlc_enter_ready_state */ /* +------------------------------------------------------------------------------ | Function : grlc_convert_11bit_2_etsi +------------------------------------------------------------------------------ | Description : Converts the 11 bit access burst value into ETSI format | | Parameters : In: eleven bit value | Out: converted eleven bit | +------------------------------------------------------------------------------ */ LOCAL USHORT grlc_convert_11bit_2_etsi ( USHORT eleven_bit ) { USHORT etsi11bit; USHORT dummy1 = 0, dummy2 = 0; TRACE_FUNCTION( "grlc_convert_11bit_2_etsi" ); /* * 11 Bit access burst * b: bit * b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 * should be sent to the network -according 04.60 and 0404- in the * following 16-bit format: * 0 0 0 0 0 b2 b1 b0 b10 b9 b8 b7 b6 b5 b4 b3 */ /* * get b2 b1 b0 */ dummy1 = 0x0007 & eleven_bit; /* * shift it 8 bits to left */ dummy1 = ( dummy1 << 8 ); /* * get b10 b9 b8 b7 b6 b5 b4 b3 */ dummy2 = 0xFFF8 & eleven_bit; /* * shift it 3 bits to right */ dummy2 = ( dummy2 >> 3 ); /* * compose dummy1 and dummy2 to the target 16-bit format */ etsi11bit = dummy1 | dummy2; return etsi11bit; } /* grlc_convert_11bit_2_etsi() */