FreeCalypso > hg > fc-magnetite
view src/aci2/aci/cmh_satr.c @ 640:16eb1b9640dc
target gtm900 renamed to gtm900mgc2
This change reflects the fact that the build target in question supports
MGC2GSMT hardware only, and will NOT work on other hw that confusing bears
the same end user name of GTM900, neither the LoCosto-based GTM900-C
nor the Calypso-based MG01GSMT that has a different and incompatible RFFE.
If we ever get our hands on a piece of MG01GSMT hw and add support for it,
that other target will be named gtm900mg01.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Fri, 31 Jan 2020 00:46:07 +0000 |
parents | 93999a60b835 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GSM-PS (6147) | Modul : CMH_SATR +----------------------------------------------------------------------------- | 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 functions which are responsible | for the responses of the protocol stack adapter for | the SIM application toolkit. +----------------------------------------------------------------------------- */ #ifdef SIM_TOOLKIT #ifndef CMH_SATR_C #define CMH_SATR_C #endif #include "aci_all.h" /*==== INCLUDES ===================================================*/ #include "aci_cmh.h" #include "aci_mem.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_sat.h" #include "psa_sim.h" /* for simShrdPrm declaration */ #include "psa_sms.h" #include "psa_util.h" #include "cmh.h" #include "cmh_cc.h" #include "cmh_sat.h" #include "cmh_sms.h" #include "aoc.h" #include "phb.h" #include "cmh_phb.h" #include "l4_tim.h" /*==== CONSTANTS ==================================================*/ /*==== TYPES ======================================================*/ /*==== EXPORT =====================================================*/ /*==== VARIABLES ==================================================*/ /*==== FUNCTIONS ==================================================*/ /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CMH_SATR | | STATE : code ROUTINE : cmhSAT_ModifyScaPdu | +--------------------------------------------------------------------+ PURPOSE : modifies the SCA in a SUBMIT PDU */ LOCAL void cmhSAT_ModifyScaPdu( T_sms_sdu *sms_sdu, UBYTE *sca_buf, UBYTE sca_len ) { UBYTE old_sca_len; UBYTE *rest; USHORT rest_len; UBYTE *old_sdu; UBYTE old_sdu_len; ACI_MALLOC(old_sdu, SIM_PDU_LEN); old_sdu_len = sms_sdu->l_buf/8; memcpy ( old_sdu, sms_sdu->buf, old_sdu_len ); old_sca_len = *old_sdu+1; rest = old_sdu + old_sca_len; rest_len = old_sdu_len - old_sca_len; /* copy new SCA */ memcpy(sms_sdu->buf, sca_buf, sca_len); /* copy the rest of the PDU */ memcpy(sms_sdu->buf+sca_len, rest, rest_len); /* set the length */ sms_sdu->l_buf = (sca_len+rest_len) * 8; ACI_MFREE(old_sdu); } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CMH_SATR | | STATE : code ROUTINE : cmhSAT_ModifyDaPdu | +--------------------------------------------------------------------+ PURPOSE : modifies the destination address in a SUBMIT PDU */ LOCAL void cmhSAT_ModifyDaPdu( T_sms_sdu *sms_sdu, UBYTE *da_buf, UBYTE da_len ) { UBYTE old_sca_len; UBYTE old_da_len; UBYTE *rest; USHORT rest_len; UBYTE *old_sdu; UBYTE *new_sdu; UBYTE old_sdu_len; ACI_MALLOC(old_sdu, SIM_PDU_LEN); old_sdu_len = sms_sdu->l_buf/8; memcpy ( old_sdu, sms_sdu->buf, old_sdu_len ); new_sdu = sms_sdu->buf; old_sca_len = *old_sdu+1; old_da_len = (*(old_sdu + old_sca_len + 2)+1)/2 + 2; rest = old_sdu + old_sca_len + 2 + old_da_len; rest_len = old_sdu_len - old_sca_len - 2 - old_da_len; /* copy old sca, fo, mr */ memcpy(new_sdu, old_sdu, old_sca_len+2); new_sdu += old_sca_len+2; /* copy the new DA */ memcpy(new_sdu, da_buf, da_len); new_sdu += da_len; /* copy the rest of the PDU */ memcpy(new_sdu, rest, rest_len); /* set the length */ sms_sdu->l_buf = (old_sca_len+2+da_len+rest_len) * 8; ACI_MFREE(old_sdu); } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH_SATR | | ROUTINE : cmhSAT_STKCmdCnf | +-------------------------------------------------------------------+ PURPOSE : STK command confirmation */ GLOBAL SHORT cmhSAT_STKCmdCnf ( void ) { TRACE_FUNCTION ("cmhSAT_STKCmdCnf()"); /* *------------------------------------------------------------------- * check for command context *------------------------------------------------------------------- */ switch( satEntStat.curCmd ) { case( AT_CMD_SATE ): /* *---------------------------------------------------------------- * process event for %SATE command *---------------------------------------------------------------- */ satEntStat.curCmd = AT_CMD_NONE; TRACE_EVENT_P1("SAT reponse with SIM cause: %d", satShrdPrm.stkError); switch (satShrdPrm.stkError) { case SIM_NO_ERROR: R_AT( RAT_SATE, satEntStat.entOwn ) ( satShrdPrm.stkCmdLen>>3, satShrdPrm.stkCmd ); R_AT( RAT_OK, satEntStat.entOwn ) ( AT_CMD_SATE ); break; case SIM_CAUSE_SAT_BUSY: R_AT( RAT_CME, satEntStat.entOwn ) ( AT_CMD_SATE, CME_ERR_SimSatBusy ); break; case SIM_CAUSE_PUK1_BLOCKED: R_AT( RAT_CME, satEntStat.entOwn ) ( AT_CMD_SATE, CME_ERR_SimFail ); break; default: R_AT( RAT_CME, satEntStat.entOwn ) ( AT_CMD_SATE, CME_ERR_Unknown ); break; } break; } return 0; } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH_SATR | | ROUTINE : cmhSAT_STKCmdInd | +-------------------------------------------------------------------+ PURPOSE : STK command indication */ GLOBAL SHORT cmhSAT_STKCmdInd ( void ) { SHORT idx; /* holds list index */ TRACE_FUNCTION ("cmhSAT_STKCmdInd()"); /* *---------------------------------------------------------------- * send unsolicited result *---------------------------------------------------------------- */ for( idx = 0; idx < CMD_SRC_MAX; idx++ ) { R_AT( RAT_SATI, idx ) ( satShrdPrm.stkCmdLen>>3, satShrdPrm.stkCmd ); } return 0; } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH_SATR | | ROUTINE : cmhSAT_Cust1StkCmdInd | +-------------------------------------------------------------------+ PURPOSE : Used for Sending the Origianl STK command indication to a Cust1 MMI, when performing Setup Call, Send SS, Send USSD or Send SMS */ GLOBAL SHORT cmhSAT_Cust1StkCmdInd ( void ) { SHORT idx; /* holds list index */ TRACE_FUNCTION ("cmhSAT_Cust1StkCmdInd()"); if (satShrdPrm.cust1StkCmd != (void *)0) { /* *---------------------------------------------------------------- * send %SATI the MMI with the Stk Cmd *---------------------------------------------------------------- */ for( idx = 0; idx < CMD_SRC_MAX; idx++ ) { R_AT( RAT_SATI, idx ) ( satShrdPrm.cust1StkCmdLen >>3, satShrdPrm.cust1StkCmd); } ACI_MFREE(satShrdPrm.cust1StkCmd); satShrdPrm.cust1StkCmd = (void *)0; satShrdPrm.cust1StkCmdLen = 0; } return 0; } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH_SATR | | ROUTINE : cmhSAT_STKUsrNtfy | +-------------------------------------------------------------------+ PURPOSE : STK user notification */ GLOBAL SHORT cmhSAT_STKUsrNtfy ( void ) { SHORT idx; /* holds list index */ T_ACI_SATN_CNTRL_TYPE cntrl_type = SATN_CNTRL_BY_SIM_Not_Present; TRACE_FUNCTION ("cmhSAT_STKUsrNtfy()"); /* *---------------------------------------------------------------- * determine user notification *---------------------------------------------------------------- */ switch( satShrdPrm.ntfy ) { case( USR_NTF_CC_SIM ): if (simShrdPrm.overall_cust_mode EQ CUST_MODE_BEHAVIOUR_1) { switch (satShrdPrm.SIMCCParm.ccAct) { case CC_ACT_CAL: cntrl_type = SATN_CNTRL_BY_SIM_CALL; break ; case CC_ACT_SS: cntrl_type = SATN_CNTRL_BY_SIM_SS; break ; case CC_ACT_USSD: cntrl_type = SATN_CNTRL_BY_SIM_USSD; break ; case SMC_ACT_MO: cntrl_type = SATN_CNTRL_BY_SIM_SMS; break ; default: cntrl_type = SATN_CNTRL_BY_SIM_Not_Present; } } if(psa_IsVldOwnId(satShrdPrm.owner) AND satShrdPrm.owner NEQ NO_VLD_OWN ) { R_AT( RAT_SATN, satShrdPrm.owner ) ( satShrdPrm.stkCmdLen>>3, satShrdPrm.stkCmd, cntrl_type ); break; } /* otherwise continue, no break */ /*lint -fallthrough*/ default: for( idx = 0; idx < CMD_SRC_MAX; idx++ ) { if( idx NEQ satShrdPrm.run_at_id ) { /* don't notify SAT itself over run at channel */ R_AT( RAT_SATN, idx ) ( satShrdPrm.stkCmdLen>>3, satShrdPrm.stkCmd, cntrl_type ); } } } return 0; } LOCAL void send_error_to_user( BOOL ownNotSAT, UBYTE command, UBYTE result, UBYTE additional_result, UBYTE *resId, BOOL satopc ) { T_ACI_SAT_TERM_RESP resp_data; psaSAT_InitTrmResp( &resp_data ); if( ownNotSAT ) { /* setup initiated by user */ R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner ) ( command, CME_ERR_NotPresent ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, command, -1, -1, CME_ERR_NotPresent ); return; } /* setup initiated by SAT */ /* send SAT response */ resp_data.add_content = additional_result; /* if source was open channel command */ #ifdef FF_SAT_E if(satopc) { if( satShrdPrm.opchStat EQ OPCH_CCSIM_REQ ) { cmhSAT_OpChnFailed( result, &resp_data ); return; } } #endif /* FF_SAT_E */ if( resId NEQ NULL ) { resp_data.resCC = resId; } psaSAT_SendTrmResp( result, &resp_data ); } /* return TRUE if key sequence accepted, FALSE otherwise */ LOCAL BOOL sim_control_send_ss( T_CLPTY_PRM *ss_clpty, UBYTE command, BOOL ownNotSAT, UBYTE *resCC ) { T_ACI_RETURN retVal; /* holds return value */ T_ACI_D_CLIR_OVRD dummy2; /* dummy value */ T_ACI_D_TOC dummy1; /* dummy value */ /* check for busy SS condition */ if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY ) { /* NOTE: shouldn't that be: send_error_to_user( ownNotSAT, RSLT_CC_SIM_PRM, ADD_ME_SS_BUSY, resCC, FALSE); or send_error_to_user( ownNotSAT, RSLT_CC_SIM_PRM, RSLT_ME_CAP, resCC, FALSE); ??*/ send_error_to_user( ownNotSAT, command, RSLT_ME_UNAB_PROC, ADD_ME_SS_BUSY, resCC, FALSE); return FALSE; } /* send SS control string */ retVal = cmhCC_chkKeySeq ( satShrdPrm.SIMCCParm.owner, ss_clpty, &dummy1, &dummy2, CC_SIM_NO ); if( retVal NEQ AT_EXCT ) { /* string is not SS: terminate with error */ send_error_to_user( ownNotSAT, command, RSLT_CC_SIM_PRM, RSLT_ME_CAP, resCC, FALSE); return(FALSE); } else { #ifdef FF_SAT_E if(!ownNotSAT AND satShrdPrm.opchStat EQ OPCH_CCSIM_REQ ) { return( FALSE ); } #endif /* FF_SAT_E */ return(TRUE); } } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH_SATR | | ROUTINE : cmhSAT_ResCalCntrlBySIM | +-------------------------------------------------------------------+ PURPOSE : Handle SIM call control result. Return TRUE if primitive is needed for building a terminal response. */ LOCAL BOOL cmhSAT_result_sim_cc_ss( SHORT cId, UBYTE *resId, T_ccr_allw *ccr ) { T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId]; T_ACI_SAT_TERM_RESP resp_data; BOOL ownNotSAT = (satShrdPrm.SIMCCParm.owner NEQ OWN_SAT); /* flags that the owner is not SAT */ UBYTE cmdBuf; /* buffer command */ TRACE_FUNCTION("cmhSAT_result_sim_cc_ss()"); psaSAT_InitTrmResp( &resp_data ); #ifdef FF_SAT_E /* check for a pending OPEN CHANNEL command */ if (ctb->calStat EQ CS_SAT_CSD_REQ) { /* free ctb entry */ psaCC_FreeCtbNtry (cId); /* respond with "error, Interaction with CC by SIM, perm problem" */ resp_data.add_content = ADD_CC_REQ_CHNG; resp_data.chnStat = TRUE; cmhSAT_OpChnFailed( RSLT_CC_SIM_PRM, &resp_data ); return( FALSE ); } #endif /* FF_SAT_E */ cmdBuf = ctb->curCmd; psaCC_FreeCtbNtry (cId); cmhCC_init_cldPty( &satPndSetup.clpty ); utl_BCD2DialStr( ccr->ss_string.ss_ctrl_string, satPndSetup.clpty.num, (UBYTE)MINIMUM(ccr->ss_string.c_ss_ctrl_string, MAX_DIAL_LEN-1)); satPndSetup.clpty.ton = ccr->ss_string.noa; satPndSetup.clpty.npi = ccr->ss_string.npi; if( sim_control_send_ss( &satPndSetup.clpty, cmdBuf, ownNotSAT, resId ) ) return( !ownNotSAT ); return( FALSE ); /* primitive not needed anymore */ } LOCAL void cmhSAT_result_sim_cc_address( SHORT cId, T_ccr_allw *ccr ) { TRACE_FUNCTION("cmhSAT_result_sim_cc_address()"); /* adjust called address */ cmhSAT_fillSetupPrm ( cId, &ccr->addr, ((ccr->v_subaddr)?&ccr->subaddr:NULL)); #ifdef FF_SAT_E if( psaCC_ctb(cId)->calStat NEQ CS_SAT_CSD_REQ ) #endif /* FF_SAT_E */ { /* new call table entry set default bearer capabilities */ cmhSAT_fillSetupBC ( cId, BEARER_SERV_SPEECH, BEARER_SERV_NOT_PRES ); } /* adjust bearer capabilities */ if( ccr->v_cap_cnf_parms ) { /* CCP not supported yet */ /* satShrdPrm.ntfy = USR_NTF_SETUP_CAL; satShrdPrm.capParm.cId = cId; satShrdPrm.capParm.cntxt = CTX_SAT_SETUP; satShrdPrm.capParm.CCres = *resId; if( psaCC_BCapDecode( BCRI_SAT, ccr->cap_cnf_parms.l_cap_cnf_parms>>3, ccr->cap_cnf_parms.b_cap_cnf_parms ) < 0 ) { psaSAT_SendTrmResp( RSLT_ME_CAP, 0, NULL, NULL, NULL ); psaCC_FreeCtbNtry (cId); return( FALSE ); } else { return( *resId EQ CCR_ALLW_WITH_MDFY ); } */ } } LOCAL BOOL cmhSAT_result_sim_cc_ussd( SHORT cId, UBYTE *resId, T_ccr_allw *ccr ) { T_ACI_SAT_TERM_RESP resp_data; BOOL ownNotSAT = (satShrdPrm.SIMCCParm.owner NEQ OWN_SAT); /* flags that the owner is not SAT */ UBYTE cmdBuf; /* buffer command */ UBYTE len = 0; T_ACI_RETURN retVal; T_ACI_D_TOC dummy1; T_ACI_D_CLIR_OVRD dummy2; TRACE_FUNCTION("cmhSAT_result_sim_cc_ussd()"); psaSAT_InitTrmResp( &resp_data ); /* check for busy SS condition */ if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY ) { /* respond with "error, ME currently unable to process command" */ resp_data.add_content = ADD_ME_SS_BUSY; resp_data.resCC = resId; psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); return( FALSE ); } /* call adr to be modified with USSD string*/ cmdBuf = psaCC_ctb(cId)->curCmd; psaCC_FreeCtbNtry (cId); if( utl_getAlphabetCb( (UBYTE) ccr->ussd_string.dcs) EQ 0 ) /* 7bit alphabet */ { len=utl_cvt7To8( ccr->ussd_string.ussd_str, ccr->ussd_string.c_ussd_str, (UBYTE*)&satPndSetup.clpty.num, 0); satPndSetup.clpty.num[len]=0x00; } else { memcpy( satPndSetup.clpty.num, ccr->ussd_string.ussd_str, ccr->ussd_string.c_ussd_str ); satPndSetup.clpty.num[ccr->ussd_string.c_ussd_str]=0x00; } retVal = cmhCC_chkKeySeq ( satShrdPrm.SIMCCParm.owner, &satPndSetup.clpty, &dummy1, &dummy2, CC_SIM_NO ); if( retVal EQ AT_EXCT ) { return( !ownNotSAT ); } if( ownNotSAT ) { R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner ) ( cmdBuf, CME_ERR_NotPresent ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, cmdBuf, -1, -1, CME_ERR_NotPresent ); } /* setup initiated by SAT */ else { /* send SAT response */ resp_data.resCC = resId; psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); } return( FALSE ); /* primitive not needed anymore */ } GLOBAL BOOL cmhSAT_ResCalCntrlBySIM( UBYTE* resId, void *ccRes ) { UBYTE cmdBuf; /* buffer command */ SHORT cId = satShrdPrm.SIMCCParm.cId; /* holds setup call id */ SHORT actId; /* holds active call id */ T_ccr_allw * ccr; /* points to CC result */ BOOL ownNotSAT; /* flags that the owner is not SAT */ UBYTE idx; /* holds index */ T_ACI_SAT_TERM_RESP resp_data; #if defined SMI OR defined MFW T_ACI_CLOG cmdLog; /* holds logging info */ CHAR cmdlog_num_buf[MAX_CC_CALLED_NUMBER]; /* buffer where number is written for cmdLog */ USHORT length; /* length of number */ #endif TRACE_FUNCTION("cmhSAT_ResCalCntrlBySIM()"); psaSAT_InitTrmResp( &resp_data ); ccr = (T_ccr_allw*)ccRes; /* check if queued event download */ if (satShrdPrm.event.c_queued) { cmhSAT_EventDwn( -1, -1, -1); } satShrdPrm.SIMCCParm.busy = FALSE; if (!psaCC_ctbIsValid (cId)) { TRACE_ERROR ("Call table entry disappeared"); return FALSE; } ownNotSAT = satShrdPrm.SIMCCParm.owner NEQ OWN_SAT; /* ** If this is a Cust1 MMI and The originator was a STK Cmd */ if ((simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) AND (ownNotSAT == FALSE)) { /* ** Customised behaviour for the Cust1 MMI */ if (*resId == CCR_NOT_ALLW) { /* Call Setup not allowed */ send_error_to_user( ownNotSAT, psaCC_ctb(cId)->curCmd, RSLT_CC_SIM_PRM, ADD_CC_NOT_ALLWD, NULL, TRUE); } else { /* ** This was a SAT initiated call. For the Cust1 the ACI does not yet have any ** actions to perform, other than the CC By SIM which has been done. So : ** Send the Original STK Cmd to the MMI in a %SATI for the MMI to process. ** ** The second action will cause the MMI to request the approriate Call Setup, SS ** or USSD Request and the required Call Table entry will then be re-created. */ cmhSAT_Cust1StkCmdInd(); } /* Free the Call Table Entry ** The SATI indication (if sent) will cause the MMI to request the approriate Call Setup, SS ** or USSD Request and the required Call Table entry will then be re-created. */ psaCC_FreeCtbNtry (cId); return( FALSE ); /* primitive not needed anymore */ } /* determine result id */ switch( *resId ) { case( CCR_NOT_ALLW ): /* call setup not allowed */ send_error_to_user( ownNotSAT, psaCC_ctb(cId)->curCmd, RSLT_CC_SIM_PRM, ADD_CC_NOT_ALLWD, NULL, TRUE); /* memory for number has also been allocated in case of SAT setup call !! */ psaCC_FreeCtbNtry (cId); return( FALSE ); /* primitive not needed anymore */ case( CCR_ALLW_WITH_MDFY ): /* call setup allowed with modification */ if( ccr->v_ss_string ) { /* if setup was converted into a SS control string */ return(cmhSAT_result_sim_cc_ss( cId, resId, ccr )); } else if( ccr->v_addr ) { /* Replace call parameters for this cId with the ones provided by SIM */ cmhSAT_result_sim_cc_address( cId, ccr ); } else if (ccr->v_ussd_string) { /* if setup was converted into a USSD control string */ return(cmhSAT_result_sim_cc_ussd( cId, resId, ccr )); } else {} /* do not change cId parameters */ break; case( CCR_ALLW_NO_MDFY ): /* call setup allowed no modification */ /* use parameters already linked to cId */ break; } /* perform call setup initiated by user */ if( ownNotSAT ) { /* check for an active call */ actId = psaCC_ctbFindCall( NO_VLD_OWN, CS_ACT, NO_VLD_CT ); if( actId NEQ NO_ENTRY ) { /* put active on hold if possible */ if( psaCC_ctb(actId)->prio EQ PRIO_NORM_CALL AND cmhCC_getcalltype(actId) EQ VOICE_CALL ) { cmhCC_HoldCall(actId, psaCC_ctb(cId)->curSrc, AT_CMD_D); } /* reject call setup: already data or emergency call on going */ else { cmdBuf = psaCC_ctb(cId)->curCmd; psaCC_FreeCtbNtry (cId); R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner ) ( cmdBuf, CME_ERR_NotPresent ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, cmdBuf, -1, -1, CME_ERR_NotPresent ); return( FALSE ); /* primitive not needed anymore */ } } /* finally set up call */ cmhCC_flagCall( cId, &(cmhPrm[psaCC_ctb(cId)->calOwn].ccCmdPrm.mltyCncFlg)); psaCC_NewCall (cId); #if defined SMI OR defined MFW /* log command */ cmdLog.atCmd = AT_CMD_D; cmdLog.cmdType = CLOG_TYPE_Set; cmdLog.retCode = AT_EXCT; cmdLog.cId = cId+1; cmdLog.sId = ACI_NumParmNotPresent; cmdLog.cmdPrm.sD.srcId = psaCC_ctb(cId)->curSrc; cmdLog.cmdPrm.sD.number = cmdlog_num_buf; /* * For this block wrong code is generated by target compiler 1.22e * Use psaCC_ctb() to simplify pointer expression. */ #if 0 if(ccShrdPrm.ctb[cId]->cldPty.c_called_num < MAX_CC_CALLED_NUMBER) { length = ccShrdPrm.ctb[cId]->cldPty.c_called_num; } else length = MAX_CC_CALLED_NUMBER; utl_BCD2String( cmdLog.cmdPrm.sD.number, (UBYTE *) ccShrdPrm.ctb[cId]->cldPty.called_num, length); #else if(psaCC_ctb(cId)->cldPty.c_called_num < MAX_CC_CALLED_NUMBER) { length = psaCC_ctb(cId)->cldPty.c_called_num; } else length = MAX_CC_CALLED_NUMBER; utl_BCD2String (cmdLog.cmdPrm.sD.number, psaCC_ctb(cId)->cldPty.called_num, length); #endif /* else, #if 0 */ cmdLog.cmdPrm.sD.clirOvrd = D_CLIR_OVRD_Default; /* ??? */ cmdLog.cmdPrm.sD.cugCtrl = D_CUG_CTRL_NotPresent; /* ??? */ cmdLog.cmdPrm.sD.callType = psaCC_ctb(cId)->calType; #ifdef SIM_TOOLKIT cmdLog.cmdPrm.sD.simCallCtrl= D_SIMCC_ACTIVE; #endif /* SIM tOOLKIT */ rAT_PercentCLOG( &cmdLog ); #endif /* SMI or MFW */ return( FALSE ); } /* perform call setup initiated by SAT */ else /* Must be normal behaviour, otherwise it would have been trapped earlier in the function */ { #ifdef FF_SAT_E /* if source was open channel command */ if( satShrdPrm.opchStat EQ OPCH_CCSIM_REQ ) { if(*resId EQ CCR_ALLW_WITH_MDFY) satShrdPrm.opchCCMdfy = TRUE; cmhSAT_OpChnAlert( cId ); return( FALSE ); } #endif /* FF_SAT_E */ /* alert user if command details are supported */ if( cmhSAT_ChckCmdDet() ) { /* check aoc condition */ if ((psaCC_ctb(cId)->prio EQ PRIO_NORM_CALL) AND (aoc_check_moc() EQ FALSE)) /* * check ACM exceeds ACMmax * for non-emergency calls */ { resp_data.add_content = ADD_NO_CAUSE; resp_data.resCC = (*resId EQ CCR_ALLW_WITH_MDFY)? resId: NULL; psaSAT_SendTrmResp(RSLT_ME_UNAB_PROC, &resp_data); psaCC_FreeCtbNtry (cId); return( FALSE ); } for( idx = 0; idx < CMD_SRC_MAX; idx++ ) { #ifdef FF_SAT_E T_ACI_SATA_ADD addPrm; addPrm.chnType = SATA_CT_VOICE; addPrm.chnEst = SATA_EST_IM; R_AT( RAT_SATA, idx )( cId+1, satShrdPrm.dur, &addPrm ); #else R_AT( RAT_SATA, idx )( cId+1, satShrdPrm.dur ); #endif /* FF_SAT_E */ } satShrdPrm.ntfy = USR_NTF_SETUP_CAL; } return( FALSE ); } } LOCAL BOOL sim_control_setup_call( T_ccr_allw *ccr, BOOL ownNotSAT ) { SHORT cId = satShrdPrm.SIMCCParm.cId; /* holds setup call id */ UBYTE idx; /* holds index */ #ifdef FF_SAT_E T_ACI_SATA_ADD addPrm; #endif /* FF_SAT_E */ cId = psaCC_ctbNewEntry(); if( cId EQ NO_ENTRY ) { send_error_to_user( ownNotSAT, AT_CMD_D, RSLT_ME_UNAB_PROC, ADD_NO_CAUSE, NULL, FALSE); return( FALSE ); /* primitive not needed anymore */ } /* fill in setup parameter for called address */ cmhSAT_fillSetupPrm ( cId, ((ccr->v_addr)?&ccr->addr:NULL), ((ccr->v_subaddr)?&ccr->subaddr:NULL)); /* new call table entry set default bearer capabilities */ cmhSAT_fillSetupBC ( cId, BEARER_SERV_SPEECH, BEARER_SERV_NOT_PRES ); /* check aoc condition */ if ((psaCC_ctb(cId)->prio EQ PRIO_NORM_CALL) AND (aoc_check_moc() EQ FALSE)) /* check ACM exceeds ACMmax for non-emergency calls */ { send_error_to_user( ownNotSAT, AT_CMD_D, RSLT_ME_UNAB_PROC, ADD_NO_CAUSE, NULL, FALSE); psaCC_FreeCtbNtry (cId); return( FALSE ); } if( ccr->v_cap_cnf_parms ) { /* check bearer caps, ctb not allocated */ } /* declare call table entry as used and the owner and status of the call */ psaCC_ctb(cId)->calOwn = satShrdPrm.SIMCCParm.owner; psaCC_ctb(cId)->calStat = CS_SAT_REQ; psaCC_ctb(cId)->curCmd = AT_CMD_D; psaCC_ctb(cId)->curSrc = satShrdPrm.SIMCCParm.owner; if( !ownNotSAT ) psaCC_ctb(cId)->SATinv = TRUE; /* alert user */ if( ownNotSAT ) { #ifdef FF_SAT_E addPrm.chnType = SATA_CT_VOICE; addPrm.chnEst = SATA_EST_IM; R_AT( RAT_SATA, satShrdPrm.SIMCCParm.owner ) ( cId+1, satShrdPrm.dur, &addPrm ); #else R_AT( RAT_SATA, satShrdPrm.SIMCCParm.owner ) ( cId+1, satShrdPrm.dur); #endif /* FF_SAT_E */ R_AT( RAT_OK, satShrdPrm.SIMCCParm.owner ) ( AT_CMD_D ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_OK, AT_CMD_D, -1, -1, -1 ); } /* setup initiated by SAT */ else { for( idx = 0; idx < CMD_SRC_MAX; idx++ ) { #ifdef FF_SAT_E addPrm.chnType = SATA_CT_VOICE; addPrm.chnEst = SATA_EST_IM; R_AT( RAT_SATA, idx ) ( cId+1, satShrdPrm.dur, &addPrm ); #else R_AT( RAT_SATA, idx ) ( cId+1, satShrdPrm.dur); #endif /* FF_SAT_E */ } } return( !ownNotSAT ); } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH_SATR | | ROUTINE : cmhSAT_ResSSCntrlBySIM | +-------------------------------------------------------------------+ PURPOSE : Handle SIM SS control result. Return TRUE if primitive is needed for building a terminal response. */ GLOBAL BOOL cmhSAT_ResSSCntrlBySIM( UBYTE* resId, void *ccRes ) { SHORT cId = satShrdPrm.SIMCCParm.cId; /* holds setup call id */ T_ccr_allw * ccr; /* points to CC result */ BOOL ownNotSAT; /* flags that the owner is not SAT */ TRACE_FUNCTION("cmhSAT_ResSSCntrlBySIM()"); ccr = (T_ccr_allw*)ccRes; /* check if queued event download */ if (satShrdPrm.event.c_queued) { cmhSAT_EventDwn( -1, -1, -1); } satShrdPrm.SIMCCParm.busy = FALSE; ownNotSAT = satShrdPrm.SIMCCParm.owner NEQ OWN_SAT; /* ** If this is a Cust1 MMI and The originator was a STK Cmd */ if ((simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) AND (ownNotSAT == FALSE)) { /* ** Customised behaviour for the Cust1 MMI */ if (*resId == CCR_NOT_ALLW) { send_error_to_user( ownNotSAT, AT_CMD_D, RSLT_CC_SIM_PRM, ADD_CC_NOT_ALLWD, NULL, FALSE); } else { /* ** This was a SAT initiated Request. For the Cust1 the ACI does not yet have any ** actions to perform, other than the CC By SIM which has been done. So : ** Send the Original STK Cmd to the MMI in a %SATI for the MMI to process. ** ** The second action will cause the MMI to request the approriate Call Setup, SS ** or USSD Request and the required Call Table entry will then be re-created. */ cmhSAT_Cust1StkCmdInd(); } /* Free the Call Table Entry ** The SATI indication (if sent) will cause the MMI to request the approriate Call Setup, SS ** or USSD Request and the required Call Table entry will then be re-created. */ if (psaCC_ctbIsValid (cId)) { psaCC_retMOCTi(psaCC_ctb(cId)->ti); psaCC_chngCalTypCnt(cId, -1); psaCC_FreeCtbNtry (cId); } return( FALSE ); /* primitive not needed anymore */ } /* determine result id */ switch( *resId ) { case( CCR_NOT_ALLW ): /* SS not allowed */ { send_error_to_user( ownNotSAT, AT_CMD_D, RSLT_CC_SIM_PRM, ADD_CC_NOT_ALLWD, NULL, FALSE); if (ownNotSAT EQ FALSE) { /* clear call ID */ if (psaCC_ctbIsValid (cId)) { psaCC_retMOCTi(psaCC_ctb(cId)->ti); psaCC_chngCalTypCnt(cId, -1); psaCC_FreeCtbNtry (cId); } } return( FALSE ); /* primitive not needed anymore */ } case( CCR_ALLW_WITH_MDFY ): /* SS allowed with modification */ { if( ccr->v_addr ) { /* if SS control string was converted into a call setup */ return(sim_control_setup_call( ccr, ownNotSAT )); } else if( ccr->v_ss_string ) { /* if SS control string was changed by sim control */ /* adjust SS control string */ cmhCC_init_cldPty( &satPndSetup.clpty ); /* erase previous ss string */ utl_BCD2DialStr( ccr->ss_string.ss_ctrl_string, satPndSetup.clpty.num, (UBYTE)MINIMUM(ccr->ss_string.c_ss_ctrl_string, MAX_DIAL_LEN-1)); satPndSetup.clpty.ton = ccr->ss_string.noa; satPndSetup.clpty.npi = ccr->ss_string.npi; sim_control_send_ss( &satPndSetup.clpty, AT_CMD_D, ownNotSAT, NULL ); return(FALSE); } else /* if no optionnal field, then assume no modification see 11.14 ?9.1.6 */ sim_control_send_ss( &satPndSetup.clpty, AT_CMD_D, ownNotSAT, NULL ); return(FALSE); } /* SS allowed no modification */ default: TRACE_ERROR ("Unknown resID in cmhSAT_ResSSCntrlBySIM!"); /*lint -fallthrough*/ case( CCR_ALLW_NO_MDFY ): sim_control_send_ss( &satPndSetup.clpty, AT_CMD_D, ownNotSAT, NULL ); return( FALSE ); /* primitive not needed anymore */ } } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH_SATR | | ROUTINE : cmhSAT_ResUSSDCntrlBySIM | +-------------------------------------------------------------------+ PURPOSE : Handle SIM USSD control result. Return TRUE if primitive is needed for building a terminal response. */ GLOBAL BOOL cmhSAT_ResUSSDCntrlBySIM( UBYTE* resId, void *ccRes ) { T_ACI_RETURN retVal; /* holds return value */ T_ccr_allw * ccr; /* points to CC result */ UBYTE idx; /* holds index */ BOOL ownNotSAT; /* flags that the owner is not SAT */ SHORT sId; T_ACI_SAT_TERM_RESP resp_data; #ifdef FF_SAT_E T_ACI_SATA_ADD addPrm; #endif UBYTE *ussdString; UBYTE ussdLen; UBYTE src_len; TRACE_FUNCTION ("cmhSAT_ResUSSDCntrlBySIM()"); psaSAT_InitTrmResp( &resp_data ); ccr = (T_ccr_allw*)ccRes; /* check if queued event download */ if (satShrdPrm.event.c_queued) { cmhSAT_EventDwn( -1, -1, -1); } satShrdPrm.SIMCCParm.busy = FALSE; ownNotSAT = satShrdPrm.SIMCCParm.owner NEQ OWN_SAT; /* ** If this is a Cust1 MMI and The originator was a STK Cmd */ if ((simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) AND (ownNotSAT == FALSE)) { /* ** Customised behaviour for the Cust1 MMI */ if (*resId == CCR_NOT_ALLW) { /* send SAT response */ resp_data.add_content = ADD_CC_NOT_ALLWD; psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); } else { /* ** This was a SAT initiated Request. For the Cust1 the ACI does not yet have any ** actions to perform, other than the CC By SIM which has been done. So : ** Send the Original STK Cmd to the MMI in a %SATI for the MMI to process. */ cmhSAT_Cust1StkCmdInd(); } return( FALSE ); /* primitive not needed anymore */ } /* *---------------------------------------------------------------- * determine result id *---------------------------------------------------------------- */ switch( *resId ) { /* *------------------------------------------------------------ * SS not allowed *------------------------------------------------------------ */ case( CCR_NOT_ALLW ): /* setup initiated by user */ if( ownNotSAT ) { R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner ) ( AT_CMD_D, CME_ERR_NotPresent ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, AT_CMD_D, -1, -1, CME_ERR_NotPresent ); } /* setup initiated by SAT */ else { /* send SAT response */ resp_data.add_content = ADD_CC_NOT_ALLWD; psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); } return( FALSE ); /* primitive not needed anymore */ /* *------------------------------------------------------------ * USSD allowed with modification *------------------------------------------------------------ */ case( CCR_ALLW_WITH_MDFY ): /* if USSD control string was converted into a call setup */ if( ccr->v_addr ) { SHORT cId = psaCC_ctbNewEntry(); if( cId EQ NO_ENTRY ) { /* * We got no free slot in the call table */ if( ownNotSAT ) { R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner ) ( AT_CMD_D, CME_ERR_NotPresent ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, AT_CMD_D, -1, -1, CME_ERR_NotPresent ); } /* setup initiated by SAT */ else { /* send SAT response */ resp_data.add_content = ADD_NO_CAUSE; psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); } return( FALSE ); /* primitive not needed anymore */ } /* * We have successfully allocated a slot in the call table */ /* fill in setup parameter for called address */ cmhSAT_fillSetupPrm ( cId, ((ccr->v_addr)?&ccr->addr:NULL), ((ccr->v_subaddr)?&ccr->subaddr:NULL)); /* new call table entry set default bearer capabilities */ cmhSAT_fillSetupBC ( cId, BEARER_SERV_SPEECH, BEARER_SERV_NOT_PRES ); /* check aoc condition */ if ((psaCC_ctb(cId)->prio EQ PRIO_NORM_CALL) AND (aoc_check_moc() EQ FALSE)) /* * check ACM exceeds ACMmax * for non-emergency calls */ { if( ownNotSAT ) { R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner ) ( AT_CMD_D, CME_ERR_NotPresent ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, AT_CMD_D, -1, -1, CME_ERR_NotPresent ); } /* setup initiated by SAT */ else { resp_data.add_content = ADD_NO_CAUSE; psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); } psaCC_FreeCtbNtry (cId); return( FALSE ); } if( ccr->v_cap_cnf_parms ) { /* check bearer caps, ctb not allocated */ } /* declare call table entry as used and the owner and status of the call */ psaCC_ctb(cId)->calOwn = satShrdPrm.SIMCCParm.owner; psaCC_ctb(cId)->calStat = CS_SAT_REQ; psaCC_ctb(cId)->curCmd = AT_CMD_D; psaCC_ctb(cId)->curSrc = satShrdPrm.SIMCCParm.owner; if( !ownNotSAT ) psaCC_ctb(cId)->SATinv = TRUE; /* alert user */ if( ownNotSAT ) { #ifdef FF_SAT_E addPrm.chnType = SATA_CT_VOICE; addPrm.chnEst = SATA_EST_IM; R_AT( RAT_SATA, satShrdPrm.SIMCCParm.owner ) ( cId+1, satShrdPrm.dur, &addPrm ); #else R_AT( RAT_SATA, satShrdPrm.SIMCCParm.owner ) ( cId+1, satShrdPrm.dur); #endif /* FF_SAT_E */ R_AT( RAT_OK, satShrdPrm.SIMCCParm.owner ) ( AT_CMD_D ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_OK, AT_CMD_D, -1, -1, -1 ); } /* setup initiated by SAT */ else { for( idx = 0; idx < CMD_SRC_MAX; idx++ ) { #ifdef FF_SAT_E addPrm.chnType = SATA_CT_VOICE; addPrm.chnEst = SATA_EST_IM; R_AT( RAT_SATA, idx ) ( cId+1, satShrdPrm.dur, &addPrm ); #else R_AT( RAT_SATA, idx ) ( cId+1, satShrdPrm.dur); #endif } } return( !ownNotSAT ); } /* --- no break, continue with next case --- */ /*lint -fallthrough*/ /* *------------------------------------------------------------ * USSD allowed no modification *------------------------------------------------------------ */ default: TRACE_ERROR ("unknown resID in cmhSAT_ResUSSDCntrlBySIM"); /*lint -fallthrough*/ case( CCR_ALLW_NO_MDFY ): /* check for busy SS condition */ if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY ) { /* respond with "error, ME currently unable to process command" */ resp_data.add_content = ADD_ME_USSD_BUSY; psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); return( FALSE ); } /* adjust SS control string */ if( ccr->v_ussd_string ) { memcpy( &(satPndSetup.ussd_str), &ccr->ussd_string, sizeof(T_ussd_string)); } /********************************************************************************/ /* *------------------------------------------------------------------- * check if there is a USSD request pending *------------------------------------------------------------------- */ sId = psaSS_stbFindUssdReq(); if( sId EQ NO_ENTRY ) { /* check if there is another service in progress */ if( psaSS_stbFindActSrv( sId ) NEQ NO_ENTRY ) { ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_ParallelUSSD ); return( AT_FAIL ); } /* get new service table entry */ sId = psaSS_stbNewEntry(); if( sId EQ NO_ENTRY ) { ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull ); return( AT_FAIL ); } CCD_START; MALLOC(ussdString, MAX_USSD_STRING); /* set data coding scheme */ /* patch !!!!! CLB 11/12/01 */ if( (UBYTE)satPndSetup.ussd_str.dcs EQ 0x40 ) { /* 0x40 means basically default alphabet... yet some asian networks dont seem to accept it (although using it in their own STK !!!) */ satPndSetup.ussd_str.dcs = 0x0F; } /*********************************/ if( utl_getAlphabetCb( (UBYTE)satPndSetup.ussd_str.dcs ) EQ 0 ) /* 7bit alphabet */ { src_len = (UBYTE)MINIMUM( MAX_USSD_STRING, satPndSetup.ussd_str.c_ussd_str); ussdLen = utl_cvt8To7( satPndSetup.ussd_str.ussd_str, src_len, ussdString, 0 ); /* According to spec 23.038 section 6.1.2.3 for USSD packing, for bytes end with * (8*n)-1 i.e where n is 1,2,3....i.e byte 7, 15, 23 ... to be padded * with carriage return <CR>(0xD) */ if ((src_len+1)%8 EQ 0) { ussdString[ussdLen-1] |= (0xD << 1); } } else { ussdLen = satPndSetup.ussd_str.c_ussd_str; memcpy(ussdString, satPndSetup.ussd_str.ussd_str, MAX_USSD_STRING); } psaSS_asmProcUSSDReq( (UBYTE)satPndSetup.ussd_str.dcs /*dcs*/, ussdString, ussdLen); MFREE(ussdString); /* start new transaction */ ssShrdPrm.stb[sId].ntryUsdFlg = TRUE; if (ownNotSAT) { ssShrdPrm.stb[sId].curCmd = AT_CMD_CUSD; ssShrdPrm.stb[sId].srvOwn = satShrdPrm.SIMCCParm.owner; } else { ssShrdPrm.stb[sId].curCmd = AT_CMD_NONE; ssShrdPrm.stb[sId].srvOwn = OWN_SAT; satShrdPrm.SentUSSDid = sId; } psaSS_NewTrns(sId); if (ownNotSAT) { R_AT( RAT_OK, satShrdPrm.SIMCCParm.owner ) ( AT_CMD_CUSD); cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_OK, AT_CMD_CUSD, -1, -1, -1 ); } CCD_END; retVal = AT_EXCT; } else { CCD_START; psaSS_asmCnfUSSDReq( (UBYTE)satPndSetup.ussd_str.dcs, satPndSetup.ussd_str.ussd_str, satPndSetup.ussd_str.c_ussd_str ); ssShrdPrm.stb[sId].ussdReqFlg = FALSE; /* continue existing transaction */ psaSS_CntTrns(sId); CCD_END; retVal = AT_CMPL; } /**********************************************************************************/ if( retVal EQ AT_EXCT ) return( FALSE ); /* primitive not needed anymore */ if( ownNotSAT ) { R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner ) ( AT_CMD_D, CME_ERR_NotPresent ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, AT_CMD_D, -1, -1, CME_ERR_NotPresent ); } /* setup initiated by SAT */ else { /* send SAT response */ resp_data.resCC = resId; psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); } return( FALSE ); /* primitive not needed anymore */ } } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH_SATR | | ROUTINE : cmhSAT_ResSMCntrlBySIM | +-------------------------------------------------------------------+ PURPOSE : Handle SIM SM control result. Return TRUE if primitive is needed for building a terminal response. */ GLOBAL BOOL cmhSAT_ResSMCntrlBySIM( UBYTE* resId, void *smcRes ) { BOOL ownNotSAT; /* flags that the owner is not SAT */ T_smcr_allw *smcr; /* points to SM result */ T_ACI_CMGF_MOD mode; UBYTE sca_buf[MAX_SMS_ADDR_DIG/2 + 2]; UBYTE da_buf[MAX_SMS_ADDR_DIG/2 + 2]; UBYTE sca_len = 0; UBYTE da_len = 0; T_ACI_SAT_TERM_RESP resp_data; UBYTE srcId = smsShrdPrm.smsEntStat.entOwn; TRACE_FUNCTION ("cmhSAT_ResSMCntrlBySIM()"); psaSAT_InitTrmResp( &resp_data ); smcr = (T_smcr_allw*)smcRes; /* check if queued event download */ if (satShrdPrm.event.c_queued) { cmhSAT_EventDwn( -1, -1, -1); } satShrdPrm.SIMCCParm.busy = FALSE; ownNotSAT = satShrdPrm.SIMCCParm.owner NEQ OWN_SAT; /* ** If this is a Cust1 MMI and The originator was a STK Cmd */ if ((simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) AND (ownNotSAT == FALSE)) { /* ** Customised behaviour for the Cust1 MMI */ if (*resId == CCR_NOT_ALLW) { /* send SAT response */ resp_data.add_content = ADD_CC_NOT_ALLWD; psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); } else { /* ** This was a SAT initiated Request. For the Cust1 the ACI does not yet have any ** actions to perform, other than the CC By SIM which has been done. So : ** Send the Original STK Cmd to the MMI in a %SATI for the MMI to process. ** ** The second action will cause the MMI to request the approriate Call Setup, SS ** or USSD Request and the required Call Table entry will then be re-created. */ cmhSAT_Cust1StkCmdInd(); } if ( (sat_mnsms_submit_req->rec_num EQ SMS_RECORD_NOT_EXIST) OR (sat_mnsms_submit_req->modify NEQ SMS_MODIFY_NON) ) { if (smsShrdPrm.tpdu.tp_submit NEQ NULL) { ACI_MFREE(smsShrdPrm.tpdu.tp_submit); smsShrdPrm.tpdu.tp_submit = NULL; } } PFREE( sat_mnsms_submit_req ); /* ** Ensure that the SMS parameters are reset, so that the SMS Entity is freed to ** process the command later. */ smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = CMD_SRC_NONE; return( FALSE ); /* primitive not needed anymore */ } if (smsShrdPrm.smsEntStat.curCmd EQ AT_CMD_CMSS) { mode = CMGF_MOD_Txt; } #if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ else if (smsShrdPrm.smsEntStat.entOwn EQ CMD_SRC_LCL) { mode = CMGF_MOD_Txt; /* since text mode (AT+CMGF=1) is never set in MMI */ } #endif else if (ownNotSAT EQ FALSE) { mode = CMGF_MOD_Pdu; } else { /* * request current mode */ qAT_PlusCMGF(srcId, &mode); } /* *---------------------------------------------------------------- * determine result id *---------------------------------------------------------------- */ switch( *resId ) { /* *------------------------------------------------------------ * send message not allowed *------------------------------------------------------------ */ case( CCR_NOT_ALLW ): /* setup initiated by user */ if( ownNotSAT ) { R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner ) ( smsShrdPrm.smsEntStat.curCmd, CME_ERR_NotPresent ); /* log result */ cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, smsShrdPrm.smsEntStat.curCmd, -1, -1, CME_ERR_NotPresent ); smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; } /* setup initiated by SAT */ else { /* send SAT response */ resp_data.add_content = ADD_CC_NOT_ALLWD; psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); } if ( (sat_mnsms_submit_req->rec_num EQ SMS_RECORD_NOT_EXIST) OR (sat_mnsms_submit_req->modify NEQ SMS_MODIFY_NON) ) { if (smsShrdPrm.tpdu.tp_submit NEQ NULL) { ACI_MFREE(smsShrdPrm.tpdu.tp_submit); smsShrdPrm.tpdu.tp_submit = NULL; } } PFREE( sat_mnsms_submit_req ); return( FALSE ); /* primitive not needed anymore */ case( CCR_ALLW_WITH_MDFY ): if ( smcr->v_sm_addr ) { /* * RP Service Center Address */ sat_mnsms_submit_req->modify |= SMS_MODIFY_SCA; if (mode EQ CMGF_MOD_Pdu) { /* PDU mode */ sca_len = CodeRPAddress( sca_buf, smcr->sm_addr.c_bcdDigit, smcr->sm_addr.noa, smcr->sm_addr.npi, smcr->sm_addr.bcdDigit ); cmhSAT_ModifyScaPdu( &sat_mnsms_submit_req->sms_sdu, sca_buf, sca_len ); } else { /* Text mode */ smsShrdPrm.tpdu.sc_addr.v_ton = 1; smsShrdPrm.tpdu.sc_addr.ton = smcr->sm_addr.noa; smsShrdPrm.tpdu.sc_addr.v_npi = 1; smsShrdPrm.tpdu.sc_addr.npi = smcr->sm_addr.npi; smsShrdPrm.tpdu.sc_addr.c_num = smcr->sm_addr.c_bcdDigit; memcpy(smsShrdPrm.tpdu.sc_addr.num, smcr->sm_addr.bcdDigit, smcr->sm_addr.c_bcdDigit); } } if ( smcr->v_sm_addr_2) { /* * TP Destination Address */ sat_mnsms_submit_req->modify |= SMS_MODIFY_TPOA; if (mode EQ CMGF_MOD_Pdu) { /* PDU mode */ da_len = CodeTPAddress( da_buf, smcr->sm_addr_2.c_bcdDigit, smcr->sm_addr_2.noa, smcr->sm_addr_2.npi, smcr->sm_addr_2.bcdDigit ); cmhSAT_ModifyDaPdu( &sat_mnsms_submit_req->sms_sdu, da_buf, da_len ); } else { /* Text mode */ smsShrdPrm.tpdu.tp_submit->tp_da.ton = smcr->sm_addr_2.noa; smsShrdPrm.tpdu.tp_submit->tp_da.npi = smcr->sm_addr_2.npi; smsShrdPrm.tpdu.tp_submit->tp_da.c_num = smcr->sm_addr_2.c_bcdDigit; smsShrdPrm.tpdu.tp_submit->tp_da.digits = smcr->sm_addr_2.c_bcdDigit; memcpy(smsShrdPrm.tpdu.tp_submit->tp_da.num, smcr->sm_addr_2.bcdDigit, smcr->sm_addr_2.c_bcdDigit); } } /* no break needed !!!! */ /*lint -fallthrough*/ case( CCR_ALLW_NO_MDFY ): if( sat_mnsms_submit_req ) { if (mode EQ CMGF_MOD_Txt) /* Text mode */ { /* code sm here */ cmhSMS_codeMsg (&sat_mnsms_submit_req->sms_sdu, SMS_VT_SUBMIT, &smsShrdPrm.tpdu.sc_addr, SMS_SUBMIT, (UBYTE*)smsShrdPrm.tpdu.tp_submit); if (smsShrdPrm.tpdu.tp_submit NEQ NULL) { ACI_MFREE(smsShrdPrm.tpdu.tp_submit); smsShrdPrm.tpdu.tp_submit = NULL; } } PSENDX (SMS, sat_mnsms_submit_req); } else TRACE_EVENT("error provoked by SAT"); break; default: if ( (sat_mnsms_submit_req->rec_num EQ SMS_RECORD_NOT_EXIST) OR (sat_mnsms_submit_req->modify NEQ SMS_MODIFY_NON) ) { if (smsShrdPrm.tpdu.tp_submit NEQ NULL) { ACI_MFREE(smsShrdPrm.tpdu.tp_submit); smsShrdPrm.tpdu.tp_submit = NULL; } } TRACE_EVENT("wrong type of result received from SIM"); PFREE( sat_mnsms_submit_req ); return( FALSE ); /* primitive not needed anymore */ } return FALSE; } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CMH | | ROUTINE : cmhCC_SatDTMFsent | +-------------------------------------------------------------------+ PURPOSE : confirmation for sent SAT DTMF */ GLOBAL void cmhCC_SatDTMFsent ( SHORT cId ) { T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId]; T_ACI_SAT_TERM_RESP resp_data; static UBYTE dtmf_separator_count = 0; TRACE_FUNCTION ("cmhCC_SatDTMFsent()"); psaSAT_InitTrmResp( &resp_data ); /* * Use ctb here because TI compiler 1.22e may have a problem otherwise here. * See cmhCC_SndDiscRsn() for the details. */ if (GET_CAUSE_VALUE(ctb->nrmCs) NEQ NOT_PRESENT_8BIT AND ctb->nrmCs NEQ MNCC_CAUSE_DTMF_START_SUCCESS) { TRACE_EVENT_P1("network reported error when sending DTMF: %d", ctb->nrmCs); psaSAT_SendTrmResp( RSLT_NTW_UNAB_PROC, &resp_data ); dtmf_separator_count = 0; return; } if(is_digit_dtmf_separator(ccShrdPrm.dtmf.dig[ccShrdPrm.dtmf.cur])) { if (dtmf_separator_count EQ 0) { dtmf_separator_count = 1; if(ctb->dtmfCmd NEQ AT_CMD_VTS) /* this is only valid within a number to dial */ { /* p within a number string: this is a 3 seconds pause */ TRACE_EVENT("DTMF pause requested: 3 seconds"); #if defined (NEW_FRAME) TIMERSTART( TDTMF_VALUE, ACI_TDTMF ); #else TIMERSTART( TDTMF_VALUE, t_dtmf_handle ); #endif ccShrdPrm.dtmf.cur++; /* skip the DTMF seperator */ return; } ccShrdPrm.dtmf.cur++; /* skip the DTMF seperator */ } } else { dtmf_separator_count = 0; } if (ccShrdPrm.dtmf.cur < ccShrdPrm.dtmf.cnt) { cmhSAT_sendDTMF ( NULL ); } else /* whole DTMF string has been sent */ { ccShrdPrm.dtmf.cId = NO_ENTRY; /* Reset cId after sending the whole DTMF string */ ctb->dtmfCmd = AT_CMD_NONE; ctb->dtmfSrc = CMD_SRC_NONE; psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); dtmf_separator_count = 0; } } #endif /* #ifdef SIM_TOOLKIT */ /*==== EOF ========================================================*/