FreeCalypso > hg > fc-magnetite
view src/g23m-gprs/sndcp/sndcp_mgp.c @ 624:012028896cfb
FFS dev.c, Leonardo target: Fujitsu MB84VF5F5F4J2 #if 0'ed out
The FFS code we got from TI/Openmoko had a stanza for "Fujitsu MB84VF5F5F4J2
stacked device", using a fake device ID code that would need to be patched
manually into cfgffs.c (suppressing and overriding autodetection) and using
an FFS base address in the nCS2 bank, indicating that this FFS config was
probably meant for the MCP version of Leonardo which allows for 16 MiB flash
with a second bank on nCS2.
We previously had this FFS config stanza conditionalized under
CONFIG_TARGET_LEONARDO because the base address contained therein is invalid
for other targets, but now that we actually have a Leonardo build target in
FC Magnetite, I realize that the better approach is to #if 0 out this stanza
altogether: it is already non-functional because it uses a fake device ID
code, thus it is does not add support for more Leonardo board variants,
instead it is just noise.
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 22 Dec 2019 21:24:29 +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*/