FreeCalypso > hg > tcs211-l1-reconst
diff g23m/condat/ms/src/aci/psa_ccp.c @ 0:509db1a7b7b8
initial import: leo2moko-r1
| author | Space Falcon <falcon@ivan.Harhan.ORG> |
|---|---|
| date | Mon, 01 Jun 2015 03:24:05 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/g23m/condat/ms/src/aci/psa_ccp.c Mon Jun 01 03:24:05 2015 +0000 @@ -0,0 +1,2106 @@ +/* ++----------------------------------------------------------------------------- +| Project : GSM-PS (6147) +| Modul : PSA_CCP ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : This module defines the processing functions for the +| primitives send to the protocol stack adapter by call +| control. ++----------------------------------------------------------------------------- +*/ + +#ifndef PSA_CCP_C +#define PSA_CCP_C +#endif + +#include "aci_all.h" + +/*==== INCLUDES ===================================================*/ +#include "ccdapi.h" + +#include "aci_cmh.h" +#include "ati_cmd.h" +#include "aci_cmd.h" +#include "aci_mem.h" +#include "aci_lst.h" + +#ifdef FAX_AND_DATA +#include "aci_fd.h" +#endif /* of #ifdef FAX_AND_DATA */ + +#include "aci.h" +#include "psa.h" +#include "psa_cc.h" +#include "psa_ss.h" +#include "psa_mmi.h" +#include "psa_mm.h" +#include "cmh.h" +#include "cmh_cc.h" + +#ifdef SIM_TOOLKIT +#include "psa_sat.h" +#include "cmh_sat.h" +#endif /* of #ifdef SIM_TOOLKIT */ + +#include "aoc.h" +#include "psa_sim.h" + +#if defined (FF_WAP) || defined (FF_SAT_E) +#include "wap_aci.h" +#endif /* of FF_WAP */ + +#include "l4_tim.h" + +/*==== CONSTANTS ==================================================*/ + + +/*==== TYPES ======================================================*/ + + +/*==== EXPORT =====================================================*/ + +#ifdef FF_EM_MODE +EXTERN USHORT em_relcs; +#endif /* FF_EM_MODE + +/*==== VARIABLES ==================================================*/ + +EXTERN T_PCEER causeMod; +EXTERN SHORT causeCeer; + +/*==== FUNCTIONS ==================================================*/ + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_setup_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_SETUP_IND primitive send by CC. + this indicates an incoming call. + +*/ +// CC test 0319 +extern void CongiureGPIO_Internal(int GpioPin); +extern void HighGPIO(int GpioPin); +extern void LowGPIO(int GpioPin); +// end + +GLOBAL const void psa_mncc_setup_ind + ( T_MNCC_SETUP_IND *mncc_setup_ind ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + int i; + + TRACE_FUNCTION ("psa_mncc_setup_ind()"); + + causeMod = P_CEER_mod; /* Clear module which was set for ceer */ + causeCeer = CEER_NotPresent; /* Clear extended error cause */ + +// CC test 0319 + CongiureGPIO_Internal(1); +// LowGPIO(1); +// end + + /* stop redialling timer if necessary */ + if (rdlPrm.rdlcId NEQ NO_ENTRY) + { + TIMERSTOP(ACI_REPEAT_HND); + + #ifdef SIM_TOOLKIT + if( ( ccShrdPrm.ctb[rdlPrm.rdlcId]->SATinv & SAT_REDIAL ) ) + { /* This is the call invoked by SAT */ + T_ACI_SAT_TERM_RESP resp_data; + + psaSAT_InitTrmResp( &resp_data ); + psaSAT_SendTrmResp( RSLT_USR_CLR_DWN, &resp_data ); + } + #endif /* SIM_TOOLKIT */ + + psaCC_FreeCtbNtry (rdlPrm.rdlcId); + for(i = 0; i < CMD_SRC_MAX; i++) + { + R_AT(RAT_RDL, i)(REDIAL_STOP); + } + /* reset some redial parameter */ + rdlPrm.rdlcId = NO_ENTRY; + } + +/* + *------------------------------------------------------------------- + * check for new entry in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbNewEntry(); + + if( cId < 0 ) + { + /* + * disconnect call, due to full call table. + */ + { + UBYTE ti = mncc_setup_ind -> ti; + PREUSE (mncc_setup_ind, mncc_disconnect_req, MNCC_DISCONNECT_REQ); + mncc_disconnect_req -> ti = ti; + mncc_disconnect_req -> cause = MNCC_CAUSE_USER_BUSY; + mncc_disconnect_req -> fac_inf.l_fac = 0; + mncc_disconnect_req -> ss_version = SS_VER_NOT_PRES; + PSENDX (CC, mncc_disconnect_req); + } + + TRACE_EVENT ("MTC rejected due to full call table"); + + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + pCtbNtry -> curCs = MNCC_CAUSE_NO_MS_CAUSE; + + pCtbNtry -> ti = mncc_setup_ind -> ti; + pCtbNtry -> rptInd = mncc_setup_ind -> ri; + pCtbNtry -> sigInf = mncc_setup_ind -> sig; + pCtbNtry -> clgPty = mncc_setup_ind -> calling_party; + pCtbNtry -> clgPtySub = mncc_setup_ind -> calling_party_sub; + + /* + * Assign called party + */ + pCtbNtry -> cldPty.ton = mncc_setup_ind -> called_party.ton; + pCtbNtry -> cldPty.npi = mncc_setup_ind -> called_party.npi; + pCtbNtry -> cldPty.c_called_num = + mncc_setup_ind -> called_party.c_called_num; + if (pCtbNtry -> cldPty.called_num NEQ NULL) + { + ACI_MFREE (pCtbNtry -> cldPty.called_num); + pCtbNtry -> cldPty.called_num = NULL; + } + if (pCtbNtry -> cldPty.c_called_num NEQ 0) + { + ACI_MALLOC (pCtbNtry -> cldPty.called_num, + pCtbNtry -> cldPty.c_called_num); + memcpy (pCtbNtry -> cldPty.called_num, + mncc_setup_ind -> called_party.called_num, + mncc_setup_ind -> called_party.c_called_num); + } + + /* + * Assign called party subaddress + */ + pCtbNtry -> cldPtySub = mncc_setup_ind -> called_party_sub; + + /* + * Assign redirecting party + */ + pCtbNtry -> rdrPty.ton = mncc_setup_ind -> redirecting_party.ton; + pCtbNtry -> rdrPty.npi = mncc_setup_ind -> redirecting_party.npi; + pCtbNtry -> rdrPty.present = mncc_setup_ind -> redirecting_party.present; + pCtbNtry -> rdrPty.screen = mncc_setup_ind -> redirecting_party.screen; + pCtbNtry -> rdrPty.c_redir_num = + mncc_setup_ind -> redirecting_party.c_redir_num; + if (pCtbNtry -> rdrPty.redir_num NEQ NULL) + { + ACI_MFREE (pCtbNtry -> rdrPty.redir_num); + pCtbNtry -> rdrPty.redir_num = NULL; + } + if (pCtbNtry -> rdrPty.c_redir_num NEQ 0) + { + ACI_MALLOC (pCtbNtry -> rdrPty.redir_num, + pCtbNtry -> rdrPty.c_redir_num); + memcpy (pCtbNtry -> rdrPty.redir_num, + mncc_setup_ind -> redirecting_party.redir_num, + mncc_setup_ind -> redirecting_party.c_redir_num); + } + + /* + * Assign redirecting party subaddress + */ + pCtbNtry -> rdrPtySub.tos = + mncc_setup_ind -> redirecting_party_sub.tos; + pCtbNtry -> rdrPtySub.odd_even = + mncc_setup_ind -> redirecting_party_sub.odd_even; + pCtbNtry -> rdrPtySub.c_subaddr = + mncc_setup_ind -> redirecting_party_sub.c_subaddr; + if (pCtbNtry -> rdrPtySub.subaddr NEQ NULL) + { + ACI_MFREE (pCtbNtry -> rdrPtySub.subaddr); + pCtbNtry -> rdrPtySub.subaddr = NULL; + } + if (pCtbNtry -> rdrPtySub.c_subaddr NEQ 0) + { + ACI_MALLOC (pCtbNtry -> rdrPtySub.subaddr, + pCtbNtry -> rdrPtySub.c_subaddr); + memcpy (pCtbNtry -> rdrPtySub.subaddr, + mncc_setup_ind -> redirecting_party_sub.subaddr, + mncc_setup_ind -> redirecting_party_sub.c_subaddr); + } + + /* + * Assign bearer caps + */ + memcpy( &(pCtbNtry->BC[0]),&(mncc_setup_ind->bcpara), + sizeof( T_bcpara) ); + memcpy( &(pCtbNtry->BC[1]),&(mncc_setup_ind->bcpara2), + sizeof( T_bcpara) ); + + psaCC_phbSrchNum( cId, CT_MTC ); + + pCtbNtry -> calStat = CS_ACT_REQ; + pCtbNtry -> calType = CT_MTC; + + pCtbNtry -> prio = PRIO_NORM_CALL; + pCtbNtry -> curBC = 0; + + psaCC_send_satevent( EVENT_MT_CALL, cId, FAR_END, FALSE ); + +/* + *------------------------------------------------------------------- + * indicate alerting + *------------------------------------------------------------------- + */ + + /* replace invalid/unknown sigInf by SIG_NOT_PRES */ + switch (pCtbNtry -> sigInf) + { + case SIG_DIAL_TONE_ON: + case SIG_RING_BACK_TONE_ON: + case SIG_INT_TONE_ON: + case SIG_NET_CONG_TONE_ON: + case SIG_BUSY_TONE_ON: + case SIG_CONF_TONE_ON: + case SIG_ANS_TONE_ON: + case SIG_CALL_WAIT_TONE_ON: + case SIG_OFF_HOOK_WARN_TONE_ON: + case SIG_TONES_OFF: + case SIG_ALERT_OFF: + case SIG_NOT_PRES: + break; /* leave as it is */ + default: /* replace unknown value by something well known */ + pCtbNtry -> sigInf = SIG_NOT_PRES; + } + + if( pCtbNtry -> sigInf NEQ SIG_NOT_PRES OR + ccShrdPrm.TCHasg EQ TRUE ) + { + { + /* indicate alerting to network */ + UBYTE ti = mncc_setup_ind -> ti; + PREUSE (mncc_setup_ind, mncc_alert_req, MNCC_ALERT_REQ); + mncc_alert_req -> ti = ti; + PSENDX (CC, mncc_alert_req); + } + + cmhCC_IncomingCall (cId); /* indicate an incoming call */ + return; + } + else + { + pCtbNtry -> alrtStat = AS_PND; + } + + /* + * check for progress descriptions + */ + psaCC_chkPrgDesc ( cId, mncc_setup_ind -> progress_desc, MT_SETUP ); + + /* + * start call time measurements + */ + aoc_info (cId, AOC_START_TIME); +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_setup_ind); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_setup_cnf | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_SETUP_CNF primitive send by CC. + this terminates the call establishment request. + +*/ + +GLOBAL const void psa_mncc_setup_cnf + ( T_MNCC_SETUP_CNF *mncc_setup_cnf ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + int i; + BOOL flag_redial = FALSE; + + TRACE_FUNCTION ("psa_mncc_setup_cnf()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_setup_cnf -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_setup_cnf); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + pCtbNtry -> curCs = mncc_setup_cnf -> cause; + pCtbNtry -> rslt = mncc_setup_cnf -> cause; + + + switch( mncc_setup_cnf -> cause ) + { + case( MNCC_CAUSE_SUCCESS ): /* successful establishment, call connected */ + + /* + * MNCC_SETUP_CNF is received in call state other than CS_ACT_REQ + * so reject the primitive. + */ + if( pCtbNtry -> calStat NEQ CS_ACT_REQ) + { + TRACE_EVENT ("MNCC_SETUP_CNF is rejected as it is received in call state other than CS_ACT_REQ"); + break; + } + pCtbNtry -> clgPty.ton = mncc_setup_cnf -> connected_number.ton; + pCtbNtry -> clgPty.npi = mncc_setup_cnf -> connected_number.npi; + pCtbNtry -> clgPty.present = mncc_setup_cnf -> connected_number.present; + pCtbNtry -> clgPty.screen = mncc_setup_cnf -> connected_number.screen; + pCtbNtry -> clgPty.c_num = mncc_setup_cnf -> connected_number.c_num; + + memcpy( pCtbNtry -> clgPty.num, + mncc_setup_cnf -> connected_number.num, MAX_CC_CALLING_NUMBER ); + + pCtbNtry -> clgPtySub.tos = mncc_setup_cnf -> connected_number_sub.tos; + pCtbNtry -> clgPtySub.odd_even = mncc_setup_cnf -> connected_number_sub.odd_even; + pCtbNtry -> clgPtySub.c_subaddr = mncc_setup_cnf -> connected_number_sub.c_subaddr; + + memcpy( pCtbNtry -> clgPtySub.subaddr, + mncc_setup_cnf -> connected_number_sub.subaddr, SUB_LENGTH ); + + pCtbNtry -> inBndTns = FALSE; + pCtbNtry -> calStat = CS_ACT; + + /* check for progress descriptions */ + psaCC_chkPrgDesc ( cId, mncc_setup_cnf -> progress_desc, MT_CONN ); + + + if(pCtbNtry->calType EQ CT_MOC_RDL) + { + pCtbNtry->calType = CT_MOC; + flag_redial = TRUE; + } + /* if redialling procedure was successful we finish redialling */ + if((rdlPrm.rdlMod EQ AUTOM_REPEAT_ON) AND flag_redial) + { + for(i = 0; i < CMD_SRC_MAX; i++) + { + R_AT(RAT_RDL, i)(CALL_ATTEMPT_SUCCESSFUL); + } + pCtbNtry->rdlCnt = 0; + rdlPrm.rdlcId = NO_ENTRY; + pCtbNtry->rdlTimIndex = RDL_TIM_INDEX_NOT_PRESENT; + flag_redial = FALSE; + } + + /* Inform that a call goes to active state */ + psaCC_chngCalTypCnt( cId, +1 ); + + cmhCC_CallConnected( cId ); + + psaCC_send_satevent( EVENT_CALL_CONN, cId, FAR_END, FALSE ); + + aoc_info (cId,AOC_CALL_CONNECTED); + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_START ); + + /* check for DTMF tones to send automatically */ + psaCC_DTMFSent ( cId ); + +#if defined (FF_WAP) || defined (FF_SAT_E) + /* WAP STACK CALL is activ */ + if (Wap_Call) + ccShrdPrm.wapStat = CC_WAP_STACK_UP; +#endif + + break; + + default: /* unexpected result, assumed call disconnected */ + { + TRACE_EVENT_P1("[ERR] UNEXP CAUSE IN SETUP CNF=%4x", mncc_setup_cnf -> cause); + } + /*FALLTHROUGH*/ /*lint -fallthrough*/ + + /* unsuccessful establishment, call disconnected */ + case( MNCC_CAUSE_MS_TIMER ): + + pCtbNtry -> nrmCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); +#ifdef FF_EM_MODE + em_relcs = MNCC_CAUSE_MS_TIMER; +#endif /* FF_EM_MODE */ + ccShrdPrm.cIdFail = cId; + + /* + * At this point the call has not yet gone completely always. + * Call Control may not be in state U0, but in state U11, having + * sent a DISCONNECT to the network, expecting the RELEASE + * from the network or expiry of T308 in CC. + * Implementation works, but it is not very nice here, releasing + * the ti and decrementing the call count too early. + */ + pCtbNtry -> calStat = CS_IDL; + + psaCC_chngCalTypCnt( cId, -1 ); + psaCC_retMOCTi( pCtbNtry -> ti ); + cmhCC_CallDisconnected (cId); + psaCC_FreeCtbNtry (cId); + break; + } +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_setup_cnf); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_setup_compl_ind| ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_SETUP_COMPL_IND primitive send by CC. + this terminates the call establishment of an incoming call. + +*/ + +GLOBAL const void psa_mncc_setup_compl_ind + ( T_MNCC_SETUP_COMPL_IND *mncc_setup_compl_ind ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_setup_compl_ind()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_setup_compl_ind -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_setup_compl_ind); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + + pCtbNtry -> rslt = mncc_setup_compl_ind -> cause; + pCtbNtry -> curCs = mncc_setup_compl_ind -> cause; + + switch( mncc_setup_compl_ind -> cause ) + { + case( MNCC_CAUSE_SUCCESS ): /* successful establishment, call connected */ + + pCtbNtry -> inBndTns = FALSE; + pCtbNtry -> calStat = CS_ACT; + + psaCC_setSpeechMode (); + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_START ); + + /* + * Inform that a call goes to active state + */ + psaCC_chngCalTypCnt( cId, +1 ); + + cmhCC_CallConnected( cId ); + + aoc_info (cId, AOC_CALL_CONNECTED); + break; + + default: /* unexpected result, assumed call disconnected */ + { + TRACE_EVENT_P1("[ERR] UNEXP CAUSE IN SETUP CMPL IND=%4x", mncc_setup_compl_ind -> cause); + } + /*FALLTHROUGH*/ /*lint -fallthrough*/ + + /* unsuccessful establishment, call disconnected */ + case( MNCC_CAUSE_MS_TIMER ): + + pCtbNtry -> nrmCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); +#ifdef FF_EM_MODE + em_relcs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); +#endif /* FF_EM_MODE */ + ccShrdPrm.cIdFail = cId; + + /* + * What happens below is somewhat questionable. + * ACI sets the call to CS_IDL and free the transaction identifier. + * What happened is that on CC level, in state U8 CONNECT REQUEST the + * CONNECT message sent by CC has not been answered by the network by a + * CONNECT ACNOWLEDGE message. + * In this situation CC sends a DISCONNECT to the network and enters + * state U11 DISCONNECT REQUEST. This means, the call state in CC is + * still different from U0 NULL. + * However, problems in the field are not expected here. + */ + pCtbNtry -> calStat = CS_IDL; + + psaCC_chngCalTypCnt( cId, -1 ); + psaCC_retMOCTi( pCtbNtry -> ti ); + + cmhCC_CallDisconnected (cId); + cmhCC_CallReleased (cId); + + break; + } + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_setup_compl_ind); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_reject_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_REJECT_IND primitive send by CC. + this indicates a cause for rejecting a call establishment. + +*/ + +GLOBAL const void psa_mncc_reject_ind + ( T_MNCC_REJECT_IND *mncc_reject_ind ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_reject_ind()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_reject_ind -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_reject_ind); + return; + } + psaCC_StopDTMF (cId); /* HM 27.07.00*/ + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + pCtbNtry -> curCs = mncc_reject_ind -> cause; + + pCtbNtry -> rslt = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + pCtbNtry -> nrmCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + pCtbNtry -> rejCs = mncc_reject_ind -> cause; + /* In this case, the cause values are internal and not sent by network */ + pCtbNtry -> numRawCauseBytes = 0; + +#ifdef FF_EM_MODE + em_relcs = mncc_reject_ind -> cause; +#endif /* FF_EM_MODE */ + + if( GET_CAUSE_VALUE(pCtbNtry -> rejCs) NEQ NOT_PRESENT_8BIT ) ccShrdPrm.cIdFail = cId; + + pCtbNtry -> calStat = CS_IDL; + + psaCC_chngCalTypCnt( cId, -1 ); + psaCC_retMOCTi( pCtbNtry -> ti ); + + /* monitoring for SAT radio-link failure */ + psaCC_send_satevent( EVENT_CALL_DISC, cId, NEAR_END, TRUE ); + + /* check conditions for redialling */ + cmhCC_redialCheck(cId); + +#ifdef SIM_TOOLKIT + if( pCtbNtry->SATinv ) + { + cmhSAT_NtwErr( ADD_NO_CAUSE ); + pCtbNtry->SATinv = FALSE; + } +#endif + /* cmhCC_CallDisconnected(cId);*/ + cmhCC_CPIrejectMsg(cId); + cmhCC_CallReleased(cId); + +/* free the primitive buffer */ + PFREE (mncc_reject_ind); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_release_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_RELEASE_IND primitive send by CC. + this indicates the release of a call. + +*/ + +GLOBAL const void psa_mncc_release_ind +( T_MNCC_RELEASE_IND *mncc_release_ind ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_release_ind()"); + + /* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_release_ind -> ti ); + + if( cId < 0 ) + { + psaCC_retMOCTi( mncc_release_ind -> ti ); + + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_release_ind); + return; + } + psaCC_StopDTMF ( cId ); /* HM 27.07.00 */ + + /* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + + pCtbNtry -> calStat = CS_DSC_REQ; /* Leave active state */ + pCtbNtry -> curCs = mncc_release_ind -> cause; + pCtbNtry -> numRawCauseBytes = mncc_release_ind -> c_raw_cause; + pCtbNtry -> rawCauseBytes = mncc_release_ind -> raw_cause; + + psaCC_setSpeechMode (); + + /* check for TTY service */ + /*cmhCC_TTY_Control ( cId );*/ + + if (pCtbNtry -> nrmCs EQ MNCC_CAUSE_NO_MS_CAUSE) /* no Disconnect Cause available...*/ + { + pCtbNtry -> nrmCs= mncc_release_ind -> cause; /* Check ### */ + ccShrdPrm.cIdFail = cId; /* Check ### */ +#ifdef FF_EM_MODE + em_relcs = mncc_release_ind -> cause; /* Check ### */ +#endif /* FF_EM_MODE */ + } + + pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + pCtbNtry -> rslt = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + + psaCC_chngCalTypCnt( cId, -1 ); + psaCC_retMOCTi( pCtbNtry -> ti ); + + psaCC_send_satevent( EVENT_CALL_DISC, cId, FAR_END, TRUE ); + + pCtbNtry -> numRawCauseBytes = 0; /* Reset the cause value after sending the info to SAT */ + + cmhCC_redialCheck(cId); + + /* + if( pCtbNtry -> CCBSstat EQ CCBSS_PSSBL OR + pCtbNtry -> calType EQ CT_NI_MOC ) + */ + switch (pCtbNtry->curCmd) + { + case( AT_CMD_A ): + case( AT_CMD_D ): + case( AT_CMD_NONE ): + case( AT_CMD_ABRT ): + { + cmhCC_CallDisconnected(cId); + cmhCC_CallReleased( cId ); + } + break; + + case( AT_CMD_H ): + case( AT_CMD_Z ): + case( AT_CMD_CHUP ): + case( AT_CMD_CHLD ): + +#ifdef FF_FAX + case( AT_CMD_FKS ): + case( AT_CMD_FDT ): + case( AT_CMD_FDR ): +#endif + { + cmhCC_CallDisconnected(cId); + cmhCC_CPIReleaseMsg(cId); + } + break; + } + + if (rdlPrm.rdlcId NEQ cId) + {/* if redialling is active no clean cId entry */ + /*patch BE 30.06.00 to remove every other call drops*/ + psaCC_FreeCtbNtry (cId); + /*end patch BE */ + } + + /* free the primitive buffer */ + PFREE (mncc_release_ind); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_release_cnf | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_RELEASE_CNF primitive send by CC. + this confirmates the release request for a call. + +*/ + +GLOBAL const void psa_mncc_release_cnf + ( T_MNCC_RELEASE_CNF *mncc_release_cnf ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_release_cnf()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_release_cnf -> ti ); + + if( cId < 0 ) + { + psaCC_retMOCTi( mncc_release_cnf -> ti ); + + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_release_cnf); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + + /* HM 02-Aug-2002, done while merging SBK code, check again this code*/ +#if 0 /* Old code */ + if( mncc_release_cnf -> cause NEQ CAUSE_NOT_PRES ) + { + pCtbNtry -> nrmCs = mncc_release_cnf -> cause; + ccShrdPrm.cIdFail = cId; +#ifdef FF_EM_MODE + em_relcs = mncc_release_cnf -> cause; +#endif /* FF_EM_MODE */ + } +#endif /* #if 0 */ + + if (pCtbNtry -> nrmCs EQ MNCC_CAUSE_NO_MS_CAUSE) /* no Disconnect Cause available...*/ + { + pCtbNtry -> nrmCs = mncc_release_cnf -> cause; /* Recheck ###*/ + ccShrdPrm.cIdFail = cId; /* This line is considered harmful, only if cause present ### */ +#ifdef FF_EM_MODE + em_relcs = mncc_release_cnf -> cause; /* Recheck ### */ +#endif /* FF_EM_MODE */ + } + pCtbNtry -> rslt = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + pCtbNtry -> curCs = pCtbNtry -> rejCs; + pCtbNtry -> numRawCauseBytes = mncc_release_cnf -> c_raw_cause; + pCtbNtry -> rawCauseBytes = mncc_release_cnf -> raw_cause; +#ifdef SIM_TOOLKIT + if(!(pCtbNtry -> SATinv & SAT_REDIAL)) +#endif + pCtbNtry -> calStat = CS_IDL; + + psaCC_chngCalTypCnt( cId, -1 ); + psaCC_retMOCTi( pCtbNtry -> ti ); + + psaCC_send_satevent( EVENT_CALL_DISC, cId , FAR_END, TRUE ); + + pCtbNtry -> numRawCauseBytes = 0; /* Reset the cause value after sending the info to SAT */ + + cmhCC_redialCheck( cId); + + cmhCC_CallReleased (cId); + + /*patch BE 30.06.00 to remove every other call drops */ + { +#ifdef SIM_TOOLKIT + if ( (pCtbNtry -> SATinv & SAT_REDIAL) EQ 0 ) + { +#endif /* SIM_TOOLKIT */ + if (rdlPrm.rdlcId NEQ cId) + { + psaCC_FreeCtbNtry (cId); + } +#ifdef SIM_TOOLKIT + } +#endif /* SIM_TOOLKIT */ + } + /*end patch BE */ + + switch(CHLDaddInfo) + { + case (CHLD_ADD_INFO_DIAL_CAL): + cId = psaCC_ctbFindCall( NO_VLD_OWN, NO_VLD_CS, CT_MOC ); + if (cId NEQ NO_ENTRY) + { + cmhCC_NewCall(cId,psaCC_ctb(cId)->curSrc,AT_CMD_D); + } + break; + default: + break; + } + /* free the primitive buffer */ + PFREE (mncc_release_cnf); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_disconnect_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_DISCONNECT_IND primitive send by CC. + this indicates the disconnection of a call. + +*/ + +GLOBAL const void psa_mncc_disconnect_ind + ( T_MNCC_DISCONNECT_IND *mncc_disconnect_ind ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + BOOL held_call = FALSE; + + TRACE_FUNCTION ("psa_mncc_disconnect_ind()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_disconnect_ind -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_disconnect_ind); + return; + } + psaCC_StopDTMF ( cId ); /* HM 27.07.00 */ + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + + pCtbNtry -> curCs = mncc_disconnect_ind -> cause; + + if( mncc_disconnect_ind->diagnostic EQ DIAG_CCBS_POSSIBLE ) + { + pCtbNtry -> CCBSstat = CCBSS_PSSBL; + } + + /* CQ 23619: copy ss diagnostic to shared parameters >> */ + pCtbNtry->ssDiag = mncc_disconnect_ind->ss_diag; + /* CQ 23619 << */ + +#if 0 + if( mncc_disconnect_ind -> cause NEQ CAUSE_NOT_PRES ) + { + pCtbNtry -> nrmCs = mncc_disconnect_ind -> cause; + ccShrdPrm.cIdFail = cId; +#ifdef FF_EM_MODE + em_relcs = mncc_disconnect_ind -> cause; +#endif /* FF_EM_MODE */ + } +#endif + + pCtbNtry -> nrmCs = mncc_disconnect_ind -> cause; /* Recheck ### */ + ccShrdPrm.cIdFail = cId; /* Recheck ### */ +#ifdef FF_EM_MODE + em_relcs = mncc_disconnect_ind -> cause; /* Recheck ### */ +#endif /* FF_EM_MODE */ + + /* remember if call is currently on hold */ + if (pCtbNtry -> calStat EQ CS_HLD) + held_call = TRUE; + + /* calStat has to be set before calling psaCC_chkPrgDesc, otherwise + no CPI event will be send */ + pCtbNtry -> calStat = CS_DSC_REQ; + + /* check for TTY service */ + /* cmhCC_TTY_Control ( cId ); */ + + /* check for progress descriptions */ + psaCC_chkPrgDesc ( cId, mncc_disconnect_ind -> progress_desc, MT_DISC ); + + pCtbNtry -> rslt = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); + + pCtbNtry -> numRawCauseBytes = mncc_disconnect_ind -> c_raw_cause; + pCtbNtry -> rawCauseBytes = mncc_disconnect_ind -> raw_cause; + + psaCC_send_satevent( EVENT_CALL_DISC, cId , FAR_END, TRUE ); + + pCtbNtry -> numRawCauseBytes = 0; /* Reset the cause value after sending the info to SAT */ + + /* If call was held upon mncc_disconnect_ind it is cleared anyway */ + if (held_call EQ TRUE) + { + TRACE_EVENT ("Release a held call"); + cmhCC_CallDisconnected (cId); + psaCC_ClearCall (cId); + } + else + { + switch( cmhCC_getcalltype(cId) ) + { + case( VOICE_CALL ): + { + /* + * if in-band tones are available and TCH is assigned, request to disconnect the call + * GSM 04.08/5.4.4.1.1.1 + */ + /* + TRACE_EVENT("psa_mncc_disconnect_ind(): --> VOICE CALL"); + if ((pCtbNtry -> inBndTns EQ TRUE) + AND (pCtbNtry -> CCBSstat EQ NO_VLD_CCBSS) + AND (ccShrdPrm.TCHasg EQ TRUE)) + { + cmhCC_DisconnectCall (cId); + } + else + { + cmhCC_CallDisconnected (cId); + } + */ + /* check conditions for redialling */ + if((pCtbNtry->curCmd NEQ AT_CMD_H) AND + (pCtbNtry->curCmd NEQ AT_CMD_CHUP)) + { + cmhCC_redialCheck(cId); + } + + + /* + * for CCBS support the "Prolonged Clearing Procedure" + * GSM 04.08/5.4.4.2.1 + */ + cmhCC_CallDisconnected (cId); + + if ((pCtbNtry->inBndTns EQ TRUE) /* 5.4.4.2.1.1 */ + AND (pCtbNtry->CCBSstat EQ NO_VLD_CCBSS)) + { + if (ccShrdPrm.TCHasg NEQ TRUE) + { + TRACE_EVENT ("4.08/5.4.4.2.1.1 i)"); + psaCC_ClearCall (cId); + } + else + { + TRACE_EVENT ("4.08/5.4.4.2.1.1 ii)"); + psaCC_setSpeechMode(); + } + } + else if (pCtbNtry->CCBSstat EQ CCBSS_PSSBL) /* 5.4.4.2.2.1 */ + { + TRACE_EVENT ("4.08/5.4.4.2.2.1"); + psaCC_setSpeechMode(); + cmhCC_SndDiscRsn( cId ); /* FIXME: to emmit BUSY, but this is not good here + since BUSY is final result code and will be + emitted on Release again !!!!! */ + } + else if ((pCtbNtry->inBndTns NEQ TRUE) /* 5.4.4.2.3.1 */ + AND (pCtbNtry->CCBSstat EQ NO_VLD_CCBSS)) + { + TRACE_EVENT ("4.08/5.4.4.2.3.1"); + psaCC_ClearCall (cId); + } + else /* 5.4.4.2.3.2 */ + { + TRACE_EVENT ("4.08/5.4.4.2.3.2"); + psaCC_ClearCall (cId); + } + break; + } + default: /* all non voice calls */ + { + /* + * see cmh_cc.h T_CC_CALL_TYPE for all other call types + */ + TRACE_EVENT("psa_mncc_disconnect_ind(): --> DATA CALL"); + cmhCC_CallDisconnected (cId); + psaCC_ClearCall (cId); + break; + } + } + } /* else */ + + /* free the primitive buffer */ + PFREE (mncc_disconnect_ind); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_alert_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_ALERT_IND primitive send by CC. + this indicates that the called party is alerted. + +*/ + +GLOBAL const void psa_mncc_alert_ind + ( T_MNCC_ALERT_IND *mncc_alert_ind ) +{ + SHORT cId; /* holds call id */ + + TRACE_FUNCTION ("psa_mncc_alert_ind()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_alert_ind -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_alert_ind); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + psaCC_ctb(cId)->alrtStat = AS_SND; + psaCC_ctb(cId)->curCs = MNCC_CAUSE_NO_MS_CAUSE; + + /* check for progress descriptions */ + psaCC_chkPrgDesc ( cId, mncc_alert_ind -> progress_desc, MT_ALRT ); + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_START ); +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_alert_ind); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_call_proceed_ind| ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_CALL_PROCEED_IND primitive send by CC. + this indicates a call proceeding information for a call. + +*/ + +GLOBAL const void psa_mncc_call_proceed_ind + ( T_MNCC_CALL_PROCEED_IND *mncc_call_proceed_ind ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_call_proceed_ind()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_call_proceed_ind -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_call_proceed_ind); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + pCtbNtry -> curCs = MNCC_CAUSE_NO_MS_CAUSE; + + memcpy( &(pCtbNtry->BC[0]),&(mncc_call_proceed_ind->bcpara), + sizeof( T_bcpara) ); + memcpy( &(pCtbNtry->BC[1]),&(mncc_call_proceed_ind->bcpara2), + sizeof( T_bcpara) ); + pCtbNtry -> rptInd = mncc_call_proceed_ind -> ri; + + /* check for progress descriptions */ + psaCC_chkPrgDesc ( cId, mncc_call_proceed_ind -> progress_desc, MT_PROC ); + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_START ); +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_call_proceed_ind); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_progress_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_PROGRESS_IND primitive send by CC. + this indicates a progress description for a call. + +*/ + +GLOBAL const void psa_mncc_progress_ind + ( T_MNCC_PROGRESS_IND *mncc_progress_ind ) +{ + SHORT cId; /* holds call id */ + + TRACE_FUNCTION ("psa_mncc_progress_ind()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_progress_ind -> ti ); + + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_progress_ind); + return; + } + psaCC_ctb(cId)->curCs = MNCC_CAUSE_NO_MS_CAUSE; + + /* + * check for progress descriptions + */ + psaCC_chkPrgDesc ( cId, mncc_progress_ind -> progress_desc, MT_PROGR ); + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_progress_ind); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_hold_cnf | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_HOLD_CNF primitive send by CC. + this confirmates that a call is being held. + +*/ + +GLOBAL const void psa_mncc_hold_cnf + ( T_MNCC_HOLD_CNF *mncc_hold_cnf ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_hold_cnf()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_hold_cnf -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_hold_cnf); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + + switch( mncc_hold_cnf -> cause ) + { + case( MNCC_CAUSE_HOLD_SUCCESS ): /* successful, call held */ + case( MNCC_CAUSE_SUCCESS ): + case( MNCC_CAUSE_NO_MS_CAUSE ): + + pCtbNtry -> calStat = CS_HLD; + + psaCC_setSpeechMode (); + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_PAUSE ); + break; + + default: /* unsuccessful, call state unchanged */ + + ccShrdPrm.cIdFail = cId; + pCtbNtry -> calStat = CS_ACT; + break; + } + + pCtbNtry -> rslt = mncc_hold_cnf -> cause; + + cmhCC_CallHeld(cId); + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_hold_cnf); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_retrieve_cnf | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_RETRIEVE_CNF primitive send by CC. + this confirmates that a call is retrieved. + +*/ + +GLOBAL const void psa_mncc_retrieve_cnf + ( T_MNCC_RETRIEVE_CNF *mncc_retrieve_cnf ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_retrieve_cnf()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_retrieve_cnf -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_retrieve_cnf); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + + switch( mncc_retrieve_cnf -> cause ) + { + case( MNCC_CAUSE_RETRIEVE_SUCCESS ): /* successful, call active */ + + pCtbNtry -> calStat = CS_ACT; + + /* switch on vocoder */ + psaCC_setSpeechMode (); + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_START ); + break; + + default: /* unsuccessful, call state unchanged */ + + ccShrdPrm.cIdFail = cId; + pCtbNtry -> calStat = CS_HLD; + break; + } + + pCtbNtry -> rslt = mncc_retrieve_cnf -> cause; + + cmhCC_CallRetrieved (cId); + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_retrieve_cnf); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_sync_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_SYNC_IND primitive send by CC. + this indicates the change of the channel mode. + +*/ + +GLOBAL const void psa_mncc_sync_ind( T_MNCC_SYNC_IND *mncc_sync_ind ) +{ + SHORT cId = 0; /* holds call id */ + + TRACE_FUNCTION ("psa_mncc_sync_ind()"); + + /* + cause cause 4.6 UBYTE + channel mode chm 4.14 STRUCT + + ch_type 0 CH_SDCCH SDCCH channel + 1 CH_TCH_F TCH Fullrate + 2 CH_TCH_H TCH Halfrate + + ch_mode 0 CHM_SIG_ONLY signalling only + 1 CHM_SPEECH speech full rate or half rate version 1 + 33 CHM_SPEECH_V2 speech full rate or half rate version 2 + 65 CHM_SPEECH_V3 speech full rate or half rate version 3 + 3 CHM_DATA_9_6 data 9.6 kBit/s + 11 CHM_DATA_4_8 data 4.8 kBit/s + 19 CHM_DATA_2_4 data 2.4 kBit/s + 15 CHM_DATA_14_4 data 14.4 kBit/s + */ + + TRACE_EVENT_P4("MNCC_SYNC_IND ti: %d, cause: %d, ch_type: %d, ch_mode: %d", + mncc_sync_ind -> ti, + mncc_sync_ind -> cause, + mncc_sync_ind -> chm.ch_type, + mncc_sync_ind -> chm.ch_mode); + + /* update shared parameter */ + ccShrdPrm.syncCs = mncc_sync_ind -> cause; +#ifdef FF_EM_MODE + em_relcs = mncc_sync_ind -> cause; +#endif /* FF_EM_MODE */ + + /* Inform Advice of Charge Module */ + switch (mncc_sync_ind->cause) + { + case MNCC_CAUSE_REEST_STARTED: + for( cId = 0; cId < MAX_CALL_NR; cId++ ) + aoc_info (cId, AOC_SUSPEND_AOC); + break; + case MNCC_CAUSE_REEST_FINISHED: + ccShrdPrm.aocRsmpPend = 1; + break; + } + + /* switch channel mode */ + if( mncc_sync_ind -> chm.ch_mode NEQ NOT_PRESENT_8BIT ) + { + ccShrdPrm.chMod = mncc_sync_ind -> chm.ch_mode; + ccShrdPrm.chType = mncc_sync_ind -> chm.ch_type; + ccShrdPrm.TCHasg = TRUE; + } + + if ( ccShrdPrm.aocRsmpPend AND + (ccShrdPrm.chMod EQ CHM_SPEECH) OR + (ccShrdPrm.chMod EQ CHM_SPEECH_V2) OR + (ccShrdPrm.chMod EQ CHM_SPEECH_V3) ) + { + ccShrdPrm.aocRsmpPend = 0; + for( cId = 0; cId < MAX_CALL_NR; cId++ ) + aoc_info (cId, AOC_RESUME_AOC); + } + +if( mncc_sync_ind -> chm.ch_mode NEQ NOT_PRESENT_8BIT ) + { + /* service a pending alert */ + for( cId = 0; cId < MAX_CALL_NR; cId++ ) + { + if (ccShrdPrm.ctb[cId] NEQ NULL) + { + psaCC_ctb(cId)->curCs = mncc_sync_ind -> cause; + + if( psaCC_ctb(cId)->alrtStat EQ AS_PND AND + psaCC_ctb(cId)->calStat EQ CS_ACT_REQ ) + { + { + /* indicate alerting to network */ + PALLOC (mncc_alert_req, MNCC_ALERT_REQ); + mncc_alert_req -> ti = psaCC_ctb(cId)->ti; + PSENDX (CC, mncc_alert_req); + psaCC_ctb(cId)->alrtStat = AS_SND; + } + cmhCC_IncomingCall (cId); /* indicate an incoming call */ + } + if (psaCC_ctb(cId)->calStat NEQ CS_HLD AND + psaCC_ctb(cId)->calStat NEQ CS_IDL) + { + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_TCH ); + } + } + } + } +psaCC_setSpeechMode (); + + /* Remember cause for Call Reestablishment*/ + + if (mncc_sync_ind -> cause EQ MNCC_CAUSE_REEST_FINISHED + OR mncc_sync_ind -> cause EQ MNCC_CAUSE_REEST_STARTED) + { + for( cId = 0; cId < MAX_CALL_NR; cId++ ) + { + if (ccShrdPrm.ctb[cId] NEQ NULL) + { + psaCC_ctb(cId)->curCs = mncc_sync_ind -> cause; + } + } + } + + cId = psaCC_ctbFindTi( mncc_sync_ind -> ti ); + + /* For channel synchronization events the cId needs not to be valid here */ + cmhCC_Synchronized( cId ); + + + /* free the primitive buffer */ + PFREE (mncc_sync_ind); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_user_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_USER_IND primitive send by CC. + this indicates the receiving of user data. +*/ + +GLOBAL const void psa_mncc_user_ind( T_MNCC_USER_IND *mncc_user_ind ) +{ + TRACE_FUNCTION ("psa_mncc_user_ind()"); + + PFREE (mncc_user_ind); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_start_dtmf_cnf | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_START_DTMF_CNF primitive send by CC. + this is a confirmation for the sent DTMF tones. + +*/ + +GLOBAL const void psa_mncc_start_dtmf_cnf + ( T_MNCC_START_DTMF_CNF *mncc_start_dtmf_cnf ) +{ + SHORT cId; /* holds call id */ + + TRACE_FUNCTION ("psa_mncc_start_dtmf_cnf()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_start_dtmf_cnf -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_start_dtmf_cnf); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + psaCC_ctb(cId)->nrmCs = mncc_start_dtmf_cnf -> cause; + if ((mncc_start_dtmf_cnf->cause EQ MNCC_CAUSE_DTMF_STOP_SUCCESS) AND + (mncc_start_dtmf_cnf->dtmf_mod EQ DTMF_MOD_MAN_STOP)) + { + /* Reset the current dtmf digit */ + ccShrdPrm.dtmf.cur = 0; + } +#ifdef FF_EM_MODE + em_relcs = mncc_start_dtmf_cnf -> cause; +#endif /* FF_EM_MODE */ + + psaCC_DTMFSent( cId ); + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_start_dtmf_cnf); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_modify_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_MODIFY_IND primitive send by CC. + this indicates a mobile terminated in-call modification. + +*/ + +GLOBAL const void psa_mncc_modify_ind + ( T_MNCC_MODIFY_IND *mncc_modify_ind ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_modify_ind()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_modify_ind -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_modify_ind); + return; + } + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_PAUSE ); + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + + pCtbNtry -> curBC = (pCtbNtry -> curBC EQ 0)?1:0; + pCtbNtry -> rslt = MNCC_CAUSE_MODIFY_SUCCESS; /* SBK-02-07-30: possibly to be revised as strictly speaking ACI is orignating entity */ + + cmhCC_CallModified (cId); + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_START ); + + psaCC_StopDTMF ( cId ); +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_modify_ind); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_modify_cnf | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_MODIFY_CNF primitive send by CC. + this indicates the result for a mobile originated in-call + modification. + +*/ + +GLOBAL const void psa_mncc_modify_cnf + ( T_MNCC_MODIFY_CNF *mncc_modify_cnf ) +{ + SHORT cId; /* holds call id */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_modify_cnf()"); + +/* + *------------------------------------------------------------------- + * find call in call table + *------------------------------------------------------------------- + */ + cId = psaCC_ctbFindTi( mncc_modify_cnf -> ti ); + + if( cId < 0 ) + { + /* + * ignore primitive, due to not found transaction identifier. + */ + TRACE_EVENT ("primitive rejected due to unused ti"); + PFREE(mncc_modify_cnf); + return; + } + +/* + *------------------------------------------------------------------- + * update shared parameter and notify ACI + *------------------------------------------------------------------- + */ + pCtbNtry = ccShrdPrm.ctb[cId]; + + pCtbNtry -> rslt = mncc_modify_cnf -> cause; + + switch( mncc_modify_cnf -> cause ) + { + case( MNCC_CAUSE_MODIFY_SUCCESS ): /* successful modification */ + + pCtbNtry -> curBC = (pCtbNtry -> curBC EQ 0)?1:0; + break; + + default: /* unsuccessful modification */ + + ccShrdPrm.cIdFail = cId; + break; + } + psaCC_ctb(cId)->calStat = CS_ACT; + + cmhCC_CallModified (cId); + + /* check for TTY service */ + cmhCC_TTY_Control ( cId, TTY_START ); + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_modify_cnf); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_bearer_cap_cnf | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_BEARER_CAP_CNF primitive send by CC. + this is the result of the requested bearer coding/decoding. + +*/ + +GLOBAL const void psa_mncc_bearer_cap_cnf + ( T_MNCC_BEARER_CAP_CNF *mncc_bearer_cap_cnf ) +{ + + TRACE_FUNCTION ("psa_mncc_bearer_cap_cnf()"); + +/* + *------------------------------------------------------------------- + * determine request id + *------------------------------------------------------------------- + */ + switch( mncc_bearer_cap_cnf -> req_id ) + { + +#ifdef SIM_TOOLKIT + + case( BCRI_SAT ): + + switch( mncc_bearer_cap_cnf -> bc_mod ) + { + case( BC_MOD_CODE ): + + cmhSAT_ResCapCode ( mncc_bearer_cap_cnf -> cause, + &mncc_bearer_cap_cnf -> bcconf ); + break; + + case( BC_MOD_DECODE ): + + cmhSAT_ResCapDecode ( mncc_bearer_cap_cnf -> cause, + &mncc_bearer_cap_cnf -> bcpara ); + break; + } + break; + +#endif + } + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_bearer_cap_cnf); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_prompt_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_PROMPT_IND primitive send by CC. + this requests a transaction identifier for a CCBS recall. + +*/ + +GLOBAL const void psa_mncc_prompt_ind + ( T_MNCC_PROMPT_IND *mncc_prompt_ind ) +{ + SHORT ti; + + TRACE_FUNCTION ("psa_mncc_prompt_ind()"); + +/* + *------------------------------------------------------------------- + * allocate transaction identifier + *------------------------------------------------------------------- + */ + ti = psaCC_getMOCTi( -1 ); + + if( ti NEQ -1 ) + { + PALLOC (mncc_prompt_rsp, MNCC_PROMPT_RSP); + mncc_prompt_rsp -> ti = (UBYTE)ti; + PSENDX (CC, mncc_prompt_rsp); + } + else + { + PALLOC (mncc_prompt_rej, MNCC_PROMPT_REJ); + PSENDX (CC, mncc_prompt_rej); + } + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_prompt_ind); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_recall_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_RECALL_IND primitive send by CC. + this indicates a recall attempt from the network in case + of CCBS. + +*/ + +GLOBAL const void psa_mncc_recall_ind + ( T_MNCC_RECALL_IND *mncc_recall_ind ) +{ + SHORT cId; /* holds call table identifier */ + T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ + + TRACE_FUNCTION ("psa_mncc_recall_ind()"); + +/* + *------------------------------------------------------------------- + * check for K.O. criteria + *------------------------------------------------------------------- + */ + if( aoc_check_moc() EQ FALSE ) + { + PALLOC (mncc_reject_req, MNCC_REJECT_REQ); + + mncc_reject_req -> ti = mncc_recall_ind -> ti; + mncc_reject_req -> cause = MNCC_CAUSE_ACM_MAX; + + PSENDX (CC, mncc_reject_req); + } + + else if((cId = psaCC_ctbNewEntry()) < 0 ) + { + PALLOC (mncc_reject_req, MNCC_REJECT_REQ); + + mncc_reject_req -> ti = mncc_recall_ind -> ti; + mncc_reject_req -> cause = MNCC_CAUSE_USER_BUSY; + + PSENDX (CC, mncc_reject_req); + } + +/* + *------------------------------------------------------------------- + * insert recall parameters into call table entry + *------------------------------------------------------------------- + */ + else + { + pCtbNtry = ccShrdPrm.ctb[cId]; + + pCtbNtry -> ti = mncc_recall_ind -> ti; + pCtbNtry -> rptInd = mncc_recall_ind -> ri; + + /* + * Assign called party + */ + pCtbNtry -> cldPty.ton = mncc_recall_ind -> called_party.ton; + pCtbNtry -> cldPty.npi = mncc_recall_ind -> called_party.npi; + pCtbNtry -> cldPty.c_called_num = + mncc_recall_ind -> called_party.c_called_num; + if (pCtbNtry -> cldPty.called_num NEQ NULL) + { + ACI_MFREE (pCtbNtry -> cldPty.called_num); + pCtbNtry -> cldPty.called_num = NULL; + } + if (pCtbNtry -> cldPty.c_called_num NEQ 0) + { + ACI_MALLOC (pCtbNtry -> cldPty.called_num, + pCtbNtry -> cldPty.c_called_num); + memcpy (pCtbNtry -> cldPty.called_num, + mncc_recall_ind -> called_party.called_num, + mncc_recall_ind -> called_party.c_called_num); + } + + /* + * Assign called party subaddress + */ + pCtbNtry -> cldPtySub = mncc_recall_ind -> called_party_sub; + + /* + * Assign bearer caps + */ + memcpy( &(pCtbNtry->BC[0]),&(mncc_recall_ind->bcpara), + sizeof( T_bcpara) ); + memcpy( &(pCtbNtry->BC[1]),&(mncc_recall_ind->bcpara2), + sizeof( T_bcpara) ); + + psaCC_phbSrchNum( cId, CT_NI_MOC ); + + pCtbNtry -> calStat = CS_ACT_REQ; + pCtbNtry -> calType = CT_NI_MOC; + + pCtbNtry -> prio = PRIO_NORM_CALL; + pCtbNtry -> curBC = 0; + + } + +/* + *------------------------------------------------------------------- + * free the primitive buffer + *------------------------------------------------------------------- + */ + PFREE (mncc_recall_ind); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_status_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_STATUS_IND primitive sent by CC. + This indicates that a STATUS ENQUIRY message has been + received by CC, the network awaits a CC STATUS message. + Used to ensure that the auxiliary states between ACI and + CC were synchronized before the STATUS message is sent. + +*/ + +GLOBAL const void psa_mncc_status_ind (T_MNCC_STATUS_IND *mncc_status_ind) +{ + UBYTE ti; + + TRACE_FUNCTION ("psa_mncc_status_ind()"); + + ti = mncc_status_ind->ti; + + { + PREUSE (mncc_status_ind, mncc_status_res, MNCC_STATUS_RES); + mncc_status_res->ti = ti; + PSENDX (CC, mncc_status_res); + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : PSA_CCP | +| ROUTINE : psa_mncc_facility_ind | ++-------------------------------------------------------------------+ + + PURPOSE : processes the MNCC_FACILITY_IND primitive send by CC. + this indicates the receiving of a facility information + element. Handles multiple components in the facility info. + +*/ + +GLOBAL const void psa_mncc_facility_ind(T_MNCC_FACILITY_IND * mncc_facility_ind) +{ + UBYTE tlen = 0; + USHORT offset_comp = 0, total_len = mncc_facility_ind->fac_inf.l_fac/8; + UBYTE len_comp = 0; + UBYTE *tPtrfac = mncc_facility_ind->fac_inf.fac; + + TRACE_FUNCTION ("psa_mncc_facility_ind()"); + + if (tPtrfac[1] > 0x7F)/* For the case, when length is coded in non-standard way (0x80, 0x81, 0x82) we will be able to process only one component */ + { + psaCC_ProcessCmp((T_MNCC_FACILITY_IND *)mncc_facility_ind); + return; + } + + offset_comp = mncc_facility_ind->fac_inf.o_fac; + len_comp = tlen = tPtrfac[1] + 2; + + for ( ; total_len >= len_comp; len_comp+=tlen) + { + if ((*tPtrfac EQ 0xA1) OR + (*tPtrfac EQ 0xA2) OR + (*tPtrfac EQ 0xA3) OR + (*tPtrfac EQ 0xA4)) + { + PALLOC(new_mncc_facility_ind, MNCC_FACILITY_IND); + + new_mncc_facility_ind->ti = mncc_facility_ind->ti; + new_mncc_facility_ind->fac_context = mncc_facility_ind->fac_context; + new_mncc_facility_ind->fac_inf.l_fac = tlen * 8; + new_mncc_facility_ind->fac_inf.o_fac = offset_comp; + memcpy(new_mncc_facility_ind->fac_inf.fac, tPtrfac, tlen); + + psaCC_ProcessCmp((T_MNCC_FACILITY_IND *)new_mncc_facility_ind); + + tPtrfac = tPtrfac + tlen; + tlen = tPtrfac[1] + 2; + offset_comp = 0; + } + } + + PFREE(mncc_facility_ind); +} + +/*==== EOF =========================================================*/