FreeCalypso > hg > fc-tourmaline
diff src/g23m-aci/aci/ati_cc.c @ 1:fa8dc04885d8
src/g23m-*: import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Fri, 16 Oct 2020 06:25:50 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-aci/aci/ati_cc.c Fri Oct 16 06:25:50 2020 +0000 @@ -0,0 +1,2948 @@ +/* ++----------------------------------------------------------------------------- +| 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: Call Control related commands. ++----------------------------------------------------------------------------- +*/ +#ifndef ATI_CC_C +#define ATI_CC_C + +#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 "aci_lst.h" + +#include "aci_cmh.h" +#include "ati_cmd.h" +#include "aci_io.h" +#include "aci_cmd.h" + +#include "aci.h" +#include "l4_tim.h" +#include "aci_mem.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 */ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : cleanDialStr | ++--------------------------------------------------------------------+ + + PURPOSE : This function removes all invalid or unsupported characters + from the null terminated dial string. + +*/ + +LOCAL void cleanDialStr( CHAR * dialStr ) +{ + USHORT i,j,k = 0; + USHORT dialLen, charLen; + CHAR *valChrs = "0123456789*#+-ABCDPpWw"; + UBYTE match = FALSE; + + dialLen = strlen(dialStr ); + charLen = strlen(valChrs ); + + for (i=0;i<dialLen;i++) + { + match=FALSE; + + for (j=0;j<charLen;j++) + { + if (dialStr[i] EQ valChrs[j]) + { + match = TRUE; + break; + } + } + + if (match) + { + dialStr[k] = dialStr[i]; + k++; + } + } + + dialStr[k] = 0x0; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : | ++--------------------------------------------------------------------+ + + PURPOSE : D (dial command) +*/ + +#define NAME_BUF_LEN 32 +#define DIAL_BUF_LEN (MAX_DIAL_LEN-1) + +GLOBAL T_ATI_RSLT atD (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + char alpha [NAME_BUF_LEN] = {'\0'}; + USHORT lenAlpha = 0; + char cvtdAlpha[NAME_BUF_LEN] = {'\0'}; + USHORT lenCvtdAlpha = 0; + char t [DIAL_BUF_LEN] = {'\0'}; + char* t_p = NULL; + USHORT pos = 0; + SHORT index = -1; + + T_ACI_PB_STOR mem_stor = PB_STOR_NotPresent; + T_ACI_D_CLIR_OVRD clir_ovrd = D_CLIR_OVRD_Default; + T_ACI_D_CUG_CTRL cug_ctrl = D_CUG_CTRL_NotPresent; + T_ACI_D_TOC call_type = D_TOC_Data; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + src_params->curAtCmd = AT_CMD_D; + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_at_d bat_dial; + + cmd.ctrl_params = BAT_CMD_AT_D; + cmd.params.ptr_at_d = &bat_dial; + +#pragma message(__TODO__"atD(): check for UCS2 dial string before bat_send()") + + bat_dial.c_dial_string = strlen(cl); + if (bat_dial.c_dial_string) + { + memcpy (bat_dial.dial_string, (U8 *)cl, bat_dial.c_dial_string); + + TRACE_FUNCTION("atD() calls bat_send() <=== as APPLICATION"); + + bat_send(ati_bat_get_client(srcId), &cmd); + cmdErrStr = NULL; + srcId_cb = srcId; + rCI_PlusCCWV (CCWV_CHRG_NotPresent); + return (ATI_EXCT); /* executing, because response is passed by callback function */ + } + else + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + } +#else /* no FF_ATI_BAT */ + { + BOOL Book_Dial; + U16 i; +#ifdef NO_ASCIIZ + T_ACI_PB_TEXT pbText; +#endif + + TRACE_FUNCTION("atD()"); + + t_p=t; + if (*cl EQ '>') /*call from Phonebook*/ + { + Book_Dial=TRUE; + cl++; + if(*cl EQ '"') /*origin call to name given by string */ + { + cl=parse(cl,"z", + (LONG)NAME_BUF_LEN, + strlen(cl), + cl, + &lenAlpha, + alpha); + if (cl EQ NULL) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + else if (strcspn(cl,"iIgG;") NEQ 0) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + srcId_cb = srcId; + #ifdef NO_ASCIIZ + utl_chsetToSim ( (UBYTE*)alpha, + lenAlpha, + (UBYTE*)cvtdAlpha, + &lenCvtdAlpha, + GSM_ALPHA_Def ); + #else /* #ifdef NO_ASCIIZ */ + utl_chsetToGsm ( (UBYTE*)alpha, + lenAlpha, + (UBYTE*)cvtdAlpha, + &lenCvtdAlpha, +#ifdef REL99 + sizeof(cvtdAlpha), +#endif + GSM_ALPHA_Int); + #endif /* #ifdef NO_ASCIIZ */ + t_p = cvtdAlpha; + } + else + { + /* call using phonebook with pb specified*/ + if ((toupper(*cl)) >= 65 AND (toupper(*cl)) <= 90) + { + for (i=0;phb_mem_names[i].name != 0;i++) + { + strupper(cl); + if (strncmp(cl,phb_mem_names[i].name,2) EQ 0) + { + mem_stor=phb_mem_names[i].stor; + break; + } + else mem_stor=PB_STOR_NotPresent; + } + if (mem_stor < 0) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + cl=cl+2; + } + pos=strcspn(cl,"iIgG;"); /* determine index */ + if (pos EQ 0 OR pos >= DIAL_BUF_LEN) + { + TRACE_EVENT("incorrect strspn"); + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + strncpy(t,cl,pos); + cl=cl+pos; + index =(SHORT)atoi(t); + + if(!index OR index > 300) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + t_p = NULL; + } + } + else + { + Book_Dial=FALSE; + pos=strcspn(cl,"iIgG;"); + if(pos >= DIAL_BUF_LEN) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + if (pos) + { + strncpy(t,cl,pos); + cl=cl+pos; + t[pos]='\0'; + } + else + { + if(strlen(cl) >= DIAL_BUF_LEN) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + strcpy(t,cl); + } + + cleanDialStr(t); + if (t[0] EQ '\0') + t_p=NULL; + } + + if (*cl EQ 'i') + { + clir_ovrd=D_CLIR_OVRD_Supp; + cl++; + } + if (*cl EQ 'I') + { + clir_ovrd=D_CLIR_OVRD_Invoc; + cl++; + } + if (*cl EQ 'g'OR *cl EQ 'G') + { + cug_ctrl=D_CUG_CTRL_Present; + cl++; + } + if (*cl EQ ';') + { + call_type=D_TOC_Voice; + cl++; + } + if (*cl NEQ '\0') + { + cmdCmeError(CME_ERR_InvDialChar); + return (ATI_FAIL); + } + + if(Book_Dial) + { + #ifdef NO_ASCIIZ + if ( t_p NEQ NULL ) + { + pbText.cs = CS_Sim; + pbText.len = (UBYTE)lenCvtdAlpha; + memcpy( pbText.data, t_p, pbText.len ); + } + else + { + pbText.cs = CS_NotPresent; + pbText.len = 0; + } + ret = sAT_Dm( (T_ACI_CMD_SRC)srcId, &pbText, mem_stor, index, clir_ovrd, + cug_ctrl, call_type ); + #else /* #ifdef NO_ASCIIZ */ + ret = sAT_Dm( srcId, t_p, mem_stor, index, clir_ovrd, + cug_ctrl, call_type ); + #endif /* #ifdef NO_ASCIIZ */ + } + else + { + ret=sAT_Dn((T_ACI_CMD_SRC)srcId,t_p,clir_ovrd,cug_ctrl,call_type); + } + + if (ret EQ AT_EXCT) + { + if (call_type EQ D_TOC_Voice AND + at.flags.COLP_stat NEQ 1 ) + { + cmdErrStr = NULL; + } + else + { + src_params->curAtCmd = AT_CMD_D; + } + srcId_cb = srcId; + rCI_PlusCCWV ( CCWV_CHRG_NotPresent ); + + return (ATI_EXCT); + } + else if( ret EQ AT_CMPL ) + { + srcId_cb = srcId; + rCI_OK (AT_CMD_D); + return (ATI_CMPL_NO_OUTPUT); + } + else + { + cmdCmeError(CME_ERR_Unknown); + return (ATI_FAIL); + } + } +#endif /* no FF_ATI_BAT */ +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atA | ++--------------------------------------------------------------------+ + + PURPOSE : A command (Answer a call) +*/ + +GLOBAL T_ATI_RSLT atA(char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + +#ifdef FF_ATI_BAT + T_BAT_cmd_send cmd; + T_BAT_no_parameter dummy; + + TRACE_FUNCTION("atA() calls bat_send() <=== as APPLICATION"); + + cmd.ctrl_params = BAT_CMD_AT_A; + dummy.bat_dummy = 0xFF; + cmd.params.ptr_at_a = &dummy; + + if( at.rngPrms.isRng EQ TRUE ) + { + ati_stop_ring(); + } + src_params->curAtCmd = AT_CMD_A; + + 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("atA()"); + + if(*cl NEQ '\0') + { + cmdAtError(atError); + } + else + { + ret=sAT_A((T_ACI_CMD_SRC)srcId); + if (ret EQ AT_EXCT) + { + if( at.rngPrms.isRng EQ TRUE ) + { + ati_stop_ring(); + } + src_params->curAtCmd = AT_CMD_A; + } + else + { + cmdAtError(atError); + } + } + return (map_aci_2_ati_rslt(ret)); + +#endif /* no FF_ATI_BAT */ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atH | ++--------------------------------------------------------------------+ + + PURPOSE : H command (Hangs up single mode call) +*/ +GLOBAL T_ATI_RSLT atH(char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + +#ifdef FF_ATI_BAT + T_BAT_cmd_send cmd; + T_BAT_no_parameter dummy; + cmd.ctrl_params = BAT_CMD_AT_H; + dummy.bat_dummy = 0xFF; + cmd.params.ptr_at_h = &dummy; + + TRACE_FUNCTION("atH() calls bat_send() <=== as APPLICATION"); + + if( at.rngPrms.isRng EQ TRUE ) + { + ati_stop_ring(); + } + src_params->curAtCmd = AT_CMD_H; + + 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("atH()"); + + if (*cl EQ '0' OR *cl EQ '\0') + { + if (*cl EQ '0') + { + cl++; + } + + ret=sAT_H((T_ACI_CMD_SRC)srcId); + if (ret EQ AT_EXCT) + { + if( at.rngPrms.isRng EQ TRUE ) + { + ati_stop_ring(); + } + src_params->curAtCmd = AT_CMD_H; + } + else + { + cmdAtError(atError); + } + } + else + { + cmdAtError(atError); + } + return (map_aci_2_ati_rslt(ret)); + +#endif /* no FF_ATI_BAT */ +} + +#ifdef FAX_AND_DATA +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCBST | ++--------------------------------------------------------------------+ + + PURPOSE : +CBST command (Select Bearer Service Type) +*/ + +GLOBAL T_ATI_RSLT setatPlusCBST(char *cl, UBYTE srcId) +{ + T_ACI_BS_SPEED speed = BS_SPEED_NotPresent; + T_ACI_CBST_NAM name = CBST_NAM_NotPresent; + T_ACI_CBST_CE ce = CBST_CE_NotPresent; + T_ACI_RETURN ret = AT_FAIL; + + cl = parse(cl, "ddd", &speed, &name, &ce); + if(!cl ) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_cbst my_bat_set_plus_cbst; + + TRACE_FUNCTION("setatPlusCBST() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_cbst, 0, sizeof(my_bat_set_plus_cbst)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CBST; + cmd.params.ptr_set_plus_cbst = &my_bat_set_plus_cbst; + + my_bat_set_plus_cbst.speed = speed; + my_bat_set_plus_cbst.name = name; + my_bat_set_plus_cbst.ce = ce; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("atPLusCBST()"); + { + ret = sAT_PlusCBST((T_ACI_CMD_SRC)srcId,speed,name,ce); + } + if (ret EQ AT_FAIL) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + return (ATI_CMPL); + +#endif /* no FF_ATI_BAT*/ +} + +GLOBAL T_ATI_RSLT queatPlusCBST(char *cl, UBYTE srcId) +{ + T_ACI_BS_SPEED speed = BS_SPEED_NotPresent; + T_ACI_CBST_NAM name = CBST_NAM_NotPresent; + T_ACI_CBST_CE ce = CBST_CE_NotPresent; + T_ACI_RETURN ret = AT_FAIL; + + TRACE_FUNCTION("atPLusCBST()"); + + ret = qAT_PlusCBST((T_ACI_CMD_SRC)srcId,&speed,&name,&ce); + if (ret EQ AT_CMPL) + { + resp_disp(srcId, cl,"eee",&speed,&name,&ce); + } + else + { + cmdCmeError(CME_ERR_OpNotAllow); /* AT_FAIL, AT_EXCT, AT_BUSY ??? */ + return (ATI_FAIL); + } + return (ATI_CMPL); + +} +#endif /* FAX_AND_DATA */ + +/* +PURPOSE : Change some AT interface output configuration + (+CRC +CR +CLIP +COLP) +*/ +GLOBAL T_ATI_RSLT GenAtCR_C( CHAR *cl, UBYTE srcId, T_ACI_AT_CMD cmd ) +{ + UBYTE x = 0; + + switch(*cl) + { + case('0'): + case('1'): + /* value ok */ + break; + default: + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + x = *cl - '0'; + cl++; + + switch(cmd) + { + case( AT_CMD_CRC ): + ati_user_output_cfg[srcId].CRC_stat = x; + return (ATI_CMPL); + case( AT_CMD_CR ): + ati_user_output_cfg[srcId].CR_stat = x; + return (ATI_CMPL); + case( AT_CMD_CLIP ): + ati_user_output_cfg[srcId].CLIP_stat = x; + return (ATI_CMPL); + case( AT_CMD_CDIP ): + ati_user_output_cfg[srcId].CDIP_stat = x; + return (ATI_CMPL); + case( AT_CMD_COLP ): + at.flags.COLP_stat = x; + return (ATI_CMPL); + } + + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); +} + +#ifdef FF_TTY +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPercentCTTY | ++--------------------------------------------------------------------+ + + PURPOSE : %CTTY command (handle CTM/TTY service) +*/ + +GLOBAL T_ATI_RSLT setatPercentCTTY (char *cl, UBYTE srcId) +{ + T_ACI_CTTY_MOD mode = CTTY_MOD_NotPresent; + T_ACI_CTTY_REQ req = CTTY_REQ_NotPresent; + + cl = parse (cl, "dd", &mode, &req); + + if (!cl) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_percent_ctty my_bat_set_percent_ctty; + + TRACE_FUNCTION("setatPercentCTTY() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_percent_ctty, 0, sizeof(my_bat_set_percent_ctty)); + cmd.ctrl_params = BAT_CMD_SET_PERCENT_CTTY; + cmd.params.ptr_set_percent_ctty = &my_bat_set_percent_ctty; + + my_bat_set_percent_ctty.req = req; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + { + T_ACI_RETURN ret; + + TRACE_FUNCTION("setatPercentCTTY()"); + + ret = sAT_PercentCTTY ((T_ACI_CMD_SRC)srcId, mode, req); + switch (ret) + { + case (AT_CMPL): /* operation completed */ + break; + case (AT_EXCT): /* not valid */ + ret = AT_CMPL; + break; + default: + cmdCmeError(CME_ERR_NotPresent); /* Command failed */ + break; + } + return (map_aci_2_ati_rslt(ret)); + } +#endif /* no FF_ATI_BAT*/ +} + +GLOBAL T_ATI_RSLT queatPercentCTTY (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret; + T_ACI_CTTY_MOD mode; + T_ACI_CTTY_REQ req; + T_ACI_CTTY_STAT state; + T_ACI_CTTY_TRX trx; + + TRACE_FUNCTION("queatPercentCTTY()"); + + ret = qAT_PercentCTTY ((T_ACI_CMD_SRC)srcId, &mode, &req, &state, &trx); + + if (ret EQ AT_CMPL) + { + if (trx EQ CTTY_TRX_Unknown) + resp_disp (srcId, cl,"eee",&mode, &req, &state); + else + resp_disp (srcId, cl,"eeee",&mode, &req, &state, &trx); + return ATI_CMPL; + } + else + cmdCmeError (CME_ERR_Unknown); + + return ATI_FAIL; +} +#endif /* FF_TTY */ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCRC | ++--------------------------------------------------------------------+ + + PURPOSE : +CRC command (Select extended incoming call report) +*/ + +GLOBAL T_ATI_RSLT setatPlusCRC (char *cl, UBYTE srcId) +{ + TRACE_FUNCTION("setatPlusCRC()"); + + return(GenAtCR_C( cl, srcId, AT_CMD_CRC )); +} + +GLOBAL T_ATI_RSLT queatPlusCRC (char *cl, UBYTE srcId) +{ + TRACE_FUNCTION("queatPlusCRC()"); + + resp_disp(srcId, cl,"b",&ati_user_output_cfg[srcId].CRC_stat); + return (ATI_CMPL); +} + +/*> ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCSTA | ++--------------------------------------------------------------------+ + + PURPOSE : +CSTA command (Select type of address) +*/ + +GLOBAL T_ATI_RSLT setatPlusCSTA(char *cl, UBYTE srcId) +{ + SHORT toa_val=0; + T_ACI_TOA type; +#ifdef FF_ATI_BAT + T_ACI_TOA *p_type=NULL; +#endif /* FF_ATI_BAT */ + T_ACI_RETURN ret = AT_FAIL; + + cl = parse(cl, "r", &toa_val); + if (!cl) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } +#ifdef FF_ATI_BAT + p_type = &type; + if (toa_val EQ 0) + p_type = NULL; + else +#endif /* FF_ATI_BAT */ + { + type=toa_demerge(toa_val); + if (type.ton < 0 OR type.npi < 0) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_csta my_bat_set_plus_csta; + + TRACE_FUNCTION("setatPlusCSTA() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_csta, 0, sizeof(my_bat_set_plus_csta)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CSTA; + cmd.params.ptr_set_plus_csta = &my_bat_set_plus_csta; + + my_bat_set_plus_csta.type = (S16)p_type; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPLusCSTA()"); + + ret = sAT_PlusCSTA((T_ACI_CMD_SRC)srcId, &type); + + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + +GLOBAL T_ATI_RSLT queatPlusCSTA(char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_TOA type; + SHORT toa_val = 0; + + TRACE_FUNCTION("queatPLusCSTA()"); + + ret = qAT_PlusCSTA((T_ACI_CMD_SRC)srcId,&type); + toa_val = toa_merge (type); + if (ret EQ AT_CMPL) + { + resp_disp(srcId, cl,"s",&toa_val); + } + else + { + cmdCmeError(CME_ERR_Unknown); + } + return (map_aci_2_ati_rslt (ret)); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCHLD | ++--------------------------------------------------------------------+ + + PURPOSE : common function for +/%CHLD command +*/ +LOCAL T_ATI_RSLT setatPlus_PercentCHLD(char *cl, UBYTE srcId, T_ACI_CHLD_CMD cmdType) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CHLD_MOD mode = CHLD_MOD_NotPresent; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + CHAR CHLD_type = '\0'; + CHAR X_prm[2]; + + X_prm[0] = (CHAR)NOT_PRESENT_8BIT; + + /* check first parameter of CHLD */ + CHLD_type = *cl; + ++cl; + + /* check for special PERCENT command */ + if((CHLD_type EQ '6') AND (cmdType NEQ CHLD_PercentCmd)) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + /* check for rest of parameter if necessary (only for AT+CHLD=1 / 2 / or 4) */ + if( CHLD_type EQ '1' + OR CHLD_type EQ '2' + OR CHLD_type EQ '4' + OR CHLD_type EQ '6' + OR CHLD_type EQ '7' ) + { + /* possibility of an X or directory parameter */ + if (*cl EQ 0 OR *cl EQ ';') /* end of command */ + { + X_prm[0] = (CHAR)NOT_PRESENT_8BIT; + } + else + { + if( *cl < '0' OR *cl > '9') + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + else + { + X_prm[0] = *cl; + X_prm[1] = '\0'; + cl++; + } + } + } + + switch(CHLD_type) + { + case ('0'): + mode = CHLD_MOD_RelHldOrUdub; + break; + + case ('1'): + if ( X_prm[0] EQ (CHAR)NOT_PRESENT_8BIT ) + { + mode = CHLD_MOD_RelActAndAcpt; + } + else + { + mode = CHLD_MOD_RelActSpec; + } + break; + + case('2'): + if ( X_prm[0] EQ (CHAR)NOT_PRESENT_8BIT ) + { + mode = CHLD_MOD_HldActAndAcpt; + } + else + { + mode = CHLD_MOD_HldActExc; + } + break; + + case('3'): + mode = CHLD_MOD_AddHld; + break; + + case('4'): + mode = CHLD_MOD_Ect; + break; + + case('5'): + mode = CHLD_MOD_Ccbs; + break; + + case('6'): + /* S60/Symbian requires an extra mode in %CHLD only: + retrieving of an [specific] hold call + without affecting of an waiting call */ + if ( X_prm[0] EQ (CHAR)NOT_PRESENT_8BIT ) + { + mode = CHLD_MOD_RetrieveHoldCall; + } + else + { + mode = CHLD_MOD_RetrieveHoldCallSpec; + } + break; + + case('7'): + /* BMI requires an extra mode in %CHLD only: + releasing of an [specific] hold call of any type */ + if ( X_prm[0] EQ (CHAR)NOT_PRESENT_8BIT ) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + else + { + mode = CHLD_MOD_RelAnySpec; + } + break; + + case('h'): + case('H'): + /* FTA requires an extra mode: Put on hold (without + accepting automatically waiting or held calls) */ + mode = CHLD_MOD_OnlyHold; + break; + + case('i'): + case('I'): + /* Release dialing call, without dropping current call. */ + mode = CHLD_MOD_RelDialCall; + break; + + default: + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_percent_chld my_bat_set_percent_chld; + + TRACE_FUNCTION("setatPlus_PercentCHLD() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_percent_chld, 0, sizeof(my_bat_set_percent_chld)); + cmd.ctrl_params = BAT_CMD_SET_PERCENT_CHLD; + cmd.params.ptr_set_percent_chld = &my_bat_set_percent_chld; + + my_bat_set_percent_chld.n = mode; + my_bat_set_percent_chld.x = (S16)&X_prm; + src_params->curAtCmd = AT_CMD_CHLD; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPlus_PercentCHLD()"); + + if( X_prm[0] NEQ (CHAR)NOT_PRESENT_8BIT ) + { + if(cmdType EQ CHLD_PercentCmd) + { + ret = sAT_PercentCHLD( (T_ACI_CMD_SRC)srcId, mode, X_prm ); + } + else + { + ret = sAT_PlusCHLD( (T_ACI_CMD_SRC)srcId, mode, X_prm ); + } + } + else + { + if(cmdType EQ CHLD_PercentCmd) + { + ret = sAT_PercentCHLD( (T_ACI_CMD_SRC)srcId, mode, NULL ); + } + else + { + ret = sAT_PlusCHLD( (T_ACI_CMD_SRC)srcId, mode, NULL ); + } + } + + switch( ret ) + { + case AT_CMPL: + break; + + case AT_EXCT: + src_params->curAtCmd = AT_CMD_CHLD; + break; + + case AT_BUSY: + cmdCmeError(CME_ERR_OpNotAllow); + 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 : atPlusCHLD | ++--------------------------------------------------------------------+ + + PURPOSE : +CHLD command +*/ + +GLOBAL T_ATI_RSLT setatPlusCHLD(char *cl, UBYTE srcId) +{ + TRACE_FUNCTION("setatPlusCHLD()"); + + return( setatPlus_PercentCHLD(cl, srcId, CHLD_PlusCmd) ); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPercentCHLD | ++--------------------------------------------------------------------+ + + PURPOSE : %CHLD command (same as +CHLD but custom specific) +*/ + +GLOBAL T_ATI_RSLT setatPercentCHLD(char *cl, UBYTE srcId) +{ + TRACE_FUNCTION("setatPercentCHLD()"); + + return( setatPlus_PercentCHLD(cl, srcId, CHLD_PercentCmd) ); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCHUP | ++--------------------------------------------------------------------+ + + PURPOSE : +CHUP command (Hangs up call) +*/ +GLOBAL T_ATI_RSLT setatPlusCHUP (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + TRACE_FUNCTION("setatPlusCHUP()"); + + if (*cl EQ ';' OR *cl EQ 0) + { +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_no_parameter dummy; + cmd.ctrl_params = BAT_CMD_SET_PLUS_CHUP; + dummy.bat_dummy = 0xFF; + cmd.params.ptr_set_plus_chup = &dummy; + + TRACE_FUNCTION("setatPlusCHUP() calls bat_send() <=== as APPLICATION"); + + if( at.rngPrms.isRng EQ TRUE ) + { + ati_stop_ring(); + } + src_params->curAtCmd = AT_CMD_CHUP; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return (ATI_EXCT); /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + ret=sAT_PlusCHUP((T_ACI_CMD_SRC)srcId); + if (ret EQ AT_CMPL) + { + return (ATI_CMPL); + } + + else if (ret EQ AT_EXCT) + { + if( at.rngPrms.isRng EQ TRUE ) + { + ati_stop_ring(); + } + src_params->curAtCmd = AT_CMD_CHUP; + } + else + { + cmdCmeError(CME_ERR_Unknown); + } +#endif + } + else + { + cmdCmeError(CME_ERR_OpNotAllow); + } + return (map_aci_2_ati_rslt (ret)); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCLIP | ++--------------------------------------------------------------------+ + + PURPOSE : +CLIP command (calling line identification presentation) +*/ +GLOBAL T_ATI_RSLT setatPlusCLIP (char *cl, UBYTE srcId) +{ + TRACE_FUNCTION("setatPlusCLIP()"); + + return(GenAtCR_C( cl, srcId, AT_CMD_CLIP )); +} + +GLOBAL T_ATI_RSLT queatPlusCLIP (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CLIP_STAT stat = CLIP_STAT_NotPresent; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + TRACE_FUNCTION("queatPlusCLIP()"); + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_no_parameter dummy; + + cmd.ctrl_params=BAT_CMD_QUE_PLUS_CLIP; + dummy.bat_dummy = 0xFF; + cmd.params.ptr_que_plus_clip = &dummy; + src_params->curAtCmd = AT_CMD_CLIP; + bat_send(ati_bat_get_client(srcId), &cmd); + return(ATI_EXCT); + } +#else /* no FF_ATI_BAT */ + + ret = qAT_PlusCLIP((T_ACI_CMD_SRC)srcId,&stat); + + if (ret EQ AT_CMPL) + { + resp_disp(srcId, cl,"be",&ati_user_output_cfg[srcId].CLIP_stat,&stat); + } + else if (ret EQ AT_EXCT) + { + src_params->curAtCmd = AT_CMD_CLIP; + } + else 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 : atPlusCDIP | ++--------------------------------------------------------------------+ + + PURPOSE : +CDIP command (calling line identification presentation) +*/ +GLOBAL T_ATI_RSLT setatPlusCDIP (char *cl, UBYTE srcId) +{ + TRACE_FUNCTION("setatPlusCDIP()"); + + return(GenAtCR_C( cl, srcId, AT_CMD_CDIP )); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : queatPlusCDIP | ++--------------------------------------------------------------------+ + + PURPOSE : +CDIP command (calling line identification presentation) +*/ +GLOBAL T_ATI_RSLT queatPlusCDIP (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_CMPL; + T_ACI_CDIP_STAT stat = CDIP_STAT_Unknown; /* Return this for XT6 - No Network Interrogation */ + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_no_parameter dummy; + + cmd.ctrl_params=BAT_CMD_QUE_PLUS_CDIP; + dummy.bat_dummy = 0xFF; + cmd.params.ptr_que_plus_cdip = &dummy; + src_params->curAtCmd = AT_CMD_CDIP; + bat_send(ati_bat_get_client(srcId), &cmd); + return(ATI_EXCT); + } +#else /* no FF_ATI_BAT */ + TRACE_FUNCTION("queatPlusCDIP()"); + + resp_disp(srcId, cl,"be",&ati_user_output_cfg[srcId].CDIP_stat,&stat); + + return (map_aci_2_ati_rslt (ret)); +#endif /* FF_ATI_BAT */ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCOLP | ++--------------------------------------------------------------------+ + + PURPOSE : +COLP command (connected line identification presentation) +*/ + +GLOBAL T_ATI_RSLT setatPlusCOLP (char *cl, UBYTE srcId) +{ + TRACE_FUNCTION("setatPlusCOLP()"); + + return(GenAtCR_C( cl, srcId, AT_CMD_COLP )); +} + +GLOBAL T_ATI_RSLT queatPlusCOLP (char *cl, UBYTE srcId) +{ + T_ACI_COLP_STAT stat = COLP_STAT_NotPresent; + T_ACI_RETURN ret = AT_FAIL; + UBYTE x = 0; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + TRACE_FUNCTION("queatPlusCOLP()"); + + ret = qAT_PlusCOLP((T_ACI_CMD_SRC)srcId,&stat); + if (ret EQ AT_CMPL) + { + x = (at.flags.COLP_stat?1:0); + resp_disp(srcId, cl,"be",&x,&stat); + } + else if (ret EQ AT_EXCT) + { + src_params->curAtCmd = AT_CMD_COLP; + } + else if (ret EQ AT_FAIL) + { + cmdCmeError(CME_ERR_Unknown); + } + return (map_aci_2_ati_rslt (ret)); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCLIR | ++--------------------------------------------------------------------+ + + PURPOSE : +CLIR command (connected line identification restriction) +*/ + +GLOBAL T_ATI_RSLT setatPlusCLIR (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CLIR_MOD mode = CLIR_MOD_NotPresent; + + + switch(*cl) + { + case('0'): + { + mode=CLIR_MOD_Subscript; + cl++; + break; + } + case('1'): + { + mode=CLIR_MOD_Invoc; + cl++; + break; + } + case('2'): + { + mode=CLIR_MOD_Supp; + cl++; + break; + } + case('\0'): + { + break; + } + default: + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + } + + if (!(*cl EQ 0 OR *cl EQ ';')) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_clir my_bat_set_plus_clir; + + TRACE_FUNCTION("setatPLusCLIR() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_clir, 0, sizeof(my_bat_set_plus_clir)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CLIR; + cmd.params.ptr_set_plus_clir = &my_bat_set_plus_clir; + + my_bat_set_plus_clir.n = mode; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPLusCLIR()"); + + ret = sAT_PlusCLIR((T_ACI_CMD_SRC)srcId,mode); + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + +GLOBAL T_ATI_RSLT queatPlusCLIR (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CLIR_STAT stat = CLIR_STAT_NotPresent; + T_ACI_CLIR_MOD mode = CLIR_MOD_NotPresent; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + TRACE_FUNCTION("queatPLusCLIR()"); + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_no_parameter dummy; + + cmd.ctrl_params=BAT_CMD_QUE_PLUS_CLIR; + dummy.bat_dummy = 0xFF; + cmd.params.ptr_que_plus_clir = &dummy; + src_params->curAtCmd = AT_CMD_CLIR; + bat_send(ati_bat_get_client(srcId), &cmd); + return(ATI_EXCT); + } +#else /* OLD FUNCTION BODY */ + + ret = qAT_PlusCLIR ((T_ACI_CMD_SRC)srcId,&mode,&stat); + switch (ret) + { +/* case AT_CMPL: + { + sprintf(sa,"%s%d,%d",me,mode,stat); + io_sendMessage(sa, ATI_NORMAL_OUTPUT); + break; + } */ /* never happens as far as I know */ + case AT_EXCT: + { + src_params->curAtCmd = AT_CMD_CLIR; + break; + } + case AT_FAIL: + { + cmdCmeError (CME_ERR_Unknown); + break; + } + } + return (map_aci_2_ati_rslt (ret)); +#endif /* FF_ATI_BAT */ +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCCUG | ++--------------------------------------------------------------------+ + + PURPOSE : +CCUG command (closed useg group settings) +*/ +GLOBAL T_ATI_RSLT setatPlusCCUG (char * cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CCUG_MOD mode = CCUG_MOD_NotPresent; + T_ACI_CCUG_IDX idx = CCUG_IDX_NotPresent; + T_ACI_CCUG_INFO info = CCUG_INFO_NotPresent; + + cl = parse(cl, "ddd", &mode, &idx, &info); + if (!cl) + { + cmdCmeError (CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_ccug my_bat_set_plus_ccug; + + TRACE_FUNCTION("setatPlusCCUG() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_ccug, 0, sizeof(my_bat_set_plus_ccug)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CCUG; + cmd.params.ptr_set_plus_ccug = &my_bat_set_plus_ccug; + + my_bat_set_plus_ccug.n = mode; + my_bat_set_plus_ccug.index = idx; + my_bat_set_plus_ccug.info = info; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPlusCCUG()"); + + ret = sAT_PlusCCUG((T_ACI_CMD_SRC)srcId,mode,idx,info); + 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 queatPlusCCUG (char * cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CCUG_MOD mode = CCUG_MOD_NotPresent; + T_ACI_CCUG_IDX idx = CCUG_IDX_NotPresent; + T_ACI_CCUG_INFO info = CCUG_INFO_NotPresent; + + TRACE_FUNCTION("queatPlusCCUG()"); + + ret = qAT_PlusCCUG ((T_ACI_CMD_SRC)srcId,&mode,&idx,&info); + switch (ret) + { + case AT_CMPL: + { + resp_disp (srcId, cl,"eee",&mode,&idx,&info); + break; + } + case AT_FAIL: + { + cmdCmeError (CME_ERR_Unknown); + break; + } + } + return (map_aci_2_ati_rslt (ret)); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCMOD | ++--------------------------------------------------------------------+ + + PURPOSE : +CMOD command (call mode) +*/ + +GLOBAL T_ATI_RSLT setatPlusCMOD (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CMOD_MOD mode = CMOD_MOD_NotPresent; + + cl = parse(cl, "d", &mode); + if (!cl) + { + cmdCmeError (CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_cmod my_bat_set_plus_cmod; + + TRACE_FUNCTION("setatPLusCMOD() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_cmod, 0, sizeof(my_bat_set_plus_cmod)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CMOD; + cmd.params.ptr_set_plus_cmod = &my_bat_set_plus_cmod; + + my_bat_set_plus_cmod.mode = mode; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPLusCMOD()"); + + ret = sAT_PlusCMOD ((T_ACI_CMD_SRC)srcId,mode); + switch (ret) + { + case AT_FAIL: + cmdCmeError (CME_ERR_Unknown); + break; + + default: + break; + } + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + + +GLOBAL T_ATI_RSLT queatPlusCMOD (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CMOD_MOD mode = CMOD_MOD_NotPresent; + + TRACE_FUNCTION("queatPLusCMOD()"); + + ret = qAT_PlusCMOD ((T_ACI_CMD_SRC)srcId,&mode); + + switch (ret) + { + case AT_CMPL: + { + resp_disp (srcId, cl, "e",&mode); + break; + } + case AT_FAIL: + { + cmdCmeError (CME_ERR_OpNotAllow); + break; + } + } + return (map_aci_2_ati_rslt (ret)); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCR | ++--------------------------------------------------------------------+ + + PURPOSE : +CR command (Service reporting control) +*/ + +GLOBAL T_ATI_RSLT setatPlusCR (char *cl, UBYTE srcId) +{ + TRACE_FUNCTION("setatPlusCR()"); + + return (GenAtCR_C( cl, srcId, AT_CMD_CR )); +} + +GLOBAL T_ATI_RSLT queatPlusCR (char *cl, UBYTE srcId) +{ + UBYTE x = 0; + + TRACE_FUNCTION("queatPlusCR()"); + + x = (ati_user_output_cfg[srcId].CR_stat?1:0); + + resp_disp (srcId, cl, "b", &x); + + return (ATI_CMPL); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCAOC | ++--------------------------------------------------------------------+ + + PURPOSE : +CAOC command (Advice of Charge) +*/ +GLOBAL T_ATI_RSLT setatPlusCAOC (char* cl, UBYTE srcId) +{ + LONG ccm = 0L; + SHORT mode = 0; + T_ACI_RETURN ret = AT_FAIL; + + switch ( *cl ) + { + case('\0'): + break; + + default: + { + cl = parse(cl, "d", &mode); + if (!cl) + { + cmdCmeError (CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + switch(mode) + { + case (0): + /* + * AT+CAOC=0 queries the actual ccm value + */ + cl++; + break; + + case (1): + /* + * AT+CAOC=1 deactivates the unsolicited report mode + */ + ati_user_output_cfg[srcId].CAOC_stat=0; + return (ATI_CMPL); + + case (2): + /* + * AT+CAOC=2 activates the unsolicited report mode + */ + ati_user_output_cfg[srcId].CAOC_stat=1; + return (ATI_CMPL); + + default: + cmdCmeError (CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + break; + } + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_caoc my_bat_set_plus_caoc; + + TRACE_FUNCTION("setatPLusCAOC() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_caoc, 0, sizeof(my_bat_set_plus_caoc)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CAOC; + cmd.params.ptr_set_plus_caoc = &my_bat_set_plus_caoc; + + my_bat_set_plus_caoc.mode = mode; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPLusCAOC()"); + + ret = qAT_PlusCAOC((T_ACI_CMD_SRC)srcId,&ccm); + sprintf (g_sa,"+CAOC: \"%06X\"", ccm); + io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT); + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + + +GLOBAL T_ATI_RSLT queatPlusCAOC (char* cl, UBYTE srcId) +{ + UBYTE x = 0; + + TRACE_FUNCTION("queatPLusCAOC()"); + + /* + * AT+CAOC? requests the actual mode + */ + x = ati_user_output_cfg[srcId].CAOC_stat + 1; + + resp_disp(srcId, cl,"b",&x); + + return (ATI_CMPL); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : setatPlusCACM | ++--------------------------------------------------------------------+ + + PURPOSE : +CACM command (Advice of Charge, Accumulated Call Meter) +*/ +GLOBAL T_ATI_RSLT setatPlusCACM (char* cl, UBYTE srcId) +{ + char pin2 [MAX_PWD_LENGTH] = {0} ; + T_ACI_RETURN ret = AT_FAIL; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + cl = parse(cl, "n", (LONG)MAX_PWD_LENGTH, &pin2); + if ( !cl ) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_cacm my_bat_set_plus_cacm; + + TRACE_FUNCTION("setatPLusCACM() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_cacm, 0, sizeof(my_bat_set_plus_cacm)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CACM; + cmd.params.ptr_set_plus_cacm = &my_bat_set_plus_cacm; + + my_bat_set_plus_cacm.c_passwd = strlen(pin2); + memcpy(my_bat_set_plus_cacm.passwd, pin2, my_bat_set_plus_cacm.c_passwd); + src_params->curAtCmd = AT_CMD_CACM; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPLusCACM()"); + + ret = sAT_PlusCACM((T_ACI_CMD_SRC)srcId,pin2); + + switch (ret) + { + case AT_EXCT: + { + src_params->curAtCmd = AT_CMD_CACM; + break; + } + case AT_BUSY: + { + cmdCmeError (CME_ERR_SimBusy); + break; + } + case AT_FAIL: + { + cmdCmeError (CME_ERR_OpNotAllow); + break; + } + } + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + + +GLOBAL T_ATI_RSLT queatPlusCACM (char* cl, UBYTE srcId) +{ + LONG acm = 0L; + T_ACI_RETURN ret = AT_FAIL; + + TRACE_FUNCTION("queatPLusCACM()"); + + /* + * +AT+CACM? requests the actual value + */ + ret = qAT_PlusCACM((T_ACI_CMD_SRC)srcId,&acm); + if( ret NEQ AT_CMPL ) + { + cmdCmeError(CME_ERR_Unknown); + } + else + { + sprintf(g_sa,"+CACM: \"%06X\"", acm); + io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); + } + return (map_aci_2_ati_rslt (ret)); +} + + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCAMM | ++--------------------------------------------------------------------+ + + PURPOSE : +CAMM command (Advice of Charge, + Accumulated Call Meter Maximum) +*/ +GLOBAL T_ATI_RSLT setatPlusCAMM (char* cl, UBYTE srcId) +{ + char pin2 [MAX_PWD_LENGTH] = {0}; + char new_acmmax [MAX_CM_LENGTH] = {0}; + char *pNewAcmMax = new_acmmax; + LONG acmmax = 0L; + T_ACI_RETURN ret = AT_FAIL; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + cl = parse(cl,"sn",(LONG)MAX_CM_LENGTH, &new_acmmax, + (LONG)MAX_PWD_LENGTH, &pin2); + + if ( !cl OR *new_acmmax EQ '\0' ) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + pNewAcmMax = parse(pNewAcmMax, "y", &acmmax); + if ( !pNewAcmMax ) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_camm my_bat_set_plus_camm; + + TRACE_FUNCTION("setatPLusCAMM() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_camm, 0, sizeof(my_bat_set_plus_camm)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CAMM; + cmd.params.ptr_set_plus_camm = &my_bat_set_plus_camm; + + my_bat_set_plus_camm.acmmax = (S32)acmmax; + my_bat_set_plus_camm.c_passwd = strlen(pin2); + memcpy(my_bat_set_plus_camm.passwd, pin2, my_bat_set_plus_camm.c_passwd); + src_params->curAtCmd = AT_CMD_CAMM; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPLusCAMM()"); + + ret = sAT_PlusCAMM((T_ACI_CMD_SRC)srcId, acmmax, pin2); + + switch (ret) + { + case AT_EXCT: + { + src_params->curAtCmd = AT_CMD_CAMM; + break; + } + case AT_BUSY: + { + cmdCmeError (CME_ERR_SimBusy); + break; + } + default: + { + cmdCmeError (CME_ERR_OpNotAllow); + break; + } + } + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + + +GLOBAL T_ATI_RSLT queatPlusCAMM (char* cl, UBYTE srcId) +{ + LONG acmmax = 0L; + T_ACI_RETURN ret = AT_FAIL; + + TRACE_FUNCTION("queatPLusCAMM()"); + + /* + * +AT+CAMM? requests the actual value + */ + ret = qAT_PlusCAMM((T_ACI_CMD_SRC)srcId,&acmmax); + if( ret NEQ AT_CMPL ) + { + cmdCmeError(CME_ERR_Unknown); + return (ATI_FAIL); + } + + sprintf (g_sa,"+CAMM: \"%06X\"", acmmax); + io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT); + return (map_aci_2_ati_rslt (ret)); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCPUC | ++--------------------------------------------------------------------+ + + PURPOSE : +CPUC command (Advice of Charge, + Price per unit and currency) +*/ +GLOBAL T_ATI_RSLT setatPlusCPUC (char* cl, UBYTE srcId) +{ + char currency [MAX_CUR_LEN] = {0x00}; + char cvtdCurrency [2*MAX_CUR_LEN] = {0x00}; + USHORT lenCurrency = 0; + USHORT lenCvtdCurrency = 0; + char ppu [MAX_PPU_LENGTH] = {0x00}; + char pin2 [MAX_PWD_LENGTH] = {0x00}; + T_ACI_RETURN ret = AT_FAIL; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + /* + * AT+CPUC=currency, ppu, pw sets the PUCT with or without password. + */ + cl = parse(cl,"zsn", + (LONG)MAX_CUR_LEN, + strlen(cl), + cl, + &lenCurrency, + currency, + (LONG)MAX_PPU_LENGTH, + ppu, + (LONG)MAX_PWD_LENGTH, + pin2); + + if ( !cl OR *ppu EQ '\0' ) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + srcId_cb = srcId; + utl_chsetToGsm ((UBYTE*)currency, + lenCurrency, + (UBYTE*)cvtdCurrency, + &lenCvtdCurrency, +#ifdef REL99 + sizeof(cvtdCurrency), +#endif + GSM_ALPHA_Int); + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_cpuc my_bat_set_plus_cpuc; + + TRACE_FUNCTION("setatPLusCPUC() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_cpuc, 0, sizeof(my_bat_set_plus_cpuc)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CPUC; + cmd.params.ptr_set_plus_cpuc = &my_bat_set_plus_cpuc; + + my_bat_set_plus_cpuc.c_currency = (U8)lenCurrency; + memcpy(my_bat_set_plus_cpuc.currency, currency, lenCurrency); + my_bat_set_plus_cpuc.c_ppu = strlen(ppu); + memcpy(my_bat_set_plus_cpuc.ppu, ppu, my_bat_set_plus_cpuc.c_ppu); + my_bat_set_plus_cpuc.c_passwd = strlen(pin2); + my_bat_set_plus_cpuc.v_passwd = my_bat_set_plus_cpuc.c_passwd ? TRUE : FALSE; + memcpy(my_bat_set_plus_cpuc.passwd, pin2, my_bat_set_plus_cpuc.c_passwd); + src_params->curAtCmd = AT_CMD_CPUC; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPLusCPUC()"); + + ret = sAT_PlusCPUC((T_ACI_CMD_SRC)srcId,cvtdCurrency,ppu,pin2); + + switch (ret) + { + case AT_EXCT: + { + src_params->curAtCmd = AT_CMD_CPUC; + break; + } + case AT_BUSY: + { + cmdCmeError (CME_ERR_SimBusy); + break; + } + default: + { + cmdCmeError (CME_ERR_OpNotAllow); + break; + } + } + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + + +GLOBAL T_ATI_RSLT queatPlusCPUC (char* cl, UBYTE srcId) +{ + char currency [MAX_CUR_LEN] = {0x00}; + char cvtdCurrency [2*MAX_CUR_LEN] = {0x00}; + USHORT lenCvtdCurrency = 0; + USHORT pos = 0; + char ppu [MAX_PPU_LENGTH] = {0x00}; + T_ACI_RETURN ret = AT_FAIL; + + + TRACE_FUNCTION("queatPLusCPUC()"); + + /* + * +AT+CPUC? requests the actual value + */ + ret = qAT_PlusCPUC((T_ACI_CMD_SRC)srcId,currency, ppu); + + if( ret NEQ AT_CMPL ) + { + cmdCmeError(CME_ERR_Unknown); + return (ATI_FAIL); + } + + + pos = sprintf(g_sa,"+CPUC: "); + + srcId_cb = srcId; + utl_chsetFromGsm((UBYTE*)currency, + (USHORT)strlen(currency), + (UBYTE*)cvtdCurrency, + sizeof(cvtdCurrency), + &lenCvtdCurrency, + GSM_ALPHA_Def); + pos += sprints(g_sa+pos,cvtdCurrency,lenCvtdCurrency); + pos += sprintf(g_sa+pos,",\"%s\"",ppu); + io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); + + return (map_aci_2_ati_rslt (ret)); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCLCC | ++--------------------------------------------------------------------+ + + PURPOSE : +CLCCcommand (list current calls) +*/ +GLOBAL T_ATI_RSLT setatPlusCLCC(char *cl, UBYTE srcId) +{ +#ifdef FF_ATI_BAT + + T_BAT_cmd_send cmd; + T_BAT_no_parameter dummy; + cmd.ctrl_params = BAT_CMD_QUE_PLUS_CLCC; + dummy.bat_dummy = 0xFF; + cmd.params.ptr_que_plus_clcc = &dummy; + + TRACE_FUNCTION("setatPlusCLCC() calls bat_send() <=== as APPLICATION"); + + bat_send(ati_bat_get_client(srcId), &cmd); + + return (ATI_EXCT); /* executing, because response is passed by callback function */ + +#else /* no FF_ATI_BAT */ + + char *me = "+CLCC: "; + T_ACI_CLCC_CALDESC *calLst = NULL; + UBYTE lstIdx = 0; + SHORT pos = 0; + USHORT lenCvtdAlpha = 0; + UBYTE type = 0; + + CHAR cvtdAlpha[2*MAX_ALPHA_LEN]; + + TRACE_FUNCTION("setatPlusCLCC()"); + + srcId_cb = srcId; /* For utl_chsetFromGsm() */ + switch (*cl) + { + case(';'): + case(0x0): + { + /* Check if we have enough RAM for the following ACI_MALLOC */ + USHORT free, alloc; + int ret; + ret = vsi_m_status ( hCommACI, + MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC), + PRIM_POOL_PARTITION, + &free, + &alloc ); + if (ret EQ VSI_ERROR || free EQ 0) + { + cmdCmeError(CME_ERR_MemFull); + return (ATI_FAIL); + } + } + ACI_MALLOC (calLst, MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC)); + (void)qAT_PlusCLCC((T_ACI_CMD_SRC)srcId, calLst); /* Always returns AT_CMPL */ + + /* 20 is approximatly the amount of extra characters (like ",") */ + + for( lstIdx = 0; lstIdx < MAX_CALL_NR; lstIdx++ ) + { + if( calLst[lstIdx].idx EQ ACI_NumParmNotPresent ) + break; + + pos = sprintf(g_sa,"%s%d",me,calLst[lstIdx].idx); + + if (calLst[lstIdx].dir NEQ CLCC_DIR_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].dir); + else + pos += sprintf(g_sa+pos,","); + if (calLst[lstIdx].stat NEQ CLCC_STAT_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].stat); + else + pos += sprintf(g_sa+pos,","); + if (calLst[lstIdx].mode NEQ CLCC_MODE_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].mode); + else + pos += sprintf(g_sa+pos,","); + if (calLst[lstIdx].mpty NEQ CLCC_MPTY_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].mpty); + else + pos += sprintf(g_sa+pos,","); + + if (calLst[lstIdx].number[0] NEQ 0x0) + { + pos += sprintf(g_sa+pos,",\"%s\"",calLst[lstIdx].number); + if (calLst[lstIdx].type.ton NEQ TON_NotPresent) + { + type = toa_merge(calLst[lstIdx].type); + pos += sprintf(g_sa+pos,",%d",(int)type); + } +#ifdef NO_ASCIIZ + if (calLst[lstIdx].alpha.len NEQ 0x0) + { + pos += sprintf(g_sa+pos,","); + utl_chsetFromGsm ( calLst[lstIdx].alpha.data, + calLst[lstIdx].alpha.len, + (UBYTE*)cvtdAlpha, + sizeof(cvtdAlpha), + &lenCvtdAlpha, + GSM_ALPHA_Def ); + pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha ); + } +#else /* #ifdef NO_ASCIIZ */ + if (calLst[lstIdx].alpha[0] NEQ 0x0) + { + pos += sprintf(g_sa+pos,","); + utl_chsetFromGsm ( (UBYTE*)calLst[lstIdx].alpha, + 0, + (UBYTE*)cvtdAlpha, + sizeof(cvtdAlpha), + &lenCvtdAlpha, + GSM_ALPHA_Int ); + pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha ); + } +#endif /* #ifdef NO_ASCIIZ */ + } + + ci_remTrailCom(g_sa, pos); + io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); + } + ACI_MFREE (calLst); + break; + default: + cmdCmeError(CME_ERR_Unknown); + return (ATI_FAIL); + } + return (ATI_CMPL); + +#endif /* no FF_ATI_BAT */ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPercentCLCC | ++--------------------------------------------------------------------+ + + PURPOSE : %CLCCcommand (list current calls) +*/ +GLOBAL T_ATI_RSLT setatPercentCLCC(char *cl, UBYTE srcId) +{ + char *me = "%CLCC: "; + T_ACI_CLCC_CALDESC *calLst = NULL; + UBYTE lstIdx = 0; + SHORT pos = 0; + USHORT lenCvtdAlpha = 0; + UBYTE type = 0; + CHAR cvtdAlpha[2*MAX_ALPHA_LEN]; + + TRACE_FUNCTION("setatPercentCLCC()"); + + srcId_cb = srcId; /* For utl_chsetFromGsm() */ + + switch (*cl) + { + case(';'): + case(0x0): + ACI_MALLOC (calLst, MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC)); + memset(calLst, 0 , MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC)); + (void)qAT_PlusCLCC((T_ACI_CMD_SRC)srcId, calLst); /* Always returns AT_CMPL */ + + /* 20 is approximatly the amount of extra characters (like ",") */ + + for( lstIdx = 0; lstIdx < MAX_CALL_NR; lstIdx++ ) + { + if( calLst[lstIdx].idx EQ ACI_NumParmNotPresent ) + break; + + pos = sprintf(g_sa,"%s%d",me,calLst[lstIdx].idx); + + if (calLst[lstIdx].dir NEQ CLCC_DIR_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].dir); + else + pos += sprintf(g_sa+pos,","); + if (calLst[lstIdx].stat NEQ CLCC_STAT_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].stat); + else + pos += sprintf(g_sa+pos,","); + if (calLst[lstIdx].mode NEQ CLCC_MODE_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].mode); + else + pos += sprintf(g_sa+pos,","); + if (calLst[lstIdx].mpty NEQ CLCC_MPTY_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].mpty); + else + pos += sprintf(g_sa+pos,","); + if (calLst[lstIdx].class_type NEQ CLCC_CLASS_NotPresent) + pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].class_type); + else + pos += sprintf(g_sa+pos,","); + + if (calLst[lstIdx].number[0] NEQ 0x0) + { + pos += sprintf(g_sa+pos,",\"%s\"",calLst[lstIdx].number); + if (calLst[lstIdx].type.ton NEQ TON_NotPresent) + { + type = toa_merge(calLst[lstIdx].type); + pos += sprintf(g_sa+pos,",%d",(int)type); + } +#ifdef NO_ASCIIZ + if (calLst[lstIdx].alpha.len NEQ 0x0) + { + pos += sprintf(g_sa+pos,","); + utl_chsetFromGsm ( calLst[lstIdx].alpha.data, + calLst[lstIdx].alpha.len, + (UBYTE*)cvtdAlpha, + sizeof(cvtdAlpha), + &lenCvtdAlpha, + GSM_ALPHA_Def ); + pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha ); + } +#else /* #ifdef NO_ASCIIZ */ + if (calLst[lstIdx].alpha[0] NEQ 0x0) + { + pos += sprintf(g_sa+pos,","); + utl_chsetFromGsm ( (UBYTE*)calLst[lstIdx].alpha, + 0, + (UBYTE*)cvtdAlpha, + sizeof(cvtdAlpha), + &lenCvtdAlpha, + GSM_ALPHA_Int ); + pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha ); + } +#endif /* #ifdef NO_ASCIIZ */ + } + + ci_remTrailCom(g_sa, pos); + io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); + } + ACI_MFREE (calLst); + break; + default: + cmdCmeError(CME_ERR_Unknown); + return (ATI_FAIL); + } + return (ATI_CMPL); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusCCWA | ++--------------------------------------------------------------------+ + + PURPOSE : +CCWA command (Call Waiting Managment) +*/ +GLOBAL T_ATI_RSLT setatPlusCCWA (char *cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CCWA_MOD mode = CCWA_MOD_NotInterrogate; + T_ACI_CLASS class_type = CLASS_NotPresent; + SHORT val = -1; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + cl = parse(cl, "rdd", &val, &mode, &class_type); + if (!cl OR val > 1 ) + { + cmdCmeError (CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + if (val >= 0) + { + at.flags.CCWA_stat=(UBYTE) val; + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_ccwa my_bat_set_plus_ccwa; + + TRACE_FUNCTION("setatPLusCCWA() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_ccwa, 0, sizeof(my_bat_set_plus_ccwa)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CCWA; + cmd.params.ptr_set_plus_ccwa = &my_bat_set_plus_ccwa; + + my_bat_set_plus_ccwa.mode = mode; + my_bat_set_plus_ccwa.bearer_class = class_type; + src_params->curAtCmd = AT_CMD_CCWA; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPLusCCWA()"); + + if (mode EQ CCWA_MOD_Query) /*query mode*/ + { + ret = qAT_PlusCCWA ((T_ACI_CMD_SRC)srcId,class_type); + switch (ret) + { + case AT_EXCT: + src_params->curAtCmd = AT_CMD_CCWA; + break; + + default: + cmdCmeError(CME_ERR_Unknown); + break; + } + } + else /*set mode*/ + { + ret = sAT_PlusCCWA ((T_ACI_CMD_SRC)srcId,mode,class_type); + switch (ret) + { + case AT_EXCT: + break; + + case AT_FAIL: + case AT_BUSY: + cmdCmeError (CME_ERR_Unknown); + break; + } + } + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + + +GLOBAL T_ATI_RSLT queatPlusCCWA (CHAR *cl, UBYTE srcId) +{ + TRACE_FUNCTION("queatPLusCCWA()"); + + resp_disp (srcId, cl,"b",&at.flags.CCWA_stat); + return (ATI_CMPL); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPlusVTS | ++--------------------------------------------------------------------+ + + PURPOSE : +VTS command (send DTMF) +*/ +GLOBAL T_ATI_RSLT setatPlusVTS (char * cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + SHORT duration = ACI_NumParmNotPresent; + CHAR dtmf = '\0'; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + if( *cl EQ '\0' ) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + cl = parse (cl, "ar", (ULONG)1, &dtmf, &duration); + if (!cl) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_vts my_bat_set_plus_vts; + + TRACE_FUNCTION("setatPlusVTS() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_vts, 0, sizeof(my_bat_set_plus_vts)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_VTS; + cmd.params.ptr_set_plus_vts = &my_bat_set_plus_vts; + + my_bat_set_plus_vts.dtmf = dtmf; + src_params->curAtCmd = AT_CMD_VTS; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPlusVTS()"); + + ret = sAT_PlusVTS((T_ACI_CMD_SRC)srcId,dtmf,VTS_MOD_Auto); + + switch (ret) + { + case AT_EXCT: + src_params->curAtCmd = AT_CMD_VTS; + break; + + case AT_FAIL: + case AT_BUSY: + 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 : setatPercentRDL | ++--------------------------------------------------------------------+ + + PURPOSE : %RDL command (set redial mode) +*/ + +GLOBAL T_ATI_RSLT setatPercentRDL (char* cl, UBYTE srcId) +{ + T_ACI_CC_REDIAL_MODE rdlmode = AUTOM_REP_NOT_PRESENT; + T_ACI_CC_REDIAL_NOTIF usr_notif = NOTIF_NO_PRESENT; + T_ACI_RETURN ret = AT_FAIL; + + cl = parse(cl, "dd", &rdlmode, &usr_notif); + if(!cl) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_percent_rdl my_bat_set_percent_rdl; + + TRACE_FUNCTION("setatPercentRDL() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_percent_rdl, 0, sizeof(my_bat_set_percent_rdl)); + cmd.ctrl_params = BAT_CMD_SET_PERCENT_RDL; + cmd.params.ptr_set_percent_rdl = &my_bat_set_percent_rdl; + + my_bat_set_percent_rdl.mode = (T_BAT_percent_rdl_mode)&rdlmode; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPercentRDL()"); + + ret = sAT_PercentRDL ((T_ACI_CMD_SRC)srcId, rdlmode, usr_notif); + + if (ret NEQ AT_CMPL) + { + cmdCmeError(CME_ERR_OpNotAllow); + } + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : queatPercentRDL | ++--------------------------------------------------------------------+ + + PURPOSE : %RDL command (query redial mode) +*/ + +GLOBAL T_ATI_RSLT queatPercentRDL (char* cl, UBYTE srcId) +{ + T_ACI_CC_REDIAL_MODE rdlmode = AUTOM_REP_NOT_PRESENT; + T_ACI_CC_REDIAL_NOTIF usr_notif = NOTIF_NO_PRESENT; + T_ACI_RETURN ret = AT_FAIL; + + TRACE_FUNCTION("queatPercentRDL()"); + + ret = qAT_PercentRDL ((T_ACI_CMD_SRC)srcId,&rdlmode, &usr_notif); + + if(ret EQ AT_CMPL) + { + resp_disp (srcId, cl,"bb",&rdlmode, &usr_notif); + } + else + { + cmdCmeError (CME_ERR_Unknown); + } + return (map_aci_2_ati_rslt (ret)); +} + +#ifdef TI_PS_FF_AT_P_CMD_RDLB +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : setatPercentRDLB | ++--------------------------------------------------------------------+ + + PURPOSE : %RDLB command (delete black list of redialling phone + numbers) +*/ + +GLOBAL T_ATI_RSLT setatPercentRDLB (char* cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CC_REDIAL_NOTIF usr_notif = NOTIF_NO_PRESENT; + T_ACI_CC_REDIAL_BLMODE blmode = BLMODE_NO_PRESENT; + + cl = parse(cl, "dd", &blmode, &usr_notif); + if(!cl) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_percent_rdlb my_bat_set_percent_rdlb; + + TRACE_FUNCTION("setatPercentRDLB() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_percent_rdlb, 0, sizeof(my_bat_set_percent_rdlb)); + cmd.ctrl_params = BAT_CMD_SET_PERCENT_RDLB; + cmd.params.ptr_set_percent_rdlb = &my_bat_set_percent_rdlb; + + my_bat_set_percent_rdlb.mode = (T_BAT_percent_rdlb_mode)&blmode; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPercentRDLB()"); + + ret = sAT_PercentRDLB((T_ACI_CMD_SRC)srcId, blmode, usr_notif); + + if (ret NEQ AT_CMPL) + { + cmdCmeError(CME_ERR_OpNotAllow); + } + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : queatPercentRDLB | ++--------------------------------------------------------------------+ + + PURPOSE : %RDLB command (query black list of redialling phone + numbers) +*/ + +GLOBAL T_ATI_RSLT queatPercentRDLB (char* cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + T_ACI_CC_REDIAL_BLACKL blackl; + T_ACI_CC_REDIAL_NOTIF usr_notif= NOTIF_NO_PRESENT; + UBYTE i,j; + UBYTE type; + + TRACE_FUNCTION("queatPercentRDLB()"); + + memset(&blackl, 0, sizeof(T_ACI_CC_REDIAL_BLACKL)); + + ret = qAT_PercentRDLB ((T_ACI_CMD_SRC)srcId,&blackl,&usr_notif); + + if(ret EQ AT_CMPL) + { + resp_disp (srcId, cl,"b", &usr_notif); /* output user notification state */ + for(i=0; i<blackl.blCount; i++) /* output black list */ + { + type = (UBYTE)toa_merge(blackl.blNum[i].type); + for(j=0; j<blackl.blNum[i].numb_len; j++) + { + blackl.blNum[i].number[j] = (blackl.blNum[i].number[j] | 0x30); + } + sprintf(g_sa,"%s:\"%s\",%d","%RDLB",blackl.blNum[i].number, + (int)type); + io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); + } + } + else + { + cmdCmeError (CME_ERR_Unknown); + } + return (map_aci_2_ati_rslt (ret)); +} +#endif /* TI_PS_FF_AT_P_CMD_RDLB */ +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : atPercentVTS | ++--------------------------------------------------------------------+ + + PURPOSE : %VTS command (send DTMF) +*/ +GLOBAL T_ATI_RSLT setatPercentVTS (char * cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + CHAR dtmf = 0x0; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + T_ACI_VTS_MOD mode = VTS_MOD_Auto; + + if( *cl EQ '\0' ) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + cl = parse (cl, "ar", (ULONG)1, &dtmf, &mode); + + if (!cl) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + + if (mode EQ VTS_MOD_NotPresent) + { + mode = VTS_MOD_Auto; + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_percent_vts my_bat_set_percent_vts; + + TRACE_FUNCTION("setatPercentVTS() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_percent_vts, 0, sizeof(my_bat_set_percent_vts)); + cmd.ctrl_params = BAT_CMD_SET_PERCENT_VTS; + cmd.params.ptr_set_percent_vts = &my_bat_set_percent_vts; + + my_bat_set_percent_vts.dtmf = dtmf; + my_bat_set_percent_vts.mode = mode; + src_params->curAtCmd = AT_CMD_VTS; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPercentVTS()"); + + ret = sAT_PlusVTS((T_ACI_CMD_SRC)srcId,dtmf,mode); + + switch (ret) + { + case AT_EXCT: + { + src_params->curAtCmd = AT_CMD_VTS; + break; + } + case AT_FAIL: + case AT_BUSY: + { + 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 : atPlusCSNS | ++--------------------------------------------------------------------+ + + PURPOSE : +CSNS command (single numbering scheme) +*/ +GLOBAL T_ATI_RSLT setatPlusCSNS (char* cl, UBYTE srcId) +{ + T_ACI_CSNS_MOD mode = CSNS_MOD_NotPresent; + T_ACI_RETURN ret = AT_FAIL; + + cl= parse (cl, "d", &mode); + if (!cl) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_csns my_bat_set_plus_csns; + + TRACE_FUNCTION("setatPlusCSNS() calls bat_send() <=== as APPLICATION"); + + memset(&my_bat_set_plus_csns, 0, sizeof(my_bat_set_plus_csns)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CSNS; + cmd.params.ptr_set_plus_csns = &my_bat_set_plus_csns; + + my_bat_set_plus_csns.mode = mode; + + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* OLD FUNCTION BODY */ + + TRACE_FUNCTION("setatPlusCSNS()"); + + ret = sAT_PlusCSNS ((T_ACI_CMD_SRC)srcId, mode); + if (ret NEQ AT_CMPL) + { + cmdCmeError(CME_ERR_OpNotAllow); + } + return (map_aci_2_ati_rslt (ret)); + +#endif /* no FF_ATI_BAT*/ +} + +GLOBAL T_ATI_RSLT queatPlusCSNS (char* cl, UBYTE srcId) +{ + T_ACI_CSNS_MOD mode = CSNS_MOD_NotPresent; + T_ACI_RETURN ret = AT_FAIL; + + TRACE_FUNCTION("queatPlusCSNS()"); + + ret = qAT_PlusCSNS ((T_ACI_CMD_SRC)srcId,&mode); + + if(ret EQ AT_CMPL) + { + resp_disp (srcId, cl,"e",&mode); + } + else + { + cmdCmeError (CME_ERR_Unknown); + } + return (map_aci_2_ati_rslt (ret)); +} +#ifdef TI_PS_FF_AT_CMD_P_ECC +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : setatPercentECC | ++--------------------------------------------------------------------+ + + PURPOSE : %ECC command (set additional ECC numbers) +*/ + +GLOBAL T_ATI_RSLT setatPercentECC (char* cl, UBYTE srcId) +{ + T_ACI_RETURN ret = AT_FAIL; + U8 index; + char ecc_number[ADDITIONAL_ECC_NUMBER_LENGTH+1]; /* +1 for '\0' */ + UBYTE idx; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + TRACE_FUNCTION("setatPercentECC()"); + + memset(ecc_number,0,sizeof(ecc_number)); + + cl = parse(cl,"ds", + &index, + (LONG)sizeof(ecc_number), + ecc_number); + + if (cl EQ NULL) + { + idx = get_parse_index(); /* get the problematic component */ + TRACE_EVENT_P1("index %d",idx); + switch (idx) + { + case 1: + cmdCmeError(CME_ERR_InvIdx); + break; + case 2: + cmdCmeError(CME_ERR_TxtToLong); + break; + default: + cmdCmeError(CME_ERR_OpNotAllow); + break; + } + return ATI_FAIL; + } + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_percent_ecc ecc; + + memset(&ecc, 0, sizeof(ecc)); + cmd.ctrl_params = BAT_CMD_SET_PERCENT_ECC; + cmd.params.ptr_set_percent_ecc = &ecc; + ecc.index = index; + ecc.c_number = (U8)strlen(ecc_number); + memcpy(ecc.number, ecc_number, ecc.c_number); + src_params->curAtCmd = AT_CMD_P_ECC; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; + } +#else + ret = sAT_PercentECC((T_ACI_CMD_SRC)srcId, index, ecc_number); + + return (map_aci_2_ati_rslt(ret)); +#endif +} +#endif /* TI_PS_FF_AT_CMD_P_ECC */ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : setatPlusCVHU | ++--------------------------------------------------------------------+ + + PURPOSE : +CVHU command (set voice hangup control) +*/ +GLOBAL T_ATI_RSLT setatPlusCVHU (char* cl, UBYTE srcId) +{ + T_ACI_CVHU_MODE mode = CVHU_DropDTR_IGNORED; + T_ACI_RETURN ret = AT_FAIL; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + TRACE_FUNCTION("setatPlusCVHU()"); + + cl= parse (cl,"d",&mode); + if(!cl) + { + cmdCmeError(CME_ERR_OpNotAllow); + return (ATI_FAIL); + } +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_cmd_set_plus_cvhu cvhu; + + memset(&cvhu, 0, sizeof(cvhu)); + cmd.ctrl_params = BAT_CMD_SET_PLUS_CVHU; + cmd.params.ptr_set_plus_cvhu = &cvhu; + cvhu.cvhu_mode = mode; + src_params->curAtCmd = AT_CMD_CVHU; + bat_send(ati_bat_get_client(srcId), &cmd); + + return ATI_EXCT; + } +#else + ret= sAT_PlusCVHU ((T_ACI_CMD_SRC)srcId, mode); + if (ret NEQ AT_CMPL) + { + cmdCmeError(CME_ERR_OpNotAllow); + } + return (map_aci_2_ati_rslt (ret)); +#endif +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : queatPlusCVHU | ++--------------------------------------------------------------------+ + + PURPOSE : +CVHU command (query voice hangup control) +*/ +GLOBAL T_ATI_RSLT queatPlusCVHU (char* cl, UBYTE srcId) +{ + T_ACI_CVHU_MODE mode = CVHU_DropDTR_IGNORED; + T_ACI_RETURN ret = AT_FAIL; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + TRACE_FUNCTION("queatPlusCVHU()"); + +#ifdef FF_ATI_BAT + { + T_BAT_cmd_send cmd; + T_BAT_no_parameter dummy; + + TRACE_FUNCTION("queatPlusCVHU() calls bat_send() <=== as APPLICATION"); + + cmd.ctrl_params = BAT_CMD_QUE_PLUS_CVHU; + dummy.bat_dummy = 0xFF; + cmd.params.ptr_que_plus_cvhu = &dummy; + src_params->curAtCmd = AT_CMD_CVHU; + bat_send(ati_bat_get_client(srcId), &cmd); + return ATI_EXCT; /* executing, because response is passed by callback function */ + } +#else /* no FF_ATI_BAT */ + ret = qAT_PlusCVHU ((T_ACI_CMD_SRC)srcId, &mode); + + if(ret EQ AT_CMPL) + { + resp_disp (srcId, cl, "e", &mode); + } + else + { + cmdCmeError (CME_ERR_Unknown); + } + return (map_aci_2_ati_rslt (ret)); +#endif /* FF_ATI_BAT */ +} +#endif /* ATI_CC_C */ +