FreeCalypso > hg > freecalypso-sw
view gsm-fw/g23m-aci/aci/ati_sim.c @ 799:9b2ed89a1adc
aci: cmh_sms?.c compile
author | Space Falcon <falcon@ivan.Harhan.ORG> |
---|---|
date | Sun, 05 Apr 2015 00:38:21 +0000 |
parents | 0b85dd2dec6a |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GSM-F&D (8411) | Modul : ATI +----------------------------------------------------------------------------- | 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 : AT Command Interpreter: SIM related functions. +----------------------------------------------------------------------------- */ #ifndef ATI_SIM_C #define ATI_SIM_C #include "config.h" #include "fixedconf.h" #include "condat-features.h" #include "aci_conf.h" #undef DUMMY_ATI_STRINGS #include "aci_all.h" #include "aci_cmh.h" #include "ati_cmd.h" #include "aci_io.h" #include "aci_cmd.h" #include "l4_tim.h" #include "gdi.h" #include "audio.h" #include "aci_mem.h" #include "aci_ext_pers.h" #include "aci_slock.h" #include "aci_prs.h" #include "aci_lst.h" #include "ati_int.h" #ifdef FF_ATI_BAT #include "typedefs.h" #include "gdd.h" #include "bat.h" #include "ati_bat.h" #endif /* FF_ATI_BAT */ /*==== EXPORT ==================================================*/ EXTERN CHAR *cmdExtError (T_ACI_EXT_ERR e); #ifdef TI_PS_FF_AT_P_CMD_SECP /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentSECP | +--------------------------------------------------------------------+ PURPOSE : %SECP command (PIN functionality for MMI Security) */ GLOBAL T_ATI_RSLT setatPercentSECP(CHAR * cl, UBYTE srcId) { char pinOld [MAX_PWD_LENGTH]={0}; char pinNew [MAX_PWD_LENGTH]={0}; T_ACI_RETURN ret = AT_FAIL; TRACE_FUNCTION ("setatPercentSECP()"); cl = parse(cl, "nn", (LONG)MAX_PWD_LENGTH, pinOld,(LONG)MAX_PWD_LENGTH, pinNew); if ( !cl OR (*pinOld EQ '\0' AND *pinNew EQ '\0') ) { cmdCmeError(CME_ERR_OpNotAllow); return ATI_FAIL; } ret = sAT_PercentSECP((T_ACI_CMD_SRC)srcId, pinOld, pinNew); return (map_aci_2_ati_rslt(ret)); } #endif /* TI_PS_FF_AT_P_CMD_SECP */ #ifdef TI_PS_FF_AT_P_CMD_SECS /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentSECS | +--------------------------------------------------------------------+ PURPOSE : %SECS command (This function changes the state of the MMI Security code It requires the existing security code as one of the parameters) */ GLOBAL T_ATI_RSLT setatPercentSECS (CHAR *cl, UBYTE srcId) { char code [MAX_PWD_LENGTH]={0}; T_ACI_SECS_STA securityState = SECS_STA_NotPresent; T_ACI_RETURN ret = AT_FAIL; TRACE_FUNCTION ("setatPercentSECS()"); /* Get the required state and the Security code from the command parameters*/ cl = parse(cl, "dn", &securityState, (LONG)MAX_PWD_LENGTH, code); if ( !cl OR *code EQ '\0' ) { cmdCmeError(CME_ERR_OpNotAllow); return ATI_FAIL; } ret = sAT_PercentSECS((T_ACI_CMD_SRC)srcId,securityState,code); return (map_aci_2_ati_rslt(ret)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : qetatPercentSECS | +--------------------------------------------------------------------+ PURPOSE : %SECS? command (It queries the state of the MMI Security code) */ GLOBAL T_ATI_RSLT quetatPercentSECS (CHAR *cl, UBYTE srcId) { T_ACI_SECS_STA securityState = SECS_STA_NotPresent; T_ACI_RETURN ret = AT_FAIL; TRACE_FUNCTION ("qetatPercentSECS()"); /* Get the State value from the Command Handler */ ret = qAT_PercentSECS((T_ACI_CMD_SRC)srcId, &securityState); if (ret EQ AT_CMPL) { resp_disp(srcId, cl,"e",&securityState); return ATI_CMPL; } else { cmdCmeError(CME_ERR_Unknown); return ATI_FAIL; } } #endif /* TI_PS_FF_AT_P_CMD_SECS */ GLOBAL CHAR *CPIN_RESULT(T_ACI_CPIN_RSLT code) { switch (code) { default: case(CPIN_RSLT_NotPresent): return"not present"; case(CPIN_RSLT_SimReady): return"READY"; case(CPIN_RSLT_SimPinReq): return"SIM PIN"; case(CPIN_RSLT_SimPukReq): return"SIM PUK"; case(CPIN_RSLT_PhSimPinReq):return"PH-SIM PIN"; case(CPIN_RSLT_SimPin2Req): return"SIM PIN2"; case(CPIN_RSLT_SimPuk2Req): return"SIM PUK2"; /* OVK: Extended list of all possible result according to 07.07 */ case(CPIN_RSLT_PhFSimPinReq): return"PH-FSIM PIN"; case(CPIN_RSLT_PhFSimPukReq): return"PH-FSIM PUK"; case(CPIN_RSLT_PhNetPinReq): return"PH-NET PIN"; case(CPIN_RSLT_PhNetPukReq): return"PH_NET PUK"; case(CPIN_RSLT_PhNetSubPinReq): return"PH-NETSUB PIN"; case(CPIN_RSLT_PhNetSubPukReq): return"PH-NETSUB PUK"; case(CPIN_RSLT_PhSPPinReq): return"PH-SP PIN"; case(CPIN_RSLT_PhSPPukReq): return"PH-SP PUK"; case(CPIN_RSLT_PhCorpPinReq): return"PH-CORP PIN"; case(CPIN_RSLT_PhCorpPukReq): return"PH-CORP PUK"; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : atPlusCPIN | +--------------------------------------------------------------------+ PURPOSE : +CPIN command (PIN functionality of ME) */ GLOBAL T_ATI_RSLT setatPlusCPIN (char *cl, UBYTE srcId) { char pinOld [MAX_PWD_LENGTH]={0}; /* ES!! enough for bad guys?*/ char pinNew [MAX_PWD_LENGTH]={0}; T_ACI_RETURN ret = AT_FAIL; UBYTE slockBlocked = 0; /* @GBR: AT_CMPL is interpreted as error per default. This is wrong, if the ME is SIMLOCKed */ TRACE_FUNCTION ("setatPlusCPIN()"); cl = parse(cl,"nn",(LONG)MAX_PWD_LENGTH,&pinOld,(LONG)MAX_PWD_LENGTH,&pinNew); if ( !cl OR *pinOld EQ '\0' ) { cmdCmeError(CME_ERR_OpNotAllow); return ATI_FAIL; } #ifdef SIM_PERS slockBlocked = AciSLockShrd.blocked; #endif #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_cmd_set_plus_cpin my_bat_set_plus_cpin = {0}; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION("setatPlusCPIN() calls bat_send() <=== as APPLICATION"); /* memset(&my_bat_set_plus_cpin, FALSE, sizeof(my_bat_set_plus_cpin)); Already initilaised */ cmd.ctrl_params = BAT_CMD_SET_PLUS_CPIN; cmd.params.ptr_set_plus_cpin = &my_bat_set_plus_cpin; /* Set old pin BAT attribs */ my_bat_set_plus_cpin.c_pin = strlen(pinOld); memcpy(my_bat_set_plus_cpin.pin, pinOld, BAT_MAX_CPIN_PIN_LEN); /* Set new pin BAT attribs */ if(my_bat_set_plus_cpin.c_newpin = strlen(pinNew)) { my_bat_set_plus_cpin.v_newpin = TRUE; memcpy(my_bat_set_plus_cpin.pin, pinNew, BAT_MAX_CPIN_PIN_LEN); } src_params->curAtCmd = AT_CMD_CPIN; bat_send(ati_bat_get_client(srcId), &cmd); return ATI_EXCT; /* executing, because response is passed by callback function */ } #else /* no FF_ATI_BAT */ TRACE_FUNCTION("setatPlusCPIN()"); ret = sAT_PlusCPIN ((T_ACI_CMD_SRC)srcId,pinOld,pinNew); switch(ret) { case(AT_EXCT): { break; } case(AT_BUSY): { cmdCmeError(CME_ERR_SimBusy); break; } case(AT_FAIL): { cmdCmeError(CME_ERR_Unknown); break; } case(AT_CMPL): { if (!slockBlocked) { cmdCmeError(CME_ERR_Unknown); } break; } } return (map_aci_2_ati_rslt(ret)); #endif /* FF_ATI_BAT */ } GLOBAL T_ATI_RSLT queatPlusCPIN (char *cl, UBYTE srcId) { T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); src_params->curAtCmd = AT_CMD_CPIN; #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; TRACE_FUNCTION("queatPlusCPIN() calls bat_send() <=== as APPLICATION"); cmd.ctrl_params = BAT_CMD_QUE_PLUS_CPIN; dummy.bat_dummy = 0xFF; cmd.params.ptr_que_plus_cpin = &dummy; bat_send(ati_bat_get_client(srcId), &cmd); return ATI_EXCT; /* executing, because response is passed by callback function */ } #else /* no FF_ATI_BAT */ { T_ACI_RETURN ret = AT_FAIL; T_ACI_CPIN_RSLT code; TRACE_FUNCTION ("queatPlusCPIN()"); ret= qAT_PlusCPIN ((T_ACI_CMD_SRC)srcId,&code); /*PIN status is requested*/ switch (ret) { case(AT_CMPL): { sprintf (g_sa,"+CPIN: %s",CPIN_RESULT(code)); io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT); break; } case(AT_EXCT): { src_params->curAtCmd = AT_CMD_CPIN; break; } default: { cmdCmeError (CME_ERR_Unknown); break; } } return (map_aci_2_ati_rslt(ret)); } #endif /* no FF_ATI_BAT */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : atPlusCPOL | +--------------------------------------------------------------------+ PURPOSE : +CPOL command (preferred operator list) */ GLOBAL T_ATI_RSLT setatPlusCPOL (char *cl, UBYTE srcId) { T_ACI_CPOL_FRMT format = CPOL_FRMT_NotPresent; SHORT index = ACI_NumParmNotPresent; char op[20] = {0}; T_ACI_RETURN ret = AT_FAIL; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION("setatPlusCPOL()"); cl = parse(cl,"dds",&index,&format,(LONG)20,op); if(!cl) { cmdCmeError(CME_ERR_OpNotAllow); return ATI_FAIL; } #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_cmd_set_plus_cpol cpol; UBYTE len; len=strlen(op); /* * If the operator name is too big for the BAT structure, there's * nothing we can do. A truncated version would be meaningless, and * to omit it would result in an operator being deleted from the * list. */ if (len>BAT_MAX_CPOL_OPER_LEN) return(ATI_FAIL); cmd.ctrl_params = BAT_CMD_SET_PLUS_CPOL; cmd.params.ptr_set_plus_cpol=&cpol; cpol.index=(S16)index; /* * This relies on T_ACI_CPOL_FRMT being identical to * T_BAT_plus_cpol_format. */ cpol.format=(T_BAT_plus_cpol_format)format; if (len>0) { memcpy(cpol.oper,op,len); cpol.v_oper=TRUE; cpol.c_oper=(U8)len; } else { cpol.v_oper=FALSE; } bat_send(ati_bat_get_client(srcId), &cmd); src_params->curAtCmd=AT_CMD_CPOL; return(ATI_EXCT); } #else /* no FF_ATI_BAT */ #ifdef WIN32 ret=sAT_PlusCPOL(srcId,index,format, ((op[0] NEQ 0x0)?op:NULL), cpolIdx2, cpolMode); #else ret=sAT_PlusCPOL((T_ACI_CMD_SRC)srcId,index,format, ((op[0] NEQ 0x0)?op:NULL), ACI_NumParmNotPresent, CPOL_MOD_NotPresent); #endif switch (ret) { case (AT_CMPL): return ATI_CMPL; case (AT_EXCT): src_params->curAtCmd = AT_CMD_CPOL; return ATI_EXCT; default: cmdCmeError(CME_ERR_Unknown); return ATI_FAIL; } #endif /* no FF_ATI_BAT */ } GLOBAL T_ATI_RSLT tesatPlusCPOL (char *cl, UBYTE srcId) { SHORT lastIdx=0,usdNtry=0; T_ACI_RETURN ret = AT_FAIL; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION("tesatPlusCPOL()"); src_params->curAtCmd=AT_CMD_CPOL; #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; cmd.ctrl_params = BAT_CMD_TST_PLUS_CPOL; dummy.bat_dummy = 0xFF; cmd.params.ptr_tst_plus_cpol = &dummy; bat_send(ati_bat_get_client(srcId), &cmd); return(ATI_EXCT); } #else /* no FF_ATI_BAT */ ret = tAT_PlusCPOL((T_ACI_CMD_SRC)srcId,&lastIdx,&usdNtry); if (ret EQ AT_CMPL) { sprintf(g_sa,"+CPOL: (1-%d),(0-2)", lastIdx); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); } if (ret EQ AT_EXCT) { src_params->curAtCmd = AT_CMD_CPOL; } if (ret EQ AT_FAIL) { cmdCmeError(CME_ERR_Unknown); } return (map_aci_2_ati_rslt(ret)); #endif /* no FF_ATI_BAT */ } GLOBAL T_ATI_RSLT queatPlusCPOL (char *cl, UBYTE srcId) { #ifndef FF_ATI_BAT T_ACI_CPOL_LST plmnSelLst; UBYTE idx; BOOL loop; #endif SHORT startIdx=0,lastIdx=0; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); src_params->curAtCmd=AT_CMD_CPOL; TRACE_FUNCTION("queatPlusCPOL()"); #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; cmd.ctrl_params = BAT_CMD_QUE_PLUS_CPOL; dummy.bat_dummy = 0xFF; cmd.params.ptr_que_plus_cpol = &dummy; bat_send(ati_bat_get_client(srcId), &cmd); return(ATI_EXCT); } #else /* no FF_ATI_BAT */ #ifdef WIN32 switch (qAT_PlusCPOL ( srcId, 1, &lastIdx, &plmnSelLst[0], cpolMode)) #else switch (qAT_PlusCPOL ( (T_ACI_CMD_SRC)srcId, 1, &lastIdx, &plmnSelLst[0], CPOL_MOD_NotPresent)) #endif { case AT_CMPL: loop = TRUE; do { if( lastIdx EQ ACI_NumParmNotPresent ) break; startIdx = lastIdx+1; for( idx=0; idx < MAX_OPER; idx++ ) { if( plmnSelLst[idx].index EQ ACI_NumParmNotPresent ) { loop = FALSE; break; } sprintf(g_sa,"+CPOL: %d,%d,\"%s\"", plmnSelLst[idx].index, plmnSelLst[idx].format, plmnSelLst[idx].oper ); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); } if( qAT_PlusCPOL((T_ACI_CMD_SRC)srcId, startIdx, &lastIdx, &plmnSelLst[0], #ifdef WIN32 cpolMode #else CPOL_MOD_NotPresent #endif ) EQ AT_FAIL OR !loop) { break; } } while( loop ); return ATI_CMPL; case AT_EXCT: src_params->curAtCmd = AT_CMD_CPOL; return ATI_EXCT; default: cmdCmeError(CME_ERR_Unknown); return ATI_FAIL; } #endif /* no FF_ATI_BAT */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : atPlusCNUM | +--------------------------------------------------------------------+ PURPOSE : +CNUM command (subscriber number) */ GLOBAL T_ATI_RSLT setatPlusCNUM (char *cl, UBYTE srcId) { T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION("setatPlusCNUM()"); #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; TRACE_FUNCTION("setatPlusCNUM() calls bat_send() <=== as APPLICATION"); cmd.ctrl_params = BAT_CMD_SET_PLUS_CNUM; dummy.bat_dummy = 0xFF; cmd.params.ptr_set_plus_cnum = &dummy; bat_send(ati_bat_get_client(srcId), &cmd); src_params->curAtCmd=AT_CMD_CNUM; return(ATI_EXCT); } #else /* no FF_ATI_BAT */ if ( qAT_PlusCNUM ( (T_ACI_CMD_SRC)srcId, CNUM_MOD_NewRead ) EQ AT_EXCT ) { src_params->curAtCmd = AT_CMD_CNUM; return ATI_EXCT; } else { cmdCmeError ( CME_ERR_Unknown ); return ATI_FAIL; } #endif /* no FF_ATI_BAT */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : atPlusCFUN | +--------------------------------------------------------------------+ PURPOSE : +CFUN command (Phone functionality) */ GLOBAL T_ATI_RSLT setatPlusCFUN (char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; T_ACI_CFUN_FUN fun = CFUN_FUN_NotPresent; T_ACI_CFUN_RST rst = CFUN_RST_NotPresent; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); src_params->curAtCmd = AT_CMD_CFUN; cl = parse (cl, "dd", &fun, &rst); if ( !cl ) { cmdCmeError (CME_ERR_OpNotAllow); return (ATI_FAIL); } #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_cmd_set_plus_cfun my_bat_set_plus_cfun; TRACE_FUNCTION("setatPlusCFUN() calls bat_send() <=== as APPLICATION"); memset(&my_bat_set_plus_cfun, FALSE, sizeof(my_bat_set_plus_cfun)); cmd.ctrl_params = BAT_CMD_SET_PLUS_CFUN; cmd.params.ptr_set_plus_cfun = &my_bat_set_plus_cfun; my_bat_set_plus_cfun.fun = (T_BAT_VAL_plus_cfun_fun)fun; my_bat_set_plus_cfun.rst = (T_BAT_VAL_plus_cfun_rst)rst; bat_send(ati_bat_get_client(srcId), &cmd); return ATI_EXCT; /* executing, because response is passed by callback function */ } #else /* no FF_ATI_BAT */ { TRACE_FUNCTION("setatPlusCFUN()"); ret = sAT_PlusCFUN ((T_ACI_CMD_SRC)srcId,fun,rst); switch (ret) { case AT_EXCT: /*Command is executing*/ audio_SetAmplf (AUDIO_MICROPHONE, (UBYTE)75); audio_SetAmplf (AUDIO_SPEAKER, (UBYTE)175); src_params->curAtCmd = AT_CMD_CFUN; break; case AT_CMPL: src_params->curAtCmd = AT_CMD_NONE; break; default: /* AT_FAIL or nothing was returned */ cmdExtError (EXT_ERR_NotPresent); break; } return (map_aci_2_ati_rslt (ret)); } #endif /* no FF_ATI_BAT */ } GLOBAL T_ATI_RSLT queatPlusCFUN (char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; T_ACI_CFUN_FUN fun = CFUN_FUN_NotPresent; #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; TRACE_FUNCTION("queatPlusCFUN() calls bat_send() <=== as APPLICATION"); cmd.ctrl_params = BAT_CMD_QUE_PLUS_CFUN; dummy.bat_dummy = 0xFF; cmd.params.ptr_que_plus_cfun = &dummy; bat_send(ati_bat_get_client(srcId), &cmd); return ATI_EXCT; /* executing, because response is passed by callback function */ } #else /* no FF_ATI_BAT */ TRACE_FUNCTION("queatPlusCFUN()"); ret = qAT_PlusCFUN((T_ACI_CMD_SRC)srcId, &fun); if (ret EQ AT_CMPL) { resp_disp(srcId, cl,"e",&fun); return ATI_CMPL; } else { cmdCmeError(CME_ERR_Unknown); return ATI_FAIL; } #endif /* no FF_ATI_BAT */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : atPlusCIMI | +--------------------------------------------------------------------+ PURPOSE : +CIMI command (request international mobile subscriber identity) */ GLOBAL T_ATI_RSLT setatPlusCIMI(char *cl, UBYTE srcId) { #ifndef FF_ATI_BAT CHAR imsi[MAX_IMSI_LEN+1]; /* +1 for '\0' */ #endif T_ACI_RETURN ret = AT_FAIL; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION("setatPlusCIMI()"); #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; TRACE_FUNCTION("setatPlusCIMI() calls bat_send() <=== as APPLICATION"); cmd.ctrl_params = BAT_CMD_SET_PLUS_CIMI; dummy.bat_dummy = 0xFF; cmd.params.ptr_set_plus_cimi = &dummy; bat_send(ati_bat_get_client(srcId), &cmd); src_params->curAtCmd=AT_CMD_CIMI; return(ATI_EXCT); } #else /* no FF_ATI_BAT */ ret = qAT_PlusCIMI((T_ACI_CMD_SRC)srcId, imsi); switch (ret) { case( AT_CMPL ): sprintf(g_sa,"%s",imsi); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); break; case( AT_EXCT ): src_params->curAtCmd = AT_CMD_CIMI; break; default: break; } return (map_aci_2_ati_rslt(ret)); #endif /* no FF_ATI_BAT */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : atPlusCRSM | +--------------------------------------------------------------------+ PURPOSE : +CRSM Restricted SIM access */ GLOBAL T_ATI_RSLT setatPlusCRSM(char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; UBYTE *data; USHORT lenData = 0; T_ACI_CRSM_CMD cmd = CRSM_CMD_NotPresent; SHORT fileId = ACI_NumParmNotPresent, p1 = ACI_NumParmNotPresent, p2 = ACI_NumParmNotPresent, p3 = ACI_NumParmNotPresent; USHORT lenDataStr = 0; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION("setatPlusCRSM"); cl = parse(cl,"drrrrl", &cmd,&fileId, &p1, &p2, &p3,&lenDataStr,&data ); if(!cl) { cmdCmeError(CME_ERR_OpNotAllow); return ATI_FAIL; } utl_hexToGsm( data, lenDataStr, data, &lenData, GSM_ALPHA_Def, CSCS_ALPHA_Reserved ); #ifdef FF_ATI_BAT { T_BAT_cmd_send bat_cmd; T_BAT_cmd_set_plus_crsm crsm; /* * If the data is too big for the BAT structure, there's * nothing we can do. A truncated version would be meaningless. */ if (lenData>BAT_MAX_CRSM_DATA_LEN) return(ATI_FAIL); bat_cmd.ctrl_params = BAT_CMD_SET_PLUS_CRSM; bat_cmd.params.ptr_set_plus_crsm=&crsm; /* * This relies on T_ACI_CRSM_COMMAND and T_BAT_plus_crsm_command * being identical. They are, except in that the ACI version has * a 'not present' value. This is not an issue in this direction. */ crsm.command=(T_BAT_plus_crsm_command)cmd; crsm.fileid=(S32)fileId; crsm.p1=(S16)p1; crsm.p2=(S16)p2; crsm.p3=(S16)p3; crsm.c_data=(U8)lenData; memcpy(crsm.data,data,lenData); bat_send(ati_bat_get_client(srcId),&bat_cmd); src_params->curAtCmd=AT_CMD_CRSM; return(ATI_EXCT); } #else /* no FF_ATI_BAT */ ret = sAT_PlusCRSM( (T_ACI_CMD_SRC)srcId, cmd, fileId, p1, p2, p3, lenData, data ); if (ret EQ AT_EXCT) { src_params->curAtCmd = AT_CMD_CRSM; } if (ret EQ AT_FAIL) { cmdCmeError(CME_ERR_Unknown); } return (map_aci_2_ati_rslt(ret)); #endif /* no FF_ATI_BAT */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPlusCSIM | +--------------------------------------------------------------------+ PURPOSE : +CSIM Generic SIM access */ GLOBAL T_ATI_RSLT setatPlusCSIM(char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; USHORT given_length; UBYTE *data; USHORT lenData = 0; USHORT lenDataStr = 0; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION("setatPlusCSIM"); cl = parse(cl,"rl", &given_length, &lenDataStr, &data ); if(!cl) { cmdCmeError(CME_ERR_OpNotAllow); return ATI_FAIL; } if ((given_length > MAX_SIM_TRANSP*2) OR (given_length NEQ lenDataStr) OR (lenDataStr EQ 0)) { cmdCmeError(CME_ERR_OpNotAllow); return ATI_FAIL; } lenData = utl_HexStrToBin(data, lenDataStr, data, MAX_SIM_TRANSP); if (lenData EQ 0) { TRACE_EVENT("invalid character in <command>"); cmdCmeError(CME_ERR_OpNotAllow); return ATI_FAIL; } #ifdef FF_ATI_BAT { T_BAT_cmd_send bat_cmd; T_BAT_cmd_set_plus_csim csim; /* * If the data is too big for the BAT structure, there's * nothing we can do. A truncated version would be meaningless. */ if (lenData>BAT_MAX_CSIM_CMD_LEN) return(ATI_FAIL); bat_cmd.ctrl_params = BAT_CMD_SET_PLUS_CSIM; bat_cmd.params.ptr_set_plus_csim=&csim; csim.c_command=(U8)lenData; memcpy(csim.command,data,lenData); bat_send(ati_bat_get_client(srcId),&bat_cmd); src_params->curAtCmd=AT_CMD_CRSM; return(ATI_EXCT); } #else /* no FF_ATI_BAT */ ret = sAT_PlusCSIM( (T_ACI_CMD_SRC)srcId, lenData, data ); if (ret EQ AT_EXCT) { src_params->curAtCmd = AT_CMD_CSIM; } if (ret EQ AT_FAIL) { cmdCmeError(CME_ERR_Unknown); } return (map_aci_2_ati_rslt(ret)); #endif /* no FF_ATI_BAT */ } #ifdef TI_PS_FF_AT_P_CMD_ATR /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : queatPercentATR | +--------------------------------------------------------------------+ PURPOSE : %ATR answer to reset (query) */ GLOBAL T_ATI_RSLT queatPercentATR ( char *cl, UBYTE srcId ) { #ifndef FF_ATI_BAT T_ACI_RETURN ret; UBYTE i; UBYTE phase; UBYTE atr_len = 0; UBYTE atr_info[MAX_SIM_ATR]; #endif TRACE_FUNCTION( "queatPercentATR()" ); #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; cmd.ctrl_params = BAT_CMD_QUE_PERCENT_ATR; dummy.bat_dummy = 0xFF; cmd.params.ptr_que_percent_atr = &dummy; /* * Without this we will lose track of the source ID by the time the * response arrives. */ srcId_cb=srcId; bat_send(ati_bat_get_client(srcId), &cmd); return(ATI_EXCT); } #else /* no FF_ATI_BAT */ ret = qAT_PercentATR( (T_ACI_CMD_SRC)srcId, &phase, &atr_len, atr_info ); if( ret NEQ AT_CMPL ) { cmdCmeError(CME_ERR_Unknown); } else { if(phase NEQ NOT_PRESENT_8BIT) { i=sprintf(g_sa,"%s%d,", "%ATR: ", phase);/* if phase available.. return phase*/ } else { i=sprintf(g_sa,"%s", "%ATR: FFFF");/* else return FFFF*/ } if(atr_len) /* if ATR data available... return ATR data*/ { sprintf(g_sa+i,","); utl_binToHex( atr_info, atr_len, g_sa+i ); } io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); } return (map_aci_2_ati_rslt(ret)); #endif /* no FF_ATI_BAT */ } #endif /* TI_PS_FF_AT_P_CMD_ATR */ /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentCPRI | +--------------------------------------------------------------------+ PURPOSE : %CPRI command (select cipher indication mode) */ GLOBAL T_ATI_RSLT setatPercentCPRI ( char *cl, UBYTE srcId ) { T_ACI_RETURN ACI_return = AT_FAIL; UBYTE CPRImode; TRACE_FUNCTION( "setatPercentCPRI()" ); switch( *cl ) { case '0': case '1': CPRImode = *cl - 0x30; /* make binary value */ cl++; ACI_return = sAT_PercentCPRI( (T_ACI_CMD_SRC)srcId, CPRImode ); if( ACI_return NEQ AT_CMPL ) { cmdCmeError(CME_ERR_Unknown); } else /* If ACI_return is AT_CMPL,updates the CPRI_stat with CPRImode */ { ati_user_output_cfg[srcId].CPRI_stat = CPRImode; } break; default: cmdCmeError(CME_ERR_OpNotAllow); break; } return (map_aci_2_ati_rslt(ACI_return)); } GLOBAL T_ATI_RSLT queatPercentCPRI ( char *cl, UBYTE srcId ) { T_ACI_RETURN ACI_return = AT_FAIL; UBYTE CPRIenabled; TRACE_FUNCTION( "queatPercentCPRI()" ); ACI_return = qAT_PercentCPRI( (T_ACI_CMD_SRC)srcId, &CPRIenabled ); if( ACI_return NEQ AT_CMPL ) { cmdCmeError(CME_ERR_Unknown); } else { if (CPRIenabled) { CPRIenabled = ati_user_output_cfg[srcId].CPRI_stat; } else { CPRIenabled = CI_DISABLED; } resp_disp(srcId, cl,"b",&CPRIenabled); } return (map_aci_2_ati_rslt(ACI_return)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : | | STATE : code ROUTINE : setatPercentPVRF | +--------------------------------------------------------------------+ PURPOSE : return information relating to status of PIN. */ GLOBAL T_ATI_RSLT setatPercentPVRF( char *cl, UBYTE srcId ) { T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); T_ACI_PVRF_TYPE type; CHAR pin[10]; CHAR newpin[10]; T_ACI_RETURN ret = AT_FAIL; TRACE_FUNCTION( "setatPercentPVRF()" ); /* parse mode */ cl = parse (cl, "dss", &type, (LONG) sizeof (pin),pin, (LONG) sizeof (newpin), newpin); if (!cl OR (type > PVRF_TYPE_Puk2) OR (type <= PVRF_TYPE_NotPresent))/*lint !e685 (Warning -- :685 Relational operator '>' always evaluates to 'false ) */ { cmdCmeError (CME_ERR_OpNotAllow); return (ATI_FAIL); } #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_cmd_set_percent_pvrf pvrf; UBYTE len; cmd.ctrl_params = BAT_CMD_SET_PERCENT_PVRF; cmd.params.ptr_set_percent_pvrf=&pvrf; /* * This relies on T_ACI_PVRF_TYPE and T_BAT_percent_pvrf_type * being identical. They are, except in that the ACI version has * a 'not present' value. In this direction, that doesn't matter. */ pvrf.type=(T_BAT_percent_pvrf_type)type; len=strlen(pin); if (len>BAT_MAX_PVRF_PIN_LEN) return(ATI_FAIL); pvrf.c_pin=(U8)len; memcpy(pvrf.pin,pin,len); len=strlen(newpin); if (len>BAT_MAX_PVRF_NEW_PIN_LEN) return(ATI_FAIL); if (len) { pvrf.v_newpin=TRUE; pvrf.c_newpin=(U8)len; memcpy(pvrf.newpin,newpin,len); } else { pvrf.v_newpin=FALSE; } bat_send(ati_bat_get_client(srcId), &cmd); src_params->curAtCmd=AT_CMD_PVRF; return(ATI_EXCT); } #else /* no FF_ATI_BAT */ ret = sAT_PercentPVRF ((T_ACI_CMD_SRC)srcId, type, pin, newpin); switch (ret) { case (AT_CMPL): /*operation completed*/ break; case (AT_EXCT): src_params->curAtCmd = AT_CMD_PVRF; break; default: cmdCmeError(CME_ERR_Unknown); /*Command failed*/ break; } return (map_aci_2_ati_rslt(ret)); #endif /* no FF_ATI_BAT */ } /* +--------------------------------------------------------------------+ | PROJECT : GPRS (8441) MODULE : GACI_CMD | | STATE : code ROUTINE : queatPercentPVRF | +--------------------------------------------------------------------+ PURPOSE : %PVRF command */ GLOBAL T_ATI_RSLT queatPercentPVRF (char *cl, UBYTE srcId) { TRACE_FUNCTION("queatPercentPVRF()"); #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; cmd.ctrl_params = BAT_CMD_QUE_PERCENT_PVRF; dummy.bat_dummy = 0xFF; cmd.params.ptr_que_percent_pvrf = &dummy; bat_send(ati_bat_get_client(srcId), &cmd); return(ATI_EXCT); } #else /* no FF_ATI_BAT */ { T_ACI_PVRF_STAT ps1; T_ACI_PVRF_STAT ps2; CHAR *me = "%PVRF: "; SHORT pn1cnt = 0; SHORT pn2cnt = 0; SHORT pk1cnt = 0; SHORT pk2cnt = 0; T_ACI_RETURN ret = qAT_PercentPVRF((T_ACI_CMD_SRC)srcId, &pn1cnt, &pn2cnt, &pk1cnt, &pk2cnt, &ps1, &ps2); if (ret NEQ AT_CMPL) { cmdCmeError(CME_ERR_Unknown); return (ATI_FAIL); } sprintf(g_sa,"%s%d, %d, %d, %d, %d, %d", me, pn1cnt, pn2cnt, pk1cnt, pk2cnt, ps1, ps2); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); return (ATI_CMPL); } #endif /* no FF_ATI_BAT */ } #ifdef TI_PS_FF_AT_P_CMD_CUST /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : | | STATE : code ROUTINE : setatPercentCUST | +--------------------------------------------------------------------+ PURPOSE : %CUST command ( Set Customisation Mode Function ) */ GLOBAL T_ATI_RSLT setatPercentCUST ( char *cl, UBYTE srcId ) /* Function protype is T_ATI_RSLT not T_ACI_RETURN so it is changed */ { TRACE_FUNCTION( "setatPercentCUST()" ); #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_cmd_set_percent_cust cust; cmd.ctrl_params = BAT_CMD_SET_PERCENT_CUST; cmd.params.ptr_set_percent_cust=&cust; switch (*cl) { case '0': cust.mode=BAT_P_CUST_MODE_NORMAL; break; case '1': cust.mode=BAT_P_CUST_MODE_BEHAVIOUR_1; break; default: cmdCmeError(CME_ERR_OpNotAllow); return(ATI_FAIL); } bat_send(ati_bat_get_client(srcId), &cmd); return(ATI_EXCT); } #else /* no FF_ATI_BAT */ switch( *cl ) { case '0': if (sAT_PercentCUST((T_ACI_CMD_SRC)srcId, CUST_NORMAL_BEHAVIOUR) EQ AT_FAIL) { cmdCmeError(CME_ERR_Unknown); return (ATI_FAIL); } break; case '1': if (sAT_PercentCUST ((T_ACI_CMD_SRC)srcId, CUST_MODE_BEHAVIOUR_1) EQ AT_FAIL) { cmdCmeError(CME_ERR_Unknown); return (ATI_FAIL); } break; default: cmdCmeError(CME_ERR_OpNotAllow); return (ATI_FAIL); } return (ATI_CMPL); #endif /* no FF_ATI_BAT */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : queatPercentCUST | +--------------------------------------------------------------------+ PURPOSE : %CUST command (Customisaton Mode) */ GLOBAL T_ATI_RSLT queatPercentCUST (char *cl, UBYTE srcId) { TRACE_FUNCTION("queatPercentCUST()"); #ifdef FF_ATI_BAT { T_BAT_cmd_send cmd; T_BAT_no_parameter dummy; cmd.ctrl_params = BAT_CMD_QUE_PERCENT_CUST; dummy.bat_dummy = 0xFF; cmd.params.ptr_que_percent_cust = &dummy; bat_send(ati_bat_get_client(srcId), &cmd); return(ATI_EXCT); } #else /* no FF_ATI_BAT */ { T_CUST_MOD mode; T_ACI_RETURN ret = qAT_PercentCUST((T_ACI_CMD_SRC)srcId, &mode); if (ret NEQ AT_CMPL) { cmdCmeError(CME_ERR_Unknown); return (ATI_FAIL); } sprintf(g_sa,"%%CUST: %d", mode); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); return ATI_CMPL; } #endif /* no FF_ATI_BAT */ } #endif /* TI_PS_FF_AT_P_CMD_CUST */ /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : | | STATE : code ROUTINE : setatPercentSATCC | +--------------------------------------------------------------------+ PURPOSE : %SATCC command ( Enable/Disable the Call/Short Message Control By SIM ) */ GLOBAL T_ATI_RSLT setatPercentSATCC ( char *cl, UBYTE srcId ) /* Function protype is T_ATI_RSLT not T_ACI_RETURN so it is changed */ { #ifdef FF_ATI_BAT T_BAT_cmd_send bat_cmd; T_BAT_cmd_set_percent_satcc satcc; #endif TRACE_FUNCTION( "setatPercentSATCC()" ); #ifdef FF_ATI_BAT switch( *cl ) { case '0': satcc.mode = BAT_P_SATCC_MODE_INACTIVE; break; case '1': satcc.mode = BAT_P_SATCC_MODE_ACTIVE; break; default: cmdCmeError(CME_ERR_Unknown); return (ATI_FAIL); } bat_cmd.ctrl_params = BAT_CMD_SET_PERCENT_SATCC; bat_cmd.params.ptr_set_percent_satcc = &satcc; bat_send(ati_bat_get_client(srcId),&bat_cmd); return(ATI_EXCT); #else switch( *cl ) { case '0': if (sAT_PercentSATCC((T_ACI_CMD_SRC)srcId, SATCC_CONTROL_BY_SIM_INACTIVE) EQ AT_FAIL) { cmdCmeError(CME_ERR_Unknown); return (ATI_FAIL); } break; case '1': if (sAT_PercentSATCC ((T_ACI_CMD_SRC)srcId, SATCC_CONTROL_BY_SIM_ACTIVE) EQ AT_FAIL) { cmdCmeError(CME_ERR_Unknown); return (ATI_FAIL); } break; default: cmdCmeError(CME_ERR_OpNotAllow); return (ATI_FAIL); } return (ATI_CMPL); #endif } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : queatPercentSATCC | +--------------------------------------------------------------------+ PURPOSE : %SATCC command (Query Call/Short Message control By SIM) */ GLOBAL T_ATI_RSLT queatPercentSATCC (char *cl, UBYTE srcId) { #ifdef FF_ATI_BAT T_BAT_cmd_send bat_cmd; T_BAT_no_parameter satcc; #else T_SAT_CC_MOD mode; T_ACI_RETURN ret = AT_FAIL; #endif TRACE_FUNCTION("queatPercentSATCC()"); #ifdef FF_ATI_BAT bat_cmd.ctrl_params = BAT_CMD_QUE_PERCENT_SATCC; bat_cmd.params.ptr_que_percent_satcc = &satcc; bat_send(ati_bat_get_client(srcId),&bat_cmd); return(ATI_EXCT); #else ret = qAT_PercentSATCC((T_ACI_CMD_SRC)srcId, &mode); if (ret NEQ AT_CMPL) { cmdCmeError(CME_ERR_Unknown); return (ATI_FAIL); } sprintf(g_sa,"%%SATCC: %d", mode); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); #endif /*FF_ATI_BAT*/ return ATI_CMPL; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentSIMIND | +--------------------------------------------------------------------+ PURPOSE : enable %SIMINS / %SIMREM indications */ GLOBAL T_ATI_RSLT setatPercentSIMIND(char *cl, UBYTE srcId) { int mode = 1; TRACE_FUNCTION("setatPercentSIMIND()"); /* parse mode */ cl = parse (cl, "d", &mode); if (mode EQ 0 OR mode EQ 1) { ati_user_output_cfg[srcId].SIMIND_stat = mode; return (ATI_CMPL); } else { cmdCmeError(CME_ERR_OpNotAllow); return (ATI_FAIL); } } /* +--------------------------------------------------------------------+ | PROJECT : GPRS (8441) MODULE : ACI_CMD | | STATE : code ROUTINE : queatPercentSIMIND | +--------------------------------------------------------------------+ PURPOSE : query status of %SIMINS / %SIMREM indications */ GLOBAL T_ATI_RSLT queatPercentSIMIND(char *cl, UBYTE srcId) { CHAR *me = "%SIMIND"; TRACE_FUNCTION("queatPercentSIMIND()"); sprintf(g_sa,"%s: %d", me, ati_user_output_cfg[srcId].SIMIND_stat); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); return (ATI_CMPL); } #ifdef FF_DUAL_SIM /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : atPlusCFUN | +--------------------------------------------------------------------+ PURPOSE : %SIM command (SIM Selection) */ GLOBAL T_ATI_RSLT setatPercentSIM (char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; UBYTE sim_num; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION("setatPercentSIM()"); /*input functionality*/ cl = parse (cl,"d",&sim_num); if ( !cl ) { cmdCmeError (CME_ERR_OpNotAllow); return(ATI_FAIL); } ret = sAT_PercentSIM (srcId,sim_num); switch (ret) { case AT_EXCT: /*Command is executing*/ src_params->curAtCmd = AT_CMD_SIM; break; case AT_FAIL: src_params->curAtCmd = AT_CMD_NONE; break; default: cmdCmeError(CME_ERR_Unknown); break; } return (map_aci_2_ati_rslt (ret)); } GLOBAL T_ATI_RSLT queatPercentSIM (char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; UBYTE sim_num; TRACE_FUNCTION("queatPercentSIM()"); ret = qAT_PercentSIM(srcId, &sim_num); if (ret EQ AT_CMPL) { resp_disp(srcId, cl,"b",&sim_num); return ATI_CMPL; } else { cmdCmeError(CME_ERR_Unknown); return ATI_FAIL; } } #endif /*FF_DUAL_SIM*/ #ifdef FF_CPHS_REL4 /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentCFIS | +--------------------------------------------------------------------+ PURPOSE : %CFIS command (Call Forwarding Unconditional) */ GLOBAL T_ATI_RSLT setatPercentCFIS (char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; T_ACI_CFIS_MOD cfisMode = CFIS_MOD_NotPresent; UBYTE index = NOT_PRESENT_8BIT; UBYTE mspId; UBYTE cfuStat; CHAR number[MAX_PHB_NUM_LEN]; T_ACI_TOA type; T_ACI_TOA *p_type; SHORT toa_oct = 0; UBYTE cc2_Id = NOT_PRESENT_8BIT; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION( "setatPercentCFIS()" ); /* init */ memset( number, 0, sizeof(number)); cl = parse (cl, "ddddsdd", &cfisMode, &index, &mspId, &cfuStat, (LONG)MAX_PHB_NUM_LEN, number, &toa_oct , &cc2_Id); if(!cl) { cmdCmeError(CME_ERR_OpNotAllow); return (ATI_FAIL); } if (toa_oct EQ 0) { p_type = NULL; } else { type=toa_demerge(toa_oct); p_type = &type; } if( cfisMode EQ CFIS_MOD_Read) { ret=qAT_PercentCFIS(srcId, index ); } else { ret = sAT_PercentCFIS(srcId, cfisMode,index,mspId, cfuStat, number, p_type, cc2_Id); } switch (ret) { case AT_EXCT: /*Command is executing*/ src_params->curAtCmd = AT_CMD_P_CFIS; break; default: src_params->curAtCmd = AT_CMD_NONE; cmdCmeError(CME_ERR_Unknown); break; } return (map_aci_2_ati_rslt (ret)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentMWIS | +--------------------------------------------------------------------+ PURPOSE : %MWIS command (Message Waiting Indication Status) */ GLOBAL T_ATI_RSLT setatPercentMWIS (char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; T_ACI_MWIS_MOD mwisMode = MWIS_MOD_Invalid; UBYTE mspId = NOT_PRESENT_8BIT; T_ACI_MWIS_MWI mwis; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION( "setatPercentMWIS()" ); memset(&mwis, 0, sizeof(T_ACI_MWIS_MWI)); cl = parse (cl, "ddddddd", &mwisMode, &mspId, &mwis.mwiStat, &mwis.mwis_count_voice, &mwis.mwis_count_fax, &mwis.mwis_count_email,&mwis.mwis_count_other); if(!cl) { cmdCmeError(CME_ERR_OpNotAllow); return (ATI_FAIL); } if( mwisMode EQ MWIS_MOD_Read) { ret = qAT_PercentMWIS(srcId, mspId ); } else { ret = sAT_PercentMWIS(srcId, mwisMode,mspId, &mwis); } switch (ret) { case AT_EXCT: /*Command is executing*/ src_params->curAtCmd = AT_CMD_P_MWIS; break; default: src_params->curAtCmd = AT_CMD_NONE; cmdCmeError(CME_ERR_Unknown); break; } return (map_aci_2_ati_rslt (ret)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentMWI | +--------------------------------------------------------------------+ PURPOSE : %MWI command (Message Waiting Indication) */ GLOBAL T_ATI_RSLT setatPercentMWI(char *cl, UBYTE srcId) { SHORT mode = ACI_NumParmNotPresent; TRACE_FUNCTION("setatPercentMWI()"); cl = parse(cl,"r",&mode); if(!cl OR mode > 1 OR mode < 0) { cmdCmeError(CME_ERR_OpNotAllow); return (ATI_FAIL); } ati_user_output_cfg[srcId].MWI_stat=(UBYTE)mode; return (ATI_CMPL); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : queatPercentMWI | +--------------------------------------------------------------------+ PURPOSE : %MWI command (Message Waiting Indication) */ GLOBAL T_ATI_RSLT queatPercentMWI(char *cl, UBYTE srcId) { UBYTE mode; TRACE_FUNCTION("queatPercentMWI()"); mode = ati_user_output_cfg[srcId].MWI_stat; resp_disp(srcId, cl,"b",&mode); return (ATI_CMPL); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentMBI | +--------------------------------------------------------------------+ PURPOSE : %MBI command (Mailbox Identifier) */ GLOBAL T_ATI_RSLT setatPercentMBI (char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; T_ACI_MBN_MODE mbiMode = MBN_Mode_Invalid; UBYTE index = NOT_PRESENT_8BIT; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION( "setatPercentMBI()" ); cl = parse (cl, "dd", &mbiMode, &index); if(!cl OR (mbiMode NEQ MBN_Mode_Read)) { cmdCmeError(CME_ERR_OpNotAllow); return (ATI_FAIL); } ret = qAT_PercentMBI(srcId, index ); switch (ret) { case AT_EXCT: /*Command is executing*/ src_params->curAtCmd = AT_CMD_P_MBI; break; default: src_params->curAtCmd = AT_CMD_NONE; cmdCmeError(CME_ERR_Unknown); break; } return (map_aci_2_ati_rslt (ret)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | STATE : code ROUTINE : setatPercentMBDN | +--------------------------------------------------------------------+ PURPOSE : %MBDN command (Mailbox Dialling Number) */ GLOBAL T_ATI_RSLT setatPercentMBDN (char *cl, UBYTE srcId) { T_ACI_RETURN ret = AT_FAIL; T_ACI_MBN_MODE mbdnMode = MBN_Mode_Invalid; UBYTE index = 0; CHAR number[MAX_MB_NUM_LEN]; CHAR alpha_id[MAX_ALPHA_LEN] = {0x00}; USHORT len_alpha_id = 0; USHORT lenCvtd = 0; /* holds length of converted text */ T_ACI_PB_TEXT *p_text = NULL; /* holds pointer to converted text */ T_ACI_PB_TEXT cvtdText; /* holds text converted to SIM alpha */ T_ACI_TOA type; T_ACI_TOA *p_type; CHAR *p_number; SHORT toa_oct = 0; UBYTE cc2_Id = NOT_PRESENT_8BIT; T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); TRACE_FUNCTION( "setatPercentMBDN()" ); /* init */ memset( number, 0, sizeof(number)); cl = parse (cl, "ddsddz", &mbdnMode, &index,(LONG)MAX_MB_NUM_LEN, number, &toa_oct , &cc2_Id, (LONG)MAX_ALPHA_LEN, strlen(cl), cl, &len_alpha_id, alpha_id); if(!cl OR (mbdnMode < 0 OR mbdnMode > 2) OR (!index)) { cmdCmeError(CME_ERR_OpNotAllow); return (ATI_FAIL); } /* translate alpha text to SIM */ if ( len_alpha_id NEQ 0 ) { utl_chsetToSim ((UBYTE*)alpha_id, len_alpha_id, (UBYTE*)cvtdText.data, &lenCvtd, GSM_ALPHA_Def); } if (toa_oct EQ 0) { p_type = NULL; } else { type=toa_demerge(toa_oct); p_type = &type; } /* when the text is empty p_text to NULL */ if (lenCvtd EQ 0 ) { p_text = NULL; } else { p_text = &cvtdText; cvtdText.len = (UBYTE)lenCvtd; } /* set pointer for number */ if (number[0] EQ '\0') /* The number given is empty */ { p_number = NULL; } else { p_number = number; } if( mbdnMode EQ MBN_Mode_Read) { ret = qAT_PercentMBDN(srcId, index ); } else { ret = sAT_PercentMBDN(srcId, mbdnMode,index, p_number, p_type, cc2_Id, p_text); } switch (ret) { case AT_EXCT: /*Command is executing*/ src_params->curAtCmd = AT_CMD_P_MBDN; break; default: src_params->curAtCmd = AT_CMD_NONE; cmdCmeError(CME_ERR_Unknown); break; } return (map_aci_2_ati_rslt (ret)); } #endif /* FF_CPHS_REL4 */ #endif /* ATI_SIM_C */