FreeCalypso > hg > fc-magnetite
view src/g23m-gprs/sndcp/sndcp_nuf.c @ 632:d968a3216ba0
new tangomdm build target
TCS211/Magnetite built for target leonardo runs just fine on the Tango-based
Caramel board, but a more proper tangomdm build target is preferable in order
to better market these Tango modems to prospective commercial customers. The
only differences are in GPIO and MCSI config:
* MCSI is enabled in the tangomdm build config.
* GPIO 1 is loudspeaker amplifier control on Leonardo, but on Tango platforms
it can be used for anything. On Caramel boards this GPIO should be
configured as an output driving high.
* GPIO 2 needs to be configured as Calypso input on Leonardo, but on Tango
platforms it can be used for anything. On Caramel boards this GPIO should be
configured as an output, either high or low is OK.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sat, 04 Jan 2020 19:27:41 +0000 |
parents | 219afcfc6250 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GPRS (8441) | Modul : sndcp_nuf.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 | procedures and functions as described in the | SDL-documentation (NU-statemachine) +----------------------------------------------------------------------------- */ /*---- HISTORY --------------------------------------------------------------*/ #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" #include "sndcp.h" /* to get the global entity definitions */ #include "sndcp_f.h" /* to get the functions to access the global arrays*/ #ifndef NCONFIG #include "sndcp_nuf.h" #include "sndcp_suas.h" #include "sndcp_sus.h" #endif /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ LOCAL void nu_delete (T_NPDU_BUFFER* npdu_buffer); /* +------------------------------------------------------------------------------ | Function : nu_delete +------------------------------------------------------------------------------ | Description : The function nu_delete() deletes one buffered N-PDU. | It is used to delete one N-PDU in form of an SN_DATA_REQ | pointer. | It will be useful when one N-PDU is deleted in case of | LL_DATA_CNF orwhen every N-PDU for one NSAPI is deleted in case | of SIG_MG_DELETE_NPDUS. | First every descriptor in the SN_DATA_REQ is deleted, then the | primitive is deleted, then the T_NPDU_BUFFER* is deleted. (This | type is only specified in the code.) | Parameter : the one N-PDU to be deleted. | +------------------------------------------------------------------------------ */ LOCAL void nu_delete (T_NPDU_BUFFER* npdu_buffer) { TRACE_FUNCTION( "nu_delete" ); if (npdu_buffer == NULL) { return; } /* * Free the SN_DATA_REQ. */ #ifdef _SNDCP_DTI_2_ if (npdu_buffer->sn_data_req != NULL) { MFREE_PRIM(npdu_buffer->sn_data_req); npdu_buffer->sn_data_req = NULL; } #else /*_SNDCP_DTI_2_*/ if (npdu_buffer->sn_data_req != NULL) { PFREE_DESC(npdu_buffer->sn_data_req); npdu_buffer->sn_data_req = NULL; } #endif /*_SNDCP_DTI_2_*/ /* * If this was the next to send in recovery state, move to next now. */ if (npdu_buffer == sndcp_data->nu->next_resend) { sndcp_data->nu->next_resend = npdu_buffer->next; } if (npdu_buffer == sndcp_data->nu->first_buffered_npdu) { sndcp_data->nu->first_buffered_npdu = npdu_buffer->next; } /* * Free the T_NPDU_BUFFER */ MFREE(npdu_buffer); npdu_buffer = NULL; } /* nu_delete() */ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : nu_buffer_npdu +------------------------------------------------------------------------------ | Description : The function nu_buffer_npdu() buffers the given SN_DATA_REQ | together with the given N-PDU number. | | Parameters : N-PDU number, SN_DATA_REQ primitive. | +------------------------------------------------------------------------------ */ GLOBAL void nu_buffer_npdu (UBYTE npdu_number, T_SN_DATA_REQ* sn_data_req) { T_NPDU_BUFFER* npdu_buffer = 0; TRACE_FUNCTION( "nu_buffer_npdu" ); /* * Allocate the T_NPDU_BUFFER struct for */ MALLOC(npdu_buffer, sizeof(T_NPDU_BUFFER)); /* * Insert the given values. */ npdu_buffer->npdu_number = npdu_number; npdu_buffer->sn_data_req = sn_data_req; npdu_buffer->next = NULL; if (sndcp_data->nu->first_buffered_npdu == NULL) { sndcp_data->nu->first_buffered_npdu = npdu_buffer; sndcp_data->nu->next_resend = npdu_buffer; } else { T_NPDU_BUFFER* help = sndcp_data->nu->first_buffered_npdu; if (help->next == NULL) { help->next = npdu_buffer; } else { while (help->next != NULL) { help = help->next; } help->next = npdu_buffer; } } } /* nu_buffer_npdu() */ #ifndef NCONFIG /* +------------------------------------------------------------------------------ | Function : nu_config_discard +------------------------------------------------------------------------------ | Description : reaction to config prim | | Parameters : nsapi | +------------------------------------------------------------------------------ */ GLOBAL void nu_config_discard (UBYTE nsapi) { TRACE_FUNCTION( "nu_config_discard" ); sndcp_data->nu = &sndcp_data->nu_base[nsapi]; sndcp_data->nu->discard = TRUE; } /* +------------------------------------------------------------------------------ | Function : nu_config_resume +------------------------------------------------------------------------------ | Description : reaction to config prim | | Parameters : nsapi | +------------------------------------------------------------------------------ */ GLOBAL void nu_config_resume (UBYTE nsapi) { TRACE_FUNCTION( "nu_config_resume" ); sndcp_data->nu = &sndcp_data->nu_base[nsapi]; sndcp_data->nu->discard = FALSE; } /* +------------------------------------------------------------------------------ | Function : nu_config_send +------------------------------------------------------------------------------ | Description : reaction to config prim | | Parameters : nsapi, number of octets | +------------------------------------------------------------------------------ */ GLOBAL void nu_config_send (UBYTE nsapi, U32 octets) { U32 *data_count = NULL; TRACE_FUNCTION( "nu_config_send" ); sndcp_data->nu = &sndcp_data->nu_base[nsapi]; data_count = &sndcp_data->data_count[nsapi]; if (*data_count == 0) { *data_count = octets; } else { *data_count += octets; return; } switch( GET_STATE( NU ) ) { case NU_ACK_SUA_RECEPTIVE: case NU_SEND_ACK_SUA_RECEPTIVE: SET_STATE(NU, NU_SEND_ACK_SUA_NOT_RECEPTIVE); nu_config_send_next(nsapi); sndcp_data->nu->sn_ready_ind_pending = FALSE; break; case NU_ACK_SUA_NOT_RECEPTIVE: SET_STATE(NU, NU_SEND_ACK_SUA_NOT_RECEPTIVE); break; case NU_SEND_ACK_SUA_NOT_RECEPTIVE: SET_STATE(NU, NU_SEND_ACK_SUA_NOT_RECEPTIVE); *data_count += octets; sndcp_data->nu->sn_ready_ind_pending = FALSE; break; case NU_UNACK_SU_NOT_RECEPTIVE: SET_STATE(NU, NU_SEND_UNACK_SU_NOT_RECEPTIVE); break; case NU_SEND_UNACK_SU_NOT_RECEPTIVE: SET_STATE(NU, NU_SEND_UNACK_SU_NOT_RECEPTIVE); *data_count += octets; sndcp_data->nu->sn_unitready_ind_pending = FALSE; break; case NU_UNACK_SU_RECEPTIVE: case NU_SEND_UNACK_SU_RECEPTIVE: SET_STATE(NU, NU_SEND_UNACK_SU_NOT_RECEPTIVE); nu_config_send_next(nsapi); sndcp_data->nu->sn_unitready_ind_pending = FALSE; break; case NU_REC_SUA_NOT_RECEPTIVE: SET_STATE(NU, NU_SEND_REC_SUA_NOT_RECEPTIVE); break; case NU_SEND_REC_SUA_NOT_RECEPTIVE: break; case NU_SUS_SUA_NOT_RECEPTIVE: SET_STATE(NU, NU_SEND_SUS_SUA_NOT_RECEPTIVE); break; case NU_SEND_SUS_SUA_NOT_RECEPTIVE: break; case NU_SUS_SUA_RECEPTIVE: SET_STATE(NU, NU_SEND_SUS_SUA_RECEPTIVE); break; case NU_SEND_SUS_SUA_RECEPTIVE: break; default: TRACE_ERROR( "config prim SEND unexpected" ); break; } } /* nu_config_send() */ /* +------------------------------------------------------------------------------ | Function : nu_config_send_next +------------------------------------------------------------------------------ | Description : sends data with 'data_count' octets. State is not changed. | | Parameters : nsapi | Pre : data_count > 0 | +------------------------------------------------------------------------------ */ GLOBAL void nu_config_send_next (UBYTE nsapi) { BOOL ack = FALSE; /* * Index and number in pattern. */ USHORT i = 0; USHORT r = 0; UBYTE sapi = 0; USHORT k = 0; UBYTE sapi_index = 0; USHORT send_size = 0; U16 ip_size = 0; U32 length; U32* data_count = NULL; #ifdef _SNDCP_DTI_2_ T_desc2* desc = NULL,*help; #else /*_SNDCP_DTI_2_*/ T_desc* desc = NULL; #endif /*_SNDCP_DTI_2_*/ T_SN_DATA_REQ* sn_data_req = NULL; T_SN_UNITDATA_REQ* sn_unitdata_req = NULL; data_count = &sndcp_data->data_count[nsapi]; length = *data_count; TRACE_FUNCTION( "nu_config_send_next" ); if (length == 0) { sndcp_get_nsapi_ack(nsapi, &ack); if (ack) { SET_STATE(NU, NU_SEND_ACK_SUA_RECEPTIVE); } else { SET_STATE(NU, NU_SEND_UNACK_SU_RECEPTIVE); } return; } sndcp_get_nsapi_sapi(sndcp_data->nu->nsapi, &sapi); sndcp_get_sapi_index(sapi, &sapi_index); sndcp_data->nu = &sndcp_data->nu_base[nsapi]; sndcp_get_nsapi_ack(nsapi, &ack); if (ack) { send_size = sndcp_data->sua_base[sapi_index].n201_i - SN_DATA_PDP_HDR_LEN_BIG; TRACE_EVENT_P1("send_size: %d", send_size); } else { send_size = sndcp_data->su_base[sapi_index].n201_u - SN_UNITDATA_PDP_HDR_LEN_BIG; TRACE_EVENT_P1("send_size: %d", send_size); } /* * The amount of data to be segmented * shall be a multiple of N201_I or N201_U respectively */ if(ack) { ip_size = 2 * sndcp_data->sua_base[sapi_index].n201_i + 100; if (length > ip_size) { if ( sndcp_data->sua_base[sapi_index].n201_i < ip_size) { k = (ip_size - (ip_size % sndcp_data->sua_base[sapi_index].n201_i))/ sndcp_data->sua_base[sapi_index].n201_i; length = k * (sndcp_data->sua_base[sapi_index].n201_i) -(k-1)- SN_DATA_PDP_HDR_LEN_BIG; } else { length = sndcp_data->sua_base[sapi_index].n201_i - SN_DATA_PDP_HDR_LEN_BIG; } } } else { ip_size = 2 * sndcp_data->su_base[sapi_index].n201_u + 100; if (length > ip_size) { if ( sndcp_data->su_base[sapi_index].n201_u < ip_size) { k = (ip_size - (ip_size % sndcp_data->su_base[sapi_index].n201_u))/ sndcp_data->su_base[sapi_index].n201_u; length = k * (sndcp_data->su_base[sapi_index].n201_u) - (k * (SN_UNITDATA_PDP_HDR_LEN_BIG -1) +1); } else { length = sndcp_data->su_base[sapi_index].n201_u - SN_UNITDATA_PDP_HDR_LEN_BIG; } } } TRACE_EVENT_P2("data to segment: %d, data to send: %d", length, *data_count); *data_count -= length; /* * Allocates small segments */ k = (U16)(length / 100); /* Number of 'full' 100 byte descriptors*/ r = (U16)(length % 100); /* Number of rest bytes */ if(r > 0){ #ifdef _SNDCP_DTI_2_ MALLOC (desc, (USHORT)(sizeof(T_desc2) - 1 + r)); #else /*_SNDCP_DTI_2_*/ MALLOC (desc, (USHORT)(sizeof(T_desc) - 1 + r)); #endif /*_SNDCP_DTI_2_*/ desc->next = (ULONG)NULL; desc->len = r; #ifdef _SNDCP_DTI_2_ desc->offset = 0; desc->size = r; #endif } for ( i=0; i < k; i++){ /* * Allocate memory for descriptor */ MALLOC (help, (USHORT)(sizeof(T_desc2) - 1 + 100)); /* * Fill descriptor control information. */ help->next = (ULONG)desc; help->len = 100; help->offset = 0; help->size = help->len; desc = help; } /* for k */ if (ack) { #ifdef _SNDCP_DTI_2_ MALLOC(sn_data_req, sizeof(T_SN_DATA_REQ)); sn_data_req->desc_list2.first = (ULONG) desc; sn_data_req->desc_list2.list_len = (U16)length; #else /*_SNDCP_DTI_2_*/ PALLOC_DESC (sn_data_req, SN_DATA_REQ); sn_data_req->desc_list.first = (ULONG) desc; sn_data_req->desc_list.list_len = (U16)length; #endif /*_SNDCP_DTI_2_*/ sn_data_req->nsapi = nsapi; #ifdef SNDCP_UPM_INCLUDED sn_data_req->p_id = DTI_PID_IP; #else sn_data_req->p_id = PPP_PID_IP; #endif /*SNDCP_UPM_INCLUDED*/ /* * Buffer the given N-PDU */ nu_buffer_npdu(sndcp_data->nu->send_npdu_number_ack, sn_data_req); sndcp_data->nu->send_npdu_number_ack = (U8)((sndcp_data->nu->send_npdu_number_ack + 1) % MAX_NPDU_NUMBER_ACK); sig_nu_sua_data_req(sn_data_req, (U8)((sndcp_data->nu->send_npdu_number_ack - 1 + MAX_NPDU_NUMBER_ACK) % MAX_NPDU_NUMBER_ACK), sn_data_req->nsapi, sapi); } else { #ifdef _SNDCP_DTI_2_ MALLOC(sn_unitdata_req, sizeof(T_SN_UNITDATA_REQ)); sn_unitdata_req->desc_list2.first = (ULONG) desc; sn_unitdata_req->desc_list2.list_len = (U16)length; #else /*_SNDCP_DTI_2_*/ PALLOC_DESC (sn_unitdata_req, SN_UNITDATA_REQ); sn_unitdata_req->desc_list.first = (ULONG) desc; sn_unitdata_req->desc_list.list_len = (U16)length; #endif /*_SNDCP_DTI_2_*/ sn_unitdata_req->nsapi = nsapi; #ifdef SNDCP_UPM_INCLUDED sn_unitdata_req->p_id = DTI_PID_IP; #else sn_unitdata_req->p_id = PPP_PID_IP; #endif /*SNDCP_UPM_INCLUDED*/ sndcp_data->nu->send_npdu_number_unack = (sndcp_data->nu->send_npdu_number_unack + 1) % MAX_NPDU_NUMBER_UNACK; sig_nu_su_unitdata_req(sn_unitdata_req, (U16)((sndcp_data->nu->send_npdu_number_unack - 1 + MAX_NPDU_NUMBER_UNACK) % MAX_NPDU_NUMBER_UNACK), sndcp_data->nu->nsapi, sapi); } } /* nu_config_send_next() */ #endif /* +------------------------------------------------------------------------------ | Function : nu_delete_npdu +------------------------------------------------------------------------------ | Description : The function nu_delete_npdu() searches and deletes one | buffered N-PDU. | Parameter : nsapi, npdu_number. | Pre : correct nu instance must be active, NPDU must exist. | +------------------------------------------------------------------------------ */ GLOBAL void nu_delete_npdu (UBYTE nsapi, UBYTE npdu_number) { T_NPDU_BUFFER* npdu_buffer = NULL; T_NPDU_BUFFER* pre = NULL; BOOL found = FALSE; TRACE_FUNCTION( "nu_delete_npdu" ); /* * Find the npdu. */ npdu_buffer = sndcp_data->nu->first_buffered_npdu; while (!found && npdu_buffer != NULL) { if (sndcp_data->nu->nsapi == nsapi && npdu_buffer->npdu_number == npdu_number) { found = TRUE; if (pre != NULL) { pre->next = npdu_buffer->next; } } else { pre = npdu_buffer; npdu_buffer = npdu_buffer->next; } } /* * Delete it. */ if (npdu_buffer != NULL) { nu_delete(npdu_buffer); } } /* nu_delete_npdu() */ /* +------------------------------------------------------------------------------ | Function : nu_delete_npdus +------------------------------------------------------------------------------ | Description : The function nu_delete_npdus() deletes all buffered N-PDUs. | | Pre : The correct nu instance has to be "active". | +------------------------------------------------------------------------------ */ GLOBAL void nu_delete_npdus (void) { T_NPDU_BUFFER* help = NULL; TRACE_FUNCTION( "nu_delete_npdus" ); while (sndcp_data->nu->first_buffered_npdu != NULL) { help = sndcp_data->nu->first_buffered_npdu->next; /* * Delete the first one. */ nu_delete(sndcp_data->nu->first_buffered_npdu); /* * Go to the next. */ sndcp_data->nu->first_buffered_npdu = help; } sndcp_data->nu->next_resend = NULL; } /* nu_delete_npdus() */ /* +------------------------------------------------------------------------------ | Function : nu_init +------------------------------------------------------------------------------ | Description : The function nu_init() .... | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void nu_init (void) { UBYTE nsapi = 0; TRACE_FUNCTION( "nu_init" ); sndcp_data->nu = & sndcp_data->nu_base[0]; INIT_STATE(NU_0, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[1]; INIT_STATE(NU_1, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[2]; INIT_STATE(NU_2, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[3]; INIT_STATE(NU_3, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[4]; INIT_STATE(NU_4, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[5]; INIT_STATE(NU_5, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[6]; INIT_STATE(NU_6, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[7]; INIT_STATE(NU_7, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[8]; INIT_STATE(NU_8, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[9]; INIT_STATE(NU_9, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[10]; INIT_STATE(NU_10, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[11]; INIT_STATE(NU_11, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[12]; INIT_STATE(NU_12, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[13]; INIT_STATE(NU_13, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[14]; INIT_STATE(NU_14, NU_UNACK_SU_RECEPTIVE); sndcp_data->nu = & sndcp_data->nu_base[15]; INIT_STATE(NU_15, NU_UNACK_SU_RECEPTIVE); for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { sndcp_data->nu = & sndcp_data->nu_base[nsapi]; sndcp_data->nu->nsapi = nsapi; sndcp_data->nu->send_npdu_number_unack = 0; sndcp_data->nu->send_npdu_number_ack = 0; sndcp_data->nu->rec_npdu_number_ack = 0; sndcp_data->nu->first_buffered_npdu = NULL; sndcp_data->nu->next_resend = NULL; sndcp_data->nu->sn_ready_ind_pending = FALSE; sndcp_data->nu->sn_unitready_ind_pending = FALSE; sndcp_data->nu->connection_is_opened = FALSE; sndcp_data->nu->discard = FALSE; sndcp_data->nu->discarded_data = 0; sndcp_data->nu->sent_data = 0; } } /* nu_init() */ /* +------------------------------------------------------------------------------ | Function : nu_ready_ind_if_nec +------------------------------------------------------------------------------ | Description : Sends an SN_READY_IND if none is pending and DTI connection is | opened. | | Parameters : nsapi | +------------------------------------------------------------------------------ */ GLOBAL void nu_ready_ind_if_nec (UBYTE nsapi) { BOOL used = FALSE; USHORT stat = MG_IDLE; UBYTE sapi = 0; TRACE_FUNCTION( "nu_ready_ind_if_nec" ); #ifdef SNDCP_TRACE_ALL if (sndcp_data->nu->sn_ready_ind_pending) { TRACE_EVENT("sn_ready_ind_pending TRUE"); } else { TRACE_EVENT("sn_ready_ind_pending FALSE"); } if (sndcp_data->nu->connection_is_opened) { TRACE_EVENT("connection_is_opened TRUE"); } else { TRACE_EVENT("connection_is_opened FALSE"); } #endif /* SNDCP_TRACE_ALL */ /* * set service instance according to nsapi parameter */ sndcp_data->nu = & sndcp_data->nu_base[nsapi]; sndcp_get_nsapi_sapi(nsapi, &sapi); sndcp_get_sapi_state(sapi, &stat); sndcp_is_nsapi_used(nsapi, &used); if (! sndcp_data->nu->sn_ready_ind_pending && sndcp_data->nu->connection_is_opened && used ) { sndcp_data->nu->sn_ready_ind_pending = TRUE; #ifdef SNDCP_UPM_INCLUDED dti_start(sndcp_data->hDTI, 0, SNDCP_INTERFACE_UNACK, nsapi); #else dti_start(sndcp_data->hDTI, 0, SNDCP_INTERFACE_ACK, nsapi); #endif } } /* nu_ready_ind_if_nec() */ /* +------------------------------------------------------------------------------ | Function : nu_unitready_ind_if_nec +------------------------------------------------------------------------------ | Description : Sends an SN_UNITREADY_IND if none is pending and DTI connection | is opened. | | Parameters : nsapi | Pre : The correct nu instance has to be "active". | +------------------------------------------------------------------------------ */ GLOBAL void nu_unitready_ind_if_nec (UBYTE nsapi) { BOOL used = FALSE; USHORT stat = MG_IDLE; UBYTE sapi = 0; TRACE_FUNCTION( "nu_unitready_ind_if_nec" ); #ifdef SNDCP_TRACE_ALL if (sndcp_data->nu->sn_unitready_ind_pending) { TRACE_EVENT("sn_unitready_ind_pending TRUE"); } else { TRACE_EVENT("sn_unitready_ind_pending FALSE"); } if (sndcp_data->nu->connection_is_opened) { TRACE_EVENT("connection_is_opened TRUE"); } else { TRACE_EVENT("connection_is_opened FALSE"); } #endif sndcp_get_nsapi_sapi(nsapi, &sapi); sndcp_get_sapi_state(sapi, &stat); sndcp_is_nsapi_used(nsapi, &used); if (! sndcp_data->nu->sn_unitready_ind_pending && sndcp_data->nu->connection_is_opened && used ) { #ifdef SNDCP_TRACE_ALL TRACE_EVENT("trying to palloc/send SN_UNITREADY_IND"); #endif sndcp_data->nu->sn_unitready_ind_pending = TRUE; dti_start(sndcp_data->hDTI, 0, SNDCP_INTERFACE_UNACK, nsapi); } } /* nu_unitready_ind_if_nec() */