FreeCalypso > hg > fc-magnetite
view src/g23m-gprs/sndcp/sndcp_mgp.c @ 495:9e55fe3a5ee4
OSL: os_mis_fl.c compiles
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 24 Jun 2018 20:47:42 +0000 |
| parents | 219afcfc6250 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GPRS (8441) | Modul : sndcp_mgp.c +----------------------------------------------------------------------------- | 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 modul is part of the entity SNDCP and implements all | functions to handles the incoming primitives as described in | the SDL-documentation (MG-statemachine) +----------------------------------------------------------------------------- */ #define ENTITY_SNDCP /*==== INCLUDES =============================================================*/ #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ #include "macdef.h" #include "gsm.h" /* to get a lot of macros */ #include "prim.h" /* to get the definitions of used SAP and directions */ #include "dti.h" #ifdef _SNDCP_DTI_2_ #include <string.h> #endif /* _SNDCP_DTI_2_ */ #include "sndcp.h" /* to get the global entity definitions */ #include "sndcp_f.h" /* to get the functions to access the global arrays*/ #include "sndcp_mgf.h" /* to get the local functions of service mg */ #include "sndcp_nuf.h" #include "sndcp_nus.h" /* to get the internal signals toservice nu */ #include "sndcp_nds.h" /* to get the internal signals to service nd */ #include "sndcp_cias.h" /* to get the internal signals to service cia */ #include "sndcp_sds.h" /* to get the signals to sd service */ #include "sndcp_sus.h" /* to get the internal signals to service su */ #include "sndcp_suas.h" /* to get the internal signals to service sua */ #include "sndcp_sdas.h" /* to get the signals to sda service */ #include "sndcp_sdf.h" #include "sndcp_sdaf.h" /*==== CONST ================================================================*/ #define TCPIP_NAME "TCP" /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /* +------------------------------------------------------------------------------ | Function : mg_est_cnf_est_pending +------------------------------------------------------------------------------ | Description : After receiving an ll_establish_cnf, an snsm_activate_res | is sent to each waiting nsapi, sua and sda, sd are notified. | | Parameters : ll_establish_cnf | +------------------------------------------------------------------------------ */ LOCAL void mg_est_cnf_est_pending (T_LL_ESTABLISH_CNF* ll_establish_cnf) { UBYTE nsapi = 0; USHORT sapi_state = MG_IDLE; TRACE_FUNCTION( "mg_est_cnf_est_pending" ); /* * If MG_REL_NEC_LOC/PEER is set for the affected sapi, there will be no * nsapi waiting for LL_ESTABLISH_CNF. * LL_RELEASE_REQ must be sent. */ sndcp_get_sapi_state(ll_establish_cnf->sapi, &sapi_state); if ((sapi_state & MG_REL_NEC_LOC) > 0) { PALLOC(ll_release_req, LL_RELEASE_REQ); ll_release_req->sapi = ll_establish_cnf->sapi; ll_release_req->local = TRUE; sndcp_unset_sapi_state(ll_release_req->sapi, MG_REL_NEC_LOC); /* * Set the "state" for the affected and sapi to MG_REL. */ sndcp_set_sapi_state(ll_establish_cnf->sapi, MG_REL); sndcp_unset_sapi_state(ll_establish_cnf->sapi, MG_EST); PSEND(hCommLLC, ll_release_req); return; } if ((sapi_state & MG_REL_NEC_PEER) > 0) { PALLOC(ll_release_req, LL_RELEASE_REQ); ll_release_req->sapi = ll_establish_cnf->sapi; ll_release_req->local = FALSE; sndcp_unset_sapi_state(ll_release_req->sapi, MG_REL_NEC_PEER); /* * Set the "state" for the affected and sapi to MG_REL. */ sndcp_set_sapi_state(ll_establish_cnf->sapi, MG_REL); sndcp_unset_sapi_state(ll_establish_cnf->sapi, MG_EST); PSEND(hCommLLC, ll_release_req); return; } if ((sapi_state & MG_XID_NEC) > 0) { sndcp_unset_sapi_state(ll_establish_cnf->sapi, MG_EST); return; } /* * Send an SNSM_ACTIVATE_RES to all nsapis that are waiting for * an LL_ESTABLISH_CNF. */ for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { USHORT nsapi_state = MG_IDLE; USHORT local_sapi_state = MG_IDLE; UBYTE sapi = 0; UBYTE sapi_index = 0; sndcp_get_nsapi_state(nsapi, &nsapi_state); sndcp_get_nsapi_sapi(nsapi, &sapi); sndcp_get_sapi_state(sapi, &local_sapi_state); sndcp_get_sapi_index(sapi, &sapi_index); if ((nsapi_state & MG_ACT) > 0 && (local_sapi_state & MG_XID) == 0 && sapi == ll_establish_cnf->sapi) { #ifndef SNDCP_UPM_INCLUDED mg_dti_open(nsapi); #else nu_ready_ind_if_nec(nsapi); #endif mg_send_snsm_activate_res(nsapi); sndcp_unset_nsapi_state(nsapi, MG_ACT); } if ((nsapi_state & MG_ACT) > 0 && (local_sapi_state & MG_XID) > 0 && sapi == ll_establish_cnf->sapi) { /* * Open DTI connection. */ #ifndef SNDCP_UPM_INCLUDED mg_dti_open(nsapi); #else nu_ready_ind_if_nec(nsapi); #endif mg_send_snsm_activate_res(nsapi); /* * Set nsapi state to MG_IDLE. */ sndcp_unset_nsapi_state(nsapi, MG_ACT); } if (((local_sapi_state & MG_EST) > 0) && ((nsapi_state & MG_ACT) == 0) && ((local_sapi_state & MG_XID) > 0)) { sig_mg_nu_reset_ack(nsapi, 0, 0, FALSE); } } /* for (nsapi... */ /* * All nsapis at this sapi that use ack mode, enter recovery state. */ for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) { UBYTE sapi = 0; BOOL ack = FALSE; sndcp_get_nsapi_sapi(nsapi, &sapi); sndcp_get_nsapi_ack(nsapi, &ack); if (ack && sapi == ll_establish_cnf->sapi) { sig_mg_cia_delete_npdus(nsapi); sig_mg_sua_delete_pdus(nsapi, sapi, FALSE); sig_mg_nu_recover(nsapi); sig_mg_nd_recover(nsapi); } } /* for all nsapis */ sndcp_unset_sapi_state(ll_establish_cnf->sapi, MG_XID); sndcp_unset_sapi_state(ll_establish_cnf->sapi, MG_EST); sndcp_set_sapi_ack(ll_establish_cnf->sapi, TRUE); /* * Service sda may now leave state SDA_ESTABLISH_REQUESTED. */ sig_mg_sda_end_est(ll_establish_cnf->sapi, TRUE); /* * Services su and sua may now leave suspend state. */ sig_mg_su_resume(ll_establish_cnf->sapi); sig_mg_sua_resume(ll_establish_cnf->sapi); mg_resume_affected_nus(ll_establish_cnf->sapi); /* * If req xid has been changed during establishment, resend it. */ mg_resend_xid_if_nec(ll_establish_cnf->sapi); } /* mg_est_cnf_est_pending() */ /* +------------------------------------------------------------------------------ | Function : mg_check_unset_nsapi_flow_ctrl_flag +------------------------------------------------------------------------------ | Description : This function checks if flow control is received before PDP | activation for the nsapi by checking the bit in nsapi_rcv_rdy_b4_used flag | for the NSAPI | Depending on the mode calls the corresponding function to set the | nsapi recv flag to true. | In all cases unset the NSAPI bit in the nsapi_rcv_rdy_b4_used flag | | Parameters : affected nsapi, mode | +------------------------------------------------------------------------------ */ LOCAL void mg_check_unset_nsapi_flow_ctrl_flag (UBYTE nsapi, UBYTE mode) { /* check if flow control is received before PDP activation */ if ((sndcp_data->nsapi_rcv_rdy_b4_used & (0x001 << nsapi)) > 0) { if (mode == SNDCP_ACK) sda_set_nsapi_rec(nsapi, TRUE); else if (mode == SNDCP_UNACK) sd_set_nsapi_rec(nsapi, TRUE); /* Set flow control flag for the NSAPI to FALSE */ sndcp_data->nsapi_rcv_rdy_b4_used &= ~(0x001 << nsapi); } } /* +------------------------------------------------------------------------------ | Function : mg_get_downlink_data +------------------------------------------------------------------------------ | Description : If at the given sapi an nsapi is active and using | unacknowledged LLC operation mode then sig_mg_sd_getunitdata | (sapi) is sent. | If at the given sapi an nsapi is active and using | acknowledged LLC operation mode then sig_mg_sda_getdata(sapi) | is sent. | | Parameters : affected sapi | +------------------------------------------------------------------------------ */ LOCAL void mg_get_downlink_data (UBYTE sapi) { /* * Are unack or ack nsapis used? */ UBYTE nsapi; TRACE_FUNCTION( "mg_get_downlink_data" ); for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) { BOOL used = FALSE; sndcp_is_nsapi_used(nsapi, &used); if (used) { UBYTE local_sapi = 0; sndcp_get_nsapi_sapi(nsapi, &local_sapi); if (sapi == local_sapi) { BOOL ack = FALSE; USHORT nsapi_state = MG_IDLE; USHORT sapi_state = MG_IDLE; sndcp_get_nsapi_state(nsapi, &nsapi_state); sndcp_get_sapi_state(local_sapi, &sapi_state); if (((sapi_state & MG_XID) == 0) && ((sapi_state & MG_EST) == 0)) { sndcp_get_nsapi_ack(nsapi, &ack); if(ack){ sig_mg_sda_getdata(sapi, nsapi); } else { sig_mg_sd_getunitdata(sapi, nsapi); } } } } } /* for all nsapis */ } /* mg_get_downlink_data() */ /* +------------------------------------------------------------------------------ | Function : mg_is_comp_available +------------------------------------------------------------------------------ | Description : is another compressor available | | Parameters : sapi, ack, kind, available | | Note: implementation dependent!!! | +------------------------------------------------------------------------------ */ LOCAL void mg_is_comp_available (UBYTE sapi, BOOL ack, UBYTE kind, UBYTE msid, BOOL* available) { UBYTE nsapi = 0; USHORT nsapi_set = 0; UBYTE sapi_index = 0; BOOL local_ack = FALSE; T_XID_BLOCK comp_xid_block; U16 sapi_state = MG_IDLE; TRACE_FUNCTION( "mg_is_comp_available" ); sndcp_get_sapi_index(sapi, &sapi_index); /* * Implementation dependent! * Currently only implemented for VJ. * Is requested xid block for the given SAPI holding a compressor of the * given kind? */ if (sndcp_data->vj_count < SNDCP_MAX_VJ_COUNT) { *available = TRUE; return; } /* * If an XID negotiation is ongoing we have to look at the compressors in * req_xid_block: is a compressor requested that will be used for the same * LLC operation mode? * If no negotiation is pending, we must look at the cur_xid_block of the * SAPI. * Note: since we have checked before that vj_count has already reached * SNDCP_MAX_VJ_COUNT, ther must be an appropriate compressor on the * used SAPI, current or requested which may also be used for this nsapi. * No new compressor is available. */ sndcp_get_sapi_state(sapi, &sapi_state); if (((sapi_state & MG_EST) == 0) && ((sapi_state & MG_XID) == 0)) { comp_xid_block = sndcp_data->mg.cur_xid_block[sapi_index]; } else { comp_xid_block = sndcp_data->mg.req_xid_block[sapi_index]; } nsapi_set = comp_xid_block.vj.nsapis; if (! comp_xid_block.vj.is_set || (comp_xid_block.vj.is_set && nsapi_set == 0)) { *available = FALSE; return; } /* * If the LLC operation mode of the cur_xid_block is not equal to the * given LLC operation mode, no compressor is available. */ for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { if (((1 << nsapi) & nsapi_set) > 0) { break; } } if(nsapi < SNDCP_NUMBER_OF_NSAPIS){ sndcp_get_nsapi_ack(nsapi, &local_ack); if ((local_ack && ack) || (! local_ack && ack)) { *available = TRUE; return; } } else { /* * No nsapi yet using the compressor. */ *available = TRUE; return; } *available = FALSE; return; } /* mg_is_comp_available() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_release_to_snsm_status +------------------------------------------------------------------------------ | Description : Converts ll_release_ind->cause to snsm_status_req->cause | | Parameters : ll_release_ind->error_cause | Return : snsm_status_req->cause | +------------------------------------------------------------------------------ */ LOCAL U16 mg_ll_release_to_snsm_status (U16 ll_cause) { switch (ll_cause) { #ifdef SNDCP_2to1 return ll_cause; #else /*SNDCP_2to1*/ #ifdef SNDCP_UPM_INCLUDED /* Here the cause values from LL sap is converted to * cause values from CAUSE include SAP. This is because * SM expects these cause values. */ case LL_RELCS_INVALID_XID: return CAUSE_LLC_INVALID_XID; case LL_RELCS_DM_RECEIVED: return CAUSE_LLC_DM_RECEIVED; case LL_RELCS_NO_PEER_RES: return CAUSE_LLC_NO_PEER_RES; case LL_RELCS_NORMAL: return CAUSE_LLC_NORMAL_REL; #endif /* SNDCP_UPM_INCLUDED */ #endif /*SNDCP_2to1*/ default: return ll_cause; } } /* mg_ll_release_to_snsm_status() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_status_to_snsm_status +------------------------------------------------------------------------------ | Description : Converts ll_status_ind->error_cause to snsm_status_req->cause | | Parameters : ll_status_ind->error_cause | Return : snsm_status_req->cause | +------------------------------------------------------------------------------ */ LOCAL U16 mg_ll_status_to_snsm_status (U16 ll_error_cause) { switch (ll_error_cause) { #ifdef SNDCP_2to1 return ll_error_cause; #else /*SNDCP_2to1*/ #ifdef SNDCP_UPM_INCLUDED /* Here the cause values from LL sap is converted to * cause values from CAUSE include SAP. This is because * SM expects these cause values. */ case LL_ERRCS_INVALID_XID: return CAUSE_LLC_INVALID_XID; case LL_ERRCS_NO_PEER_RES: return CAUSE_LLC_NO_PEER_RES; #endif /* SNDCP_UPM_INCLUDED */ #endif /* SNDCP_2to1 */ default: return ll_error_cause; } } /* mg_ll_status_to_snsm_status() */ /* +------------------------------------------------------------------------------ | Function : mg_mod_ack_unack +------------------------------------------------------------------------------ | Description : An snsm_modify_ind has indicated that the operation mode of | the affected nsapi changed from acknowledged to unacknowledged. | | Parameters : snsm_modify_ind | +------------------------------------------------------------------------------ */ #ifdef SNDCP_UPM_INCLUDED LOCAL void mg_mod_ack_unack (T_SN_MODIFY_REQ* snsm_modify_ind) { #else LOCAL void mg_mod_ack_unack (T_SNSM_MODIFY_IND* snsm_modify_ind) { #endif /*#ifdef SNDCP_UPM_INCLUDED*/ UBYTE nsapi = 0; BOOL alone = TRUE; TRACE_FUNCTION( "mg_mod_ack_unack" ); mg_delete_npdus(snsm_modify_ind->nsapi); sig_mg_nu_reset(snsm_modify_ind->nsapi, TRUE); /* * LL_RELEASE_IND expected, if this was the only ack nsapi on the affected * sapi. */ while (nsapi < SNDCP_NUMBER_OF_NSAPIS && alone) { UBYTE sapi = 0; BOOL ack = FALSE; sndcp_get_nsapi_sapi(nsapi, &sapi); sndcp_get_nsapi_ack(nsapi, &ack); alone = ! (nsapi != snsm_modify_ind->nsapi && sapi == snsm_modify_ind->sapi && ack); sndcp_set_nsapi_ack(snsm_modify_ind->nsapi, FALSE); nsapi++; } if (alone) { sndcp_data->mg.mod_expects |= MG_MOD_X_REL; } } /* mg_mod_ack_unack() */ /* +------------------------------------------------------------------------------ | Function : mg_mod_nsapi_new +------------------------------------------------------------------------------ | Description : An snsm_modify_ind has indicated the creation of a new NSAPI. | Actions similar to snsm_activate_ind are taken, but the | establishment is never initiated by the MS. Everything | concerning the given nsapi is set to acknowlegded, but the | LLC establishment is expected to be done by the net. | | Parameters : snsm_modify_ind | +------------------------------------------------------------------------------ */ #ifdef SNDCP_UPM_INCLUDED LOCAL void mg_mod_nsapi_new (T_SN_MODIFY_REQ* snsm_modify_ind) { #else LOCAL void mg_mod_nsapi_new (T_SNSM_MODIFY_IND* snsm_modify_ind) { #endif /*#ifdef SNDCP_UPM_INCLUDED*/ /* * LLC mode specified? */ BOOL spec = FALSE; /* * LLC mode acknowledged? */ BOOL b = FALSE; TRACE_FUNCTION( "mg_mod_nsapi_new" ); sndcp_set_nsapi_used(snsm_modify_ind->nsapi, TRUE); sndcp_set_nsapi_qos(snsm_modify_ind->nsapi, snsm_modify_ind->snsm_qos); sndcp_set_nsapi_sapi(snsm_modify_ind->nsapi, snsm_modify_ind->sapi); sndcp_set_nsapi_prio(snsm_modify_ind->nsapi, snsm_modify_ind->radio_prio); #ifdef REL99 sndcp_set_nsapi_pktflowid(snsm_modify_ind->nsapi, snsm_modify_ind->pkt_flow_id); #endif /*REL99*/ mg_is_ack(snsm_modify_ind->snsm_qos, &spec, &b); if (spec) { if (b) { BOOL ack = FALSE; /* * The NSAPI will use acknowledged LLC operation mode. */ sndcp_set_nsapi_ack(snsm_modify_ind->nsapi, TRUE); /* * Is the affected SAPI already in ack mode? */ sndcp_get_sapi_ack(snsm_modify_ind->sapi, &ack); /* * Reset service nu to acknowledged LLC mode. */ #ifdef SNDCP_UPM_INCLUDED sig_mg_nu_reset_ack(snsm_modify_ind->nsapi, 0, /*snsm_modify_ind->send_no, FIXME !!*/ 0, /*snsm_modify_ind->rec_no, FIXME !!*/ TRUE); #else sig_mg_nu_reset_ack(snsm_modify_ind->nsapi, snsm_modify_ind->send_no, snsm_modify_ind->rec_no, TRUE); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } } /* * LL_ESTABLISH_IND expected. */ sndcp_data->mg.mod_expects |= MG_MOD_X_EST; } /* mg_mod_nsapi_new() */ /* +------------------------------------------------------------------------------ | Function : mg_mod_res_if_nec +------------------------------------------------------------------------------ | Description : The service var 'mod_expects' informs about the measures to be | taken before an SNSM_MODIFY_RES is sent. | If it is set to MG_MOD_X_READY then one SNSM_MODIFY_RES will be sent to each | of the nsapis indicated in service var 'waiting_nsapis'. | Sets 'waiting_nsapis' to 0. | Sets 'mod_expects' to MG_MOD_X_NONE. | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void mg_mod_res_if_nec (void) { TRACE_FUNCTION( "mg_mod_res_if_nec" ); if (sndcp_data->mg.mod_expects == MG_MOD_X_READY) { UBYTE nsapi = 0; for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { if ((sndcp_data->mg.waiting_nsapis & (1 << nsapi)) > 0) { #ifdef SNDCP_UPM_INCLUDED PALLOC (snsm_modify_res, SN_MODIFY_CNF); #else PALLOC (snsm_modify_res, SNSM_MODIFY_RES); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ snsm_modify_res->nsapi = nsapi; #ifdef SNDCP_UPM_INCLUDED PSEND(hCommUPM, snsm_modify_res); #else PSEND(hCommSM, snsm_modify_res); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } } sndcp_data->mg.waiting_nsapis = 0; sndcp_data->mg.mod_expects = MG_MOD_X_NONE; } } /* mg_mod_res_if_nec() */ /* +------------------------------------------------------------------------------ | Function : mg_mod_sapi_diff +------------------------------------------------------------------------------ | Description : An snsm_modify_ind has indicated that the new sapi for the | affected context is different from the current one. | | Parameters : snsm_modify_ind | +------------------------------------------------------------------------------ */ #ifdef SNDCP_UPM_INCLUDED LOCAL void mg_mod_sapi_diff (T_SN_MODIFY_REQ* snsm_modify_ind) { #else LOCAL void mg_mod_sapi_diff (T_SNSM_MODIFY_IND* snsm_modify_ind) { #endif /*#ifdef SNDCP_UPM_INCLUDED*/ BOOL old_sapi_ack = FALSE; BOOL alone = TRUE; BOOL new_context_ack = FALSE; BOOL new_context_ack_spec = FALSE; BOOL new_sapi_est = FALSE; UBYTE nsapi = 0; UBYTE old_sapi = 0; BOOL rec = FALSE; UBYTE old_sapi_index, new_sapi_index = 0; T_SN_UNITDATA_IND *temp_sn_unitdata = NULL; TRACE_FUNCTION( "mg_mod_sapi_diff" ); /* * If old sapi was established and affected nsapi is only one connected * in ack mode: LL_RELEASE_IND expected. */ sndcp_get_sapi_ack(snsm_modify_ind->sapi, &old_sapi_ack); while (nsapi < SNDCP_NUMBER_OF_NSAPIS && alone) { UBYTE sapi = 0; BOOL ack = FALSE; sndcp_get_nsapi_sapi(nsapi, &sapi); sndcp_get_nsapi_ack(nsapi, &ack); alone = ! (nsapi != snsm_modify_ind->nsapi && sapi == snsm_modify_ind->sapi && ack); nsapi++; } /* * If new qos is ack and new sapi is not yet established: expect * LL_ESTABLISH_IND. */ mg_is_ack(snsm_modify_ind->snsm_qos, &new_context_ack_spec, &new_context_ack); if (alone && !new_context_ack) { sndcp_data->mg.mod_expects |= MG_MOD_X_REL; } sndcp_get_sapi_ack(snsm_modify_ind->sapi, &new_sapi_est); if (! new_sapi_est) { sndcp_data->mg.mod_expects |= MG_MOD_X_EST; } /* Old & the New SAPI are UnAck Mode, send SNSM_MOD_CNF to SM and * flowcontrol to LLC */ sndcp_get_nsapi_sapi(snsm_modify_ind->nsapi, &old_sapi); sndcp_get_sapi_ack(old_sapi, &old_sapi_ack); if(new_context_ack == old_sapi_ack && old_sapi_ack == FALSE) { sndcp_get_sapi_index(old_sapi, &old_sapi_index); sndcp_data->sd = & sndcp_data->sd_base[old_sapi_index]; sd_is_nsapi_rec(snsm_modify_ind->nsapi, &rec); /* Copy the Pointer, where Data on old Sapi was stored if any */ if(sndcp_data->sd->cur_sn_unitdata_ind[snsm_modify_ind->nsapi] NEQ NULL) { temp_sn_unitdata = sndcp_data->sd->cur_sn_unitdata_ind[snsm_modify_ind->nsapi]; sndcp_data->sd->cur_sn_unitdata_ind[snsm_modify_ind->nsapi] = NULL; } /* Set the old SAPI's NSAPI state to Non Receptive*/ sd_set_nsapi_rec(snsm_modify_ind->nsapi, FALSE); /* Set the state of NSAPI associated with new SAPI same as Old SAPI */ sndcp_get_sapi_index(snsm_modify_ind->sapi, &new_sapi_index); sndcp_data->sd = & sndcp_data->sd_base[new_sapi_index]; sd_set_nsapi_rec(snsm_modify_ind->nsapi, rec); sndcp_data->mg.mod_expects = MG_MOD_X_READY; /* * Taking care of DOWNLINK Data, when PDP is Modified * from one sapi to another. */ switch( sndcp_get_nsapi_rec_state(snsm_modify_ind->nsapi) ) { case SD_UNACK_RECEIVE_SUBSEQUENT_SEGMENT: /* * If the Receiving State is SD_UNACK_RECEIVE_SUBSEQUENT_SEGMENT, * this means that SNDCP has not receive the whole N-PDU, * it has received some SN-PDU's of the whole N-PDU. * Hence we need to DELETE those SN-PDU's since PDP gets modified. */ sig_mg_cia_delete_npdus(snsm_modify_ind->nsapi); sndcp_set_nsapi_rec_state(snsm_modify_ind->nsapi, SD_UNACK_RECEIVE_FIRST_SEGMENT); break; case SD_UNACK_WAIT_NSAPI: /* * If the Receiving State is SD_UNACK_WAIT_NSAPI, this means that * SNDCP has received the whole N-PDU. * Since SNDCP has not received the FLOW CONTROL from application, * so it could not send the N-PDU to the application. * In the meantime PDP gets modified.In this condition SNDCP needs * to copy the N-PDU from the old sapi to the modified sapi. */ if(temp_sn_unitdata NEQ NULL) { sndcp_data->sd->cur_sn_unitdata_ind[snsm_modify_ind->nsapi] = temp_sn_unitdata; } break; default: /* * It is assumed that if the Receiving State is SD_UNACK_DISCARD * then SNDCP must have deleted all the SN-PDU,s that it might * have received on the old sapi. Hence we need not have to do * anything here. */ break; } /* Flowcontrol to LLC for new SAPI to send downlink data after * PDP Modification */ if(sndcp_data->sd->cur_sn_unitdata_ind[snsm_modify_ind->nsapi] EQ NULL) { sd_get_unitdata_if_nec(snsm_modify_ind->sapi); } } /* * Now switch to the new setting. */ sndcp_set_nsapi_sapi(snsm_modify_ind->nsapi, snsm_modify_ind->sapi); } /* mg_mod_sapi_diff() */ /* +------------------------------------------------------------------------------ | Function : mg_mod_unack_ack +------------------------------------------------------------------------------ | Description : An snsm_modify_ind has indicated that the operation mode of | the affected nsapi changed from unacknowledged to acknowledged. | | Parameters : snsm_modify_ind | +------------------------------------------------------------------------------ */ #ifdef SNDCP_UPM_INCLUDED LOCAL void mg_mod_unack_ack (T_SN_MODIFY_REQ* snsm_modify_ind) { #else LOCAL void mg_mod_unack_ack (T_SNSM_MODIFY_IND* snsm_modify_ind) { #endif /*#ifdef SNDCP_UPM_INCLUDED*/ BOOL ack = FALSE; TRACE_FUNCTION( "mg_mod_unack_ack" ); mg_delete_npdus(snsm_modify_ind->nsapi); sndcp_set_nsapi_ack(snsm_modify_ind->nsapi, TRUE); sig_mg_nu_reset_ack(snsm_modify_ind->nsapi, 0, 0, TRUE); /* * LL_ESTABLISH_IND expected, if the sapi is not in established mode. */ sndcp_get_sapi_ack(snsm_modify_ind->sapi, &ack); if (! ack) { sndcp_data->mg.mod_expects |= MG_MOD_X_EST; } } /* mg_mod_unack_ack() */ /* +------------------------------------------------------------------------------ | Function : mg_start_re_est_timer +------------------------------------------------------------------------------ | Description : According to GSM 4.65, 6.2.1.4, starts re-establishment timer | | Parameters : affected sapi | +------------------------------------------------------------------------------ */ LOCAL void mg_start_re_est_timer (UBYTE sapi) { UBYTE sapi_index = 0; TRACE_FUNCTION( "mg_start_re_est_timer" ); sndcp_get_sapi_index(sapi, &sapi_index); vsi_t_start(SNDCP_handle, sapi_index, MG_RE_EST_TIME); } /* mg_start_re_est_timer() */ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : mg_exp_re_est_timer +------------------------------------------------------------------------------ | Description : Re establishment timer has expired | | Parameters : sapi_index | +------------------------------------------------------------------------------ */ GLOBAL void mg_exp_re_est_timer (UBYTE sapi_index) { TRACE_FUNCTION( "mg_exp_re_est_timer" ); sndcp_data->su = & sndcp_data->su_base[sapi_index]; #ifdef SNDCP_UPM_INCLUDED mg_re_negotiate_ack(sndcp_data->su->sapi, CAUSE_SN_NO_PEER_RESPONSE); #else mg_re_negotiate_ack(sndcp_data->su->sapi, LL_RELCS_NO_PEER_RES); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } /* mg_exp_re_est_timer() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_reset_ind +------------------------------------------------------------------------------ | Description : Handles the primitive LL_RESET_IND | | Parameters : *ll_reset_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_ll_reset_ind ( T_LL_RESET_IND *ll_reset_ind ) { UBYTE nsapi = 0; UBYTE sapi_index = 0; BOOL ack = FALSE; UBYTE sapi = 0; TRACE_FUNCTION( "mg_ll_reset_ind" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS;nsapi++) { BOOL used = 0; sndcp_is_nsapi_used(nsapi, &used); if (! used) { continue; } sig_mg_nu_reset_ind(nsapi); sig_mg_nu_suspend(nsapi); sndcp_get_nsapi_sapi(nsapi, &sapi); sndcp_get_nsapi_ack(nsapi, &ack); if (ack) { sig_mg_sua_delete_pdus(nsapi, sapi, FALSE); sig_mg_sda_reset_ind(nsapi); sig_mg_nd_suspend(nsapi); sndcp_set_nsapi_state(nsapi, MG_SEQ); /* Set the flag as LL_ESTB_IND is expected * before resend of buffered NPDU */ sndcp_set_sapi_state(sapi, MG_EST_IND); } else { sig_mg_su_delete_pdus(nsapi, sapi); sig_mg_sd_reset_ind(nsapi); } sig_mg_nd_reset_ind(nsapi); } sig_mg_cia_reset_ind(); /* * Reset pending states and xid_block. */ for (sapi_index = 0; sapi_index < SNDCP_NUMBER_OF_SAPIS; sapi_index++) { sapi = (sndcp_data->sua_base[sapi_index]).sapi; /* * Reset SUA and SU services */ sig_mg_sua_n201(sapi, N201_I_DEFAULT); sig_mg_sua_reset_ind(sapi); sig_mg_su_n201(sapi, N201_U_DEFAULT); sig_mg_su_reset_ind(sapi); /* * cnf_xid_block and req_xid_block initialized. */ sndcp_reset_xid_block(&sndcp_data->mg.cnf_xid_block[sapi_index]); sndcp_reset_xid_block(&sndcp_data->mg.req_xid_block[sapi_index]); mg_reset_states_n_rej(sapi_index); /* * Init renegotiation counter and cur_xid_block with default values. */ sndcp_data->mg.renego[sapi_index] = 0; sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]); sig_mg_cia_new_xid (&sndcp_data->mg.cur_xid_block[sapi_index]); } sndcp_data->mg.mod_expects = MG_MOD_X_NONE; sndcp_data->mg.waiting_nsapis = 0; break; default: TRACE_ERROR( "LL_RESET_IND unexpected" ); break; } if (ll_reset_ind != NULL) { PFREE (ll_reset_ind); } } /* mg_ll_reset_ind() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_establish_cnf +------------------------------------------------------------------------------ | Description : Handles the primitive LL_ESTABLISH_CNF | | Parameters : *ll_establish_cnf - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_ll_establish_cnf ( T_LL_ESTABLISH_CNF *ll_establish_cnf ) { UBYTE sapi_index = 0; USHORT state = 0; TRACE_FUNCTION( "mg_ll_establish_cnf" ); TRACE_EVENT_P1("ll_establish_cnf->n201_i: %d", ll_establish_cnf->n201_i); sndcp_get_sapi_index(ll_establish_cnf->sapi, &sapi_index); switch( GET_STATE( MG ) ) { case MG_DEFAULT: sndcp_get_sapi_state(ll_establish_cnf->sapi, &state); if ((state & MG_EST) > 0) { UBYTE dec_ret = 0; UBYTE check_ret = 0; /* * Reset all compressors at this SAPI in ack mode. */ mg_reset_comp_ack(ll_establish_cnf->sapi); /* * Set N201 values in uplink services. */ sig_mg_su_n201(ll_establish_cnf->sapi, ll_establish_cnf->n201_u); sig_mg_sua_n201(ll_establish_cnf->sapi, ll_establish_cnf->n201_i); /* * SDL label MG_EST_CNF_EST_XID_PENDING. */ mg_decode_xid(&(ll_establish_cnf->sdu), &(sndcp_data->mg.cnf_xid_block[sapi_index]), &dec_ret, ll_establish_cnf->sapi); if (dec_ret == MG_XID_OK) { /* * SDL label MG_CHECK_CNF_XID_ACK */ mg_check_cnf_xid(&check_ret, ll_establish_cnf->sapi); if (check_ret == MG_XID_OK) { /* * This is now similar to the reaction to LL_XID_CNF: */ /* * SDL Label MG_CNF_OK_ACK */ mg_set_cur_xid_block(ll_establish_cnf->sapi); /* * Reset nsapis or ntts that were assigned, but are not any more. */ mg_clean_xid(ll_establish_cnf->sapi); /* * Resume suspended data transfer on sapi will be done in * mg_est_cnf_est_pending(ll_establish_cnf). */ mg_est_cnf_est_pending(ll_establish_cnf); sndcp_get_sapi_state(ll_establish_cnf->sapi, &state); if (((state & MG_XID_NEC) > 0) && ((state & MG_REL) == 0)) { mg_resend_xid_if_nec(ll_establish_cnf->sapi); } } else { #ifdef SNDCP_UPM_INCLUDED mg_re_negotiate_ack(ll_establish_cnf->sapi, CAUSE_SN_INVALID_XID); #else mg_re_negotiate_ack(ll_establish_cnf->sapi, SNSM_RELCS_INVALID_XID); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } } else { #ifdef SNDCP_UPM_INCLUDED mg_re_negotiate_ack(ll_establish_cnf->sapi, CAUSE_SN_INVALID_XID); #else mg_re_negotiate_ack(ll_establish_cnf->sapi, SNSM_RELCS_INVALID_XID); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } break; } else { /* if ((state & MG_EST) > 0) */ PALLOC(ll_release_req, LL_RELEASE_REQ); sndcp_unset_sapi_state(ll_release_req->sapi, MG_REL_NEC_PEER); ll_release_req->sapi = ll_establish_cnf->sapi; ll_release_req->local = FALSE; /* * Set the "state" for the affected sapi to MG_REL. */ sndcp_set_sapi_state(ll_establish_cnf->sapi, MG_REL); PSEND(hCommLLC, ll_release_req); } break; default: TRACE_ERROR( "LL_ESTABLISH_CNF unexpected" ); break; } /* * Establish confirm has been computed. If no new XID is pending, * the req_xid_block may be reset. */ sndcp_get_sapi_state(ll_establish_cnf->sapi, &state); if (((state & MG_XID) == 0) && ((state & MG_EST) == 0)) { sndcp_reset_xid_block(&sndcp_data->mg.req_xid_block[sapi_index]); } if (ll_establish_cnf != NULL) { PFREE(ll_establish_cnf); } } /* mg_ll_establish_cnf() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_status_ind +------------------------------------------------------------------------------ | Description : Handles the primitive LL_STATUS_IND | | Parameters : *ll_status_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_ll_status_ind ( T_LL_STATUS_IND *ll_status_ind ) { USHORT sapi_state = MG_IDLE; TRACE_FUNCTION( "mg_ll_status_ind" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: { #ifdef SNDCP_UPM_INCLUDED PALLOC(snsm_status_req, SN_STATUS_IND); #else PALLOC(snsm_status_req, SNSM_STATUS_REQ); #endif snsm_status_req->sapi = ll_status_ind->sapi; #ifdef SNDCP_UPM_INCLUDED snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_llc; snsm_status_req->ps_cause.value.llc_cause = #ifdef SNDCP_2to1 mg_ll_status_to_snsm_status(ll_status_ind->ps_cause.value.llc_cause); #else /*SNDCP_2to1*/ mg_ll_status_to_snsm_status(ll_status_ind->error_cause); #endif /*SNDCP_2to1*/ PSEND(hCommUPM, snsm_status_req); #else /*SNDCP_UPM_INCLUDED*/ snsm_status_req->status_cause = #ifdef _SNDCP_DTI_2_ mg_ll_status_to_snsm_status(ll_status_ind->error_cause); #else /* _SNDCP_DTI_2_ */ (U8)mg_ll_status_to_snsm_status(ll_status_ind->error_cause); #endif /* _SNDCP_DTI_2_ */ PSEND(hCommSM, snsm_status_req); #endif /*SNDCP_UPM_INCLUDED*/ sndcp_get_sapi_state(ll_status_ind->sapi, &sapi_state); if ((sapi_state & MG_XID) != 0) { sig_mg_su_resume(ll_status_ind->sapi); sig_mg_sua_resume(ll_status_ind->sapi); mg_resume_affected_nus(ll_status_ind->sapi); sndcp_unset_sapi_state (ll_status_ind->sapi, MG_XID); } if ((sapi_state & MG_EST) != 0) { #ifdef SNDCP_UPM_INCLUDED if (snsm_status_req->ps_cause.value.llc_cause == CAUSE_LLC_NO_PEER_RES) { #else /* SNDCP_UPM_INCLUDED */ #ifdef _SNDCP_DTI_2_ if (snsm_status_req->status_cause == LL_RELCS_NO_PEER_RES) { #else /*_SNDCP_DTI_2_*/ if (snsm_status_req->status_cause == SNSM_RELCS_NO_PEER_RES) { #endif /* _SNDCP_DTI_2_*/ #endif /* SNDCP_UPM_INCLUDED */ mg_start_re_est_timer(ll_status_ind->sapi); } else { sig_mg_su_resume(ll_status_ind->sapi); sig_mg_sua_resume(ll_status_ind->sapi); mg_resume_affected_nus(ll_status_ind->sapi); sndcp_unset_sapi_state (ll_status_ind->sapi, MG_EST); } } } break; default: TRACE_ERROR( "LL_STATUS_IND unexpected" ); break; } if (ll_status_ind != NULL) { PFREE(ll_status_ind); } } /* mg_ll_status_ind() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_establish_ind +------------------------------------------------------------------------------ | Description : Handles the primitive LL_ESTABLISH_IND | | Parameters : *ll_establish_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_ll_establish_ind ( T_LL_ESTABLISH_IND *ll_establish_ind ) { USHORT sapi_state = 0; TRACE_FUNCTION( "mg_ll_establish_ind" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_EST_IND); /* * Reset all compressors at this SAPI in ack mode. */ mg_reset_comp_ack(ll_establish_ind->sapi); /* * If prim has been expected in course of modification, here it is. */ sndcp_data->mg.mod_expects &= ~ MG_MOD_X_EST; /* * Do we have a collision? */ sndcp_get_sapi_state(ll_establish_ind->sapi, &sapi_state); if ((sapi_state & MG_REL) > 0) { PFREE(ll_establish_ind); return; } if (((sapi_state & MG_XID) > 0) || ((sapi_state & MG_EST) > 0)) { /* * Is the establishment a re-establishment? */ BOOL re = FALSE; sndcp_get_sapi_ack(ll_establish_ind->sapi, &re); if (re) { mg_col_re(ll_establish_ind); } else { mg_col_no_re(ll_establish_ind); } } else { /* * Is the establishment a re-establishment? */ BOOL re = FALSE; sndcp_get_sapi_ack(ll_establish_ind->sapi, &re); if (re) { mg_no_col_re(ll_establish_ind); } else { mg_no_col_no_re(ll_establish_ind); } } /* * Now send snsm_modify_res, if expected. */ mg_mod_res_if_nec(); break; default: TRACE_ERROR( "LL_ESTABLISH_IND unexpected" ); break; } if (ll_establish_ind != NULL) { PFREE(ll_establish_ind); } } /* mg_ll_establish_ind() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_release_cnf +------------------------------------------------------------------------------ | Description : Handles the primitive LL_RELEASE_CNF | | Parameters : *ll_release_cnf - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_ll_release_cnf ( T_LL_RELEASE_CNF *ll_release_cnf ) { UBYTE nsapi = 0; USHORT nsapi_state = MG_IDLE; UBYTE sapi = 0; USHORT sapi_state = MG_IDLE; TRACE_FUNCTION( "mg_ll_release_cnf" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: /* * Reset all compressors at this SAPI in ack mode. */ mg_reset_comp_ack(ll_release_cnf->sapi); for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { sndcp_get_nsapi_state(nsapi, &nsapi_state); sndcp_get_nsapi_sapi(nsapi, &sapi); sndcp_get_sapi_state(ll_release_cnf->sapi, &sapi_state); if (((sapi_state & MG_REL) > 0 ) && ((nsapi_state & MG_DEACT) > 0 ) && ((sapi_state & MG_XID) == 0 )) { /* * Release is now completed, negotiate XID or deactivate context. */ if (sapi == ll_release_cnf->sapi) { BOOL nec = FALSE; mg_is_rel_comp_nec(nsapi, &nec); if (nec) { sndcp_set_sapi_state(sapi, MG_XID_NEC); sndcp_get_sapi_state(sapi, &sapi_state); } else { #ifdef SNDCP_UPM_INCLUDED PALLOC(snsm_deactivate_res, SN_DEACTIVATE_CNF); snsm_deactivate_res->nsapi = nsapi; #else PALLOC(snsm_deactivate_res, SNSM_DEACTIVATE_RES); snsm_deactivate_res->nsapi = nsapi; #endif /*#ifdef SNDCP_UPM_INCLUDED*/ /* * Now the NSAPI is not in use anymore: */ sndcp_set_nsapi_used(nsapi, FALSE); sndcp_set_nsapi_ack(nsapi, FALSE); /* * Set the "state" of the nsapi. */ sndcp_unset_nsapi_state(nsapi, MG_DEACT); #ifdef SNDCP_UPM_INCLUDED PSEND(hCommUPM, snsm_deactivate_res); #else /*#ifdef SNDCP_UPM_INCLUDED*/ PSEND(hCommSM, snsm_deactivate_res); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } } } if (((sapi_state & MG_REL) > 0 ) && ((nsapi_state & MG_DEACT) > 0 ) && ((sapi_state & MG_XID_NEC) > 0 )) { /* * Release is now completed, * Remove nspi from compressor. */ /* * Suspend uplink transfer for affected sapi. */ sig_mg_su_suspend(sapi); sig_mg_sua_suspend(sapi); mg_suspend_affected_nus(sapi); /* * Negotiate possible deactivation of compressors. */ mg_send_xid_req_del(sapi); } } sndcp_set_sapi_ack(ll_release_cnf->sapi, FALSE); sndcp_unset_sapi_state(ll_release_cnf->sapi, MG_REL); break; default: TRACE_ERROR( "LL_RELEASE_CNF unexpected" ); break; } if (ll_release_cnf != NULL) { PFREE(ll_release_cnf); } } /* mg_ll_release_cnf() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_release_ind +------------------------------------------------------------------------------ | Description : Handles the primitive LL_RELEASE_IND | | Parameters : *ll_release_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_ll_release_ind ( T_LL_RELEASE_IND *ll_release_ind ) { USHORT sapi_state = 0; U8 sapi_index = 0; TRACE_FUNCTION( "mg_ll_release_ind" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: sndcp_unset_sapi_state(ll_release_ind->sapi, MG_REL_NEC_LOC + MG_REL_NEC_PEER); sndcp_get_sapi_state(ll_release_ind->sapi, &sapi_state); /* * Service sda may now leave state SDA_ESTABLISH_REQUESTED. */ sig_mg_sda_end_est(ll_release_ind->sapi, FALSE); #ifdef SNDCP_2to1 if (((sapi_state & MG_EST) > 0) && ((ll_release_ind->ps_cause.ctrl_value == CAUSE_is_from_llc) && (ll_release_ind->ps_cause.value.llc_cause == CAUSE_LLC_NO_PEER_RES))) #else /*SNDCP_2to1*/ if (((sapi_state & MG_EST) > 0) && (ll_release_ind->cause == LL_RELCS_NO_PEER_RES)) #endif /*SNDCP_2to1*/ { /* * SNDCP waits for LL_ESTABLISH_CNF and cause is "no peer response". * According to GSM 4.65, 6.2.1.4 a re-establishment is tried after an * implementation specific amount of time. */ mg_start_re_est_timer(ll_release_ind->sapi); PFREE(ll_release_ind); return; } sndcp_unset_sapi_state(ll_release_ind->sapi, MG_EST); if ((sapi_state & MG_REL) > 0) { /* * SNDCP waits for LL_ESTABLISH_CNF and cause is "no peer response". * According to GSM 4.65, 6.2.1.4 a re-establishment is tried after an * implementation specific amount of time. */ PALLOC (ll_release_cnf, LL_RELEASE_CNF); ll_release_cnf->sapi = ll_release_ind->sapi; mg_ll_release_cnf(ll_release_cnf); PFREE(ll_release_ind); return; } /* * Reset all compressors at this SAPI in ack mode. */ mg_reset_comp_ack(ll_release_ind->sapi); /* * If release has been expected in course of modification, here it is. */ if ((sndcp_data->mg.mod_expects & MG_MOD_X_REL) > 0) { sndcp_data->mg.mod_expects -= MG_MOD_X_REL; } mg_del_comp_pdus_ack(ll_release_ind->sapi); sig_mg_su_resume(ll_release_ind->sapi); sig_mg_sua_resume(ll_release_ind->sapi); mg_resume_affected_nus(ll_release_ind->sapi); #ifdef SNDCP_2to1 if (((ll_release_ind->ps_cause.ctrl_value == CAUSE_is_from_llc)&& (ll_release_ind->ps_cause.value.llc_cause == CAUSE_LLC_DM_RECEIVED)) || ((ll_release_ind->ps_cause.ctrl_value == CAUSE_is_from_llc)&& (ll_release_ind->ps_cause.value.llc_cause == CAUSE_LLC_INVALID_XID)) || ((ll_release_ind->ps_cause.ctrl_value == CAUSE_is_from_llc)&& (ll_release_ind->ps_cause.value.llc_cause == CAUSE_LLC_NO_PEER_RES))) { #else /*SNDCP_2to1*/ if (ll_release_ind->cause == LL_RELCS_DM_RECEIVED || ll_release_ind->cause == LL_RELCS_INVALID_XID || ll_release_ind->cause == LL_RELCS_NO_PEER_RES) { #endif /*SNDCP_2to1*/ #ifdef SNDCP_UPM_INCLUDED PALLOC (snsm_status_req, SN_STATUS_IND); #ifdef SNDCP_2to1 if((ll_release_ind->ps_cause.ctrl_value == CAUSE_is_from_llc)&& (ll_release_ind->ps_cause.value.llc_cause == CAUSE_LLC_DM_RECEIVED)){ #else if (ll_release_ind->cause == LL_RELCS_DM_RECEIVED){ #endif UBYTE nsapi, sapi = 0; USHORT nsapi_set = 0; for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++){ sndcp_get_nsapi_sapi(nsapi, &sapi); if(sapi == ll_release_ind->sapi){ BOOL ack = FALSE; sndcp_get_nsapi_ack(nsapi, &ack); if(ack){ nsapi_set |= (1 << nsapi); } } } snsm_status_req->nsapi_set = nsapi_set; } snsm_status_req->sapi = ll_release_ind->sapi; snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_llc; snsm_status_req->ps_cause.value.llc_cause = #ifdef SNDCP_2to1 mg_ll_release_to_snsm_status(ll_release_ind->ps_cause.value.llc_cause); #else /*SNDCP_2to1*/ mg_ll_release_to_snsm_status(ll_release_ind->cause); #endif /*SNDCP_2to1*/ PSEND(hCommUPM, snsm_status_req); #else /* SNDCP_UPM_INCLUDED */ PALLOC (snsm_status_req, SNSM_STATUS_REQ); snsm_status_req->sapi = ll_release_ind->sapi; snsm_status_req->status_cause = #ifdef _SNDCP_DTI_2_ mg_ll_release_to_snsm_status(ll_release_ind->cause); #else /* _SNDCP_DTI_2_ */ (U8)mg_ll_release_to_snsm_status(ll_release_ind->cause); #endif /* _SNDCP_DTI_2_ */ PSEND(hCommSM, snsm_status_req); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } sndcp_set_sapi_ack(ll_release_ind->sapi, FALSE); /* * Now send snsm_modify_res, if expected. */ mg_mod_res_if_nec(); break; default: TRACE_ERROR( "LL_RELEASE_IND unexpected" ); break; } /* * Establish confirm has been computed. If no new XID is pending, * the req_xid_block may be reset. */ sndcp_get_sapi_index(ll_release_ind->sapi, &sapi_index); sndcp_get_sapi_state(ll_release_ind->sapi, &sapi_state); if (((sapi_state & MG_XID) == 0) && ((sapi_state & MG_EST) == 0)) { sndcp_reset_xid_block(&sndcp_data->mg.req_xid_block[sapi_index]); } if (ll_release_ind != NULL) { PFREE(ll_release_ind); } } /* mg_ll_release_ind() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_xid_cnf +------------------------------------------------------------------------------ | Description : Handles the primitive LL_XID_CNF | | Parameters : *ll_xid_cnf - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_ll_xid_cnf ( T_LL_XID_CNF* ll_xid_cnf ) { UBYTE dec_ret = 0; UBYTE check_ret = 0; UBYTE sapi_index = 0; TRACE_FUNCTION( "mg_ll_xid_cnf" ); sndcp_get_sapi_index(ll_xid_cnf->sapi, &sapi_index); #ifdef SNDCP_TRACE_ALL TRACE_EVENT("incoming xid block:"); sndcp_trace_sdu(&ll_xid_cnf->sdu); #endif switch( GET_STATE( MG ) ) { case MG_DEFAULT: sndcp_unset_sapi_state(ll_xid_cnf->sapi, MG_XID); mg_decode_xid(&(ll_xid_cnf->sdu), &(sndcp_data->mg.cnf_xid_block[sapi_index]), &dec_ret, ll_xid_cnf->sapi); if (dec_ret == MG_XID_OK) { mg_check_cnf_xid(&check_ret, ll_xid_cnf->sapi); if (check_ret == MG_XID_OK) { USHORT sapi_state = MG_IDLE; /* * SDL Label MG_CNF_OK */ mg_set_cur_xid_block(ll_xid_cnf->sapi); mg_xid_cnf_ok_res(ll_xid_cnf->sapi); /* * Reset nsapis or ntts that were assigned, but are not any more. */ mg_clean_xid(ll_xid_cnf->sapi), /* * Set n201. */ sig_mg_su_n201 (ll_xid_cnf->sapi, ll_xid_cnf->n201_u); sig_mg_sua_n201 (ll_xid_cnf->sapi, ll_xid_cnf->n201_i); /* * Resume suspended data transfer on sapi. */ sndcp_get_sapi_state(ll_xid_cnf->sapi, &sapi_state); if (((sapi_state & MG_XID) == 0) && ((sapi_state & MG_EST) == 0)) { sig_mg_su_resume(ll_xid_cnf->sapi); sig_mg_sua_resume(ll_xid_cnf->sapi); mg_resume_affected_nus(ll_xid_cnf->sapi); } /* * Now get downlink data. */ mg_get_downlink_data(ll_xid_cnf->sapi); /* * XID confirm has been computed. The negotiation is finished and * the req_xid_block may be reset. */ sndcp_get_sapi_state(ll_xid_cnf->sapi, &sapi_state); if (((sapi_state & MG_XID) == 0) && ((sapi_state & MG_EST) == 0)) { sndcp_reset_xid_block(&sndcp_data->mg.req_xid_block[sapi_index]); } } else { mg_re_negotiate(ll_xid_cnf->sapi); } } else { mg_re_negotiate(ll_xid_cnf->sapi); } break; default: TRACE_ERROR( "LL_XID_CNF unexpected" ); break; } if (ll_xid_cnf != NULL) { PFREE(ll_xid_cnf); sndcp_reset_xid_block(&sndcp_data->mg.cnf_xid_block[sapi_index]); } } /* mg_ll_xid_cnf() */ /* +------------------------------------------------------------------------------ | Function : mg_ll_xid_ind +------------------------------------------------------------------------------ | Description : Handles the primitive LL_XID_IND | | Parameters : *ll_xid_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_ll_xid_ind ( T_LL_XID_IND *ll_xid_ind ) { UBYTE dec_ret = 0; UBYTE check_ret = 0; UBYTE sapi_index = 0; TRACE_FUNCTION( "mg_ll_xid_ind" ); sndcp_get_sapi_index(ll_xid_ind->sapi, &sapi_index); switch( GET_STATE( MG ) ) { case MG_DEFAULT: /* * Set N201 values in uplink services. */ sig_mg_su_n201(ll_xid_ind->sapi, ll_xid_ind->n201_u); sig_mg_sua_n201(ll_xid_ind->sapi, ll_xid_ind->n201_i); TRACE_EVENT_P3("l3_valid: %d, N201_I: %d, N201_U: %d", ll_xid_ind->xid_valid, ll_xid_ind->n201_i, ll_xid_ind->n201_i); /* * If SNDCP XID block is not valid, we are ready. */ if (ll_xid_ind->xid_valid == LL_XID_INVALID) { break; } /* * SNDCP XID block is valid and checked now. */ mg_decode_xid(&(ll_xid_ind->sdu), &(sndcp_data->mg.ind_xid_block[sapi_index]), &dec_ret, ll_xid_ind->sapi); if (dec_ret == MG_XID_OK) { mg_check_ind_xid(&check_ret, ll_xid_ind->sapi); if (check_ret == MG_XID_OK) { /* * Label MG_IND_OK */ USHORT res_sdu_bit_len = 0; UBYTE ntt = 0; BOOL v42_rej = FALSE; BOOL vj_rej = FALSE; USHORT sapi_state = MG_IDLE; mg_set_res_cur_xid_block(ll_xid_ind->sapi, &res_sdu_bit_len); /* * Add the extra space for ntts with nsapis == 0. */ for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { BOOL rej = FALSE; mg_get_sapi_dntt_rej(ll_xid_ind->sapi, ntt, &rej); if (rej) { /* * length of ntt octet and nsapis. */ res_sdu_bit_len += 32; v42_rej = TRUE; } mg_get_sapi_pntt_rej(ll_xid_ind->sapi, ntt, &rej); if (rej) { /* * length of ntt octet and nsapis. */ res_sdu_bit_len += 32; vj_rej = TRUE; } } if (! sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set && v42_rej) { /* * Add length of parameter type and length. */ res_sdu_bit_len += 16; } if (! sndcp_data->mg.ind_xid_block[sapi_index].vj.is_set && vj_rej) { /* * Add length of parameter type and length. */ res_sdu_bit_len += 16; } { PALLOC_SDU (ll_xid_res, LL_XID_RES, res_sdu_bit_len); /* * Set sapi in ll_xid_res. */ ll_xid_res->sapi = ll_xid_ind->sapi; /* * Write res_xid_block struct to sdu byte buffer. Implementation dep.. */ mg_set_res_xid_params(&ll_xid_res->sdu, ll_xid_ind->sapi); /* * Mark the affected nsapi and sapi as MG_XID_IDLE. */ sndcp_unset_sapi_state(ll_xid_ind->sapi, MG_XID); sndcp_unset_sapi_state(ll_xid_ind->sapi, MG_EST); /* * Send the XID block to LLC. */ #ifdef SNDCP_RANGE_CHECK if(ll_xid_res EQ NULL) { TRACE_EVENT("ERROR: ll_xid_res is NULL"); } else if(*((ULONG*)ll_xid_res - 7) NEQ 0) { TRACE_EVENT("ERROR in SNDCP: ll_xid_res is not allocated"); } #endif /* SNDCP_RANGE_CHECK */ PSEND(hCommLLC, ll_xid_res); } /* * Reset nsapis or ntts that were assigned, but are not any more. */ mg_clean_xid(ll_xid_ind->sapi); /* * If there was a collision and xid has not been negotiated * sufficiently. */ mg_resend_xid_if_nec(ll_xid_ind->sapi); /* * If activation or deactivation is pending, it will be responded if * no xid_req is pending. */ sndcp_get_sapi_state(ll_xid_ind->sapi, &sapi_state); if ((sapi_state & MG_XID) == 0) { mg_xid_cnf_ok_res(ll_xid_ind->sapi); } } else { /* * not (check_ret == MG_IND_XID_OK) */ /* * Label MG_CHECK_FAIL */ USHORT res_sdu_bit_len = 0; UBYTE ntt = 0; BOOL v42_rej = FALSE; BOOL vj_rej = FALSE; /* * Add the extra space for ntts with nsapis == 0. */ for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { BOOL rej = FALSE; mg_get_sapi_dntt_rej(ll_xid_ind->sapi, ntt, &rej); if (rej) { /* * length of ntt octet and nsapis. */ res_sdu_bit_len += 32; v42_rej = TRUE; } mg_get_sapi_pntt_rej(ll_xid_ind->sapi, ntt, &rej); if (rej) { /* * length of ntt octet and nsapis. */ res_sdu_bit_len += 32; vj_rej = TRUE; } } if (v42_rej) { /* * Add length of parameter type and length. */ res_sdu_bit_len += 16; } if (vj_rej) { /* * Add length of parameter type and length. */ res_sdu_bit_len += 16; } /* * Allocate response and send it. */ { PALLOC_SDU (ll_xid_res, LL_XID_RES, res_sdu_bit_len); /* * Reset res_xid_block, ind_xid_block. */ sndcp_reset_xid_block(&sndcp_data->mg.res_xid_block[sapi_index]); sndcp_reset_xid_block(&sndcp_data->mg.ind_xid_block[sapi_index]); /* * Set sapi in ll_xid_res. */ ll_xid_res->sapi = ll_xid_ind->sapi; /* * Write res_xid_block struct to sdu byte buffer. Implementation dep.. */ mg_set_res_xid_params(&ll_xid_res->sdu, ll_xid_res->sapi); /* * Modify the affected sapi state. */ sndcp_unset_sapi_state(ll_xid_ind->sapi, MG_XID); sndcp_unset_sapi_state(ll_xid_ind->sapi, MG_EST); /* * Send the XID block to LLC. */ #ifdef SNDCP_RANGE_CHECK if(ll_xid_res EQ NULL) { TRACE_EVENT("ERROR: ll_xid_res is NULL"); } else if(*((ULONG*)ll_xid_res - 7) NEQ 0) { TRACE_EVENT("ERROR in SNDCP: ll_xid_res is not allocated"); } #endif /* SNDCP_RANGE_CHECK */ PSEND(hCommLLC, ll_xid_res); } /* * If there was a collision and xid has not been negotiated * sufficiently. */ mg_resend_xid_if_nec(ll_xid_ind->sapi); /* * Reset nsapis or ntts that were assigned before * but are not anymore. */ mg_clean_xid(ll_xid_ind->sapi); /* * Allocate status req and send it (label MG_SEND_STATUS_REQ). */ { #ifdef SNDCP_UPM_INCLUDED PALLOC (snsm_status_req, SN_STATUS_IND); snsm_status_req->sapi = ll_xid_ind->sapi; snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp; snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_INVALID_XID; PSEND(hCommUPM, snsm_status_req); #else PALLOC (snsm_status_req, SNSM_STATUS_REQ); snsm_status_req->sapi = ll_xid_ind->sapi; snsm_status_req->status_cause = SNSM_RELCS_INVALID_XID; PSEND(hCommSM, snsm_status_req); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } } } else { /* not if (dec_ret == MG_XID_OK) */ /* * Reset nsapis or ntts that were assigned before * but are not anymore. */ sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]); mg_clean_xid(ll_xid_ind->sapi); /* * Decoding of LL_XID_IND failed (label MG_SEND_STATUS_REQ). * Allocate status req and send it. */ { #ifdef SNDCP_UPM_INCLUDED PALLOC (snsm_status_req, SN_STATUS_IND); snsm_status_req->sapi = ll_xid_ind->sapi; snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp; snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_INVALID_XID; PSEND(hCommUPM, snsm_status_req); #else PALLOC (snsm_status_req, SNSM_STATUS_REQ); snsm_status_req->sapi = ll_xid_ind->sapi; snsm_status_req->status_cause = SNSM_RELCS_INVALID_XID; PSEND(hCommSM, snsm_status_req); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } } break; default: TRACE_ERROR( "LL_XID_IND unexpected" ); break; } if (ll_xid_ind != NULL) { sndcp_reset_xid_block(&sndcp_data->mg.ind_xid_block[sapi_index]); PFREE(ll_xid_ind); } } /* mg_ll_xid_ind() */ /* +------------------------------------------------------------------------------ | Function : mg_snsm_activate_ind +------------------------------------------------------------------------------ | Description : Handles the primitive SNSM_ACTIVATE_IND | | Parameters : *snsm_activate_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ #ifdef SNDCP_UPM_INCLUDED GLOBAL void mg_snsm_activate_ind ( T_SN_ACTIVATE_REQ *snsm_activate_ind ) #else GLOBAL void mg_snsm_activate_ind ( T_SNSM_ACTIVATE_IND *snsm_activate_ind ) #endif /*#ifdef SNDCP_UPM_INCLUDED*/ { /* * is nsapi already used? */ BOOL used = FALSE; /* * is LLC mode specified (TRUE) or should the subscribed one be used * (FALSE) */ BOOL spec = FALSE; /* * should the context use acknowledged LLC operation mode? */ BOOL b = FALSE; TRACE_FUNCTION( "mg_snsm_activate_ind" ); #ifndef NCONFIG if (sndcp_data->millis > 0) { vsi_t_sleep(VSI_CALLER sndcp_data->millis); } #endif /* NCONFIG */ switch( GET_STATE( MG ) ) { case MG_DEFAULT: sndcp_is_nsapi_used(snsm_activate_ind->nsapi, &used); if (used == FALSE) { USHORT sapi_state = MG_IDLE; sndcp_set_nsapi_state(snsm_activate_ind->nsapi, MG_ACT); sndcp_reset_nd_nsapi_npdu_num(snsm_activate_ind->nsapi); sndcp_set_nsapi_used(snsm_activate_ind->nsapi, TRUE); sndcp_set_nsapi_qos(snsm_activate_ind->nsapi, snsm_activate_ind->snsm_qos); sndcp_set_nsapi_sapi(snsm_activate_ind->nsapi, snsm_activate_ind->sapi); sndcp_set_nsapi_prio(snsm_activate_ind->nsapi, snsm_activate_ind->radio_prio); #ifdef REL99 sndcp_set_nsapi_pktflowid(snsm_activate_ind->nsapi, snsm_activate_ind->pkt_flow_id); #endif /*REL 99*/ #if 0 #ifdef _SNDCP_DTI_2_ #ifndef SNDCP_UPM_INCLUDED if (snsm_activate_ind->dti_direction == DTI_CHANNEL_TO_LOWER_LAYER) { /* new constant instead of SNSM HOME , replaced by DTI_CHANNEL_TO_LOWER_LAYER */ sndcp_set_nsapi_direction(snsm_activate_ind->nsapi, DTI_CHANNEL_TO_LOWER_LAYER); } else { sndcp_set_nsapi_direction(snsm_activate_ind->nsapi, DTI_CHANNEL_TO_HIGHER_LAYER); } sndcp_set_nsapi_linkid(snsm_activate_ind->nsapi, snsm_activate_ind->dti_linkid); sndcp_set_nsapi_neighbor(snsm_activate_ind->nsapi, #ifdef _SIMULATION_ (snsm_activate_ind->dti_neighbor == 0xabcdabcd ? "PPP" : "NULL") #else /* _SIMULATION_ */ (U8*)snsm_activate_ind->dti_neighbor #endif /* _SIMULATION_ */ ); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ #else /*_SNDCP_DTI_2_*/ if (snsm_activate_ind->dti_direction == SNSM_HOME) { /* new constant instead of HOME, but the comiler switch! */ sndcp_set_nsapi_direction(snsm_activate_ind->nsapi, HOME); } else { sndcp_set_nsapi_direction(snsm_activate_ind->nsapi, NEIGHBOR); } sndcp_set_nsapi_linkid(snsm_activate_ind->nsapi, snsm_activate_ind->dti_linkid); sndcp_set_nsapi_neighbor(snsm_activate_ind->nsapi, #ifdef _SIMULATION_ (snsm_activate_ind->dti_neighbor == 0xabcdabcd ? "PPP" : "NULL") #else (U8*)snsm_activate_ind->dti_neighbor #endif /* _SIMULATION_ */ ); #endif /*_SNDCP_DTI_2_*/ #endif mg_is_ack(snsm_activate_ind->snsm_qos, &spec, &b); if (spec) { if (b) { /* * The NSAPI will use acknowledged LLC operation mode. */ BOOL ack = FALSE; USHORT local_sapi_state = MG_IDLE; BOOL comp_available = FALSE; /* * Is another compressor available? */ #ifdef SNDCP_UPM_INCLUDED mg_is_comp_available(snsm_activate_ind->sapi, TRUE, SNDCP_ACK, snsm_activate_ind->comp_params.msid, &comp_available); #else mg_is_comp_available(snsm_activate_ind->sapi, TRUE, SNDCP_ACK, snsm_activate_ind->msid, &comp_available); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ sndcp_set_nsapi_ack(snsm_activate_ind->nsapi, TRUE); /* * Is the affected SAPI already in ack mode or est_pending?? */ sndcp_get_sapi_ack(snsm_activate_ind->sapi, &ack); sndcp_get_sapi_state(snsm_activate_ind->sapi, &local_sapi_state); if ((((local_sapi_state & MG_EST) > 0) || ((local_sapi_state & MG_XID) > 0)) && comp_available) { sndcp_set_sapi_state(snsm_activate_ind->sapi, MG_XID_NEC); mg_set_new_xid_block(snsm_activate_ind); } else if (ack) { /* check if flow control is received before PDP activation */ mg_check_unset_nsapi_flow_ctrl_flag (snsm_activate_ind->nsapi,SNDCP_ACK); /* * If XID negotiation is not requested, respond * activation to SM, else send LL_XID_REQ. */ #ifdef SNDCP_UPM_INCLUDED if ((snsm_activate_ind->comp_params.dcomp == NAS_DCOMP_OFF && snsm_activate_ind->comp_params.hcomp == NAS_HCOMP_OFF) || ! comp_available) { #else if ((snsm_activate_ind->dcomp == SNSM_COMP_NEITHER_DIRECT && snsm_activate_ind->hcomp == SNSM_COMP_NEITHER_DIRECT) || ! comp_available) { #endif /*#ifdef SNDCP_UPM_INCLUDED*/ /* * If est_pending, the res is sent after est_cnf. */ /* * Reset service nu to acknowledged LLC mode. */ sig_mg_nu_reset_ack(snsm_activate_ind->nsapi, 0, 0, FALSE); /* * Open DTI connection. */ #ifndef SNDCP_UPM_INCLUDED mg_dti_open(snsm_activate_ind->nsapi); #else nu_ready_ind_if_nec(snsm_activate_ind->nsapi); #endif /* * */ sig_mg_sda_getdata(snsm_activate_ind->sapi, snsm_activate_ind->nsapi); /* * Send response */ mg_send_snsm_activate_res(snsm_activate_ind->nsapi); /* * unsetting the ACT-state */ sndcp_unset_nsapi_state(snsm_activate_ind->nsapi, MG_ACT); } else { /* if XID negotiation necessary */ USHORT punct_sapi_state = MG_IDLE; /* * Increment number of requested compressors. */ sndcp_data->vj_count++; /* * Set the N-PDU number in the affected nu instance to 0. */ sig_mg_nu_reset_ack(snsm_activate_ind->nsapi, 0, 0, TRUE); /* * Uplink data transfer on SAPI is completely suspended. */ sig_mg_su_suspend(snsm_activate_ind->sapi); sig_mg_sua_suspend(snsm_activate_ind->sapi); mg_suspend_affected_nus(snsm_activate_ind->sapi); /* * Send prim or store requested compression. */ sndcp_get_sapi_state(snsm_activate_ind->sapi, &punct_sapi_state); mg_send_xid_req(snsm_activate_ind); } /* if XID negotiation necessary */ } else { /* * Is XID negotiation necessary? */ #ifdef SNDCP_UPM_INCLUDED if ((snsm_activate_ind->comp_params.dcomp == NAS_DCOMP_OFF && snsm_activate_ind->comp_params.hcomp == NAS_HCOMP_OFF) || sndcp_data->vj_count == SNDCP_MAX_VJ_COUNT) #else if ((snsm_activate_ind->dcomp == SNSM_COMP_NEITHER_DIRECT && snsm_activate_ind->hcomp == SNSM_COMP_NEITHER_DIRECT) || sndcp_data->vj_count == SNDCP_MAX_VJ_COUNT) #endif /*#ifdef SNDCP_UPM_INCLUDED*/ { /* * Ack mode, sapi not yet established. * No XID requested. */ PALLOC_SDU(ll_establish_req, LL_ESTABLISH_REQ, 0); /* * Reset service nu to acknowledged LLC mode. */ sig_mg_nu_reset_ack(snsm_activate_ind->nsapi, 0, 0, TRUE); ll_establish_req->sapi = snsm_activate_ind->sapi; /* * Set the establishment states of sapi */ sndcp_set_sapi_state(snsm_activate_ind->sapi, MG_EST); /* * Uplink data transfer on SAPI is completely suspended. */ sig_mg_su_suspend(snsm_activate_ind->sapi); sig_mg_sua_suspend(snsm_activate_ind->sapi); mg_suspend_affected_nus(snsm_activate_ind->sapi); /* * Send prim to LLC. */ sndcp_set_nsapi_rec_state(snsm_activate_ind->nsapi, SDA_ESTABLISH_REQUESTED); #ifdef SNDCP_RANGE_CHECK if(ll_establish_req EQ NULL) { TRACE_EVENT("ERROR: ll_establish_req is NULL"); } else if(*((ULONG*)ll_establish_req - 7) NEQ 0) { TRACE_EVENT ("ERROR in SNDCP: ll_establish_req is not allocated"); } #endif /* SNDCP_RANGE_CHECK */ PSEND(hCommLLC, ll_establish_req); } else { UBYTE sapi_index = 0; /* * Ack mode, sapi not yet established. * XID requested. */ PALLOC_SDU(ll_establish_req, LL_ESTABLISH_REQ, SNDCP_XID_BLOCK_BIT_LEN); /* * Increment number of requested compressors. */ sndcp_data->vj_count++; sndcp_get_sapi_index(snsm_activate_ind->sapi, &sapi_index); /* * Reset service nu to acknowledged LLC mode. */ sig_mg_nu_reset_ack(snsm_activate_ind->nsapi, 0, 0, TRUE); ll_establish_req->sapi = snsm_activate_ind->sapi; /* * Write data from snsm_activate_ind to service variable req_xid_block. */ mg_set_req_xid_block(snsm_activate_ind); /* * Fill the XID block. Implementation dependent!!! */ mg_set_xid_params(ll_establish_req->sapi, &ll_establish_req->sdu, sndcp_data->mg.req_xid_block[sapi_index]); /* * Set the establishment states of sapi */ sndcp_set_sapi_state(snsm_activate_ind->sapi, MG_EST); /* * Uplink data transfer on SAPI is completely suspended. */ sig_mg_su_suspend(snsm_activate_ind->sapi); sig_mg_sua_suspend(snsm_activate_ind->sapi); mg_suspend_affected_nus(snsm_activate_ind->sapi); /* * Send prim to LLC. */ sndcp_set_nsapi_rec_state(snsm_activate_ind->nsapi, SDA_ESTABLISH_REQUESTED); #ifdef SNDCP_RANGE_CHECK if(ll_establish_req EQ NULL) { TRACE_EVENT("ERROR: ll_establish_req is NULL"); } else if(*((ULONG*)ll_establish_req - 7) NEQ 0) { TRACE_EVENT ("ERROR in SNDCP: ll_establish_req is not allocated"); } #endif /* SNDCP_RANGE_CHECK */ PSEND(hCommLLC, ll_establish_req); } } } else { /* * The NSAPI will not use acknowledged LLC operation mode. */ /* * Is XID negotiation necessary? */ /* check if flow control is received before PDP activation */ mg_check_unset_nsapi_flow_ctrl_flag (snsm_activate_ind->nsapi,SNDCP_UNACK); #ifdef TI_PS_FF_V42BIS #ifdef SNDCP_UPM_INCLUDED if ((snsm_activate_ind->comp_params.hcomp == NAS_HCOMP_NEITHER_DIRECT || sndcp_data->vj_count >= SNDCP_MAX_VJ_COUNT) && snsm_activate_ind->comp_params.dcomp == NAS_HCOMP_NEITHER_DIRECT) #else if ((snsm_activate_ind->hcomp == SNSM_COMP_NEITHER_DIRECT || sndcp_data->vj_count >= SNDCP_MAX_VJ_COUNT) && snsm_activate_ind->dcomp == SNSM_COMP_NEITHER_DIRECT) #endif /*#ifdef SNDCP_UPM_INCLUDED*/ #else /* !TI_PS_FF_V42BIS */ #ifdef SNDCP_UPM_INCLUDED if (snsm_activate_ind->comp_params.hcomp == NAS_HCOMP_OFF || sndcp_data->vj_count == SNDCP_MAX_VJ_COUNT) #else if (snsm_activate_ind->hcomp == SNSM_COMP_NEITHER_DIRECT || sndcp_data->vj_count == SNDCP_MAX_VJ_COUNT) #endif /*#ifdef SNDCP_UPM_INCLUDED*/ #endif /* TI_PS_FF_V42BIS */ { /* * No XID negotiation necessary. * BUT LLC needs trigger to send LLC XID request to network. * If LL_ESTABLISH_REQ or LL_XID_REQ is pending, no LL_XID_REQ * is needed here. * If LL_RELEASE_REQ is pending, XID must have been negotiated, * so it is not necessary. */ USHORT local_sapi_state = MG_IDLE; sndcp_get_sapi_state(snsm_activate_ind->sapi, &local_sapi_state); if (sndcp_data->always_xid && (local_sapi_state & MG_EST) == 0 && (local_sapi_state & MG_REL) == 0 && (local_sapi_state & MG_XID) == 0 ) { /* * XID negotiation is not necessary, but done for LLC. */ /* * Set the N-PDU number in the affected nu instance to 0. */ sig_mg_nu_reset(snsm_activate_ind->nsapi, TRUE); /* * Uplink data transfer on SAPI is completely suspended. */ sig_mg_su_suspend(snsm_activate_ind->sapi); sig_mg_sua_suspend(snsm_activate_ind->sapi); mg_suspend_affected_nus(snsm_activate_ind->sapi); /* * Send prim. */ mg_send_empty_xid_req(snsm_activate_ind); } else { /* * No XID negotiation necessary. */ /* * LLC may send data now */ sig_mg_sd_getunitdata(snsm_activate_ind->sapi, snsm_activate_ind->nsapi); /* * Open DTI connection. */ #ifndef SNDCP_UPM_INCLUDED mg_dti_open(snsm_activate_ind->nsapi); #else nu_unitready_ind_if_nec(snsm_activate_ind->nsapi); #endif /* * Set the N-PDU number in the affected nu instance to 0. */ sig_mg_nu_reset(snsm_activate_ind->nsapi, FALSE); mg_send_snsm_activate_res(snsm_activate_ind->nsapi); /* * The response is now sent, state flag can be unset. */ sndcp_unset_nsapi_state(snsm_activate_ind->nsapi, MG_ACT); } } else { #ifdef SNDCP_UPM_INCLUDED if (snsm_activate_ind->comp_params.hcomp > NAS_HCOMP_OFF) { #else if (snsm_activate_ind->hcomp > SNSM_COMP_NEITHER_DIRECT) { #endif /*#ifdef SNDCP_UPM_INCLUDED*/ /* * Increment number of requested compressors. */ sndcp_data->vj_count++; } /* * XID negotiation is necessary. */ /* * Set the N-PDU number in the affected nu instance to 0. */ sndcp_get_sapi_state(snsm_activate_ind->sapi, &sapi_state); sig_mg_nu_reset(snsm_activate_ind->nsapi, TRUE); if (((sapi_state & MG_XID) == 0) && ((sapi_state & MG_EST) == 0)) { /* * Uplink data transfer on SAPI is completely suspended. */ sig_mg_su_suspend(snsm_activate_ind->sapi); sig_mg_sua_suspend(snsm_activate_ind->sapi); mg_suspend_affected_nus(snsm_activate_ind->sapi); /* * Send prim. */ mg_send_xid_req(snsm_activate_ind); } else { mg_set_new_xid_block(snsm_activate_ind); sndcp_set_sapi_state(snsm_activate_ind->sapi, MG_XID_NEC); } } /* else from if negotiation necessary */ } /* else from if (b) { */ } /* if (spec) { */ if ( sndcp_data->tcp_flow) { TRACE_EVENT("sndcp_data.tcp_flow --- DATA FLOW PRIMITIVE "); TRACE_EVENT_P1("nsapi value %d", snsm_activate_ind->nsapi); nd_dti_buffer_ready(snsm_activate_ind->nsapi); } } /* if (used == FALSE) { */ break; default: TRACE_ERROR( "SNSM_ACTIVATE_IND unexpected" ); break; } if (snsm_activate_ind != NULL) { PFREE(snsm_activate_ind); } } /* mg_snsm_activate_ind() */ /* +------------------------------------------------------------------------------ | Function : mg_snsm_deactivate_ind +------------------------------------------------------------------------------ | Description : Handles the primitive SNSM_DEACTIVATE_IND | | Parameters : *snsm_deactivate_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ #ifdef SNDCP_UPM_INCLUDED GLOBAL void mg_snsm_deactivate_ind ( T_SN_DEACTIVATE_REQ *snsm_deactivate_ind ) #else GLOBAL void mg_snsm_deactivate_ind ( T_SNSM_DEACTIVATE_IND *snsm_deactivate_ind ) #endif /*#ifdef SNDCP_UPM_INCLUDED*/ { UBYTE nsapi = 0; BOOL nec = FALSE; TRACE_FUNCTION( "mg_snsm_deactivate_ind" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) { #ifdef SNDCP_UPM_INCLUDED if (snsm_deactivate_ind->nsapi == nsapi) { #else if (snsm_deactivate_ind->nsapi_set & (0x001 << nsapi)) { #endif USHORT sapi_state = 0; BOOL ack = FALSE; BOOL used = FALSE; UBYTE sapi = 0; /* * Delete information about requested compressors. */ sndcp_reset_xid_block(&sndcp_data->mg.user_xid_block[nsapi]); /* * If nsapi is not used, send response anyway to avoid block. */ sndcp_is_nsapi_used(nsapi, &used); if (!used) { #ifdef SNDCP_UPM_INCLUDED PALLOC(snsm_deactivate_res, SN_DEACTIVATE_CNF); snsm_deactivate_res->nsapi = nsapi; #else PALLOC(snsm_deactivate_res, SNSM_DEACTIVATE_RES); snsm_deactivate_res->nsapi = nsapi; #endif /*#ifdef SNDCP_UPM_INCLUDED*/ /* * Set the "state" of the nsapi. */ sndcp_unset_nsapi_state(nsapi, MG_DEACT); #ifdef SNDCP_UPM_INCLUDED PSEND(hCommUPM, snsm_deactivate_res); #else /*#ifdef SNDCP_UPM_INCLUDED*/ PSEND(hCommSM, snsm_deactivate_res); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ continue; } /* * Close affected DTI connection. */ #ifdef _SNDCP_DTI_2_ /* FIX for entity test TC TC 321 and TC 327 and TC 262a*/ sndcp_data->nu = & sndcp_data->nu_base[nsapi]; /* End FIX */ #endif /* _SNDCP_DTI_2_ */ #ifndef SNDCP_UPM_INCLUDED mg_dti_close(nsapi); #else /* * This part is required for EDGE to get next line out of if * statement. */ {} #endif sndcp_set_nsapi_state(nsapi, MG_DEACT); sndcp_unset_nsapi_state(nsapi, MG_ACT); sndcp_get_nsapi_ack(nsapi, &ack); sndcp_get_nsapi_sapi(nsapi, &sapi); if (ack) { mg_rel_nsapi_nec(nsapi); } sndcp_get_sapi_state(sapi, &sapi_state); mg_delete_npdus(nsapi); sndcp_data->nu_base[nsapi].sn_unitready_ind_pending = FALSE; sndcp_data->nu_base[nsapi].sn_ready_ind_pending = FALSE; /* * is compressor deactivation necessary? */ mg_is_rel_comp_nec(nsapi, &nec); #ifdef SNDCP_UPM_INCLUDED if ((snsm_deactivate_ind->rel_ind == PS_REL_IND_YES) && ((sapi_state & (MG_REL + MG_REL_NEC_LOC + MG_REL_NEC_PEER)) == 0) ) { #else if ((snsm_deactivate_ind->rel_ind == REL_IND_YES) && ((sapi_state & (MG_REL + MG_REL_NEC_LOC + MG_REL_NEC_PEER)) == 0) ) { #endif /*#ifdef SNDCP_UPM_INCLUDED*/ /* * Local deactivation. No LL_XID_REQ will be sent (because rel_ind * is REL_IND_YES). * No release is pending or needed. */ #ifdef SNDCP_UPM_INCLUDED PALLOC(snsm_deactivate_res, SN_DEACTIVATE_CNF); snsm_deactivate_res->nsapi = nsapi; #else PALLOC(snsm_deactivate_res, SNSM_DEACTIVATE_RES); snsm_deactivate_res->nsapi = nsapi; #endif /*#ifdef SNDCP_UPM_INCLUDED*/ /* * Now the NSAPI is not in use anymore: */ sndcp_set_nsapi_used(nsapi, FALSE); sndcp_set_nsapi_ack(nsapi, FALSE); /* * Set the "state" of the nsapi. */ sndcp_unset_nsapi_state(nsapi, MG_DEACT); /* * Reset xid blocks. */ mg_reset_compressors(nsapi); #ifdef SNDCP_UPM_INCLUDED PSEND(hCommUPM, snsm_deactivate_res); #else PSEND(hCommSM, snsm_deactivate_res); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } else if ((sapi_state & (MG_REL + MG_REL_NEC_LOC + MG_REL_NEC_PEER)) == 0 ) { /* * No release is pending. * If no compressor has to be released: respond to SM. */ if (nec) { /* * If xid req is sent, suspend uplink transfer for affected sapi. */ sig_mg_su_suspend(sapi); sig_mg_sua_suspend(sapi); mg_suspend_affected_nus(sapi); /* * Negotiate possible deactivation of compressors. */ mg_send_xid_req_del(sapi); } else { /* if (nec) */ sndcp_get_sapi_state(sapi, &sapi_state); if ((sapi_state & MG_XID_NEC) == 0) { /* * No compressor negotiated, no release sent. */ #ifdef SNDCP_UPM_INCLUDED PALLOC(snsm_deactivate_res, SN_DEACTIVATE_CNF); snsm_deactivate_res->nsapi = nsapi; #else PALLOC(snsm_deactivate_res, SNSM_DEACTIVATE_RES); snsm_deactivate_res->nsapi = nsapi; #endif /*#ifdef SNDCP_UPM_INCLUDED*/ /* * Now the NSAPI is not in use anymore: */ sndcp_set_nsapi_used(nsapi, FALSE); sndcp_set_nsapi_ack(nsapi, FALSE); /* * Set the "state" of the nsapi. */ sndcp_unset_nsapi_state(nsapi, MG_DEACT); #ifdef SNDCP_UPM_INCLUDED PSEND(hCommUPM, snsm_deactivate_res); #else /*#ifdef SNDCP_UPM_INCLUDED*/ PSEND(hCommSM, snsm_deactivate_res); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ } } /* if (nec) */ } else {/* if ((state & (MG_REL + ....)) == 0) */ /* * LL_RELEASE_REQ is pending. After reception of LL_RELEASE_REQ, * if XID negotiatio is necessary, LL_XID_REQ will be sent. */ if (nec) { sndcp_set_sapi_state(sapi, MG_XID_NEC); } } } } break; default: TRACE_ERROR( "SNSM_DEACTIVATE_IND unexpected" ); break; } if (snsm_deactivate_ind != NULL) { PFREE(snsm_deactivate_ind); } } /* mg_snsm_deactivate_ind() */ /* +------------------------------------------------------------------------------ | Function : mg_snsm_sequence_ind +------------------------------------------------------------------------------ | Description : Handles the primitive SNSM_SEQUENCE_IND | | Parameters : *snsm_sequence_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ #ifdef SNDCP_UPM_INCLUDED GLOBAL void mg_snsm_sequence_ind ( T_SN_SEQUENCE_REQ *snsm_sequence_ind ) #else GLOBAL void mg_snsm_sequence_ind ( T_SNSM_SEQUENCE_IND *snsm_sequence_ind ) #endif /*#ifdef SNDCP_UPM_INCLUDED*/ { #ifdef SNDCP_UPM_INCLUDED int i = 0; U8 nsapi,rec_no,npdu_number; #endif TRACE_FUNCTION( "mg_snsm_sequence_ind" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: { #ifdef SNDCP_UPM_INCLUDED PALLOC(snsm_sequence_res, SN_SEQUENCE_CNF); for (i = 0; i < snsm_sequence_ind->c_receive_no_list; i++) { nsapi = snsm_sequence_ind->receive_no_list[i].nsapi; rec_no = snsm_sequence_ind->receive_no_list[i].receive_no; sndcp_unset_nsapi_state(nsapi, MG_SEQ); sig_mg_nu_delete_to(nsapi, rec_no); npdu_number = sig_mg_nd_get_rec_no(nsapi); snsm_sequence_res->receive_no_list[i].nsapi = nsapi; snsm_sequence_res->receive_no_list[i].receive_no = npdu_number; } snsm_sequence_res->c_receive_no_list = i; PSEND(hCommUPM, snsm_sequence_res); #else TRACE_EVENT_P1( "SEQ_IND rec_no: %d", snsm_sequence_ind->rec_no); sndcp_unset_nsapi_state(snsm_sequence_ind->nsapi, MG_SEQ); sig_mg_nu_delete_to(snsm_sequence_ind->nsapi, snsm_sequence_ind->rec_no); sig_mg_nd_get_rec_no(snsm_sequence_ind->nsapi); #endif /*#ifdef SNDCP_UPM_INCLUDED*/ break; } default: TRACE_ERROR( "SNSM_SEQUENCE_IND unexpected" ); break; } if (snsm_sequence_ind != NULL) { PFREE (snsm_sequence_ind); } } /* mg_snsm_sequence_ind() */ /* +------------------------------------------------------------------------------ | Function : mg_snsm_modify_ind +------------------------------------------------------------------------------ | Description : Handles the primitive SNSM_MODIFY_IND | | Parameters : *snsm_modify_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ #ifdef SNDCP_UPM_INCLUDED GLOBAL void mg_snsm_modify_ind ( T_SN_MODIFY_REQ *snsm_modify_ind ) #else GLOBAL void mg_snsm_modify_ind ( T_SNSM_MODIFY_IND *snsm_modify_ind ) #endif /*#ifdef SNDCP_UPM_INCLUDED*/ { /* * LLC mode specified? */ BOOL spec = FALSE; /* * LLC mode acknowledged? */ BOOL b = FALSE; BOOL nsapi_used = FALSE; BOOL old_nsapi_ack = FALSE; UBYTE old_sapi = 0; TRACE_FUNCTION( "mg_snsm_modify_ind" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: /* * If no release/establish will be done, SNSM_MODIFY_RES is expected now. */ sndcp_data->mg.mod_expects = MG_MOD_X_READY; /* * Is NSAPI already used? */ sndcp_is_nsapi_used(snsm_modify_ind->nsapi, &nsapi_used); if (! nsapi_used) { mg_mod_nsapi_new(snsm_modify_ind); } /* * Is LLC operation mode changing from unack to ack? */ mg_is_ack(snsm_modify_ind->snsm_qos, &spec, &b); sndcp_get_nsapi_ack(snsm_modify_ind->nsapi, &old_nsapi_ack); if (spec && b && ! old_nsapi_ack) { mg_mod_unack_ack(snsm_modify_ind); } /* * Is LLC operation mode changing from ack to unack? */ if (spec && ! b && old_nsapi_ack) { mg_mod_ack_unack(snsm_modify_ind); } /* * Is new sapi different from old one? */ sndcp_get_nsapi_sapi(snsm_modify_ind->nsapi, &old_sapi); if (old_sapi != snsm_modify_ind->sapi) { mg_mod_sapi_diff(snsm_modify_ind); } /* * Add nsapi to waiting_nsapis */ sndcp_data->mg.waiting_nsapis |= (1 << (snsm_modify_ind->nsapi)); /* * The following will be done in any case: */ sndcp_set_nsapi_qos(snsm_modify_ind->nsapi, snsm_modify_ind->snsm_qos); sndcp_set_nsapi_prio(snsm_modify_ind->nsapi, snsm_modify_ind->radio_prio); #ifdef REL99 sndcp_set_nsapi_pktflowid(snsm_modify_ind->nsapi, snsm_modify_ind->pkt_flow_id); #endif /*REL99*/ /* * If no establish/release is expected, send res now. */ mg_mod_res_if_nec(); break; default: TRACE_ERROR( "SNSM_MODIFY_IND unexpected" ); break; } if (snsm_modify_ind != NULL) { PFREE(snsm_modify_ind); } } /* mg_snsm_modify_ind() */ #ifndef SNDCP_UPM_INCLUDED /* +------------------------------------------------------------------------------ | Function : mg_sn_switch_req +------------------------------------------------------------------------------ | Description : Handles the primitive SN_SWITCH_REQ | | Parameters : *snswitch_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_sn_switch_req ( T_SN_SWITCH_REQ *sn_switch_req ) { #ifdef _SNDCP_DTI_2_ UBYTE* neighbor = NULL; #endif /* _SNDCP_DTI_2_ */ TRACE_FUNCTION( "mg_sn_switch_req" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: sndcp_set_nsapi_linkid(sn_switch_req->nsapi, sn_switch_req->dti_linkid); #ifdef _SNDCP_DTI_2_ sndcp_get_nsapi_neighbor(sn_switch_req->nsapi, &neighbor); #endif /* _SNDCP_DTI_2_ */ #ifdef _SIMULATION_ sndcp_set_nsapi_neighbor(sn_switch_req->nsapi, (sn_switch_req->dti_neighbor == 0xabcdabcd ? "PPP" : "NULL")); #else /*_SIMULATION_ */ sndcp_set_nsapi_neighbor(sn_switch_req->nsapi, (UBYTE*)sn_switch_req->dti_neighbor); #endif /* _SIMULATION_ */ /* * Map sn constants to dti constants. */ if (sn_switch_req->dti_direction == SN_HOME) { sndcp_set_nsapi_direction(sn_switch_req->nsapi, HOME); } else { sndcp_set_nsapi_direction(sn_switch_req->nsapi, NEIGHBOR); } #ifdef _SIMULATION_ #ifdef _SNDCP_DTI_2_ /* FIX for entity test TC 1205*/ sndcp_data->nu = & sndcp_data->nu_base[sn_switch_req->nsapi]; if ((sndcp_data->nu->connection_is_opened == TRUE) || ((neighbor != NULL) && !(strcmp(neighbor,"NULL")))) /* End FIX */ #endif /* _SNDCP_DTI_2_ */ #endif /* _SIMULATION_ */ #ifndef SNDCP_UPM_INCLUDED mg_dti_close(sn_switch_req->nsapi); #endif sndcp_data->nu->sn_switch_cnf_expected = TRUE; #ifndef SNDCP_UPM_INCLUDED mg_dti_open(sn_switch_req->nsapi); #endif break; default: TRACE_ERROR( "SN_SWITCH_REQ unexpected" ); break; } PFREE(sn_switch_req); } /* mg_sn_switch_req() */ #endif /*SNDCP_UPM_INCLUDED*/ #ifdef SNDCP_UPM_INCLUDED /* +------------------------------------------------------------------------------ | Function : mg_sn_dti_req +------------------------------------------------------------------------------ | Description : Handles the primitive SN_DTI_REQ | | Parameters : *sn_dti_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_sn_dti_req ( T_SN_DTI_REQ *sn_dti_req ) { UBYTE* neighbor = NULL; /* * is nsapi already used? */ /* BOOL used = FALSE;*/ BOOL ack = FALSE; TRACE_FUNCTION( "mg_sn_dti_req" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: sndcp_set_nsapi_linkid(sn_dti_req->nsapi, sn_dti_req->dti_linkid); TRACE_EVENT_P1("sn_dti_req->nsapi: %d", sn_dti_req->nsapi); if (sn_dti_req->dti_conn == NAS_CONNECT_DTI) { sndcp_get_nsapi_neighbor(sn_dti_req->nsapi, &neighbor); sndcp_data->nsapi = sn_dti_req->nsapi; #ifdef SNDCP_2to1 sndcp_set_nsapi_neighbor(sn_dti_req->nsapi, (U8*)sn_dti_req->dti_neighbor.name); #else /*SNDCP_2to1*/ #ifdef _SIMULATION_ sndcp_set_nsapi_neighbor(sn_dti_req->nsapi, (sn_dti_req->dti_neighbor == 0xabcdabcd ? "PPP" : "NULL")); #else /*_SIMULATION_ */ sndcp_set_nsapi_neighbor(sn_dti_req->nsapi, (U8*)sn_dti_req->dti_neighbor); #endif /* _SIMULATION_ */ #endif /*SNDCP_2to1*/ /* * Map sn constants to dti constants. * The compiler switch is required because the dti_direction * C-Macros have different values in old and new worlds. */ #ifdef SNDCP_UPM_INCLUDED if (sn_dti_req->dti_direction == NAS_HOME) { sndcp_set_nsapi_direction(sn_dti_req->nsapi, DTI_CHANNEL_TO_LOWER_LAYER); } else { sndcp_set_nsapi_direction(sn_dti_req->nsapi, DTI_CHANNEL_TO_HIGHER_LAYER); } #else /*SNDCP_UPM_INCLUDED*/ if (sn_dti_req->dti_direction == DTI_CHANNEL_TO_LOWER_LAYER) { sndcp_set_nsapi_direction(sn_dti_req->nsapi, DTI_CHANNEL_TO_LOWER_LAYER); } else { sndcp_set_nsapi_direction(sn_dti_req->nsapi, DTI_CHANNEL_TO_HIGHER_LAYER); } #endif sndcp_set_nsapi_linkid(sn_dti_req->nsapi, sn_dti_req->dti_linkid); if (sn_dti_req->dti_neighbor NEQ (ULONG)TCPIP_NAME) { mg_dti_open(sn_dti_req->nsapi); } #ifdef SNDCP_UPM_INCLUDED sndcp_get_nsapi_ack(sn_dti_req->nsapi, &ack); if (ack) { UBYTE sapi = 0; USHORT stat = MG_IDLE; sndcp_get_nsapi_sapi(sn_dti_req->nsapi, &sapi); sndcp_get_sapi_state(sapi, &stat); /* * Do not call nu_ready_ind_if_nec() if establish * is ongoing. */ if ((stat & MG_EST) == 0) { nu_ready_ind_if_nec(sn_dti_req->nsapi); } } else { nu_unitready_ind_if_nec(sn_dti_req->nsapi); } #endif } else { /* if (sn_dti_req->dti_conn == SNDCP_CONNECT_DTI) */ /* check if flow control is received before PDP activation */ mg_check_unset_nsapi_flow_ctrl_flag (sn_dti_req->nsapi,MG_MOD_X_NONE); mg_dti_close(sn_dti_req->nsapi); } /* if (sn_dti_req->dti_conn == SNDCP_CONNECT_DTI) */ break; default: TRACE_ERROR( "SN_DTI_REQ unexpected" ); break; } PFREE(sn_dti_req); } /* mg_sn_dti_req() */ #endif /* SNDCP_UPM_INCLUDED */ #ifdef TI_DUAL_MODE /* +------------------------------------------------------------------------------ | Function : mg_get_pending_pdu_req +------------------------------------------------------------------------------ | Description : Handles the primitive SN_GET_PENDING_PDU_REQ | | Parameters : *sn_get_pending_pdu_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void mg_get_pending_pdu_req (T_SN_GET_PENDING_PDU_REQ *sn_get_pending_pdu_req) { U8 nsapi = 0; BOOL ack = FALSE, used = FALSE; TRACE_FUNCTION( "mg_get_pending_pdu_req" ); switch( GET_STATE( MG ) ) { case MG_DEFAULT: { PALLOC(sn_get_pending_pdu_cnf, SN_GET_PENDING_PDU_CNF); #ifdef _SIMULATION_ PALLOC(sn_test_get_pending_pdu_cnf, SN_TEST_GET_PENDING_PDU_CNF); #endif memset(sn_get_pending_pdu_cnf->ul_pdus,0, sizeof(T_SN_ul_pdus)); for (nsapi = 0; nsapi < SN_SIZE_NSAPI; nsapi++) { sn_get_pending_pdu_cnf->ul_pdus[nsapi].c_desc_list2 = 0; sn_get_pending_pdu_cnf->ul_pdus[nsapi].nsapi = 0; sn_get_pending_pdu_cnf->ul_pdus[nsapi].dl_sequence_number = 0; sndcp_is_nsapi_used(nsapi, &used); if (used) { sndcp_get_nsapi_ack(nsapi, &ack); if (ack) {/*acknowledged context*/ sn_get_pending_pdu_cnf = mg_get_unsent_unconfirmed_npdus(nsapi, sn_get_pending_pdu_cnf); mg_clean_ack_npdu_queues_leave_data(nsapi); } else {/*unacknowledged context*/ mg_clean_unack_npdu_queues_including_data(nsapi); } } } sn_get_pending_pdu_cnf->c_ul_pdus=SN_SIZE_NSAPI; #ifdef _SIMULATION_ sm_make_test_pending_pdu_cnf(sn_get_pending_pdu_cnf, sn_test_get_pending_pdu_cnf); PSEND(hCommUPM, sn_test_get_pending_pdu_cnf); #else PSEND(hCommUPM, sn_get_pending_pdu_cnf); #endif break; } default: TRACE_ERROR( "SN_GET_PENDING_PDU_REQ unexpected" ); break; } if (sn_get_pending_pdu_req != NULL) { PFREE (sn_get_pending_pdu_req); } } #endif /*TI_DUAL_MODE*/