FreeCalypso > hg > tcs211-pirelli
diff g23m/condat/ms/src/aci/ati_bat.c @ 0:509db1a7b7b8
initial import: leo2moko-r1
| author | Space Falcon <falcon@ivan.Harhan.ORG> |
|---|---|
| date | Mon, 01 Jun 2015 03:24:05 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/g23m/condat/ms/src/aci/ati_bat.c Mon Jun 01 03:24:05 2015 +0000 @@ -0,0 +1,5310 @@ +/* ++----------------------------------------------------------------------------- +| Project : GSM-PS (6147) +| Modul : ATI_SRC_TST ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : this source is used for W32 tests ++----------------------------------------------------------------------------- +*/ + +#include "aci_all.h" +/*==== INCLUDES ===================================================*/ +#include "line_edit.h" +#include "aci_cmh.h" +#include "ati_cmd.h" +#include "aci_cmd.h" +#include "dti.h" /* functionality of the dti library */ +#include "cmh_dti.h" + +#include "aci_lst.h" +#include "dti_conn_mng.h" +#ifdef UART +#include "psa_uart.h" +#include "cmh_uart.h" +#endif +#ifdef FF_PSI +#include "psa_psi.h" +#include "cmh_psi.h" +#endif /*FF_PSI*/ +#include "aci_io.h" +#include "aci_mem.h" +#include "aci.h" +#include "ati_io.h" +#include "sap_dti.h" + +#include "ati_int.h" +#ifdef UART +#include "ati_src_uart.h" +#endif +#ifdef FF_PSI +#include "ati_src_psi.h" +#endif /*FF_PSI*/ + +#ifdef FF_FAX +#include "aci_fd.h" +#endif + + +#include "aci_bat_cmh.h" +#include "typedefs.h" +#include "gdd.h" +#include "gdd_aci.h" +#include "bat.h" +#include "bat_ctrl.h" +#include "bat_intern.h" +#include "cmh_sms.h" +#ifdef GPRS +#include "gaci_cmh.h" +#include "gaci_cmd.h" +#endif +#include "aci_bat.h" +#include "aci_bat_cb.h" + +#define ATI_BAT_GLOBALS +#include "ati_bat.h" + +#include "cphs.h" +#include "aci_cphs.h" + +#ifdef _SIMULATION_ +#include "gdd_aci.h" +#endif + + +#define MAX_CEER_DESC_LTH (50) +#define MAGIC_EMPTY_APN "\x0ff" +#define BAT_BIT_12 0x1000 +#define HIGHEST_BAND_SUPPORTED (0x1F) + +/*==== EXTERNS ==================================================*/ + +EXTERN CHAR *cmdExtError (T_ACI_EXT_ERR e); +EXTERN void psi_InitCmdStruct (T_ACI_DTI_PRC_PSI *cmd_struct); +EXTERN void getCeerDesc(USHORT cause, char *desc); +EXTERN T_CAP_ID map_dti_cpblty (UBYTE dti_cpblty); + +EXTERN void rCI_PercentCCCN ( T_ACI_FAC_DIR tDirection, + SHORT cId, + T_fac_inf *fie ); + +#ifdef SIM_TOOLKIT +EXTERN UBYTE sat[CMD_SRC_MAX]; +#endif + +EXTERN const T_CAP_NAME ati_cap_name[]; +EXTERN UBYTE cpmsCallType; + +LOCAL const SMS_Memory sms_mem [] = + +{ + {"ME", SMS_STOR_Me}, + {"me", SMS_STOR_Me}, + {"SM", SMS_STOR_Sm}, + {"sm", SMS_STOR_Sm}, + {0,0} +}; + +/*==== TYPES ======================================================*/ +typedef struct +{ + int (*fptr)(T_ACI_DTI_PRC_PSI *src_infos_psi, + T_BAT_cmd_response *resp_p); /* BAT Response wrapper func */ +} BATResponse; + +/*==== VARIABLES ==================================================*/ + +LOCAL BOOL cops_flag=FALSE; +LOCAL BOOL CLCC_flag=FALSE; +LOCAL CHAR *clan_buf=NULL; + + +#ifdef FF_ATI + #define RSP_ATI(rspFoo) {Resp_##rspFoo} +#else + #define RSP_ATI(rspFoo) {0} +#endif + +#ifdef FAX_AND_DATA + #define RSP_FAD(rspFoo) {Resp_##rspFoo} +#else + #define RSP_FAD(rspFoo) {0} +#endif + +#ifdef SIM_TOOLKIT + #define RSP_STK(rspFoo) {Resp_##rspFoo} +#else + #define RSP_STK(rspFoo) {0} +#endif + +#ifdef GPRS + #define RSP_GPR(rspFoo) {Resp_##rspFoo} +#else + #define RSP_GPR(rspFoo) {0} +#endif + +static BATResponse ResponseTab[] = +{ + RSP_ATI(AtOk), /* BAT_RES_AT_OK = 0x0, */ + RSP_ATI(AtConnect), /* BAT_RES_AT_CONNECT = 0x1, */ + RSP_ATI(AtNoCarrierFinal), /* BAT_RES_AT_NO_CARRIER_FINAL = 0x2, */ + RSP_ATI(PlusCmeError), /* BAT_RES_PLUS_CME_ERROR = 0x3, */ + RSP_ATI(PlusCmsError), /* BAT_RES_PLUS_CMS_ERROR = 0x4, */ + RSP_ATI(AtBusy), /* BAT_RES_AT_BUSY = 0x5, */ + RSP_ATI(AtChannelBusy), /* BAT_RES_AT_CHANNEL_BUSY = 0x6, */ + RSP_ATI(AtNoAnswer), /* BAT_RES_AT_NO_ANSWER = 0x7, */ + RSP_ATI(PlusExtError), /* BAT_RES_PLUS_EXT_ERROR = 0x8, */ + RSP_ATI(qPercentALS), /* BAT_RES_QUE_PERCENT_ALS = 0x9, */ + RSP_ATI(tPercentALS), /* BAT_RES_TST_PERCENT_ALS = 0xa, */ + RSP_ATI(qPercentATR), /* BAT_RES_QUE_PERCENT_ATR = 0xb, */ + RSP_ATI(qPercentBAND), /* BAT_RES_QUE_PERCENT_BAND = 0xc, */ + RSP_ATI(tPercentBAND), /* BAT_RES_TST_PERCENT_BAND = 0xd, */ + RSP_ATI(qPlusCACM), /* BAT_RES_QUE_PLUS_CACM = 0xe, */ + RSP_ATI(qPlusCAMM), /* BAT_RES_QUE_PLUS_CAMM = 0xf, */ + RSP_ATI(sPlusCAOC), /* BAT_RES_SET_PLUS_CAOC = 0x10, */ + RSP_ATI(sPlusCBC), /* BAT_RES_SET_PLUS_CBC = 0x11, */ + RSP_ATI(qPercentCBHZ), /* BAT_RES_QUE_PERCENT_CBHZ = 0x12, */ + RSP_ATI(tPercentCBHZ), /* BAT_RES_TST_PERCENT_CBHZ = 0x13, */ + RSP_ATI(qPlusCBST), /* BAT_RES_QUE_PLUS_CBST = 0x14, */ + RSP_ATI(qPercentCCBS), /* BAT_RES_QUE_PERCENT_CCBS = 0x15, */ + RSP_ATI(sPlusCCFC), /* BAT_RES_SET_PLUS_CCFC = 0x16, */ + RSP_ATI(qPlusCCLK), /* BAT_RES_QUE_PLUS_CCLK = 0x17, */ + RSP_ATI(qPlusCCUG), /* BAT_RES_QUE_PLUS_CCUG = 0x18, */ + RSP_ATI(sPlusCCWA), /* BAT_RES_SET_PLUS_CCWA = 0x19, */ + RSP_ATI(sPlusCCWA_W), /* BAT_RES_SET_PLUS_CCWA_W = 0x1a, */ + RSP_ATI(sPlusCEER), /* BAT_RES_SET_PLUS_CEER = 0x1b, */ + RSP_ATI(qPlusCFUN), /* BAT_RES_QUE_PLUS_CFUN = 0x1c, */ + RSP_GPR(qPercentCGAATT), /* BAT_RES_QUE_PERCENT_CGAATT = 0x1d, */ + RSP_GPR(qPlusCGACT), /* BAT_RES_QUE_PLUS_CGACT = 0x1e, */ + RSP_GPR(qPlusCGATT), /* BAT_RES_QUE_PLUS_CGATT = 0x1f, */ + RSP_GPR(qPercentCGCLASS), /* BAT_RES_QUE_PERCENT_CGCLASS = 0x20, */ + RSP_GPR(qPlusCGCLASS), /* BAT_RES_QUE_PLUS_CGCLASS = 0x21, */ + RSP_GPR(qPlusCGDCONT), /* BAT_RES_QUE_PLUS_CGDCONT = 0x22, */ + RSP_GPR(sPlusCGPADDR), /* BAT_RES_SET_PLUS_CGPADDR = 0x23, */ + RSP_GPR(tPlusCGPADDR), /* BAT_RES_TST_PLUS_CGPADDR = 0x24, */ + RSP_GPR(sPercentCGPCO), /* BAT_RES_SET_PERCENT_CGPCO = 0x25, */ + RSP_GPR(qPercentCGPPP), /* BAT_RES_QUE_PERCENT_CGPPP = 0x26, */ + RSP_GPR(qPlusCGQMIN), /* BAT_RES_QUE_PLUS_CGQMIN = 0x27, */ + RSP_GPR(qPlusCGQREQ), /* BAT_RES_QUE_PLUS_CGQREQ = 0x28, */ + RSP_GPR(qPercentCGREG), /* BAT_RES_QUE_PERCENT_CGREG = 0x29, */ + RSP_GPR(qPlusCGREG), /* BAT_RES_QUE_PLUS_CGREG = 0x2a, */ + RSP_GPR(qPlusCGSMS), /* BAT_RES_QUE_PLUS_CGSMS = 0x2b, */ + RSP_ATI(sPercentCHPL), /* BAT_RES_SET_PERCENT_CHPL = 0x2c, */ + RSP_ATI(sPercentCHPL_W), /* BAT_RES_SET_PERCENT_CHPL_W = 0x2d, */ + RSP_ATI(sPlusCIMI), /* BAT_RES_SET_PLUS_CIMI = 0x2e, */ + RSP_ATI(qPlusCIND), /* BAT_RES_QUE_PLUS_CIND = 0x2f, */ + RSP_ATI(qPlusCLAN), /* BAT_RES_QUE_PLUS_CLAN = 0x30, */ + RSP_ATI(tPlusCLAN), /* BAT_RES_TST_PLUS_CLAN = 0x31, */ + RSP_ATI(qPlusCLCC), /* BAT_RES_QUE_PLUS_CLCC = 0x32, */ + RSP_ATI(sPlusCLCK), /* BAT_RES_SET_PLUS_CLCK = 0x33, */ + RSP_ATI(qPlusCLIP), /* BAT_RES_QUE_PLUS_CLIP = 0x34, */ + RSP_ATI(qPlusCLIP_W), /* BAT_RES_QUE_PLUS_CLIP_W = 0x35, */ + RSP_ATI(qPlusCLIR), /* BAT_RES_QUE_PLUS_CLIR = 0x36, */ + RSP_ATI(sPlusCLVL), /* BAT_RES_SET_PLUS_CLVL = 0x37, */ + RSP_ATI(qPlusCLVL), /* BAT_RES_QUE_PLUS_CLVL = 0x38, */ + RSP_ATI(qPlusCMER), /* BAT_RES_QUE_PLUS_CMER = 0x39, */ + RSP_ATI(sPlusCMGC), /* BAT_RES_SET_PLUS_CMGC = 0x3a, */ + RSP_ATI(sPlusCMGL), /* BAT_RES_SET_PLUS_CMGL = 0x3b, */ + RSP_ATI(sPlusCMGL_W), /* BAT_RES_SET_PLUS_CMGL_W = 0x3c, */ + RSP_ATI(sPlusCMGR), /* BAT_RES_SET_PLUS_CMGR = 0x3d, */ + RSP_ATI(sPlusCMGR_W), /* BAT_RES_SET_PLUS_CMGR_W = 0x3e, */ + RSP_ATI(sPlusCMGS), /* BAT_RES_SET_PLUS_CMGS = 0x3f, */ + RSP_ATI(sPlusCMGW), /* BAT_RES_SET_PLUS_CMGW = 0x40, */ + RSP_ATI(qPlusCMOD), /* BAT_RES_QUE_PLUS_CMOD = 0x41, */ + RSP_ATI(qPlusCMUT), /* BAT_RES_QUE_PLUS_CMUT = 0x42, */ + RSP_ATI(qPlusCMUX), /* BAT_RES_QUE_PLUS_CMUX = 0x43, */ + RSP_ATI(qPercentCNAP), /* BAT_RES_QUE_PERCENT_CNAP = 0x44, */ + RSP_ATI(qPlusCNMI), /* BAT_RES_QUE_PLUS_CNMI = 0x45, */ + RSP_ATI(sPlusCNUM), /* BAT_RES_SET_PLUS_CNUM = 0x46, */ + RSP_ATI(sPlusCNUM_W), /* BAT_RES_SET_PLUS_CNUM_W = 0x47, */ + RSP_ATI(qPlusCOLP), /* BAT_RES_QUE_PLUS_COLP = 0x48, */ + RSP_ATI(qPlusCOLP_W), /* BAT_RES_QUE_PLUS_COLP_W = 0x49, */ + RSP_ATI(qPercentCOPS), /* BAT_RES_QUE_PERCENT_COPS = 0x4a, */ + RSP_ATI(tPercentCOPS), /* BAT_RES_TST_PERCENT_COPS = 0x4b, */ + RSP_ATI(qPlusCOPS), /* BAT_RES_QUE_PLUS_COPS = 0x4c, */ + RSP_ATI(tPlusCOPS), /* BAT_RES_TST_PLUS_COPS = 0x4d, */ + RSP_ATI(qPercentCOPS_W), /* BAT_RES_QUE_PERCENT_COPS_W = 0x4e, */ + RSP_ATI(tPercentCOPS_W), /* BAT_RES_TST_PERCENT_COPS_W = 0x4f, */ + RSP_ATI(sPercentCPALS), /* BAT_RES_SET_PERCENT_CPALS = 0x50, */ + RSP_ATI(qPercentCPALS), /* BAT_RES_QUE_PERCENT_CPALS = 0x51, */ + RSP_ATI(sPercentCPALS_W), /* BAT_RES_SET_PERCENT_CPALS_W = 0x52, */ + RSP_ATI(qPercentCPALS_W), /* BAT_RES_QUE_PERCENT_CPALS_W = 0x53, */ + RSP_ATI(sPlusCPAS), /* BAT_RES_SET_PLUS_CPAS = 0x54, */ + RSP_ATI(sPlusCPBF), /* BAT_RES_SET_PLUS_CPBF = 0x55, */ + RSP_ATI(tPlusCPBF), /* BAT_RES_TST_PLUS_CPBF = 0x56, */ + RSP_ATI(sPlusCPBF_W), /* BAT_RES_SET_PLUS_CPBF_W = 0x57, */ + RSP_ATI(tPlusCPBF_W), /* BAT_RES_TST_PLUS_CPBF_W = 0x58, */ + RSP_ATI(sPlusCPBR), /* BAT_RES_SET_PLUS_CPBR = 0x59, */ + RSP_ATI(tPlusCPBR), /* BAT_RES_TST_PLUS_CPBR = 0x5a, */ + RSP_ATI(sPlusCPBR_W), /* BAT_RES_SET_PLUS_CPBR_W = 0x5b, */ + RSP_ATI(tPlusCPBR_W), /* BAT_RES_TST_PLUS_CPBR_W = 0x5c, */ + RSP_ATI(qPercentCPBS), /* BAT_RES_QUE_PERCENT_CPBS = 0x5d, */ + RSP_ATI(qPlusCPBS), /* BAT_RES_QUE_PLUS_CPBS = 0x5e, */ + RSP_ATI(tPlusCPBW), /* BAT_RES_TST_PLUS_CPBW = 0x5f, */ + RSP_ATI(tPlusCPBW_W), /* BAT_RES_TST_PLUS_CPBW_W = 0x60, */ + RSP_ATI(sPercentCPCFU), /* BAT_RES_SET_PERCENT_CPCFU = 0x61, */ + RSP_ATI(qPercentCPHS), /* BAT_RES_QUE_PERCENT_CPHS = 0x62, */ + RSP_ATI(qPlusCPIN), /* BAT_RES_QUE_PLUS_CPIN = 0x63, */ + RSP_ATI(qPercentCPINF), /* BAT_RES_QUE_PERCENT_CPINF = 0x64, */ + RSP_ATI(sPercentCPMB), /* BAT_RES_SET_PERCENT_CPMB = 0x65, */ + RSP_ATI(qPercentCPMB), /* BAT_RES_QUE_PERCENT_CPMB = 0x66, */ + RSP_ATI(tPercentCPMBW), /* BAT_RES_TST_PERCENT_CPMBW = 0x67, */ + RSP_ATI(tPercentCPMBW_W), /* BAT_RES_TST_PERCENT_CPMBW_W = 0x68, */ + RSP_ATI(sPercentCPMB_W), /* BAT_RES_SET_PERCENT_CPMB_W = 0x69, */ + RSP_ATI(sPlusCPMS), /* BAT_RES_SET_PLUS_CPMS = 0x6a, */ + RSP_ATI(qPlusCPMS), /* BAT_RES_QUE_PLUS_CPMS = 0x6b, */ + RSP_ATI(sPercentCPNUMS), /* BAT_RES_SET_PERCENT_CPNUMS = 0x6c, */ + RSP_ATI(tPercentCPNUMS), /* BAT_RES_TST_PERCENT_CPNUMS = 0x6d, */ + RSP_ATI(sPercentCPNUMS_W), /* BAT_RES_SET_PERCENT_CPNUMS_W = 0x6e, */ + RSP_ATI(tPercentCPNUMS_W), /* BAT_RES_TST_PERCENT_CPNUMS_W = 0x6f, */ + RSP_ATI(qPlusCPOL), /* BAT_RES_QUE_PLUS_CPOL = 0x70, */ + RSP_ATI(tPlusCPOL), /* BAT_RES_TST_PLUS_CPOL = 0x71, */ + RSP_ATI(qPlusCPOL_W), /* BAT_RES_QUE_PLUS_CPOL_W = 0x72, */ + RSP_ATI(tPlusCPOL_W), /* BAT_RES_TST_PLUS_CPOL_W = 0x73, */ + RSP_ATI(qPercentCPOPN), /* BAT_RES_QUE_PERCENT_CPOPN = 0x74, */ + RSP_ATI(qPercentCPRSM), /* BAT_RES_QUE_PERCENT_CPRSM = 0x75, */ + RSP_ATI(qPlusCPUC), /* BAT_RES_QUE_PLUS_CPUC = 0x76, */ + RSP_ATI(qPlusCPUC_W), /* BAT_RES_QUE_PLUS_CPUC_W = 0x77, */ + RSP_ATI(sPercentCPVWI), /* BAT_RES_SET_PERCENT_CPVWI = 0x78, */ + RSP_ATI(qPercentCREG), /* BAT_RES_QUE_PERCENT_CREG = 0x79, */ + RSP_ATI(tPlusCRES), /* BAT_RES_TST_PLUS_CRES = 0x7a, */ + RSP_ATI(qPlusCRLP), /* BAT_RES_QUE_PLUS_CRLP = 0x7b, */ + RSP_ATI(sPlusCRSM), /* BAT_RES_SET_PLUS_CRSM = 0x7c, */ + RSP_ATI(tPlusCSAS), /* BAT_RES_TST_PLUS_CSAS = 0x7d, */ + RSP_ATI(qPlusCSCA), /* BAT_RES_QUE_PLUS_CSCA = 0x7e, */ + RSP_ATI(qPlusCSCB), /* BAT_RES_QUE_PLUS_CSCB = 0x7f, */ + RSP_ATI(qPlusCSCS), /* BAT_RES_QUE_PLUS_CSCS = 0x80, */ + RSP_ATI(sPlusCSIM), /* BAT_RES_SET_PLUS_CSIM = 0x81, */ + RSP_ATI(qPlusCSMS), /* BAT_RES_QUE_PLUS_CSMS = 0x82, */ + RSP_ATI(qPlusCSNS), /* BAT_RES_QUE_PLUS_CSNS = 0x83, */ + RSP_ATI(qPercentCSQ), /* BAT_RES_QUE_PERCENT_CSQ = 0x84, */ + RSP_ATI(sPlusCSQ), /* BAT_RES_SET_PLUS_CSQ = 0x85, */ + RSP_ATI(qPlusCSTA), /* BAT_RES_QUE_PLUS_CSTA = 0x86, */ + RSP_ATI(qPlusCSVM), /* BAT_RES_QUE_PLUS_CSVM = 0x87, */ + RSP_ATI(qPercentCTTY), /* BAT_RES_QUE_PERCENT_CTTY = 0x88, */ + RSP_ATI(qPlusCTZU), /* BAT_RES_QUE_PLUS_CTZU = 0x89, */ + RSP_ATI(qPercentCUST), /* BAT_RES_QUE_PERCENT_CUST = 0x8a, */ + RSP_ATI(qPercentDATA), /* BAT_RES_QUE_PERCENT_DATA = 0x8b, */ + RSP_ATI(sPercentDINF), /* BAT_RES_SET_PERCENT_DINF = 0x8c, */ + RSP_FAD(qPlusDS), /* BAT_RES_QUE_PLUS_DS = 0x8d, */ + RSP_FAD(qPlusFAP), /* BAT_RES_QUE_PLUS_FAP = 0x8e, */ + RSP_FAD(qPlusFBO), /* BAT_RES_QUE_PLUS_FBO = 0x8f, */ + RSP_FAD(qPlusFBS), /* BAT_RES_QUE_PLUS_FBS = 0x90, */ + RSP_FAD(qPlusFBU), /* BAT_RES_QUE_PLUS_FBU = 0x91, */ + RSP_FAD(qPlusFCC), /* BAT_RES_QUE_PLUS_FCC = 0x92, */ + RSP_FAD(qPlusFCLASS), /* BAT_RES_QUE_PLUS_FCLASS = 0x93, */ + RSP_FAD(qPlusFCQ), /* BAT_RES_QUE_PLUS_FCQ = 0x94, */ + RSP_FAD(qPlusFCR), /* BAT_RES_QUE_PLUS_FCR = 0x95, */ + RSP_FAD(qPlusFCS), /* BAT_RES_QUE_PLUS_FCS = 0x96, */ + RSP_FAD(qPlusFCT), /* BAT_RES_QUE_PLUS_FCT = 0x97, */ + RSP_FAD(qPlusFEA), /* BAT_RES_QUE_PLUS_FEA = 0x98, */ + RSP_FAD(qPlusFFC), /* BAT_RES_QUE_PLUS_FFC = 0x99, */ + RSP_FAD(qPlusFHS), /* BAT_RES_QUE_PLUS_FHS = 0x9a, */ + RSP_FAD(qPlusFIE), /* BAT_RES_QUE_PLUS_FIE = 0x9b, */ + RSP_FAD(qPlusFIS), /* BAT_RES_QUE_PLUS_FIS = 0x9c, */ + RSP_FAD(qPlusFIT), /* BAT_RES_QUE_PLUS_FIT = 0x9d, */ + RSP_FAD(qPlusFLI), /* BAT_RES_QUE_PLUS_FLI = 0x9e, */ + RSP_FAD(qPlusFLO), /* BAT_RES_QUE_PLUS_FLO = 0x9f, */ + RSP_FAD(qPlusFLP), /* BAT_RES_QUE_PLUS_FLP = 0xa0, */ + RSP_FAD(qPlusFMS), /* BAT_RES_QUE_PLUS_FMS = 0xa1, */ + RSP_FAD(qPlusFNS), /* BAT_RES_QUE_PLUS_FNS = 0xa2, */ + RSP_FAD(qPlusFPA), /* BAT_RES_QUE_PLUS_FPA = 0xa3, */ + RSP_FAD(qPlusFPI), /* BAT_RES_QUE_PLUS_FPI = 0xa4, */ + RSP_FAD(qPlusFPS), /* BAT_RES_QUE_PLUS_FPS = 0xa5, */ + RSP_FAD(qPlusFPW), /* BAT_RES_QUE_PLUS_FPW = 0xa6, */ + RSP_FAD(qPlusFRQ), /* BAT_RES_QUE_PLUS_FRQ = 0xa7, */ + RSP_FAD(qPlusFSA), /* BAT_RES_QUE_PLUS_FSA = 0xa8, */ + RSP_FAD(qPlusFSP), /* BAT_RES_QUE_PLUS_FSP = 0xa9, */ + RSP_ATI(qPlusICF), /* BAT_RES_QUE_PLUS_ICF = 0xaa, */ + RSP_ATI(qPlusIFC), /* BAT_RES_QUE_PLUS_IFC = 0xab, */ + RSP_ATI(qPercentIMEI), /* BAT_RES_QUE_PERCENT_IMEI = 0xac, */ + RSP_ATI(qPlusIPR), /* BAT_RES_QUE_PLUS_IPR = 0xad, */ + RSP_ATI(qPercentPBCF), /* BAT_RES_QUE_PERCENT_PBCF = 0xae, */ + RSP_ATI(qPercentPPP), /* BAT_RES_QUE_PERCENT_PPP = 0xaf, */ + RSP_ATI(qPercentPVRF), /* BAT_RES_QUE_PERCENT_PVRF = 0xb0, */ + RSP_ATI(qPercentRDL), /* BAT_RES_QUE_PERCENT_RDL = 0xb1, */ + RSP_ATI(qPercentRDLB), /* BAT_RES_QUE_PERCENT_RDLB = 0xb2, */ + RSP_STK(qPercentSATC), /* BAT_RES_QUE_PERCENT_SATC = 0xb3, */ + RSP_STK(qPercentSATCC), /* BAT_RES_QUE_PERCENT_SATCC = 0xb4, */ + RSP_STK(sPercentSATE), /* BAT_RES_SET_PERCENT_SATE = 0xb5, */ + RSP_ATI(qPlusWS46), /* BAT_RES_QUE_PLUS_WS46 = 0xb6, */ + RSP_ATI(qPlusCDIP), /* BAT_RES_QUE_PLUS_CDIP = 0xb7, */ + RSP_ATI(sPercentCMGR), /* BAT_RES_SET_PERCENT_CMGR = 0xb8 ,*/ + RSP_ATI(sPercentCMGL), /* BAT_RES_SET_PERCENT_CMGL = 0xb9, */ + RSP_ATI(sPlusCGMI), /*BAT_RES_SET_PLUS_CGMI = 0xba, */ + RSP_ATI(sPlusCGMM), /*BAT_RES_SET_PLUS_CGMM = 0xbb, */ + RSP_ATI(sPlusCGMR), /*BAT_RES_SET_PLUS_CGMR = 0xbc, */ + RSP_ATI(sPlusCGSN) /*BAT_RES_SET_PLUS_CGSN = 0xbd, */ +}; + +static BATResponse UnsResponseTab[] = +{ + RSP_ATI(uAtBusy), /* BAT_RES_UNS_AT_BUSY = 0x1000, */ + RSP_ATI(uAtNoAnswer), /* BAT_RES_UNS_AT_NO_ANSWER = 0x1001, */ + RSP_ATI(uPlusCBM), /* BAT_RES_UNS_PLUS_CBM = 0x1002, */ + RSP_ATI(uPlusCBMI), /* BAT_RES_UNS_PLUS_CBMI = 0x1003, */ + RSP_ATI(uPercentCCBS), /* BAT_RES_UNS_PERCENT_CCBS = 0x1004, */ + RSP_ATI(uPlusCCCM), /* BAT_RES_UNS_PLUS_CCCM = 0x1005, */ + RSP_ATI(uPercentCCCN), /* BAT_RES_UNS_PERCENT_CCCN = 0x1006, */ + RSP_ATI(uPlusCCWA), /* BAT_RES_UNS_PLUS_CCWA = 0x1007, */ + RSP_ATI(uPlusCCWA_W), /* BAT_RES_UNS_PLUS_CCWA_W = 0x1008, */ + RSP_ATI(uPlusCCWE), /* BAT_RES_UNS_PLUS_CCWE = 0x1009, */ + RSP_ATI(uPlusCDIP), /* BAT_RES_UNS_PLUS_CDIP = 0x100a, */ + RSP_ATI(uPlusCDS), /* BAT_RES_UNS_PLUS_CDS = 0x100b, */ + RSP_ATI(uPlusCCWV), /* BAT_RES_UNS_PLUS_CCWV = 0x100c, */ + RSP_GPR(uPercentCGEV), /* BAT_RES_UNS_PERCENT_CGEV = 0x100d, */ + RSP_GPR(uPlusCGEV), /* BAT_RES_UNS_PLUS_CGEV = 0x100e, */ + RSP_GPR(uPercentCGREG), /* BAT_RES_UNS_PERCENT_CGREG = 0x100f, */ + RSP_GPR(uPlusCGREG), /* BAT_RES_UNS_PLUS_CGREG = 0x1010, */ + RSP_ATI(uPlusCLAE), /* BAT_RES_UNS_PLUS_CLAE = 0x1011, */ + RSP_ATI(uPlusCLAV), /* BAT_RES_UNS_PLUS_CLAV = 0x1012, */ + RSP_ATI(uPlusCLIP), /* BAT_RES_UNS_PLUS_CLIP = 0x1013, */ + RSP_ATI(uPlusCLIP_W), /* BAT_RES_UNS_PLUS_CLIP_W = 0x1014, */ + RSP_ATI(uPlusCMT), /* BAT_RES_UNS_PLUS_CMT = 0x1015, */ + RSP_ATI(uPlusCMTI), /* BAT_RES_UNS_PLUS_CMTI = 0x1016, */ + RSP_ATI(uPlusCMT_W), /* BAT_RES_UNS_PLUS_CMT_W = 0x1017, */ + RSP_ATI(uPercentCNAP), /* BAT_RES_UNS_PERCENT_CNAP = 0x1018, */ + RSP_ATI(uPlusCOLP), /* BAT_RES_UNS_PLUS_COLP = 0x1019, */ + RSP_ATI(uPlusCOLP_W), /* BAT_RES_UNS_PLUS_COLP_W = 0x101a, */ + RSP_ATI(uPercentCPI), /* BAT_RES_UNS_PERCENT_CPI = 0x101b, */ + RSP_ATI(uPercentCPI_W), /* BAT_RES_UNS_PERCENT_CPI_W = 0x101c, */ + RSP_ATI(uPercentCPRI), /* BAT_RES_UNS_PERCENT_CPRI = 0x101d, */ + RSP_ATI(uPercentCPROAM), /* BAT_RES_UNS_PERCENT_CPROAM = 0x101e, */ + RSP_ATI(uPercentCPVWI), /* BAT_RES_UNS_PERCENT_CPVWI = 0x101f, */ + RSP_ATI(uPlusCR), /* BAT_RES_UNS_PLUS_CR = 0x1020, */ + RSP_ATI(uPercentCREG), /* BAT_RES_UNS_PERCENT_CREG = 0x1021, */ + RSP_ATI(uPlusCRING), /* BAT_RES_UNS_PLUS_CRING = 0x1022, */ + RSP_ATI(uPercentCSQ), /* BAT_RES_UNS_PERCENT_CSQ = 0x1023, */ + RSP_ATI(uPlusCSSI), /* BAT_RES_UNS_PLUS_CSSI = 0x1024, */ + RSP_ATI(uPercentCSSN), /* BAT_RES_UNS_PERCENT_CSSN = 0x1025, */ + RSP_ATI(uPlusCSSU), /* BAT_RES_UNS_PLUS_CSSU = 0x1026, */ + RSP_ATI(uPercentCSTAT), /* BAT_RES_UNS_PERCENT_CSTAT = 0x1027, */ + RSP_ATI(uPercentCTYI), /* BAT_RES_UNS_PERCENT_CTYI = 0x1028, */ + RSP_ATI(uPlusCTZR), /* BAT_RES_UNS_PLUS_CTZR = 0x1029, */ + RSP_ATI(uPercentCTZV), /* BAT_RES_UNS_PERCENT_CTZV = 0x102a, */ + RSP_ATI(uPlusCTZV), /* BAT_RES_UNS_PLUS_CTZV = 0x102b, */ + RSP_ATI(uPercentCTZV_W), /* BAT_RES_UNS_PERCENT_CTZV_W = 0x102c, */ + RSP_ATI(uPlusCUSD), /* BAT_RES_UNS_PLUS_CUSD = 0x102d, */ + RSP_ATI(uPlusCUSD_W), /* BAT_RES_UNS_PLUS_CUSD_W = 0x102e, */ + RSP_ATI(uAtNoCarrier), /* BAT_RES_UNS_AT_NO_CARRIER = 0x102f, */ + RSP_ATI(uPlusFHS), /* BAT_RES_UNS_PLUS_FHS = 0x1030, */ + RSP_ATI(uPlusILRR), /* BAT_RES_UNS_PLUS_ILRR = 0x1031, */ + RSP_ATI(uPercentRDL), /* BAT_RES_UNS_PERCENT_RDL = 0x1032, */ + RSP_ATI(uPercentRDLB), /* BAT_RES_UNS_PERCENT_RDLB = 0x1033, */ + RSP_STK(uPercentSATA), /* BAT_RES_UNS_PERCENT_SATA = 0x1034, */ + RSP_STK(uPercentSATI), /* BAT_RES_UNS_PERCENT_SATI = 0x1035, */ + RSP_STK(uPercentSATN), /* BAT_RES_UNS_PERCENT_SATN = 0x1036, */ + RSP_ATI(uPercentSIMEF), /* BAT_RES_UNS_PERCENT_SIMEF = 0x1037, */ + RSP_ATI(uPercentSIMINS), /* BAT_RES_UNS_PERCENT_SIMINS = 0x1038, */ + RSP_ATI(uPercentSIMREM), /* BAT_RES_UNS_PERCENT_SIMREM = 0x1039, */ + RSP_ATI(uPercentSNCNT) /* BAT_RES_UNS_PERCENT_SNCNT = 0x103a, */ +}; + +void ati_bat_inst_sig_cb(T_BAT_signal signal); +#ifdef _SIMULATION_ +int ati_bat_resp_cb_simulation (T_BAT_client client, T_BAT_cmd_response *response); +int ati_bat_uns_resp_cb_simulation (T_BAT_client client, T_BAT_cmd_response *response); +LOCAL BOOL asynch_resp = FALSE; +#endif +int ati_bat_resp_cb (T_BAT_client client, T_BAT_cmd_response *response); +int ati_bat_uns_resp_cb(T_BAT_client client, T_BAT_cmd_response *response); + +void ati_bat_sig_cb (T_BAT_client client, T_BAT_signal signal); + +/* ========================================================================================== */ + + +/* Get PSI Source Info */ +void Get_psi_src_info(T_ACI_DTI_PRC_PSI **psi_src_info) +{ + /* Use the function 'find_element()' to search for the PSI + source that has the correct command source ID. */ + + *psi_src_info=find_element(psi_src_params,srcId_cb,cmhPSItest_srcId); +} + +/* Some ATI maintenance is needed for BAT */ + +void Perform_ati_bat_maint(UBYTE srcId) +{ + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); + + src_params->curAtCmd = AT_CMD_NONE; + ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL); + src_params->cmd_state = CMD_IDLE; + cmdErrStr = NULL; + +#ifdef _SIMULATION_ + asynch_resp = FALSE; +#endif +} + +/* BAT instance_signal_cb */ +void ati_bat_inst_sig_cb(T_BAT_signal signal) +{ + TRACE_FUNCTION ("ati_bat_inst_sig_cb ()"); + + /* Result tells application if instance is successfully created/deleted */ +} + +#ifdef _SIMULATION_ +/* this function is called by sig_dti_data_received_ind() */ +void ati_bat_response_simulation(T_ACI_BAT_RES *res) +{ + TRACE_EVENT("ati_bat_response_simulation(): simulation of asynchronous response"); + if (BITFIELD_CHECK(res->response->ctrl_response, BAT_BIT_12) || /* 0x1000 */ + res->response->ctrl_response EQ BAT_RES_UNS_PLUS_CRING || + res->response->ctrl_response EQ BAT_RES_UNS_PLUS_CCWV) + { + ati_bat_uns_resp_cb(res->client, res->response); + } + else + { + ati_bat_resp_cb(res->client, res->response); + } + if (asynch_resp EQ FALSE) + { + res->response = NULL; + } +} + +int ati_bat_resp_cb_simulation (T_BAT_client client, T_BAT_cmd_response *response) +{ + T_ACI_DTI_PRC_PSI *psi_src_info=find_element(psi_src_params,srcId_cb,cmhPSItest_srcId); + psi_src_info->res.client = client; + psi_src_info->res.response = response; + if (psi_src_info->bat_client[psi_src_info->active_client].curCmd EQ (T_BAT_ctrl_params)-1) + { + ati_bat_resp_cb(client,response); + } + else + { + ati_bat_resp_cb(client,response); +// TRACE_EVENT("ati_bat_resp_cb_simulation(): prepare simulation of asynchronous response"); +// asynch_resp = TRUE; + } + return 0; +} + +int ati_bat_uns_resp_cb_simulation (T_BAT_client client, T_BAT_cmd_response *response) +{ + T_ACI_DTI_PRC_PSI *psi_src_info=find_element(psi_src_params,srcId_cb,cmhPSItest_srcId); + psi_src_info->res.client = client; + psi_src_info->res.response = response; + if (psi_src_info->bat_client[psi_src_info->active_client].curCmd EQ (T_BAT_ctrl_params)-1) + { + ati_bat_uns_resp_cb(client,response); + } + else + { + ati_bat_uns_resp_cb(client,response); +// TRACE_EVENT("ati_bat_uns_resp_cb_simulation(): prepare simulation of asynchronous response"); +// asynch_resp = TRUE; + } + return 0; +} +#endif _SIMULATION_ + +/* BAT unsolicited_result_cb */ +int ati_bat_uns_resp_cb (T_BAT_client client, T_BAT_cmd_response *response) +{ + int ret = 0; + T_ACI_DTI_PRC_PSI *psi_src_info; + U16 index = 0; + + TRACE_FUNCTION ("ati_bat_uns_resp_cb ()"); + + Get_psi_src_info(&psi_src_info); + + if (psi_src_info) + { + if (response) + { + T_BAT_cmd_response *resp_p = response; + + if (resp_p->ctrl_response EQ BAT_RES_UNS_PLUS_CRING || /* Cases where Ids < 0x1000 */ + resp_p->ctrl_response EQ BAT_RES_UNS_PLUS_CCWV) + { + index = (U16)resp_p->ctrl_response; + + if (ResponseTab[index].fptr) + { + ret = ResponseTab[index].fptr(psi_src_info, resp_p); + } + else + { + ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow); + } + } + else /* Cases where Ids >= 0x1000 */ + { + index = ((U16)resp_p->ctrl_response - BAT_BIT_12); + + if (UnsResponseTab[index].fptr) + { + ret = UnsResponseTab[index].fptr(psi_src_info, resp_p); + } + else + { + ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow); + } + } + } + +#ifdef _SIMULATION_ + if (asynch_resp EQ FALSE) +#endif + Perform_ati_bat_maint(psi_src_info->srcId); + } + return 0; +} + +/* BAT response_cb */ +int ati_bat_resp_cb (T_BAT_client client, T_BAT_cmd_response *response) +{ + int ret = 0; + T_ACI_DTI_PRC_PSI *psi_src_info; + U16 index; + + TRACE_FUNCTION ("ati_bat_resp_cb()"); + + Get_psi_src_info(&psi_src_info); + + if (psi_src_info) + { + /* Check if response is complete */ + if (response) + { + T_BAT_cmd_response *resp_p = response; + + index = (U16)resp_p->ctrl_response; + TRACE_EVENT_P1("ati_bat_resp_cb(): resp_p->ctrl_response = 0x%04X", resp_p->ctrl_response); + if (ResponseTab[index].fptr) + { + ret = ResponseTab[index].fptr(psi_src_info, resp_p); + } + else + { + ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow); + } + } +#ifdef _SIMULATION_ + if (asynch_resp EQ FALSE) +#endif + Perform_ati_bat_maint(psi_src_info->srcId); + } + return 0; /* Ok for now */ +} + + +/* BAT signal_cb */ +void ati_bat_sig_cb(T_BAT_client client, T_BAT_signal signal) +{ + TRACE_FUNCTION ("ati_bat_sig_cb ()"); +} + + +GLOBAL void ati_bat_lib_init (U8 src_id) +{ + U8 num_instances = ATI_BAT_MAX_INSTANCES; + U8 *mem; + + /* allocate memory for maintaining the instances */ + ACI_MALLOC(mem, num_instances * BAT_INSTANCE_HEADER_SIZE); + + if (0 != bat_init (mem, num_instances)) + { + TRACE_ERROR("bat_init failure"); + return; + } + ati_bat_globs.bat_lib_initialized = TRUE; + + if (GDD_OK != gdd_aci_func.gdd_init(src_id, 0, CMD_SRC_MAX)) + { + TRACE_ERROR("gdd_aci_init failure"); + return; + } +} + +/* because the ATI src_id is the only identifier, we create for every ATI source + a BAT Lib instance, but with only one client */ +GLOBAL void ati_bat_lib_new (U8 src_id, T_ATI_SRC_TYPE src_type) +{ + T_GDD_SIGNAL signal = {GDD_SIGTYPE_SEND_BUF_AVAILABLE}; + U8 num_clients = ATI_BAT_MAX_CLIENTS; + U8 *mem; + + T_ACI_DTI_PRC_PSI *cmd_struct; + + + if (src_type NEQ ATI_SRC_TYPE_PSI) + { + /* because BAT has been designed for PSI connections only, we must fake one. + in the real life psi_new_source() creates such a thing */ + ACI_MALLOC(cmd_struct, sizeof(T_ACI_DTI_PRC_PSI)); + + psi_InitCmdStruct(cmd_struct); + + cmd_struct->srcId = src_id; + cmd_struct->devId = 0xBACDBACD; /* to distinguish from DIO_DATA_PKT used in acibat_test suite */ + cmd_struct->dlci = 0; + + if (insert_list (psi_src_params, cmd_struct) NEQ TRUE) + { + TRACE_ERROR ("ati_bat_open_client(): failed to create PSI source"); + return; + } + } + + aci_cmd_src_mode_set(src_id,CMD_MODE_BAT); + ati_bat_globs.instance[src_id].src_type = src_type; + gdd_aci_remember_src_id(src_id); + + /* allocate memory for maintaining the clients in the instance */ + ACI_MALLOC(mem, BAT_INSTANCE_SIZE + (num_clients * BAT_CLIENT_SIZE)); + + if ((bat_new(&(ati_bat_globs.instance[src_id].inst_hndl), + mem, + num_clients, + &(ati_bat_globs.config), + ati_bat_inst_sig_cb)) NEQ 0) + { + TRACE_ERROR("bat_new failure"); + return; + } + + /* simulate an asynch response from GDD to BAT Lib to tell BAT Lib that GDD has an open channel */ + signal.sig = GDD_SIGTYPE_SEND_BUF_AVAILABLE; + bat_gdd_signal_cb(gdd_aci_get_con_handle(src_id), signal); +} + + +GLOBAL void ati_bat_lib_finit (void) +{ + int i = 0; + if (ati_bat_globs.bat_lib_initialized) + { + for (i=0; i<ATI_BAT_MAX_INSTANCES; i++) + { + if (ati_bat_globs.instance[i].src_type NEQ ATI_SRC_TYPE_UNKNOWN) + { + if (aci_cmd_src_mode_get(i) EQ CMD_MODE_BAT) + { + bat_delete(ati_bat_globs.instance[i].inst_hndl); + } + ati_bat_globs.instance[i].client_id[0]= 0xFF; + ati_bat_globs.instance[i].uns_client_id = 0xFF; + ati_bat_globs.instance[i].src_type = ATI_SRC_TYPE_UNKNOWN; + } + } + bat_deinit(); + ati_bat_globs.bat_lib_initialized = FALSE; + } +} + + +GLOBAL void ati_bat_open_client (U8 src_id) +{ + T_ACI_DTI_PRC_PSI *src_infos_psi; + + src_infos_psi = find_element (psi_src_params, src_id, cmhPSItest_srcId); + + if (src_infos_psi EQ NULL) + { + TRACE_ERROR ("ati_bat_open_client(): failed to get PSI source"); + return; + } + + aci_cmd_src_mode_set(src_id,CMD_MODE_BAT); + + /* all ATI sources use the same response callback */ + if ((bat_open(ati_bat_globs.instance[src_id].inst_hndl, + &(ati_bat_globs.instance[src_id].client_id[0]), +#ifdef _SIMULATION_ + ati_bat_resp_cb_simulation, +#else + ati_bat_resp_cb, +#endif + ati_bat_sig_cb)) NEQ 0) + { + TRACE_ERROR("bat_open failure"); + return; + } + /* all ATI sources use the same unsolicited response callback */ + if ((bat_uns_open(ati_bat_globs.instance[src_id].inst_hndl, + &(ati_bat_globs.instance[src_id].uns_client_id), +#ifdef _SIMULATION_ + ati_bat_uns_resp_cb_simulation)) NEQ 0) +#else + ati_bat_uns_resp_cb)) NEQ 0) +#endif + + { + TRACE_ERROR("bat_uns_open failure"); + return; + } +} + + +GLOBAL U16 ati_bat_get_client (U8 src_id) +{ + /* currently we have only one client per instance, else need a mux_src_id */ + if (ati_bat_globs.instance[src_id].client_id[0] NEQ 0xFF) + { + return (ati_bat_globs.instance[src_id].client_id[0]); + } + TRACE_ERROR("ati_bat_get_client(): no BAT client"); + return (0xFF); +} + + +GLOBAL void ati_bat_close_client (U8 src_id) +{ + if (ati_bat_globs.bat_lib_initialized) + { + /* currently we have only one client per instance, else need a mux_src_id */ + if (ati_bat_globs.instance[src_id].client_id[0] NEQ 0xFF) + { + bat_close(ati_bat_globs.instance[src_id].client_id[0]); + ati_bat_globs.instance[src_id].client_id[0] = 0xFF; + } + } +} + + +GLOBAL BOOL ati_bat_all_clients_closed (void) +{ + int i,k; + for (i=0; i<ATI_BAT_MAX_INSTANCES; i++) + { + for (k=0; k<ATI_BAT_MAX_CLIENTS; k++) + { + if (ati_bat_globs.instance[i].client_id[k] NEQ 0xFF) + { + return (FALSE); + } + } + } + return (TRUE); +} + + +GLOBAL void ati_bat_reset (void) +{ + int i,k; + + for (i=0; i<ATI_BAT_MAX_INSTANCES; i++) + { + ati_bat_globs.instance[i].src_type = ATI_SRC_TYPE_UNKNOWN; + ati_bat_globs.instance[i].uns_client_id = 0xFF; + for (k=0; k<ATI_BAT_MAX_CLIENTS; k++) + { + ati_bat_globs.instance[i].client_id[k] = 0xFF; + } + } + + ati_bat_globs.bat_lib_initialized = FALSE; + ati_bat_globs.config.adapter.gdd_if = gdd_aci_func; + ati_bat_globs.config.adapter.cap.dio_cap.mtu_size = 300; /*GDD_DIO_MTU_SIZE*/ + ati_bat_globs.config.device = DEVICE_PACKET; + ati_bat_globs.config.l2p.protocol_id = L2P_SP_PSI; +} + + +/***************************************************************************/ +/* Response Function Definitions Start Here */ +/***************************************************************************/ + +int Resp_AtOk (T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_AtOk ()"); + + /* + * If we have been receiving COPS responses, this OK signals + * the end of them, so clear the flag. + */ + cops_flag=FALSE; + CLCC_flag=FALSE; + + if (clan_buf) + { + io_sendMessage(srcId_cb,g_sa,ATI_NORMAL_OUTPUT); + clan_buf=NULL; + } + +#ifdef _SIMULATION_ + { + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, src_infos_psi->srcId, search_ati_src_id); + T_ACI_AT_CMD cmdId = src_params->curAtCmd; + if (ledit_ctrl(src_params->src_id,LEDIT_CTRL_MORE_CMDS, NULL) EQ LEDIT_CMPL) + { + rCI_OK(cmdId); + + return 0; + } + } +#endif + + io_sendConfirm(src_infos_psi->srcId, cmdAtError(atOk), ATI_NORMAL_OUTPUT); + + Perform_ati_bat_maint(src_infos_psi->srcId); + + return 0; /* Ok */ +} + +int Resp_AtConnect(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_BS_SPEED speed; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, src_infos_psi->srcId, search_ati_src_id); + + TRACE_FUNCTION ("Resp_AtConnect()"); + /* + * We're in trouble if we don't have 'src_params', as we need + * to know the command ID. + */ + if (src_params==NULL) + { + TRACE_EVENT("No src_params in CONNECT."); + return 1; /* Indicate error */ + } + + /* + * rCI_CONNECT() only cares about the speed, not the rate adaption / + * modulation type. + */ + switch(resp_p->response.ptr_at_connect->data_rate) + { + default: + case BAT_AT_CONNECT_RATE_NOT_PRESENT: speed=BS_SPEED_NotPresent; break; + case BAT_AT_CONNECT_RATE_300: speed=BS_SPEED_300_V110; break; + case BAT_AT_CONNECT_RATE_1200: speed=BS_SPEED_1200_V110; break; + case BAT_AT_CONNECT_RATE_2400: speed=BS_SPEED_2400_V110; break; + case BAT_AT_CONNECT_RATE_4800: speed=BS_SPEED_4800_V110; break; + case BAT_AT_CONNECT_RATE_9600: speed=BS_SPEED_9600_V110; break; + case BAT_AT_CONNECT_RATE_14400: speed=BS_SPEED_14400_V110; break; + case BAT_AT_CONNECT_RATE_19200: speed=BS_SPEED_19200_V110; break; + case BAT_AT_CONNECT_RATE_38400: speed=BS_SPEED_38400_V110; break; + } + + /* + * BAT does not provide the call ID, the current command or the + * flow control flag. rCI_CONNECT() doesn't care about the call ID, + * so we can set that to 0. I'm not sure about flow control, setting + * it to FALSE seems safest. + */ + rCI_CONNECT(src_params->curAtCmd,speed,0,FALSE); + return 0; /* Ok */ +} + +int Resp_AtNoCarrierFinal(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, src_infos_psi->srcId, search_ati_src_id); + TRACE_FUNCTION ("Resp_AtNoCarrierFinal()"); + + /* + * We're in trouble if we don't have 'src_params', as we need + * to know the command ID. + */ + if (src_params==NULL) + { + TRACE_EVENT("No src_params in NO_CARRIER_FINAL."); + return 1; /* Indicate error */ + } + + /* + * BAT does not provide the call ID or the current command. + * rCI_NO_CARRIER() doesn't care about the call ID, + * so we can set that to 0. + */ + rCI_NO_CARRIER(src_params->curAtCmd,0); + return 0; /* Ok */ +} + +int Resp_PlusCmeError(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_PlusCmeError()"); + + io_sendConfirm(src_infos_psi->srcId, + cmdCmeError(resp_p->response.ptr_plus_cme_error->error), + ATI_ERROR_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_PlusCmsError(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_PlusCmsError()"); + + io_sendConfirm(src_infos_psi->srcId, + cmdCmsError(resp_p->response.ptr_plus_cms_error->err), + ATI_ERROR_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_AtBusy(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, src_infos_psi->srcId, search_ati_src_id); + TRACE_FUNCTION ("Resp_AtBusy()"); + /* + * We're in trouble if we don't have 'src_params', as we need + * to know the command ID. + */ + if (src_params==NULL) + { + TRACE_EVENT("No src_params in BUSY."); + return 1; /* Indicate error */ + } + + /* + * BAT does not provide the call ID or the current command. + * rCI_BUSY() doesn't care about the call ID, + * so we can set that to -1 safely. + */ + rCI_BUSY(src_params->curAtCmd,-1); + return 0; /* Ok */ +} + +int Resp_AtNoAnswer(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, src_infos_psi->srcId, search_ati_src_id); + TRACE_FUNCTION ("Resp_AtNoAnswer()"); + + /* + * We're in trouble if we don't have 'src_params', as we need + * to know the command ID. + */ + if (src_params==NULL) + { + TRACE_EVENT("No src_params in NO_ANSWER."); + return 1; /* Indicate error */ + } + + /* + * BAT does not provide the call ID or the current command. + * rCI_NO_ANSWER() doesn't care about the call ID, + * so we can set that to -1 safely. + */ + rCI_NO_ANSWER(src_params->curAtCmd,-1); + + return 0; /* Ok */ +} + +int Resp_AtChannelBusy(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ +} + + +int Resp_uAtNoCarrier(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uAtNoCarrier()"); + + return 0; /* Ok */ +} + +int Resp_uPlusCRING(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CRING_MOD mode; + T_ACI_CRING_TYP type1; + T_ACI_CRING_TYP type2; + T_BAT_res_uns_plus_cring *cring; + + TRACE_FUNCTION ("Resp_uPlusCRING()"); + /* + * Get a pointer to the CRING structure for convenience. + */ + cring=resp_p->response.ptr_plus_cring; + + /* + * This relies on T_ACI_CRING_TYP being the same as + * T_BAT_cring_type/T_BAT_plus_cring_type2. + */ + type1=(T_ACI_CRING_TYP)cring->type1; + type2=(T_ACI_CRING_TYP)cring->type2; + + /* + * This relies on T_ACI_CRING_MOD being the same as + * T_BAT_plus_cring_alt. + */ + mode=(T_ACI_CRING_MOD)cring->alt; + + rCI_PlusCRING(mode,type1,type2); + return 0; /* Ok */ +} + +int Resp_uPlusCCWV(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCCWV() "); + + rCI_PlusCCWV((T_ACI_CCWV_CHRG)resp_p->response.ptr_plus_ccwv->bat_dummy ); + + return 0; /* Ok */ +} + +int Resp_qPercentALS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentALS() "); + + resp_disp((UBYTE)src_infos_psi->srcId, NULL,"b",resp_p->response.ptr_que_percent_als->mode); + return 0; /* Ok */ +} + +int Resp_tPercentALS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *me = "%ALS"; + TRACE_FUNCTION ("Resp_tPercentALS() "); + + if (resp_p->response.ptr_tst_percent_als->mode EQ BAT_P_ALS_MOD_SPEECH) + sprintf(g_sa,"%s: (0)", me); + if (resp_p->response.ptr_tst_percent_als->mode EQ BAT_P_ALS_MOD_AUX_SPEECH) + sprintf(g_sa,"%s: (1)", me); + if (resp_p->response.ptr_tst_percent_als->mode EQ (BAT_P_ALS_MOD_SPEECH | BAT_P_ALS_MOD_AUX_SPEECH)) + sprintf(g_sa,"%s: (0,1)", me); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentATR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_percent_atr *atr; + UBYTE i; + TRACE_FUNCTION ("Resp_qPercentATR()"); + + atr=resp_p->response.ptr_que_percent_atr; + i=sprintf(g_sa,"%s%d,","%ATR: ",atr->phase); + utl_binToHex(atr->atr,atr->c_atr,g_sa+i); + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentBAND(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_percent_band band; + TRACE_FUNCTION ("Resp_qPercentBAND()"); + + band= *(resp_p->response.ptr_que_percent_band); + if( band.band EQ 0x00 OR band.mode EQ BAND_MODE_Auto ) + { + sprintf(g_sa, "%s: %d", "%BAND", band.mode); + } + else + { + sprintf(g_sa, "%s: %d,%d", "%BAND", band.mode, band.band); + } + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_tPercentBAND(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + UBYTE c_set_bit = 0; + USHORT pos = 0; + UBYTE i, tested_filter_byte, highest_set_bit_only=0; + + TRACE_FUNCTION ("Resp_tPercentBAND() "); + + /* initialization of the string */ + pos += sprintf(g_sa, "%s: (0-%d)", "%BAND", resp_p->response.ptr_tst_percent_band->mode); + pos += sprintf( g_sa+pos, ",(" ); + + if(resp_p->response.ptr_tst_percent_band->band EQ 0x00) + { + /* no particular settings from manufacturer */ + pos += sprintf( g_sa+pos, "1-%d)", HIGHEST_BAND_SUPPORTED ); + } + else + { + /* search holes between highest bit and lowest bit */ + for( i=0; i<8 ; i++ ) + { + tested_filter_byte = 0x01 << i; + + if( (resp_p->response.ptr_tst_percent_band->band & tested_filter_byte) ) + { + highest_set_bit_only = tested_filter_byte; + c_set_bit++; + } + } + + if(c_set_bit) /* alignment at the end */ + { + c_set_bit--; + } + + if( highest_set_bit_only EQ (0x01 << c_set_bit) ) + { + /* there is no hole in the supported values, form 1 to max_value */ + pos += sprintf( g_sa+pos, "1-%d)", resp_p->response.ptr_tst_percent_band->band); + } + else + { + for(i=1 ; i<=resp_p->response.ptr_tst_percent_band->band; i++) /* bands_bitfield is obviously the highest possible value */ + { + if( (i & resp_p->response.ptr_tst_percent_band->band) EQ i ) + { + pos += sprintf( g_sa+pos, "%d,", i); + } + if(pos>MAX_CMD_LEN-5) /* -5 to have some buffer */ + { + TRACE_EVENT("output buffer is too short !!!"); + break; + } + } + pos--; /* erase last comma */ + sprintf( g_sa+pos, ")"); + } + } + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCACM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + LONG acm = 0L; + TRACE_FUNCTION ("Resp_qPlusCACM()"); + + acm=resp_p->response.ptr_que_plus_cacm->acm; + sprintf(g_sa,"+CACM: \"%06X\"", acm); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCAMM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + LONG acmmax = 0L; + TRACE_FUNCTION ("Resp_qPlusCAMM()"); + + acmmax=resp_p->response.ptr_que_plus_camm->acmmax; + sprintf (g_sa,"+CAMM: \"%06X\"", acmmax); + io_sendMessage ((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_sPlusCAOC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + LONG ccm = 0L; + TRACE_FUNCTION ("Resp_sPlusCAOC() "); + ccm=resp_p->response.ptr_set_plus_caoc->ccm; + sprintf (g_sa,"+CAOC: \"%06X\"", ccm); + io_sendMessage ((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_sPlusCBC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCBC()"); + + sprintf(g_sa, "+CBC: %d,%d",resp_p->response.ptr_set_plus_cbc->bsc, resp_p->response.ptr_set_plus_cbc->bcl ); + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentCBHZ(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCBHZ() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_tPercentCBHZ(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPercentCBHZ() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_qPlusCBST(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCBST()"); + resp_disp((UBYTE)src_infos_psi->srcId, NULL,"eee",&resp_p->response.ptr_que_plus_cbst->speed, + &resp_p->response.ptr_que_plus_cbst->name,&resp_p->response.ptr_que_plus_cbst->ce); + return 0; /* Ok */ +} + +int Resp_qPercentCCBS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CCBS_IND ind; + T_ACI_CCBS_STAT status; + T_ACI_CCBS_SET setting; + T_BAT_res_que_percent_ccbs *ccbs; + TRACE_FUNCTION ("Resp_qPercentCCBS()"); + /* + * Get a pointer to the CCBS structure for convenience. + */ + ccbs=resp_p->response.ptr_que_percent_ccbs; + + /* + * This relies on T_ACI_CCBS_IND being identical to + * T_BAT_percent_ccbs_ind and T_ACI_CCBS_STAT being identical + * to T_BAT_percent_ccbs_stat. + */ + ind=(T_ACI_CCBS_IND)ccbs->ind; + status=(T_ACI_CCBS_STAT)ccbs->stat; + + /* + * The main reason for zeroing this memory is to ensure we + * end up with zero-terminated 'number' and 'subaddress' + * strings. + */ + memset(&setting,0,sizeof(T_ACI_CCBS_SET)); + + setting.idx=(SHORT)ccbs->idx; + + if ((ccbs->v_number==TRUE) && (ccbs->c_number<MAX_B_SUBSCR_NUM_LEN)) + memcpy(setting.number,ccbs->number,ccbs->c_number); + + setting.type=toa_demerge((SHORT)ccbs->type); + + if ((ccbs->v_subaddr==TRUE) && (ccbs->c_subaddr<MAX_SUBADDR_LEN)) + memcpy(setting.subaddr,ccbs->subaddr,ccbs->c_subaddr); + + setting.satype=tos_demerge((SHORT)ccbs->satype); + + /* + * This relies on T_ACI_CLASS being identical to T_BAT_bearer_class + * and T_ACI_ALRT_PATTERN being identical to T_BAT_percent_ccbs_ptn. + */ + setting.class_type=(T_ACI_CLASS)ccbs->bearer_class; + setting.alrtPtn=(T_ACI_ALRT_PTRN)ccbs->ptn; + + rCI_PercentCCBS(ind,status,&setting,TRUE); + + return 0; /* Ok */ +} + +int Resp_sPlusCCFC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CCFC_SET setting = {0}, *set_p = &setting; + + TRACE_FUNCTION ("Resp_sPlusCCFC()"); + + /* Load from BAT response structure before calling rCI_... */ + set_p->clsstat.status = (T_ACI_STATUS)resp_p->response.ptr_set_plus_ccfc->status; + set_p->clsstat.class_type = (T_ACI_CLASS)resp_p->response.ptr_set_plus_ccfc->bearer_class; + + if(resp_p->response.ptr_set_plus_ccfc->v_number) + { + memcpy(set_p->number, + (U8 *)resp_p->response.ptr_set_plus_ccfc->number, + resp_p->response.ptr_set_plus_ccfc->c_number); + } + + if(resp_p->response.ptr_set_plus_ccfc->type NEQ 0) + { + set_p->type=toa_demerge(resp_p->response.ptr_set_plus_ccfc->type); + } + + if(resp_p->response.ptr_set_plus_ccfc->v_subaddr) + { + memcpy(set_p->subaddr, + (U8 *)resp_p->response.ptr_set_plus_ccfc->subaddr, + resp_p->response.ptr_set_plus_ccfc->c_subaddr); + } + + if(resp_p->response.ptr_set_plus_ccfc->satype NEQ 0) + { + set_p->satype=tos_demerge(resp_p->response.ptr_set_plus_ccfc->satype); + } + + set_p->time = (SHORT)resp_p->response.ptr_set_plus_ccfc->time; + + rCI_PlusCCFC(set_p); + + return 0; /* Ok */ +} + +int Resp_qPlusCCLK(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_plus_cclk *cclk; + char sign; + int tz; + TRACE_FUNCTION ("Resp_qPlusCCLK()"); + /* + * Get a pointer to the CCLK structure for convenience. + */ + cclk=resp_p->response.ptr_que_plus_cclk; + tz=(char)cclk->time_zone; + #ifndef _SIMULATION_ + #ifdef FF_TIMEZONE + if (tz<0) + { + sign='-'; + tz=tz*(-1); + } + else + { + sign='+'; + } + + #endif /*FF_TIMEZONE*/ + #else + sign='-'; + tz=tz*(-1); + #endif /*_SIMULATION_*/ + + #if defined(_SIMULATION_) || defined(FF_TIMEZONE) + sprintf( + g_sa, + "%d/%d/%d,%d:%d:%d%c%d", + cclk->year, + cclk->month, + cclk->day, + cclk->hour, + cclk->minutes, + cclk->seconds, + sign, + tz); + #else + sprintf( + g_sa, + "%d/%d/%d,%d:%d:%d", + cclk->year, + cclk->month, + cclk->day, + cclk->hour, + cclk->minutes, + cclk->seconds); + #endif + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCCUG(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCCUG()"); + resp_disp (src_infos_psi->srcId,NULL,"eee",&resp_p->response.ptr_que_plus_ccug->n, + &resp_p->response.ptr_que_plus_ccug->index,&resp_p->response.ptr_que_plus_ccug->info); + return 0; /* Ok */ +} + +int Resp_sPlusCCWA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCCWA() Not implemented no callback which fills set response not present"); + + return 0; /* Ok */ +} + +int Resp_sPlusCCWA_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCCWA_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_qPlusCDIP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_plus_cdip *cdip; + + TRACE_FUNCTION ("Resp_qPlusCDIP() Not Implemented"); + + cdip = resp_p->response.ptr_que_plus_cdip; + + /* from ati_cc.c use bat params here! */ + resp_disp(src_infos_psi->srcId, NULL, "be", &ati_user_output_cfg[src_infos_psi->srcId].CDIP_stat, &cdip->m); + + return 0; /* Ok */ +} + +int Resp_sPlusCEER(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_set_plus_ceer *ceer; + char desc[MAX_CEER_DESC_LTH]; + USHORT cause; + TRACE_FUNCTION ("Resp_sPlusCEER()"); + /* + * Get a pointer to the CEER structure for convenience. + */ + ceer=resp_p->response.ptr_set_plus_ceer; + + cause=CAUSE_MAKE( + ceer->definedby, + ceer->originatingside, + ceer->originatingentity, + ceer->causevalue); + + getCeerDesc(cause, desc); + + if (desc[0]==0) + { + /* + * No description text is available + */ + sprintf( g_sa, "+CEER: %d,%d,%d,%d", + ceer->definedby, + ceer->originatingside, + ceer->originatingentity, + ceer->causevalue); + } + else + { + /* + * Description text is available + */ + sprintf( g_sa, "+CEER: %d,%d,%d,%d,%s", + ceer->definedby, + ceer->originatingside, + ceer->originatingentity, + ceer->causevalue, + desc); + } + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCFUN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCFUN()"); + + sprintf(g_sa, + "%s: %d","+CFUN", + resp_p->response.ptr_que_plus_cfun->fun); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +#ifdef GPRS +int Resp_qPercentCGAATT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCGAATT()"); + sprintf(g_sa,"%s: %d,%d", "%CGAATT", + resp_p->response.ptr_que_percent_cgaatt->att_m, + resp_p->response.ptr_que_percent_cgaatt->det_m); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCGACT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_plus_cgact *cgact; + TRACE_FUNCTION ("Resp_qPlusCGACT()"); + /* + * Get a pointer to the CGACT structure for convenience. + */ + cgact=resp_p->response.ptr_que_plus_cgact; + sprintf( + g_sa, + "+CGACT: %hd,%d", + cgact->cid, + (cgact->state==BAT_CGACT_STATE_ACTIVATED) ? 1:0); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCGATT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCGATT()"); + sprintf(g_sa,"+CGATT: %d",resp_p->response.ptr_que_plus_cgatt->state); + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentCGCLASS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *classes[] = {"A","B","BG","BC","BX","CG","CC"}; + TRACE_FUNCTION ("Resp_qPercentCGCLASS()"); + if(resp_p->response.ptr_que_percent_cgclass->p_mobile_class NEQ + resp_p->response.ptr_que_percent_cgclass->current_mobile_class) + { + sprintf(g_sa,"%s: \"%s\",\"%s\"", "%CGCLASS", classes[resp_p->response.ptr_que_percent_cgclass->p_mobile_class], + classes[resp_p->response.ptr_que_percent_cgclass->current_mobile_class]); + } + else + { + sprintf(g_sa,"%s: \"%s\"", "%CGCLASS", classes[resp_p->response.ptr_que_percent_cgclass->p_mobile_class]); + } + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCGCLASS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *me="+CGCLASS: "; + char *classes[] = {"A","B","CG","CC"}; + TRACE_FUNCTION ("Resp_qPlusCGCLASS()"); + sprintf(g_sa,"%s\"%s\"", me, classes[resp_p->response.ptr_que_plus_cgclass->mobile_class]); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCGDCONT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *me="+CGDCONT: "; + T_BAT_res_que_plus_cgdcont *cgdcont; + U8 apn[BAT_MAX_APN_LEN+1]; + U8 pdp_addr[BAT_MAX_PDP_ADD+1]; + CHAR *type; + TRACE_FUNCTION ("Resp_qPlusCGDCONT()"); + /* + * Get a pointer to the CGDCONT structure for convenience. + */ + cgdcont=resp_p->response.ptr_que_plus_cgdcont; + memset(apn,0,sizeof(apn)); + memset(pdp_addr,0,sizeof(pdp_addr)); + /* + * Make these into null terminated strings. + */ + memcpy(apn,cgdcont->apn,cgdcont->c_apn); + memcpy(pdp_addr,cgdcont->pdp_addr,cgdcont->c_pdp_addr); + type=(cgdcont->pdp_type==BAT_PDP_TYPE_IPV4) ? "IP":""; + + if (!strcmp(apn, MAGIC_EMPTY_APN)) + { + sprintf(g_sa,"%s%hd,\"%s\",\"\",\"%s\",%hd,%hd", + me, + cgdcont->cid, + type, + pdp_addr, + cgdcont->d_comp, + cgdcont->h_comp); + } + else if (apn[0]==0) + { + sprintf(g_sa,"%s%hd,\"%s\",,\"%s\",%hd,%hd", + me, + cgdcont->cid, + type, + pdp_addr, + cgdcont->d_comp, + cgdcont->h_comp); + } + else + { + sprintf(g_sa,"%s%hd,\"%s\",\"%s\",\"%s\",%hd,%hd", + me, + cgdcont->cid, + type, + apn, + pdp_addr, + cgdcont->d_comp, + cgdcont->h_comp); + } + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_sPlusCGPADDR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_set_plus_cgpaddr *cgpaddr; + TRACE_FUNCTION ("Resp_sPlusCGPADDR() "); + /* + * Get a pointer to the CGPADDR structure for convenience. + */ + cgpaddr=resp_p->response.ptr_set_plus_cgpaddr; + if (cgpaddr->c_pdp_addr) + { + U8 pa[BAT_MAX_PDP_ADD+1]; + memset(pa,0,sizeof(pa)); + memcpy(pa,cgpaddr->pdp_addr,cgpaddr->c_pdp_addr); + sprintf(g_sa,"+CGPADDR: %hd,\"%s\"",cgpaddr->cid,pa); + } + else + { + sprintf(g_sa,"+CGPADDR: %hd",cgpaddr->cid); + } + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_tPlusCGPADDR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_tst_plus_cgpaddr *cgpaddr; + int pos=0; + UBYTE n; + TRACE_FUNCTION ("Resp_tPlusCGPADDR() "); + /* + * Get a pointer to the CGPADDR structure for convenience. + */ + cgpaddr=resp_p->response.ptr_tst_plus_cgpaddr; + + pos=sprintf(g_sa,"+CGPADDR: ("); + + for (n=0;n<cgpaddr->c_cid;n++) + { + if (n!=0) + { + g_sa[pos]=','; + pos++; + } + + pos+=sprintf(g_sa+pos,"%hd",cgpaddr->cid[n]); + } + g_sa[pos]=')'; + pos++; + g_sa[pos]=0; + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_sPercentCGPCO(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_set_percent_cgpco *cgpco; + U8 pco[BAT_MAX_CGPCO_PCO_LEN+1]; + TRACE_FUNCTION ("Resp_sPercentCGPCO()"); + /* + * Get a pointer to the CGPCO structure for convenience. + */ + cgpco=resp_p->response.ptr_set_percent_cgpco; + /* + * Get a zero-terminated version of the pco string. + */ + memset(pco,0,sizeof(pco)); + memcpy(pco,cgpco->pco,cgpco->c_pco); + sprintf(g_sa,"%s\"%s\",%d","%CGPCO: ",pco,cgpco->cid); + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentCGPPP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCGPPP()"); + + sprintf (g_sa, "%s: %d", "%CGPPP", resp_p->response.ptr_que_percent_cgppp->protocol); + io_sendMessage (src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCGQMIN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_plus_cgqmin *cgqmin; + UBYTE precedence; + UBYTE delay; + UBYTE reliability; + UBYTE peak; + UBYTE mean; + TRACE_FUNCTION ("Resp_qPlusCGQMIN()"); + /* + * Get a pointer to the CGQMIN structure for convenience. + */ + cgqmin=resp_p->response.ptr_que_plus_cgqmin; + + precedence=(UBYTE)cgqmin->precedence; + delay=(UBYTE)cgqmin->delay; + reliability=(UBYTE)cgqmin->reliability; + peak=(UBYTE)cgqmin->peak; + mean=(UBYTE)cgqmin->mean; + + if (precedence==(UBYTE)BAT_PRECEDENCE_NOT_PRESENT) + precedence=GPRS_QOS_OMITTED; + + if (delay==(UBYTE)BAT_DELAY_NOT_PRESENT) + delay=GPRS_QOS_OMITTED; + + if (reliability==(UBYTE)BAT_RELIABILITY_NOT_PRESENT) + reliability=GPRS_QOS_OMITTED; + + if (peak==(UBYTE)BAT_PEAK_NOT_PRESENT) + peak=GPRS_QOS_OMITTED; + + if (mean==(UBYTE)BAT_MEAN_NOT_PRESENT) + mean=GPRS_QOS_OMITTED; + + sprintf( + g_sa, + "%s%hd,%d,%d,%d,%d,%d", + "+CGQMIN: ", + cgqmin->cid, + precedence, + delay, + reliability, + peak, + mean); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCGQREQ(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_plus_cgqreq *cgqreq; + UBYTE precedence; + UBYTE delay; + UBYTE reliability; + UBYTE peak; + UBYTE mean; + TRACE_FUNCTION ("Resp_qPlusCGQREQ()"); + /* + * Get a pointer to the CGQREQ structure for convenience. + */ + cgqreq=resp_p->response.ptr_que_plus_cgqreq; + + precedence=(UBYTE)cgqreq->precedence; + delay=(UBYTE)cgqreq->delay; + reliability=(UBYTE)cgqreq->reliability; + peak=(UBYTE)cgqreq->peak; + mean=(UBYTE)cgqreq->mean; + + if (precedence==(UBYTE)BAT_PRECEDENCE_NOT_PRESENT) + precedence=GPRS_QOS_OMITTED; + + if (delay==(UBYTE)BAT_DELAY_NOT_PRESENT) + delay=GPRS_QOS_OMITTED; + + if (reliability==(UBYTE)BAT_RELIABILITY_NOT_PRESENT) + reliability=GPRS_QOS_OMITTED; + + if (peak==(UBYTE)BAT_PEAK_NOT_PRESENT) + peak=GPRS_QOS_OMITTED; + + if (mean==(UBYTE)BAT_MEAN_NOT_PRESENT) + mean=GPRS_QOS_OMITTED; + + sprintf(g_sa,"%s%hd,%d,%d,%d,%d,%d", + "+CGQREQ: ", + cgqreq->cid, + precedence, + delay, + reliability, + peak, + mean); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentCGREG(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_P_CGREG_STAT stat; + USHORT lac, cid; + T_ATI_CREG_MOD mode; + SHORT pos; + T_BAT_res_que_percent_cgreg *cgreg; + TRACE_FUNCTION ("Resp_qPercentCGREG()"); + /* + * Get a pointer to the CGREG structure for convenience. + */ + cgreg=resp_p->response.ptr_que_percent_cgreg; + stat=(T_P_CGREG_STAT)cgreg->stat; + lac=(USHORT)cgreg->lac; + cid=(USHORT)cgreg->ci; + + mode=ati_gprs_user_output_cfg[(src_infos_psi->srcId)].percent_cgreg.mod_lac_cid.pres_mode; + pos=sprintf(g_sa,"%s: %d,%d","%CGREG",mode,stat); + if ((mode==CREG_MOD_LOC_INF_ON) || (mode==CREG_MOD_LOC_INF_ON_CTXACT)) + { + if ((stat==P_CGREG_STAT_REG_HOME) || (stat==P_CGREG_STAT_REG_ROAM)) + pos += sprintf(g_sa+pos, ",\"%04X\",\"%04X\"", lac, cid); + else if (mode==CREG_MOD_LOC_INF_ON_CTXACT) + pos += sprintf(g_sa+pos, ",,"); /* if CTXACT follows so lac and cid are ommitted */ + } + if (mode==CREG_MOD_LOC_INF_ON_CTXACT) + sprintf(g_sa+pos,(cgreg->state==BAT_P_CGREG_STATE_STAT_1) ? ",1" : ",0"); + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCGREG(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_CGREG_STAT stat; + USHORT lac, cid; + T_ATI_CREG_MOD mode; + SHORT pos; + T_BAT_res_que_plus_cgreg *cgreg; + TRACE_FUNCTION ("Resp_qPlusCGREG()"); + /* + * Get a pointer to the CGREG structure for convenience. + */ + cgreg=resp_p->response.ptr_que_plus_cgreg; + stat=(T_P_CGREG_STAT)cgreg->stat; + lac=(USHORT)cgreg->lac; + cid=(USHORT)cgreg->ci; + mode=ati_gprs_user_output_cfg[src_infos_psi->srcId].plus_cgreg.mod_lac_cid.pres_mode; + pos=sprintf(g_sa, "+CGREG: %d,%d", mode, stat); + if (mode==CREG_MOD_LOC_INF_ON) + { + if((stat==CGREG_STAT_REG_HOME) || (stat==CGREG_STAT_REG_ROAM)) + sprintf(g_sa+pos, ",\"%04X\",\"%04X\"", lac, cid); + } + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCGSMS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *me="+CGSMS: "; + TRACE_FUNCTION ("Resp_qPlusCGSMS()"); + + sprintf(g_sa,"%s%hd", me, (T_CGSMS_SERVICE)resp_p->response.ptr_que_plus_cgsms->service); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +#endif /* GPRS */ + +int Resp_sPercentCHPL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_set_percent_chpl *chpl; + CHAR str[BAT_MAX_CHPL_OPER_LEN+1]; + TRACE_FUNCTION ("Resp_sPercentCHPL()"); + /* + * Get a pointer to the CHPL structure for convenience. + */ + chpl=resp_p->response.ptr_set_percent_chpl; + /* + * Make a zero-terminated version of the operator string. + */ + memset(str,0,sizeof(str)); + memcpy(str,chpl->oper,chpl->c_oper); + /* + * This relies on the BAT representation of the numeric + * format being the same as the ATI representation. + */ + sprintf(g_sa,"%s: %s","%CHPL",str); + io_sendMessage (src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_sPercentCHPL_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPercentCHPL_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPlusCIMI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR imsi[MAX_IMSI_LEN+1]; + TRACE_FUNCTION ("Resp_sPlusCIMI()"); + + utl_binToHex(resp_p->response.ptr_set_plus_cimi->imsi, + resp_p->response.ptr_set_plus_cimi->c_imsi,imsi); + sprintf(g_sa,"%s",imsi); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCIND(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCIND() "); + resp_disp(src_infos_psi->srcId, NULL,"ee", &resp_p->response.ptr_que_plus_cind->signal, + &resp_p->response.ptr_que_plus_cind->smsfull); + + return 0; /* Ok */ +} + +int Resp_qPlusCLAN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_plus_clan *clan; + CHAR code[BAT_MAX_CLAN_CODE_LEN+1]; + TRACE_FUNCTION ("Resp_qPlusCLAN()"); + /* + * Get a pointer to the CLAN structure for convenience. + */ + clan=resp_p->response.ptr_que_plus_clan; + memset(code,0,sizeof(code)); + memcpy(code,clan->code,clan->c_code); + sprintf(g_sa,"+CLAN: %s",code); + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_tPlusCLAN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_tst_plus_clan *clan; + CHAR code[BAT_MAX_CLAN_CODE_LEN+1]; + TRACE_FUNCTION ("Resp_tPlusCLAN() "); + /* + * Get a pointer to the CLAN structure for convenience. + */ + clan=resp_p->response.ptr_tst_plus_clan; + memset(code,0,sizeof(code)); + memcpy(code,clan->code,clan->c_code); + if (clan_buf==NULL) + { + clan_buf=g_sa; + clan_buf+=sprintf(clan_buf,"+CLAN: "); + } + else + { + *clan_buf++=','; + } + clan_buf+=sprintf(clan_buf,"%s",code); + return 0; /* Ok */ +} + +int Resp_sPlusCLCK(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + SHORT pos; + TRACE_FUNCTION ("Resp_sPlusCLCK()"); + + pos = sprintf(g_sa,"+CLCK: "); + pos += sprintf(g_sa+pos,"%d,",resp_p->response.ptr_set_plus_clck->status); + if (resp_p->response.ptr_set_plus_clck->bearer_class NEQ BAT_CLASS_NOT_PRESENT) + { + pos += sprintf(g_sa+pos,"%d,",resp_p->response.ptr_set_plus_clck->bearer_class); + } + ci_remTrailCom(g_sa, pos); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCLIP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCLIP() "); + resp_disp(src_infos_psi->srcId,NULL,"be",&ati_user_output_cfg[src_infos_psi->srcId].CLIP_stat, + &resp_p->response.ptr_que_plus_clip->m); + return 0; /* Ok */ +} + +int Resp_qPlusCLIP_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCLIP_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_qPlusCLIR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *me = "+CLIR: "; + TRACE_FUNCTION ("Resp_qPlusCLIR()"); + sprintf(g_sa,"%s%d,%d",me,resp_p->response.ptr_que_plus_clir->n, + resp_p->response.ptr_que_plus_clir->m); + io_sendMessage(src_infos_psi->srcId,g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_sPlusCLVL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCLVL() "); + /* Output nothing as input is bat_dummy*/ + + return 0; /* Ok */ +} + +int Resp_qPlusCLVL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCLVL()"); + + sprintf ( g_sa, "+CLVL: %d", resp_p->response.ptr_que_plus_clvl->level ); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCMER(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCMER() not implemented"); + + return 0; /* Ok */ +} + +int Resp_sPlusCMGC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MNSMS_COMMAND_CNF mnsms_command_cnf; + TRACE_FUNCTION ("Resp_sPlusCMGC()"); + + mnsms_command_cnf.tp_mr = resp_p->response.ptr_set_plus_cmgc->mr; + mnsms_command_cnf.sms_sdu.l_buf= resp_p->response.ptr_set_plus_cmgc->c_ackpdu; + memcpy(mnsms_command_cnf.sms_sdu.buf,resp_p->response.ptr_set_plus_cmgc->ackpdu,mnsms_command_cnf.sms_sdu.l_buf); + + rCI_PlusCMGCPdu(&mnsms_command_cnf); + return 0; /* Ok */ +} + +int Resp_sPlusCMGL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MNSMS_READ_CNF mnsms_read_cnf; + TRACE_FUNCTION ("Resp_sPlusCMGL()"); + + mnsms_read_cnf.status = resp_p->response.ptr_set_plus_cmgl->stat; + /*mnsms_read_cnf.rec_status = resp_p->response.ptr_set_plus_cmgl->stat;*/ + mnsms_read_cnf.rec_num = (UBYTE)resp_p->response.ptr_set_plus_cmgl->sms_index; + mnsms_read_cnf.sms_sdu.l_buf = resp_p->response.ptr_set_plus_cmgl->c_pdu; + memcpy(mnsms_read_cnf.sms_sdu.buf,resp_p->response.ptr_set_plus_cmgl->pdu, + resp_p->response.ptr_set_plus_cmgl->c_pdu); + rCI_Plus_Percent_CMGLPdu(&mnsms_read_cnf, AT_CMD_CMGL); + return 0; /* Ok */ +} + +int Resp_sPercentCMGL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MNSMS_READ_CNF mnsms_read_cnf; + TRACE_FUNCTION ("Resp_sPercentCMGL()"); + + mnsms_read_cnf.status = resp_p->response.ptr_set_percent_cmgl->stat; + mnsms_read_cnf.rec_num = (UBYTE)resp_p->response.ptr_set_percent_cmgl->sms_index; + mnsms_read_cnf.sms_sdu.l_buf = resp_p->response.ptr_set_percent_cmgl->c_pdu; + memcpy(mnsms_read_cnf.sms_sdu.buf,resp_p->response.ptr_set_percent_cmgl->pdu, + resp_p->response.ptr_set_percent_cmgl->c_pdu); + rCI_Plus_Percent_CMGLPdu(&mnsms_read_cnf, AT_CMD_P_CMGL); + return 0; /* Ok */ +} + + +int Resp_sPlusCMGL_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCMGL_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPlusCMGR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MNSMS_READ_CNF mnsms_read_cnf; + + TRACE_FUNCTION ("Resp_sPlusCMGR()"); + + mnsms_read_cnf.status = resp_p->response.ptr_set_plus_cmgr->sms_stat; + mnsms_read_cnf.sms_sdu.l_buf = resp_p->response.ptr_set_plus_cmgr->c_pdu; + memcpy(mnsms_read_cnf.sms_sdu.buf,resp_p->response.ptr_set_plus_cmgr->pdu, + resp_p->response.ptr_set_plus_cmgr->c_pdu); + + rCI_Plus_Percent_CMGRPdu(&mnsms_read_cnf, AT_CMD_CMGR); + + return 0; /* Ok */ +} + +int Resp_sPercentCMGR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MNSMS_READ_CNF mnsms_read_cnf; + + TRACE_FUNCTION ("Resp_sPercentCMGR()"); + + mnsms_read_cnf.status = resp_p->response.ptr_set_percent_cmgr->sms_stat; + mnsms_read_cnf.sms_sdu.l_buf = resp_p->response.ptr_set_percent_cmgr->c_pdu; + memcpy(mnsms_read_cnf.sms_sdu.buf,resp_p->response.ptr_set_percent_cmgr->pdu, + resp_p->response.ptr_set_percent_cmgr->c_pdu); + + rCI_Plus_Percent_CMGRPdu(&mnsms_read_cnf, AT_CMD_P_CMGR); + + return 0; /* Ok */ +} + + + +int Resp_sPlusCMGR_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCMGR_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPlusCMGS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MNSMS_SUBMIT_CNF mnsms_submit_cnf; + + TRACE_FUNCTION ("Resp_sPlusCMGS()"); + + /* + * Set up the bits of mnsms_submit_cnf that are used by + * rCI_PlusCMGSPdu(). + */ + mnsms_submit_cnf.tp_mr=resp_p->response.ptr_set_plus_cmgs->mr; + mnsms_submit_cnf.sms_sdu.l_buf=0; + + rCI_PlusCMGS(&mnsms_submit_cnf); + return 0; /* Ok */ +} + +int Resp_sPlusCMGW(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCMGW()"); + + rCI_PlusCMGW((UBYTE)resp_p->response.ptr_set_plus_cmgw->index); + return 0; /* Ok */ +} + +int Resp_qPlusCMOD(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCMOD()"); + resp_disp (src_infos_psi->srcId, NULL, "e",&resp_p->response.ptr_que_plus_cmod->mode); + return 0; /* Ok */ +} + +int Resp_qPlusCMUT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCMUT()"); + sprintf ( g_sa, "+CMUT: %d", resp_p->response.ptr_que_plus_cmut->n); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCMUX(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCMUX() not implemented"); + + return 0; /* Ok */ +} + +int Resp_qPercentCNAP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCNAP() "); + + sprintf(g_sa, "%s%d,%d", "%CNAP: ", ati_user_output_cfg[src_infos_psi->srcId].cnap_mode, + resp_p->response.ptr_que_percent_cnap->status); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT ); + + return 0; /* Ok */ +} + +int Resp_qPlusCNMI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char* me = "+CNMI: "; + + TRACE_FUNCTION ("Resp_qPlusCNMI()"); + + sprintf ( g_sa,"%s%d,%d,%d,%d,%d", me, at.CNMI_mode, + resp_p->response.ptr_que_plus_cnmi->mt, resp_p->response.ptr_que_plus_cnmi->bm, + resp_p->response.ptr_que_plus_cnmi->ds, at.CNMI_bfr ); + io_sendMessage (src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT ); + + return 0; /* Ok */ +} + +int Resp_sPlusCNUM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CNUM_MSISDN msisdn[MAX_MSISDN]; + UBYTE n; + T_BAT_res_set_plus_cnum *cnum; + T_ACI_CNUM_MSISDN *ms; + + TRACE_FUNCTION ("Resp_sPlusCNUM()"); + + /* + * Get a pointer to the CNUM structure for convenience. + */ + cnum=resp_p->response.ptr_set_plus_cnum; + + /* + * Get a pointer to the output data for convenience. + */ + ms=&msisdn[0]; + + /* + * rCI_PlusCNUM() ignores the 'num' parameter which is supposed + * to indicate the number of items. Instead it assumes that its + * 'msisdn' parameter is a pointer to an array of MAX_MSISDN + * items. We are providing only a single item so here we set + * all the other items in the array invalid. + */ + for (n=1;n<MAX_MSISDN;n++) + msisdn[n].vldFlag=FALSE; + + ms->vldFlag=TRUE; + + /* + * Convert the alphanumeric data into a null terminated string, + * which is what the ATI expects. + */ + memset(ms->alpha,0,MAX_ALPHA_LEN); + + if (cnum->v_alpha==TRUE) + { + if (cnum->c_alpha>=MAX_ALPHA_LEN) + memcpy(ms->alpha,cnum->alpha,MAX_ALPHA_LEN-1); + else + memcpy(ms->alpha,cnum->alpha,cnum->c_alpha); + } + + /* + * Convert the number into a null terminated string, + * which is what the ATI expects. + */ + memset(ms->number,0,MAX_PHB_NUM_LEN); + + if (cnum->c_number>=MAX_PHB_NUM_LEN) + memcpy(ms->number,cnum->number,MAX_PHB_NUM_LEN-1); + else + memcpy(ms->number,cnum->number,cnum->c_number); + + ms->type=toa_demerge(cnum->type); + + /* + * These are not included in the BAT message, so set them + * all to 'not present'. + */ + ms->speed=BS_SPEED_NotPresent; + ms->service=CNUM_SERV_NotPresent; + ms->itc=CNUM_ITC_NotPresent; + + rCI_PlusCNUM(msisdn,1); + + return 0; /* Ok */ +} + +int Resp_sPlusCNUM_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCNUM_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_qPlusCOLP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + UBYTE x = 0; + + TRACE_FUNCTION ("Resp_qPlusCOLP()"); + + x = (at.flags.COLP_stat?1:0); + resp_disp(src_infos_psi->srcId, NULL,"be",&x, + &resp_p->response.ptr_que_plus_colp->m); + + return 0; /* Ok */ +} + +int Resp_qPlusCOLP_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCOLP_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_qPercentCOPS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + U8 oper[40] = {'\0'}; + TRACE_FUNCTION ("Resp_qPercentCOPS()"); + + /* resp_p->response.ptr_que_percent_cops->oper is not NULL terminated */ + memcpy(oper, + resp_p->response.ptr_que_percent_cops->oper, + resp_p->response.ptr_que_percent_cops->c_oper); + + /* Added an empty comma and the service Status parameter */ + sprintf(g_sa, + "%s: %d,%d,\"%s\",,%d","%COPS", + resp_p->response.ptr_que_percent_cops->mode, + resp_p->response.ptr_que_percent_cops->format, + oper, /* resp_p->response.ptr_que_percent_cops->oper, */ + resp_p->response.ptr_que_percent_cops->service); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_tPercentCOPS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *cmdstr="%COPS"; + T_BAT_res_tst_percent_cops *cops; + + TRACE_FUNCTION ("Resp_tPercentCOPS()"); + /* + * Get a pointer to the BAT structure for convenience. + */ + cops=resp_p->response.ptr_tst_percent_cops; + + if (cops_flag==FALSE) + { + cops_flag=TRUE; + + /* + * First operator. + */ + sprintf(g_sa, "%s: (%d,\"%s\",\"%s\",\"%s\")", + cmdstr, + cops->status, + cops->long_oper, + cops->short_oper, + cops->num_oper); + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + } + else + { + /* + * Subsequent operators. + */ + sprintf(g_sa, ",(%d,\"%s\",\"%s\",\"%s\")", + cops->status, + cops->long_oper, + cops->short_oper, + cops->num_oper); + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + } + + return 0; /* Ok */ +} + +int Resp_qPlusCOPS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_plus_cops *cops; + TRACE_FUNCTION ("Resp_qPlusCOPS()"); + /* + * Get a pointer to the COPS structure for convenience. + */ + cops=resp_p->response.ptr_que_plus_cops; + if (cops->v_oper==TRUE) + { + U8 op[BAT_MAX_COPS_OPER_LEN+1]; + /* + * Create a zero-terminated version of the operator name. + */ + memset(op,0,sizeof(op)); + memcpy(op,cops->oper,cops->c_oper); + sprintf(g_sa,"+COPS: %d,%d,\"%s\"",cops->mode,cops->format,op); + } + else + { + sprintf(g_sa,"+COPS: %d",cops->mode); + } + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_tPlusCOPS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *cmdstr; + T_BAT_res_tst_plus_cops *cops; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, src_infos_psi->srcId, search_ati_src_id); + + TRACE_FUNCTION ("Resp_tPlusCOPS()"); + /* + * We're in trouble if we don't have 'src_params', as we need + * to know the command ID. + */ + if (src_params==NULL) + { + TRACE_EVENT("No src_params in COPS response."); + return 1; /* Indicate error */ + } + + /* + * rBAT_PlusCOPS doubles for both %COPS and +COPS responses. + */ + if (src_params->curAtCmd==AT_CMD_P_COPS) + cmdstr = "%COPS"; + else + cmdstr = "+COPS"; + + /* + * Get a pointer to the BAT structure for convenience. + */ + cops=resp_p->response.ptr_tst_plus_cops; + + if (cops_flag==FALSE) + { + cops_flag=TRUE; + + /* + * First operator. + */ + sprintf(g_sa, "%s: (%d,\"%s\",\"%s\",\"%s\")", + cmdstr, + cops->status, + cops->long_oper, + cops->short_oper, + cops->num_oper); + + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + } + else + { + /* + * Subsequent operators. + */ + sprintf(g_sa, ",(%d,\"%s\",\"%s\",\"%s\")", + cops->status, + cops->long_oper, + cops->short_oper, + cops->num_oper); + + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + } + return 0; /* Ok */ +} + +int Resp_qPercentCOPS_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCOPS_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_tPercentCOPS_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPercentCOPS_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPercentCPALS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR msisdn_id[BAT_MAX_CPALS_MSISDN_ID_LEN + 1] ; + TRACE_FUNCTION ("Resp_sPercentCPALS() "); + + utl_binToHex(resp_p->response.ptr_set_percent_cpals->msisdn_id, + (SHORT)resp_p->response.ptr_set_percent_cpals->c_msisdn_id , + msisdn_id); + + sprintf(g_sa, "%s: %d,\"%s\"", "%CPALS", + resp_p->response.ptr_set_percent_cpals->lines, + msisdn_id); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentCPALS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCPALS() "); + + sprintf(g_sa, "%s: %d", "%CPALS", + resp_p->response.ptr_que_percent_cpals->lines); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_sPercentCPALS_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPercentCPALS_W() not implemented"); + + return 0; /* Ok */ +} + +int Resp_qPercentCPALS_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCPALS_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPlusCPAS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCPAS()"); + + resp_disp(src_infos_psi->srcId, NULL, "e", &resp_p->response.ptr_set_plus_cpas->pas); + return 0; /* Ok */ +} + +int Resp_sPlusCPBF(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_set_plus_cpbf *cpbf; + USHORT pos; + U8 num[BAT_MAX_CPBF_NUMBER_LEN+1]; + CHAR cvtd_text[2*BAT_MAX_CPBF_TEXT_LEN]; + USHORT len_cvtd_text; + TRACE_FUNCTION ("Resp_sPlusCPBF()"); + /* + * Get a pointer to the CPBF structure for convenience. + */ + cpbf=resp_p->response.ptr_set_plus_cpbf; + memset(num,0,sizeof(num)); + memcpy(num,cpbf->number,cpbf->c_number); + pos=sprintf(g_sa,"+CPBF: %d,\"%s\",%d,",cpbf->index,num,cpbf->type); + utl_chsetFromSim( + (UBYTE*)cpbf->text, + (USHORT)cpbf->c_text, + (UBYTE*)cvtd_text, + sizeof(cvtd_text), + &len_cvtd_text, + GSM_ALPHA_Def); + pos+=sprints(g_sa+pos,cvtd_text,len_cvtd_text); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_tPlusCPBF(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_tst_plus_cpbf *cpbf; + TRACE_FUNCTION ("Resp_tPlusCPBF()"); + /* + * Get a pointer to the CPBF structure for convenience. + */ + cpbf=resp_p->response.ptr_tst_plus_cpbf; + resp_disp(src_infos_psi->srcId,NULL,"bb",(UBYTE *)&cpbf->nlength,(UBYTE *)&cpbf->tlength); + return 0; /* Ok */ +} + +int Resp_sPlusCPBF_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + + TRACE_FUNCTION ("Resp_sPlusCPBF_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_tPlusCPBF_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCPBF_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPlusCPBR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + USHORT pos = 0; + TRACE_FUNCTION ("Resp_sPlusCPBR()"); + + if (resp_p->response.ptr_set_plus_cpbr->index NEQ ACI_NumParmNotPresent) + { + CHAR cvtdText[4*MAX_ALPHA_LEN] = {0x00}; /* need enough space for UCS2 strings */ + USHORT lenCvtdText = 0; + + pos=sprintf(g_sa,"+CPBR: %d,\"%s\",%d,", + resp_p->response.ptr_set_plus_cpbr->index, + resp_p->response.ptr_set_plus_cpbr->number, + resp_p->response.ptr_set_plus_cpbr->type); + + utl_chsetFromSim((UBYTE*)resp_p->response.ptr_set_plus_cpbr->text, + resp_p->response.ptr_set_plus_cpbr->c_text, + (UBYTE*)cvtdText, + sizeof(cvtdText), + &lenCvtdText, + GSM_ALPHA_Def); + + pos+=sprints(g_sa+pos,cvtdText,lenCvtdText); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + } + + return 0; /* Ok */ +} + +int Resp_tPlusCPBR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCPBR()"); + + sprintf(g_sa,"+CPBR: (%d-%d),%d,%d", + resp_p->response.ptr_tst_plus_cpbr->index_f, + resp_p->response.ptr_tst_plus_cpbr->index_l, + resp_p->response.ptr_tst_plus_cpbr->nlength, + resp_p->response.ptr_tst_plus_cpbr->tlength); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_sPlusCPBR_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCPBR_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_tPlusCPBR_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCPBR_W() Not Implemented"); + return 0; /* Ok */ +} + +int Resp_qPercentCPBS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + SHORT i; + TRACE_FUNCTION ("Resp_qPercentCPBS()"); + + for(i=0;phb_mem_names[i].name NEQ NULL;i++) + { + if (phb_mem_names[i].stor EQ resp_p->response.ptr_que_percent_cpbs->storage) + { + sprintf(g_sa,"%s: \"%s\",%d,%d,%d","%CPBS", + phb_mem_names[i].name, + resp_p->response.ptr_que_percent_cpbs->used, + resp_p->response.ptr_que_percent_cpbs->total, + resp_p->response.ptr_que_percent_cpbs->first); + + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + break; + } + } + + return(0); /* Ok */ +} + +int Resp_qPlusCPBS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + SHORT i; + TRACE_FUNCTION ("Resp_qPlusCPBS()"); + + for(i=0;phb_mem_names[i].name NEQ NULL;i++) + { + if (phb_mem_names[i].stor EQ resp_p->response.ptr_que_plus_cpbs->storage) + { + sprintf(g_sa,"+CPBS: \"%s\",%d,%d", + phb_mem_names[i].name, + resp_p->response.ptr_que_plus_cpbs->used, + resp_p->response.ptr_que_plus_cpbs->total); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + break; + } + } + + return 0; /* Ok */ +} + +int Resp_tPlusCPBW(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCPBW()"); + sprintf(g_sa,"%s(%d-%d),%d,%s,%d", + "+CPBW: ", + resp_p->response.ptr_tst_plus_cpbw->index1, + resp_p->response.ptr_tst_plus_cpbw->index2, + resp_p->response.ptr_tst_plus_cpbw->nlength, + "(128-201)", + resp_p->response.ptr_tst_plus_cpbw->tlength); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_tPlusCPBW_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCPBW_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPercentCPCFU(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPercentCPCFU()"); + + if(resp_p->response.ptr_set_percent_cpcfu->status EQ BAT_P_CPCFU_STATUS_ACTIVATED) + { + sprintf(g_sa, "%s: %d,%d", "%CPCFU", CPHS_FLAG_ACTIVATED, + resp_p->response.ptr_set_percent_cpcfu->line); + } + else + { + sprintf(g_sa, "%s: %d", "%CPCFU", CPHS_FLAG_DEACTIVATED); + } + + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentCPHS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCPHS() "); + + sprintf(g_sa, "%s%d", "%CPHS: ", + resp_p->response.ptr_que_percent_cphs->init_mode); + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCPIN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCPIN() "); + + rCI_PlusCPIN(resp_p->response.ptr_que_plus_cpin->code); + + return 0; /* Ok */ +} + +int Resp_qPercentCPINF(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCPINF()"); + + if (resp_p->response.ptr_que_percent_cpinf->c_csp > 0) + { + if (resp_p->response.ptr_que_percent_cpinf->c_csp2 > 0) + { + sprintf(g_sa, "%s: %d,\"%04X\",\"%s\",\"%s\"", "%CPINF", + resp_p->response.ptr_que_percent_cpinf->phase, + resp_p->response.ptr_que_percent_cpinf->sst, + resp_p->response.ptr_que_percent_cpinf->csp, + resp_p->response.ptr_que_percent_cpinf->csp2); + } + else + { + sprintf(g_sa, "%s: %d,\"%04X\",\"%s\"", "%CPINF", + resp_p->response.ptr_que_percent_cpinf->phase, + resp_p->response.ptr_que_percent_cpinf->sst, + resp_p->response.ptr_que_percent_cpinf->csp); + } + + } + else + { + sprintf(g_sa, "%s: %d,\"%04X\"", "%CPINF", + resp_p->response.ptr_que_percent_cpinf->phase, + resp_p->response.ptr_que_percent_cpinf->sst); + } + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentCPMB(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCPMB()"); + + sprintf(g_sa,"%s: %d","%CPMB",resp_p->response.ptr_que_percent_cpmb->first); + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return(0); /* Ok */ +} + +int Resp_sPercentCPMB(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR number[BAT_MAX_CPMB_NUMBER_LEN + 1] = {'\0'}; + CHAR* p_number; + CHAR alpha_id[BAT_MAX_CPMB_ALPHA_ID_LEN + 1] = {'\0'}; + CHAR* p_alpha_id; + T_BAT_res_set_percent_cpmb *cpmb; + + TRACE_FUNCTION ("Resp_sPercentCPMB()"); + + /* + * Get a pointer to the CPMB structure for convenience. + */ + cpmb=resp_p->response.ptr_set_percent_cpmb; + + /* + * Don't output anything if there is no actual number. This is in line + * with the existing ATI implementation (see setatPercentCPMB()) and + * is necessary in order to pass tests such as ACI583. + */ + if (cpmb->v_number EQ FALSE) + return(0); + + p_number = number; + p_alpha_id = alpha_id ; + + /* + * Zero the arrays to ensure that we end up with null-terminated + * strings following the memcpy. + */ + memset(number,0,sizeof(number)); + memset(alpha_id,0,sizeof(alpha_id)); + + if ((cpmb->v_number NEQ FALSE) AND (cpmb->c_number<=BAT_MAX_CPMB_NUMBER_LEN)) + memcpy(number,cpmb->number,cpmb->c_number); + else + p_number = NULL; + + if ((cpmb->v_alpha_id NEQ FALSE) AND (cpmb->c_alpha_id<=BAT_MAX_CPMB_ALPHA_ID_LEN)) + memcpy(alpha_id,cpmb->alpha_id,cpmb->c_alpha_id); + else + p_alpha_id = NULL; + + sprintf(g_sa,"%s: %d,%d,\"%s\",%d,\"%s\"", "%CPMB", + resp_p->response.ptr_set_percent_cpmb->record_id, + resp_p->response.ptr_set_percent_cpmb->line, + p_number, + resp_p->response.ptr_set_percent_cpmb->type, + p_alpha_id); + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_tPercentCPMBW(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *me = "%CPMBW: "; + TRACE_FUNCTION ("Resp_tPercentCPMBW() "); + + sprintf(g_sa,"%s(%d-%d),%d,%s,%d",me, + resp_p->response.ptr_tst_percent_cpmbw->min_rec_id, + resp_p->response.ptr_tst_percent_cpmbw->max_rec_id, + resp_p->response.ptr_tst_percent_cpmbw->nlength, + "(128-201)", + resp_p->response.ptr_tst_percent_cpmbw->tlength); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_tPercentCPMBW_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPercentCPMBW_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPercentCPMB_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPercentCPMB_W() Not Implemented"); + + return 0; /* Ok */ +} + + +int Resp_sPlusCPMS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_SMS_STOR_OCC mem1; + T_ACI_SMS_STOR_OCC mem2; + T_ACI_SMS_STOR_OCC mem3; + + TRACE_FUNCTION ("Resp_sPlusCPMS() "); + + mem1.mem = (T_ACI_SMS_STOR)resp_p->response.ptr_set_plus_cpms->mem1; + mem1.total = (SHORT)resp_p->response.ptr_set_plus_cpms->total1; + mem1.used = (SHORT)resp_p->response.ptr_set_plus_cpms->used1; + + mem2.mem = (T_ACI_SMS_STOR)resp_p->response.ptr_set_plus_cpms->mem2; + mem2.total = (SHORT)resp_p->response.ptr_set_plus_cpms->total2; + mem2.used = (SHORT)resp_p->response.ptr_set_plus_cpms->used2; + + mem3.mem = (T_ACI_SMS_STOR)resp_p->response.ptr_set_plus_cpms->mem3; + mem3.total = (SHORT)resp_p->response.ptr_set_plus_cpms->total3; + mem3.used = (SHORT)resp_p->response.ptr_set_plus_cpms->used3; + + rCI_PlusCPMS (&mem1, &mem2, &mem3); + + return 0; /* Ok */ +} + +int Resp_qPlusCPMS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR* me = "+CPMS: "; + int i = 0; + CHAR memstr1[3] = {0}; + CHAR memstr2[3] = {0}; + CHAR memstr3[3] = {0}; + BOOL f1 = TRUE; + BOOL f2 = TRUE; + BOOL f3 = TRUE; + + TRACE_FUNCTION ("Resp_qPlusCPMS() "); + + if ( cpmsCallType EQ QAT_CALL ) + { + for ( i=0; sms_mem[i].name != NULL; i++ ) + { + if ( ( sms_mem[i].stor EQ resp_p->response.ptr_que_plus_cpms->mem1) AND f1 ) + { + strcpy ( memstr1, sms_mem[i].name ); + f1 = FALSE; + } + + if ( ( sms_mem[i].stor EQ resp_p->response.ptr_que_plus_cpms->mem2) AND f2 ) + { + strcpy ( memstr2, sms_mem[i].name ); + f2 = FALSE; + } + + if ( ( sms_mem[i].stor EQ resp_p->response.ptr_que_plus_cpms->mem3) AND f3 ) + { + strcpy ( memstr3, sms_mem[i].name ); + f3 = FALSE; + } + } + sprintf ( g_sa, "%s\"%s\",%d,%d,\"%s\",%d,%d,\"%s\",%d,%d", + me, memstr1, resp_p->response.ptr_que_plus_cpms->used1, resp_p->response.ptr_que_plus_cpms->total1, + memstr2, resp_p->response.ptr_que_plus_cpms->used2, resp_p->response.ptr_que_plus_cpms->total2, + memstr3, resp_p->response.ptr_que_plus_cpms->used3, resp_p->response.ptr_que_plus_cpms->total3); + } + else + { + sprintf ( g_sa, "%s%d,%d,%d,%d,%d,%d", + me, resp_p->response.ptr_que_plus_cpms->used1, resp_p->response.ptr_que_plus_cpms->total1, + memstr2, resp_p->response.ptr_que_plus_cpms->used2, resp_p->response.ptr_que_plus_cpms->total2, + memstr3, resp_p->response.ptr_que_plus_cpms->used3, resp_p->response.ptr_que_plus_cpms->total3); + } + + io_sendMessage ( src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT ); + + cpmsCallType = NONE_CALL; + return 0; /* Ok */ + +} + +int Resp_sPercentCPNUMS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPercentCPNUMS() "); + + sprintf(g_sa, "%s%d,\"%s\",\"%s\",%d,%d,%d", "%CPNUMS: ", + resp_p->response.ptr_set_percent_cpnums->element_id, + resp_p->response.ptr_set_percent_cpnums->alpha_tag, + resp_p->response.ptr_set_percent_cpnums->number, + resp_p->response.ptr_set_percent_cpnums->index_level, + resp_p->response.ptr_set_percent_cpnums->premium_flag, + resp_p->response.ptr_set_percent_cpnums->network_flag); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_tPercentCPNUMS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR alpha_tag[BAT_MAX_CPNUMS_ALPHA_TAG_LEN + 1]; + CHAR number[BAT_MAX_CPNUMS_NUMBER_LEN + 1]; + + TRACE_FUNCTION ("Resp_tPercentCPNUMS() "); + + utl_binToHex(resp_p->response.ptr_set_percent_cpnums->alpha_tag, + (SHORT)resp_p->response.ptr_set_percent_cpnums->c_alpha_tag, + alpha_tag); + + utl_binToHex(resp_p->response.ptr_set_percent_cpnums->number, + (SHORT)resp_p->response.ptr_set_percent_cpnums->c_number, + number); + + sprintf(g_sa, "%s%d,\"%s\",\"%s\",%d,%d,%d", "%CPNUMS: ", + resp_p->response.ptr_tst_percent_cpnums->element_id, + alpha_tag, number, + resp_p->response.ptr_tst_percent_cpnums->index_level, + resp_p->response.ptr_tst_percent_cpnums->premium_flag, + resp_p->response.ptr_tst_percent_cpnums->network_flag); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_sPercentCPNUMS_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPercentCPNUMS_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_tPercentCPNUMS_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPercentCPNUMS_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_qPlusCPOL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CPOL_OPDESC op[2]; + T_BAT_res_que_plus_cpol *cpol; + + TRACE_FUNCTION ("Resp_qPlusCPOL()"); + + /* + * Get a pointer to the CPOL structure for convenience. + */ + cpol=resp_p->response.ptr_que_plus_cpol; + + /* + * This represents a termination of the list of operators + * as far as rCI_PlusCPOL() is concerned. In this case + * our list contains only a single operator. + */ + op[1].index=ACI_NumParmNotPresent; + + /* + * Convert the operator name into a null terminated string, + * which is what the ATI expects. + */ + memset(op[0].oper,0,MAX_ALPHA_OPER_LEN); + if (cpol->c_oper>=MAX_ALPHA_OPER_LEN) + memcpy(op[0].oper,cpol->oper,MAX_ALPHA_OPER_LEN-1); + else + memcpy(op[0].oper,cpol->oper,cpol->c_oper); + + /* + * This relies on T_ACI_CPOL_FRMT being identical to + * T_BAT_plus_cpol_format. + */ + op[0].format=(T_ACI_CPOL_FRMT)cpol->format; + + op[0].index=(SHORT)cpol->index; + + rCI_PlusCPOL( + ACI_NumParmNotPresent, + ACI_NumParmNotPresent, + op, + ACI_NumParmNotPresent); + return 0; /* Ok */ +} + +int Resp_tPlusCPOL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCPOL()"); + + rCI_PlusCPOL((SHORT)resp_p->response.ptr_tst_plus_cpol->index1, + (SHORT)resp_p->response.ptr_tst_plus_cpol->index2, + NULL, + ACI_NumParmNotPresent); + + return 0; /* Ok */ +} + +int Resp_qPlusCPOL_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCPOL_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_tPlusCPOL_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCPOL_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_qPercentCPOPN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR long_name[BAT_MAX_CPOPN_LONG_NAME_LEN + 1]; + CHAR short_name[BAT_MAX_CPOPN_SHORT_NAME_LEN + 1]; + + TRACE_FUNCTION ("Resp_qPercentCPOPN() "); + + utl_binToHex(resp_p->response.ptr_que_percent_cpopn->long_name, + (SHORT)resp_p->response.ptr_que_percent_cpopn->c_long_name, + long_name); + + if(resp_p->response.ptr_que_percent_cpopn->v_short_name) + utl_binToHex(resp_p->response.ptr_que_percent_cpopn->short_name, + (SHORT)resp_p->response.ptr_que_percent_cpopn->c_short_name, + short_name); + + if ( resp_p->response.ptr_que_percent_cpopn->v_short_name) + { + sprintf(g_sa, "%s: \"%s\",\"%s\"", "%CPOPN", long_name, short_name); + } + else + { + sprintf(g_sa, "%s: \"%s\"", "%CPOPN", long_name); + } + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentCPRSM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *me = "%CPRSM"; + TRACE_FUNCTION ("Resp_qPercentCPRSM()"); + + sprintf(g_sa,"%s: %d", me, resp_p->response.ptr_que_percent_cprsm->mode); + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCPUC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char currency [BAT_MAX_CPUC_CURRENCY_LEN+1] = {0x00}; + char cvtdCurrency [2*BAT_MAX_CPUC_CURRENCY_LEN+1] = {0x00}; + USHORT lenCurrency = 0; + USHORT lenCvtdCurrency = 0; + USHORT pos = 0; + char ppu [BAT_MAX_CPUC_PPU_LEN+1] = {0x00}; + + TRACE_FUNCTION ("Resp_qPlusCPUC()"); + utl_binToHex(resp_p->response.ptr_que_plus_cpuc->currency, + (SHORT)resp_p->response.ptr_que_plus_cpuc->c_currency, + currency); + utl_binToHex(resp_p->response.ptr_que_plus_cpuc->ppu, + (SHORT)resp_p->response.ptr_que_plus_cpuc->c_ppu, + ppu); + utl_chsetFromGsm((UBYTE*)currency, + (USHORT)strlen(currency), + (UBYTE*)cvtdCurrency, + sizeof(cvtdCurrency), + &lenCvtdCurrency, + GSM_ALPHA_Def); + pos = sprintf(g_sa,"+CPUC: "); + pos += sprints(g_sa+pos,cvtdCurrency,lenCvtdCurrency); + pos += sprintf(g_sa+pos,",\"%s\"",ppu); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCPUC_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCPUC_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_sPercentCPVWI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPercentCPVWI()"); + + if(resp_p->response.ptr_set_percent_cpvwi->status EQ BAT_P_CPVWI_FLAG_ACTIVATED) + + sprintf(g_sa, "%s: %d,%d", "%CPVWI", resp_p->response.ptr_set_percent_cpvwi->status, + resp_p->response.ptr_set_percent_cpvwi->line); + else + sprintf(g_sa, "%s: %d", "%CPVWI", resp_p->response.ptr_set_percent_cpvwi->status); + + io_sendMessage((UBYTE)src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + + return 0; /* Ok */ +} + +int Resp_qPercentCREG(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ATI_CREG_MOD mode; + T_ACI_CREG_STAT stat; + short pos; + TRACE_FUNCTION ("Resp_qPercentCREG() "); +/* + r_plus_percent_CREG ( src_infos_psi->srcId, + resp_p->response.ptr_que_percent_creg->stat, + (USHORT)resp_p->response.ptr_que_percent_creg->lac, + (USHORT)resp_p->response.ptr_que_percent_creg->ci, + PercentCREG_CMD, + resp_p->response.ptr_que_percent_creg->gprs_ind, + FALSE ); +*/ + + mode = ati_user_output_cfg[src_infos_psi->srcId].percent_creg.mod_lac_cid.pres_mode; + stat = resp_p->response.ptr_que_percent_creg->stat; + + pos = sprintf(g_sa, "%s: %d,%d", "%CREG", mode, stat); + + if ((mode EQ CREG_MOD_LOC_INF_ON) AND + (stat EQ CREG_STAT_Reg OR stat EQ CREG_STAT_Roam)) + { + pos += sprintf(g_sa+pos, ",\"%04X\",\"%04X\"", + (USHORT)resp_p->response.ptr_que_percent_creg->lac, + (USHORT)resp_p->response.ptr_que_percent_creg->ci); + } + else + { + pos += sprintf(g_sa+pos, ",,"); + } + + sprintf(g_sa+pos,",%d", resp_p->response.ptr_que_percent_creg->gprs_ind); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_tPlusCRES(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCRES() some error no min filed present!!!"); + + sprintf ( g_sa, "+CRES: (%d-%d)",resp_p->response.ptr_tst_plus_cres->max, + /*need a min filed*/ + resp_p->response.ptr_tst_plus_cres->max); + io_sendMessage (src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT ); + + return 0; /* Ok */ +} + +int Resp_qPlusCRLP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCRLP()"); + + resp_disp(src_infos_psi->srcId,NULL,"ssss",&(resp_p->response.ptr_que_plus_crlp->iws), + &(resp_p->response.ptr_que_plus_crlp->mws), + &(resp_p->response.ptr_que_plus_crlp->t1), + &(resp_p->response.ptr_que_plus_crlp->n2)); + + return 0; /* Ok */ +} + +int Resp_sPlusCRSM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_set_plus_crsm *crsm; + + TRACE_FUNCTION ("Resp_sPlusCRSM() "); + /* + * Get a pointer to the CRSM structure for convenience. + */ + crsm=resp_p->response.ptr_set_plus_crsm; + rCI_PlusCRSM( + (SHORT)crsm->sw1, + (SHORT)crsm->sw2, + (SHORT)crsm->c_response, + (UBYTE *)crsm->response); + return 0; /* Ok */ +} + +int Resp_tPlusCSAS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_tPlusCSAS() "); + + sprintf ( g_sa, "+CSAS: (0-%d)", resp_p->response.ptr_tst_plus_csas->max - 1 ); + io_sendMessage (src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT ); + + return 0; /* Ok */ +} + +int Resp_qPlusCSCA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR sca[MAX_SMS_NUM_LEN] = {'\0'}; + T_ACI_TOA tosca; + TRACE_FUNCTION ("Resp_qPlusCSCA() "); + +/* utl_binToHex(resp_p->response.ptr_que_plus_csca->sca, + (SHORT)resp_p->response.ptr_que_plus_csca->c_sca, + sca); +*/ + if (resp_p->response.ptr_que_plus_csca->c_sca > 0) + { + memcpy(sca, + resp_p->response.ptr_que_plus_csca->sca, + (SHORT)resp_p->response.ptr_que_plus_csca->c_sca); + } + + tosca=toa_demerge((SHORT)resp_p->response.ptr_que_plus_csca->tosca); + sprintf(g_sa, "+CSCA: \"%s%s\",%d", (tosca.ton EQ TON_International)?"+":"", + sca, resp_p->response.ptr_que_plus_csca->tosca); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCSCB(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + int i, pos; + char mids_str[6*BAT_MAX_IDENTS+1]={'\0'}; + char dcss_str[4*BAT_MAX_IDENTS+1]={'\0'}; + + TRACE_FUNCTION ("Resp_qPlusCSCB()"); + + /* assemble the string for message identifiers */ + pos = i = 0; + while ((resp_p->response.ptr_que_plus_cscb->mids[i] NEQ 0xFFFF) + AND (resp_p->response.ptr_que_plus_cscb->mids[i+1] NEQ 0xFFFF) + AND (i < BAT_MAX_IDENTS-1)) + { + if (resp_p->response.ptr_que_plus_cscb->mids[i] EQ resp_p->response.ptr_que_plus_cscb->mids[i+1]) + { + pos += sprintf ( mids_str + pos, "%d,", resp_p->response.ptr_que_plus_cscb->mids[i] ); + } + else + { + pos += sprintf ( mids_str + pos, "%d-%d,", resp_p->response.ptr_que_plus_cscb->mids[i], + resp_p->response.ptr_que_plus_cscb->mids[i+1] ); + } + i += 2; + } + + if (pos > 0) /* remove the last ',' */ + { + mids_str[pos-1] = '\0'; + } + + /* assemble the string for data coding schemes */ + pos = i = 0; + + while ((resp_p->response.ptr_que_plus_cscb->dcss[i] NEQ 0xFF) + AND (resp_p->response.ptr_que_plus_cscb->dcss[i+1] NEQ 0xFF) + AND (i < BAT_MAX_IDENTS-1)) + { + if (resp_p->response.ptr_que_plus_cscb->dcss[i] EQ resp_p->response.ptr_que_plus_cscb->dcss[i+1]) + { + pos += sprintf(dcss_str + pos, "%d,", resp_p->response.ptr_que_plus_cscb->dcss[i]); + } + else + { + pos += sprintf(dcss_str + pos, "%d-%d,", resp_p->response.ptr_que_plus_cscb->dcss[i], + resp_p->response.ptr_que_plus_cscb->dcss[i+1]); + } + i += 2; + } + + if (pos > 0) /* remove the last ',' */ + { + dcss_str[pos-1] = '\0'; + } + + sprintf(g_sa,"+CSCB: %d,\"%s\",\"%s\"",resp_p->response.ptr_que_plus_cscb->mode,mids_str,dcss_str); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPlusCSCS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCSCS()"); + + strcpy ( g_sa, "+CSCS: "); + + switch (resp_p->response.ptr_que_plus_cscs->cs) + { + case (BAT_CSCS_CS_IRA ): strcat (g_sa,"\"IRA\"" ); break; + case (BAT_CSCS_CS_PCDN ): strcat (g_sa,"\"PCDN\"" ); break; + case (BAT_CSCS_CS_8859_1 ): strcat (g_sa,"\"8859-1\"" ); break; + case (BAT_CSCS_CS_PCCP_437): strcat (g_sa,"\"PCCP437\""); break; + case (BAT_CSCS_CS_GSM ): strcat (g_sa,"\"GSM\"" ); break; + case (BAT_CSCS_CS_HEX ): strcat (g_sa,"\"HEX\"" ); break; + case (BAT_CSCS_CS_UCS2 ): strcat (g_sa,"\"UCS2\"" ); break; + + default: + /* + * It's probably best to do nothing at all at this point. An + * error message would just confuse the issue as aci_bat_wrapper() + * will cause an OK to be sent and we can't stop it now. + * Shouldn't get here anyway. + */ + cmdErrStr=NULL; + return(0); + } + + io_sendMessage(src_infos_psi->srcId,g_sa,ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_sPlusCSIM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_set_plus_csim *csim; + + TRACE_FUNCTION ("Resp_sPlusCSIM()"); + /* + * Get a pointer to the CSIM structure for convenience. + */ + csim=resp_p->response.ptr_set_plus_csim; + rCI_PlusCSIM( + (SHORT)csim->c_response, + (UBYTE *)csim->response); + return 0; /* Ok */ +} + +int Resp_qPlusCSMS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCSMS()"); + sprintf(g_sa,"+CSMS: %d,%d,%d,%d",resp_p->response.ptr_que_plus_csms->service, + resp_p->response.ptr_que_plus_csms->mt,resp_p->response.ptr_que_plus_csms->mo, + resp_p->response.ptr_que_plus_csms->bm); + io_sendMessage(src_infos_psi->srcId,g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCSNS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCSNS()"); + resp_disp (src_infos_psi->srcId, NULL,"e",&resp_p->response.ptr_que_plus_csns->mode); + + return 0; /* Ok */ +} + +int Resp_qPercentCSQ(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCSQ()"); + sprintf (g_sa, "%s %d, %d, %d", "%CSQ: ",resp_p->response.ptr_que_percent_csq->rssi, + resp_p->response.ptr_que_percent_csq->ber, resp_p->response.ptr_que_percent_csq->actlevel); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_sPlusCSQ(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCSQ()"); + + sprintf (g_sa, "+CSQ: %d,%d ", resp_p->response.ptr_set_plus_csq->rssi, + resp_p->response.ptr_set_plus_csq->ber ); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusCSTA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCSTA()"); + resp_disp(src_infos_psi->srcId, NULL,"s",&resp_p->response.ptr_que_plus_csta->type); + + return 0; /* Ok */ +} + +int Resp_qPlusCSVM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR num[BAT_MAX_CSVM_NUMBER_LEN+1]; + + TRACE_FUNCTION ("Resp_qPlusCSVM()"); + /* + * Get a pointer to the CSVM structure for convenience. + */ + memset(num,0,sizeof(num)); + utl_binToHex(resp_p->response.ptr_que_plus_csvm->number, + resp_p->response.ptr_que_plus_csvm->c_number, num); + sprintf(g_sa,"+CSVM: %d,\"%s\",%d",resp_p->response.ptr_que_plus_csvm->mode, + num,resp_p->response.ptr_que_plus_csvm->type); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentCTTY(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCTTY()"); + if (resp_p->response.ptr_que_percent_ctty->trx EQ CTTY_TRX_Unknown) + resp_disp (src_infos_psi->srcId,NULL,"ee", + &resp_p->response.ptr_que_percent_ctty->req, + &resp_p->response.ptr_que_percent_ctty->m); + else + resp_disp (src_infos_psi->srcId, NULL ,"eee", &resp_p->response.ptr_que_percent_ctty->req, + &resp_p->response.ptr_que_percent_ctty->m, &resp_p->response.ptr_que_percent_ctty->trx); + + return 0; /* Ok */ +} + +int Resp_qPlusCTZU(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusCTZU() "); + sprintf(g_sa,"+CTZU: %d", resp_p->response.ptr_que_plus_ctzu->onoff); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentCUST(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentCUST()"); + sprintf(g_sa,"%CUST: %d", resp_p->response.ptr_que_percent_cust->mode); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentSATCC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentSATCC()"); + sprintf(g_sa,"%%SATCC: %d", resp_p->response.ptr_que_percent_satcc->mode); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentDATA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *pktioName = "PKTIO"; + char* des_name; + char* src_name; + T_CAP_ID capability = DEV_CPBLTY_NONE; + + TRACE_FUNCTION ("Resp_qPercentDATA() "); + + des_name = dti_entity_name[resp_p->response.ptr_que_percent_data->des_dev_name].name; + src_name = dti_entity_name[resp_p->response.ptr_que_percent_data->src_dev_name].name; + capability = map_dti_cpblty((U8)resp_p->response.ptr_que_percent_data->capability); + + #ifdef GPRS + if (resp_p->response.ptr_que_percent_data->des_dev_name + EQ BAT_DEV_NAME_PKTIO) + { + des_name = pktioName; + } + + if (resp_p->response.ptr_que_percent_data->src_dev_name + EQ BAT_DEV_NAME_PKTIO) + { + src_name = pktioName; + } + #endif + + sprintf (g_sa,"%s: %d,\"%s\",%d,%d,\"%s\",\"%s\",%d,%d,%d", + "%DATA", + resp_p->response.ptr_que_percent_data->mode, + des_name, + resp_p->response.ptr_que_percent_data->des_dev_no, + resp_p->response.ptr_que_percent_data->des_sub_no, + ati_cap_name[capability].name, + src_name, + resp_p->response.ptr_que_percent_data->src_dev_no, + resp_p->response.ptr_que_percent_data->src_sub_no, + resp_p->response.ptr_que_percent_data->cid); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + + +int Resp_sPercentDINF(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_CAP_ID capability = DEV_CPBLTY_NONE; + T_CAP_ID cur_cap = DEV_CPBLTY_NONE; + + TRACE_FUNCTION ("Resp_sPercentDINF() IMPLEMENTED but without outputing mode !"); + capability = map_dti_cpblty((U8)(resp_p->response.ptr_set_percent_dinf->cap)); + cur_cap = map_dti_cpblty((U8)(resp_p->response.ptr_set_percent_dinf->cur_cap)); + + sprintf (g_sa,"%s:\"%s\",%d,%d,\"%s\",\"%s\"", "%DINF", + dti_entity_name[(resp_p->response.ptr_set_percent_dinf->dev_name)].name, + resp_p->response.ptr_set_percent_dinf->dev_no, + resp_p->response.ptr_set_percent_dinf->sub_no, + ati_cap_name[capability].name, + ati_cap_name[cur_cap].name + /*mode*/); + /* dont know how to get mode?? */ + /*shd we call qBAT_PercentDINF??*/ + + io_sendMessage (src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; +} + + +int Resp_qPlusDS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusDS()"); + resp_disp(src_infos_psi->srcId,NULL,"eels",&resp_p->response.ptr_que_plus_ds->dir, + &resp_p->response.ptr_que_plus_ds->neg, + &resp_p->response.ptr_que_plus_ds->p1, + &resp_p->response.ptr_que_plus_ds->p2); + return 0; /* Ok */ +} + +int Resp_qPlusFAP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFAP()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFBO(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFBO()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFBS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFBS()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFBU(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFBU()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFCC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFCC()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFCLASS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFCLASS()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFCQ(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFCQ()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFCR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFCR()"); + + return 0; /* Ok */ +} + + +int Resp_qPlusFCS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFCS()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFCT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFCT()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFEA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFEA()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFFC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFFC()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFHS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFHS()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFIE(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFIE()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFIS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFIS()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFIT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFIT()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFLI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFLI()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFLO(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFLO()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFLP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFLP()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFMS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFMS()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFNS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFNS()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFPA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFPA()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFPI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFPI()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFPS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFPS()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFPW(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFPW()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFRQ(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFRQ()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFSA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFSA()"); + + return 0; /* Ok */ +} + +int Resp_qPlusFSP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusFSP()"); + + sprintf(g_sa,"+FSP:%d",resp_p->response.ptr_que_plus_fsp->poll); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPlusICF(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_BS_FRM format; + T_ACI_BS_PAR parity; + T_BAT_res_que_plus_icf *icf; + TRACE_FUNCTION ("Resp_qPlusICF()"); + /* + * Get a pointer to the ICF structure for convenience. + */ + icf=resp_p->response.ptr_que_plus_icf; + /* + * This relies on T_ACI_BS_FRM being identical to + * T_BAT_framing_format and T_ACI_BS_PAR being identical + * to T_BAT_framing_parity. + */ + format=(T_ACI_BS_FRM)icf->framing_format; + parity=(T_ACI_BS_PAR)icf->framing_parity; + if ((format==BS_FRM_Dat8_Par1_St1) || (format==BS_FRM_Dat7_Par1_St1)) + resp_disp(src_infos_psi->srcId,NULL,"ee",&format,&parity); + else + resp_disp(src_infos_psi->srcId,NULL,"e",&format); + + return 0; /* Ok */ +} + +int Resp_qPlusIFC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusIFC()"); + sprintf(g_sa,"+IFC: %d,%d", resp_p->response.ptr_que_plus_ifc->by_te, + resp_p->response.ptr_que_plus_ifc->by_ta); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + + +int Resp_qPercentIMEI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentIMEI()"); + sprintf ( g_sa, + "%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d", + (resp_p->response.ptr_que_percent_imei->tac1 >> 4) & 0x0F, + resp_p->response.ptr_que_percent_imei->tac1 & 0x0F, + + (resp_p->response.ptr_que_percent_imei->tac2 >> 4) & 0x0F, + resp_p->response.ptr_que_percent_imei->tac2 & 0x0F, + + (resp_p->response.ptr_que_percent_imei->tac3 >> 4) & 0x0F, + resp_p->response.ptr_que_percent_imei->tac3 & 0x0F, + + (resp_p->response.ptr_que_percent_imei->fac >> 4) & 0x0F, + resp_p->response.ptr_que_percent_imei->fac & 0x0F, + + (resp_p->response.ptr_que_percent_imei->snr1 >> 4) & 0x0F, + resp_p->response.ptr_que_percent_imei->snr1 & 0x0F, + + (resp_p->response.ptr_que_percent_imei->snr2 >> 4) & 0x0F, + resp_p->response.ptr_que_percent_imei->snr2 & 0x0F, + + (resp_p->response.ptr_que_percent_imei->snr3 >> 4) & 0x0F, + resp_p->response.ptr_que_percent_imei->snr3 & 0x0F, + + resp_p->response.ptr_que_percent_imei->cd, + (resp_p->response.ptr_que_percent_imei->svn >> 4) & 0x0F, + resp_p->response.ptr_que_percent_imei->svn & 0x0F ); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT ); + return 0; /* Ok */ +} + + + +int Resp_qPlusIPR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + int rate_value; + TRACE_FUNCTION ("Resp_qPlusIPR()"); + switch (resp_p->response.ptr_que_plus_ipr->rate) + { + case BD_RATE_75: rate_value = 75; break; + case BD_RATE_150: rate_value = 150; break; + case BD_RATE_300: rate_value = 300; break; + case BD_RATE_600: rate_value = 600; break; + case BD_RATE_1200: rate_value = 1200; break; + case BD_RATE_2400: rate_value = 2400; break; + case BD_RATE_4800: rate_value = 4800; break; + case BD_RATE_7200: rate_value = 7200; break; + case BD_RATE_9600: rate_value = 9600; break; + case BD_RATE_14400: rate_value = 14400; break; + case BD_RATE_19200: rate_value = 19200; break; + case BD_RATE_28800: rate_value = 28800; break; + case BD_RATE_33900: rate_value = 33900; break; + case BD_RATE_38400: rate_value = 38400; break; + case BD_RATE_57600: rate_value = 57600; break; + case BD_RATE_115200: rate_value = 115200; break; + case BD_RATE_203125: rate_value = 203125; break; + case BD_RATE_406250: rate_value = 406250; break; + case BD_RATE_812500: rate_value = 812500; break; + default: rate_value = 0; break; + } + sprintf(g_sa,"+IPR: %d", rate_value); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentPBCF(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR *me="%PBCF: "; + + TRACE_FUNCTION ("Resp_qPercentPBCF()"); + sprintf(g_sa,"%s%d, %d, %d", me, resp_p->response.ptr_que_percent_pbcf->ldn, + resp_p->response.ptr_que_percent_pbcf->lrn, + resp_p->response.ptr_que_percent_pbcf->lmn); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentPPP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentPPP()"); + #define IPADDR_BYTE(b, a) (((a) >> ((b) * 8)) & 0xff) + + sprintf(g_sa, "%%PPP: %u.%u.%u.%u,%u.%u.%u.%u,%u.%u.%u.%u", + IPADDR_BYTE(3, resp_p->response.ptr_que_percent_ppp->ipaddr), + IPADDR_BYTE(2, resp_p->response.ptr_que_percent_ppp->ipaddr), + IPADDR_BYTE(1, resp_p->response.ptr_que_percent_ppp->ipaddr), + IPADDR_BYTE(0, resp_p->response.ptr_que_percent_ppp->ipaddr), + IPADDR_BYTE(3, resp_p->response.ptr_que_percent_ppp->dns1), + IPADDR_BYTE(2, resp_p->response.ptr_que_percent_ppp->dns1), + IPADDR_BYTE(1, resp_p->response.ptr_que_percent_ppp->dns1), + IPADDR_BYTE(0, resp_p->response.ptr_que_percent_ppp->dns1), + IPADDR_BYTE(3, resp_p->response.ptr_que_percent_ppp->dns2), + IPADDR_BYTE(2, resp_p->response.ptr_que_percent_ppp->dns2), + IPADDR_BYTE(1, resp_p->response.ptr_que_percent_ppp->dns2), + IPADDR_BYTE(0, resp_p->response.ptr_que_percent_ppp->dns2)) ; + io_sendMessage (src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_qPercentPVRF(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_que_percent_pvrf *pvrf; + CHAR *me="%PVRF: "; + TRACE_FUNCTION ("Resp_qPercentPVRF()"); + /* + * Get a pointer to the PVRF structure for convenience. + */ + pvrf=resp_p->response.ptr_que_percent_pvrf; + + sprintf(g_sa,"%s%d, %d, %d, %d, %d, %d", + me, + pvrf->pn1cnt, + pvrf->pn2cnt, + pvrf->pk1cnt, + pvrf->pk2cnt, + pvrf->ps1, + pvrf->ps2); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_qPercentRDL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentRDL() "); + resp_disp (src_infos_psi->srcId, NULL,"b",&resp_p->response.ptr_que_percent_rdl->mode); + return 0; /* Ok */ +} + +int Resp_qPercentRDLB(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR number[MAX_CC_CALLED_NUMBER+1]; + UBYTE i,j; + USHORT pos = 0; + TRACE_FUNCTION ("Resp_qPercentRDLB() "); + memset(number,0,MAX_CC_CALLED_NUMBER+1); + // resp_disp (srcId, cl,"b", &usr_notif); /* output user notification state */ + for(i=0; i<resp_p->response.ptr_que_percent_rdlb->c_number; i++) /* output black list */ + { + for(j=0; j<resp_p->response.ptr_que_percent_rdlb->c_number; j++) + { + resp_p->response.ptr_que_percent_rdlb->number[j] = (resp_p->response.ptr_que_percent_rdlb->number[j] | 0x30); + } + utl_binToHex(resp_p->response.ptr_que_percent_rdlb->number, + resp_p->response.ptr_que_percent_rdlb->c_number, number); + pos=sprintf(g_sa,"%s:\"%s\",%d","%RDLB",number, + (int)resp_p->response.ptr_que_percent_rdlb->type); + + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + } + + return 0; /* Ok */ +} + +#ifdef SIM_TOOLKIT +int Resp_qPercentSATC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + UBYTE i; + TRACE_FUNCTION ("Resp_qPercentSATC()"); + + i=sprintf(g_sa,"%s: %d,", "%SATC", sat[src_infos_psi->srcId]); + + if (resp_p->response.ptr_que_percent_satc->c_satprfl) + { + utl_binToHex( resp_p->response.ptr_que_percent_satc->satprfl, + resp_p->response.ptr_que_percent_satc->c_satprfl, g_sa +i ); + } + + i+=resp_p->response.ptr_que_percent_satc->c_satprfl*2; + g_sa[i++]='"'; + g_sa[i]='\0'; + + ci_remTrailCom(g_sa,(USHORT)strlen(g_sa)); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} +#endif /* SIM_TOOLKIT */ + +#ifdef GPRS +int Resp_qPercentSNCNT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPercentSNCNT() "); + + rCI_PercentSNCNT ((UBYTE)resp_p->response.ptr_uns_percent_sncnt->cid, + resp_p->response.ptr_uns_percent_sncnt->oct_up, + resp_p->response.ptr_uns_percent_sncnt->oct_down, + resp_p->response.ptr_uns_percent_sncnt->pkt_up, + resp_p->response.ptr_uns_percent_sncnt->pkt_down); + + return 0; /* Ok */ +} +#endif /* GPRS */ + +int Resp_qPlusWS46(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_qPlusWS46() "); + + resp_disp(src_infos_psi->srcId, NULL,"e", + &resp_p->response.ptr_que_plus_ws46->n); + + return 0; /* Ok */ +} + +int Resp_qPlusCLCC(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + SHORT pos = 0; + char *me = "+CLCC: "; + USHORT lenCvtdAlpha = 0; + CHAR number[BAT_MAX_CLCC_NUMBER_LEN + 1]; + + TRACE_FUNCTION ("Resp_qPlusCLCC() "); + + /* Call info is sent at a time, this flag will mark the start and end of this call list */ + if(CLCC_flag == FALSE) + CLCC_flag = TRUE; + + if(resp_p->response.ptr_que_plus_clcc->idx EQ ACI_NumParmNotPresent) + return 0; + + pos = sprintf(g_sa,"%s%d", me, resp_p->response.ptr_que_plus_clcc->idx); + + if (resp_p->response.ptr_que_plus_clcc->dir NEQ CLCC_DIR_NotPresent) + pos += sprintf(g_sa+pos,",%d",resp_p->response.ptr_que_plus_clcc->dir); + else + pos += sprintf(g_sa+pos,","); + if (resp_p->response.ptr_que_plus_clcc->stat NEQ CLCC_STAT_NotPresent) + pos += sprintf(g_sa+pos,",%d",resp_p->response.ptr_que_plus_clcc->stat); + else + pos += sprintf(g_sa+pos,","); + if (resp_p->response.ptr_que_plus_clcc->mode NEQ CLCC_MODE_NotPresent) + pos += sprintf(g_sa+pos,",%d",resp_p->response.ptr_que_plus_clcc->mode); + else + pos += sprintf(g_sa+pos,","); + if (resp_p->response.ptr_que_plus_clcc->mpty NEQ CLCC_MPTY_NotPresent) + pos += sprintf(g_sa+pos,",%d",resp_p->response.ptr_que_plus_clcc->mpty); + else + pos += sprintf(g_sa+pos,","); + + if (resp_p->response.ptr_que_plus_clcc->number[0] NEQ 0x0) + { + utl_binToHex(resp_p->response.ptr_que_plus_clcc->number, + resp_p->response.ptr_que_plus_clcc->c_number, number); + pos += sprintf(g_sa+pos,",\"%s\",%d",number,(int)(resp_p->response.ptr_que_plus_clcc->type)); + } +#ifdef NO_ASCIIZ /* Need to add other struct ?! */ + /* if (resp_p->response.ptr_que_plus_clcc->c_alpha.len NEQ 0x0) + { + pos += sprintf(g_sa+pos,","); + utl_chsetFromGsm ( resp_p->response.ptr_que_plus_clcc->alpha.data, + resp_p->response.ptr_que_plus_clcc->alpha.len, + (UBYTE*)cvtdAlpha, + sizeof(cvtdAlpha), + &lenCvtdAlpha, + GSM_ALPHA_Def ); + pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha ); + } */ +#else /* #ifdef NO_ASCIIZ */ + if (resp_p->response.ptr_que_plus_clcc->alpha[0] NEQ 0x0) + { + pos += sprintf(g_sa+pos,","); + utl_chsetFromGsm ( (UBYTE*)resp_p->response.ptr_que_plus_clcc->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(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + + +int Resp_uPlusCBM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MMI_CBCH_IND mmi_cbch_ind ; + TRACE_FUNCTION ("Resp_uPlusCBM() "); + + mmi_cbch_ind.cbch_len = resp_p->response.ptr_res_plus_cbm->c_pdu; + memcpy(resp_p->response.ptr_res_plus_cbm->pdu, + mmi_cbch_ind.cbch_msg, + resp_p->response.ptr_res_plus_cbm->c_pdu); + + return 0; /* Ok */ +} + +int Resp_uPlusCBMI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCBMI() not implemented"); + + return 0; /* Ok */ +} + +int Resp_uPercentCCBS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CCBS_IND ind; + T_ACI_CCBS_STAT status; + T_ACI_CCBS_SET setting; + T_BAT_res_uns_percent_ccbs *ccbs; + TRACE_FUNCTION ("Resp_uPercentCCBS()"); + /* + * Get a pointer to the CCBS structure for convenience. + */ + ccbs=resp_p->response.ptr_res_percent_ccbs; + /* + * This relies on T_ACI_CCBS_IND being identical to + * T_BAT_percent_ccbs_ind and T_ACI_CCBS_STAT being identical + * to T_BAT_percent_ccbs_stat. + */ + ind=(T_ACI_CCBS_IND)ccbs->ind; + status=(T_ACI_CCBS_STAT)ccbs->stat; + /* + * The main reason for zeroing this memory is to ensure we + * end up with zero-terminated 'number' and 'subaddress' + * strings. + */ + memset(&setting,0,sizeof(T_ACI_CCBS_SET)); + setting.idx=(SHORT)ccbs->idx; + if ((ccbs->v_number==TRUE) && (ccbs->c_number<MAX_B_SUBSCR_NUM_LEN)) + memcpy(setting.number,ccbs->number,ccbs->c_number); + setting.type=toa_demerge((SHORT)ccbs->type); + if ((ccbs->v_subaddr==TRUE) && (ccbs->c_subaddr<MAX_SUBADDR_LEN)) + memcpy(setting.subaddr,ccbs->subaddr,ccbs->c_subaddr); + setting.satype=tos_demerge((SHORT)ccbs->satype); + /* + * This relies on T_ACI_CLASS being identical to T_BAT_bearer_class + * and T_ACI_ALRT_PATTERN being identical to T_BAT_percent_ccbs_ptn. + */ + setting.class_type=(T_ACI_CLASS)ccbs->bearer_class; + setting.alrtPtn=(T_ACI_ALRT_PTRN)ccbs->ptn; + rCI_PercentCCBS(ind,status,&setting,FALSE); + return 0; /* Ok */ +} + +int Resp_uPlusCCCM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCCCM()"); + rCI_PlusCCCM(&resp_p->response.ptr_res_plus_cccm->ccm); + return 0; /* Ok */ +} + +int Resp_uPercentCCCN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_fac_inf fie; + TRACE_FUNCTION ("Resp_uPercentCCCN() "); + + fie.l_fac = resp_p->response.ptr_res_percent_cccn->c_facility; + memcpy(fie.fac,resp_p->response.ptr_res_percent_cccn->facility, + fie.l_fac); + + rCI_PercentCCCN((T_ACI_FAC_DIR)resp_p->response.ptr_res_percent_cccn->direction, + (SHORT)resp_p->response.ptr_res_percent_cccn->cid, + &fie ); + + return 0; /* Ok */ +} + +int Resp_uPlusCCWA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CLSSTAT clsStat; + T_ACI_TOA type ; + CHAR number[BAT_MAX_CCWA_NUMBER_LEN+1]; + + #ifdef NO_ASCIIZ + T_ACI_PB_TEXT alpha_text ; + #else + CHAR * p_alpha; + CHAR alpha[BAT_MAX_CCWA_NUMBER_LEN+1]; + #endif + + TRACE_FUNCTION ("Resp_uPlusCCWA()"); + + clsStat.class_type = resp_p->response.ptr_res_plus_ccwa->bearer_class; + clsStat.status = STATUS_NotPresent;/*response structure has no info abt sttus*/ +/* + utl_binToHex(resp_p->response.ptr_res_plus_ccwa->number, + (SHORT)resp_p->response.ptr_res_plus_ccwa->c_number, + number); +*/ + memcpy(number, + resp_p->response.ptr_res_plus_ccwa->number, + (SHORT)resp_p->response.ptr_res_plus_ccwa->c_number); + + type = toa_demerge((SHORT)resp_p->response.ptr_res_plus_ccwa->type); + + #ifdef NO_ASCIIZ + + alpha_text.len = resp_p->response.ptr_res_plus_ccwa->c_alpha; + memcpy(alpha_text.data, resp_p->response.ptr_res_plus_ccwa->alpha, alpha_text.len); + + rCI_PlusCCWA(resp_p->response.ptr_res_plus_ccwa->bearer_class EQ BAT_CCWA_CLASS_NOT_PRESENT + ? NULL + : &clsStat, + number, + &type, + (U8)resp_p->response.ptr_res_plus_ccwa->cli, + (T_ACI_CLASS)resp_p->response.ptr_res_plus_ccwa->bearer_class, + alpha_text.len + ? &alpha_text + : NULL); + #else + + p_alpha = alpha; + if(resp_p->response.ptr_res_plus_ccwa.->v_alpha) + { + utl_binToHex(resp_p->response.ptr_res_plus_ccwa->alpha, + (SHORT)resp_p->response.ptr_res_plus_ccwa->c_alpha, + alpha); + } + else + { + p_alpha = NULL; + } + rCI_PlusCCWA(resp_p->response.ptr_res_plus_ccwa->bearer_class EQ BAT_CCWA_CLASS_NOT_PRESENT + ? NULL + : &clsStat, + number, + &type, + (U8)resp_p->response.ptr_res_plus_ccwa->cli, + (T_ACI_CLASS)resp_p->response.ptr_res_plus_ccwa->bearer_class, + p_alpha); + #endif + + return 0; /* Ok */ +} + +int Resp_uPlusCCWA_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCCWA_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_uPlusCCWE(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCCWE() contains bat dummy out put nothing"); + + return 0; /* Ok */ +} + +int Resp_uPlusCDIP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_uns_plus_cdip *cdip; + CHAR number[BAT_MAX_CDIP_NUMBER_LEN+1]; + T_ACI_TOA type; + CHAR *sub_ptr; + CHAR subaddr[BAT_MAX_SUBADDR_LENGTH+1]; + T_ACI_TOS *satype_ptr; + T_ACI_TOS satype; + + TRACE_FUNCTION ("Resp_uPlusCDIP()"); + + sub_ptr=NULL; + satype_ptr=NULL; + + /* + * Get a pointer to the CDIP structure for convenience. + */ + cdip = (T_BAT_res_uns_plus_cdip *)resp_p->response.ptr_res_plus_cdip; + + memset(number,0,sizeof(number)); + memcpy(number,cdip->number,BAT_MAX_CDIP_NUMBER_LEN); + + type=toa_demerge(cdip->type); + + if (cdip->v_subaddr) + { + memset(subaddr,0,sizeof(subaddr)); + memcpy(subaddr,cdip->subaddr,BAT_MAX_SUBADDR_LENGTH); + sub_ptr=subaddr; + + satype=tos_demerge(cdip->satype); + satype_ptr=&satype; + } + + rCI_PlusCDIP(number, + &type, + sub_ptr, + satype_ptr); + return 0; /* Ok */ +} + +int Resp_uPlusCDS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MNSMS_STATUS_IND mnsms_status_ind; + + TRACE_FUNCTION ("Resp_uPlusCDS()"); + + mnsms_status_ind.sms_sdu.l_buf = resp_p->response.ptr_res_plus_cds->c_pdu; + memcpy(mnsms_status_ind.sms_sdu.buf,resp_p->response.ptr_res_plus_cds->pdu, + resp_p->response.ptr_res_plus_cds->c_pdu); + + rCI_PlusCDSPdu(&mnsms_status_ind); + + return 0; /* Ok */ +} + +#ifdef GPRS +int Resp_uPercentCGEV(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_CGEREP_EVENT event; + T_CGEREP_EVENT_REP_PARAM param; + T_BAT_res_uns_percent_cgev *cgev; + TRACE_FUNCTION ("Resp_uPercentCGEV()"); + /* + * Get a pointer to the CGEV structure for convenience. + */ + cgev=resp_p->response.ptr_res_percent_cgev; + + memset(¶m,0,sizeof(param)); + + /* + * This relies on T_CGEREP_EVENT being identical to + * T_BAT_percent_cgev_evt. + */ + event=(T_CGEREP_EVENT)cgev->evt; + + switch (event) + { + case CGEREP_EVENT_REJECT: + if (cgev->v_pdp_addr==TRUE) + { + if (cgev->c_pdp_addr<MAX_PDP_ADDR_LEN) + memcpy(param.reject.pdp_addr,cgev->pdp_addr,cgev->c_pdp_addr); + } + break; + + case CGEREP_EVENT_NW_CLASS: + case CGEREP_EVENT_ME_CLASS: + /* + * This relies on T_PERCENT_CGCLASS being identical to + * T_BAT_p_mobile_class. + */ + param.mobile_class=(T_PERCENT_CGCLASS)cgev->p_mobile_class; + break; + + case CGEREP_EVENT_NW_REACT: + case CGEREP_EVENT_NW_DEACT: + case CGEREP_EVENT_ME_DEACT: + case CGEREP_EVENT_NW_ACT: + case CGEREP_EVENT_ME_ACT: + if (cgev->v_pdp_addr==TRUE) + { + if (cgev->c_pdp_addr<MAX_PDP_ADDR_LEN) + memcpy(param.act.pdp_addr,cgev->pdp_addr,cgev->c_pdp_addr); + } + + param.act.cid=(SHORT)cgev->cid; + break; + + default: + break; + } + rCI_PercentCGEV(event,¶m); + return 0; /* Ok */ +} + +int Resp_uPlusCGEV(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCGEV() Not Implemented no res plus cgev structure filler found"); + + return 0; /* Ok */ +} + +int Resp_uPercentCGREG(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_P_CGREG_STAT stat; + USHORT lac; + USHORT ci; + T_BAT_res_uns_percent_cgreg *cgreg; + TRACE_FUNCTION ("Resp_uPercentCGREG()"); + /* + * Get a pointer to the CGREG structure for convenience. + */ + cgreg=resp_p->response.ptr_res_percent_cgreg; + stat=(T_P_CGREG_STAT)cgreg->stat; + lac=(USHORT)cgreg->lac; + ci=(USHORT)cgreg->ci; + rCI_PercentCGREG(stat,lac,ci,FALSE); + return 0; /* Ok */ +} + +int Resp_uPlusCGREG(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCGREG()"); + + rCI_PlusCGREG((T_CGREG_STAT)resp_p->response.ptr_res_plus_cgreg->stat, + (USHORT)resp_p->response.ptr_res_plus_cgreg->lac, + (USHORT)resp_p->response.ptr_res_plus_cgreg->ci ); + + return 0; /* Ok */ +} +#endif /* GPRS */ + +int Resp_uPlusCLAE(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_uns_plus_clae *clae; + T_ACI_LAN_SUP lang; + CHAR code[BAT_MAX_CLAE_CODE_LEN+1]; + TRACE_FUNCTION ("Resp_uPlusCLAE()"); + /* + * Get a pointer to the CLAE structure for convenience. + */ + clae=resp_p->response.ptr_res_plus_clae; + memset(code,0,sizeof(code)); + memcpy(code,clae->code,clae->c_code); + /* + * NB rCI_PlusCLAE only cares about the code string, so + * we don't need to populate 'lang' any further than this. + */ + lang.str=code; + rCI_PlusCLAE(&lang); + return 0; /* Ok */ +} + +int Resp_uPlusCLAV(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR code[BAT_MAX_CLAV_CODE_LEN + 1]; + + TRACE_FUNCTION ("Resp_uPlusCLAV() recheck"); + + utl_binToHex(resp_p->response.ptr_res_plus_clav->code, + (SHORT)resp_p->response.ptr_res_plus_clav->c_code, + code) ; + + sprintf(g_sa,"+CLAN: %s",code); + io_sendMessage(src_infos_psi->srcId,g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_uPlusCLIP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_uns_plus_clip *clip; + CHAR number[BAT_MAX_CLIP_NUMBER_LEN+1]; + T_ACI_TOA type; + U8 validity; + CHAR *sub_ptr; + CHAR subaddr[BAT_MAX_SUBADDR_LENGTH+1]; + T_ACI_TOS *satype_ptr; + T_ACI_TOS satype; +#ifdef NO_ASCIIZ + T_ACI_PB_TEXT *alpha_ptr; + T_ACI_PB_TEXT alpha; +#else + CHAR *alpha_ptr; + CHAR alpha[BAT_MAX_PHB_NUM_LEN+1]; +#endif + + TRACE_FUNCTION ("Resp_uPlusCLIP()"); + + sub_ptr=NULL; + satype_ptr=NULL; + alpha_ptr=NULL; + + /* + * Get a pointer to the CLIP structure for convenience. + */ + clip=resp_p->response.ptr_res_plus_clip; + + memset(number,0,sizeof(number)); + memcpy(number,clip->number,BAT_MAX_CLIP_NUMBER_LEN); + + type=toa_demerge(clip->type); + + if (clip->v_subaddr) + { + memset(subaddr,0,sizeof(subaddr)); + memcpy(subaddr,clip->subaddr,BAT_MAX_SUBADDR_LENGTH); + sub_ptr=subaddr; + + satype=tos_demerge(clip->satype); + satype_ptr=&satype; + } + + if (clip->v_alpha) + { +#ifdef NO_ASCIIZ + + memcpy(alpha.data,clip->alpha,MAX_PHB_NUM_LEN); + + if (clip->c_alpha>MAX_PHB_NUM_LEN) + alpha.len=MAX_PHB_NUM_LEN; + else + alpha.len=clip->c_alpha; + + alpha.cs=CS_NotPresent; + + alpha_ptr=α + +#else + + memset(alpha,0,sizeof(alpha)); + memcpy(alpha,clip->alpha,BAT_MAX_PHB_NUM_LEN); + alpha_ptr=alpha; + +#endif + } + + validity=(U8)clip->cli; + + rCI_PlusCLIP( + CLIP_STAT_NotPresent, /* <=== not always true, but BAT does not provide status infromation */ + number, + &type, + validity, + sub_ptr, + satype_ptr, + alpha_ptr); + + return 0; /* Ok */ +} + +int Resp_uPlusCLIP_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCLIP_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_uPlusCMT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MNSMS_MESSAGE_IND mnsms_message_ind; + T_BAT_res_uns_plus_cmt *cmt; + + TRACE_FUNCTION ("Resp_uPlusCMT()"); + /* + * Get a pointer to the CMT structure for convenience. + */ + cmt=resp_p->response.ptr_res_plus_cmt; + + /* + * Check that the received BAT message is not too big. If it is, + * we discard it. + */ + if (cmt->c_pdu>SIM_PDU_LEN) + { + TRACE_EVENT("BAT CMT too big"); + } + else + { + /* + * Set up the bits of mnsms_message_ind that are used by + * rCI_PlusCMT(). + */ + memcpy(&mnsms_message_ind.sms_sdu.buf,cmt->pdu,cmt->c_pdu); + mnsms_message_ind.sms_sdu.l_buf=cmt->c_pdu<<3; + mnsms_message_ind.sms_sdu.o_buf=0; + + /* + * This is not part of the BAT response, so choose a sensible + * value. + */ + mnsms_message_ind.status=REC_UNREAD; + + rCI_PlusCMT(&mnsms_message_ind); + } + return 0; /* Ok */ +} + +int Resp_uPlusCMTI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCMTI() "); + rCI_PlusCMTI((T_ACI_SMS_STOR)resp_p->response.ptr_res_plus_cmti->sms_mem, + (UBYTE)resp_p->response.ptr_res_plus_cmti->sms_index); + + return 0; /* Ok */ +} + +int Resp_uPlusCMT_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCMT_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_uPercentCNAP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + CHAR name[BAT_MAX_CNAP_NAME_LEN + 1]; + + UBYTE pos = 0; + + TRACE_FUNCTION ("Resp_uPercentCNAP() Not implemented"); + + if(resp_p->response.ptr_res_percent_cnap->v_name) + { + utl_binToHex(resp_p->response.ptr_res_percent_cnap->name, + (SHORT)resp_p->response.ptr_res_percent_cnap->c_name, + name) ; + } + + pos += sprintf(g_sa+pos,"%s%d", "%CNAP: ", + resp_p->response.ptr_res_percent_cnap->pres_mode); + + if(resp_p->response.ptr_res_percent_cnap->v_name) + { + pos += sprintf(g_sa+pos,",%hd,", resp_p->response.ptr_res_percent_cnap->dcs); + + switch(resp_p->response.ptr_res_percent_cnap->pres_mode) + { + case BAT_P_CNAP_PRES_NAME: + case BAT_P_CNAP_PRES_NAME_RESTRICTED: + { + TRACE_EVENT("CNAP: name presentation is allowed or restrcited"); + pos += sprintf(g_sa+pos,"%d,\"%s\"", + resp_p->response.ptr_res_percent_cnap->c_name), + resp_p->response.ptr_res_percent_cnap->name; + break; + } + case BAT_P_CNAP_PRES_RESTRICTED: + case BAT_P_CNAP_PRES_NO_NAME: + { + TRACE_EVENT("CNAP: presentation is restricted or no name"); + break; + } + default: + { + TRACE_ERROR("CNAP: wrong presentation mode"); + } + } + } + io_sendIndication(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT ); + + return 0; /* Ok */ +} + +int Resp_uPlusCOLP(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_uns_plus_colp *colp; + CHAR *num_ptr; + CHAR number[BAT_MAX_COLP_NUMBER_LEN+1]; + T_ACI_TOA *type_ptr; + T_ACI_TOA type; + CHAR *sub_ptr; + CHAR subaddr[BAT_MAX_SUBADDR_LENGTH+1]; + T_ACI_TOS *satype_ptr; + T_ACI_TOS satype; +#ifdef NO_ASCIIZ + T_ACI_PB_TEXT *alpha_ptr; + T_ACI_PB_TEXT alpha; +#else + CHAR *alpha_ptr; + CHAR alpha[BAT_MAX_COLP_ALPHA_LEN+1]; +#endif + + TRACE_FUNCTION ("Resp_uPlusCOLP()"); + + num_ptr=NULL; + type_ptr=NULL; + sub_ptr=NULL; + satype_ptr=NULL; + alpha_ptr=NULL; + + /* + * Get a pointer to the COLP structure for convenience. + */ + colp=resp_p->response.ptr_res_plus_colp; + + if (colp->v_number) + { + memset(number,0,sizeof(number)); + memcpy(number,colp->number,BAT_MAX_COLP_NUMBER_LEN); + num_ptr=number; + + type=toa_demerge(colp->type); + type_ptr=&type; + } + + if (colp->v_subaddr) + { + memset(subaddr,0,sizeof(subaddr)); + memcpy(subaddr,colp->subaddr,BAT_MAX_SUBADDR_LENGTH); + sub_ptr=subaddr; + + satype=tos_demerge(colp->satype); + satype_ptr=&satype; + } + + if (colp->v_alpha) + { +#ifdef NO_ASCIIZ + + memcpy(alpha.data,colp->alpha,MAX_PHB_NUM_LEN); + + if (colp->c_alpha>MAX_PHB_NUM_LEN) + alpha.len=MAX_PHB_NUM_LEN; + else + alpha.len=colp->c_alpha; + + alpha.cs=CS_NotPresent; + alpha_ptr=α + +#else + + memset(alpha,0,sizeof(alpha)); + memcpy(alpha,colp->alpha,BAT_MAX_COLP_ALPHA_LEN); + alpha_ptr=alpha; + +#endif + } + + rCI_PlusCOLP( + COLP_STAT_NotPresent, + num_ptr, + type_ptr, + sub_ptr, + satype_ptr, + alpha_ptr); + + return 0; /* Ok */ +} + +int Resp_uPlusCOLP_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCOLP_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_uPercentCPI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_uns_percent_cpi *cpi; + SHORT cId; + T_ACI_CPI_MSG msgType; + T_ACI_CPI_IBT ibt; + T_ACI_CPI_TCH tch; + USHORT cause; + + TRACE_FUNCTION ("Resp_uPercentCPI()"); + /* + * Get a pointer to the CPI structure for convenience. + */ + cpi=resp_p->response.ptr_res_percent_cpi; + + cId=(SHORT)cpi->cid; + + /* + * This relies on T_ACI_CPI_MSG being equivalent to + * T_BAT_percent_cpi_msgtype. + */ + msgType=(T_ACI_CPI_MSG)cpi->msgtype; + + /* + * This relies on T_ACI_CPI_IBT being equivalent to + * T_BAT_percent_cpi_ibt. + */ + ibt=(T_ACI_CPI_IBT)cpi->ibt; + /* + * This relies on T_ACI_CPI_TCH being equivalent to + * T_BAT_percent_cpi_tch. + */ + tch=(T_ACI_CPI_TCH)cpi->tch; + cause=(USHORT)cpi->cause; + rCI_PercentCPI(cId,msgType,ibt,tch,cause); + return 0; /* Ok */ +} + +int Resp_uPercentCPI_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentCPI_W() not implemented"); + + return 0; /* Ok */ +} + +int Resp_uPercentCPRI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_uns_percent_cpri *cpri; + TRACE_FUNCTION ("Resp_uPercentCPRI()"); + /* + * Get a pointer to the CPRI structure for convenience. + */ + cpri=resp_p->response.ptr_res_percent_cpri; + + rCI_PercentCPRI((UBYTE)cpri->gsm_ciph,(UBYTE)cpri->gprs_ciph); + + return 0; /* Ok */ +} + +int Resp_uPercentCPROAM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentCPROAM()"); + + rCI_PercentCPROAM((UBYTE)resp_p->response.ptr_res_percent_cproam->roam_status); + + return 0; /* Ok */ +} + +int Resp_uPercentCPVWI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentCPVWI() "); + rCI_PercentCPVWI((UBYTE)resp_p->response.ptr_res_percent_cpvwi->status, + (USHORT)resp_p->response.ptr_res_percent_cpvwi->line); + + return 0; /* Ok */ +} + +int Resp_uPlusCR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char service[BAT_MAX_CR_SERV_LEN]; + T_ACI_CR_SERV serv; + + TRACE_FUNCTION ("Resp_uPlusCR()"); + + utl_binToHex(resp_p->response.ptr_res_plus_cr->serv, + (SHORT)resp_p->response.ptr_res_plus_cr->c_serv, + service); + + if(!strcmp(service,"ASYNC")) + serv=CR_SERV_Async; + else if(!strcmp(service,"SYNC")) + serv=CR_SERV_Sync; + else if(!strcmp(service,"REL ASYNC")) + serv=CR_SERV_RelAsync; + else if(!strcmp(service,"REL SYNC")) + serv=CR_SERV_RelSync; + + #ifdef GPRS + else if(!strcmp(service,"GPRS")) + serv=CR_SERV_GPRS; + #endif + + else + return 0; + + rCI_PlusCR( serv); + + return 0; /* Ok */ +} + +int Resp_uPercentCREG(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_BAT_res_uns_percent_creg *creg; + T_ACI_CREG_STAT status; + USHORT lac; + USHORT cid; + T_ACI_P_CREG_GPRS_IND gprs_ind; + + TRACE_FUNCTION ("Resp_uPercentCREG()"); + + /* + * Get a pointer to the CREG structure for convenience. + */ + creg=resp_p->response.ptr_res_percent_creg; + + /* + * This relies on T_ACI_CREG_STAT and T_BAT_percent_creg_stat being + * identical. + */ + status=(T_ACI_CREG_STAT)creg->stat; + + lac=(USHORT)creg->lac; + cid=(USHORT)creg->ci; + + /* + * This relies on T_ACI_P_CREG_GPRS_IND and T_BAT_percent_creg_gprs_ind + * being identical. + */ + gprs_ind=(T_ACI_P_CREG_GPRS_IND)creg->gprs_ind; + + rCI_PercentCREG(status,lac,cid,gprs_ind); + return 0; /* Ok */ +} + +int Resp_uPercentCSQ(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentCSQ() "); + + rCI_PercentCSQ((UBYTE)resp_p->response.ptr_res_percent_csq->rssi, + (UBYTE)resp_p->response.ptr_res_percent_csq->ber, + (UBYTE)resp_p->response.ptr_res_percent_csq->actlevel); + + return 0; /* Ok */ +} + +int Resp_uPlusCSSI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCSSI()"); + + rCI_PlusCSSI((T_ACI_CSSI_CODE)resp_p->response.ptr_res_plus_cssi->code1, + (SHORT)resp_p->response.ptr_res_plus_cssi->index); + + return 0; /* Ok */ +} + +int Resp_uPercentCSSN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_fac_inf fie; + TRACE_FUNCTION ("Resp_uPercentCSSN() "); + + fie.l_fac = resp_p->response.ptr_res_percent_cssn->c_facility; + memcpy(fie.fac,resp_p->response.ptr_res_percent_cssn->facility,BAT_MAX_CSSN_FACILITY_LEN); + + rCI_PercentCSSN (resp_p->response.ptr_res_percent_cssn->direction, + resp_p->response.ptr_res_percent_cssn->trans_type, + &fie ); + return 0; /* Ok */ +} + +int Resp_uPlusCSSU(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + char *me="+CSSU: "; + char number[BAT_MAX_CSSU_NUMBER_LEN+1]; + char subaddr[BAT_MAX_SUBADDR_LENGTH+1]; + char* p_number; + char* p_subaddr; + T_ACI_TOA type ; + T_ACI_TOS satype ; + SHORT pos=0; + TRACE_FUNCTION ("Resp_uPlusCSSU()"); + + p_number = number; + p_subaddr = subaddr; + + type = toa_demerge((SHORT)resp_p->response.ptr_res_plus_cssu->type); + satype = tos_demerge((SHORT)resp_p->response.ptr_res_plus_cssu->satype); + + if(resp_p->response.ptr_res_plus_cssu->v_number) + { + utl_binToHex(resp_p->response.ptr_res_plus_cssu->number, + (SHORT)resp_p->response.ptr_res_plus_cssu->c_number, + number); + } + else + p_number = NULL; + + if(resp_p->response.ptr_res_plus_cssu->v_subaddr) + { + utl_binToHex(resp_p->response.ptr_res_plus_cssu->subaddr, + (SHORT)resp_p->response.ptr_res_plus_cssu->c_subaddr, + subaddr); + } + else + p_subaddr=NULL; + + rCI_PlusCSSU((T_ACI_CSSU_CODE)resp_p->response.ptr_res_plus_cssu->code2, + (SHORT)resp_p->response.ptr_res_plus_cssu->index, + p_number, + &type, + p_subaddr, + &satype) ; + + return 0; /* Ok */ +} + +int Resp_uPercentCSTAT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + SHORT pos = 0; + TRACE_FUNCTION ("Resp_uPercentCSTAT() "); + + pos = sprintf(g_sa,"%s: ","%CSTAT"); + + switch(resp_p->response.ptr_res_percent_cstat->entity_id) + { + case BAT_P_CSTAT_ENT_ID_PBOOK: + pos += sprintf(g_sa+pos,"PHB, %d",resp_p->response.ptr_res_percent_cstat->status); + break; + case BAT_P_CSTAT_ENT_ID_SMS : + pos += sprintf(g_sa+pos,"SMS, %d",resp_p->response.ptr_res_percent_cstat->status); + break; + case BAT_P_CSTAT_ENT_ID_RDY : + pos += sprintf(g_sa+pos,"RDY, %d",resp_p->response.ptr_res_percent_cstat->status); + break; + default: + return 0; + } + +#ifndef _SIMULATION_ /* SKA: a lot of test cases do not expect %CSTAT: xxx unsolicited responses */ + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); +#endif + + return 0; /* Ok */ +} + +int Resp_uPercentCTYI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentCTYI()"); + + rCI_PercentCTYI ((T_ACI_CTTY_NEG)resp_p->response.ptr_res_percent_ctyi->neg, + (T_ACI_CTTY_TRX)resp_p->response.ptr_res_percent_ctyi->trx); + + return 0; /* Ok */ +} + +int Resp_uPlusCTZR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCTZR()"); + + sprintf(g_sa,"+CTZR: %d", resp_p->response.ptr_res_plus_ctzr->tz); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + + return 0; /* Ok */ +} + +int Resp_uPercentCTZV(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_MMR_INFO_IND mmr_info_ind; + + TRACE_FUNCTION ("Resp_uPercentCTZV() "); + + mmr_info_ind.time.year = resp_p->response.ptr_res_percent_ctzv->year; + mmr_info_ind.time.month = resp_p->response.ptr_res_percent_ctzv->month; + mmr_info_ind.time.day = resp_p->response.ptr_res_percent_ctzv->day; + mmr_info_ind.time.hour = resp_p->response.ptr_res_percent_ctzv->hour; + mmr_info_ind.time.minute = resp_p->response.ptr_res_percent_ctzv->minutes; + mmr_info_ind.time.second = resp_p->response.ptr_res_percent_ctzv->seconds; + + rCI_PercentCTZV (&mmr_info_ind, (S32)resp_p->response.ptr_res_percent_ctzv->time_zone); + + return 0; /* Ok */ +} + +int Resp_uPlusCTZV(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCTZV()"); + + #ifdef FF_TIMEZONE + rCI_PlusCTZV((S32)resp_p->response.ptr_res_plus_ctzv->tz); + #else + rCI_PlusCTZV(&((UBYTE)resp_p->response.ptr_res_plus_ctzv->tz)); + #endif + + return 0; /* Ok */ +} + +int Resp_uPercentCTZV_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentCTZV_W() Not Implemented"); + + return 0; /* Ok */ +} + +int Resp_uPlusCUSD(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CUSD_MOD m; + T_BAT_res_uns_plus_cusd *cusd; + T_ACI_USSD_DATA ussd; + SHORT dcs; + + TRACE_FUNCTION ("Resp_uPlusCUSD()"); + + /* + * Get a pointer to the CUSD structure for convenience. + */ + cusd=resp_p->response.ptr_res_plus_cusd; + + /* + * If the string isn't valid, just ignore the message. + */ + if (cusd->v_str==TRUE) + { + /* + * This assumes that T_ACI_CUSD_MOD and + * T_BAT_VAL_plus_cusd_m are equivalent. + */ + m=(T_ACI_CUSD_MOD)cusd->m; + + dcs=(SHORT)cusd->dcs; + + /* + * Copy in as much data as the ACI structure can take. + */ + memcpy(ussd.data,cusd->str,MAX_USSD_LEN); + + /* + * Set the length of the data. If there was too much for the + * ACI structure then the data will be truncated. + */ + ussd.len=(cusd->c_str>MAX_USSD_LEN) ? MAX_USSD_LEN:cusd->c_str; + + rCI_PlusCUSD(m,&ussd,dcs); + } + return 0; /* Ok */ +} + + +int Resp_uPlusCUSD_W(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusCUSD_W() Not implemented"); + + return 0; /* Ok */ +} + +int Resp_PlusExtError(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusExtError()"); + + /* + * ACI_ERR_CLASS_Ext ("EXT ERROR: ...")is very often set on CMH level, + * but on ATI level it is overwritten with plain "ERROR". + * Almost all test cases want to see plain "ERROR" only. + * There are only 4 test cases, which want to see "EXT ERROR:..." + * ACI1220, ACICC044, ACICC074 and ACICC107. Let these 4 FAIL + * and all other let PASS by sending a plain "ERROR" + */ +#ifdef _SIMULATION_ + TRACE_EVENT("Resp_uPlusExtError(): overwrite EXT ERROR with plain ERROR to make TAP happy"); + io_sendConfirm (src_infos_psi->srcId, cmdAtError(atError), ATI_NORMAL_OUTPUT); +#else + io_sendConfirm(src_infos_psi->srcId, + cmdExtError(resp_p->response.ptr_res_plus_ext_error->err), + ATI_ERROR_OUTPUT); +#endif + return 0; /* Ok */ +} + +int Resp_uPlusFHS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPlusFHS() "); + + rCI_PlusFHS(resp_p->response.ptr_res_plus_fhs->status); + + return 0; /* Ok */ +} + +int Resp_uPlusILRR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + LONG val; + TRACE_FUNCTION ("Resp_uPlusILRR()"); + + if ( ati_user_output_cfg[src_infos_psi->srcId].ILRR_stat ) + { + switch(resp_p->response.ptr_res_plus_ilrr->rate) + { + case(BAT_ILRR_RATE_300): val= 300; break; + case(BAT_ILRR_RATE_1200): val= 1200; break; + case(BAT_ILRR_RATE_2400): val= 2400; break; + case(BAT_ILRR_RATE_4800): val= 4800; break; + case(BAT_ILRR_RATE_9600): val= 9600; break; + case(BAT_ILRR_RATE_14400): val=14400; break; + case(BAT_ILRR_RATE_19200): val=19200; break; + case(BAT_ILRR_RATE_38400): val=38400; break; + default: val= 1; break; + } + sprintf(g_sa,"+ILRR: %d,%d,%d",val,resp_p->response.ptr_res_plus_ilrr->framing_format + ,resp_p->response.ptr_res_plus_ilrr->framing_parity); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + } + + return 0; /* Ok */ +} + +int Resp_uPercentRDL(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentRDL()"); + + rCI_PercentRDL (resp_p->response.ptr_res_percent_rdl->state ); + return 0; /* Ok */ +} + +int Resp_uPercentRDLB(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentRDLB()"); + + rCI_PercentRDLB(resp_p->response.ptr_res_percent_rdlb->state); + return 0; /* Ok */ +} + +#ifdef SIM_TOOLKIT + +int Resp_uPercentSATA(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentSATA()"); + +#ifdef FF_SAT_E + rCI_PercentSATA(0, /* cId not used */ + resp_p->response.ptr_res_percent_sata->redial_timeout, &Addparm); +#else /* FF_SAT_E */ + rCI_PercentSATA(0, /* cId not used */ + resp_p->response.ptr_res_percent_sata->redial_timeout); +#endif /* FF_SAT_E */ + return 0; /* Ok */ +} + +int Resp_sPercentSATE(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPercentSATE()"); + + rCI_PercentSATE((SHORT)resp_p->response.ptr_set_percent_sate->c_satrsp, + resp_p->response.ptr_set_percent_sate->satrsp); + return 0; /* Ok */ +} + +int Resp_uPercentSATI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentSATI()"); + + rCI_PercentSATI((SHORT)resp_p->response.ptr_res_percent_sati->c_satcmd, + resp_p->response.ptr_res_percent_sati->satcmd); + return 0; /* Ok */ +} + +int Resp_uPercentSATN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentSATN()"); + + /* use SATN_CNTRL_BY_SIM_SS as this is required by the acisat test */ + rCI_PercentSATN((SHORT)resp_p->response.ptr_res_percent_satn->c_satcmd, + (UBYTE*)resp_p->response.ptr_res_percent_satn->satcmd, + SATN_CNTRL_BY_SIM_SS); + + return 0; /* Ok */ +} + +int Resp_uPercentSIMEF(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + UBYTE n; + T_BAT_res_uns_percent_simef *simef; + SHORT ef[BAT_MAX_SIMEF_EF_LEN]; + + /* + * Get a pointer to the SIMEF structure for convenience. + */ + simef=resp_p->response.ptr_res_percent_simef; + + for (n=0;((n<simef->c_ef) AND (n<BAT_MAX_SIMEF_EF_LEN));n++) + { + ef[n]=(SHORT)simef->ef[n]; + } + + rCI_PercentSIMEF(ef,(UBYTE)simef->c_ef); + + return(0); +} + +#endif /* SIM_TOOLKIT */ + +int Resp_uPercentSIMINS(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + T_ACI_CME_ERR err ; + + TRACE_FUNCTION ("Resp_uPercentSIMINS()"); + + switch (resp_p->response.ptr_res_percent_simins->n) + { + case BAT_P_SIMINS_N_NO_PIN: + err =CME_ERR_NotPresent; + break; + + case BAT_P_SIMINS_N_SIM_PIN: + err =CME_ERR_SimPinReq; + break; + + case BAT_P_SIMINS_N_SIM_PUK: + err=CME_ERR_SimPinReq; + break; + + case BAT_P_SIMINS_N_SIM_FAIL: + err=CME_ERR_SimFail; + break; + + case BAT_P_SIMINS_N_SIM_BUSY: + err=CME_ERR_SimBusy; + break; + + case BAT_P_SIMINS_N_SIM_WRONG: + err=CME_ERR_SimWrong; + break; + + default: + err=CME_ERR_Unknown; + break; + } + + rCI_PercentSIMINS ( err ) ; + + return 0; /* Ok */ +} + +int Resp_uPercentSIMREM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_uPercentSIMREM)()"); + /* + * This relies on T_ACI_SIMREM_TYPE being identical to + * T_BAT_percent_simrem_m. + */ + rCI_PercentSIMREM( + (T_ACI_SIMREM_TYPE)resp_p->response.ptr_res_percent_simrem->m); + return 0; /* Ok */ +} + +int Resp_sPlusCGMI(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCGMI()"); + sprintf(g_sa,"%s",resp_p->response.ptr_set_plus_cgmi->manufacturer); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_sPlusCGMM(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCGMM()"); + sprintf(g_sa,"%s",resp_p->response.ptr_set_plus_cgmm->model); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_sPlusCGMR(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCGMR()"); + sprintf(g_sa,"%s",resp_p->response.ptr_set_plus_cgmr->revision); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + +int Resp_sPlusCGSN(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ + TRACE_FUNCTION ("Resp_sPlusCGSN()"); + sprintf(g_sa,"%s",resp_p->response.ptr_set_plus_cgsn->sn); + io_sendMessage(src_infos_psi->srcId, g_sa, ATI_NORMAL_OUTPUT); + return 0; /* Ok */ +} + + +int Resp_uPercentSNCNT(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ +} + +int Resp_uAtBusy(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ +} + +int Resp_uAtNoAnswer(T_ACI_DTI_PRC_PSI *src_infos_psi, T_BAT_cmd_response *resp_p) +{ +} + + + + +