FreeCalypso > hg > fc-selenite
view src/g23m-gprs/grr/grr_tcs.c @ 172:a0f935d68377
targets: gtm900 added
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Wed, 19 Jun 2019 04:38:43 +0000 |
| parents | d393cd9bb723 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GPRS (8441) | Modul : GRR +----------------------------------------------------------------------------- | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose : This module implements signal handler functions for service | TC of entity GRR. +----------------------------------------------------------------------------- */ #ifndef GRR_TCS_C #define GRR_TCS_C #endif #define ENTITY_GRR /*==== INCLUDES =============================================================*/ #include <string.h> #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ #include "macdef.h" #include "gprs.h" #include "gsm.h" /* to get a lot of macros */ #include "ccdapi.h" /* to get CCD API */ #include "cnf_grr.h" /* to get cnf-definitions */ #include "mon_grr.h" /* to get mon-definitions */ #include "prim.h" /* to get the definitions of used SAP and directions */ #include "message.h" /* to get air message definitions */ #include "grr.h" /* to get the global entity definitions */ #include "grr_f.h" /* to get the global entity definitions */ #include "grr_tcf.h" /* to get the service TC procedure definitions */ #include "grr_tcs.h" /* to get the service TC signal definitions */ #include "grr_ctrls.h" /* to get the service CTRL signal definitions */ #include "grr_cpaps.h" /* to get the service CPAP signal definitions */ #include "grr_meass.h" #include "grr_psif.h" /* stop timers in Testmode A */ #include "cl_rlcmac.h" /*==== CONST ================================================================*/ /*==== DIAGNOSTICS ==========================================================*/ /*==== LOCAL TYPES===========================================================*/ LOCAL void tc_handle_new_cell ( BOOL cell_has_changed, UBYTE enable_cause ); /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /* +------------------------------------------------------------------------------ | Function : tc_handle_new_cell +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void tc_handle_new_cell ( BOOL cell_has_changed, UBYTE enable_cause ) { UBYTE queue_mode; TRACE_FUNCTION( "tc_handle_new_cell" ); if( cell_has_changed ) { /* inform CPAP because it has to stop T3142 if running */ sig_tc_cpap_new_cell(); grr_data->ta_params.ta_valid = FALSE; TRACE_EVENT_P1( "tc_handle_new_cell: N3102 = %d", psc_db->gprs_cell_opt.pan_struct.pmax ); } queue_mode = ( enable_cause EQ CGRLC_ENAC_NORMAL ? CGRLC_QUEUE_MODE_GMM : CGRLC_QUEUE_MODE_LLC ); tc_cgrlc_enable_req( queue_mode, CGRLC_RA_DEFAULT, cell_has_changed, enable_cause ); } /* tc_handle_new_cell() */ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : tc_get_ctrl_blk +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL UBYTE* tc_get_ctrl_blk ( UBYTE *index, BOOL unacknowledged ) { UBYTE *ctrl_blk; TRACE_FUNCTION( "tc_get_ctrl_blk" ); ctrl_blk = tc_set_start_ctrl_blk( index ); if( unacknowledged ) { /* * in case the control blocks are send by the service RU, we are * working in unacknowledged mode, so every block is transmitted * succesfully */ tc_set_stop_ctrl_blk( TRUE, CGRLC_BLK_OWNER_NONE, 0 ); } return( ctrl_blk ); } /* tc_get_ctrl_blk() */ /* +------------------------------------------------------------------------------ | Function : tc_is_ctrl_blk_rdy +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL BOOL tc_is_ctrl_blk_rdy ( UBYTE ack_cnt_meas_rpt, UBYTE ack_cnt_other ) { BOOL result = FALSE; T_BLK_INDEX blk_index = grr_data->tc.ul_ctrl_blk.seq[0]; TRACE_FUNCTION( "tc_is_ctrl_blk_rdy" ); if( blk_index NEQ MAX_CTRL_BLK_NUM ) { switch( grr_data->tc.ul_ctrl_blk.blk[blk_index].owner ) { case( CGRLC_BLK_OWNER_MEAS ): case( CGRLC_BLK_OWNER_CS ): result = ( ack_cnt_meas_rpt EQ 0 ); break; default : result = ( ack_cnt_other EQ 0 ); break; } } return( result ); } /* tc_is_ctrl_blk_rdy() */ /* +------------------------------------------------------------------------------ | Function : tc_get_num_ctrl_blck +------------------------------------------------------------------------------ | Description : This function returns the number of allocated control blocks. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL UBYTE tc_get_num_ctrl_blck ( void ) { UBYTE i = 0; /* used for counting */ UBYTE num = 0; /* number of allocated control blocks */ TRACE_FUNCTION( "tc_get_num_ctrl_blck" ); while( i < MAX_CTRL_BLK_NUM AND grr_data->tc.ul_ctrl_blk.seq[i] NEQ MAX_CTRL_BLK_NUM ) { if( grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].state EQ BLK_STATE_ALLOCATED ) { num++; } i++; } return( num ); } /* tc_get_num_ctrl_blck() */ /* +------------------------------------------------------------------------------ | Function : tc_cpy_ctrl_blk_to_buffer +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL UBYTE tc_cpy_ctrl_blk_to_buffer( UBYTE *buffer ) { UBYTE index; UBYTE *ctrl_block = tc_get_ctrl_blk( &index, FALSE ); TRACE_FUNCTION( "tc_cpy_ctrl_blk_to_buffer" ); if( ctrl_block NEQ NULL ) { memcpy( buffer, ctrl_block, BYTE_UL_CTRL_BLOCK ); grr_data->tc.v_sb_without_tbf = FALSE; /* * After copying Measurement reports (PIM) in single block req * v_sb_without_tbf is not required */ } else { TRACE_ERROR( "tc_cpy_ctrl_blk_to_buffer: ctrl_block EQ NULL" ); } return( index ); } /* tc_cpy_ctrl_blk_to_buffer() */ /*==== SIGNAL FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_control_block +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_CONTROL_BLOCK | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_control_block ( T_BLK_OWNER blk_owner_i, void * blk_struct_i ) { TRACE_ISIG( "sig_ctrl_tc_control_block " ); switch( GET_STATE( TC ) ) { case TC_ACCESS_DISABLED: case TC_CPAP: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: case TC_WAIT_STOP_TASK_CNF: if( tc_store_ctrl_blk( blk_owner_i, blk_struct_i ) EQ FALSE ) { sig_tc_ctrl_control_block_result( blk_owner_i, FALSE ); } else { tc_send_control_msg_to_grlc(); } break; case TC_SINGLE_BLOCK: case TC_PIM: if( tc_store_ctrl_blk( blk_owner_i, blk_struct_i ) EQ FALSE ) { sig_tc_ctrl_control_block_result( blk_owner_i, FALSE ); } else { /* * check if grlc has to transmit data */ tc_cgrlc_access_status_req(); /* grr_data->tc.v_sb_without_tbf = TRUE; grr_data->uplink_tbf.nr_blocks = 1; grr_data->uplink_tbf.prio = RADIO_PRIO_4; grr_data->uplink_tbf.access_type = CGRLC_AT_SINGLE_BLOCK; grr_data->uplink_tbf.ti = 0; tc_check_access_is_needed( CAC_OTHER );*/ } break; default: sig_tc_ctrl_control_block_result( blk_owner_i, FALSE ); TRACE_ERROR( "SIG_CTRL_TC_CONTROL_BLOCK unexpected" ); break; } } /* sig_ctrl_tc_control_block () */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_cancel_control_block +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_CANCEL_CONTROL_BLOCK | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_cancel_control_block ( T_BLK_OWNER blk_owner_i ) { UBYTE state = GET_STATE( TC ); TRACE_ISIG( "sig_ctrl_tc_cancel_control_block " ); switch( state ) { case TC_CPAP: case TC_WAIT_ASSIGN: if( tc_cancel_ctrl_blk( blk_owner_i ) EQ TRUE ) { if( tc_get_num_ctrl_blck( ) EQ 0 ) { if( state EQ TC_CPAP ) { sig_tc_cpap_abort_access(); } else { SET_STATE( TC, TC_PIM ); tc_send_ra_stop_req( ); vsi_t_stop( GRR_handle, T3170 ); tc_check_access_is_needed( CAC_OTHER ); } } } break; case TC_ACCESS_DISABLED: case TC_POLLING: case TC_PIM: tc_cancel_ctrl_blk( blk_owner_i ); break; case TC_SINGLE_BLOCK: case TC_WAIT_2P_ASSIGN: tc_cancel_ctrl_blk( blk_owner_i ); tc_stop_normal_burst_req( ); break; case TC_TBF_ACTIVE: case TC_CONTENTION_RESOLUTION: tc_cancel_ctrl_blk( blk_owner_i ); tc_handle_error_ra(); break; default: TRACE_EVENT( "SIG_CTRL_TC_CANCEL_CONTROL_BLOCK unexpected" ); break; } } /* sig_ctrl_tc_cancel_control_block () */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_enable_grlc +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_ENABLE_GRLC | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_enable_grlc (UBYTE queue_mode, UBYTE cell_update_cause ) { TRACE_ISIG( "sig_ctrl_tc_enable_grlc" ); if(cell_update_cause EQ GMMRR_RA_CU) tc_cgrlc_enable_req(queue_mode,CGRLC_RA_CU,FALSE,CGRLC_ENAC_NORMAL); else tc_cgrlc_enable_req(queue_mode,CGRLC_RA_DEFAULT,FALSE,CGRLC_ENAC_NORMAL); } /* sig_ctrl_tc_enable_grlc() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_access_disable +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_ACCESS_DISABLE | | Parameters : dc - disable cause | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_access_disable ( T_TC_DISABLE_CAUSE disable_cause, T_TC_DISABLE_CALLBACK_FUNC callback_func ) { UBYTE disable_class; T_TC_DC_CLASS dc_class = ( disable_cause & DCM_CLASS ); T_TC_DC_TYPE dc_type = ( UBYTE )( disable_cause & DCM_TYPE ); UBYTE state = GET_STATE( TC ); UBYTE prim_st = CGRLC_PRIM_STATUS_NULL; TRACE_ISIG( "sig_ctrl_tc_access_disable" ); disable_class = ( dc_class EQ DCC_CR ? CGRLC_DISABLE_CLASS_CR : CGRLC_DISABLE_CLASS_OTHER ); if( grr_data->tc.disable_class EQ CGRLC_DISABLE_CLASS_NULL OR disable_class NEQ CGRLC_DISABLE_CLASS_CR ) { grr_data->tc.disable_class = disable_class; } if ( disable_cause EQ TC_DC_CR_NETWORK) { TRACE_EVENT("T3170 stopped if disable cause is NW CR"); vsi_t_stop(GRR_handle,T3170); } switch( state ) { case TC_CPAP: sig_tc_cpap_abort_access(); SET_STATE( TC, TC_ACCESS_DISABLED ); tc_cgrlc_disable_req(prim_st); callback_func( ); break; case TC_WAIT_2P_ASSIGN: vsi_t_stop( GRR_handle, T3168 ); #if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH if(grr_data->tbf_type EQ CGRLC_TBF_MODE_2PA) { tc_abort_tbf( grr_data->tbf_type ); } else #endif { tc_stop_normal_burst_req( ); } SET_STATE( TC, TC_ACCESS_DISABLED ); if( dc_class EQ DCC_SUSPEND ) { prim_st = CGRLC_PRIM_STATUS_ONE; } tc_cgrlc_disable_req(prim_st); grr_data->tc.disable_callback_func = callback_func; break; case TC_POLLING: case TC_WAIT_ASSIGN: tc_send_ra_stop_req( ); SET_STATE( TC, TC_ACCESS_DISABLED ); if( dc_class EQ DCC_SUSPEND ) { prim_st = CGRLC_PRIM_STATUS_ONE; } tc_cgrlc_disable_req(prim_st); callback_func( ); break; case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: TRACE_EVENT_P1( "SIG_CTRL_TC_ACCESS_DISABLE: %s of TBF", dc_type EQ DCT_NORMAL ? "normal release" : "abort" ); if(!grr_data->tc.two_2p_w_4_tbf_con AND ( dc_type NEQ DCT_NORMAL )) { TRACE_EVENT("SB SUSPEND Before TBF_C"); tc_stop_normal_burst_req( ); SET_STATE( TC, TC_ACCESS_DISABLED ); if( dc_class EQ DCC_SUSPEND ) { prim_st = CGRLC_PRIM_STATUS_ONE; } tc_cgrlc_disable_req(prim_st); } else if( dc_type NEQ DCT_NORMAL ) { if( grr_data->tc.num_of_rels_running EQ 0 OR grr_data->tbf_type NEQ CGRLC_TBF_MODE_NULL ) { tc_abort_tbf( grr_data->tbf_type ); SET_STATE( TC, TC_ACCESS_DISABLED ); } tc_cgrlc_disable_req(prim_st); } grr_data->tc.disable_callback_func = callback_func; break; case TC_SINGLE_BLOCK: tc_stop_normal_burst_req( ); tc_set_stop_all_ctrl_blk( ); tc_cgrlc_disable_req(prim_st); SET_STATE( TC, TC_ACCESS_DISABLED ); grr_data->tc.disable_callback_func = callback_func; break; case TC_PIM: tc_cgrlc_disable_req(prim_st); if( grr_data->tc.num_of_rels_running NEQ 0 ) { /* * disable request during TBF release procedure, * GRR is waiting for RRGRR_STOP_TASK_CNF */ TRACE_EVENT( "SIG_CTRL_TC_ACCESS_DISABLE: TBF release procedure is running" ); grr_data->tc.disable_callback_func = callback_func; } else { SET_STATE( TC, TC_ACCESS_DISABLED ); callback_func( ); } break; default: TRACE_EVENT_P1( "SIG_CTRL_TC_ACCESS_DISABLE in TC state %d", state ); /*lint -fallthrough*/ case TC_ACCESS_DISABLED: case TC_WAIT_STOP_TASK_CNF: tc_cgrlc_disable_req(prim_st); SET_STATE( TC, TC_ACCESS_DISABLED ); if( grr_data->tc.disable_callback_func EQ NULL ) { callback_func( ); } else { grr_data->tc.disable_callback_func = callback_func; } break; } #ifdef _SIMULATION_ tc_stop_timer_t3172(); #endif } /* sig_ctrl_tc_access_disable() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_error_pim +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_ERROR_PIM | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_error_pim ( void ) { TRACE_ISIG( "sig_cpap_tc_error_pim" ); switch( GET_STATE( TC ) ) { case TC_CPAP: SET_STATE( TC, TC_PIM ); tc_handle_error_pim(); break; default: TRACE_ERROR( "SIG_CPAP_TC_ERROR_PIM unexpected" ); break; } } /* sig_cpap_tc_error_pim() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_tbf_created +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_TBF_CREATED | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_tbf_created ( T_TBF_TYPE tbf_type ) { TRACE_ISIG( "sig_cpap_tc_tbf_created" ); switch( GET_STATE( TC ) ) { case TC_CPAP: switch(tbf_type) { case CGRLC_TBF_MODE_UL: SET_STATE(TC,TC_CONTENTION_RESOLUTION); tc_activate_tbf(tbf_type); tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL); break; case CGRLC_TBF_MODE_DL: SET_STATE(TC,TC_TBF_ACTIVE); tc_activate_tbf(tbf_type); tc_cgrlc_dl_tbf_req(); break; default: TRACE_ERROR("unknown tbf type! sig_cpap_tc_tbf_created"); SET_STATE(TC,TC_PIM); break; } break; case TC_PIM: switch(tbf_type) { case CGRLC_TBF_MODE_UL: TRACE_ERROR("unexpected tbf type! sig_cpap_tc_tbf_created"); break; case CGRLC_TBF_MODE_DL: SET_STATE(TC,TC_TBF_ACTIVE); tc_activate_tbf(tbf_type); tc_cgrlc_dl_tbf_req(); break; default: TRACE_ERROR("unknown tbf type! sig_cpap_tc_tbf_created 2"); SET_STATE(TC,TC_PIM); break; } break; default: TRACE_ERROR( "SIG_CPAP_TC_TBF_CREATED unexpected" ); break; } } /* sig_cpap_tc_tbf_created() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_ia_received +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_IA_RECEIVED | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_ia_received (T_RRGRR_IA_IND *rrgrr_ia_ind ) { TRACE_ISIG( "sig_ctrl_tc_ia_received" ); switch( GET_STATE( TC ) ) { case TC_CPAP: case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: sig_tc_cpap_ia_received(rrgrr_ia_ind); break; default: TRACE_ERROR( "sig_ctrl_tc_ia_received unexpected" ); break; } } /* sig_ctrl_tc_ia_received() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_iaext_received +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_IAEXT_RECEIVED | | Parameters : UBYTE indicates the valid immediate assignment | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_iaext_received ( T_RRGRR_IAEXT_IND *rrgrr_iaext_ind ) { TRACE_ISIG( "sig_ctrl_tc_iaext_received" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_cpap_iaext_received ( rrgrr_iaext_ind); break; case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: break; default: TRACE_ERROR( "sig_ctrl_tc_iaext_received unexpected" ); break; } } /* sig_ctrl_tc_iaext_received() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_iarej_received +------------------------------------------------------------------------------ | Description : Handles the internal signal sig_ctrl_tc_iarej_received | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_iarej_received(T_RRGRR_ASSIGNMENT_REJ_IND *rrgrr_assignment_rej_ind ) { TRACE_ISIG( "sig_ctrl_tc_iarej_received" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_cpap_iarej_received(rrgrr_assignment_rej_ind); if(grr_data->cc_running) { SET_STATE(TC,TC_ACCESS_DISABLED) /* * todo:why state change: grlc will be disabled by sending ctrl_tc_disable */ } break; case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: break; default: TRACE_ERROR( "sig_ctrl_tc_iarej_received unexpected" ); break; } } /* sig_ctrl_tc_iarej_received() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_ia_downlink_received +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_IA_DOWNLINK_RECEIVED | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_ia_downlink_received (T_RRGRR_IA_DOWNLINK_IND *rrgrr_ia_downlink_in ) { TRACE_ISIG( "sig_ctrl_tc_ia_downlink_received" ); switch( GET_STATE( TC ) ) { case TC_CPAP: case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: sig_tc_cpap_ia_downlink_received(rrgrr_ia_downlink_in); break; default: sig_tc_ctrl_send_stop_task_req( INVALID_MSG ); TRACE_EVENT_P1( "sig_ctrl_tc_ia_downlink_received unexpected tc_state=%d", grr_data->tc.state); TRACE_ERROR( "sig_ctrl_tc_ia_downlink_received unexpected" ); break; } } /* sig_ctrl_tc_ia_downlink_received() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_stop_task_cnf_received +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_STOP_TASK_CNF | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_stop_task_cnf_received ( void ) { TRACE_ISIG( "sig_ctrl_tc_stop_task_cnf_received" ); switch( GET_STATE( TC ) ) { case TC_CPAP: case TC_PIM: sig_tc_cpap_stop_task_cnf_received(); break; default: TRACE_ERROR( "SIG_CTRL_TC_STOP_TASK_CNF unexpected" ); break; } } /* sig_ctrl_tc_stop_task_cnf_received() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_send_stop_task_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_STOP_TASK_REQ | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_send_stop_task_req( UBYTE v_stop_ccch ) { TRACE_ISIG( "sig_cpap_tc_send_stop_task_req" ); sig_tc_ctrl_send_stop_task_req( v_stop_ccch ); } /* sig_cpap_tc_send_stop_task_req() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_channel_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_CHANNEL_REQ | | Parameters : req_data - data which RR has to send | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_channel_req(UBYTE req_data ) { TRACE_ISIG( "sig_cpap_tc_channel_req" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_ctrl_channel_req(req_data); break; default: TRACE_ERROR( "sig_cpap_tc_channel_req unexpected" ); break; } } /* sig_cpap_tc_channel_req() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_assign_sb +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_ASSIGN_SB | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_assign_sb(void *ptr2prim, UBYTE purpose) { TRACE_ISIG( "sig_cpap_tc_assign_sb" ); switch( GET_STATE( TC ) ) { case TC_CPAP: if(TWO_PHASE_ACESS EQ purpose) { SET_STATE(TC,TC_WAIT_2P_ASSIGN); } else { SET_STATE(TC,TC_SINGLE_BLOCK); } sig_tc_meas_update_pch( ); { T_MPHP_SINGLE_BLOCK_REQ* mphp_single_block_req = ( T_MPHP_SINGLE_BLOCK_REQ* )ptr2prim; TRACE_BINDUMP ( hCommGRR, TC_USER4, cl_rlcmac_get_msg_name ( ( UBYTE )( mphp_single_block_req->l2_frame[1] >> 2 ), RLC_MAC_ROUTE_UL ), mphp_single_block_req->l2_frame, MAX_L2_FRAME_SIZE ); /*lint !e569*/ } PSEND(hCommL1,ptr2prim); break; case TC_PIM: if(SINGLE_BLOCK_TRANSFER_DL EQ purpose) { SET_STATE(TC,TC_SINGLE_BLOCK); PSEND(hCommL1,ptr2prim); } else { /* this shall never happen! */ TRACE_ERROR("FATAL ERROR: single block assignment in wrong state!"); PFREE(ptr2prim); } break; default: TRACE_ERROR( "sig_cpap_tc_assign_sb unexpected" ); PFREE(ptr2prim); break; } } /* sig_cpap_tc_assign_sb() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_pdch_assign_received +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_PDCH_ASSIGN_RECEIVED | | Parameters : fn - reception frame number | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_pdch_assign_received( T_RRGRR_DATA_IND *rrgrr_data_ind ) { TRACE_ISIG( "sig_ctrl_tc_pdch_assign_received" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_cpap_pdch_assign_received(rrgrr_data_ind); break; case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: break; default: TRACE_ERROR( "sig_ctrl_tc_pdch_assign_received unexpected" ); break; } } /* sig_ctrl_tc_pdch_assign_received() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_dcch_data_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_DCCH_DATA_REQ | | Parameters : pointer - to primitive with data | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_dcch_data_req( T_RRGRR_DATA_REQ * rrgrr_data_req_i ) { TRACE_ISIG( "sig_cpap_tc_dcch_data_req" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_ctrl_dcch_data_req(rrgrr_data_req_i); break; default: TRACE_ERROR( "sig_cpap_tc_dcch_data_req unexpected" ); break; } } /* sig_cpap_tc_dcch_data_req() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_assign_pdch +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_ASSIGN_PDCH | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_assign_pdch(T_MPHP_ASSIGNMENT_REQ *ptr2prim, T_PDCH_ASS_CAUSE cause ) { TRACE_ISIG( "sig_cpap_tc_assign_pdch" ); switch( GET_STATE( TC ) ) { case TC_CPAP: grr_data->tc.dcch_present = FALSE; if( (PDCH_UL_ASS_CMD EQ cause) OR (PDCH_DL_ASS_CMD EQ cause) ) { grr_data->tc.dcch_present = TRUE; } PSEND(hCommL1,ptr2prim); break; case TC_PIM: grr_data->tc.dcch_present = FALSE; if((IA_UL EQ cause) OR (PDCH_UL_ASS_CMD EQ cause)) { PFREE(ptr2prim); TRACE_ERROR( "uplink assignments unexpected in PIM" ); } else { if((PDCH_DL_ASS_CMD EQ cause)) grr_data->tc.dcch_present = TRUE; PSEND(hCommL1,ptr2prim); } break; case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: TRACE_ERROR( "sig_cpap_tc_assign_pdch unexpected" ); PFREE(ptr2prim); break; default: TRACE_ERROR( "sig_cpap_tc_assign_pdch unexpected" ); FREE(ptr2prim); break; } } /* sig_cpap_tc_assign_pdch() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_suspend_dedi_chan +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_SUSPEND_DEDI_CHAN | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_suspend_dedi_chan(void ) { TRACE_ISIG( "sig_cpap_tc_suspend_dedi_chan" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_ctrl_suspend_dedi_chan(); break; case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: TRACE_ERROR( "sig_cpap_tc_suspend_dedi_chan unexpected" ); break; default: TRACE_ERROR( "sig_cpap_tc_suspend_dedi_chan unexpected" ); break; } } /* sig_cpap_tc_suspend_dedi_chan() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_resume_dedi_chan +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_RESUME_DEDI_CHAN | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_resume_dedi_chan(void ) { TRACE_ISIG( "sig_cpap_tc_resume_dedi_chan" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_ctrl_resume_dedi_chan(); break; case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: TRACE_ERROR( "sig_cpap_tc_resume_dedi_chan unexpected" ); break; default: TRACE_ERROR( "sig_cpap_tc_resume_dedi_chan unexpected" ); break; } } /* sig_cpap_tc_resume_dedi_chan() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_send_gprs_data_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_SEND_GPRS_DATA_REQ | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_send_gprs_data_req(T_RRGRR_GPRS_DATA_REQ *rrgrr_gprs_data_req) { TRACE_ISIG( "sig_cpap_tc_send_gprs_data_req" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_ctrl_gprs_data_req(rrgrr_gprs_data_req); break; case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: TRACE_ERROR( "sig_cpap_tc_send_gprs_data_req unexpected" ); break; default: TRACE_ERROR( "sig_cpap_tc_send_gprs_data_req unexpected" ); break; } } /* sig_cpap_tc_send_gprs_data_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_suspend_dcch_cnf +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_SUSPEND_DCCH_CNF | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_suspend_dcch_cnf(void) { TRACE_ISIG( "sig_ctrl_tc_suspend_dcch_cnf" ); switch( GET_STATE( TC ) ) { case TC_CPAP: sig_tc_cpap_suspend_dcch_cnf(); break; case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: TRACE_ERROR( "sig_ctrl_tc_suspend_dcch_cnf unexpected" ); break; default: TRACE_ERROR( "sig_ctrl_tc_suspend_dcch_cnf unexpected" ); break; } } /* sig_ctrl_tc_suspend_dcch_cnf() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_build_res_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_BUILD_RES_REQ | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_build_res_req(T_U_RESOURCE_REQ *ptr2res_req) { TRACE_ISIG( "sig_cpap_tc_build_res_req" ); switch( GET_STATE( TC ) ) { case TC_CPAP: tc_build_res_req( ptr2res_req, R_BUILD_2PHASE_ACCESS, SRC_TBF_INFO_IMM_ASSIGN ); break; case TC_SINGLE_BLOCK: case TC_PIM: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: default: TRACE_ERROR( "sig_cpap_tc_build_res_req unexpected" ); break; } } /* sig_cpap_tc_build_res_req() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_ctrl_ptm +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_CTRL_PTM | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_ctrl_ptm(void) { TRACE_ISIG( "sig_cpap_tc_ctrl_ptm" ); switch( GET_STATE( TC ) ) { case TC_CPAP: case TC_PIM: sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_TRANSFER, TASK_STOP_DUMMY_VALUE ); break; case TC_SINGLE_BLOCK: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: TRACE_ERROR( "sig_cpap_tc_ctrl_ptm unexpected" ); break; default: TRACE_ERROR( "sig_cpap_tc_ctrl_ptm unexpected" ); break; } } /* sig_cpap_tc_ctrl_ptm() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_fix_alloc_ack_ptm +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_GFP_TC_FIX_ALLOC_ACK_PTM | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_fix_alloc_ack_ptm( void ) { MCAST(d_ul_ack,D_UL_ACK); TRACE_ISIG( "sig_ru_tc_fix_alloc_ack" ); grr_data->uplink_tbf.cs_mode = d_ul_ack->gprs_ul_ack_nack_info.chan_coding_cmd; switch( GET_STATE( TC ) ) { case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: if(d_ul_ack->gprs_ul_ack_nack_info.v_f_alloc_ack EQ 0 ) { /* * if no fix alloc is present in last uplink ack/nack, delete any existing repeat alloc */ if(grr_data->tc.fa_ctrl.fa_type EQ FA_REPEAT) { /*kill reapeat alloc, which is not yet started*/ grr_data->tc.fa_ctrl.fa_type = FA_NO_NEXT; grr_data->tc.fa_ctrl.repeat_alloc = FALSE; tc_send_ul_repeat_alloc_req(); } else if(grr_data->tc.fa_ctrl.fa_type EQ FA_NO_NEXT AND grr_data->tc.fa_ctrl.repeat_alloc EQ TRUE ) { if(!grr_check_if_tbf_start_is_elapsed ( grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn, grr_data->ul_fn)) /*grr_data->tc.fa_ctrl.ul_res_remain EQ grr_data->tc.fa_ctrl.current_alloc.ul_res_sum*/ { /*kill reapeat alloc if is not yet started*/ grr_data->tc.fa_ctrl.fa_type = FA_NO_CURRENT; grr_data->tc.fa_ctrl.repeat_alloc = FALSE; tc_send_ul_repeat_alloc_req(); } } return; } /* * check if current allocation is active */ if(grr_data->tc.fa_ctrl.fa_type EQ FA_NO_CURRENT AND d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.v_ts_overr ) { ULONG next_start_fn; ULONG next_end_fn; /* repeat allocation in packet uplink ack/nack received, * no fixed allocation active, find out the next natural boundary * and store new allocation in current allocation */ grr_data->tc.fa_ctrl.fa_type = FA_NO_NEXT; grr_data->tc.fa_ctrl.repeat_alloc = TRUE; grr_data->tc.fa_ctrl.ts_overr = d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.ts_overr; tc_set_fa_bitmap((UBYTE)(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.ts_overr & grr_data->uplink_tbf.ts_usage), &grr_data->tc.fa_ctrl.current_alloc); /*find start of alloc (natural boundary of next allocation)*/ next_end_fn = grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn; do { USHORT len; len = grr_data->tc.fa_ctrl.current_alloc.alloc.size_bitmap-1; next_start_fn = grr_decode_tbf_start_rel(next_end_fn,0); next_end_fn = grr_decode_tbf_start_rel(next_start_fn,(USHORT)(len-1)); if(grr_data->ul_fn EQ next_start_fn) break; else if((next_end_fn > next_start_fn) AND (grr_data->ul_fn <= next_start_fn) AND (grr_data->ul_fn > next_start_fn) ) { next_start_fn = grr_decode_tbf_start_rel(next_end_fn,0); next_end_fn = grr_decode_tbf_start_rel(next_start_fn,(USHORT)(len-1)); break; } else if( (next_end_fn < next_start_fn) AND ( ((next_end_fn >= grr_data->ul_fn) AND (next_start_fn > grr_data->ul_fn)) OR ((next_end_fn < grr_data->ul_fn) AND (next_start_fn < grr_data->ul_fn)) ) ) { next_start_fn = grr_decode_tbf_start_rel(next_end_fn,0); next_end_fn = grr_decode_tbf_start_rel(next_start_fn,(USHORT)(len-1)); break; } } while (1); grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn = next_start_fn; grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn = next_end_fn; tc_send_ul_repeat_alloc_req(); return; } else if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.v_ts_overr ) { UBYTE len; /* repeat allocation in packet uplink ack/nack received, * current allocation is active, store new alloc in next alloc * overwriting is possibe. */ grr_data->tc.fa_ctrl.fa_type = FA_REPEAT; grr_data->tc.fa_ctrl.repeat_alloc = TRUE; grr_data->tc.fa_ctrl.ts_overr = d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.ts_overr; tc_set_fa_bitmap((UBYTE)(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.ts_overr & grr_data->uplink_tbf.ts_usage),&grr_data->tc.fa_ctrl.current_alloc); grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn = grr_decode_tbf_start_rel(grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn,0); len = grr_data->tc.fa_ctrl.current_alloc.alloc.size_bitmap-1; grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn = grr_decode_tbf_start_rel(grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn, (USHORT)(len-1)); tc_send_ul_repeat_alloc_req(); return; } grr_data->tc.fa_ctrl.repeat_alloc = FALSE; if( d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.v_fa_s2 ) { /* * new fixed allocation with allocation bitmap */ if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.v_ts_alloc) { UBYTE tx_slots; tx_slots = grr_calc_nr_of_set_bits (d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.ts_alloc); grr_data->uplink_tbf.nts = tx_slots; grr_data->uplink_tbf.ts_usage = d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.ts_alloc; if(!handle_ms_cap(UL_ASSIGNMENT)) { TRACE_ERROR( "TS_ALLOC not valid" ); return; } } tc_handle_tbf_start(CGRLC_TBF_MODE_UL); } else { TRACE_EVENT("NO FIX ALLOC STRUCT IN D_UL_ACK " ); } break; default: TRACE_ERROR( "sig_ru_tc_fix_alloc_ack unexpected" ); break; } } /* sig_gfp_tc_fix_alloc_ack_ptm() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_reconnect_cnf +------------------------------------------------------------------------------ | Description : Cell reselection has failled and we have to inform cpap | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_reconnect_dcch_cnf() { TRACE_ISIG( "sig_ctrl_tc_reconnect_cnf" ); switch( GET_STATE( TC ) ) { case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: case TC_WAIT_ASSIGN: SET_STATE(TC, TC_ACCESS_DISABLED); sig_tc_cpap_reconnect_ind(); break; default: TRACE_ERROR( "sig_ctrl_tc_reconnect_cnf unexpected" ); } } /*sig_ctrl_tc_reconnect_dcch_cnf()*/ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_cr_timerout_cnf +------------------------------------------------------------------------------ | Description : Cell reselection has failled because of timer out | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_cr_timerout_cnf() { TRACE_ISIG( "sig_ctrl_tc_cr_timerout_cnf" ); switch( GET_STATE( TC ) ) { case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: case TC_WAIT_ASSIGN: tc_abort_tbf(grr_data->tbf_type); SET_STATE(TC, TC_ACCESS_DISABLED); sig_tc_cpap_reconnect_ind(); break; default: TRACE_ERROR( "sig_ctrl_cr_timerout_cnf unexpected" ); } }/*sig_ctrl_tc_cr_timerout_cnf()*/ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_abnorm_rel_with_cr_failed +------------------------------------------------------------------------------ | Description : Handles the internal signal | SIG_CTRL_TC_ABNORM_REL_WITH_CR_FAILED | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL BOOL sig_ctrl_tc_abnorm_rel_with_cr_failed ( BOOL cell_has_changed ) { TRACE_ISIG( "sig_ctrl_tc_abnorm_rel_with_cr_failed" ); switch( GET_STATE( TC ) ) { case TC_ACCESS_DISABLED: SET_STATE_TC_PIM_AFTER_ACCESS_DISABLED ( cell_has_changed, CGRLC_ENAC_ABNORM_RELEASE_CRESELECT_FAILED ); break; default: TRACE_ERROR( "SIG_CTRL_TC_ABNORM_REL_WITH_CR_FAILED unexpected" ); break; } return( TRUE ); } /* sig_ctrl_tc_abnorm_rel_with_cr_failed() */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_start_T3142 +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_START_T3142, | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_start_T3142(ULONG wait) { TRACE_ISIG( "sig_cpap_tc_start_T3142" ); tc_start_timer_t3172(wait); sig_tc_ctrl_t3172_running(); } /* sig_cpap_tc_start_T3142 */ /* +------------------------------------------------------------------------------ | Function : sig_cpap_tc_stop_T3142 +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CPAP_TC_STOP_T3142, | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_cpap_tc_stop_T3142(void) { TRACE_ISIG( "sig_cpap_tc_stop_T3142" ); } /* sig_cpap_tc_stop_T3142 */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_disable_prim_queue +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_DISABLE_PRIM_QUEUE | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL BOOL sig_ctrl_tc_disable_prim_queue ( BOOL cell_has_changed ) { TRACE_EVENT( "sig_ctrl_tc_disable_prim_queue" ); switch( GET_STATE( TC ) ) { case TC_ACCESS_DISABLED: SET_STATE_TC_PIM_AFTER_ACCESS_DISABLED( cell_has_changed, CGRLC_ENAC_NORMAL ); break; default: TRACE_ERROR( "SIG_CTRL_TC_DISABLE_PRIM_QUEUE unexpected" ); break; } return( TRUE); } /* sig_ctrl_tc_disable_prim_queue() */ /* +------------------------------------------------------------------------------ | Function : sig_meas_tc_update_ta_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_MEAS_TC_UPDATE_TA_REQ. | New TA values are received, it shall passed to l1 | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_meas_tc_update_ta_req ( void) { MCAST(d_ctrl_pwr_ta,D_CTRL_PWR_TA); /* T_D_CTRL_PWR_TA */ TRACE_FUNCTION( "tc_send_reconf_tbf_ta_req" ); TRACE_EVENT_P9("TAU: %d tav=%d - %d %d %d - %d %d %d tbf_type=%d" ,d_ctrl_pwr_ta->gpta.v_ta_value ,d_ctrl_pwr_ta->gpta.ta_value ,d_ctrl_pwr_ta->gpta.v_ul_ta_index ,d_ctrl_pwr_ta->gpta.ul_ta_index ,d_ctrl_pwr_ta->gpta.ul_ta_tn ,d_ctrl_pwr_ta->gpta.v_dl_ta_index ,d_ctrl_pwr_ta->gpta.dl_ta_index ,d_ctrl_pwr_ta->gpta.dl_ta_tn ,grr_data->tbf_type ); switch(grr_data->tbf_type) { case CGRLC_TBF_MODE_DL_UL: { PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */ mphp_timing_advance_req->assign_id = 0; grr_handle_ta ( d_ctrl_pwr_ta->gpta.v_ta_value, d_ctrl_pwr_ta->gpta.ta_value, d_ctrl_pwr_ta->gpta.v_ul_ta_index, d_ctrl_pwr_ta->gpta.ul_ta_index, d_ctrl_pwr_ta->gpta.ul_ta_tn, d_ctrl_pwr_ta->gpta.v_dl_ta_index, d_ctrl_pwr_ta->gpta.dl_ta_index, d_ctrl_pwr_ta->gpta.dl_ta_tn, &mphp_timing_advance_req->p_timing_advance); PSEND(hCommL1,mphp_timing_advance_req); } break; case CGRLC_TBF_MODE_DL: { PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */ mphp_timing_advance_req->assign_id = 0; if(d_ctrl_pwr_ta->gpta.v_ul_ta_index) { d_ctrl_pwr_ta->gpta.v_ul_ta_index = 0; TRACE_EVENT("TAU: only dl tbf is running, ul ta index present"); } if(!d_ctrl_pwr_ta->gpta.v_dl_ta_index) { TRACE_EVENT("TAU: only dl tbf is running, no dl ta index present"); } grr_handle_ta ( d_ctrl_pwr_ta->gpta.v_ta_value, d_ctrl_pwr_ta->gpta.ta_value, d_ctrl_pwr_ta->gpta.v_ul_ta_index, d_ctrl_pwr_ta->gpta.ul_ta_index, d_ctrl_pwr_ta->gpta.ul_ta_tn, d_ctrl_pwr_ta->gpta.v_dl_ta_index, d_ctrl_pwr_ta->gpta.dl_ta_index, d_ctrl_pwr_ta->gpta.dl_ta_tn, &mphp_timing_advance_req->p_timing_advance); PSEND(hCommL1,mphp_timing_advance_req); } break; case CGRLC_TBF_MODE_UL: { PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */ mphp_timing_advance_req->assign_id = 0; if(d_ctrl_pwr_ta->gpta.v_dl_ta_index) { d_ctrl_pwr_ta->gpta.v_dl_ta_index = 0; TRACE_EVENT("TAU: only ul tbf is running, dl ta index present"); } if(!d_ctrl_pwr_ta->gpta.v_ul_ta_index) { TRACE_EVENT("TAU: only ul tbf is running, no ul ta index present"); } grr_handle_ta ( d_ctrl_pwr_ta->gpta.v_ta_value, d_ctrl_pwr_ta->gpta.ta_value, d_ctrl_pwr_ta->gpta.v_ul_ta_index, d_ctrl_pwr_ta->gpta.ul_ta_index, d_ctrl_pwr_ta->gpta.ul_ta_tn, d_ctrl_pwr_ta->gpta.v_dl_ta_index, d_ctrl_pwr_ta->gpta.dl_ta_index, d_ctrl_pwr_ta->gpta.dl_ta_tn, &mphp_timing_advance_req->p_timing_advance); PSEND(hCommL1,mphp_timing_advance_req); } break; default: TRACE_ERROR ( "sig_meas_tc_update_ta_req: TBF type is invalid" ); TRACE_EVENT_P1 ( "TBF type = %d",grr_data->tbf_type ); break; } } /* sig_meas_tc_update_ta_req() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_update_ta_req_ptm +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_GFP_TC_UPDATE_TA_REQ_PTM. | New TA values are received, it shall passed to l1 | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_update_ta_req_ptm ( void) { MCAST(d_ul_ack,D_UL_ACK); PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */ TRACE_FUNCTION( "tc_send_reconf_tbf_ta_req" ); mphp_timing_advance_req->assign_id = 0; grr_handle_ta ( d_ul_ack->gprs_ul_ack_nack_info.pta.v_ta_value, d_ul_ack->gprs_ul_ack_nack_info.pta.ta_value, d_ul_ack->gprs_ul_ack_nack_info.pta.v_ta_index_tn, d_ul_ack->gprs_ul_ack_nack_info.pta.ta_index_tn.ta_index, d_ul_ack->gprs_ul_ack_nack_info.pta.ta_index_tn.ta_tn, 0xFF, 0, 0, &mphp_timing_advance_req->p_timing_advance); PSEND(hCommL1,mphp_timing_advance_req); } /* sig_gfp_tc_update_ta_req_ptm() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_enter_pam +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_ENTER_PAM. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_enter_pam ( void ) { TRACE_ISIG( "sig_ctrl_tc_enter_pam" ); switch( GET_STATE( TC ) ) { case TC_WAIT_STOP_TASK_CNF: if( grr_is_pbcch_present( ) ) { if( grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_DL ) { sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ASSIGNED, grr_data->tc.last_eval_assign.ccch_read ); } else { SET_STATE( TC, TC_WAIT_ASSIGN ); vsi_t_start( GRR_handle, T3186, T3186_VALUE ); tc_send_ra_req( ); } } else { SET_STATE( TC, TC_CPAP ); sig_tc_cpap_acc_req( ); } break; default: TRACE_ERROR( "SIG_CTRL_TC_ENTER_PAM unexpected" ); break; } } /* sig_ctrl_tc_enter_pam() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_leave_to_ptm +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_LEAVE_TO_PTM | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_leave_to_ptm ( void ) { TRACE_ISIG( "sig_ctrl_tc_leave_to_ptm" ); switch( GET_STATE( TC ) ) { case TC_WAIT_STOP_TASK_CNF: tc_mfree_assign( TRUE ); #ifdef _SIMULATION_ switch( grr_data->tc.last_eval_assign.state ) { case TC_ACCESS_DISABLED : SET_STATE( TC, TC_ACCESS_DISABLED ); break; case TC_CPAP : SET_STATE( TC, TC_CPAP ); break; case TC_PIM : SET_STATE( TC, TC_PIM ); break; case TC_WAIT_ASSIGN : SET_STATE( TC, TC_WAIT_ASSIGN ); break; case TC_POLLING : SET_STATE( TC, TC_POLLING ); break; case TC_WAIT_2P_ASSIGN : SET_STATE( TC, TC_WAIT_2P_ASSIGN ); break; case TC_CONTENTION_RESOLUTION: SET_STATE( TC, TC_CONTENTION_RESOLUTION ); break; case TC_TBF_ACTIVE : SET_STATE( TC, TC_TBF_ACTIVE); break; case TC_SINGLE_BLOCK : SET_STATE( TC, TC_SINGLE_BLOCK); break; case TC_WAIT_STOP_TASK_CNF : SET_STATE( TC, TC_WAIT_STOP_TASK_CNF); break; default: SET_STATE( TC, grr_data->tc.last_eval_assign.state ); TRACE_ERROR( "sig_ctrl_tc_leave_to_ptm: unknown TC state" ); break; } #else /* #ifdef _SIMULATION_ */ SET_STATE( TC, grr_data->tc.last_eval_assign.state ); #endif /* #ifdef _SIMULATION_ */ tc_handle_tbf_start( grr_data->tc.last_eval_assign.tbf_type ); break; default: TRACE_ERROR( "SIG_CTRL_TC_LEAVE_TO_PTM unexpected" ); break; } } /* sig_ctrl_tc_leave_to_ptm() */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_leave_to_pim +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_CTRL_TC_LEAVE_TO_PIM | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_leave_to_pim ( void ) { TRACE_ISIG( "sig_ctrl_tc_leave_to_pim" ); tc_send_tbf_release_req( grr_data->tc.last_tbf_type, FALSE ); } /* sig_ctrl_tc_leave_to_pim() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_access_rej_ptm +------------------------------------------------------------------------------ | Description : Handles the signal SIG_GFP_TC_ACCESS_REJ_PTM | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_access_rej_ptm ( void ) { ULONG t3172_value=0; TRACE_ISIG( "sig_gfp_tc_access_rej_ptm" ); TRACE_EVENT("ACC REJ PACCH" ); switch(grr_data->tbf_type) { case CGRLC_TBF_MODE_UL: /* * wait for the end of the current UL TBF */ if(grr_t_status( T3172_1 ) EQ 0) { TRACE_EVENT("Return to idle mode after release of DA"); #if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH if(grr_data->tc.tbf_est_pacch AND grr_t_status( T3170) EQ 0 ) { /* GRLC has sent PCA or PRR. PAR received before PUA */ vsi_t_start(GRR_handle,T3170,tc_get_t3170_value()); } #endif } /*lint -fallthrough*/ case CGRLC_TBF_MODE_DL_UL: /* * UL TBF ends before the number of requested octets has been transferred, as if FINAL_ALLOCATION bit * go to idle mode after release * stop 3168 * check 3172 * Before initiating a new packet access procedure the mobile station shall decode the * PRACH Control Parameters if they are broadcast. */ if(grr_data->uplink_tbf.mac_mode EQ FIXED_ALLOCATION) { tc_abort_tbf(CGRLC_TBF_MODE_UL); /* abort UL TBF*/ } else if(grr_t_status( T3172_1 ) EQ 0 ) { ; } /*lint -fallthrough*/ case CGRLC_TBF_MODE_DL: if(grr_t_status( T3172_1 ) EQ 0 ) { TRACE_EVENT("CGRLC_TBF_MODE_DL, T3172_1 is not running"); /* * primtive is delted if prim_status is set, status indication is sent to higher layers */ tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_ACCESS_FAILED,CGRLC_PRIM_STATUS_ONE); switch( tc_eval_access_rej(&t3172_value) ) { case E_ACCESS_REJ_WAIT: tc_start_timer_t3172( t3172_value ); sig_tc_ctrl_t3172_running(); break; case E_ACCESS_REJ_NO_WAIT: TRACE_EVENT("NO WAIT_INDICATION: nothing to do"); break; default: break; } } /* no else because additional rejects have to be ignored!! */ break; #if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH case CGRLC_TBF_MODE_2PA: /* PRR is sent by GRLC. NW responds with PAR */ if(grr_data->tc.tbf_est_pacch) { if(grr_t_status( T3170) EQ 0 ) vsi_t_start(GRR_handle,T3170,tc_get_t3170_value()); switch( tc_eval_access_rej(&t3172_value) ) { case E_ACCESS_REJ_WAIT: tc_start_timer_t3172( t3172_value ); sig_tc_ctrl_t3172_running(); break; case E_ACCESS_REJ_NO_WAIT: TRACE_EVENT("NO WAIT_INDICATION: nothing to do"); break; default: break; } } break; #endif default: break; }/* switch tbf_type*/ } /* sig_gfp_tc_access_rej_ptm() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_ts_reconfig_ptm +------------------------------------------------------------------------------ | Description : Handles the | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_ts_reconfig_ptm ( void ) { TRACE_ISIG( "sig_gfp_tc_ts_reconfig_ptm" ); /* * ASUMPTION: * This primitive (re)assigns an uplink AND downlink assignment. * if not the primitive is ignored. * CASES: * 1. ONLY UL_TBF is running: reassignment of uplink AND assignment of downlink * 2. ONLY DL_TBF is running: reassignment of downlink AND assignment of uplink * 3. DL_TBF AND UL_TBF is running: reassignment of downlink AND reassignment of uplink */ switch( GET_STATE( TC ) ) { case TC_CONTENTION_RESOLUTION: TRACE_ERROR("TS RECONF in CONT: RES. ignored"); break; /*ignore during contention resolution procedure*/ case TC_TBF_ACTIVE: switch(tc_eval_ts_reconf()) { /*handle tbf starting time for uplink*/ case E_TS_UL_REASSIG_NEW_DL: case E_TS_NEW_UL_DL_REASSIG: case E_TS_UL_REASSIG_DL_REASSIG: /* TRACE_EVENT("Packet TS Reconfigure "); */ tc_handle_tbf_start( CGRLC_TBF_MODE_DL_UL ); break; case E_TS_IGNORE: /*no effect on current tbfs*/ break; case E_TS_RECONFIG_ERROR_RA: TRACE_EVENT("Packet TS Reconfigure invalid"); vsi_t_stop(GRR_handle,T3168); tc_handle_error_ra(); break; default: TRACE_ERROR( "SIG_GFP_TC_TS_RECONFIG_PTM unexpected" ); break; } break; default: TRACE_ERROR( "SIG_GFP_TC_TS_RECONFIG_PTM unexpected" ); break; } } /* sig_gfp_tc_ts_reconfig_ptm() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_ul_assign_ptm +------------------------------------------------------------------------------ | Description : Handles the | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_ul_assign_ptm (void ) { TRACE_ISIG( "sig_gfp_tc_ul_assign_ptm " ); switch( GET_STATE( TC ) ) { case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: switch( tc_eval_ul_assign() ) { case E_UL_ASSIGN_DYNAMIC: /* TRACE_EVENT("Packet UL Assignment with dynamic allocation"); */ tc_handle_tbf_start( CGRLC_TBF_MODE_UL ); break; case E_UL_ASSIGN_FIXED: /* TRACE_EVENT("Packet UL Assignment with fixed allocation"); */ tc_handle_tbf_start( CGRLC_TBF_MODE_UL ); break; #if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH case E_UL_ASSIGN_SB_2PHASE_ACCESS: if((grr_data->tc.tbf_est_pacch) AND (!psc_db->gprs_cell_opt.ctrl_ack_type)) { /* Control ack type is Access burst. GRLC would have sent * PCA as poll for initiating TBF est on PACCH. Send UL_TBF_RES * to GRLC. Packet resource request message will be sent by GRLC. */ TRACE_EVENT("TBF on pacch"); SET_STATE(TC,TC_WAIT_2P_ASSIGN); tc_handle_tbf_start( CGRLC_TBF_MODE_2PA); } break; #endif default: TRACE_EVENT("Packet UL Assignment invalid"); tc_handle_error_ra(); break; } break; default: TRACE_ERROR( "SIG_GFP_TC_UL_ASSIGN_PTM unexpected" ); break; } } /* sig_gfp_tc_ul_assign_ptm () */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_dl_assign_ptm +------------------------------------------------------------------------------ | Description : Handles the | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_dl_assign_ptm ( void ) { TRACE_ISIG( "sig_gfp_tc_dl_assign_ptm" ); switch( GET_STATE( TC ) ) { case TC_CONTENTION_RESOLUTION: TRACE_ERROR("P. DL. ASS. in CONT: RES. ignored"); break; /*ignore during contention resolution procedure*/ case TC_TBF_ACTIVE: switch( tc_eval_dl_assign() ) { case E_DL_ASSIGN: /* TRACE_EVENT("Packet DL Assignment"); */ tc_handle_tbf_start( CGRLC_TBF_MODE_DL ); break; case E_DL_ASSIGN_ERROR_RA: TRACE_EVENT("Packet DL Assignment invalid"); tc_handle_error_ra(); break; case E_DL_ASSIGN_IGNORE: /* * If a failure in the PACKET DOWNLINK ASSIGNMENT is due to any reason, * the mobile station shall abort the procedure and continue the normal * operation of the uplink TBF. */ break; case E_DL_ASSIGN_ABORT_DL: tc_abort_tbf(CGRLC_TBF_MODE_DL); break; default: TRACE_ERROR( "Packet DL Assignment with unexpected content" ); break; } break; default: TRACE_ERROR( "SIG_GFP_TC_DL_ASSIGN_PTM unexpected" ); break; } } /* sig_gfp_tc_dl_assign_ptm() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_pdch_release_ptm ( tn ); +------------------------------------------------------------------------------ | Description : Handles | | Parameters : tn_i | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_pdch_release_ptm ( UBYTE tn) { TRACE_ISIG( "sig_gfp_tc_pdch_release_ptm" ); switch( GET_STATE( TC ) ) { case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: switch( tc_eval_pdch_rel(tn) ) { case E_PDCH_REL_RECONF: tc_send_pdch_rel(grr_data->pdch_rel_ts_mask); break; case E_PDCH_REL_RELEASE_DL_RECONF_UL: tc_abort_tbf(CGRLC_TBF_MODE_DL); tc_send_pdch_rel(grr_data->pdch_rel_ts_mask); break; case E_PDCH_REL_RELEASE_UL_RECONF_DL: tc_abort_tbf(CGRLC_TBF_MODE_UL); tc_send_pdch_rel(grr_data->pdch_rel_ts_mask); break; case E_PDCH_REL_RELEASE_BOTH: tc_abort_tbf(CGRLC_TBF_MODE_DL_UL); break; case E_PDCH_REL_RELEASE_UL: tc_abort_tbf(CGRLC_TBF_MODE_UL); break; case E_PDCH_REL_RELEASE_DL: tc_abort_tbf(CGRLC_TBF_MODE_DL); break; default: break; } break; default: TRACE_ERROR( "SIG_GFP_TC_PDCH_RELEASE_PTM unexpected" ); break; } /* * in all states */ if(grr_data->tbf_type EQ CGRLC_TBF_MODE_NULL) { /* new access is done when release confirm arrives */ SET_STATE(TC,TC_PIM); } else if(grr_data->tbf_type EQ CGRLC_TBF_MODE_DL) { SET_STATE(TC,TC_TBF_ACTIVE); } } /* sig_gfp_tc_pdch_release_ptm() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_queuing_not +------------------------------------------------------------------------------ | Description : Handles | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_queuing_not ( void ) { TRACE_ISIG( "sig_gfp_tc_queuing_not " ); switch( GET_STATE( TC ) ) { case TC_WAIT_ASSIGN: SET_STATE(TC,TC_POLLING); /* * stop sending packet access request */ tc_send_ra_stop_req(); vsi_t_stop(GRR_handle,T3170); vsi_t_start(GRR_handle,T3162,T3162_VALUE); /* * save tqi */ { MCAST(d_queuing_not,D_QUEUING_NOT); grr_data->tqi = d_queuing_not->tqi; } break; default: TRACE_ERROR( "SIG_GFP_TC_QUEUING_NOT unexpected" ); break; } } /* sig_gfp_tc_queuing_not () */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_ul_assign +------------------------------------------------------------------------------ | Description : Handles | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_ul_assign ( void ) { UBYTE old_state = GET_STATE( TC ); TRACE_ISIG( "sig_gfp_tc_ul_assign" ); if( grr_t_status( T3172_1 ) > 0 ) { if( grr_t_status( T3170 ) > 0 ) { /* * stop T3172 and set some parameters */ tc_stop_timer_t3172(); } else if ( grr_t_status( T3176 ) EQ 0) { TRACE_EVENT("Ignore UL Assignment"); return; } } switch( old_state ) { case TC_WAIT_2P_ASSIGN: grr_data->uplink_tbf.ti = 0; /* mark that contention resulution is not yet done */ /*lint -fallthrough*/ case TC_WAIT_STOP_TASK_CNF: if (grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_UL) { TRACE_EVENT("Reassignment for UL ASS in CNF state"); } else if(grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_DL) { TRACE_EVENT("Ignore UL ASS, wait for DL start"); break; } else if(grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_NULL AND grr_data->uplink_tbf.ti) { TRACE_EVENT("Ignore UL ASS, wait for condirn to start RA procedure !!!!"); break; } /*lint -fallthrough*/ /* * else :TWO PHASE ACCESS IS RUNNING */ case TC_POLLING: case TC_WAIT_ASSIGN: /* * stop sending packet access request if in progress */ tc_send_ra_stop_req(); /*lint -fallthrough*/ case TC_SINGLE_BLOCK: case TC_CONTENTION_RESOLUTION: switch( tc_eval_ul_assign() ) { case E_UL_ASSIGN_SB_2PHASE_ACCESS: SET_STATE(TC,TC_WAIT_2P_ASSIGN); /* * send MPHP_SINGLE_BLOCK_REQ with PACKET RESOURCE REQUEST */ tc_send_resource_request_p(); vsi_t_stop(GRR_handle,T3170); break; case E_UL_ASSIGN_DYNAMIC: /* TRACE_EVENT("Packet UL Assignment with dynamic allocation"); */ if(grr_data->uplink_tbf.ti) { SET_STATE(TC,TC_CONTENTION_RESOLUTION); } else { SET_STATE(TC,TC_TBF_ACTIVE); sig_tc_ctrl_contention_ok(); grr_data->tc.two_2p_w_4_tbf_con = FALSE; } tc_prepare_handle_tbf_start( CGRLC_TBF_MODE_UL, GET_STATE( TC ), old_state ); break; case E_UL_ASSIGN_FIXED: /*TRACE_EVENT("Packet UL Assignment with fixed allocation");*/ if(grr_data->uplink_tbf.ti) { SET_STATE(TC,TC_CONTENTION_RESOLUTION); } else { SET_STATE(TC,TC_TBF_ACTIVE); sig_tc_ctrl_contention_ok(); } tc_prepare_handle_tbf_start( CGRLC_TBF_MODE_UL, GET_STATE( TC ), old_state ); break; case E_UL_ASSIGN_SB_WITHOUT_TBF: TRACE_EVENT("Packet UL Assignment with single block allocation"); /* send MPHP_SINGLE_BLOCK_REQ with DATA * (measurement report) */ tc_send_single_block(); SET_STATE(TC,TC_SINGLE_BLOCK); vsi_t_stop(GRR_handle,T3170); break; default: vsi_t_stop(GRR_handle,T3170); if(grr_data->tc.state EQ TC_WAIT_2P_ASSIGN OR grr_data->tc.state EQ TC_SINGLE_BLOCK) { vsi_t_stop(GRR_handle,T3168); TRACE_EVENT_P1("Packet UL Assignment invalid during 2 phase access state=%d",grr_data->tc.state); tc_stop_normal_burst_req( ); } else { TRACE_EVENT("Packet UL Assignment invalid"); tc_handle_error_ra(); } break; } break; default: vsi_t_stop(GRR_handle,T3170); TRACE_ERROR( "SIG_GFP_TC_UL_ASSIGN unexpected" ); break; } } /* sig_gfp_tc_ul_assign() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_dl_assign +------------------------------------------------------------------------------ | Description : Handles | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_dl_assign (void) { UBYTE old_state = GET_STATE( TC ); TRACE_ISIG( "sig_gfp_tc_dl_assign " ); switch( old_state ) { case TC_WAIT_STOP_TASK_CNF: TRACE_EVENT_P4("ASS IN CNF state:ccch_read=%d tbf_Type =%d state=%d p_assign=%ld" ,grr_data->tc.last_eval_assign.ccch_read ,grr_data->tc.last_eval_assign.tbf_type ,grr_data->tc.last_eval_assign.state ,grr_data->tc.p_assign); if (grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_UL) { TRACE_EVENT("Ignore DL ASS, wait for UL start"); break; } /*lint -fallthrough*/ case TC_WAIT_ASSIGN: /* * stop sending packet access request if in progress */ tc_send_ra_stop_req(); /*lint -fallthrough*/ case TC_PIM: case TC_POLLING: case TC_SINGLE_BLOCK: case TC_TBF_ACTIVE: switch( tc_eval_dl_assign() ) { case E_DL_ASSIGN: /* TRACE_EVENT("Packet DL Assignment"); */ SET_STATE(TC,TC_TBF_ACTIVE); if( grr_t_status( T3162 ) NEQ 0 ) { vsi_t_stop(GRR_handle,T3162);/*ETSI 4.60 7.1.2.2.2.*/ } tc_prepare_handle_tbf_start( CGRLC_TBF_MODE_DL, GET_STATE( TC ), old_state ); break; case E_DL_ASSIGN_ERROR_RA: TRACE_EVENT("Packet DL Assignment invalid"); vsi_t_stop(GRR_handle,T3170); if(grr_data->tc.state EQ TC_SINGLE_BLOCK) { TRACE_EVENT_P1("Packet DL Assignment invalid during IA_DL_SB state=%d",grr_data->tc.state); tc_stop_normal_burst_req( ); } else { tc_handle_error_ra(); } break; case E_DL_ASSIGN_IGNORE: /* * If a failure in the PACKET DOWNLINK ASSIGNMENT is due to any reason, * the mobile station shall abort the procedure and continue the normal * operation of the uplink TBF. */ vsi_t_stop(GRR_handle,T3170); break; default: vsi_t_stop(GRR_handle,T3170); TRACE_ERROR( "DL_ASSIGNMENT with unexpected content" ); break; } break; default: vsi_t_stop(GRR_handle,T3170); TRACE_ERROR( "SIG_GFP_TC_DL_ASSIGN unexpected" ); break; } } /* sig_gfp_tc_dl_assign () */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_access_rej +------------------------------------------------------------------------------ | Description : Handles | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_access_rej ( void ) { ULONG t3172_value=0; BOOL start_t3172 = TRUE; TRACE_ISIG( "sig_gfp_tc_access_rej " ); if(grr_t_status( T3172_1 ) > 0) { TRACE_EVENT("T3172 running: Ignore PACKET ACCESS REJECT"); } else { /* The T3168 could running. */ vsi_t_stop(GRR_handle,T3168); switch( GET_STATE( TC ) ) { case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: case TC_SINGLE_BLOCK: tc_send_ra_stop_req(); /* * stop Packet Access Request sending (T3186 will be stopped if runnig) */ if( grr_t_status( T3174 ) > 0 ) { TRACE_ERROR( " Access reject on the network commanded cell" ); grr_data->pcco_failure_cause = 2; sig_tc_ctrl_access_reject_on_new_cell(); /* Do not start the 3172 timer if on the new cell access reject is received */ start_t3172 = FALSE; } else if(grr_t_status( T3170 ) EQ 0 ) { /* T3170 is not running */ vsi_t_start(GRR_handle,T3170,tc_get_t3170_value()); TRACE_EVENT("sig_gfp_tc_access_rej: t3170 started"); } switch( tc_eval_access_rej( &t3172_value ) ) { case E_ACCESS_REJ_WAIT: if (start_t3172 EQ TRUE) { tc_start_timer_t3172( t3172_value ); sig_tc_ctrl_t3172_running(); } break; case E_ACCESS_REJ_NO_WAIT: TRACE_EVENT("No value for T3172, go to idle mode after T3170 expiration"); break; default: break; } break; default: TRACE_ERROR( "SIG_GFP_TC_ACCESS_REJ unexpected" ); break; } }/* ignore reject*/ } /* sig_gfp_tc_access_rej () */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_ra_con +------------------------------------------------------------------------------ | Description : Handles | | Parameters : payload to primitive | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_ra_con ( T_MPHP_RA_CON * mphp_ra_con_i ) { TRACE_ISIG( "sig_gfp_tc_ra_con" ); /*MODIF*/ /* * save last packet access request reference * see also 0408d640, 10.5.2.28 */ grr_data->req_ref[grr_data->tc.n_acc_req%3].fn_mod.t1 = (UBYTE)( ( mphp_ra_con_i->fn / 1326) % 32 ); grr_data->req_ref[grr_data->tc.n_acc_req%3].fn_mod.t2 = (UBYTE)( mphp_ra_con_i->fn % 26 ); grr_data->req_ref[grr_data->tc.n_acc_req%3].fn_mod.t3 = (UBYTE)( mphp_ra_con_i->fn % 51 ); /* * 0 8 bit access burst * 1 11 bit access burst */ if(psc_db->gprs_cell_opt.ab_type) { /* * 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 * * We have to store the access info in the * b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 format */ USHORT acc_inf, dummy = 0; dummy = mphp_ra_con_i->channel_request_data; dummy = dummy >> 8; /* 0 0 0 0 0 0 0 0 0 0 0 0 0 b2 b1 b0*/ acc_inf = mphp_ra_con_i->channel_request_data; acc_inf = (acc_inf & 0xFF);/* 0 0 0 0 0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 */ acc_inf = acc_inf << 3; /* 0 0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 0 0 0 */ acc_inf = acc_inf | dummy;/* 0 0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 */ grr_data->req_ref[grr_data->tc.n_acc_req%3].access_info = acc_inf; } else { grr_data->req_ref[grr_data->tc.n_acc_req%3].access_info = mphp_ra_con_i->channel_request_data; } grr_data->tc.n_acc_req++; grr_data->tc.ra_once_sent++; if (grr_data->tc.ra_once_sent >= 2) { grr_data->r_bit = 1; } switch( GET_STATE( TC ) ) { case TC_WAIT_ASSIGN: switch( tc_handle_ra_con() ) { case H_RA_CON_STOP_REQ: tc_send_ra_stop_req(); break; case H_RA_CON_CONTINUE: tc_send_ra_req(); break; default: break; } break; default: tc_send_ra_stop_req(); break; } } /* sig_gfp_tc_ra_con() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_ra_stop_con +------------------------------------------------------------------------------ | Description : Handles the primitive T_MPHP_RA_STOP_CON | | Parameters : Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_ra_stop_con ( T_MPHP_RA_STOP_CON * mphp_ra_stop_con_i ) { TRACE_ISIG( "sig_gfp_tc_ra_stop_con" ); switch( GET_STATE( TC ) ) { case TC_ACCESS_DISABLED: tc_call_disable_callback_func( ); break; default: /* nothing to do */ break; } } /* sig_gfp_tc_ra_stop_con() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_single_block_cnf +------------------------------------------------------------------------------ | Description : Handles | | Parameters : *mphp_single_block_con - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_single_block_cnf ( T_MPHP_SINGLE_BLOCK_CON *mphp_single_block_con) { TRACE_ISIG( "sig_gfp_tc_single_block_cnf" ); switch( GET_STATE( TC ) ) { case TC_WAIT_2P_ASSIGN: if(!mphp_single_block_con->sb_status) { /* * TRACE_EVENT_P1("T3168 start: %d ms",((psc_db->gprs_cell_opt.t3168)+1)*500); */ vsi_t_start(GRR_handle,T3168,(psc_db->gprs_cell_opt.t3168+1)*500); sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS_TWO_PHASE, TASK_STOP_DUMMY_VALUE ); } else { vsi_t_stop(GRR_handle,T3168); TRACE_ERROR("Single Block not sent by layer 1"); TRACE_EVENT_P1("sb_status = %d",mphp_single_block_con->sb_status); sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS_TWO_PHASE, TASK_STOP_DUMMY_VALUE ); tc_stop_normal_burst_req( ); } break; case TC_SINGLE_BLOCK: if(mphp_single_block_con->purpose EQ SINGLE_BLOCK_TRANSFER_UL) { BOOL is_tx_success = mphp_single_block_con->sb_status EQ SB_STAT_OK; tc_set_stop_ctrl_blk ( is_tx_success,CGRLC_BLK_OWNER_NONE, 0 ); sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_MEAS_REP_IDLE, TASK_STOP_DUMMY_VALUE ); } else { sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS_TWO_PHASE, TASK_STOP_DUMMY_VALUE ); } tc_stop_normal_burst_req( ); break; case TC_ACCESS_DISABLED: /* * After receiving a Packet Cell Change Order the signal SIG_GFP_SINGLE_BLOCK_CNF * was unexpected. MPHP_STOP_SINGLE_BLOCK_REQ is sent during disableing of the * GRR services. */ break; default: TRACE_ERROR( "SIG_GFP_TC_SINGLE_BLOCK_CNF unexpected" ); break; } } /* sig_gfp_tc_single_block_cnf () */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_assignment_con +------------------------------------------------------------------------------ | Description : Handles | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_assignment_con ( void ) { TRACE_ISIG( "sig_gfp_tc_assignment_con " ); grr_data->tc.two_2p_w_4_tbf_con = TRUE; if(grr_data->tc.state NEQ TC_ACCESS_DISABLED) { if(grr_is_pbcch_present( )) { grr_data->tc.last_eval_assign.ccch_read = 0xFF; grr_data->tc.last_eval_assign.tbf_type = CGRLC_TBF_MODE_NULL; grr_data->tc.last_eval_assign.state = 0xFF; } sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_TRANSFER, TASK_STOP_DUMMY_VALUE ); } else { TRACE_EVENT_P1("TBF_C in TC_ACCESS_DISABLED: do not sent sig_tc_ctrl_set_pckt_mode num_rel=%d ",grr_data->tc.num_of_rels_running ); } } /* sig_gfp_tc_assignment_con () */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_tbf_release_con +------------------------------------------------------------------------------ | Description : Handles | | Parameters : T_MPHP_TBF_RELEASE_CON * mphp_tbf_release_con_i | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_tbf_release_con ( T_MPHP_TBF_RELEASE_CON * mphp_tbf_release_con_i ) { T_RELEASE_STATE rel_state= REL_RUNNING; TRACE_ISIG( "sig_gfp_tc_tbf_release_con" ); if(mphp_tbf_release_con_i->tbf_type EQ UL_DL_ASSIGNMENT) grr_data->tc.num_of_rels_running = 0; else if (grr_data->tc.num_of_rels_running) grr_data->tc.num_of_rels_running--; else { TRACE_EVENT_P2("REL CON UNEXPECTED num=%d tbf_rel_type=%d " ,grr_data->tc.num_of_rels_running ,mphp_tbf_release_con_i->tbf_type); } if(!grr_data->tc.num_of_rels_running) { rel_state = REL_PERFORMED; if(grr_is_pbcch_present( )) { grr_data->tc.last_eval_assign.ccch_read = 0xFF; grr_data->tc.last_eval_assign.tbf_type = CGRLC_TBF_MODE_NULL; grr_data->tc.last_eval_assign.state = 0xFF; } } sig_tc_ctrl_rel_state(rel_state); switch( GET_STATE( TC ) ) { case TC_PIM: grr_data->ta_params.ta_value = 0xFF; grr_data->ta_params.ta_valid = FALSE; memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS)); if(0 EQ grr_data->tc.num_of_rels_running) { grr_data->tc.v_freq_set = FALSE; if( grr_data->tc.disable_callback_func EQ NULL ) { /*enable access for grlc*/ tc_cgrlc_tbf_rel_res( mphp_tbf_release_con_i->tbf_type ); /* release of all tbfs, grr has entered PIM, transition rule is taken into acocount*/ } else { SET_STATE( TC, TC_ACCESS_DISABLED ); tc_cgrlc_disable_req ( CGRLC_PRIM_STATUS_NULL ); tc_call_disable_callback_func( ); } }/* else: wait for last release confirm */ else { tc_cgrlc_tbf_rel_res( mphp_tbf_release_con_i->tbf_type ); TRACE_EVENT_P1("WAIT FOR %d TBF RELEASE CON ",grr_data->tc.num_of_rels_running); } break; case TC_ACCESS_DISABLED: grr_data->ta_params.ta_value = 0xFF; grr_data->ta_params.ta_valid = FALSE; memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS)); grr_data->tc.v_freq_set = FALSE; grr_data->tc.two_2p_w_4_tbf_con = TRUE; tc_cgrlc_disable_req ( CGRLC_PRIM_STATUS_NULL ); if(0 EQ grr_data->tc.num_of_rels_running) { tc_call_disable_callback_func( ); } else { TRACE_EVENT_P1("REL_C in disable state: nr_rel=%d",grr_data->tc.num_of_rels_running); } break; case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: /* * update timimg advance */ switch(mphp_tbf_release_con_i->tbf_type ) { case DL_ASSIGNMENT: { tc_cgrlc_tbf_rel_res( mphp_tbf_release_con_i->tbf_type ); /* * downlink tbf released, set ul ta, if it is different */ if(!((grr_data->ta_params.l1_ta_value EQ grr_data->ta_params.ta_value) AND (grr_data->ta_params.l1_ta_i EQ grr_data->ta_params.ul_ta_i) AND (grr_data->ta_params.l1_ta_tn EQ grr_data->ta_params.ul_ta_tn))) { PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */ mphp_timing_advance_req->assign_id = 0; mphp_timing_advance_req->p_timing_advance.ta_value = grr_data->ta_params.ta_value; mphp_timing_advance_req->p_timing_advance.ta_index = grr_data->ta_params.ul_ta_i; mphp_timing_advance_req->p_timing_advance.tn = grr_data->ta_params.ul_ta_tn; PSEND(hCommL1,mphp_timing_advance_req); TRACE_EVENT_P5("DL TBF_REL TAU: new: %d %d %d-- old %d %d" ,grr_data->ta_params.ta_value ,grr_data->ta_params.ul_ta_i ,grr_data->ta_params.ul_ta_tn ,grr_data->ta_params.dl_ta_i ,grr_data->ta_params.dl_ta_tn); grr_data->ta_params.dl_ta_i = 0xFF; grr_data->ta_params.dl_ta_tn = 0xFF; } } break; case UL_ASSIGNMENT: { tc_cgrlc_tbf_rel_res( mphp_tbf_release_con_i->tbf_type ); /* * uplink tbf released, set dl ta, if it is different */ if(!((grr_data->ta_params.l1_ta_value EQ grr_data->ta_params.ta_value) AND (grr_data->ta_params.l1_ta_i EQ grr_data->ta_params.dl_ta_i) AND (grr_data->ta_params.l1_ta_tn EQ grr_data->ta_params.dl_ta_tn))) { PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */ mphp_timing_advance_req->assign_id = 0; mphp_timing_advance_req->p_timing_advance.ta_value = grr_data->ta_params.ta_value; mphp_timing_advance_req->p_timing_advance.ta_index = grr_data->ta_params.dl_ta_i; mphp_timing_advance_req->p_timing_advance.tn = grr_data->ta_params.dl_ta_tn; PSEND(hCommL1,mphp_timing_advance_req); TRACE_EVENT_P5("UL TBF_REL TAU: new: %d %d %d-- old %d %d" ,grr_data->ta_params.ta_value ,grr_data->ta_params.dl_ta_i ,grr_data->ta_params.dl_ta_tn ,grr_data->ta_params.ul_ta_i ,grr_data->ta_params.ul_ta_tn); grr_data->ta_params.ul_ta_i = 0xFF; grr_data->ta_params.ul_ta_tn = 0xFF; } } break; default: TRACE_ERROR( "TBF RELEASED, stay in tbf mode, concurrent tbf or no tbf ????" ); break; } break; case TC_CPAP: case TC_WAIT_ASSIGN: case TC_POLLING: case TC_WAIT_2P_ASSIGN: /* in these cases the prim shall not occur */ default: TRACE_ERROR( "SIG_GFP_TC_TBF_RELEASE_CON unexpected" ); break; } } /* sig_gfp_tc_tbf_release_con() */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_stop_single_block_con +------------------------------------------------------------------------------ | Description : Handles | | Parameters : T_MPHP_STOP_SINGLE_BLOCK_CON * mphp_stop_single_block_con_i | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_stop_single_block_con (T_MPHP_STOP_SINGLE_BLOCK_CON * mphp_stop_single_block_con_i ) { TRACE_ISIG( "sig_gfp_tc_stop_single_block_con" ); switch( GET_STATE( TC ) ) { case TC_PIM: TRACE_EVENT("MPHP_STOP_SINGLE_BLOCK_CON in TC_PIM: nothing to do"); tc_cgrlc_access_status_req(); break; case TC_WAIT_2P_ASSIGN: if(grr_t_status( T3172_1 ) > 0) { tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_ACCESS_FAILED,CGRLC_PRIM_STATUS_ONE); sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_IDLE, TASK_STOP_DUMMY_VALUE ); } else { /* * two phase access has failed */ SET_STATE(TC,TC_PIM); tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_ACCESS_FAILED,CGRLC_PRIM_STATUS_NULL); } break; case TC_ACCESS_DISABLED: if(!grr_data->tc.two_2p_w_4_tbf_con) { TRACE_EVENT("BLC_C abort TBF"); tc_abort_tbf( grr_data->tbf_type ); } else { tc_call_disable_callback_func( ); } break; case TC_SINGLE_BLOCK: /* * single block procedure for uplink ctrl message or receiving DL block stopped */ /* * Stay in TC_SINGLE_BLOCK state while access reject is running. * Go to TC_PIM after T3170 is expired */ if( grr_t_status( T3170 ) EQ 0 ) { SET_STATE(TC,TC_PIM); tc_cgrlc_access_status_req(); } break; default: TRACE_ERROR( "SIG_GFP_TC_STOP_SINGLE_BLOCK_CON unexpected" ); break; } } /* sig_gfp_tc_stop_single_block_con () */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_packet_tbf_rel_ptm +------------------------------------------------------------------------------ | Description : Handles the signal sig_gfp_tc_packet_tbf_rel_ptm | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_packet_tbf_rel_ptm (ULONG fn, UBYTE rrbp, UBYTE sp ) { MCAST(d_tbf_release,D_TBF_RELEASE); TRACE_ISIG( "sig_gfp_tc_packet_tbf_rel_ptm" ); switch( GET_STATE( TC ) ) { case TC_CONTENTION_RESOLUTION: case TC_TBF_ACTIVE: if( !d_tbf_release->dl_release AND !d_tbf_release->ul_release) { TRACE_ERROR("no release request in packet tbf release"); return; } else { T_TBF_TYPE tbf_type = CGRLC_TBF_MODE_NULL; UBYTE rel_cause = CGRLC_TBF_REL_ABNORMAL; ULONG rel_fn = CGRLC_STARTING_TIME_NOT_PRESENT; if( d_tbf_release->dl_release AND d_tbf_release->ul_release ) { if (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL) { tbf_type = CGRLC_TBF_MODE_DL_UL; } else if (grr_data->tbf_type EQ CGRLC_TBF_MODE_UL) { tbf_type = CGRLC_TBF_MODE_UL; } else if (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL) { tbf_type = CGRLC_TBF_MODE_DL; } } else if ( d_tbf_release->dl_release AND ((grr_data->tbf_type EQ CGRLC_TBF_MODE_DL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL))) { tbf_type = CGRLC_TBF_MODE_DL; } else if ( d_tbf_release->ul_release AND ((grr_data->tbf_type EQ CGRLC_TBF_MODE_UL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL))) { tbf_type = CGRLC_TBF_MODE_UL; } if( sp ) { rel_fn = grr_calc_new_poll_pos(fn,rrbp); } if( d_tbf_release->rel_cause EQ NORMAL_RELEASE) { if ( d_tbf_release->ul_release AND ((grr_data->tbf_type EQ CGRLC_TBF_MODE_UL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL))) { rel_cause = CGRLC_TBF_REL_NORMAL; } } tc_cgrlc_tbf_rel_req(tbf_type,rel_cause,rel_fn); } break; default: TRACE_ERROR( "SIG_GFP_TC_PACKET_TBF_REL_PTM unexpected" ); break; } } /* sig_gfp_tc_packet_tbf_rel_ptm () */ /* +------------------------------------------------------------------------------ | Function : sig_gfp_tc_poll_ind +------------------------------------------------------------------------------ | Description : Handles the signal sig_gfp_tc_poll_ind | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_gfp_tc_poll_ind (ULONG fn, UBYTE rrbp, UBYTE poll_type,UBYTE pctrl_ack ) { TRACE_ISIG( "sig_gfp_tc_poll_ind" ); switch( GET_STATE( TC ) ) { case TC_PIM: case TC_CPAP: case TC_POLLING: case TC_WAIT_ASSIGN: case TC_WAIT_2P_ASSIGN: case TC_SINGLE_BLOCK: case TC_WAIT_STOP_TASK_CNF: switch(grr_data->tbf_type) { case CGRLC_TBF_MODE_NULL: tc_send_polling_res ( poll_type,fn,rrbp,pctrl_ack); break; default: TRACE_ERROR( "SIG_GFP_TC_POLL_IND unexpected tbf_type" ); break; } break; default: TRACE_ERROR( "SIG_GFP_TC_POLL_IND unexpected" ); break; } } /* sig_gfp_tc_poll_ind () */ /* +------------------------------------------------------------------------------ | Function : sig_ctrl_tc_delete_cs_msg +------------------------------------------------------------------------------ | Description : This function deletes the control blocks of cs owner. This | function is called when MS is moving from PAM to PTM. In this | scenario it has to delete PMRs if any. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void sig_ctrl_tc_delete_cs_msg ( void ) { UBYTE i= 0; TRACE_FUNCTION( "sig_ctrl_tc_delete_cs_msg" ); while( i < MAX_CTRL_BLK_NUM AND grr_data->tc.ul_ctrl_blk.seq[i] NEQ MAX_CTRL_BLK_NUM ) { if( grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].state EQ BLK_STATE_ALLOCATED ) { /* remove control block */ TRACE_EVENT_P2("Delete Control msg sequence:%d owner:%d", grr_data->tc.ul_ctrl_blk.seq[i], grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner); if (CGRLC_BLK_OWNER_CS EQ grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner) { tc_cancel_ctrl_blk(grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner); } } } }/* sig_ctrl_tc_delete_cs_msg*/