line source
/*
+-----------------------------------------------------------------------------
| Project : GSM-F&D (8411)
| Modul : ATI
+-----------------------------------------------------------------------------
| Copyright 2002 Texas Instruments Berlin, AG
| All rights reserved.
|
| This file is confidential and a trade secret of Texas
| Instruments Berlin, AG
| The receipt of or possession of this file does not convey
| any rights to reproduce or disclose its contents or to
| manufacture, use, or sell anything it may describe, in
| whole, or in part, without the specific written consent of
| Texas Instruments Berlin, AG.
+-----------------------------------------------------------------------------
| Purpose : AT Command Interpreter Call-Back Functions
+-----------------------------------------------------------------------------
*/
#ifndef ATI_RET_C
#define ATI_RET_C
#include "aci_all.h" /* defines FF_TIMEZONE */
#include "line_edit.h"
#include "aci_cmh.h" /* uses FF_TIMEZONE */
#include "ati_cmd.h"
#include "aci_cmd.h"
#include "aci_io.h"
#include "p_aci.h"
#include "aci.h"
#include "l4_tim.h"
#include "ksd.h"
#include "psa.h"
#include "psa_sms.h"
#include "psa_sim.h"
#include "cmh.h"
#include "cmh_sms.h"
#include "psa_cc.h"
#include "psa_ss.h"
#include "cmh_ss.h"
#include "cmh_cc.h"
#include "cmh_mm.h"
#include "psa_util.h"
#include "cmh_mm.h"
#ifdef DTI
#include "dti.h" /* functionality of the dti library */
#endif
#include "dti_conn_mng.h"
#ifdef GPRS
#include "gaci.h"
#include "gaci_cmh.h"
#include "psa_sm.h"
#include "cmh_sm.h"
#endif /* GPRS */
#include "aci_mem.h"
#include "aci_lst.h"
#ifdef UART
#include "psa_uart.h"
#include "cmh_uart.h"
#endif
#include "conc_sms.h"
#ifdef FF_PSI
#include "psa_psi.h"
#include "cmh_psi.h"
#endif /*FF_PSI*/
#ifdef GPRS
#include "gaci_cmd.h"
#endif
#include "aci_cmd.h"
#if defined FF_EOTD
#include "cmh_lc.h"
#endif
#include "ati_int.h"
#ifdef ACI
#include "cmh_mmi.h"
#endif /* ACI */
#ifdef FF_ATI
GLOBAL T_CIEV_SIGNAL_BUFFER asCievSignalBuf;
GLOBAL T_CIEV_SMSFULL_BUFFER asCievSmsFullBuf;
EXTERN CHAR *CPIN_RESULT(T_ACI_CPIN_RSLT code);
EXTERN UBYTE src_id_ext; /* this source runs currently an extension command */
EXTERN T_ATI_IO_MODE ati_get_mode (UBYTE srcId );
EXTERN T_ATI_RSLT ati_execute_cmd_line (T_ATI_SRC_PARAMS *src_params);
/*
* needed for rCI_Z
*/
EXTERN void ati_cmd_reset (UBYTE srcId);
EXTERN void ati_zn_retrieve_params ( UBYTE srcId );
LOCAL UBYTE aci_writeCnumMsisdn (UBYTE srcId, T_ACI_CNUM_MSISDN* msisdn );
LOCAL void aci_frmtOutput ( UBYTE fo,
UBYTE dcs,
T_ACI_SM_DATA *data );
LOCAL void r_Plus_Percent_COPS( T_ACI_AT_CMD cmd,
SHORT lastIdx,
T_ACI_COPS_OPDESC * operLst);
/*
typedef struct
{
char *name;
T_ACI_CPWD_FAC fac;
} net_fac; */
LOCAL BOOL allowCCCM = TRUE;
LOCAL UBYTE callTime = 0;
LOCAL const SMS_Memory sms_mem [] =
{
{"ME", SMS_STOR_Me},
{"me", SMS_STOR_Me},
{"SM", SMS_STOR_Sm},
{"sm", SMS_STOR_Sm},
{0,0}
};
#if defined (SMS_PDU_SUPPORT)
LOCAL void rCI_PlusCMTText ( T_MNSMS_MESSAGE_IND * mnsms_message_ind);
LOCAL void rCI_PlusCDSText ( T_MNSMS_STATUS_IND * mnsms_status_ind );
LOCAL void rCI_PlusCBMText ( T_MMI_CBCH_IND * mmi_cbch_ind );
LOCAL void rCI_PlusCMGSText( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf);
LOCAL void rCI_PlusCMSSText( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf);
LOCAL void rCI_PlusCMGCText( T_MNSMS_COMMAND_CNF * mnsms_command_cnf);
#endif
LOCAL void rCI_Plus_Percent_CMGLText ( T_MNSMS_READ_CNF *mnsms_read_cnf,
T_ACI_AT_CMD cmd);
LOCAL void rCI_Plus_Percent_CMGRText ( T_MNSMS_READ_CNF * mnsms_read_cnf,
T_ACI_CMGR_CBM * cbm,
T_ACI_AT_CMD cmd);
LOCAL void rCI_Plus_Percent_CMGLTextSP ( T_MNSMS_READ_CNF* mnsms_read_cnf,
T_ACI_AT_CMD cmdId);
LOCAL void rCI_Plus_Percent_CMGRTextSP ( T_MNSMS_READ_CNF* mnsms_read_cnf,
T_ACI_AT_CMD cmdId);
GLOBAL CHAR *sms_status (T_ACI_SMS_STAT stat) /* used in text mode by CMGL and CMGR */
{
switch(stat)
{
case(SMS_STAT_Invalid): return "INVALID MESSAGE";
case(SMS_STAT_RecUnread): return "REC UNREAD";
case(SMS_STAT_RecRead): return "REC READ";
case(SMS_STAT_StoUnsent): return "STO UNSENT";
case(SMS_STAT_StoSent): return "STO SENT";
case(SMS_STAT_All): return "ALL";
default: return 0;
}
}
GLOBAL char *ring_stat(T_ACI_CRING_TYP type)
{
switch(type)
{
case(CRING_TYP_NotPresent): return "Not Present";
case(CRING_TYP_Async): return "ASYNC";
case(CRING_TYP_Sync): return "SYNC";
case(CRING_TYP_RelAsync): return "REL ASYNC";
case(CRING_TYP_RelSync): return "REL SYNC";
case(CRING_TYP_Fax): return "FAX";
case(CRING_TYP_Voice): return "VOICE";
case(CRING_TYP_AuxVoice): return "AUX VOICE";
default: return "Error";
}
}
#define RING_STAT_LTH 15
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_OK |
+--------------------------------------------------------------------+
PURPOSE : handles AT_OK call back
*/
GLOBAL void rCI_OK ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId )
{
UBYTE srcId = srcId_cb;
T_ATI_RSLT rv_ati = ATI_FAIL;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_OK()");
src_params->curAtCmd = AT_CMD_NONE;
switch (cmdId)
{
case (AT_CMD_D):
TRACE_EVENT("AT command line successfully processed") ;
/*lint -fallthrough*/
case (AT_CMD_NONE):
case (AT_CMD_EXT):
#if FF_FAX
case (AT_CMD_FDR):
case (AT_CMD_FDT):
case (AT_CMD_FKS):
#endif
/*
* tell line edit that the cmd line is finished/aborted
* and to be able to receive a new one
*/
ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
io_sendConfirm (srcId, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
curAbrtCmd = AT_CMD_NONE;
cmdErrStr = NULL;
break;
default:
/*
* there are possibly further AT cmds after re-entering the ACI context
*/
/* this is only a bypass for ATI sources which uses the functional interface */
if (src_params->cmd_state EQ CMD_IDLE)
{
io_sendConfirm (src_params->src_id, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
}
else
{
/*
* there are possibly further AT cmds after re-entering the ACI context
*/
rv_ati = ati_execute_cmd_line (src_params);
}
break;
}
#ifdef ACI /* for ATI only version */
cmhMMI_handleAudioTone ( cmdId, RAT_OK, CPI_MSG_NotPresent );
#endif
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_NO_CARRIER |
+--------------------------------------------------------------------+
PURPOSE : handles AT_NO_CARRIER call back
*/
GLOBAL void rCI_NO_CARRIER ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, SHORT cId )
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_NO_CARRIER()");
if ( src_params->curAtCmd EQ AT_CMD_D
OR src_params->curAtCmd EQ AT_CMD_A
OR src_params->curAtCmd EQ AT_CMD_H
OR src_params->curAtCmd EQ AT_CMD_CGDATA
OR src_params->curAtCmd EQ AT_CMD_CGANS
#ifdef FF_FAX
OR src_params->curAtCmd EQ AT_CMD_FDR
OR src_params->curAtCmd EQ AT_CMD_FDT
#endif
)
{
ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
src_params->curAtCmd = AT_CMD_NONE;
io_sendConfirm(srcId, cmdAtError(atNoCarrier), ATI_ERROR_OUTPUT | ATI_RESULT_CODE_OUTPUT);
}
else
{
/*
* According to the v25ter NO CARRIER is stated as a final result code.
*
* This implementation differ in this case from the standard.
* There are two differnt reasons:
* - Data transfer on a different source than the transfer was started
* - NO CARRIER if the other peer of a CS call hangs up
*
* For the first reason the CONNECT will be the final result code (standard: intermediate)
* For the second reason the ATD resuts an OK.
*/
io_sendIndication(srcId, cmdAtError(atNoCarrier), ATI_FORCED_OUTPUT | ATI_RESULT_CODE_OUTPUT);
}
cmdErrStr = NULL;
#ifdef ACI /* for ATI only version */
cmhMMI_handleAudioTone ( cmdId, RAT_NO_CARRIER, CPI_MSG_NotPresent );
#endif
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_BUSY |
+--------------------------------------------------------------------+
PURPOSE : handles AT_BUSY call back
*/
GLOBAL void rCI_BUSY ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, SHORT cId )
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_BUSY()");
src_params->curAtCmd = AT_CMD_NONE;
ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
io_sendConfirm(srcId, cmdAtError(atBusy), ATI_ERROR_OUTPUT);
#ifdef ACI /* for ATI only version */
cmhMMI_handleAudioTone ( cmdId, RAT_BUSY, CPI_MSG_NotPresent );
#endif
cmdErrStr = NULL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_NO_ANSWER |
+--------------------------------------------------------------------+
PURPOSE : handles AT_NO_ANSWER call back
*/
GLOBAL void rCI_NO_ANSWER ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, SHORT cId )
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_NO_ANSWER()");
src_params->curAtCmd = AT_CMD_NONE;
ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
io_sendConfirm(srcId, cmdAtError(atNoAnswer), ATI_ERROR_OUTPUT);
cmdErrStr = NULL;
#ifdef ACI /* for ATI only version */
cmhMMI_handleAudioTone ( cmdId, RAT_NO_ANSWER, CPI_MSG_NotPresent );
#endif
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CONNECT |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CONNECT call back.
flow_cntr = TRUE flow control active.
flow_cntr = FALSE " " inactive.
*/
GLOBAL void rCI_CONNECT ( /*UBYTE srcId,*/
T_ACI_AT_CMD cmdId,
T_ACI_BS_SPEED speed,
SHORT cId,
BOOL flow_cntr )
{
LONG val;
LONG val_nv=-1;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
CHAR *cmd_key = "";
TRACE_FUNCTION("rCI_CONNECT()");
src_params->curAtCmd = AT_CMD_NONE;
switch(speed)
{
case(BS_SPEED_300_V110): val=300; val_nv = 10; break;
case(BS_SPEED_1200_V110): val=1200; val_nv = 11; break;
case(BS_SPEED_2400_V110): val=2400; val_nv = 13; break;
case(BS_SPEED_4800_V110): val=4800; val_nv = 14; break;
case(BS_SPEED_9600_V110): val=9600; val_nv = 15; break;
case(BS_SPEED_14400_V110): val=14400; val_nv = 16; break;
case(BS_SPEED_19200_V110): val=19200; break;
case(BS_SPEED_38400_V110): val=38400; break;
default: val=-1;
}
if (src_params EQ NULL)
{
TRACE_EVENT_P1 ("[ERR] rCI_CONNECT(): srcId=%d not found", srcId);
return;
}
#ifdef UART
if (src_params->src_type EQ ATI_SRC_TYPE_UART)
{
T_ACI_DTI_PRC *uart_infos;
uart_infos = find_element (uart_src_params,
(UBYTE)srcId,
cmhUARTtest_srcId);
if( flow_cntr )
{
/* this is in case of fax sending */
BITFIELD_SET (uart_infos->data_cntr, UART_DTI_FLOW_OFF);
}
else
{
BITFIELD_CLEAR (uart_infos->data_cntr, UART_DTI_FLOW_OFF);
}
}
#endif
#ifdef FF_PSI
if (src_params->src_type EQ ATI_SRC_TYPE_PSI)
{
T_ACI_DTI_PRC_PSI *psi_infos;
psi_infos = find_element (psi_src_params,
(UBYTE)srcId,
cmhPSItest_srcId);
if( flow_cntr )
{
/* this is in case of fax sending */
BITFIELD_SET (psi_infos->data_cntr, PSI_DTI_FLOW_OFF);
}
else
{
BITFIELD_CLEAR (psi_infos->data_cntr, PSI_DTI_FLOW_OFF);
}
}
#endif /*FF_PSI*/
if(val > 0 AND ati_user_output_cfg[srcId].atX > 0)
{
if(at.s1415.atV NEQ 0) /*Verbose case*/
{
sprintf(g_sa,"CONNECT %d",val);
io_sendConfirm(srcId, g_sa, (ATI_NORMAL_OUTPUT | ATI_CONNECT_OUTPUT));
}
else if(val_nv > 0) /*Nonverbose case*/
{
sprintf(g_sa,"%d",val_nv);
io_sendConfirm(srcId, g_sa, (ATI_NORMAL_OUTPUT | ATI_CONNECT_OUTPUT) );
}
else
io_sendConfirm(srcId, cmdAtError(atConnect), (ATI_NORMAL_OUTPUT | ATI_CONNECT_OUTPUT));
}
else
{
io_sendConfirm(srcId, cmdAtError(atConnect), (ATI_NORMAL_OUTPUT | ATI_CONNECT_OUTPUT));
}
/*
* tell line edit that the cmd line is finished/aborted
* and to be able to receive a new one
*/
ati_get_cmds_key(cmdId, &cmd_key, NULL);
TRACE_EVENT_P1("%s completed", cmd_key);
ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
cmdErrStr = NULL;
#ifdef ACI /* for ATI only version */
cmhMMI_handleAudioTone ( cmdId, RAT_CONNECT, CPI_MSG_NotPresent );
#endif
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCME |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCME call back
*/
GLOBAL void rCI_PlusCME ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, T_ACI_CME_ERR err )
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PLusCME()");
/*
* tell line edit that the cmd line is finished/aborted
* and to be able to receive a new one
*/
ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
/*
* if (asynchroniously) extension command, reset the global src_id_ext
*/
if (src_id_ext EQ src_params->src_id)
{
src_id_ext = 0xFF;
}
if ( curAbrtCmd EQ AT_CMD_NONE )
{
src_params->curAtCmd = AT_CMD_NONE;
io_sendConfirm(srcId, cmdCmeError(err), ATI_ERROR_OUTPUT);
cmdErrStr = NULL;
#ifdef ACI /* for ATI only version */
cmhMMI_handleAudioTone ( cmdId, RAT_CME, CPI_MSG_NotPresent );
#endif
}
else
{
curAbrtCmd = AT_CMD_NONE;
io_sendMessage ( srcId, cmdCmeError ( CME_ERR_FailedToAbort ),
ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCPIN |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCPIN call back
*/
GLOBAL void rCI_PlusCPIN (/*UBYTE srcId,*/ T_ACI_CPIN_RSLT rslt )
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PLusCPIN()");
src_params->curAtCmd = AT_CMD_NONE;
sprintf(g_sa,"%s%s","+CPIN: ",CPIN_RESULT(rslt));
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
typedef enum
{
STAT_NotPresent = -1,
STAT_Other, /* other than registered and Roaming */
STAT_Reg,
STAT_Roam
} T_ACI_NTW_STATUS;
LOCAL T_ACI_NTW_STATUS get_raw_stat_among_CREG( T_ACI_CREG_STAT status )
{
switch(status)
{
case(CREG_STAT_NotPresent):
return(STAT_NotPresent);
case(CREG_STAT_Reg):
return(STAT_Reg);
case(CREG_STAT_Roam):
return(STAT_Roam);
default:
return(STAT_Other);
}
}
#ifdef GPRS
LOCAL T_ACI_NTW_STATUS get_raw_stat_among_CGREG( T_CGREG_STAT status )
{
switch(status)
{
case(CGREG_STAT_REG_HOME):
return(STAT_Reg);
case(CGREG_STAT_REG_ROAM):
return(STAT_Roam);
default:
return(STAT_Other);
}
}
LOCAL T_ACI_NTW_STATUS get_raw_stat_among_P_CGREG( T_P_CGREG_STAT status )
{
switch(status)
{
case(P_CGREG_STAT_REG_HOME):
return(STAT_Reg);
case(P_CGREG_STAT_REG_ROAM):
return(STAT_Roam);
default:
return(STAT_Other);
}
}
#endif /* GPRS */
/* function fills up registration status parameters according to type of
user notification (+CREG/+CGREG/%CGREG)
returns whether network status has changed or not: BOOL */
LOCAL BOOL get_registration_data_among_cmd( UBYTE srcId,
int status,
T_ATI_REG_MOD_LAC_CID *mod_lac_cid,
T_ACI_NTW_STATUS *raw_status,
CHAR *cmd_string,
T_ACI_CREG_CMD cmd)
{
USHORT previous_status,
current_status;
current_status = previous_status = status;
switch(cmd)
{
case(CREG_CMD):
*mod_lac_cid = ati_user_output_cfg[srcId].creg.mod_lac_cid;
previous_status = ati_user_output_cfg[srcId].creg.last_presented_state;
*raw_status = get_raw_stat_among_CREG((T_ACI_CREG_STAT) current_status);
strcpy(cmd_string, "+CREG: ");
break;
case(PercentCREG_CMD):
*mod_lac_cid = ati_user_output_cfg[srcId].percent_creg.mod_lac_cid;
previous_status = ati_user_output_cfg[srcId].percent_creg.last_presented_state;
*raw_status = get_raw_stat_among_CREG((T_ACI_CREG_STAT) current_status);
strcpy(cmd_string, "%CREG: ");
break;
#if defined (GPRS) AND defined (DTI)
case(PlusCGREG_CMD):
*mod_lac_cid = ati_gprs_user_output_cfg[srcId].plus_cgreg.mod_lac_cid;
previous_status = ati_gprs_user_output_cfg[srcId].plus_cgreg.last_presented_state;
*raw_status = get_raw_stat_among_CGREG((T_CGREG_STAT) current_status);
strcpy(cmd_string, "+CGREG: ");
break;
case(PercentCGREG_CMD):
*mod_lac_cid = ati_gprs_user_output_cfg[srcId].percent_cgreg.mod_lac_cid;
previous_status = ati_gprs_user_output_cfg[srcId].percent_cgreg.last_presented_state;
*raw_status = get_raw_stat_among_P_CGREG((T_P_CGREG_STAT) current_status);
strcpy(cmd_string, "%CGREG: ");
break;
#endif
}
if( current_status NEQ previous_status)
{
return TRUE;
}
return FALSE;
}
LOCAL void update_last_presented_datas_among_cmd( UBYTE srcId,
int status,
USHORT lac,
USHORT cid,
T_ACI_CREG_CMD cmd)
{
T_ATI_REG_MOD_LAC_CID *mod_lac_cid;
switch(cmd)
{
case(CREG_CMD):
ati_user_output_cfg[srcId].creg.last_presented_state = (T_ACI_CREG_STAT)status;
mod_lac_cid = &ati_user_output_cfg[srcId].creg.mod_lac_cid;
break;
case(PercentCREG_CMD):
ati_user_output_cfg[srcId].percent_creg.last_presented_state = (T_ACI_CREG_STAT)status;
mod_lac_cid = &ati_user_output_cfg[srcId].percent_creg.mod_lac_cid;
break;
#if defined (GPRS) AND defined (DTI)
case(PlusCGREG_CMD):
ati_gprs_user_output_cfg[srcId].plus_cgreg.last_presented_state = (T_CGREG_STAT)status;
mod_lac_cid = &ati_gprs_user_output_cfg[srcId].plus_cgreg.mod_lac_cid;
break;
case(PercentCGREG_CMD):
ati_gprs_user_output_cfg[srcId].percent_cgreg.last_presented_state = (T_P_CGREG_STAT)status;
mod_lac_cid = &ati_gprs_user_output_cfg[srcId].percent_cgreg.mod_lac_cid;
break;
#endif /* GPRS */
default:
return;
}
if( lac NEQ NOT_PRESENT_16BIT )
{
mod_lac_cid->last_presented_lac = lac;
}
if( cid NEQ NOT_PRESENT_16BIT )
{
mod_lac_cid->last_presented_cid = cid;
}
}
/* function sends notification to user about network registration status.
Functionnality centralised for either +CREG/+CGREG/%CGREG... */
GLOBAL void r_plus_percent_CREG ( UBYTE srcId,
int status,
USHORT lac,
USHORT cid,
T_ACI_CREG_CMD cmd,
T_ACI_P_CREG_GPRS_IND gprs_ind,
BOOL bActiveContext )
{
T_ATI_CREG_MOD mode;
T_ATI_REG_MOD_LAC_CID mod_lac_cid;
USHORT previous_lac,
previous_cid;
BOOL network_status_has_changed = FALSE;
BOOL cell_has_changed = FALSE;
CHAR loc_info[LOC_INFO_STRLTH] = ""; /* enough to get e.g. ",A1F4, F4D0" */
CHAR gprs_info[GPRS_INFO_STRLTH] = ""; /* enough to get e.g. ", 2" */
CHAR *ctxtInfo = "";
T_ACI_NTW_STATUS raw_status;
CHAR cmd_key[KEY];
USHORT presented_lac = NOT_PRESENT_16BIT,
presented_cid = NOT_PRESENT_16BIT;
/* check whether cell has changed */
network_status_has_changed = get_registration_data_among_cmd( srcId,
status,
&mod_lac_cid,
&raw_status,
cmd_key,
cmd );
if( network_status_has_changed )
{
TRACE_EVENT_P3("cmd: %d, source: %d, new network status: %d !", cmd, srcId, status);
}
mode = mod_lac_cid.pres_mode;
previous_lac = mod_lac_cid.last_presented_lac;
previous_cid = mod_lac_cid.last_presented_cid;
/* check whether cell has changed */
if( ((lac NEQ NOT_PRESENT_16BIT) AND (lac NEQ previous_lac))
OR
((cid NEQ NOT_PRESENT_16BIT) AND (cid NEQ previous_cid)) )
{
if(raw_status EQ STAT_Reg OR raw_status EQ STAT_Roam)
{
/* cell info is only relevant when registered or in roaming */
TRACE_EVENT_P2("cell has changed !, lac: %04X, cId: %04X", lac, cid);
cell_has_changed = TRUE;
}
}
/* comma always needed */
if (cmd EQ PercentCREG_CMD OR
mode EQ CREG_MOD_LOC_INF_ON_CTXACT)
{
strcat(loc_info,",,");
}
/* check if presentation should occur */
switch( mode )
{
case(CREG_MOD_NotPresent):
case(CREG_MOD_OFF):
/* no presentation to user */
return;
case(CREG_MOD_ON):
if( !network_status_has_changed )
{
return;
}
/* network status is available and has changed */
break;
case(CREG_MOD_LOC_INF_ON_CTXACT):
case(CREG_MOD_LOC_INF_ON):
if( (raw_status EQ STAT_Reg OR
raw_status EQ STAT_Roam) AND
cell_has_changed )
{
presented_lac = lac;
presented_cid = cid;
}
else if( (raw_status EQ STAT_Reg OR
raw_status EQ STAT_Roam) AND
network_status_has_changed )
{
/* show last presented lac/cid */
presented_lac = mod_lac_cid.last_presented_lac;
presented_cid = mod_lac_cid.last_presented_cid;
}
else if( network_status_has_changed )
{
/* mobile is not registered: do not show location information
parameters have already been initialized, so no need to set them */
}
else
{
TRACE_EVENT_P3("%s presentation denied. mode: %d, network status: %d", cmd_key, mode, status);
return;
}
if( presented_lac NEQ NOT_PRESENT_16BIT AND
presented_cid NEQ NOT_PRESENT_16BIT )
{
sprintf(loc_info, ",\"%04X\",\"%04X\"", presented_lac, presented_cid);
}
else if (mode EQ CREG_MOD_LOC_INF_ON_CTXACT)
sprintf(loc_info, ",,");
break;
}
/* ACI-SPR-17218: attach gprs information for %CREG */
if ( cmd EQ PercentCREG_CMD )
{
sprintf(gprs_info, ",%01X", gprs_ind );
}
#ifdef GPRS
if ( (cmd EQ PercentCGREG_CMD) AND
(mode EQ CREG_MOD_LOC_INF_ON_CTXACT) )
{
if( bActiveContext EQ TRUE )
ctxtInfo = ",1";
else
ctxtInfo = ",0";
}
#endif /* GPRS */
sprintf(g_sa,"%s%d%s%s%s", cmd_key, status, loc_info, gprs_info, ctxtInfo );
io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
update_last_presented_datas_among_cmd( srcId,
status,
presented_lac,
presented_cid,
cmd );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCREG |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCREG call backs(change in network registration status)
*/
GLOBAL void rCI_PlusCREG ( T_ACI_CREG_STAT status,
USHORT lac,
USHORT cid )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCREG()");
r_plus_percent_CREG ( srcId,
status,
lac,
cid,
CREG_CMD,
P_CREG_GPRS_Support_Unknown, /*ACI-SPR-17218: ignored*/
FALSE );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCREG |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCREG call backs(change in network registration status)
*/
GLOBAL void rCI_PercentCREG ( T_ACI_CREG_STAT status,
USHORT lac,
USHORT cid,
T_ACI_P_CREG_GPRS_IND gprs_ind)
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentCREG()");
r_plus_percent_CREG ( srcId,
status,
lac,
cid,
PercentCREG_CMD, /*ACI-SPR-17218: introduced for %CREG*/
gprs_ind,
FALSE );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCRING |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCRING call back
*/
/* should be called when ringing indications should stop */
GLOBAL void ati_stop_ring(void)
{
TRACE_FUNCTION("ati_stop_ring()");
at.rngPrms.rngCnt = 1;
at.rngPrms.isRng = FALSE;
at.S[1] = 0; /* S1 register will hold the ring counts */
/* Reset the CLIP parameters to default values */
at.clipPrms.stat = CLIP_STAT_NotPresent;
memset( at.clipPrms.number, 0, sizeof(at.clipPrms.number));
memset(&at.clipPrms.type, 0, sizeof(T_ACI_TOA));
at.clipPrms.validity = PRES_NOT_PRES;
memset( at.clipPrms.subaddr, 0, sizeof(at.clipPrms.subaddr));
memset(&at.clipPrms.satype, 0, sizeof(T_ACI_TOS));
#ifdef NO_ASCIIZ
memset(&at.clipPrms.alpha, 0, sizeof(T_ACI_PB_TEXT));
#else
memset(at.clipPrms.alpha, 0, sizeof(at.clipPrms.alpha));
#endif
TIMERSTOP( ACI_TRING );
}
GLOBAL void rCI_PlusCRING ( /*UBYTE srcId,*/
T_ACI_CRING_MOD mode,
T_ACI_CRING_TYP type1,
T_ACI_CRING_TYP type2 )
{
static T_ACI_CMD_SRC first_ringing_srcId = CMD_SRC_NONE; /* Source which will handle the ringing-timer */
UBYTE srcId = srcId_cb,
autoAnswerSrcId = at.rngPrms.srcID_S0;
T_ACI_AT_CMD autoanswer_command;
T_ACI_RETURN ret;
int DTR=0;
UBYTE DTR_behaviour = DTR_BEHAVIOUR_Ignore;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCRING()");
if (first_ringing_srcId EQ CMD_SRC_NONE)
first_ringing_srcId = srcId; /* catch the first source id for setting up the ring timer */
/* save ringing parameter at the first call to rCI_PlusCRING */
if( !at.rngPrms.isRng AND
at.rngPrms.rngCnt EQ 1 AND /* this is only done on the first ring, not on any subsequent*/
srcId EQ first_ringing_srcId) /* only first source will reach the setting of "at.rngPrms.isRng = TRUE" */
{
at.rngPrms.mode = mode;
at.rngPrms.type1 = type1;
at.rngPrms.type2 = type2;
at.rngPrms.isRng = TRUE;
}
if (!at.rngPrms.isRng)
{
return; /* dont emmit any "RING" but escape here if ringing has been stopped
in a multi-source configuration on any source in rhe RAT_CRING loop */
}
at.S[1] = at.rngPrms.rngCnt; /* S1 register will return the ring counts */
/* check for automatic reject of an network initiated context activation */
#if defined (GPRS) AND defined (DTI)
if( at.rngPrms.mode EQ CRING_MOD_Gprs AND
first_ringing_srcId EQ srcId AND /* it is sufficent to check this only for one ringing source */
cmhSM_call_reject(at.rngPrms.rngCnt, mode) )
{
TRACE_EVENT_P2("PDP context is to be automatically rejected: RING count: %d, srcId %d", at.rngPrms.rngCnt, srcId_cb);
ati_stop_ring();
ret=sAT_PlusCGANS(srcId, 0, NULL, GPRS_CID_OMITTED);
if( ret EQ AT_CMPL )
return;
TRACE_EVENT_P1("auto reject return error: %d", ret);
cmdAtError(atError);
return;
}
#endif
#ifdef UART
if (src_params->src_type EQ ATI_SRC_TYPE_UART)
{
T_ACI_DTI_PRC *uart_infos;
uart_infos = find_element (uart_src_params,
(UBYTE)srcId,
cmhUARTtest_srcId);
if (BITFIELD_CHECK (uart_infos->data_cntr, UART_DTI_SA_BIT))
DTR=1;
}
#endif
#if defined (FF_PSI) AND defined (DTI)
if (src_params->src_type EQ ATI_SRC_TYPE_PSI)
{
T_ACI_DTI_PRC_PSI *psi_infos;
psi_infos = find_element (psi_src_params,
(UBYTE)srcId,
cmhPSItest_srcId);
if (BITFIELD_CHECK (psi_infos->data_cntr, PSI_DTI_SA_BIT))
DTR=1;
}
#endif
qAT_AndD ( srcId, &DTR_behaviour);
if(DTR EQ 0 AND
DTR_behaviour EQ DTR_BEHAVIOUR_ClearCall)
{
/* V.250 6.2.9 Circuit 108 (Data terminal ready) behaviour:
Automatic answer is disabled while circuit 108/2 remains off. */
;
/* Also don't emit any RING while 108/2 remains off */
}
else
{
if (at.rngPrms.rngCnt EQ 1 OR
!check_should_buffer_ind(src_params)) /* Ring indications are not buffered, except of the first one */
{
if(ati_user_output_cfg[srcId].CRC_stat)
{
switch(mode)
{
case CRING_MOD_Direct:
sprintf(g_sa,"+CRING: %s",ring_stat(at.rngPrms.type1));
break;
case CRING_MOD_Alternate:
sprintf(g_sa,"+CRING: %s/%s",ring_stat(at.rngPrms.type1),ring_stat(at.rngPrms.type2));
break;
#if defined (GPRS) AND defined (DTI)
case CRING_MOD_Gprs:
sprintf(g_sa,"+CRING: %s", cmhSM_ring_gprs_par());
break;
#endif /* GPRS && DTI */
}
}
else
{
strcpy(g_sa, cmdAtError(atRing));
cmdErrStr = NULL;
}
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/* check for automatic answer */
#ifdef GPRS
if( at.rngPrms.mode EQ CRING_MOD_Gprs )
{
autoAnswerSrcId = at.rngPrms.srcID_CGAUTO NEQ CMD_SRC_NONE ?
at.rngPrms.srcID_CGAUTO : at.rngPrms.srcID_S0;
}
#endif
if( srcId EQ autoAnswerSrcId AND /* Caution !!! */
at.rngPrms.type1 NEQ CRING_TYP_Fax AND /* Never auto answer FAX calls !!! */
at.rngPrms.type1 NEQ CRING_TYP_AuxVoice AND /* Instead continue ringing! */
#if defined (GPRS) AND defined (DTI)
cmhSM_call_answer(at.rngPrms.rngCnt, at.rngPrms.mode) EQ TRUE
#else /* GPRS */
(at.S[0] AND at.rngPrms.rngCnt >= at.S[0])
#endif /* GPRS */
)
{
TRACE_EVENT_P2("Call is to be automatically answered: RING count: %d, srcId %d", at.rngPrms.rngCnt, srcId_cb);
ati_stop_ring();
#if defined (GPRS) AND defined (DTI)
if ( at.rngPrms.mode EQ CRING_MOD_Gprs )
{
ret = sAT_PlusCGANS(autoAnswerSrcId, 1, "PPP", INVALID_CID);
autoanswer_command = AT_CMD_CGANS;
}
else
#endif
{
ret = sAT_A(autoAnswerSrcId);
autoanswer_command = AT_CMD_A;
}
if( ret EQ AT_EXCT )
{
src_params->curAtCmd = autoanswer_command;
return;
}
TRACE_EVENT_P1("auto answer return error: %d", ret);
cmdAtError(atError);
return;
}
}
if( first_ringing_srcId EQ srcId AND /* only the first source will start the ringing timer */
at.rngPrms.isRng AND /* ringing is still valid? */
at.rngPrms.rngCnt EQ 1 ) /* since Timer is self-retriggering */
{
TRACE_EVENT_P1("start RING timer on Source: %d", srcId);
PTIMERSTART( TRING_VALUE, TRING_VALUE, ACI_TRING );
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCRING_OFF |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCRING off call back
*/
GLOBAL void rCI_PlusCRING_OFF ( /*UBYTE srcId,*/ SHORT cId )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCRING_OFF()");
if( at.rngPrms.isRng )
{
ati_stop_ring();
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentSIMREM |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentSIMREM call back
*/
GLOBAL void rCI_PercentSIMREM ( /*UBYTE srcId,*/ T_ACI_SIMREM_TYPE srType )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentSIMREM()");
if (ati_user_output_cfg[srcId].SIMIND_stat)
{
sprintf (g_sa, "%s%d", "%SIMREM: ", srType);
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentSIMINS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentSIMINS call back
*/
GLOBAL void rCI_PercentSIMINS ( /*UBYTE srcId,*/ T_ACI_CME_ERR err )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentSIMINS()");
if (ati_user_output_cfg[srcId].SIMIND_stat)
{
sprintf (g_sa, "%s%d", "%SIMINS: ", err);
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentKSIR |
+--------------------------------------------------------------------+
PURPOSE : handles PercentKSIR call back.
Code is in aci_util.c to share the code with BAT
*/
GLOBAL void rCI_PercentKSIR ( /*UBYTE srcId,*/ T_ACI_KSIR * ksStat )
{
TRACE_FUNCTION("rCI_PercentKSIR()");
utl_cb_percentKSIR (srcId_cb, ksStat);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCLIR |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCLIR call back
*/
GLOBAL void rCI_PlusCLIR ( /*UBYTE srcId,*/
T_ACI_CLIR_MOD mode,
T_ACI_CLIR_STAT stat)
{
UBYTE srcId = srcId_cb;
sprintf(g_sa,"+CLIR: %d,%d",mode,stat);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : ACI/MMI MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCSQ |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCSQ call back
Shen,Chao
*/
GLOBAL void rCI_PercentCSQ(UBYTE rssi, UBYTE ber, UBYTE actlevel)
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentCSQ()");
sprintf (g_sa, "%s %d, %d, %d", "%CSQ: ",rssi, ber, actlevel);
io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusClip |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCLIP call back
*/
#ifdef NO_ASCIIZ
GLOBAL void rCI_PlusCLIP ( /*UBYTE srcId,*/
T_ACI_CLIP_STAT stat,
CHAR * number,
T_ACI_TOA * type,
U8 validity,
CHAR * subaddr,
T_ACI_TOS * satype,
T_ACI_PB_TEXT * alpha)
#else /* ifdef NO_ASCIIZ */
GLOBAL void rCI_PlusCLIP ( /*UBYTE srcId, */
T_ACI_CLIP_STAT stat,
CHAR* number,
T_ACI_TOA* type,
U8 validity,
CHAR* subaddr,
T_ACI_TOS* satype,
CHAR* alpha)
#endif /* ifdef NO_ASCIIZ */
{
char* me = "+CLIP: ";
SHORT pos = 0;
CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
USHORT lenCvtdAlpha;
UBYTE *uniAlpha = NULL;
UBYTE uniAlphaLen = 0;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PLusCLIP()");
/* save CLIP parameter */
at.clipPrms.stat = stat;
if ( number )
memcpy(at.clipPrms.number, number, strlen(number));
if ( type )
memcpy(&at.clipPrms.type, type, sizeof(T_ACI_TOA));
at.clipPrms.validity = validity;
if ( subaddr )
memcpy(at.clipPrms.subaddr, subaddr, strlen(subaddr));
if ( satype )
memcpy(&at.clipPrms.satype, satype, sizeof(T_ACI_TOS));
#ifdef NO_ASCIIZ
if ( alpha )
memcpy(&at.clipPrms.alpha, alpha, sizeof(T_ACI_PB_TEXT));
#else
if ( alpha )
memcpy(at.clipPrms.alpha, alpha, strlen(alpha));
#endif
#ifdef NO_ASCIIZ
if ( alpha NEQ NULL )
{
uniAlpha = alpha->data;
uniAlphaLen = alpha->len;
}
#else /* ifdef NO_ASCIIZ */
if ( alpha NEQ NULL )
{
uniAlpha = (UBYTE *)alpha;
uniAlphaLen = strlen(alpha);
}
#endif /* ifdef NO_ASCIIZ */
pos = sprintf(g_sa,"%s",me);
if ( stat EQ CLIP_STAT_NotPresent ) /*Function call when connection is made*/
{
if ( ati_user_output_cfg[srcId].CLIP_stat
/* AND
(
io_getIoMode ( ) EQ IO_MODE_CMD OR
io_getIoMode ( ) EQ IO_MODE_RUN
)*/
)
{
if (number)
{
pos += sprintf(g_sa+pos,"\"%s\",",number);
if (type)
pos += sprintf(g_sa+pos,"%d,",toa_merge(*type));
else
pos += sprintf(g_sa+pos,",");
}
else
pos += sprintf(g_sa+pos,"\"\",128,");
if (subaddr)
{
pos += sprintf(g_sa+pos,"\"%s\",",subaddr);
if (satype)
pos += sprintf(g_sa+pos,"%d,",tos_merge(*satype));
else
pos += sprintf(g_sa+pos,",");
}
else if (alpha)
pos += sprintf(g_sa+pos,"\"\",,");
else if (validity NEQ PRES_NOT_PRES)
pos += sprintf(g_sa+pos,",");
if (alpha)
{
utl_chsetFromSim ( uniAlpha,
uniAlphaLen,
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Def );
pos+=sprints(g_sa+pos,cvtdAlpha,lenCvtdAlpha);
}
else if (validity NEQ PRES_NOT_PRES)
pos += sprintf(g_sa+pos,",");
if (validity NEQ PRES_NOT_PRES)
pos += sprintf(g_sa+pos,",%d",validity);
ci_remTrailCom(g_sa, pos);
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
else /* Answer for qA_PlusCLIP*/
{
src_params->curAtCmd = AT_CMD_NONE;
sprintf(g_sa+pos,"%d,%d",ati_user_output_cfg[srcId].CLIP_stat,stat);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCdip |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCDIP call back
*/
GLOBAL void rCI_PlusCDIP (CHAR * number,
T_ACI_TOA * type,
CHAR * subaddr,
T_ACI_TOS * satype)
{
char* me = "+CDIP: ";
SHORT pos = 0;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCDIP()");
pos = sprintf(g_sa,"%s",me);
if ( ati_user_output_cfg[srcId].CDIP_stat)
{
if (number)
{
pos += sprintf(g_sa+pos,"\"%s\",",number);
if (type)
{
pos += sprintf(g_sa+pos,"%d,",toa_merge(*type));
if (subaddr) /* Only check to display subaddr if Number and Type are present */
{
pos += sprintf(g_sa+pos,"\"%s\",",subaddr);
if (satype)
pos += sprintf(g_sa+pos,"%d",tos_merge(*satype));
}
}
else /* No Number Type present */
{
pos += sprintf(g_sa+pos,",");
}
}
else /* No Number present */
{
pos += sprintf(g_sa+pos,"\"\",128,");
}
ci_remTrailCom(g_sa, pos);
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCOLP |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCOLP call back
*/
#ifdef NO_ASCIIZ
GLOBAL void rCI_PlusCOLP ( /*UBYTE srcId,*/
T_ACI_COLP_STAT stat,
CHAR *number,
T_ACI_TOA *type,
CHAR *subaddr,
T_ACI_TOS *satype,
T_ACI_PB_TEXT *alpha)
#else /* ifdef NO_ASCIIZ */
GLOBAL void rCI_PlusCOLP ( /*UBYTE srcId, */
T_ACI_COLP_STAT stat,
CHAR *number,
T_ACI_TOA *type,
CHAR *subaddr,
T_ACI_TOS *satype,
CHAR *alpha)
#endif /* ifdef NO_ASCIIZ */
{
char* me = "+COLP: ";
int pos = 0;
CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
USHORT lenCvtdAlpha;
UBYTE *uniAlpha = NULL;
UBYTE uniAlphaLen = 0;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PLusCOLP()");
#ifdef NO_ASCIIZ
if ( alpha NEQ NULL )
{
uniAlpha = alpha->data;
uniAlphaLen = alpha->len;
}
#else /* ifdef NO_ASCIIZ */
if ( alpha NEQ NULL )
{
uniAlpha = (UBYTE *)alpha;
uniAlphaLen = strlen(alpha);
}
#endif /* ifdef NO_ASCIIZ */
pos = sprintf(g_sa,"%s",me);
if (stat==COLP_STAT_NotPresent) /* Function call if connection is made*/
{
if ( at.flags.COLP_stat
/* AND
(
io_getIoMode ( ) EQ IO_MODE_CMD OR
io_getIoMode ( ) EQ IO_MODE_RUN
) */
)
{
if (number)
{
pos += sprintf(g_sa+pos,"\"%s\",",number);
if (type)
pos += sprintf(g_sa+pos,"%d,",toa_merge(*type));
else
pos += sprintf(g_sa+pos,"128,");
}
else
pos += sprintf(g_sa+pos,"\"\",128,");
if (subaddr)
{
pos += sprintf(g_sa+pos,"\"%s\",",subaddr);
if (satype)
pos += sprintf(g_sa+pos,"%d,",tos_merge(*satype));
else pos += sprintf(g_sa+pos,",");
}
else
pos += sprintf(g_sa+pos,",,");
if (alpha)
{
utl_chsetFromSim ( uniAlpha,
uniAlphaLen,
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Def );
pos+=sprints(g_sa+pos,cvtdAlpha,lenCvtdAlpha);
}
ci_remTrailCom(g_sa,(USHORT)pos);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
else /* Answer for qAT_PlusCOLP*/
{
src_params->curAtCmd = AT_CMD_NONE;
if (at.flags.COLP_stat)
sprintf(g_sa+pos,"1,%d",stat);
else
sprintf(g_sa+pos,"0,%d",stat);
ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCOLR |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCOLR call back
*/
GLOBAL void rCI_PercentCOLR ( /*UBYTE srcId,*/ T_ACI_COLR_STAT stat)
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentCOLR()");
sprintf(g_sa, "%s: %d", "%COLR", stat);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_DR |
+--------------------------------------------------------------------+
PURPOSE : handles AT_DR call back
*/
GLOBAL void rCI_PlusDR ( /*UBYTE srcId,*/ T_ACI_DR_TYP type )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PLusDR()");
if ( ati_user_output_cfg[srcId].DR_stat
/* AND
(
io_getIoMode ( ) EQ IO_MODE_CMD OR
io_getIoMode ( ) EQ IO_MODE_RUN
)*/
)
{
sprintf(g_sa,"+DR: %d",type);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CR |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CR call back
*/
GLOBAL void rCI_PlusCR ( /*UBYTE srcId,*/ T_ACI_CR_SERV service )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PLusCR()");
if ( ati_user_output_cfg[srcId].CR_stat
/* AND
(
io_getIoMode ( ) EQ IO_MODE_CMD OR
io_getIoMode ( ) EQ IO_MODE_RUN
) */
)
{
sprintf(g_sa,"+CR: %s",ring_stat(service));
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCOPS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCOPS call back
*/
GLOBAL void rCI_PlusCOPS(/*UBYTE srcId, */
SHORT lastIdx,
T_ACI_COPS_OPDESC * operLst)
{
TRACE_FUNCTION("rCI_PLusCOPS()");
r_Plus_Percent_COPS(AT_CMD_COPS, lastIdx, operLst);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCOPS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PecentCOPS call back
*/
GLOBAL void rCI_PercentCOPS(/*UBYTE srcId, */
SHORT lastIdx,
T_ACI_COPS_OPDESC * operLst)
{
TRACE_FUNCTION("rCI_PercentCOPS()");
r_Plus_Percent_COPS(AT_CMD_P_COPS, lastIdx, operLst);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_Plus_Percent_COPS |
+--------------------------------------------------------------------+
PURPOSE : common functioality for rCI_PlusCOPS and rCI_PercentCOPS
*/
LOCAL void r_Plus_Percent_COPS ( T_ACI_AT_CMD cmd,
SHORT lastIdx,
T_ACI_COPS_OPDESC * operLst)
{
char *format;
USHORT i;
BOOL END_OF_LIST = FALSE;
T_ACI_RETURN ret;
SHORT startIdx=0;
int pos=0;
UBYTE srcId = srcId_cb;
char longName[MAX_ALPHA_OPER_LEN] = { '\0' };
char shrtName[MAX_ALPHA_OPER_LEN] = { '\0' };
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("r_Plus_Percent_COPS()");
if (lastIdx < 0) /* no operLst available */
{
TRACE_EVENT("No operator list available");
return;
}
if (lastIdx < MAX_OPER)
{
if(cmd EQ AT_CMD_P_COPS)
{
pos=sprintf(g_sa,"%s","%COPS: ");
}
else
{
pos=sprintf(g_sa,"%s","+COPS: ");
}
}
src_params->curAtCmd = AT_CMD_NONE;
for(i=0; i < MAX_OPER; i++)
{
if (operLst[i].status < 0)
{
END_OF_LIST = TRUE;
break;
}
format = ",(%d,\"%s\",\"%s\",\"%s\")";
if (i EQ 0)
format++; /* the first recond begins without a comma */
if (operLst[i].pnn)
{
if (operLst[i].long_len)
{
switch (operLst[i].long_ext_dcs>>4 & 0x07)
{
case 0x00: /* GSM default alphabet */
utl_cvtPnn7To8((UBYTE *)operLst[i].longOper,
operLst[i].long_len,
operLst[i].long_ext_dcs,
(UBYTE *)longName);
break;
case 0x01: /* UCS2 */
TRACE_ERROR ("Unhandled UCS2 in PNN entry");
break;
default:
TRACE_ERROR ("Unknown DCS in PNN entry");
break;
}
}
if (operLst[i].shrt_len)
{
switch (operLst[i].shrt_ext_dcs>>4 & 0x07)
{
case 0x00: /* GSM default alphabet */
utl_cvtPnn7To8((UBYTE *)operLst[i].shortOper,
operLst[i].shrt_len,
operLst[i].shrt_ext_dcs,
(UBYTE *)shrtName);
break;
case 0x01: /* UCS2 */
TRACE_ERROR ("ERROR: Unhandled UCS2");
break;
default:
TRACE_ERROR ("ERROR: Unknown DCS");
break;
}
}
pos+=sprintf(g_sa+pos, format, operLst[i].status, longName, shrtName, operLst[i].numOper);
}
else
{
pos+=sprintf(g_sa+pos, format, operLst[i].status, operLst[i].longOper, operLst[i].shortOper, operLst[i].numOper);
}
/* Beware of overwriting of g_sa */
#ifdef _SIMULATION_ /* Option for line by line output in simulation */
if (pos > 1) /* line-by-line in simulation */
{
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
g_sa[0]='\0';
pos=0;
}
#else
if (pos > sizeof(g_sa)-80) /* a single plmn should not exceed 80 bytes */
{
io_sendMessageEx(srcId, g_sa, ATI_ECHO_OUTPUT);
g_sa[0]='\0';
pos=0;
}
#endif /* _SIMULATION_ */
}
if (i EQ MAX_PLMN_ID)
END_OF_LIST = TRUE;
if (!END_OF_LIST)
{
startIdx=lastIdx+1;
do
{
if(cmd EQ AT_CMD_P_COPS)
{
ret=tAT_PercentCOPS(srcId,startIdx,&lastIdx,&operLst[0]);
}
else
{
ret=tAT_PlusCOPS(srcId,startIdx,&lastIdx,&operLst[0]);
}
if (ret EQ AT_CMPL)
{
END_OF_LIST=FALSE;
for(i=0;i<MAX_OPER;i++)
{
if (operLst[i].status < 0)
{
END_OF_LIST = TRUE;
break;
}
pos+=sprintf(g_sa+pos,",(%d,\"%s\",\"%s\",\"%s\")",
operLst[i].status,operLst[i].longOper,
operLst[i].shortOper,operLst[i].numOper);
/* Beware of overwriting of g_sa */
#ifdef _SIMULATION_
if (pos > 1) /* line-by-line in simulation */
{
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
g_sa[0]='\0';
pos=0;
}
#else
if (pos > sizeof(g_sa)-80) /* a single plmn should not exceed 80 bytes */
{
io_sendMessageEx(srcId, g_sa, ATI_ECHO_OUTPUT);
g_sa[0]='\0';
pos=0;
}
#endif /* _SIMULATION_ */
}
}
if (ret EQ AT_EXCT)
{
src_params->curAtCmd = cmd;
break;
}
if (ret EQ AT_FAIL)
{
cmdCmeError(CME_ERR_Unknown);
break;
}
}
while(!END_OF_LIST);
}
if (END_OF_LIST)
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CCWA |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CCWA call back
*/
#ifdef NO_ASCIIZ
GLOBAL void rCI_PlusCCWA ( /*UBYTE srcId,*/
T_ACI_CLSSTAT * clsStat,
CHAR * number,
T_ACI_TOA * type,
U8 validity,
T_ACI_CLASS class_type,
T_ACI_PB_TEXT * alpha )
#else /* ifdef NO_ASCIIZ */
GLOBAL void rCI_PlusCCWA (/*UBYTE srcId, */
T_ACI_CLSSTAT * clsStat,
CHAR * number,
T_ACI_TOA * type,
U8 validity,
T_ACI_CLASS class_type,
CHAR * alpha )
#endif /* ifdef NO_ASCIIZ */
{
char* me = "+CCWA: ";
int i = 0;
CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
USHORT lenCvtdAlpha;
UBYTE *uniAlpha = NULL;
UBYTE uniAlphaLen = 0;
UBYTE srcId = srcId_cb;
T_ACI_CLASS test_class;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCCWA()");
#ifdef NO_ASCIIZ
if ( alpha NEQ NULL )
{
uniAlpha = alpha->data;
uniAlphaLen = alpha->len;
}
#else /* ifdef NO_ASCIIZ */
if ( alpha NEQ NULL )
{
uniAlpha = (UBYTE *)alpha;
uniAlphaLen = strlen(alpha);
}
#endif /* ifdef NO_ASCIIZ */
if(clsStat) /*Callback for q_AT_PlusCCWA*/
{
if (clsStat->status EQ STATUS_Active)
{
src_params->curAtCmd = AT_CMD_NONE;
test_class = 1;
while( test_class < 2*CLASS_Fax )
{
if( clsStat->class_type & test_class )
{
TRACE_EVENT_P1("test_class: %d", test_class);
sprintf(g_sa,"%s%d,%d", me, clsStat->status, test_class);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
test_class *= 2; /* test next class */
}
}
else
{
sprintf ( g_sa, "%s0,%d",me, clsStat->class_type );
io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
}
}
else /*call waiting indication*/
{
if ( at.flags.CCWA_stat
/* AND
(
io_getIoMode ( ) EQ IO_MODE_CMD OR
io_getIoMode ( ) EQ IO_MODE_RUN
)*/
)
{
i=sprintf(g_sa,"%s",me);
if (number)
{
i+=sprintf(g_sa+i,"\"%s\",",number);
if (type)
i+=sprintf(g_sa+i,"%d,",toa_merge(*type));
else
i+=sprintf(g_sa+i,"128,");
}
else
i+=sprintf(g_sa+i,"\"\",128,");
if (class_type >=0)
i+=sprintf(g_sa+i,"%d,",class_type);
else
i+=sprintf(g_sa+i,",");
if (alpha)
{
utl_chsetFromSim ( uniAlpha,
uniAlphaLen,
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Def );
i+=sprints(g_sa+i,cvtdAlpha,lenCvtdAlpha);
}
if (validity NEQ PRES_NOT_PRES)
{
i += sprintf(g_sa+i,",%d",validity);
}
ci_remTrailCom(g_sa, (USHORT)i);
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
#ifdef ACI /* for ATI only version */
cmhMMI_handleAudioTone ( AT_CMD_NONE, RAT_CCWA, CPI_MSG_NotPresent );
#endif
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CCFC |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CCFC call back
*/
GLOBAL void rCI_PlusCCFC (/*UBYTE srcId,*/ T_ACI_CCFC_SET* setting)
{
char *me="+CCFC: ";
int i=0;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCCFC()");
src_params->curAtCmd = AT_CMD_NONE;
if (setting) /*Callback for qAT_PlusCCFC*/
{
if (setting->clsstat.status EQ STATUS_Active)
{
i=sprintf(g_sa,"%s",me);
if (setting->clsstat.status NEQ STATUS_NotPresent)
i+=sprintf(g_sa+i,"%d,",setting->clsstat.status);
else
i+=sprintf(g_sa+i,",");
if (setting->clsstat.class_type NEQ CLASS_NotPresent)
i+=sprintf(g_sa+i,"%d,",setting->clsstat.class_type);
else
i+=sprintf(g_sa+i,",");
if (setting->number[0] NEQ 0x0 )
i+=sprintf(g_sa+i,"\"%s\",",setting->number);
else
i+=sprintf(g_sa+i,",");
if (setting->type.npi NEQ NPI_NotPresent )
i+=sprintf(g_sa+i,"%d,",toa_merge(setting->type));
else
i+=sprintf(g_sa+i,",");
if (setting->subaddr[0] NEQ 0x0 )
i+=sprintf(g_sa+i,"\"%s\",",setting->subaddr);
else
i+=sprintf(g_sa+i,",");
if (setting->satype.tos NEQ TOS_NotPresent )
i+=sprintf(g_sa+i,"%d,",tos_merge(setting->satype));
else
i+=sprintf(g_sa+i,",");
if (setting->time NEQ ACI_NumParmNotPresent)
i+=sprintf(g_sa+i,"%d",setting->time);
ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
else
{
sprintf ( g_sa, "%s0,%d",me, setting->clsstat.class_type );
io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CLCK |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CLCK call back
*/
GLOBAL void rCI_PlusCLCK (/*UBYTE srcId,*/ T_ACI_CLSSTAT * clsStat)
{
char *me="+CLCK: ";
int i=0;
UBYTE srcId = srcId_cb;
T_ACI_CLASS test_class;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCLCK()");
src_params->curAtCmd = AT_CMD_NONE;
if(clsStat) /*Callback for qAT_PlusCLCK*/
{
if (clsStat->status EQ STATUS_Active)
{
test_class = 1;
while( test_class < 2*CLASS_Sms )
{
if( clsStat->class_type & test_class )
{
sprintf(g_sa,"%s%d,%d",me,clsStat->status,test_class);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
test_class *= 2; /* test next class */
}
}
else
{
sprintf ( g_sa, "%s0,%d", me, clsStat->class_type );
io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CRSM |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CRSM call back
*/
GLOBAL void rCI_PlusCRSM ( /*UBYTE srcId,*/
SHORT sw1,
SHORT sw2,
SHORT rspLen,
UBYTE *rsp )
{
int i=0;
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCRSM()");
i=sprintf(g_sa,"%s","+CRSM: ");
if (sw1 NEQ ACI_NumParmNotPresent)
i+=sprintf(g_sa+i,"%d,",sw1);
else
i+=sprintf(g_sa+i,",");
if (sw2 NEQ ACI_NumParmNotPresent)
i+=sprintf(g_sa+i,"%d,",sw2);
else
i+=sprintf(g_sa+i,",");
if (rspLen AND rsp)
{
utl_binToHex( rsp, rspLen, g_sa+i );
}
ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CSIM |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CSIM call back
*/
GLOBAL void rCI_PlusCSIM ( /*UBYTE srcId,*/
SHORT len,
UBYTE *rsp )
{
UBYTE i;
UBYTE srcId = srcId_cb;
SHORT rstLen = 0;
SHORT tmpLen;
TRACE_FUNCTION("rCI_PlusCSIM()");
i=sprintf(g_sa,"%s%d,","+CSIM: ",len*2);
if (len AND rsp)
{
if( len*2+i > (MAX_CMD_LEN-1) ) rstLen = (len*2+i) - (MAX_CMD_LEN-1);
tmpLen = (rstLen)?len-rstLen/2:len;
utl_binToHex( rsp, tmpLen, g_sa+i );
io_sendMessageEx(srcId, g_sa, ATI_NORMAL_OUTPUT|ATI_BEGIN_CRLF_OUTPUT );
while( rstLen )
{
rsp += tmpLen;
tmpLen = rstLen/2;
rstLen =( tmpLen*2 > (MAX_CMD_LEN-1))?tmpLen*2 - (MAX_CMD_LEN-1):0;
if(rstLen) tmpLen = tmpLen-rstLen/2;
utl_binToHex( rsp, tmpLen, g_sa );
io_sendMessageEx(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
g_sa[0] = '\0';
io_sendMessageEx(srcId, g_sa, ATI_NORMAL_OUTPUT|ATI_END_CRLF_OUTPUT);
}
else
{
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CSMS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CSMS call back
*/
GLOBAL void rCI_PlusCSMS ( /*UBYTE srcId,*/
T_ACI_CSMS_SERV service,
T_ACI_CSMS_SUPP mt,
T_ACI_CSMS_SUPP mo,
T_ACI_CSMS_SUPP bm)
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
char *me="+CSMS: ";
int i=0;
TRACE_FUNCTION("rCI_PlusCSMS()");
src_params->curAtCmd = AT_CMD_NONE;
if (service < 0)
sprintf(g_sa,"%s%d,%d,%d",me,mt,mo,bm);
else
sprintf(g_sa,"%s%d,%d,%d,%d",me,service,mt,mo,bm);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_CPMS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_CPMS call back
*/
GLOBAL void rCI_PlusCPMS ( /*UBYTE srcId,*/
T_ACI_SMS_STOR_OCC * mem1,
T_ACI_SMS_STOR_OCC * mem2,
T_ACI_SMS_STOR_OCC * mem3 )
{
CHAR* me = "+CPMS: ";
CHAR memstr1[3] = {0};
CHAR memstr2[3] = {0};
CHAR memstr3[3] = {0};
BOOL f1 = TRUE;
BOOL f2 = TRUE;
BOOL f3 = TRUE;
int i = 0;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCPMS()");
src_params->curAtCmd = AT_CMD_NONE;
if ( cpmsCallType EQ QAT_CALL )
{
for ( i=0; sms_mem[i].name != NULL; i++ )
{
if ( ( sms_mem[i].stor EQ mem1->mem ) AND f1 )
{
strcpy ( memstr1, sms_mem[i].name );
f1 = FALSE;
}
if ( ( sms_mem[i].stor EQ mem2->mem ) AND f2 )
{
strcpy ( memstr2, sms_mem[i].name );
f2 = FALSE;
}
if ( ( sms_mem[i].stor EQ mem3->mem ) 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, mem1->used, mem1->total,
memstr2, mem2->used, mem2->total,
memstr3, mem3->used, mem3->total );
}
else
{
sprintf ( g_sa, "%s%d,%d,%d,%d,%d,%d",
me, mem1->used, mem1->total,
mem2->used, mem2->total,
mem3->used, mem3->total );
}
io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
cpmsCallType = NONE_CALL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMS call back
*/
GLOBAL void rCI_PlusCMS ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, T_ACI_CMS_ERR err,
T_EXT_CMS_ERROR *conc_error)
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PLusCMS()");
ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
if ( curAbrtCmd EQ AT_CMD_NONE )
{
src_params->curAtCmd = AT_CMD_NONE;
io_sendConfirm(srcId, cmdCmsError(err), ATI_NORMAL_OUTPUT);
cmdErrStr = NULL;
}
else
{
curAbrtCmd = AT_CMD_NONE;
io_sendMessage ( srcId, cmdCmsError ( CMS_ERR_FailedToAbort ),
ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCBM |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCBM call back
*/
GLOBAL void rCI_PlusCBM ( T_MMI_CBCH_IND * mmi_cbch_ind )
{
UBYTE srcId = srcId_cb;
T_ATI_IO_MODE ioMode;
#if defined (SMS_PDU_SUPPORT)
T_ACI_CMGF_MOD mode;
#endif
TRACE_FUNCTION("rCI_PlusCBM()");
/* Check if the source invoking this function is the same as the one
* interested in SMS indications */ /* Issue 25033 */
if (srcId NEQ smsShrdPrm.smsSrcId)
return;
ioMode = ati_get_mode( srcId_cb );
if ( !cnmiFlushInProgress
AND (ioMode NEQ ATI_UNKN_MODE)
AND ( (at.CNMI_mode EQ CNMI_MOD_Buffer)
OR
((ioMode EQ ATI_DATA_MODE) AND (at.CNMI_mode EQ CNMI_MOD_BufferAndFlush)) ) )
{
T_CNMI_IND ind;
memcpy (&ind.cbm, mmi_cbch_ind, sizeof(T_MMI_CBCH_IND));
cmd_addCnmiNtry ( CNMI_CBM, &ind );
}
else if ( cnmiFlushInProgress OR
( ioMode EQ ATI_CMD_MODE AND
at.CNMI_mode NEQ CNMI_MOD_Buffer ) )
#if defined (SMS_PDU_SUPPORT)
{
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
{
/*
* handle PDU mode
*/
rCI_PlusCBMPdu (mmi_cbch_ind);
}
else
{
/*
* handle Text mode
*/
rCI_PlusCBMText (mmi_cbch_ind);
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCBM |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCBM call back
*/
LOCAL void rCI_PlusCBMText ( T_MMI_CBCH_IND * mmi_cbch_ind )
#endif /* SMS_PDU_SUPPORT */
{
USHORT pos;
USHORT lenCvtdData = 0;
CHAR cvtdData[2*MAX_CBM_LEN] = {0x00};
UBYTE srcId = srcId_cb;
USHORT sn; /* serial number */
USHORT mid; /* message identifier */
UBYTE dcs; /* data coding scheme */
UBYTE page; /* actual page number */
UBYTE pages; /* total number of pages */
T_ACI_CBM_DATA msg; /* cell broadcast message data */
TRACE_FUNCTION("rCI_PLusCBMText()");
/*
*-----------------------------------------------------------------
* process parameters for new message indication
*-----------------------------------------------------------------
*/
sn = ( ( SHORT )mmi_cbch_ind->cbch_msg[0] << 8 ) +
mmi_cbch_ind->cbch_msg[1];
mid = ( ( SHORT )mmi_cbch_ind->cbch_msg[2] << 8 ) +
mmi_cbch_ind->cbch_msg[3];
dcs = mmi_cbch_ind->cbch_msg[4];
page = ( mmi_cbch_ind->cbch_msg[5] & 0xF0 ) >> 4;
pages = ( mmi_cbch_ind->cbch_msg[5] & 0x0F );
/*
*-----------------------------------------------------------------
* process message data, expanding from 7 to 8 bit
*-----------------------------------------------------------------
*/
cmhSMS_expdSmsCb ( dcs,
&mmi_cbch_ind->cbch_msg[CBCH_HEAD_LEN],
(UBYTE)(mmi_cbch_ind->cbch_len - CBCH_HEAD_LEN),
msg.data, &msg.len );
pos=sprintf(g_sa,"+CBM: %d,%d,%d,%d,%d",sn,mid,dcs,page,pages);
io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
if (msg.len > 0)
{
pos = 0;
utl_cbmDtaToTe((UBYTE*)msg.data,
msg.len,
(UBYTE*)cvtdData,
sizeof(cvtdData),
&lenCvtdData,
0,
(UBYTE)dcs);
pos+=sprintq(g_sa+pos,cvtdData,lenCvtdData);
io_sendMessageEx(srcId, g_sa, ATI_INDICATION_OUTPUT +
ATI_FORCED_OUTPUT +
ATI_END_CRLF_OUTPUT);
}
}
#if !defined (SMS_PDU_SUPPORT)
} /* rCI_PlusCBM */
#endif
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCDS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCDS call back
*/
GLOBAL void rCI_PlusCDS ( T_MNSMS_STATUS_IND * mnsms_status_ind )
{
UBYTE srcId = srcId_cb;
T_ATI_IO_MODE ioMode;
#if defined (SMS_PDU_SUPPORT)
T_ACI_CMGF_MOD mode;
#endif
TRACE_FUNCTION("rCI_PLusCDS()");
/* Check if the source invoking this function is the same as the one
* interested in SMS indications */ /* Issue 25033 */
if (srcId NEQ smsShrdPrm.smsSrcId)
return;
ioMode = ati_get_mode( srcId_cb );
if ( !cnmiFlushInProgress
AND (ioMode NEQ ATI_UNKN_MODE)
AND ( (at.CNMI_mode EQ CNMI_MOD_Buffer)
OR
((ioMode EQ ATI_DATA_MODE) AND (at.CNMI_mode EQ CNMI_MOD_BufferAndFlush)) ) )
{
T_CNMI_IND ind;
memcpy ( &ind.cds, mnsms_status_ind, sizeof ( T_MNSMS_STATUS_IND) );
cmd_addCnmiNtry ( CNMI_CDS, &ind );
}
else if ( cnmiFlushInProgress OR
( ioMode EQ ATI_CMD_MODE AND
at.CNMI_mode NEQ CNMI_MOD_Buffer ) )
#if defined (SMS_PDU_SUPPORT)
{
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
{
/*
* handle PDU mode
*/
rCI_PlusCDSPdu (mnsms_status_ind);
}
else
{
/*
* handle Text mode
*/
rCI_PlusCDSText (mnsms_status_ind);
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCDSText |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCDS call back for text mode
*/
LOCAL void rCI_PlusCDSText (T_MNSMS_STATUS_IND * mnsms_status_ind)
#endif /* SMS_PDU_SUPPORT */
{
UBYTE srcId = srcId_cb;
T_ACI_CDS_SM* p_st;
SHORT pos = 0;
TRACE_FUNCTION("rCI_PLusCDSText()");
/* is the SM already decoded ? */
if (smsShrdPrm.pDecMsg)
p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
else
{
ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CDS_SM) );
p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
cmhSMS_cpyStatInd ( p_st, mnsms_status_ind);
}
pos=sprintf(g_sa,"+CDS: %d,%d,",p_st->fo, p_st->msg_ref);
if (strlen(p_st->addr))
pos+=sprintf(g_sa+pos,"\"%s\"",p_st->addr);
else
pos+=sprintf(g_sa+pos,",");
if( (p_st->toa.ton NEQ TON_NotPresent) AND (p_st->toa.npi NEQ NPI_NotPresent) )
pos+=sprintf(g_sa+pos,",%d",toa_merge(p_st->toa));
else
pos+=sprintf(g_sa+pos,",");
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
p_st->vpabs_scts.year [0], p_st->vpabs_scts.year [1],
p_st->vpabs_scts.month [0], p_st->vpabs_scts.month [1],
p_st->vpabs_scts.day [0], p_st->vpabs_scts.day [1],
p_st->vpabs_scts.hour [0], p_st->vpabs_scts.hour [1],
p_st->vpabs_scts.minute[0], p_st->vpabs_scts.minute[1],
p_st->vpabs_scts.second[0], p_st->vpabs_scts.second[1],
p_st->vpabs_scts.timezone);
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\",%d",
p_st->vpabs_dt.year [0], p_st->vpabs_dt.year [1],
p_st->vpabs_dt.month [0], p_st->vpabs_dt.month [1],
p_st->vpabs_dt.day [0], p_st->vpabs_dt.day [1],
p_st->vpabs_dt.hour [0], p_st->vpabs_dt.hour [1],
p_st->vpabs_dt.minute[0], p_st->vpabs_dt.minute[1],
p_st->vpabs_dt.second[0], p_st->vpabs_dt.second[1],
p_st->vpabs_dt.timezone , p_st->tp_status);
io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
}
#if !defined (SMS_PDU_SUPPORT)
} /* rCI_PlusCDS */
#endif
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMT |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMT call back
*/
GLOBAL void rCI_PlusCMT (T_MNSMS_MESSAGE_IND* mnsms_message_ind)
{
UBYTE srcId = srcId_cb;
T_ATI_IO_MODE ioMode;
#if defined (SMS_PDU_SUPPORT)
T_ACI_CMGF_MOD mode;
#endif
TRACE_EVENT_P1("rCI_PlusCMT(): source Id: %d", srcId);
/* Check if the source invoking this function is the same as the one
* interested in SMS indications */ /* Issue 25033 */
if (srcId NEQ smsShrdPrm.smsSrcId)
return;
ioMode = ati_get_mode( srcId );
if( ioMode EQ ATI_UNKN_MODE )
{
TRACE_EVENT("rCI_PlusCMT(): unused source (unknown ioMode) -> return");
return;
}
if ( !cnmiFlushInProgress AND
( (at.CNMI_mode EQ CNMI_MOD_Buffer)
OR
( (ioMode EQ ATI_DATA_MODE) AND
(at.CNMI_mode EQ CNMI_MOD_BufferAndFlush)) ) )
{ /* terminal is busy --> store data into CNMI buffer */
T_CNMI_IND ind;
TRACE_EVENT("rCI_PlusCMT(): terminal busy or buffer mode --> store data into CNMI buffer");
memcpy ( &ind.cmt, mnsms_message_ind, sizeof ( T_MNSMS_MESSAGE_IND) );
cmd_addCnmiNtry ( CNMI_CMT, &ind );
if ( smsShrdPrm.cnma_ack_expected EQ TRUE )
{ /* the acknowledge must be send automatically, because terminal is busy */
PALLOC (mnsms_ack_res, MNSMS_ACK_RES);
TRACE_EVENT("rCI_PlusCMT(): send 'automatic' acknowledge (Phase2+ mode and buffer)");
mnsms_ack_res->resp = SMS_RP_ACK;
mnsms_ack_res->sms_sdu.o_buf = 0;
mnsms_ack_res->sms_sdu.l_buf = 0;
PSENDX (SMS, mnsms_ack_res);
smsShrdPrm.cnma_ack_expected = FALSE;
}
}
else
{ /* flush in progress or terminal is not busy */
TRACE_EVENT("rCI_PlusCMT(): flush in progress or command mode --> show +CMT on terminal");
if ( cnmiFlushInProgress OR
( (ioMode EQ ATI_CMD_MODE) AND
(at.CNMI_mode NEQ CNMI_MOD_Buffer) ) )
#if defined (SMS_PDU_SUPPORT)
{ /* request current mode (text or PDU) */
if( smsShrdPrm.CNMImt EQ 0 )
{
TRACE_EVENT("rCI_PlusCMT(): +CNMI <mt>=0 --> no routing to terminal (error in SMS entity)");
return;
}
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
{
/*
* handle PDU mode
*/
rCI_PlusCMTPdu (mnsms_message_ind);
}
else
{
/*
* handle Text mode
*/
rCI_PlusCMTText (mnsms_message_ind);
}
}
else
{
TRACE_EVENT_P3("rCI_PlusCMT(): cannot display the +CMT --> flushInProgess?: %d, ioMode: %d, CNMI Mode: % d",
cnmiFlushInProgress, ioMode, at.CNMI_mode);
}
}
}
LOCAL void rCI_PlusCMTText (T_MNSMS_MESSAGE_IND* mnsms_message_ind)
#endif /* SMS_PDU_SUPPORT */
{
SHORT pos = 0;
CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
USHORT lenCvtdAlpha;
CHAR cvtdData[2*MAX_SM_LEN];
USHORT lenCvtdData;
UBYTE srcId = srcId_cb;
T_ACI_CMGL_SM* p_sm;
#if defined FF_EOTD
T_LOC_MLC_ADDRESS* lc_orig_addr_ptr;
int i = 0;
#endif
TRACE_FUNCTION("rCI_PlusCMTText()");
pos=sprintf(g_sa,"+CMT: ");
/* is the SM already decoded ? */
if (smsShrdPrm.pDecMsg)
p_sm = smsShrdPrm.pDecMsg;
else
{
ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
p_sm = smsShrdPrm.pDecMsg;
cmhSMS_cpyMsgInd ( p_sm, mnsms_message_ind);
}
#if defined FF_EOTD
memset(&lc_orig_addr,0,sizeof(T_LOC_MLC_ADDRESS));
lc_orig_addr_ptr = &lc_orig_addr;
lc_orig_addr_ptr->toa.npi = p_sm->toa.npi;
lc_orig_addr_ptr->toa.ton = p_sm->toa.ton;
if(lc_orig_addr_ptr->toa.ton EQ TON_International)
{
lc_orig_addr_ptr->address[i] = '+';
i++;
}
strncpy(lc_orig_addr_ptr->address+i,p_sm->adress,sizeof(p_sm->adress)-(size_t)i);
#endif /* FF_EOTD */
pos+=sprintf(g_sa+pos,"\"%s\",",p_sm->adress);
#ifdef FF_ATI_BAT
/*
* Extracting the alphanumeric data from the phonebook at this point
* would defeat the object (testing the BAT message). Having this
* data stored globally represents an easier solution to the
* problem of conveying it here.
*/
if (smsShrdPrm.alpha_len)
{
pos+=sprints(g_sa+pos,smsShrdPrm.alpha,smsShrdPrm.alpha_len);
}
#else
if( p_sm->alpha.len > 0 )
{
utl_chsetFromGsm((UBYTE*)p_sm->alpha.data,
p_sm->alpha.len,
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Def);
pos+=sprints(g_sa+pos,cvtdAlpha,lenCvtdAlpha);
}
#endif
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"", /* SCTS */
p_sm->scts.year [0], p_sm->scts.year [1],
p_sm->scts.month [0], p_sm->scts.month [1],
p_sm->scts.day [0], p_sm->scts.day [1],
p_sm->scts.hour [0], p_sm->scts.hour [1],
p_sm->scts.minute[0], p_sm->scts.minute[1],
p_sm->scts.second[0], p_sm->scts.second[1],
p_sm->scts.timezone);
if (ati_user_output_cfg[srcId].CSDH_stat)
{
if(strlen(p_sm->adress))
pos+=sprintf(g_sa+pos,",%d",toa_merge(p_sm->toa));
else
pos+=sprintf(g_sa+pos,",");
pos+=sprintf(g_sa+pos,",%d,%d,%d",p_sm->fo,p_sm->pid,p_sm->dcs); /*FO, PID, DCS*/
if(strlen(p_sm->sca))
{
pos+=sprintf(g_sa+pos,",\"%s\"",p_sm->sca);
pos+=sprintf(g_sa+pos,",%d",toa_merge(p_sm->tosca));
}
else
pos+=sprintf(g_sa+pos,",,");
}
if (((UBYTE)p_sm->fo & TP_UDHI_MASK) EQ TP_UDHI_WITH_HEADER)
{
T_ACI_SM_DATA data;
aci_frmtOutput(p_sm->fo, p_sm->dcs, &data);
utl_smDtaToTe((UBYTE*)data.data,
data.len,
(UBYTE*)cvtdData,
sizeof(cvtdData),
&lenCvtdData,
(UBYTE)p_sm->fo,
(UBYTE)p_sm->dcs);
if (ati_user_output_cfg[srcId].CSDH_stat)
pos+=sprintf(g_sa+pos,",%d",data.len);
io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
pos=sprintq(g_sa,cvtdData,lenCvtdData);
io_sendMessageEx(srcId, g_sa, ATI_INDICATION_OUTPUT +
ATI_FORCED_OUTPUT +
ATI_END_CRLF_OUTPUT);
}
else
{
if (ati_user_output_cfg[srcId].CSDH_stat)
pos+=sprintf(g_sa+pos,",%d",p_sm->data.len);
io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
if (p_sm->data.len > 0)
{
utl_smDtaToTe((UBYTE*)p_sm->data.data,
p_sm->data.len,
(UBYTE*)cvtdData,
sizeof(cvtdData),
&lenCvtdData,
(UBYTE)p_sm->fo,
(UBYTE)p_sm->dcs);
pos=sprintq(g_sa,cvtdData,lenCvtdData);
}
else
{
g_sa[0]='\0';
}
io_sendMessageEx(srcId, g_sa, ATI_INDICATION_OUTPUT +
ATI_FORCED_OUTPUT +
ATI_END_CRLF_OUTPUT);
}
}
#if !defined (SMS_PDU_SUPPORT)
} /* else in previous function */
} /* rCI_PlusCMT */
#endif
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMGR |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMGR call back (Read Message)
*/
GLOBAL void rCI_PlusCMGR ( T_MNSMS_READ_CNF* mnsms_read_cnf,
T_ACI_CMGR_CBM * cbm)
{
UBYTE msg_type;
#if defined (SMS_PDU_SUPPORT)
UBYTE srcId = srcId_cb;
T_ACI_CMGF_MOD mode;
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
/*
* handle PDU mode
*/
rCI_Plus_Percent_CMGRPdu (mnsms_read_cnf, AT_CMD_CMGR);
else
#endif
/*
* handle Text mode
*/
{
/* querying the type of the SM */
cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);
if (msg_type EQ TP_MTI_SMS_STATUS_REP)
rCI_Plus_Percent_CMGRTextSP (mnsms_read_cnf, AT_CMD_CMGR);
else
rCI_Plus_Percent_CMGRText (mnsms_read_cnf, cbm, AT_CMD_CMGR);
}
}
LOCAL void rCI_Plus_Percent_CMGRText (T_MNSMS_READ_CNF* mnsms_read_cnf,
T_ACI_CMGR_CBM * cbm,
T_ACI_AT_CMD cmd )
{
CHAR* buf;
SHORT pos = 0;
CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
USHORT lenCvtdAlpha;
CHAR cvtdData[2*MAX_SM_LEN];
USHORT lenCvtdData;
UBYTE srcId = srcId_cb;
T_ACI_CMGL_SM* p_sm;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
char vpenh_str[15];
TRACE_FUNCTION("rCI_Plus_Percent_CMGRText()");
src_params->curAtCmd = AT_CMD_NONE;
/* is the SM already decoded ? */
if (smsShrdPrm.pDecMsg)
p_sm = smsShrdPrm.pDecMsg;
else
{
ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
p_sm = smsShrdPrm.pDecMsg;
cmhSMS_cpyReadCnf (p_sm, mnsms_read_cnf);
}
buf=sms_status(p_sm->stat);
if (buf) /* STATUS */
{
if (cmd EQ AT_CMD_CMGR)
{
pos=sprintf(g_sa,"+CMGR: \"%s\"",buf);
}
else
{
pos=sprintf (g_sa, " %s: \"%s\"", "%CMGR", buf);
}
}
else
{
if (cmd EQ AT_CMD_CMGR)
{
pos=sprintf(g_sa,"+CMGR: ,");
}
else
{
pos=sprintf (g_sa, " %s", "%CMGR: ,");
}
}
pos+=sprintf(g_sa+pos,",\"%s\"",p_sm->adress); /*Destination Address*/
#ifdef FF_ATI_BAT
/*
* Extracting the alphanumeric data from the phonebook at this point
* would defeat the object (testing the BAT message). Having this
* data stored globally represents a quick and dirty solution to the
* problem of conveying it here.
*/
if (smsShrdPrm.alpha_len)
{
pos+=sprints(g_sa+pos,smsShrdPrm.alpha,smsShrdPrm.alpha_len);
}
else
{
pos+=sprintf(g_sa+pos,",");
}
#else
if (p_sm->alpha.len > 0) /*ALPHA*/
{
pos+=sprintf(g_sa+pos,",");
utl_chsetFromGsm((UBYTE*)p_sm->alpha.data,
p_sm->alpha.len,
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Def);
pos+=sprints(g_sa+pos,cvtdAlpha,lenCvtdAlpha);
}
else
pos+=sprintf(g_sa+pos,",");
#endif /*FF_ATI_BAT*/
if ((p_sm->fo & TP_MTI_MASK) EQ TP_MTI_SMS_DELIVER)
{
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
p_sm->scts.year [0], p_sm->scts.year [1],
p_sm->scts.month [0], p_sm->scts.month [1],
p_sm->scts.day [0], p_sm->scts.day [1],
p_sm->scts.hour [0], p_sm->scts.hour [1],
p_sm->scts.minute[0], p_sm->scts.minute[1],
p_sm->scts.second[0], p_sm->scts.second[1],
p_sm->scts.timezone);
}
if(ati_user_output_cfg[srcId].CSDH_stat)
{
if(strlen(p_sm->adress)) /*TOA Destination*/
pos+=sprintf(g_sa+pos,",%d",toa_merge(p_sm->toa));
else
pos+=sprintf(g_sa+pos,",");
pos+=sprintf(g_sa+pos,",%d,%d,%d",p_sm->fo,p_sm->pid,p_sm->dcs); /*FO, PID, DCS*/
if ((p_sm->fo & TP_MTI_MASK) EQ TP_MTI_SMS_SUBMIT)
{
if ((p_sm->fo & TP_VPF_MASK) EQ TP_VPF_ABSOLUTE)
{
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
p_sm->scts.year [0], p_sm->scts.year [1],
p_sm->scts.month [0], p_sm->scts.month [1],
p_sm->scts.day [0], p_sm->scts.day [1],
p_sm->scts.hour [0], p_sm->scts.hour [1],
p_sm->scts.minute[0], p_sm->scts.minute[1],
p_sm->scts.second[0], p_sm->scts.second[1],
p_sm->scts.timezone);
}
else if ((p_sm->fo & TP_VPF_MASK) EQ TP_VPF_ENHANCED)
{
aci_encodeVpenh ( vpenh_str, &p_sm->vp_enh );
pos+=sprintf(g_sa+pos,",\"%s\"",vpenh_str);
}
else if ((p_sm->fo & TP_VPF_MASK) EQ TP_VPF_RELATIVE)
pos+=sprintf(g_sa+pos,",%d",p_sm->vp_rel);
else
pos+=sprintf(g_sa+pos,",");
}
if(strlen(p_sm->sca)) /*Destination Address*/
{
pos+=sprintf(g_sa+pos,",\"%s\"",p_sm->sca);
pos+=sprintf(g_sa+pos,",%d",toa_merge(p_sm->tosca));
}
else
pos+=sprintf(g_sa+pos,",,");
}
if (((UBYTE)p_sm->fo & TP_UDHI_MASK) EQ TP_UDHI_WITH_HEADER)
{
T_ACI_SM_DATA data;
aci_frmtOutput (p_sm->fo, p_sm->dcs, &data);
utl_smDtaToTe((UBYTE*)data.data,
data.len,
(UBYTE*)cvtdData,
sizeof(cvtdData),
&lenCvtdData,
(UBYTE)p_sm->fo,
(UBYTE)p_sm->dcs);
if(ati_user_output_cfg[srcId].CSDH_stat)
pos+=sprintf(g_sa+pos,",%d",data.len);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
pos=sprintq(g_sa,cvtdData,lenCvtdData);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
else
{
if(ati_user_output_cfg[srcId].CSDH_stat)
pos+=sprintf(g_sa+pos,",%d",p_sm->data.len);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
if (p_sm->data.len > 0)
{
utl_smDtaToTe( (UBYTE*)p_sm->data.data,
p_sm->data.len,
(UBYTE*)cvtdData,
sizeof(cvtdData),
&lenCvtdData,
(UBYTE)p_sm->fo,
(UBYTE)p_sm->dcs);
pos=sprintq(g_sa,cvtdData,lenCvtdData);
}
else /* empty SMS passed */
{
g_sa[0]='\0';
}
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMTI |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMTI call back
*/
GLOBAL void rCI_PlusCMTI ( /*UBYTE srcId,*/ T_ACI_SMS_STOR mem, UBYTE index)
{
UBYTE srcId = srcId_cb;
char mem_str[3];
SHORT i;
T_ATI_IO_MODE ioMode;
/* Check if the source invoking this function is the same as the one
* interested in SMS indications */ /* Issue 25033 */
if (srcId NEQ smsShrdPrm.smsSrcId)
return;
TRACE_EVENT_P1("rCI_PlusCMTI(): source Id: %d", srcId);
ioMode = ati_get_mode( srcId_cb );
if ( !cnmiFlushInProgress
AND (ioMode NEQ ATI_UNKN_MODE)
AND ( (at.CNMI_mode EQ CNMI_MOD_Buffer)
OR
((ioMode EQ ATI_DATA_MODE) AND (at.CNMI_mode EQ CNMI_MOD_BufferAndFlush)) ) )
{
T_CNMI_IND ind;
ind.cmti.mem = mem;
ind.cmti.index = index;
cmd_addCnmiNtry ( CNMI_CMTI, &ind );
}
else if ( cnmiFlushInProgress OR
( ioMode EQ ATI_CMD_MODE AND
at.CNMI_mode NEQ CNMI_MOD_Buffer ) )
{
for (i=0;sms_mem[i].name != 0;i++)
{
if (sms_mem[i].stor EQ mem)
{
strcpy(mem_str,sms_mem[i].name);
break;
}
}
sprintf(g_sa,"+CMTI: \"%s\",%d",mem_str,index);
io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMGS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMGS call back
*/
GLOBAL void rCI_PlusCMGS (T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf)
#if defined (SMS_PDU_SUPPORT)
{
UBYTE srcId = srcId_cb;
T_ACI_CMGF_MOD mode;
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
/*
* handle PDU mode
*/
rCI_PlusCMGSPdu (mnsms_submit_cnf);
else
/*
* handle Text mode
*/
rCI_PlusCMGSText (mnsms_submit_cnf);
}
LOCAL void rCI_PlusCMGSText ( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf )
#endif
{
SHORT pos = 0;
T_ACI_VP_ABS scts;
UBYTE srcId = srcId_cb;
UBYTE *buf;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCMGSText()");
src_params->curAtCmd = AT_CMD_NONE;
pos=sprintf(g_sa,"+CMGS: %d", mnsms_submit_cnf->tp_mr);
if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus)
{
if (mnsms_submit_cnf->sms_sdu.l_buf)
{
/* skip SCA in SIM-PDU, buf points to SMS-SUBMIT-REPORT */
buf = mnsms_submit_cnf->sms_sdu.buf + mnsms_submit_cnf->sms_sdu.buf[0] + 1;
/* advance to TP-SCTS */
if (mnsms_submit_cnf->cause EQ SMS_NO_ERROR)
buf += 2; /* offset in SMS-SUBMIT-REPORT for RP-ACK */
else
buf += 3; /* offset in SMS-SUBMIT-REPORT for RP-ERROR */
cmh_unpackSCTS (&scts, buf);
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"", /* SCTS */
scts.year [0], scts.year [1],
scts.month [0], scts.month [1],
scts.day [0], scts.day [1],
scts.hour [0], scts.hour [1],
scts.minute[0], scts.minute[1],
scts.second[0], scts.second[1],
scts.timezone);
}
}
io_sendMessageEx( srcId, g_sa,
ATI_NORMAL_OUTPUT | ATI_BEGIN_CRLF_OUTPUT | ATI_END_CRLF_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMSS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMSS call back
*/
GLOBAL void rCI_PlusCMSS (T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf)
#if defined (SMS_PDU_SUPPORT)
{
UBYTE srcId = srcId_cb;
T_ACI_CMGF_MOD mode;
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
/*
* handle PDU mode
*/
rCI_PlusCMSSPdu (mnsms_submit_cnf);
else
/*
* handle Text mode
*/
rCI_PlusCMSSText (mnsms_submit_cnf);
}
LOCAL void rCI_PlusCMSSText ( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf )
#endif
{
SHORT pos = 0;
T_ACI_VP_ABS scts;
UBYTE srcId = srcId_cb;
UBYTE *buf;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCMSSText()");
src_params->curAtCmd = AT_CMD_NONE;
pos=sprintf(g_sa,"+CMSS: %d", mnsms_submit_cnf->tp_mr);
if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus)
{
if (mnsms_submit_cnf->sms_sdu.l_buf)
{
/* skip SCA in SIM-PDU, buf points to SMS-SUBMIT-REPORT */
buf = mnsms_submit_cnf->sms_sdu.buf + mnsms_submit_cnf->sms_sdu.buf[0] + 1;
/* advance to TP-SCTS */
if (mnsms_submit_cnf->cause EQ SMS_NO_ERROR)
buf += 2; /* offset in SMS-SUBMIT-REPORT for RP-ACK */
else
buf += 3; /* offset in SMS-SUBMIT-REPORT for RP-ERROR */
cmh_unpackSCTS (&scts, buf);
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"", /* SCTS */
scts.year [0], scts.year [1],
scts.month [0], scts.month [1],
scts.day [0], scts.day [1],
scts.hour [0], scts.hour [1],
scts.minute[0], scts.minute[1],
scts.second[0], scts.second[1],
scts.timezone);
}
}
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMGW |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMGW call back
*/
GLOBAL void rCI_PlusCMGW ( /*UBYTE srcId,*/ UBYTE index)
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PLusCMGW()");
src_params->curAtCmd = AT_CMD_NONE;
sprintf(g_sa,"+CMGW: %d",index);
io_sendMessageEx( srcId, g_sa,
ATI_NORMAL_OUTPUT | ATI_BEGIN_CRLF_OUTPUT | ATI_END_CRLF_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMGC |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMGC call back
*/
GLOBAL void rCI_PlusCMGC (T_MNSMS_COMMAND_CNF * mnsms_command_cnf)
#if defined (SMS_PDU_SUPPORT)
{
UBYTE srcId = srcId_cb;
T_ACI_CMGF_MOD mode;
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
/*
* handle PDU mode
*/
rCI_PlusCMGCPdu (mnsms_command_cnf);
else
/*
* handle Text mode
*/
rCI_PlusCMGCText (mnsms_command_cnf);
}
LOCAL void rCI_PlusCMGCText ( T_MNSMS_COMMAND_CNF * mnsms_command_cnf )
#endif
{
SHORT pos = 0;
T_ACI_VP_ABS scts;
UBYTE srcId = srcId_cb;
UBYTE *buf;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCMGCText()");
src_params->curAtCmd = AT_CMD_NONE;
pos=sprintf(g_sa,"+CMGC: %d", mnsms_command_cnf->tp_mr);
if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus)
{
if (mnsms_command_cnf->sms_sdu.l_buf)
{
/* skip SCA in SIM-PDU, buf points to SMS-STATUS-REPORT */
buf = mnsms_command_cnf->sms_sdu.buf + mnsms_command_cnf->sms_sdu.buf[0] + 1;
/* advance to to TP-RA */
buf += 2;
/* skip variable TP-RA and advance to TP-SCTS */
buf += (*buf+1)/2 + 2; /* length is in BCD digits! TON/NPI is also skipped */
cmh_unpackSCTS (&scts, buf);
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"", /* SCTS */
scts.year [0], scts.year [1],
scts.month [0], scts.month [1],
scts.day [0], scts.day [1],
scts.hour [0], scts.hour [1],
scts.minute[0], scts.minute[1],
scts.second[0], scts.second[1],
scts.timezone);
}
}
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusILRR |
+--------------------------------------------------------------------+
PURPOSE : handles CI_PlusILRR call back
*/
GLOBAL void rCI_PlusILRR( /*UBYTE srcId, */
T_ACI_BS_SPEED speed,
T_ACI_BS_FRM format,
T_ACI_BS_PAR parity)
{
LONG val;
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusILRR()");
if ( ati_user_output_cfg[srcId].ILRR_stat )
{
switch(speed)
{
case(BS_SPEED_300_V110): val= 300; break;
case(BS_SPEED_1200_V110): val= 1200; break;
case(BS_SPEED_2400_V110): val= 2400; break;
case(BS_SPEED_4800_V110): val= 4800; break;
case(BS_SPEED_9600_V110): val= 9600; break;
case(BS_SPEED_14400_V110): val=14400; break;
case(BS_SPEED_19200_V110): val=19200; break;
case(BS_SPEED_38400_V110): val=38400; break;
default: val= 1; break;
}
sprintf(g_sa,"+ILRR: %d,%d,%d",val,format,parity);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentBC |
+--------------------------------------------------------------------+
PURPOSE : handles AT_OK call back
*/
GLOBAL void rCI_PercentBC (BYTE segm);
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentDRV |
+--------------------------------------------------------------------+
PURPOSE : handles AT_OK call back
*/
GLOBAL void rCI_PercentDRV( T_ACI_DRV_DEV device,
T_ACI_DRV_FCT function,
UBYTE val1,
UBYTE val2);
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMGL |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCMGL call back
*/
GLOBAL void rCI_PlusCMGL (T_MNSMS_READ_CNF *mnsms_read_cnf)
{
UBYTE msg_type;
#if defined (SMS_PDU_SUPPORT)
UBYTE srcId = srcId_cb;
T_ACI_CMGF_MOD mode;
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
/*
* handle PDU mode
*/
rCI_Plus_Percent_CMGLPdu (mnsms_read_cnf, AT_CMD_CMGL);
else
#endif
/*
* handle Text mode
*/
{
/* querying the type of the SM */
cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);
if (msg_type EQ TP_MTI_SMS_STATUS_REP)
rCI_Plus_Percent_CMGLTextSP (mnsms_read_cnf, AT_CMD_CMGL);
else
rCI_Plus_Percent_CMGLText (mnsms_read_cnf, AT_CMD_CMGL);
}
}
LOCAL void rCI_Plus_Percent_CMGLText (T_MNSMS_READ_CNF *mnsms_read_cnf,
T_ACI_AT_CMD cmd)
{
SHORT i = 0;
SHORT pos = 0;
CHAR* buf;
CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
USHORT lenCvtdAlpha;
CHAR cvtdData[2*MAX_SM_LEN];
USHORT lenCvtdData;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
T_ACI_CMGL_SM* p_sm;
TRACE_FUNCTION("rCI_Plus_Percent_CMGLText()");
src_params->curAtCmd = AT_CMD_NONE;
/* is the SM already decoded ? */
if (smsShrdPrm.pDecMsg)
p_sm = smsShrdPrm.pDecMsg;
else
{
ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
p_sm = smsShrdPrm.pDecMsg;
cmhSMS_cpyReadCnf (p_sm, mnsms_read_cnf);
}
buf = sms_status ( p_sm->stat );
if (cmd EQ AT_CMD_CMGL )
{
pos = sprintf ( g_sa, "+CMGL: %d", p_sm->msg_ref);
}
else
{
pos=sprintf (g_sa, " %s: %d", "%CMGL", p_sm->msg_ref);
}
if ( buf )
{
pos += sprintf ( g_sa + pos, ",\"%s\"", buf ); /* STATUS */
}
else
{
pos += sprintf ( g_sa + pos, "," );
}
if (p_sm->stat EQ SMS_STAT_Invalid)
{
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); /* emit "INVALID MESSAGE" only */
return;
}
pos += sprintf ( g_sa + pos, ",\"%s\",", p_sm->adress);
#ifdef FF_ATI_BAT
/*
* Extracting the alphanumeric data from the phonebook at this point
* would defeat the object (testing the BAT message). Having this
* data stored globally represents a quick and dirty solution to the
* problem of conveying it here.
*/
if (smsShrdPrm.alpha_len)
{
pos+=sprints(g_sa+pos,smsShrdPrm.alpha,smsShrdPrm.alpha_len);
}
#else
if ( p_sm->alpha.len NEQ 0 )
{
utl_chsetFromGsm ( (UBYTE*)p_sm->alpha.data,
p_sm->alpha.len,
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Def );
pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
}
#endif /*FF_ATI_BAT*/
if ((p_sm->fo & TP_MTI_MASK) NEQ TP_MTI_SMS_DELIVER)
{
pos += sprintf ( g_sa + pos, "," );
}
else
{
pos += sprintf ( g_sa + pos, ",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
p_sm->scts.year [0], p_sm->scts.year [1],
p_sm->scts.month [0], p_sm->scts.month [1],
p_sm->scts.day [0], p_sm->scts.day [1],
p_sm->scts.hour [0], p_sm->scts.hour [1],
p_sm->scts.minute[0], p_sm->scts.minute[1],
p_sm->scts.second[0], p_sm->scts.second[1],
p_sm->scts.timezone);
}
if (((UBYTE)p_sm->fo & TP_UDHI_MASK) EQ TP_UDHI_WITH_HEADER)
{
T_ACI_SM_DATA data;
aci_frmtOutput(p_sm->fo, p_sm->dcs, &data);
utl_smDtaToTe((UBYTE*)data.data,
data.len,
(UBYTE*)cvtdData,
sizeof(cvtdData),
&lenCvtdData,
(UBYTE)p_sm->fo,
(UBYTE)p_sm->dcs);
if(ati_user_output_cfg[srcId].CSDH_stat)
pos += sprintf ( g_sa + pos, ",%d,%d",toa_merge ( p_sm->toa ), data.len );
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
pos=sprintq(g_sa,cvtdData,lenCvtdData);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
else
{
if(ati_user_output_cfg[srcId].CSDH_stat)
pos += sprintf ( g_sa + pos, ",%d,%d",
toa_merge ( p_sm->toa ), p_sm->data.len );
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
if (p_sm->data.len > 0)
{
utl_smDtaToTe( (UBYTE*)p_sm->data.data,
p_sm->data.len,
(UBYTE*)cvtdData,
sizeof(cvtdData),
&lenCvtdData,
(UBYTE)p_sm->fo,
(UBYTE)p_sm->dcs);
pos=sprintq(g_sa,cvtdData,lenCvtdData);
}
else
{
g_sa[0]='\0';
}
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCSSI |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCSSI call back
*/
GLOBAL void rCI_PlusCSSI ( T_ACI_CSSI_CODE code,
SHORT index)
{
SHORT pos=0;
char *me="+CSSI: ";
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PLusCSSI()");
if ( ati_user_output_cfg[srcId].CSSI_stat
/* AND
(
io_getIoMode ( ) EQ IO_MODE_CMD OR
io_getIoMode ( ) EQ IO_MODE_RUN
) */
)
{
pos = sprintf(g_sa,"%s",me);
if (code NEQ CSSI_CODE_NotPresent) pos += sprintf(g_sa+pos,"%d,",code);
else pos += sprintf(g_sa+pos,",");
if (index NEQ ACI_NumParmNotPresent) sprintf(g_sa+pos,"%d",index);
ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCSSU |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCSSU call back
*/
GLOBAL void rCI_PlusCSSU ( /*UBYTE srcId,*/
T_ACI_CSSU_CODE code,
SHORT index,
CHAR *number,
T_ACI_TOA *type,
CHAR *subaddr,
T_ACI_TOS *satype)
{
char *me="+CSSU: ";
SHORT pos=0;
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PLusCSSU()");
if ( ati_user_output_cfg[srcId].CSSU_stat
/* AND
(
io_getIoMode ( ) EQ IO_MODE_CMD OR
io_getIoMode ( ) EQ IO_MODE_RUN
) */
)
{
pos = sprintf(g_sa,"%s",me);
if (code NEQ CSSI_CODE_NotPresent) pos += sprintf(g_sa+pos,"%d,",code);
else pos += sprintf(g_sa+pos,",");
if (index NEQ ACI_NumParmNotPresent) pos += sprintf(g_sa+pos,"%d,",index);
else pos += sprintf(g_sa+pos,",");
if (number)
{
pos += sprintf(g_sa+pos,"\"%s\",",number);
if (type)
pos += sprintf(g_sa+pos,"%d,",toa_merge(*type));
else
pos += sprintf(g_sa+pos,"128,");
}
else
pos += sprintf(g_sa+pos,"\"\",128,");
if (subaddr)
{
pos += sprintf(g_sa+pos,"\"%s\",",subaddr);
if (satype)
pos += sprintf(g_sa+pos,"%d",tos_merge(*satype));
}
ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCUSD |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCUSD call back
*/
GLOBAL void rCI_PlusCUSD ( /*UBYTE srcId,*/
T_ACI_CUSD_MOD m,
T_ACI_USSD_DATA *ussd,
SHORT dcs)
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCUSD()");
src_params->curAtCmd = AT_CMD_NONE;
if ( ati_user_output_cfg[srcId].CUSD_stat )
{
if (ussd != NULL)
{
#ifdef FF_ATI_BAT
rci_display_USSD( srcId, m, ussd->data, ussd->len, FALSE, dcs );
#else
rci_display_USSD( srcId, m, ussd->data, ussd->len, CONVERT_STRING, dcs );
#endif
}
else
{
#ifdef FF_ATI_BAT
rci_display_USSD( srcId, m, NULL, 0, FALSE, dcs );
#else
rci_display_USSD( srcId, m, NULL, 0, CONVERT_STRING, dcs );
#endif
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCIMI |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCIMI call back
*/
GLOBAL void rCI_PlusCIMI ( /*UBYTE srcId,*/ CHAR *imsi)
{
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCIMI()");
src_params->curAtCmd = AT_CMD_NONE;
if (imsi)
{
sprintf(g_sa,"%s",imsi);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCNUM |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCNUM call back
*/
GLOBAL void rCI_PlusCNUM ( /*UBYTE srcId,*/ T_ACI_CNUM_MSISDN *msisdn,
UBYTE num )
{
UBYTE count = 0;
UBYTE i;
T_ACI_RETURN ret;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PlusCNUM()");
for ( i = 0; i < MAX_MSISDN; i++ )
{
count += aci_writeCnumMsisdn ( srcId, &msisdn[i] );
}
if ( count EQ MAX_MSISDN )
{
ret = qAT_PlusCNUM ( srcId, CNUM_MOD_NextRead ) ;
if ( ret EQ AT_EXCT )
{
src_params->curAtCmd = AT_CMD_CNUM;
}
else if ( ret EQ AT_CMPL )
{
src_params->curAtCmd = AT_CMD_NONE;
cmdErrStr = NULL;
}
else
{
src_params->curAtCmd = AT_CMD_NONE;
cmdErrStr = NULL;
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCPOL |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCPOL call back
*/
GLOBAL void rCI_PlusCPOL ( /*UBYTE srcId,*/ SHORT startIdx,
SHORT lastIdx,
T_ACI_CPOL_OPDESC *operLst,
SHORT usdNtry )
{
UBYTE idx;
BOOL loop;
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCPOL()");
loop = TRUE;
/* if oper list is present, reply to read command */
if( operLst )
{
do
{
for( idx=0; idx < MAX_OPER; idx++ )
{
if( operLst[idx].index EQ ACI_NumParmNotPresent )
{
loop = FALSE;
break;
}
sprintf(g_sa,"+CPOL: %d,%d,\"%s\"", operLst[idx].index,
operLst[idx].format,
operLst[idx].oper );
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
if( lastIdx EQ ACI_NumParmNotPresent ) break;
startIdx = lastIdx+1;
#ifdef WIN32
if( qAT_PlusCPOL(srcId, startIdx, &lastIdx, operLst,
cpolMode )
#else
if( qAT_PlusCPOL(srcId, startIdx, &lastIdx, operLst,
CPOL_MOD_NotPresent )
#endif
EQ AT_FAIL OR !loop)
break;
}
while( loop );
}
/* else, reply to test command */
else
{
sprintf(g_sa,"+CPOL: (1-%d),(0-2)", lastIdx);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCLAN |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCLAN call back
*/
GLOBAL void rCI_PlusCLAN ( T_ACI_LAN_SUP *CLang)
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCLAN()");
sprintf(g_sa,"+CLAN: %s",CLang->str );
io_sendMessage(srcId,g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCLAE |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCLAE call back
*/
GLOBAL void rCI_PlusCLAE (T_ACI_LAN_SUP *CLang)
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCLAE()");
sprintf(g_sa,"+CLAV: %s",CLang->str );
io_sendMessage(srcId,g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCCCM |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCCCM call back
*/
GLOBAL void rCI_PlusCCCM ( /*UBYTE srcId,*/ LONG *ccm )
{
static LONG oldCCM = 0;
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCCCM()");
if( *ccm < oldCCM )
{
allowCCCM = TRUE;
callTime = 0;
}
if (ccm AND allowCCCM AND ati_user_output_cfg[srcId].CAOC_stat)
{
allowCCCM = FALSE;
sprintf(g_sa,"+CCCM: \"%6X\"",*ccm);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCCWV |
+--------------------------------------------------------------------+
PURPOSE : handles unsolicited result code +CCWV
*/
GLOBAL void rCI_PlusCCWV ( /*UBYTE srcId,*/ T_ACI_CCWV_CHRG charging )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCCWV()");
if ( charging NEQ CCWV_CHRG_NotPresent )
{
ati_user_output_cfg[srcId].CCWV_charging = charging;
}
else
{
charging = ati_user_output_cfg[srcId].CCWV_charging;
}
if ( charging EQ CCWV_CHRG_Shortage AND
ati_user_output_cfg[srcId].CCWE_stat EQ 1 /* AND
(
io_getIoMode ( ) EQ IO_MODE_CMD OR
io_getIoMode ( ) EQ IO_MODE_RUN
) */
)
{
io_sendIndication(srcId, "+CCWV", ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCPI |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCPI call back
*/
GLOBAL void rCI_PercentCPI ( /*UBYTE srcId,*/ SHORT cId,
T_ACI_CPI_MSG msgType,
T_ACI_CPI_IBT ibt,
T_ACI_CPI_TCH tch,
USHORT cause)
{
SHORT pos = 0;
UBYTE srcId = srcId_cb;
SHORT idx;
T_ACI_CLCC_CALDESC *calLst;
CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
USHORT lenCvtdAlpha;
UBYTE type;
TRACE_FUNCTION("rCI_PercentCPI()");
TRACE_EVENT_P1("msgType: %d", msgType);
#ifdef ACI
if (ibt NEQ CPI_IBT_NotPresent)
ibt_params.ati_currIbt = ibt;
if (tch NEQ CPI_TCH_NotPresent)
ibt_params.ati_currTch = tch;
#endif
if ( (ati_user_output_cfg[srcId].CPI_stat > 0) )
{
pos = sprintf(g_sa,"%s: ","%CPI");
if (cId NEQ ACI_NumParmNotPresent)
pos += sprintf(g_sa+pos,"%d,",cId);
else
pos += sprintf(g_sa+pos,",");
if (msgType NEQ CPI_MSG_NotPresent)
pos += sprintf(g_sa+pos,"%d,",msgType);
else
pos += sprintf(g_sa+pos,",");
if (ibt NEQ CPI_IBT_NotPresent)
pos += sprintf(g_sa+pos,"%d,",ibt);
else
pos += sprintf(g_sa+pos,",");
if (tch NEQ CPI_TCH_NotPresent)
pos += sprintf(g_sa+pos,"%d",tch);
else
pos += sprintf(g_sa+pos,",");
ACI_MALLOC (calLst, MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC));
if ((ati_user_output_cfg[srcId].CPI_stat > 1) AND
(qAT_PlusCLCC(srcId, calLst) EQ AT_CMPL))
{
for (idx = 0; idx < MAX_CALL_NR; idx++)
{
if( calLst[idx].idx EQ ACI_NumParmNotPresent )
{
if (ati_user_output_cfg[srcId].CPI_stat > 2)
{
pos += sprintf(g_sa + pos,",,,,,");
}
break;
}
else
{
if (calLst[idx].idx NEQ cId)
{
//continue;
}
else /* if (calLst[idx].idx NEQ cId) */
{
if (calLst[idx].dir NEQ CLCC_DIR_NotPresent)
pos += sprintf(g_sa+pos,",%d",calLst[idx].dir);
else
pos += sprintf(g_sa+pos,",");
if (calLst[idx].mode NEQ CLCC_MODE_NotPresent)
pos += sprintf(g_sa+pos,",%d",calLst[idx].mode);
else
pos += sprintf(g_sa+pos,",");
if (calLst[idx].number[0] NEQ 0x0)
{
pos += sprintf(g_sa+pos,",\"%s\"",calLst[idx].number);
if (calLst[idx].type.ton NEQ TON_NotPresent)
{
type = toa_merge(calLst[idx].type);
pos += sprintf(g_sa+pos,",%d",(int)type);
}
else
pos += sprintf(g_sa+pos,",");
#ifdef NO_ASCIIZ
if (calLst[idx].alpha.len NEQ 0x0)
{
pos += sprintf(g_sa+pos,",");
utl_chsetFromGsm ( calLst[idx].alpha.data,
calLst[idx].alpha.len,
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Def );
pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
}
#else /* #ifdef NO_ASCIIZ */
if (calLst[idx].alpha[0] NEQ 0x0)
{
pos += sprintf(g_sa+pos,",");
utl_chsetFromGsm ( (UBYTE*)calLst[idx].alpha,
0,
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Int );
pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
}
#endif /* #ifdef NO_ASCIIZ */
else if(ati_user_output_cfg[srcId].CPI_stat > 2)
{
pos += sprintf(g_sa + pos,",");
}
} /* if (calLst[idx].number[0] NEQ 0x0) */
else
{
pos += sprintf(g_sa + pos,",,,");
}
break;
} /* else of - if (calLst[idx].idx NEQ cId) */
} /* else of - if( calLst[idx].idx EQ ACI_NumParmNotPresent ) */
} /*for (idx = 0; idx < MAX_CALL_NR; idx++) */
if (ati_user_output_cfg[srcId].CPI_stat > 2)
{
if (ati_user_output_cfg[srcId].CPI_stat EQ 4)
{
pos += sprintf(g_sa + pos,",0x%4x", cause);
}
else
{
if(( GET_CAUSE_ORIGIN_ENTITY(cause) EQ CC_ORIGINATING_ENTITY AND
GET_CAUSE_DEFBY(cause) EQ DEFBY_STD )
OR (cause EQ MNCC_CAUSE_REEST_STARTED OR cause EQ MNCC_CAUSE_REEST_FINISHED))
{
TRACE_EVENT_P2("cause: %d pos: %d",cId, cause);
pos += sprintf ( g_sa + pos,",%d", GET_CAUSE_VALUE(cause) );
}
else
{
pos += sprintf(g_sa + pos,",");
}
}
/* Report the the ALS bearer */
if(calLst[idx].class_type EQ CLCC_CLASS_Line2)
{
pos += sprintf ( g_sa + pos,",1");
}
else
{
pos += sprintf ( g_sa + pos,",0");
}
}
}//if ( (ati_user_output_cfg[srcId].CPI_stat > 0) )
ACI_MFREE (calLst);
ci_remTrailCom(g_sa, pos);
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
#ifdef ACI /* for ATI only version */
cmhMMI_handleAudioTone ( AT_CMD_NONE, RAT_CPI, msgType );
#endif
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCTYI |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCTYI call back
*/
GLOBAL void rCI_PercentCTYI (T_ACI_CTTY_NEG neg,
T_ACI_CTTY_TRX trx)
{
int pos = 0;
TRACE_FUNCTION ("rCI_PercentCTYI()");
if (cmhPrm[srcId_cb].ccCmdPrm.CTTYmode EQ CTTY_MOD_Enable)
{
pos = sprintf (g_sa, "%s: %d", "%CTYI", (int)neg);
if (trx NEQ CTTY_TRX_Unknown)
pos += sprintf (g_sa + pos, ",%d", trx);
io_sendMessage (srcId_cb, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCTV |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCTV call back
*/
GLOBAL void rCI_PercentCTV ( /*UBYTE srcId*/ void )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentCTV()");
callTime++;
if( callTime EQ 10 )
{
callTime = 0;
allowCCCM = TRUE;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : sAT_URC |
+--------------------------------------------------------------------+
PURPOSE : this function handles unsolicited result codes generated
using the extension mechanism for unknown AT commands.
*/
GLOBAL T_ACI_RETURN sAT_URC ( CHAR * out )
{
T_ACI_RETURN retCode = AT_FAIL;
TRACE_FUNCTION("sAT_URC ()");
if (ati_get_mode( src_id_ext ) NEQ ATI_UNKN_MODE) /* Send only to "serial" sources, no SAT etc. */
{
aci_sendPString( src_id_ext, out );
}
return AT_CMPL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : sAT_FRI |
+--------------------------------------------------------------------+
PURPOSE : this function handles final result codes generated
using the extension mechanism for unknown AT commands.
*/
GLOBAL T_ACI_RETURN sAT_FRI ( USHORT cmdLen )
{
T_ACI_RETURN rslt = AT_FAIL;
UBYTE srcId = srcId_cb;
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
if ( src_params->curAtCmd EQ AT_CMD_EXT )
{
rslt = AT_CMPL;
}
return ( rslt );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCCBS |
+--------------------------------------------------------------------+
PURPOSE : handles rCI_PercentCCBS call back
*/
GLOBAL void rCI_PercentCCBS ( /*UBYTE srcId,*/ T_ACI_CCBS_IND ind,
T_ACI_CCBS_STAT status,
T_ACI_CCBS_SET *setting,
BOOL intermediate_result )
{
SHORT pos = 0;
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentCCBS()");
if ( at.flags.CCBS_stat OR
ind EQ CCBS_IND_IrgtResult )
{
pos=sprintf(g_sa,"%s: ","%CCBS");
/* 1st param */
switch(ind)
{
case(CCBS_IND_NotPresent):
pos+=sprintf(g_sa+pos,",");
break;
case(CCBS_IND_IrgtResult):
if(status NEQ CCBS_STAT_NotPresent)
{
pos+=sprintf(g_sa+pos,"%d,",ind);
}
break;
default:
pos+=sprintf(g_sa+pos,"%d,",ind);
break;
}
if(setting EQ NULL)
{
/* do nothing: if later a parameter is added, extra commas may be needed...*/
}
else
{
/* 2nd param: CCBS index */
if(setting->idx NEQ ACI_NumParmNotPresent)
pos+=sprintf(g_sa+pos,"%d,",setting->idx);
else
pos+=sprintf(g_sa+pos,",");
/* 3rd param: Number */
if (setting->number[0] NEQ 0x0 )
pos+=sprintf(g_sa+pos,"\"%s\",",setting->number);
else
pos+=sprintf(g_sa+pos,",");
/* 4th param: Type of number */
if (setting->type.npi NEQ NPI_NotPresent )
pos+=sprintf(g_sa+pos,"%d,",toa_merge(setting->type));
else
pos+=sprintf(g_sa+pos,",");
/* 5th param: sub address */
if (setting->subaddr[0] NEQ 0x0 )
pos+=sprintf(g_sa+pos,"\"%s\",",setting->subaddr);
else
pos+=sprintf(g_sa+pos,",");
/* 6th param: type of subaddress */
if (setting->satype.tos NEQ TOS_NotPresent )
pos+=sprintf(g_sa+pos,"%d,",tos_merge(setting->satype));
else
pos+=sprintf(g_sa+pos,",");
/* 7th param: CCBS class */
if (setting->class_type NEQ CLASS_NotPresent)
pos+=sprintf(g_sa+pos,"%d,",setting->class_type);
else
pos+=sprintf(g_sa+pos,",");
/* 8th param: ALPT */
if (setting->alrtPtn NEQ ALPT_NotPresent)
pos+=sprintf(g_sa+pos,"%d",setting->alrtPtn);
}
ci_remTrailCom(g_sa, pos);
if(intermediate_result)
{
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
else
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_sms_ready |
+--------------------------------------------------------------------+
PURPOSE : handles AT_sms_ready call back
*/
GLOBAL void rCI_sms_ready ( /*UBYTE srcId*/ void )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_sms_ready()");
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_phb_status |
+--------------------------------------------------------------------+
PURPOSE : handles AT_phb_status call back
*/
GLOBAL void rCI_phb_status ( /*UBYTE srcId,*/ T_ACI_PB_STAT status )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_phb_status()");
}
GLOBAL void rCI_PlusCMGD ()
{
/* dummy function */
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : aci_writeCnumMsisdn|
+--------------------------------------------------------------------+
PURPOSE : This function writes the formatted string to AT command
interface.
*/
LOCAL UBYTE aci_writeCnumMsisdn ( UBYTE srcId, T_ACI_CNUM_MSISDN* msisdn )
{
USHORT pos = 0;
#ifndef FF_ATI_BAT
CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
USHORT lenCvtdAlpha;
#endif
TRACE_FUNCTION ("aci_writeCnumMsisdn()");
if ( msisdn -> vldFlag EQ FALSE )
{
return 0;
}
pos = sprintf ( g_sa, "+CNUM: " );
/*
*-----------------------------------------------------------------
* process parameter <alpha>
*-----------------------------------------------------------------
*/
if ( msisdn -> alpha[0] NEQ '\0' )
{
#ifdef FF_ATI_BAT
pos += sprints ( g_sa + pos, (char *)msisdn->alpha, (USHORT)strlen(msisdn->alpha) );
#else
utl_chsetFromGsm((UBYTE*)msisdn->alpha,
strlen(msisdn->alpha),
(UBYTE*)cvtdAlpha,
sizeof(cvtdAlpha),
&lenCvtdAlpha,
GSM_ALPHA_Int);
pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
#endif
}
/*
*-----------------------------------------------------------------
* process parameter <number> and <type>
*-----------------------------------------------------------------
*/
pos += sprintf ( g_sa + pos, ",\"%s\",%d",
msisdn -> number,
toa_merge ( msisdn -> type ) );
/*
*-----------------------------------------------------------------
* process parameter <speed>
*-----------------------------------------------------------------
*/
if ( msisdn -> speed NEQ BS_SPEED_NotPresent )
{
pos += sprintf ( g_sa + pos, ",%d", msisdn -> speed );
}
else
{
pos += sprintf ( g_sa + pos, "," );
}
/*
*-----------------------------------------------------------------
* process parameter <service>
*-----------------------------------------------------------------
*/
if ( msisdn -> service NEQ CNUM_SERV_NotPresent )
{
pos += sprintf ( g_sa + pos, ",%d", msisdn -> service );
}
else
{
pos += sprintf ( g_sa + pos, "," );
}
/*
*-----------------------------------------------------------------
* process parameter <itc>
*-----------------------------------------------------------------
*/
if ( msisdn -> itc NEQ CNUM_ITC_NotPresent )
{
pos += sprintf ( g_sa + pos, ",%d", msisdn -> itc );
}
ci_remTrailCom ( g_sa, ( USHORT ) strlen ( g_sa ) );
io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
return 1;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCNAP |
+--------------------------------------------------------------------+
PURPOSE : handles rCI_PercentCNAP call back
*/
typedef enum
{
CNAP_PRES_ALLOWED = 0,
CNAP_PRES_RESTRICTED,
CNAP_NAME_UNAVAILABLE,
CNAP_NAME_PRES_RESTRICTED
} T_ATI_CNAP_PRESENTATION;
LOCAL void send_cnap_name_information(UBYTE srcId,
T_ATI_CNAP_PRESENTATION pres_mode,
T_callingName *NameId)
{
T_namePresentationAllowed *cnap_name_info = NULL;
UBYTE number_of_chars = 0;
CHAR *cnap_name = NULL;
int pos = 0;
TRACE_FUNCTION("send_cnap_name_information()");
switch(pres_mode)
{
case(CNAP_PRES_ALLOWED):
TRACE_EVENT("CNAP: name presentation is allowed");
cnap_name_info = &(NameId->namePresentationAllowed);
break;
case(CNAP_NAME_PRES_RESTRICTED):
TRACE_EVENT("CNAP: name presentation is restricted");
cnap_name_info = &(NameId->namePresentationRestricted);
break;
default:
TRACE_ERROR("CNAP: wrong presentation mode");
return;
}
if(cnap_name_info EQ NULL)
{
TRACE_ERROR("CNAP cnap_name_info is NULL");
return;
}
pos += sprintf(g_sa+pos,"%s%d,", "%CNAP: ", pres_mode);
if(cnap_name_info->v_dataCodingScheme)
{
pos += sprintf(g_sa+pos,"%d,", cnap_name_info->dataCodingScheme);
}
if(cnap_name_info->v_lengthInCharacters)
{
number_of_chars = cnap_name_info->lengthInCharacters;
pos += sprintf(g_sa+pos,"%d,", number_of_chars);
number_of_chars = MINIMUM(number_of_chars, sizeof(g_sa)-(size_t)pos);
}
if(cnap_name_info->v_nameString AND
number_of_chars NEQ 0)
{
ACI_MALLOC(cnap_name, number_of_chars+3); /* 1 char for \0 and 2 chars for " */
memcpy(cnap_name, &(cnap_name_info->nameString.b_nameString), number_of_chars);
cnap_name[number_of_chars] = 0; /* Null terminated */
pos += sprintf(g_sa+pos,"\"%s\"", cnap_name);
}
ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
io_sendIndication( srcId, g_sa, ATI_NORMAL_OUTPUT );
if(cnap_name NEQ NULL)
{
ACI_MFREE(cnap_name);
}
}
LOCAL void unsolicited_rci_percent_cnap(UBYTE srcId, T_callingName *NameId)
{
TRACE_FUNCTION("unsolicited_rci_percent_cnap()");
if(ati_user_output_cfg[srcId].cnap_mode EQ CNAP_DISABLED)
{
TRACE_EVENT_P1("unsolicited message CNAP ignored: CNAP not enable for source: %d", srcId);
return;
}
if(NameId->v_namePresentationAllowed)
{
send_cnap_name_information(srcId, CNAP_PRES_ALLOWED, NameId);
return;
}
if(NameId->v_presentationRestricted)
{
sprintf(g_sa, "%s%d", "%CNAP: ", CNAP_PRES_RESTRICTED);
io_sendIndication( srcId, g_sa, ATI_NORMAL_OUTPUT );
return;
}
if(NameId->v_nameUnavailable)
{
sprintf(g_sa, "%s%d", "%CNAP: ", CNAP_NAME_UNAVAILABLE);
io_sendIndication( srcId, g_sa, ATI_NORMAL_OUTPUT );
return;
}
if(NameId->v_namePresentationRestricted)
{
send_cnap_name_information(srcId, CNAP_NAME_PRES_RESTRICTED, NameId);
return;
}
}
LOCAL void intermediate_result_rci_percent_cnap(UBYTE srcId, T_ACI_CNAP_STATUS status)
{
TRACE_FUNCTION("intermediate_result_rci_percent_cnap()");
sprintf(g_sa, "%s%d,%d", "%CNAP: ", ati_user_output_cfg[srcId].cnap_mode, status);
io_sendMessage( srcId, g_sa, ATI_NORMAL_OUTPUT );
}
GLOBAL void rCI_PercentCNAP ( T_callingName *NameId, T_ACI_CNAP_STATUS status )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentCNAP()");
if(NameId NEQ NULL)
{
unsolicited_rci_percent_cnap(srcId, NameId);
return;
}
if(status NEQ CNAP_SERVICE_STATUS_NOT_PRESENT)
{
intermediate_result_rci_percent_cnap(srcId, status);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCMS_Conc |
+--------------------------------------------------------------------+
PURPOSE : handles new rCI_PlusCMS call back for concatenated SMS
*/
GLOBAL void rCI_PlusCMS_Conc ( T_ACI_AT_CMD cmdId,
T_ACI_CMS_ERR err,
T_EXT_CMS_ERROR *conc_error )
{
TRACE_FUNCTION("rCI_PlusCMS_Conc()");
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_SignalSMS |
+--------------------------------------------------------------------+
PURPOSE : handles rCI_SignalSMS call back for concatenated SMS
*/
GLOBAL void rCI_SignalSMS ( UBYTE state )
{
TRACE_FUNCTION("rCI_SignalSMS()");
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCIEV |
+--------------------------------------------------------------------+
PURPOSE : handles rCI_SignalCIEV call back for signal strength
and SIM-full indications
*/
GLOBAL void rCI_PlusCIEV ( T_ACI_MM_CIND_VAL_TYPE sCindValues,
T_ACI_MM_CMER_VAL_TYPE sCmerSettings )
{
CHAR* me = "+CIEV: ";
SHORT pos = 0;
UBYTE srcId = srcId_cb;
T_ATI_IO_MODE sIoMode;
char *acTempString = "";
UINT uiCount;
TRACE_FUNCTION("rCI_PlusCIEV()");
pos = sprintf(g_sa,"%s",me);
/* check settings in 'cmhCmdPrm' and depends on, send the indication or buffer it */
sIoMode = ati_get_mode(srcId_cb);
if( sIoMode == ATI_UNKN_MODE )
{
acTempString = "internal ACI error at rCI_PlusCIEV() ->> ATI unknown mode !!";
sprintf( g_sa+pos, "%s, 0", acTempString );
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
return;
}
if( (sIoMode == ATI_CMD_MODE) &&
(sCmerSettings.sCmerModeParam != CMER_MODE_INVALID) && /* 'invalid' == 'mode_0' */
(sCmerSettings.sCmerModeParam != CMER_MODE_0) )
/* ---------------------------------------------------------------------------------- */
{ /* ----------- UART is in command mode --> send the +CIEV to terminal --------------- */
/* ---------------------------------------------------------------------------------- */
if( sCindValues.sCindSignalParam != CIND_SIGNAL_INDICATOR_INVALID )
{
acTempString = "1"; /* the 'signal' indicator has the order number '1' in +CIND */
sprintf( g_sa+pos, "%s, %d", acTempString, sCindValues.sCindSignalParam );
}
else
{
if( sCindValues.sCindSmsFullParam != CIND_SMSFULL_INDICATOR_INVALID )
{
acTempString = "2"; /* the 'smsfull' indicator has the order number '2' in +CIND */
sprintf( g_sa+pos, "%s, %d", acTempString, sCindValues.sCindSmsFullParam );
}
else
{ /* error!! --> no signal has to be send */
acTempString = "internal ACI error at rCI_PlusCIEV() !!";
sprintf( g_sa+pos, "%s, 0", acTempString);
}
}
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/* -------------------------------------------------------------------------------- */
else /* -- UART is in data mode or CMER-mode == '0' --> buffer the +CIEV if necessary -- */
{ /* -------------------------------------------------------------------------------- */
if( sCmerSettings.sCmerModeParam != CMER_MODE_1 )
{ /* discard message in case of MODE=='1' */
if( sCindValues.sCindSignalParam != CIND_SIGNAL_INDICATOR_INVALID )
{ /* storing of SIGNAL Value */
if( asCievSignalBuf.uiLastIndex < CIEV_BUF_SIZE )
{ /* free space in buffer -> store +CIEV indication for further purpose */
asCievSignalBuf.asBufferValues[asCievSignalBuf.uiLastIndex] = sCindValues.sCindSignalParam;
asCievSignalBuf.uiLastIndex++;
}
else /* = buffer is full (uiLastIndex == CIEV_BUF_SIZE) = */
{ /* -> drop the oldest one and try to store it again */
uiCount = 0;
while( uiCount < (CIEV_BUF_SIZE-1) )
{ /* drop the oldes one */
asCievSignalBuf.asBufferValues[uiCount] = asCievSignalBuf.asBufferValues[uiCount+1];
uiCount++;
}
asCievSignalBuf.asBufferValues[asCievSignalBuf.uiLastIndex-1] = sCindValues.sCindSignalParam;
}
}
else
{ /* storing of SMS full Value */
if( asCievSmsFullBuf.uiLastIndex < CIEV_BUF_SIZE )
{ /* free space in buffer -> store +CIEV indication for further purpose */
asCievSmsFullBuf.asBufferValues[asCievSmsFullBuf.uiLastIndex] = sCindValues.sCindSmsFullParam;
asCievSmsFullBuf.uiLastIndex++;
}
else /* = buffer is full (uiLastIndex == CIEV_BUF_SIZE) = */
{ /* -> drop the oldest one and try to store it again */
uiCount = 0;
while( uiCount < (CIEV_BUF_SIZE-1) )
{ /* drop the oldes one */
asCievSmsFullBuf.asBufferValues[uiCount] = asCievSmsFullBuf.asBufferValues[uiCount+1];
uiCount++;
}
asCievSmsFullBuf.asBufferValues[asCievSmsFullBuf.uiLastIndex-1] = sCindValues.sCindSmsFullParam;
}
}
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ACI_RET |
| STATE : code ROUTINE : aci_frmtOutput |
+--------------------------------------------------------------------+
PURPOSE : fills T_ACI_SM_DATA data structure for UD with UDHI
*/
LOCAL void aci_frmtOutput ( UBYTE fo,
UBYTE dcs,
T_ACI_SM_DATA *data )
{
switch (fo & TP_MTI_MASK)
{
case TP_MTI_SMS_DELIVER:
{
T_TP_DELIVER *sms_deliver = (T_TP_DELIVER*)_decodedMsg;
data->data[0] = sms_deliver->tp_udh_inc.tp_udh.c_data;
memcpy(data->data+1,
sms_deliver->tp_udh_inc.tp_udh.data,
sms_deliver->tp_udh_inc.tp_udh.c_data);
memcpy(data->data+sms_deliver->tp_udh_inc.tp_udh.c_data+1,
sms_deliver->tp_udh_inc.data,
sms_deliver->tp_udh_inc.c_data);
/*
data->len = sms_deliver->tp_udh_inc.tp_udh.c_data +
sms_deliver->tp_udh_inc.c_data + 1;
*/
if (cmhSMS_getAlphabetPp (dcs) EQ 0)
data->len = (sms_deliver->tp_udh_inc.length * 7 + 7)/8;
else
data->len = sms_deliver->tp_udh_inc.length;
}
break;
case TP_MTI_SMS_SUBMIT:
{
T_TP_SUBMIT *sms_submit = (T_TP_SUBMIT*)_decodedMsg;
data->data[0] = sms_submit->tp_udh_inc.tp_udh.c_data;
memcpy(data->data+1,
sms_submit->tp_udh_inc.tp_udh.data,
sms_submit->tp_udh_inc.tp_udh.c_data);
memcpy(data->data+sms_submit->tp_udh_inc.tp_udh.c_data+1,
sms_submit->tp_udh_inc.data,
sms_submit->tp_udh_inc.c_data);
/*
data->len = sms_submit->tp_udh_inc.tp_udh.c_data +
sms_submit->tp_udh_inc.c_data + 1;
*/
if (cmhSMS_getAlphabetPp (dcs) EQ 0)
data->len = (sms_submit->tp_udh_inc.length * 7 + 7)/8;
else
data->len = sms_submit->tp_udh_inc.length;
}
break;
case TP_MTI_SMS_COMMAND:
{
T_TP_COMMAND *sms_command = (T_TP_COMMAND*)_decodedMsg;
data->data[0] = sms_command->tp_cdh_inc.tp_udh.c_data;
memcpy(data->data+1,
sms_command->tp_cdh_inc.tp_udh.data,
sms_command->tp_cdh_inc.tp_udh.c_data);
memcpy(data->data+sms_command->tp_cdh_inc.tp_udh.c_data+1,
sms_command->tp_cdh_inc.data,
sms_command->tp_cdh_inc.c_data);
/*
data->len = sms_command->tp_cdh_inc.tp_udh.c_data +
sms_command->tp_cdh_inc.c_data + 1;
*/
data->len = sms_command->tp_cdh_inc.c_data;
}
break;
/*
case TP_MTI_SMS_STATUS_REP:
{
T_TP_STATUS *sms_status = (T_TP_STATUS*)_decodedMsg;
data->data[0] = sms_status->tp_udh_inc.tp_udh.c_data;
memcpy(data->data+1,
sms_status->tp_udh_inc.tp_udh.data,
sms_status->tp_udh_inc.tp_udh.c_data);
memcpy(data->data+sms_status->tp_udh_inc.tp_udh.c_data+1,
sms_status->tp_udh_inc.data,
sms_status->tp_udh_inc.c_data);
data->len = sms_status->tp_udh_inc.tp_udh.c_data +
sms_status->tp_udh_inc.c_data + 1;
}
break;
*/
default:
data->data[0] = '\0';
data->len = 0;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCPRI |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCPRI call back
*/
GLOBAL void rCI_PercentCPRI ( UBYTE gsm_ciph, UBYTE gprs_ciph )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PLusCPRI()");
/* %CPRI notification is sent only to the source through which the status is enabled */
if (ati_user_output_cfg[srcId].CPRI_stat EQ CI_SHOW)
{
sprintf(g_sa, "%s: %d,%d", "%CPRI", gsm_ciph, gprs_ciph);
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCTZR |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCTZV call back.
timezone is a range from -48..0..+48 and expresses the deviation
from GMT in steps of 15 minutes.
*/
#ifdef FF_TIMEZONE
GLOBAL void rCI_PlusCTZV ( S32 timezone )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCTZV()");
sprintf (g_sa, "%s\"%+02d\"", "+CTZV: ", timezone);
/* Send response to AT interface */
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
#else
GLOBAL void rCI_PlusCTZV ( UBYTE* timezone )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PlusCTZV()");
sprintf (g_sa, "%s%d", "+CTZV: ", *timezone);
/* Send response to AT interface */
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
#endif
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCTZV |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCTZV call back, the parameter mmr_info_ind
includes time and time zone information.
*/
GLOBAL void rCI_PercentCTZV (T_MMR_INFO_IND *mmr_info_ind, S32 timezone)
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentCTZV()");
/*Report the network time in time zone 0*/
sprintf (g_sa, "%s\"%02d/%02d/%02d,%02d:%02d:%02d%+02d\"", "%CTZV: ",
mmr_info_ind->time.year,
mmr_info_ind->time.month,
mmr_info_ind->time.day,
mmr_info_ind->time.hour,
mmr_info_ind->time.minute,
mmr_info_ind->time.second,
timezone);
/* Send response to AT interface */
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCNIV |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCNIV call back
*/
GLOBAL void rCI_PercentCNIV (T_MMR_INFO_IND *mmr_info_ind)
{
UBYTE srcId = srcId_cb;
char buf1[33]; /* be prepared for 16 UCS2 full names */
char buf2[33]; /* be prepared for 16 UCS2 full names */
char plmn[7] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00};
SHORT mcc = 0;
SHORT mnc = 0;
TRACE_FUNCTION("rCI_PercentCNIV()");
memset(buf1, 0, 33);
memset(buf2, 0, 33);
if (mmr_info_ind->plmn.v_plmn)
{
cmhMM_CnvrtPLMN2INT( mmr_info_ind->plmn.mcc,
mmr_info_ind->plmn.mnc,
&mcc, &mnc );
}
/* build numeric plmn representation */
if ((mnc & 0x000F) EQ 0x000F)
{
sprintf (plmn, "\"%03X%02X\"", mcc, (mnc & 0x0FF0) >> 4);
}
else
{
sprintf (plmn, "\"%03X%03X\"", mcc, mnc);
}
if (mmr_info_ind->short_name.v_name AND /* short name only */
!mmr_info_ind->full_name.v_name)
{
strncpy (buf2, (char *)mmr_info_ind->short_name.text, mmr_info_ind->short_name.c_text);
sprintf (g_sa, "%s\"\",\"%s\",%s", "%CNIV: ", buf2, plmn);
}
else
if (!mmr_info_ind->short_name.v_name AND
mmr_info_ind->full_name.v_name) /* full name only */
{
strncpy (buf1, (char *)mmr_info_ind->full_name.text, mmr_info_ind->full_name.c_text);
sprintf (g_sa, "%s\"%s\",\"\",%s", "%CNIV: ", buf1, plmn);
}
else
if (mmr_info_ind->short_name.v_name AND /* both given */
mmr_info_ind->full_name.v_name)
{
strncpy (buf1, (char *)mmr_info_ind->full_name.text, mmr_info_ind->full_name.c_text);
strncpy (buf2, (char *)mmr_info_ind->short_name.text, mmr_info_ind->short_name.c_text);
sprintf (g_sa, "%s\"%s\",\"%s\",%s", "%CNIV: ", buf1, buf2, plmn);
}
else
{
TRACE_EVENT("rCI_PercentCNIV(): no network name given");
sprintf (g_sa, "%s\"\",\"\",%s", "%CNIV: ", plmn);
}
/* Send response to AT interface */
io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_Z |
+--------------------------------------------------------------------+
PURPOSE : RAT callback for ATZ, for abstraction of ATI and CMH.
*/
GLOBAL void rCI_Z ( void )
{
UBYTE srcId = srcId_cb;
ati_cmd_reset( srcId );
ati_zn_retrieve_params( srcId );
}
#endif /* FF_ATI */
#if defined FF_EOTD
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PlusCLPS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusCLPS call back
*/
GLOBAL void rCI_PlusCLPS ( UBYTE srcId, T_LOC_POS_DATA * p_aci_lc_data )
{
TRACE_FUNCTION("rCI_PlusCLPS()");
io_sendIndication(srcId, "%CLPS:", ATI_NORMAL_OUTPUT);
}
#endif /* FF_EOTD */
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentALS |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PlusALS call back
*/
GLOBAL void rCI_PercentALS ( T_ACI_ALS_MOD ALSmode )
{
UBYTE srcId = srcId_cb;
char *me = "%ALS";
TRACE_FUNCTION("rCI_PlusALS()");
if (ALSmode EQ ALS_MOD_SPEECH)
sprintf(g_sa,"%s: (0)", me);
if (ALSmode EQ ALS_MOD_AUX_SPEECH)
sprintf(g_sa,"%s: (1)", me);
if (ALSmode EQ (ALS_MOD_SPEECH | ALS_MOD_AUX_SPEECH))
sprintf(g_sa,"%s: (0,1)", me);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentRDL |
+--------------------------------------------------------------------+
PURPOSE : handles AT%RDL call back
*/
GLOBAL void rCI_PercentRDL ( T_ACI_CC_REDIAL_STATE state )
{
UBYTE srcId = srcId_cb;
char *me = "%RDL:";
TRACE_FUNCTION("rCI_PercentRDL()");
if(rdlPrm.rdlModN EQ NOTIF_USER)
{
sprintf(g_sa,"%s %d",me,state);
io_sendMessage(srcId, g_sa, ATI_INDICATION_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentRDLB |
+--------------------------------------------------------------------+
PURPOSE : handles AT%RDLB call back
*/
GLOBAL void rCI_PercentRDLB ( T_ACI_CC_RDL_BLACKL_STATE state )
{
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentRDLB()");
if(rdlPrm.rdlBlN EQ NOTIF_USER)
{
sprintf(g_sa,"%s: %d","%RDLB",state);
io_sendMessage(srcId, g_sa, ATI_INDICATION_OUTPUT);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCSTAT |
+--------------------------------------------------------------------+
PURPOSE : handles rCI_PercentCSTAT call back
*/
GLOBAL void rCI_PercentCSTAT ( T_ACI_STATE_MSG msgType )
{
SHORT pos = 0;
UBYTE srcId = srcId_cb;
TRACE_FUNCTION("rCI_PercentCSTAT()");
if (ati_user_output_cfg[srcId].CSTAT_stat == 1)
{
pos = sprintf(g_sa,"%s: ","%CSTAT");
switch(msgType.entityId)
{
case STATE_MSG_PBOOK:
pos += sprintf(g_sa+pos,"PHB, %d",msgType.entityState);
break;
case STATE_MSG_SMS:
pos += sprintf(g_sa+pos,"SMS, %d",msgType.entityState);
break;
case STATE_MSG_EONS:
pos += sprintf(g_sa+pos,"EONS, %d",msgType.entityState);
break;
case STATE_MSG_RDY:
pos += sprintf(g_sa+pos,"RDY, %d",msgType.entityState);
break;
default:
return;
}
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
}
/*
+------------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : ati_printRemainFieElem |
+------------------------------------------------------------------------+
PURPOSE : this function prints all remained FIE-elemnts onto terminal
*/
LOCAL void ati_printRemainFieElem( T_fac_inf *fie,
UBYTE srcId )
{
UBYTE uTotalCharCounter = 0;
USHORT uLineCounter = 0;
UBYTE const cuNbrOfMsgElem = fie->l_fac >> 3;
TRACE_FUNCTION("ati_printRemainFieElem()");
/* print FIE elements */
while(uTotalCharCounter < cuNbrOfMsgElem)
{
uLineCounter += sprintf(g_sa+uLineCounter, "%02X", fie->fac[uTotalCharCounter++]);
if ( uLineCounter > (MAX_CMD_LEN-((MAX_CMD_LEN*95)/100)) ) /* only 5% of g_sa buffer used */
{ /* allows better sim test */
g_sa[++uLineCounter] = 0x00; /* terminate g_sa after last char */
#ifdef _SIMULATION_
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); /* and send the data in chunks with CRLF */
#else /* _SIMULATION_ */
io_sendMessage(srcId, g_sa, ATI_ECHO_OUTPUT);
#endif
uLineCounter=0; /* go to beginning of g_sa for next chunk */
}
}
g_sa[++uLineCounter] = 0x00; /* terminate g_sa after last char in last chunk */
#ifdef _SIMULATION_
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); /* and send the data in chunks with CRLF */
#else /* _SIMULATION_ */
io_sendMessage(srcId, g_sa, ATI_ECHO_OUTPUT);
g_sa[0] = 0x0; /* print CR/LF after last chunk only on target */
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
#endif
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCCCN |
+--------------------------------------------------------------------+
PURPOSE : handles unsolicited CC-network changes callback
*/
GLOBAL void rCI_PercentCCCN ( T_ACI_FAC_DIR tDirection,
SHORT cId,
T_fac_inf *fie )
{
UBYTE srcId = srcId_cb;
char *me = "%CCCN";
TRACE_FUNCTION("rCI_PercentCCCN()");
/* no output in case of empty FIE-string */
if( (fie->l_fac >> 3) EQ 0)
{
TRACE_FUNCTION("rCI_PercentCCCN() : Empty FIE-string");
return;
}
sprintf(g_sa, "%s: %d,%d,", me, tDirection, cId); /* Preamble */
#ifdef _SIMULATION_ /* 'ATI_ECHO_OUTPUT' doesn't work while Windows simulation */
io_sendMessage( srcId, g_sa, ATI_NORMAL_OUTPUT ); /* print preamble while SIM-test */
#else /* _SIMULATION_ */
io_sendMessage( srcId, g_sa, ATI_ECHO_OUTPUT ); /* print preamble to target */
#endif
ati_printRemainFieElem( fie, srcId );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCSSN |
+--------------------------------------------------------------------+
PURPOSE : handles unsolicited CC-network changes callback
*/
GLOBAL void rCI_PercentCSSN ( T_ACI_FAC_DIR tDirection,
T_ACI_FAC_TRANS_TYPE tType,
T_fac_inf *fie )
{
UBYTE srcId = srcId_cb;
char *me = "%CSSN";
TRACE_FUNCTION("rCI_PercentCSSN()");
/* no output in case of empty FIE-string */
if( (fie->l_fac >> 3) EQ 0)
{
TRACE_FUNCTION("rCI_PercentCSSN() : Empty FIE-string");
return;
}
sprintf(g_sa, "%s: %d,%d,", me, tDirection, tType); /* Preamble */
#ifdef _SIMULATION_ /* 'ATI_ECHO_OUTPUT' doesn't work while Windows simulation */
io_sendMessage( srcId, g_sa, ATI_NORMAL_OUTPUT); /* print preamble while SIM-test */
#else /* _SIMULATION_ */
io_sendMessage( srcId, g_sa, ATI_ECHO_OUTPUT ); /* print preamble to target */
#endif
ati_printRemainFieElem( fie, srcId );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCPRSM |
+--------------------------------------------------------------------+
PURPOSE : handles callback for %CPRSM? querying the SMS delivery status
which can be either PAUSE or RESUME
*/
GLOBAL void rCI_PercentCPRSM ( T_ACI_CPRSM_MOD mode )
{
UBYTE srcId = srcId_cb;
char *me = "%CPRSM";
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
TRACE_FUNCTION("rCI_PercentCPRSM()");
sprintf(g_sa,"%s: %d", me, mode);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentSIMEF |
+--------------------------------------------------------------------+
PURPOSE :
*/
GLOBAL void rCI_PercentSIMEF(
SHORT *ef,
UBYTE count)
{
UBYTE srcId=srcId_cb;
SHORT pos;
UBYTE n;
TRACE_FUNCTION("rCI_PercentSIMEF()");
pos=sprintf(g_sa,"%s: ","%SIMEF");
for (n=0;n<count;n++)
{
pos+=sprintf(g_sa+pos,"%04X",ef[n]);
if (n NEQ count-1)
*(g_sa+pos++)=',';
}
io_sendMessage(srcId,g_sa,ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ACI_RET |
| STATE : code ROUTINE : mfwExtOut |
+--------------------------------------------------------------------+
PURPOSE : This function is used as a dummy to fullfill display
driver calls.
*/
#ifndef MFW
int mfwExtOut (char *cmd)
{
TRACE_FUNCTION ("mfwExtOut");
return 1;
}
#endif /* no MFW */
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCMGR |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCMGR call back (Read Message)
*/
GLOBAL void rCI_PercentCMGR ( T_MNSMS_READ_CNF* mnsms_read_cnf,
T_ACI_CMGR_CBM * cbm)
{
UBYTE msg_type;
#if defined (SMS_PDU_SUPPORT)
UBYTE srcId = srcId_cb;
T_ACI_CMGF_MOD mode;
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
/*
* handle PDU mode
*/
rCI_Plus_Percent_CMGRPdu (mnsms_read_cnf, AT_CMD_P_CMGR);
else
#endif
/*
* handle Text mode
*/
{
/* querying the type of the SM */
cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);
if (msg_type EQ TP_MTI_SMS_STATUS_REP)
rCI_Plus_Percent_CMGRTextSP (mnsms_read_cnf, AT_CMD_P_CMGR);
else
rCI_Plus_Percent_CMGRText (mnsms_read_cnf, cbm, AT_CMD_P_CMGR);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
| STATE : code ROUTINE : rCI_PercentCMGL |
+--------------------------------------------------------------------+
PURPOSE : handles AT_PercentCMGL call back
*/
GLOBAL void rCI_PercentCMGL (T_MNSMS_READ_CNF *mnsms_read_cnf)
{
UBYTE msg_type;
#if defined (SMS_PDU_SUPPORT)
UBYTE srcId = srcId_cb;
T_ACI_CMGF_MOD mode;
/*
* request current mode
*/
qAT_PlusCMGF(srcId, &mode);
if (mode EQ 0)
/*
* handle PDU mode
*/
rCI_Plus_Percent_CMGLPdu (mnsms_read_cnf, AT_CMD_P_CMGL);
else
#endif
/*
* handle Text mode
*/
{
/* querying the type of the SM */
cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);
if (msg_type EQ TP_MTI_SMS_STATUS_REP)
rCI_Plus_Percent_CMGLTextSP (mnsms_read_cnf, AT_CMD_P_CMGL);
else
rCI_Plus_Percent_CMGLText (mnsms_read_cnf, AT_CMD_P_CMGL);
}
}
LOCAL void rCI_Plus_Percent_CMGLTextSP (T_MNSMS_READ_CNF* mnsms_read_cnf,
T_ACI_AT_CMD cmdId)
{
UBYTE srcId = srcId_cb;
T_ACI_CDS_SM* p_st;
SHORT pos = 0;
CHAR* buf;
T_MNSMS_STATUS_IND mnsms_status_ind;
TRACE_FUNCTION("rCI_Plus_Percent_CMGLTextSP()");
/* is the SM already decoded ? */
if (smsShrdPrm.pDecMsg)
p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
else
{
ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CDS_SM) );
p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
memcpy (&mnsms_status_ind.sms_sdu, &mnsms_read_cnf->sms_sdu,
sizeof (T_sms_sdu));
cmhSMS_cpyStatInd ( p_st, &mnsms_status_ind);
}
buf=sms_status(mnsms_read_cnf->status );
if (cmdId EQ AT_CMD_CMGL )
{
pos = sprintf ( g_sa, "+CMGL: %d", mnsms_read_cnf->rec_num);
}
else
{
pos=sprintf (g_sa, " %s: %d", "%CMGL", mnsms_read_cnf->rec_num);
}
if ( buf )
{
pos += sprintf ( g_sa + pos, ",\"%s\"", buf ); /* STATUS */
}
else
{
pos += sprintf ( g_sa + pos, "," );
}
pos+=sprintf(g_sa+pos,",%d,%d,",p_st->fo, p_st->msg_ref);
if(strlen(p_st->addr))
pos+=sprintf(g_sa+pos,"\"%s\"",p_st->addr);
else
pos+=sprintf(g_sa+pos,",");
if( (p_st->toa.ton NEQ TON_NotPresent) AND (p_st->toa.npi NEQ NPI_NotPresent) )
pos+=sprintf(g_sa+pos,",%d",toa_merge(p_st->toa));
else
pos+=sprintf(g_sa+pos,",");
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
p_st->vpabs_scts.year [0], p_st->vpabs_scts.year [1],
p_st->vpabs_scts.month [0], p_st->vpabs_scts.month [1],
p_st->vpabs_scts.day [0], p_st->vpabs_scts.day [1],
p_st->vpabs_scts.hour [0], p_st->vpabs_scts.hour [1],
p_st->vpabs_scts.minute[0], p_st->vpabs_scts.minute[1],
p_st->vpabs_scts.second[0], p_st->vpabs_scts.second[1],
p_st->vpabs_scts.timezone);
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\",%d",
p_st->vpabs_dt.year [0], p_st->vpabs_dt.year [1],
p_st->vpabs_dt.month [0], p_st->vpabs_dt.month [1],
p_st->vpabs_dt.day [0], p_st->vpabs_dt.day [1],
p_st->vpabs_dt.hour [0], p_st->vpabs_dt.hour [1],
p_st->vpabs_dt.minute[0], p_st->vpabs_dt.minute[1],
p_st->vpabs_dt.second[0], p_st->vpabs_dt.second[1],
p_st->vpabs_dt.timezone , p_st->tp_status);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
LOCAL void rCI_Plus_Percent_CMGRTextSP (T_MNSMS_READ_CNF* mnsms_read_cnf,
T_ACI_AT_CMD cmdId)
{
UBYTE srcId = srcId_cb;
T_ACI_CDS_SM* p_st;
SHORT pos = 0;
CHAR* buf;
T_MNSMS_STATUS_IND mnsms_status_ind;
TRACE_FUNCTION("rCI_Plus_Percent_CMGRTextSP()");
/* is the SM already decoded ? */
if (smsShrdPrm.pDecMsg)
p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
else
{
ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CDS_SM) );
p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
memcpy (&mnsms_status_ind.sms_sdu, &mnsms_read_cnf->sms_sdu,
sizeof (T_sms_sdu));
cmhSMS_cpyStatInd ( p_st, &mnsms_status_ind);
}
buf=sms_status(mnsms_read_cnf->status );
if (buf) /* STATUS */
{
if (cmdId EQ AT_CMD_CMGR)
{
pos=sprintf(g_sa,"+CMGR: \"%s\"",buf);
}
else
{
pos=sprintf (g_sa, " %s: \"%s\"", "%CMGR", buf);
}
}
else
{
if (cmdId EQ AT_CMD_CMGR)
{
pos=sprintf(g_sa,"+CMGR: ,");
}
else
{
pos=sprintf (g_sa, " %s", "%CMGR: ,");
}
}
pos+=sprintf(g_sa+pos,",%d,%d,",p_st->fo, p_st->msg_ref);
if(strlen(p_st->addr))
pos+=sprintf(g_sa+pos,"\"%s\"",p_st->addr);
else
pos+=sprintf(g_sa+pos,",");
if( (p_st->toa.ton NEQ TON_NotPresent) AND (p_st->toa.npi NEQ NPI_NotPresent) )
pos+=sprintf(g_sa+pos,",%d",toa_merge(p_st->toa));
else
pos+=sprintf(g_sa+pos,",");
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
p_st->vpabs_scts.year [0], p_st->vpabs_scts.year [1],
p_st->vpabs_scts.month [0], p_st->vpabs_scts.month [1],
p_st->vpabs_scts.day [0], p_st->vpabs_scts.day [1],
p_st->vpabs_scts.hour [0], p_st->vpabs_scts.hour [1],
p_st->vpabs_scts.minute[0], p_st->vpabs_scts.minute[1],
p_st->vpabs_scts.second[0], p_st->vpabs_scts.second[1],
p_st->vpabs_scts.timezone);
pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\",%d",
p_st->vpabs_dt.year [0], p_st->vpabs_dt.year [1],
p_st->vpabs_dt.month [0], p_st->vpabs_dt.month [1],
p_st->vpabs_dt.day [0], p_st->vpabs_dt.day [1],
p_st->vpabs_dt.hour [0], p_st->vpabs_dt.hour [1],
p_st->vpabs_dt.minute[0], p_st->vpabs_dt.minute[1],
p_st->vpabs_dt.second[0], p_st->vpabs_dt.second[1],
p_st->vpabs_dt.timezone , p_st->tp_status);
io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
#endif /* ATI_RET_C */
